3 条件控制和循环语句&函数&面向对象编程&模块&包&文件和异常

1. if
   1. if condition:T_execute
   2. if condition:T_execute else:F_execute
   3. if condition1:condition1_execute elif condition2:condition2_execute else:F_execute
   4. *random::random.randint(start,end)随机取[start,end]的数
2. while
   1. while condition:T_execute
   2. while condition1:condition1_execute while condition2:condition2_execute
   3. while condition:T_execute else:F_execute
3. break:终止最近的循环
4. continue:从头继续开始最近的循环
5. pass:空操作
6. for:for variable in sequence:statements else:statements
   1. 列表:使用for循环遍历列表,不能直接对列表进行添加或者删除操作;for i in list:代码块
   2. 元祖:for i in tuple:代码块
   3. 字符串:for i in string:代码块
   4. 字典
      1. for i in dictionary:代码块;打印key,每一次打印值得顺序不一样,因为字典是无序的
      2. for i in dict.keys():代码块
      3. for i in dict.values():代码块
      4. for i/k,v in dict.items():代码块;字典元素输出/字符串对输出
   5. range(start,end,step)返回整数序列对象,常用在for
      1. 列表是可变对象,对列表的循环操作会影响到原对象,所以谨慎使用删除操作,删除后元素的索引位置会改变,导致不能完全遍历
7. 推导式:
   1. 列表推导式[expr for value in collection if condition]:在列表的基础之上,使用for循环结合if判断,找出符合条件的元素组成新的一个列表[i.function() for i in names if len(i)>4];
      1. 不同元素对象的同级for循环和if判断划分为两个区域,不需要成对出现
   2. 集合推导式{expr for value in collection if condition}
   3. 字典推导式{ key_expr: value_expr for value in collection if condition };{k:v for k,v in dict.keys()/values()/items() }枚举字典元素
   4. 嵌套列表推导式(适用对象中嵌套的对象):注意遍历顺序;[name for lst in names for name in lst if name.count('e')>=2]搜索对象name和被嵌套对象lst

1. 函数:
   1. *函数,python中能直接使用的我们叫做函数;方法,间接调用,不能直接使用,一般通过类名,或者对象.方法名来使用
   2. 定义函数:def 函数名(形参):函数体
   3. 调用函数:函数名(实参)
   4. 直接把函数名赋值给一个变量,函数名就是一个函数对象的引用
2. 函数参数:
   1. 必备参数
      1. 位置实参:实参和形参的顺序对应
      2. 关键字参数:形参名=值
   2. 参数默认值default,默认都放参数后端
   3. 不定长参数def function(*tuple_val,**dict_val);现实中出现无法在函数创建时确定所有的参数,就需要设定不定长参数,除上面三种外的参数,(函数中使用去除*)
      1. *存放所有未命名的实参,打印为元祖
      2. **存放所有命名的实参,打印为字典;命名不需要单引号
      3. 定义时的参数位置:必备参数,*不定长,默认值参数,**不定长
         1. 调用时的必备参数必须用位置实参,默认值参数可以放在最后和**不定长前面
   4. 可变与不可变对象的传递
      1. 可变对象:列表,字典;通过函数进行传递,传递的是对象本身,通过函数修过,会影响到它本身;其实是可变对象的元素,当对可变对象本身进行修改的时候,是不会影响到原对象的,只是对象的指向变化了
      2. 不可变对象:字符串,元祖:通过函数进行传递,传递的是对象的值,没有影响对象本身,比如在a=10,只是丢弃了原值,不是改变了a的值而是生成了新的a对象;即指向另一个id,用了global后,将全局变量对象指向修改后的id
3. 函数返回值return:return语句用于退出函数，选择性的向调用者返回一个表达式
   1. 单个return返回None
   2. 函数中没有return,用print(function()),输出None(就是返回None)
   3. print(function)返回函数在内存中的地址
4. 变量的作用域
   1. 局部变量:在函数内部定义的变量称之为局部变量
   2. 全局变量:在函数外部定义的变量称之为全局变量
      1. 不可变对象:不会受到函数内部修改的影响,传递的是对象的复制
      2. 可变对象:会受到函数内部修改的影响,传递的是对象本身
   3. global:global 对象
      1. 对于不可变类型的全局变量来说，要在函数中修改需要global声明
      2. 对于可变类型的全局变量来说，要在函数中修改可以不使用global声明
5. 匿名函数lambda 参数列表:表达式;一般结果赋值给对象,所以是有返回值的
   1. 主体就是一个表达式,不需要使用return却有返回值
   2. 应用场景：赋值给变量，作为参数传入其他函数
6. 递归函数:自己调用自己
   1. *Python暂时没有尾递归优化,传入数值不应过大
