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