python的基本语法使用

不同类型之间的数据类型转换：

1. 自动转换（隐式转换）（由小到大）
2. 不同数值类型之间进行运算，会有一个隐式转换发生
3. Bool–>int
4. Int–>float
5. Float–>complex
6. 数据类型提升（自动转换）
7. Bool–>int–>float–>complex
8. 强制转换（显示转换）–>（由大到小）
9. Bool(参数值)
10. Int(参数值)
11. Float(参数值)
12. 字符与unicode编码值之间的转换
13. ASCII编码表
14. Chr() ord()
15. 如果字符串包含小数点，或者字母，或者其他字符，无法直接转换为int
16. 输出：print(内容)
17. 1.普通输出
18. 2.格式化输出

19.    %s字符串
    

20.    %i 整型
    

21.    %f 表示小数，默认保留小数点后6位%.nf
    

22.    %g小数的另外表示方式
    

23. 输入：

24.  V =input(‘输入提示’)
    

25. 不论输入的值是什么内容，v都是字符串类型
26. 十六进制0-9 a-f
27. 十进制转二进制bin(n)
28. 十进制转八进制oct(n)
29. 语句结构：
30. 顺序结构

31.     从上往下，从左往右，依次执行
    

32. 分支结构（判断）

33.     单分支
    

34.     If 条件（表达式）：
    

35.     条件成立执行
    

36. 随机数：
37. Import random
38. N = random.randint(a,b)生成[a,b]之间的随机数，包含a,b
39. 双分支
40. If 条件
41. 条件成立执行
42. Else
43. 条件不成立执行
44. 多分支
45. If 条件1

46.  条件1成立执行
    

47. Elif 条件2：

48.  条件2成立执行
    

49. Else:

50.   其他执行
    

52. 循环语句：
53. While 循环
54. For 循环
55. For 变量 in range(stop):

56.   Stop:表示终点（不包含这个点）
    

57. For 变量 in range(start,stop,step):
58. Start:表示起点，可以省略不写，默认为0
59. Stop:表示终点（不包含这个点）
60. Step:表示的步长，可以省略不写，默认为1
61. 递增或者递减（步长为负值）的数量
62. Break:结束当前循环
63. Continue 跳过本次循环
64. 数据类型：bool int float complex str list tuple dict set
65. List的基本使用

66. 概念：可以存储任意多个不同数据类型的集合
    

67. 元素通过索引值访问，索引范围[len] 
    

68. 列表内存结构：连续内存（顺序表）特点：有序，不唯一
    

69. 列表中元素的操作：
70. 添加：

71.  尾部添加
    

72.  Append(obj)
    

73.  在指定位置添加
    

74.  Insert(index,obj)
    

75.  Extend 类似拼接字符串一样添加
    

76. 删除：

77. Del
    

78. Pop(index)
    

79. Remove(obj)
    

80. Clear()
    

81. 查询

82. 在列表中查询元素所在的位置
    

83.  Index(obj)
    

84. 可以判断某个元素是否在列表中
    

85. In     not in
    

86. 修改：

87. List[index]=new_value
    

88. 列表的切片操作：
    切片操作中，不存在越界异常问题
    索引值可以为负值
    基于索引值完成操作：
    List[start:stop:step]
    Start:表示起点的索引值
    Stop:表示终点的索引值，不包含终点值，可以省略不写，默认到最后一个，包含最后一个
    Step:步长默认为1
    取出列表中指定位置的内容，得到的新列表，源数据不变
    Sort() -默认从小到大 sort(reverse=True)手动指定，从大到小
    Reverse()将数据实现翻转
    都是对源数据进行操作