7. 高阶函数:
   1. map可以接收一个函数及多个序列(函数和实参同时传入),将多个序列中的元素作用于函数,返回一个新的map对象;map(lambda x:表达式,seq[]),序列是list,将seq[]中的每个元素x都应用于func
   2. filter过滤序列中不符合条件的元素,一个序列,返回由符合条件元素组成的filter对象;filter(lambda x:表达式,seq),序列是list|tuple|string
   3. reduce对于序列中的所有元素调用fun进行数据合并(数据求和等)操作,可以给定一个初始值;一般为两个参数
      1. from functools import reduce
      2. reduce(lambda x,y:x+y[1],seq,0);将初始值0传给x,seq的元素传给y,相加后的数传给x
      3. 直接返回数值
8. 其他
   1. 空列表,空字典,空元祖,0,代表的布尔类型的值都是False
   2. flag=T/F,修改对象的1/0可以作为函数内部可修改的结束循环条件

1. 面向对象:对实体对象/系统参与者的相关的函数进行分类和封装
   1. 分析这些对象有哪些特征、哪些行为，以及对象之间的关系，所以说面向对象的开发核心是对象
   2. 类是对象的类型，具有相同属性和行为事物的统称,然后面对这个类进行面向对象编程;类是抽象的，在使用的时候通常会找到这个类的一个具体存在
   3. 类是对象的类型，对象是类的实例
2. 定义类:class 类名:属性列表 方法列表
   1. 类的三部分构成:
      1. 类的名称：类型
      2. 属性：对象的属性
      3. 方法：对象的方法
   2. 类的属性分类:
      1. 类变量:在所有同类的实例化对象中是公用的,通常不作为实例变量使用,定义在方法之外;使用:类名.类属性
         1. 内部调用classname.属性名
         2. 外部调用classname.属性名|对象名.属性名
      2. 实例变量:定义在方法中的变量，只作用于当前类的实例,主要是在初始化方法中描述对象的特征
         1. __init__(self,...)中初始化
         2. 内部调用self.
         3. 外部调用对象名.属性名
      3. 私有属性:外部不能直接调用
         1. 实例:将传入数据当做实例的私有属性
            1. 定义:def __init__():self.__属性名=属性
            2. 内部调用:self.__属性名
            3. 外部调用:实例对象._classname__属性名
         2. 类:
            1. 定义:__属性名=""
            2. 内部调用classname.__属性名
            3. 外部调用classname._classname__属性名
   3. 类的调用:
      1. class()即调用类的初始化方法__init__()
         1. self指代类的实例,对实例化对象的参数进行初始化self.name=name;在接下来的方法中可以使用self.属性来指代实例的属性
      2. class().function()即调用类的普通方法
         1. 在类中的普通方法的定义一般为def function(self):函数体;直接传入实例对象,使用初始化方法中定义的实例属性,且会修改初始化方法中定义的实例属性
   4. 类的方法
      1. __init__()是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法;每当创建类的实例化对象的时候，__init__()方法都会默认被运行
         1. 在类方法定义中，第一个参数self是必不可少的;类的方法和普通的函数的区别就是self，self并不是Python的关键字
         2. 方法中的不定长变量:**infor,直接转self.infor=infor
      2. __name__类或者模块的名字
      3. __main__所处模块，xxx.py文件本身
         1. if __name__ == “__main__”:测试模块,演示模块用法等代码
      4. __doc__显示类中的注释
      5. hasattr(对象,'属性')检查是否存在这个属性
      6. setattr(实例,属性),设置一个属性,如果属性不存在,会在实例化对象中创建一个新属性
      7. delattr(对象,'属性'),删除属性,类名和实例化对象都无法访问
3. 继承
   1. 继承:程序中当我们定义一个class的时候，可以从某个现有的class继承，新的class称之为子类（Subclass），而被继承的class称之为基类、父类或超类;子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法
   2. class 子类(父类): def __init__(self,...):super(子类,self).__init__(...);子类的方法自动继承
   3. 多继承:class 子类(父类1,父类2,...):def __init__(self,...):super().__init__(...);如果继承的父类中有相同的方法名，而在子类中使用时未指定，python将从左至右查找父类中是否包含方法
   4. super(子类,self),找到子类的父类,把self传递给父类,再调用父类下面的__init__()或其他方法,把相应的参数传递给父类
      1. super 是用来解决多重继承的方法调用问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）;
      2. MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表
      3. 一般类的多继承代码,主要通过父类名调用初始化方法:父类.__init__(self)
   5. 重写:在子类中重新定义父类同名方法
   6. *在python3中所有的类都是新式类,所有类默认继承object;搜索方式是采用“广度优先”的方式去查找属性(多继承调用方法从左至右,就近原则,一层父类有的方法不需要去上一层父类中查找;调用属性/初始化方法从右至左,广度优先),当一个子类多继承,且部分父类继承于同一个类,初始化方法会逆序打印,先运行广度较大的父类
      1. 子类.__mro__打印方法解析顺序,广度表
      2. 子类.__bases__打印直接父类
   7. *同级.py文件类继承:class 子类(文件名.父类)
