数字运算符：+ - * / %（取余数） **（幂的n次方） //（取整数）

一、高级数据类型

1、序列：在python中，序列就是一组按照顺序排列的值【数据集合】
在python中 存在三种内置的序列类型：字符串、列表、元组
优点：支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端

2、切片：截取字符串中其中一段内容，切片使用语法：[起始下标：结束下标：步长]，左闭右开，起始下标<=value<结束下标
步长默认为1，步长为-1，可以倒叙输出

3、字符串及常用方法
3.1 capitalize() 首字母变大写
3.2 endswith/startswith() 是否x结束/开始
3.3 find() 检测x是否在字符串中 跟index都可以查找，但是find查不到返回-1.index差不到会报错
3.4 isalnum() 判断是否是字母和数字
3.5 isalpha() 判断是否是字母
3.6 isdigit() 判断是否是数字
3.7 islower() 判断是否是小写
3.8 join() 循环去除所有值用XX去连接
3.9 lower/upper 大小写转换
3.10 swapcase 大写变小写，小写变大写
3.11 lstrip/rstrip/strip 移除左/右/两侧空白
3.12 split() 切割字符串
3.13 title() 把每个单词的首字母变成大写
3.14 replace(old,new,count=None) old被换字符串，new替换字符串，count换多少个，无count表示全部替换
3.15 count() 统计出现的次数

4、list：python当中非常重要的数据结构，是一种有序的数据集合
特点：
4.1 支持增删改查
4.2 列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
4.3 用[]来表示数据类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
4.4 支持索引和切片来进行操作

5、列表及常用方法
5.1 append 追加元素
5.2 count 统计元素次数
5.3 extend 扩展，相当于批量添加
5.4 index 获取指定元素索引号 ，括号是具体数据值，返回查找的是下标
5.5 insert 在指定位置插入
5.6 pop 删除最后一个元素，也可以移除指定项（参数是索引值）
5.7 remove 移除左边找到的第一个元素，也可以移除指定元素（具体数据值）
5.8 reverse 反转列表
5.9 sort 列表排序（reverse=True，倒叙）
5.10 len 长度
5.11 del list[0] 删除列表中第一个元素
5.12 del listB[1:3] 批量删除第二第三位数据

6、元组：是一种不可变的序列，在创建之后就不能做任何的修改
6.1 不可变，但是可以对元组中的列表进行修改
6.2 用（）创建元组类型，数据项用逗号来分割
6.3 可以是任何的类型
6.4 当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理
6.5 支持切片操作

7、字典：可以存储任意对象，字典是以键值对的形式创建的{‘key’,'value'}利用大括号包裹，逗号分割
7.1 键值对的键key不能重复，value可以重复
7.2 字典是不可变类型
7.3 和list一样，支持对数据的添加、修改、删除
7.4 不是序列类型，没有下标的概念，是一个无需的键值集合，是内置的高级数据类型
7.5 每个键必定是唯一的，如果存在重复的键，后者会覆盖前者

8、字典及常用方法
8.1 修改元素，字典中的值可以修改，通过键key找到对应的值修改
8.2 删除元素 del删除指定元素，clear清空字典，dictA.pop(age)删除年龄
8.3 获取键：keys，可以用for循环取出每个key值
8.4 获取键值对。返回一个包含所有（键，值）元组的列表dict items对象
8.5 新增元素，如果在使用变量名['键']=数据时，这个‘键’在字典中不存在，那么就会新增这个元素
8.6 统计个数 len()可以查看字典中有几个键值对
8.7 获取值：values python3版本中使用values返回一个包含所有制（value)dict values对象
8.8 删除指定键 pop（‘键’）删除指定键
8.9 dictA.values() 获取所有值
8.10 dictA.keys() 获取所有键
8.11 dictA.items() 获取所有键值对
8.11 for key,value in dict.items():
print ('%s==%s'%(key,value)) 输出所有的键=值
8.12 dictA.update({'age':32}) 可以更新修改或者添加