Copy浅复制，深复制
深浅复制的区别与联系：
对于一般对象，二者没有区别
都是将原数据复制一份新的出来
对于复合对象有区别：
浅复制：尽可能的复制引用
深复制：递归的复制所有数据
元组：不可变，内容不可变，可查，不可增删改—》查索引位置index,in,not in 改可转换列表后改
字典的使用：
容器：可以存储任意多个键值对元素的集合
特点：所有元素都是以键值对形式来存储的，没有索引顺序3.5之前无序，3.5之后有增加顺序
通过键访问对应的值
字典有长度len()
访问元素：通过key访问
d[key] 如果没有指定key,会导致keyError
d.get(key) 如果没有指定key,得到none值
字典中的key的特性：
Key唯一，后来的值会将之前的覆盖掉
只有不可变类型，才能作为字典的键（key）
不可变类型：bool,int,float,str,tuple,complex
可变类型：list,dict,set
字典的操作：
增：
D[key] = value
d.update(key=value)
d.setdefault(k,v)
删：
Del d[key]
根据key删除
d.clear()
清除所有，一般指列表
d.pop(k)
根据key删除
d.popitem()
删除最后一个
查：
只能查key
Int
Not in
改：
D[key]=value
d.update(key=value)
列表：
列表的切片
基于索引值完成切片，不存在越界问题
List[start:stop:step]
Start:不写，默认从最开始算起，默认值0
Stop:表示终点（不包含终点）不写，默认包含最后一个
Step:默认1，可以为负值，表示从后往前，负值为反方向，步长
列表的复制：
List.copy()----》默认为浅复制
Import copy
Copy.copy()浅复制
Copy.deepcopy()深复制
深浅复制的区别：

1. 对于一般对象，没有区别，都是复制一份新的出来
2. 对于复合对象，有区别
3. 浅复制，尽可能的复制引用
4. 深复制，递归复制所有数据
   命名空间：
   本质：存储相关变量名，已及变量值的字典
   分类：
   局部命名空间：
   Locals()
   全局命名空间
   Globals()
   内置命名空间
   系统内置
   Builtins
5. 系统加载顺序：
6. 内置—>全局—>内置
   变量的作用域：
   作用域：能起作用的范围
   LEGB
   L:局部 定义位置：定义在函数内部，仅限于当前函数可以访问
   E：闭包 定义嵌套函数的内部
   G： 全局 定义在函数外，所有函数中都能使用
   B：内建 系统内建模块
   作用域从大到小：
   内建 —》全局—》局部----》闭包
   函数会产生新的作用域
   循环，分支不会产生新的作用域
   全局变量
   局部变量
   形参
7. 定义位置不同
8. 全局：函数外
9. 局部：函数内
11. 作用域不同：
12. 全局：全局有效
13. 局部：当前函数有效
15. 处于的命名空间不同
16. 全局：全局命名空间中
17. 局部：局部命名空间中

生命周期不同
全局：长，出生时间早，全局命名空间加载
程序结束，变量被系统回收
局部：短，函数被调用时，变量出生
函数词用结束，变量被系统回收
内存存储区域不同
全局：
非栈（全局变量区）
局部：
栈中
访问问题：
在函数中访问全局变量；

1. 使用值，可以直接访问
2. 修改值，如果需要在函数中，修改全局变量的值，需要使用global声明（1.如果全局变量是不可变类型，必须使用；2.如果是可变类型，没有必要要求《用不用global修饰，都可以》）
3. 位置参数
4. 按顺序形参与实参传递的值一一对应
5. 关键字参数
6. 形成接收的值，取决于实参给的关键字
7. 缺省参数（默认参数）
8. 参数个数问题：

9.  如果函数定义时，形参有默认值，那么在调用时，有默认值的形参，可以不给具体的实参，必须非缺省参数在前，缺省参数在后
   

10. 可变参数
11. *args

12.     在函数内部，以tuple的形式存在，如果形成是*args,在调用时，可以给0个，1个多个任意类型的形参都可以**kwarsg
    

13.    在函数内部，以dict的形式存在，如果形参是**kwargs,在调用时，可以0g个，1个，多个，键值对元素
    

14. 函数的递归的调用：
15. 概念：直接或者间接的调用自己，这种调用方式，称为递归调用
16. 递归的本质：

17.  递归错误，超出最大递归深度
    

18.   RecursionError:maximum recursion depth exceeded while calling a python object
    

压栈操作：
先进后出
递归调用需要有出口：
使用递归求： 求4的阶层
2，函数的返回值问题：

1. 一个函数都能够同时返回多个值
2. 如果使用一个变量接收多个返回值，该变量默认为tuple类型
3. 使用对应个数的变量，接收对应个数的返回值
4. 内建函数：

5.      内建模块（builtins）的函数
   

6. 暂时内建模块中的函数
7. Dir(目标文件)
8. Abs()绝对值
9. Max()求最大值
10. Min()求最小值
11. Map(function,iterable,)
12. Filter()
13. Zip()
14. Filter(function,iterable)
15. 将iterable中所有的元素，逐个作为存储放在function进行处理，如果函数的返回值为true,元素保留，为false,不保留
16. Zip(*iterables)
17. 常规函数：
18. Def 函数名（形参1）：

