1. 循环 if, while, for
break : 结束整个循环
continue ：跳出当前这次循环，但不结束整个循环
else ：结束整个循环后才执行，不能与break合用，但可以与continue合用。
2. bool 惰性求值，从左到右判断，只要出现一个false就返回。
3. 打开文件
# 常用方法
# 打开文件test.txt
file = open('test.txt', 'r')
# 读取文件
file.read()
# 关闭文件
file.close() # with 方法(系统自动会关闭文件)
with open('test.txt', 'r') as f:
file = f.read() '''
with 工作机制分析
打开文件时，调用对象 test 的 __enter__方法
关闭文件时，调用对象 test 的 __exit__方法
分析如下
'''
class test(object):
def __init__(self, args):
self.args = args
def __enter__(self):
print('I am come in now')
return self.args
def __exit__(self, type, value, traceback):
print('I am come out now')
with test('hello men') as f:
# 返回 __enter__ 方法 return 的值
print(f)
4. 断言
# 断言是一种开发时期检验代码的方式，只断言绝对不能出现的错误。
assert
# 格式：
# assert 表达式，"出错后抛出异常信息"
# 默认返回True
5. 异常处理
'''
1. 尽量一个try就用一个except
2. 慎用异常：
1) 找到python内置异常
2）理解python的内置异常分别对应什么情况
3）阅读你的代码，找到你的代码里可能会抛出异常的地方
4）仅对小部分代码进行异常处理
'''
try:
'''有可能抛出异常的代码'''
print('test')
except:
'''try里面的代码抛出异常就执行except代码块里的代码'''
print('error')
else:
'''tyr代码块里的代码如果没有抛出异常就执行else代码块里的代码'''
print('hello')
finally:
'''不管如何，finally里的代码总会被执行'''
print('hai')
'''
异常应用方法
1.(在已知异常的前提下)捕获正确的异常，不要直接 try except
2.异常的处理，要有日志。
'''
'''日志的使用'''
import logging
# 实例化一个logger对象
logger = logging.getLogger()
# 指定日志文件存储路径
hdlr = logging.FileHandler('/tmp/testlog.txt')
# 格式化日志输出格式
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
# 传入格式到日志对象logger
hdlr.setFormatter(formatter)
# 传入文件到日志对象logger
logger.addHandler(hdlr)
# 生成日志等级
logger.setLevel(logging.NOTSET)
# 生成debug日志等级
logger.debug('This is a debug message')
# 生成error日志等级
logger.error('This is a error message')
6. 函数
#函数要有返回值，return
#写函数文档，doc（'''函数说明文档'''），如：
def test(a = 666):
'''函数说明文档'''
return a
print(test.__doc__)
print(test())
'''
变量作用域，先看函数局部变量，如果没有再找全局变量。 函数参数（顺序排列）：必选参数， 默认参数， 可变参数， 关键字参数。
必选参数， a # 没有默认值
默认参数， b = 1 # 有默认值(在调用时可以重新赋值)，在某种情况下降低函数的难度。
可变参数， *args # args 接收的是一个tuple。
关键字参数， **kwargs # kwargs 接收的是一个dict。
如：
'''
def test(a, b = 1, *args, **kwargs):
return a, b, args, kwargs
print(test(1,2,3,[1,2,3],aa=1,bb=2,cc=3)) '''
判断传入参数的数据类型：
isinstance(传入的参数, 数据类型)，如：
判断传入参数是不是int类型，如果是就存进list，否则pass。
'''
def func(*a):
list = []
for b in a:
if isinstance(b, int):
list.append(b)
else:
pass
return b
print(func(1,2,'d','f',3,'panisme',666)) # lambda 表达式 ，如：
a = [1,2,3,4,5,6]
b = filter(lambda x :x!=5,a) # 下面是等价表达
# 分析过程：
b = []
for x in a:
if x != 5:
b.append(x)
5. 面向对象编程
'''
构造函数，初始化类方法内部变量，给整个类方法使用。
def __init__(self, args):
self.args = args
析构函数，销毁类方法内部变量，减少内存使用。
def __del__(self):
del self.args
'''
class ClassName(object):
"""docstring for ClassName"""
def __init__(self, arg):
super(ClassName, self).__init__() # 使用 super 方法继承某个类，优点是可直接使用该类的构造函数。
self.arg = arg
@staticmethod # 静态方法的装饰（好处如下）。
def function():
pass
print(ClassName.function()) # 不用实例化一个对象，直接把类里的方法当成属性来用
'''类的继承'''
import random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
def move(self):
self.x -= 1
print('我的位置是：', self.x, self.y)
class Goldfish(Fish):
pass
class Carp(Fish):
pass
class salmon(Fish):
pass
class Shark(Fish):
def __init__(self):
# 直接重写Fish父类，其中self是子类中的self
#Fish.__init__(self)
# 使用super()函数重写Fish父类，不需要传参进来；以后要改用继承的类，直接在子类中修改父类名即可
super().__init__()
self.hungry = True
def eat(self):
if self.hungry:
print("吃货的梦想就是天天吃^_^")
self.hungry = False
else:
print("太撑了，吃不下了！")
# 实例化一条鱼，生成一个fish对象
fish = Fish()
# 调用fish对象(鱼)的move方法
fish.move()
goldfish = Goldfish()
goldfish.move()
goldfish.move()
shark = Shark()
shark.move()
shark.eat()
shark.eat()
'''类的多重继承'''
class Base1:
def foo1(self):
print("我是foo1，我为Base1代言...")
class Base2:
def foo2(self):
print("我是foo2，我为Base2代言...")
# 多重继承父类，此例继承了Base1和Base2
class C(Base1, Base2):
pass
c = C()
c.foo1()
c.foo2()