9、公用方法
9.1 + 合并操作，两个对象相加操作，会合并两个对象，适用于字符串、列表、元组
9.2 * 复制，对象自身按指定次数复制，适用于字符串，列表、元组
9.3 in 判断元素是否存在，判断指定元素是否存在于对象中，适用于字符串、列表、元组、字典，结果是布尔类型数据True False

二、函数
1、参数的分类
1.1 必选参数：形参（定义的时候不占内存地址）、实参（在调用时赋值使用）
1.2 默认参数（缺省参数）：始终存在于参数列表中的尾部，def sum(a,b=40),例如b=40为默认参数，调用时可以不加参数即调用默认的40
1.3 可选参数（不定长参数）：def sum(*args)： 接受元组类型参数
1.4 关键字可变参数：def keyFunc(**kwargs): 可变关键字参数（是一个字典类型，key是一个字符串，可以传0-n个参数），用两个星号来定义
调用的时候需要keyFunc(**dictA),在字典前加两个星号以此调用，
或者直接在代码里以命名参数的形式传 keyFunc(name='peter',age=26)，最终输出的结果是个键值对，如果不传参数也可以，会输出空字典{}
1.5 也可以混合参数组合：def complexFunc(*args,**kwargs): 调用也可以不传参，会输出空元组和空字典，也可以分别传参
如，complexFunc(1,2,3,4,name='刘德华')
注意：可选参数必须放到关键字可选参数之前

2、函数返回值
2.1 概念：函数执行完以后会返回一个对象，如果在函数的内部有return就可以返回实际的值，否则返回None
2.2 类型：可以返回任意类型，返回值类型应该取决于return后面的类型
2.3 用途：给调用方返回数据
2.4 在一个函数体内可以出现多个return值，但是肯定只能返回一个return
2.5 如果在一个函数体内执行了return，意味着函数执行完成退出了，return后面的代码语句将不会执行
2.6 函数的分类：根据函数的返回值和函数的参数
2.6.1 有参数无返回值的，多用在设置某些不需要返回值的参数设置
2.6.2 有参数有返回值的，一般是计算型的，需要参数，最终也要返回结果
2.6.3 无参数无返回值的，一般用于提示信息打印
2.6.4 无参数有返回值的，多用在数据采集中，比如获取系统信息

3、全局变量和局部变量
3.1 局部变量：就是在函数内部定义的变量【作用域仅在函数内部】，不同的函数可以定义相同的局部变量，但是各自用各自的不会产生影响
3.2 局部变量的作用：为了临时的保存数据，需要在函数中定义来进行存储
3.3 当全局变量和局部变量出现重复定义的时候，程序会优先执行函数内部的变量
3.4 如果在函数的内部要想对全局变量进行修改的话，必须使用global关键字进行声明
3.5 在python中，万物皆对象，在函数调用的时候，实参传递的就是对象的引用
3.6 了解了原理之后，就可以更好的取把控在函数内部的处理是否会影响到函数外部的数据变化
3.7 参数传递是通过对象引用来完成！！！

4、匿名函数
4.1 python中使用lambda关键字创建匿名函数，所谓匿名就是这个函数没有名字不用def关键字创建标准的函数
4.2 lambda 参数1，参数2，参数3：表达式 （匿名函数冒号后面的表达式有且只有一个，是表达式不是语句）
4.3 匿名函数自带return，而这个return的结果就是表达式计算的结果
M=lambda x,y:x+y
print(M(23,19))
or
M=lambda x,y:x if x>y else y #如果x大于y，输出前面的x，否则输出y
print(M(12,2)) #输出12
or
M=(lambda x,y:x if x>y else y)(16,12) #如果x大于y，输出前面的x，否则输出y,可以放入参数直接调用
print(M) #输出16
4.4 lambda只能是单个表达式，只能实现简单的函数场景，仅仅能封装有限的逻辑，复杂的逻辑实现不了

5、递归函数