19.  Pass
    

匿名函数 ：
定义语法：
Lambda 参数1，，，表达式
表达式部分：
不能存在return
不能存在循环
不能存在分支（三元条件表达式除外）;
求和：
Def get_sum(a,b):
Return a + b
Lambda a,b: a+ b
拆分：
Split
Partition
Rpartition
替换：
Replace(old,new[,count])
修饰 format
字符串的变换：
Upper:转小写
Lower 转大写
Swapcase 大小写互换
Title 单词首字母大写
Capitalize 首字母大写
Expandtabs 将\t转为空格，默认8个
判断
Startswith 以什么开头
Endswith 以什么结尾
Isdigit 判断纯数字组成
Islower 判断小写
Isupper 判断大写
Isalpha 判断纯字母组成
Isalnum 判断由字母数字组成
Isspace 判断空格
Istitle 判断标题
推导式（解析式）：
列表推导式：
Lst =[表达式 循环 分支]
模块的概念：

模块的分类：

1. 内建模块（builtins）
2. 系统标准模块
3. 第三方pygame
4. 自定义的
5. 模块的定义：（自定义模块）
6. 模块中可以存在内容
7. 标量 函数 可执行代码
8. 如何避免自定义模块中的测试代码在被引入时执行
9. If__name__==’main’;
10. 测试代码
11. 模块的使用
12. 导入模块
13. Import 模块名
14. 功能的使用
15. 模块名,功能名（）
16. Import 模块 as 别名
17. 引入次数问题
18. 一个模块无论被引入多少次，只能从头到尾执行一遍
19. Form … import …局部导入方式
20. From … import … as 别名
21. From 模块 import *
22. Import * 默认情况，引入当前模块中所有的功能
    all__的使用
    如果有特殊变量__all,这时候只引入__all__列表中包含的功能
    如果变量是_开头，使用form模块import方法无法引入
    模块搜索的路径
    Import sys
    Sys.path
    Pyc文件，临时文件
    Random模块：
    Random() 产生大于0 且小于 1 之间的小数
    Uniform(a,b)
    产生指定范围内的随机小数
    Randint(a,b)
    产生啊a,b范围内的整数，包含开头和结尾
    Random.choice(lst)
    随机返回序列中的一个数据
    Random.shuffle(list,n)
    随机打乱列表顺序
    Random.sample(list,n)
    返回一个从list中随机取n个非重复元素的新列表
    Sys.exit():结束python解释器
    Sys.path引入模块时的搜索路径
    Sys.version:获取解释器版本
    Sys.argv:可以动态为程序传递参数
    Sys.exec_prefix
    获取解释器安装路径
    Sys.getdefaultencoding()
    获取默认的编码方式
    Sys.getsizeof(lst)
    获取占用内存大小，以字节为单位
    Time
    Time.sleep()
    表示时间的三种方式：
23. 时间戳（给计算机看的）
24. Time.time()
25. 字符串时间（给人看的）
26. Time.asctime()
27. Ret = time.strftime(‘%Y-%m-%d %H:%M:%S’)
28. 元组时间（用来操作时间的）
29. Time.localtime()
30. __iniit__方法：初始化方法：触发时机，创建对象的时候，自动被调用
31. Self关键字的用法：
32. 1.对象方法的默认形参
33. 2.是当前类的一个对象，取决那个对象来调用就指谁
34. __str__作用：触发时机打印时自动触发
35. 私有化问题，私有属性
36. __属性名 ，特点：只能类被访问，类外不能访问
37. 一般会提供读写方法：
38. 设置属性（写）setAge(self,age) 获取属性（读）getAge(self)
39. Python私有化问题不是真正的私有化，而是进行名字重写
40. 改名规则：_类名__属性/方法名
41. Dir(对象)
42. 展示对象中所有的属性以及方法
43. Dir(模块)
44. Dir(对象)
45. 封装：最主要的是将类和属性方法的实现隐藏，对外提供访问的接口
46. 良好的封装能够减少耦合度（耦合度越高，越不利于代码的维护，列如声明的变量都是全局变量，后期想要修改值比较难）
47. 继承：子类（派生类）对象指向基类的对象称之为继承，派生类中是不能继承基类 的实有属性和方法的，但是私有属性和方法可以在同一个类中被调用
48. （Java只支持单继承，cpython是支持多继承，如果多继承只是继承第一顺序（有多态时））
49. 多态：相同方法的不同实现
    派生属性：
    类属性：属于类所有，内存中只有一份，可以提供所有对象来访问
    类属性访问：
    获取值：----》类名.类属性
    对象名.类属性
    设置值：----》类名.类属性=new_value
    属性的覆盖（派生属性）：子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了（属性的覆盖），私有属性，私有方法在继承中使用
    子类可以使用父类中所有非私有的属性以及方法
    Python中的多继承：一个子类可以同时有多个父类
    方法：子类可以继承所有父类中的非私有方法
    父类中如果存在同名方法，使用的方法取决继承的顺序
    新式类：广度优先
    经典（旧）深度优先