4. 多态:编译阶段无法确定其类型,在运行时确定其状态;python的变量是弱类型,定义时不指明其类型,且python是解释性语言,不进行预编译,在运行时才确定其状态
5. 访问限制:私有属性可以被访问和修改;对象._类名__属性名
6. 静态方法
   1. @staticmethod上一行修饰
   2. 不能访问实例属性,参数不能传入self
   3. 与类相关但是不依赖类与实例的方法
7. 类方法
   1. @classmethod上一行修饰
   2. 不能访问实例属性,参数必须传入cls
   3. 调用类属性cls.类属性名
   4. 静态方法与类方法都可以通过类或者实例来调用

1. 模块:*.py文件
   1. 导入顺序:标准自带->第三方->自定义模块
   2. 导入方式:
      1. import 模块/from 模块 import *
      2. from 模块 import 部分(as 重命名):从模块中导入一个指定的部分到当前命名空间中
      3. import 模块 as 重命名:原模块名不能使用
      4. 子目录导入模块:from 文件夹名 import 模块名
      5. 嵌套导入模块:没有明确路径,调用文件嵌套调用其他文件搜索不到
         1. import sys->sys.path.append('.\\文件夹目录')->设置好文件夹目录即可导入文件及导入文件内与其同级的间接导入文件
         2. *相对路径:.\\即当前目录,.\\model即当前目录的下一层目录model,..\\即上一层目录
         3. *绝对路径r'...',不需要转义字符\
      6. 重名的自定义模块会被自带模块覆盖,找到正确的绝对路径才能导入:模块所处文件夹目录的上一层目录->from 模块所处文件夹目录名 import 模块
         1. 第三方模块重名,import 模块,不会覆盖
   3. 定位模块
      1. Python解析器对模块位置的搜索顺序:
         1. 当前目录
         2. Python则搜索在环境变量PYTHONPATH下的每个目录
         3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
         4. 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录
   4. *在调用模块中的函数时，必须加上模块名调用，因为可能存在多个模块中含有相同名称的函数;from导入的模块,在使用函数时可以省略模块名.
   5. 单个.py文件过大需要拆分为多个不同功能的模块,if __name__=='__main__':__mian__是当前所处模块名,表示作为模块导入不能执行
   6. 导入是一个开销很大的操作,默认情况下，模块在第一次被导入之后，其他的导入都不再有效
      1. import imp->imp.reload(模块名)
2. 包:一般是from 包名 import 模块名/*
   1. 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块B
      1. 跨越当前文件的调用基本需要指明出处
   2. 目录中只有包含一个叫做__init__.py的文件才会被认作是一个包
   3. 在导入包的时候，Python会从sys.path中的目录来寻找这个包中包含的子目录
   4. __init__.py 文件的作用
      1. __init__.py 控制着包的导入行为,加入__all__=["模块1","模块2",...],才能控制from包名import * 时导入的模块
      2. 包的初始化文件,在该文件编写的其他内容在导入包(或从包中调用模块时)都会执行,例如:import sys->sys.path.append('.\\文件夹目录')即可导入嵌套的模块
      3. *尽量保证__init__.py 文件简洁

1. 文件
   1. 文件的打开:打开的是一个文件对象
      1. open(name, [mode], [buffering],[encoding]) :打开一个已经存在的文件，或者新建一个新文件
         1. name : 访问的文件名称的字符串值(区分绝对路径和相对路径)
         2. mode : 打开文件的模式：默认只读r，写入w，追加a等,rb,wb以二进制(ASCII码|字节流)形式
         3. encoding:是指明对文件编码，仅适用于文本文件
      2. with open(filename,mode,[encoding]) as file_1:python在合适的时候自动关闭文件,不再需要访问文件后将其关闭;写入文件也需要先open,在with open:写入
         1. with open() as file_1:;打开处理后的对象都是存在的
   2. 文件的读取:Python将其中的所有文本都解读为字符串
      1. 对象.read(num)num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
      2. 对象.readlines():按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
   3. 文件的写入:Python只能将字符串写入文本文件,数值数据必须str()
      1. 对象.write():如果你要写入的文件不存在，函数open()将自动创建它;函数不会在你写入的文本末尾添加换行符,需要手动添加\n,一般读入的文件都自带\n
      2. file.write(对象)->file.seek(0):写入对象+把指针放在文件的开头,一个整体写入动作
   4. 文件的关闭:文件对象.close()
2. 文件读写https://www.cnblogs.com/zywscq/p/5441145.html
   1. 读with open('file','r') as f:print(f.read())
   2. 写with open('file','w') as f:f.write(string对象)
3. 异常
   1. try:...except error_type1:...else:...finally:...可能会出现上述问题的代码没有出现上述问题,执行这块的代码finally:不管有没有问题,我们都会执行这块的代码
   2. try不能单独使用,至少有一个except或者和finally结合使用不会报错
   3. *BaseException所有异常的基类
   4. 一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组