• 5.1 递归满足的条件：①自己调用自己、②必须有一个明确的结束条件
• 5.2 优点：逻辑简单、定义简单
• 5.3 缺点：容易导致栈溢出，内存资源紧张，甚至内存泄露

6、内置函数

• 6.1 python自带得函数
• 6.2 abs():绝对值输出函数
• 6.3 round(x,n):对浮点数进行近似取值,返回浮点数x得近似值，不一定是四舍五入，n为保留得位数
• 6.4 pow(3,3):求次方,求3的3次方可以等于3**3
• 6.5 max(x,y,z...):求最大值，参数可以是序列
• 6.6 divmod(a,b):求商和余数，返回（商，余数）
• 6.7 sum(range(50),3):求和，可以传入列表、元组、集合等,此处的3可省略（没指定默认为0），如果有代表每一项先加3再求和
• 6.8 eval(expression,[globals,[locals]]):执行字符串表达式（也可以函数）,expression表达式，globals变量作用域，全局命名空间，必须是字典，locals局部变量作用域，可以是任何对象
• 6.9 类型转换函数：

1. int()
2. float()
3. str()
4. ord()
5. chr() 数字转字符，即转化为ascii码
6. bool() 转换为true false
7. bin() 十进制转换为二进制
8. hex() 十进制转换为16进制
9. oct() 整数转8进制
10. list() 将元组转换为列表
11. tuple() 将列表转元组
12. dict()
13. bytes() 转为字节数组

6.10 序列操作内置函数：