抽象类：定义：from abc import ABCMeta,abstractmethod
修改抽象类的元类，使用@abstractmethod装饰方法
什么是抽象类？
包含抽象方法的类称为抽象类,抽象类不能被实例化
什么是抽象方法？
使用@bstractmethod修饰的方法称为抽象方法
抽象类特性：
不能创建对象
抽象类的作用约束派生类去实现
子类可以继承到父类中的抽象方法，如果不重写该方法，否则当前依旧为抽象，不能实列化（实列化是new一个新的对象）
魔法方法：
在有python的解释器的环境下，能够自动触发并且能实现一定的渲染效果的方法
方法特点：方法() 比如：init(),str()
常见的魔法方法：
new() 分配内存，创建对象时，先执行new方法，后执行init（new是实列化）
init()创建对象时，初始化时候调用
del()对象被系统回收前，该方法会执行
str()直接打印对象时，会被调用
rept()用法类似str,str的替补
也可以使用格式化输出%r来选择
使用set存储自定义对象：
Set特性：无序，唯一

1. 重写__hash__方法：
2. 根据指定的内容来计算哈希值
3. 重写__eq__方法
4. 根据指定的内容进行比较两个对象内容是否一致
5. Is:比较两个对象是否为同一个对象（），同一个内存地址，比较值
6. ==比较二者内容是否一致 比较值
7. eq():比较两个对象的值
8. ==比较值
9. Is判断是否为同一个对象
10. 运算符重载 add +
11. Isinstance(obj,cls)
    判断某个对象是否为某个类（父类）的实例
    Issubclass(cls,cls)
    判断某个类是否指定类的子类（可以是本身）
    class
    反射函数：
    主要函数式编程
12. hasattr(obj,str)
13. 判断某个类是否包含指定属性
14. Getattr（obj,str）
15. 获取对应的属性
16. Setattr(obj,str)
17. 获取对应属性的值
18. Setattr(obj,str,value)
19. 设置对应的属性值
20. Delattr(obj,str)
21. 删除对应的属性
22. 也可以反射模块中的类
23. Getattr(模块名，类名)
24. 生成器（generator）:一边计算一边生成的机制
25. 生成器的创建方式：
26. 1.g = (列表推导式)
27. 包含yield的关键字的任意函数
28. 生成器的好处：
29. 1.生成效率更高
30. 2.内存占用更少
31. 弊端：

32. 需要数据的时候，需要逐个生成
    

33. 只能从前往后生成，不能回滚
    

34. 如果生成的数据超出范围：
35. StopIteration
36. 生成器生成数据的方式：
37. Next(g)
38. G.next()
39. G.sender(value)
40. 注意：如果是首次生成，value必须为None，其他可以为任意参数
41. 生成器
42. 迭代器：集合元素中，多个元素逐个访问，这种方式，称为迭代（遍历）
43. 可迭代性：（Iterable）
44. 实现了可迭代协议的类
45. 可迭代性协议：
46. 实现了__iter__方法
47. 具备可迭代性的元素，可以使用for循环直接遍历
48. 如何判断一个对象是否具备可迭代性
49. 1.isinstance
50. 2.查看对象的所有方法中是否包含__iter__方法
51. Dir(obj/cls)
52. 迭代器：（Iterator）
53. 实现了迭代器协议的类
54. 可以使用next(obj)来访问对象，称为迭代器对象
55. 迭代器的协议：

56. __iter__方法
    

57. __next__方法
    

