初始python（三）

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()