• all():判断可迭代参数中”所有“元素非0、非空、非FALSE，才算TRUE，注意：空元组、空列表返回值为TRUE，类似and
• any():判断可迭代参数中是否全部为False，只要有一个为True则返回True（除0、空、false外都算true），类似or
• sorted():对可迭代对象进行排序操作，默认reverse=False为升序，reverse=True为降序
• sort与sorted区别：sort是应用于list商的方法，sorted可以对所有可迭代对象进行排序操作
• list的sort是对已存在的列表进行操作，而sorted是返回一个新的list
• reverse()：反向列表中的元素
• range(start,stop,step)：可以创建一个整数列表(左开右闭），一般用在for循环中
• zip()：用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回这些元组组成的列表
• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表，类似阵列
• enumerate()：函数用于将一个可遍历的数据对象（如列表、元组、字符串）组合为一个索引序列，同事列出数据和数据下标，一般用在for循环当中

6.11 集合：是一个无序且不重复的元素集合set{}

• add():set1.add('python')集合追加数据
• clear()：set1.clear()清空集合
• difference()：a.difference(b),两个集合的差集，a中存在，b中不存在的，去掉ab重复的，返回值会生成一个新的集合需要定义接收变量=set1-set2
• intersection()：取交集，=set2&set1，返回一个新的值需要定义变量接收，set1.intersection(set2)
• union():取并集，包含a和b集合所有数据，a.union(b),并且去重=set1 | set2
• pop():随机移除某个元素并且获取那个参数，集合pop没有参数，a.pop(),直接在原有集合中操作
• discard()：指定移除的元素，a.discard(3),指定移除3，在原有集合操作
• update()：set1.update(set2)跟并集操作查不多，直接在原有集合操作

三、面向对象oop
1、面向过程——函数式——面向对象
面向过程：根据业务逻辑从上到下写代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象编程：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。关注的式设计思维（不考虑细节，类似老板思维）
面向对象适合做大项目，面向过程不适合大项目
面向过程的关注点是：怎么做
面向对象的关注的是：谁来做
2、类和对象
2.1 类由3个部分构成：
类的名称：类名 （大驼峰），例如：人类
类的属性：一组数据 例如：身高、年龄
类的方法：允许对进行操作的方法（行为） 例如：吃、跑
2.2 类：是具有一组相同或者相似特征【属性】和行为【方法】的一系列[多个]对象组合
现实世界 计算机世界
行为--------------->方法
特征--------------->属性

2.3 对象：对象是实实在在的一个东西，类的实例化，具象化，
创建对象 ：对象名=类名（），例如：dog=animals()
调用方法：dog.run(),这里的run()方法就是类里定义的函数
访问类属性：print(dog.name)
2.4 类是对象的抽象化 而对象是类的一个实例
3、实例方法与属性
3.1 实例方法：①在类的内部，②使用def关键字可以定义一个实例方法，与一般函数定义不同，③类方法必须包含参数self（self也可以叫其他名字），且为第一个参数
所属的权力归实例所有
3.2 类属性：定义在类里面&方法外面的属性称之为类属性
3.3 实例属性：定义在实例方法里面，使用self引用的属性称之为实例属性
4、__init__魔术方法
4.1 是一个初始化的方法，用来定义实例属性和初始化数据的，在创建对象的适合自动调用不用手动去调用
4.2 利用传参的机制可以让我们定义功能更加强大并且方便

5、self
5.1 self和对象指向同一个内存地址，可以认为self就是对象的引用
5.2 所谓self可以理解为对象自己，某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可
5.3 self只有再类中定义，实例方法的时候才有意义，在调用时候不必传入相应的参数，二十由解释器自动去指向
5.4 self的名字可以更改，可以定义成其他的名字，只是约定俗成的定义成了self
5.5 self指的时类实例对象本身，相当于java中的this

6、魔术方法
6.1 常见的魔术方法：
__init__：初始化一个类，在创建实例对象为其赋值时使用
__str__：在将对象转换成字符串str（对象）测试的时候，打印对象的信息
__new__：创建并返回一个实例对象，调用了一次。就会得到一个对象，cls代表class类缩写，return object.__new__(cls)
场景：可以控制创建对象的一些属性限定，经常用来做单例模式的时候来使用
__class__：获得已知对象的类（对象.__class__）
__del__：对象在程序运行结束后进行对象销毁的时候调用这个方法，来释放资源
__mro__：可以显示类的依次继承关系，通过类A.__mro__然后打印出来
6.2 先执行__new__，返回一个对象后，再执行__init__初始化（因为有了对象才能有后面的）

7、析构方法
7.1 析构方法概述：当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也成为析构方法
7.2 当对象被手动销毁的时候也会自动调用__del__方法销毁对象回收内存
7.3 析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源

8、继承
8.1 和生活中继承是一样的，子类可以继承父类【的属性和行为】，爸爸有的儿子都有，相反儿子有的爸爸不一定有
8.2 所有对于面向对的几次来说，其实就是将多个类共有的方法提取到父类中，子类仅需几次父类而不必一一去实现
8.3 这样就可以极大提交效率，减少代码的重复编写，精简代码的层级结构，便于拓展
8.4 class 类名(父类)：通过这样做单继承
8.5 class 类名(父类A,父类B)：多继承，继承查找先平级查（同名继承查找），A没有查B，如果AB都没有，再查AB的父类往上，最后查object
8.6 类的传递过程，把父类又称为基类，子类又成为派生类，父类的属性和方法可以一级一级的传递到子类
8.7 针对子类重写父类方法，如果重写方法名一样，以子类为准，子类重写父类有的__init__函数，父类定义会失效
如果此时还需要使用父类的__init__函数参数，可以父类.__init__(self,x,y)或者super.__init__(x,y)
用super就不需要self。因为super是自动找到父类，进而调用方法，如果继承多个父类。super会按照顺序查找继承

9、多态
9.1 所谓多态，顾名思义就是多种状态、形态，就是同一种行为，对于不同的子类【对象】有不同的行为表现
9.2 要实现多态，必须有两个前提需要遵守：
继承：多态必须发生再父类和子类之间
重写：子类重写父类的方法
9.3 多态可以增加程序的灵活性和拓展性
9.4 可以定义一个函数统一调用多态方法：只要这些多态class都有say_who()方法，不管是从哪里继承都可以统一调用

def commonInvoke(obj):
　　obj.say_who()
listObj=[Duck(),Dog(),Cat(),Bird(),Student()]
for i in listObj:
　　commonInvoke(i)

10、类方法和静态方法
10.1 类方法：类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象
一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用

class Person:
　　country='china'
#类方法 用classmethod来进行修饰
　　@classmethod
　　def get_country(cls):
　　　　return cls.country #访问类属性
　　　　pass
　　pass
print(People.get_country()) #通过类对象去引用
p=People()
print('实例对象访问%s'%p.get_country()) #通过实例对象去引用

10.2 静态方法：类对象所拥有的方法，需要用@staticmethod来表示静态方法，静态方法不需要定义额外的参数
一般情况下，我们不会通过实例对象去访问静态方法，但是类对象和实例对象都是可以访问静态方法
静态方法主要用来存放逻辑性的代码，本身和类即实例对象没有交互
也就是说，在静态方法中，不会涉及到类中方法和属性的操作
可以使得资源能够得到有效的充分利用

11、私有化属性
11.1 为了更好的保存属性安全，即不能随意被修改，可以将属性定义为私有属性，添加一个可调用的方法去访问
11.2 私有属性语法：两个下划线开头，__age=18，声明该属性为私有，不能在类的外部被使用或直接访问
11.3 使用私有属性的场景：
把特定的一个属性隐藏起来，不想让类的外部进行直接调用
想保护这个属性，不想让属性的值随意的改变
保护这个属性，不想让派生类【子类】去继承

12、私有化方法
12.1 私有化方法和私有化属性概念一样，有些重要的方法不允许外部调用，防止子类意外重写，把普通的方法设置成私有化方法
12.2 语法：私有化方法，即在方法名前加两个下划线，def __myname(self): 私有化后只能在类的内部进行调用

13、下划线说明
13.1 _xxx，前面单下划线开头表示protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能使用from xxx import *的方式导入
13.2 __xxx__前后两个下划线。魔法方法。一般是python自有，开发者不要创建这类型的方法
13.3 xxx_后面单下划线，避免属性名与python关键字冲突

14、属性函数
14.1 属性函数（property）：假设age是私有属性
方式一：

@property #提供一个getter方法
def age(self):
　　return self.__age
@age.setter #提供一个setter方法
def age(self.parms):
　　if parm<0:
　　　　print('年龄不能小于0')
　　else:
　　　　self.__age=parms
　　pass
pass

方式二：
分别定义get_age（）、set_age()函数
age=property(get_age,set_age)，外部调用默认不输入就调用get获取，输入默认调用set修改
外部就可以正常调用或者修改了这个私有属性了

15、__new__与单例模式
15.1 在新式类__new__才是真正的Shiloh方法，为类提供外壳制造出实例框架，然后调用框架内的构造方法__init__进行丰满操作
比喻建房子__new__方法负责开发地皮 打地基 并将原料存放在工地，而__init__负责从工地取材料建造出地皮开发图纸规定的大楼，负责细节设计、建造，最终完成
#在python中，如果不重写__new__默认结构如下：
def __new__(cls,*args,**kwargs):
return super().__new__(cls,*args,**kwargs)
#或 return object.__new__(cls,*args,**kwargs)
此处不能把super写作cls自己，会导致深度无线递归报错
15.2 单例模式是常用设计模式的一种，单例就比如我们打开电脑的回收站，在系统中只能打开一个回收站，
也就是说这个整个系统中只有一个实例，重复打开也是这个实例
简单的说就是不管创建多少次对象，类返回的对象都是最初创建的，不会再新建其他对象，

三次db对象返回的id都是一样的，因为是单例模式，如果有子类继承也会一样效果

    class DataBaseClass(object):
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance') #如果不存在就开始创建
                cls._instance=super().__new__(cls,*args,**kwargs)
            return cls._instance
        pass
    db1=DataBaseClass()
    print(id(db1))
    db2=DataBaseClass()
    print(id(db2))
    db3=DataBaseClass()
    print(id(db3))