58. 如何判断一个对象是否是迭代器对象？
59. 1.isinstance
60. 2.查看对象中是否包含__iter__方法以及__next__方法
61. 具备可迭代性的对象是否为迭代器对象===》不一定
62. 生成器对象是否为迭代对象==》一定是
63. Iter()函数的使用：
64. 用法：iter(Iterable)Iterator
65. 可以将一个具备可迭代性的元素，转换为迭代器对象
66. 闭包的本质是函数
67. 闭包的条件：

68.  1.函数的嵌套定义
    

69.  2.内部函数中使用外部函数中的变量
    

70.  3.外部函数要有返回值，返回内部函数名
    

71. 闭包函数的作用：可以实现在不修改源代码的前提，增加新的功能:
72. 开闭原则：
73. 开：开放
74. 闭:关闭
75. 创建迭代器的方式：
76. 1.g1 = (列表推导式)
77. 2.包含yield关键字的函数
78. 生成元素：
79. 1.next(g)
80. 2.g.next()
81. 3.g.send(value)

82. Value：首次生成，必须给None
    

83. Yield可以暂停
84. 实现两个任务交替执行
85. 迭代器：迭代遍历
86. 可迭代性（Iterable）from collections.abc import Iterable
87. 具备可迭代性的才可以用for直接迭代
88. 实现可迭代性协议（iter）
89. 如何判断是否具备可迭代性
90. 1.isinstance
91. 2.判断包含是否包含“iter”
92. 迭代器（Iterator）
93. 实现迭代器协议（iter,next）
94. 可迭代性的元素是否为迭代器？不一定
95. Iter(iterable)Iterator
96. 生成器是否是迭代器—>是
97. For循环的本质，自定义类（）
98. 自定义类（）
99. 闭包：条件：
100. 1.函数嵌套定义
101. 2.内部函数使用外部函数的变量
102. 3.外部函数返回内部函数名
103. 判断：closure
104. 作用：不修改源代码的前提下，加功能
105. 装饰器：语法@闭包外部函数名：本质函数，允许存在多个装饰器
106. 类的组成：
107. 属性：对象属性，类属性
108. 方法：对象方法（成员方法，实例方法）
109. 类方法，定义：@classmethod
110. 特点：有一个默认参数cls表示当前类
111. 属于类所有
     调用：
112. 类名.类方法（）
113. 对象.类方法（）
     静态方法：定义：@staticmethod,特点：可以没有任何默认参数（定义在类中的一个特殊函数）
     调用：同类方式一致
     文件处理：
     文件的分类:狭义：文本文件
     文件的作用：存数据（数据持久化）
     文件的处理：
     读取数据：磁盘-----》内存
114. 打开文件
115. F=open(‘文件路径’,’打开方式’)
116. 开始读取
117. 使用文件对象进行读写操作
118. Read(n)
119. 关闭文件
120. 写入数据
121. Open(file,mode=’r’,buffering=-1,encoding=None,errors=None,newline=None,closed=True,opener=None)
122. File:表示文件路径，可以是绝对也是可以是相对
123. Mode:模式，
124. R:表示读取
125. W:表示写入
126. a:表示追加写入
127. b:表示二进制
128. +:表示读写
129. Buffering:表示的缓冲大小
130. Encoding:编码方式，如果以二进制读写，不需要执行编码方式
131. 开始读取：使用文件对象进行读写操作
132. 1.read(n)从目标文件中读取指定长度的单位（字符，数字，汉字都是1个单位）不写读全部
133. Readline()默认读取一行
134. Readlines如果不写长度，默认读取所有内容，返回一个生成器
135. 关闭文件：f.close()
136. 文件的复制操作(思路)：
137. 1.读取：（打开文件-读取内容—>关闭文件）
138. 2.打开目标文件-执行读取操作-打开要写入的新文件-执行写入操作-关闭文件
139. 重要名文件：
140. Os.rename(src,dst)
141. Os.rename(‘123.txt’,’124.txt’)
142. 删除文件
143. Os.remove(path)
144. Os.remove(‘123.txt’)
145. 创建目录
146. Os.mkdir()
147. 创建多级目录
148. Os.makedirs()
149. 删除目录
150. Os.rmdir()
151. 删除多级目录
152. Os.removedirs()
153. 获取当前目录
154. Os.getcwd()
155. 修改所在目录
156. Os.chdir()
157. 判断文件是否存在
158. Os.path.exists()
159. 判断是否为文件
160. Os.path.isfile()
161. 判断是否为目录
162. Os.path.isdir()
163. 获取绝对路径
164. Os.path.abspath()
165. 判断是否为绝对路径
166. Os.path.isabs()
167. 获取路径的最后部分
168. Os.path.dirname()
169. 获取父级路径
170. Os.path.dirname()
171. 获取文件夹内的子文件名
172. Os.listdir()
173. 获取文件大小
174. Os.path.getsize(file)
175. 异常：在程序执行的过程中，遇到解释器无法解决的问题，导致程序无法继续执行
176. raise 异常对象
177. 什么是设计模式：
178. 一些现有的比较成熟解决固定问题的套路（方法方式）
179. 使用设计模式
180. 好处：1.结构更加合理，降低代码的耦合度（冗余度）

181.   2.更加容易维护，更容易拓展
     

182. 弊端：缺乏一定的灵活性
183. 单列模式：业务的核心保证对象的唯一性
     进程：
     正在运行的程序，在操作系统眼中，会被看作一个进程，有唯一的进程id,要想操作系统申请单独的内存空间
     多个进程之间互相独立
     多进程： ，
     两个任务同时执行：
     并行：同一时间碎片，绝对的同时执行
     并发：同一时间碎片，只能处理一个，多个任务，交替执行
     如何使用多进程，处理多任务：
     好处：效率高
     弊端：更消耗系统资源
     注意：开辟子进程，会将主进程中所有的资源复制一份新的，在子进程中独立运行
     获取当前的进程：注意（不能对同一个进程开启两次）
184. 进程生命周期中的几种状态
185. 创建（出生），就绪start()之后，进程进入就绪状态，等待被调度
186. 执行：cpu执行关联的任务
187. 阻塞：sleep 等待IO
188. 结束（死亡）进程结束或者手动结束terminate
189. 进程队列：

190.      Multiprocessing.Queue
     

191.      原理：FiFO:先进先出
     

192.      入队：put()队满，继续出队或导致阻塞
     

193.     出队：get()队空，继续出队或者导致阻塞
     

194.     队长：qsize()
     

195.     队满：full()
     

196.     队空：empty()
     

197. Multiprocessing.Pool
198. 进程池
199. 同步：多个任务顺利执行，同一时间只有一个任务执行，其他任务阻塞
200. 异步：多个任务可以同时执行
201. 创建进程池：

202. Pool([processes[,initializer[,maxtasksperchild[,context]]]])
     

203. 同步操作，他会阻塞，直到结果就绪
204. Apply(func[,args[,callback[,error_callback]]])
205. Close()
206. Join对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了
207. 线程的使用：
208. 线程：threading.Thread
209. 进程：运行中的程序，系统分配单独的内存，多个进程之间相互独立，系统分配资源的基本单位
210. 线程：轻量级的进程，一个进程中至少包含一个线程（主线程），线程是系统调度的基本单元，多个线程之间，共享当前进程分配的系统资源
     进程与线程：
     一个进程至少包含一个线程（主线程）,一个进程中可以存在多个线程（子线程）
     多线程的用途：处理多任务，提高效率
     Join()阻塞其他任务，让当前线程执行完毕，其他的在执行，注意放在线程开启之后

SetDaemon(True)设置守护线程
Thread(target=func,daemo=True)设置当前线程为守护线程
注意：守护线程的设置，放在线程开启之前
查看当前程序中（进程中）线程的情况theading.active_count()
Theading.activeCount()
获取当前线程：threading.currentThread()
Threading.current_thread()
设置线程名字
setName()
获取线程名字：
GetName()
28. 互斥锁：Lock() 获取锁资源 locked
29. 上锁acquire()—bool
30. 释放锁资源 unlock 解锁 release()
31. 好处：1.数据保护 2.防止数据混乱
32. 弊端：
33. 1.频繁的获取锁资源，释放锁，耗时‘
34. 2.有可能会导致死锁
35. 死锁：两个线程互相等待对方的资源，两个线程同时进入阻塞状态
36. 死锁的原因：嵌套互斥锁的使用
37. 解决方案：1.actuire(blocking=bool,timeout=int)
38. Blocking=False设置不阻塞
39. Timeout=2设置超时时间
40. 进程队列：multiprocess.Queue
41. 线程队列：queue.Queue，先进先出队列
42. LifoQueue
43. 后进先出
44. PriorityQueue
45. 优先队列
46. GIL:global interpreter lock
47. 全局解释器锁
48. CPython中的特性：
49. 好处：提高并发访问的安全性（多个线程之间，同时只允许一个python解释器运行）
50. 弊端：牺牲多核优势
51. Python中的多线程为伪多线程
52. 在实际应用中，如何合理的选择多任务方式
53. 1.多进程
54. 2.多线程
55. 任务分类；
56. 1.运算密集型（CPU密集型）
57. 采用多进程处理
58. 2.IO密集型
59. 采用多线程处理
60. 协程：1.yield:使用yield关键字实现两个任务的交替执行
a) 2。1-N模式
b) 一个线程可以存在‘任意’多个协程
c) 3.切换效率非常高，几乎不开销系统资源，上下文的切换
d) 协程模块：
e) 模块的分类：
f) 内建模块
g) 系统标准模块
h) 第三方
i) 自定义模块 gevent
网络三要素：

1. ip ： ip地址作用：区别网络中的不同计算机
2. ipv4
3. ipv6
4. 原因：网卡

5.    以太网卡，物理地址：12位16进制的数字来组成
   

6.    同一个号段内ip数量：0-255
   

7. 端口，作用：区分电脑上不同的软件
8. 范围：0-65535
   默认被占用（系统预留:0-1023’）
   协议：标准
   Http/https
   TCP/TP协议族
   应用层 http
   传输层 udp/tcp
   网络层 ip
   物理层 ppp
   传输层协议：
   UDP/TCP
   基于UDP协议的套接字通信
   套接字（socket）
   网络传输的工具
   发送方：
9. 创建套接字
10. 确立接收方的ip地址以及端口
11. 发送
12. 关闭套接字
    传输层协议：
    UDP/TCP
    基于UDP协议的套接字通信
    套接字（socket）
    网络传输的工具
    接收方：
13. 创建套接字
14. 绑定ip地址跟端口
15. 接收数据
16. 解码处理
17. 关闭套接字
    UDP协议：
    广播协议，不需要建议连接，发送效率非常高，但是，发送过程中缺乏安全验证机制，容易丢包
    TCP协议：
    面向连接的协议，电话协议（1对1），发送效率相对比较低，发送的数据包有大小限制，但是，传输过程中有数据验证，重发等机制，安全性比较高
    建立连接：（客户端连接服务器）
    三次握手
    断开连接：
    四次挥手
    TCP协议：
    建立连接：三次握手
    断开连接：四次挥手
    基于TCP的套接字通信
    客户端：
18. 创建套接字
19. 建立连接 connect()
20. 发送数据send()
21. 关闭套接字 close()
    服务器：
22. 创建套接字
23. 绑定ip地址跟端口bind
24. 开启监听listen
25. 开始接受（阻塞）socket,addr=accept()
26. Data = socket.recv(1024)
27. 套接字关闭
    TCP协议：
    建立连接：
    三次握手
    断开连接
    四次挥手
    基于TCP的套接字通信
    客户端:
28. 创建套接字
29. 建立连接 connect()
30. 发送数据 send()
31. 关闭套接字 close()
    衡量算法的优劣：
    空间复杂度
    时间复杂度
    查找：
32. 顺序查找
33. Find()
34. Rfind()
35. Index()
36. Rindex()
37. chax
38. 前提要求：

39.   要求有序数列
    

40.   循环
    

41.  递归实现
    

42. 排序算法：
43. 比较 交换 冒泡 大的往后放 选择 小的往前放
44. 线性表：顺序表，列表 连续内存 ----》查询：高 插入：较低 删除：较低
45. 链表：可以充分使用碎片化内存
46. 查询：较慢/ 删除：高 插入：高
47. 链表的分类：
48. 单向 单向循环
49. 双向 双向循环
50. 栈与队列
51. 栈：分类：顺序栈，链栈 工作原理：先进先出 基本操作：入队，出队，队长，队满，对空
52. 树状结构：

53.    1.树的遍历：
    

54.    1.层序遍历
    

55.    2.先序：根 左 右
          3.中序：左 根 右
          4.后续：左 右 根
    

内存管理机制：GC（垃圾回收）机制
引用计数机制（90%）
引用计数
查看引用计数
Sys.getrefcount()
增加引用计数
A2=a1
List.append(a1)
作为函数参数
减少引用计数
Del
List.remove()
函数调用结束
隔代回收机制（10%）