python基础知识你学会了多少
程序员文章站
2022-07-23 23:26:37
前言 学习是一个循序渐进的过程，不在于你学了多少，而在于你学会了多少。(装个b好吧，hhhh) 知识总结 之前一直想在网上找一个总结好的笔记，但是一直都没有找到，因此下定决心要总结一下，里面的都是在学习的过程中学到的一些最基础的一些概念啊，类型啊，方法啊之类的额，真的是花费了不少的时间，当然大佬请绕 ......
前言
学习是一个循序渐进的过程，不在于你学了多少，而在于你学会了多少。(装个b好吧，hhhh)
知识总结
之前一直想在网上找一个总结好的笔记，但是一直都没有找到，因此下定决心要总结一下，里面的都是在学习的过程中学到的一些最基础的一些概念啊，类型啊，方法啊之类的额，真的是花费了不少的时间，当然大佬请绕过好吧。。
1 概念
2 1. 编程
3 语言是一个事物与另外一个事物沟通的介质，编程语言是程序员与计算机沟通的一个介质。
4 编程就是程序员用计算机能够理解的表达方式（编程语言）来讲自己的思维逻辑写下来的一个过程。
5 编程的结果就是产生了一堆的文件，我们把这些文件称之为软件或者程序。
6 2. cpu, 内存，硬盘
7 cpu，内存，硬盘统称为计算机的三大核心硬件。cpu主要主要用来计算，内存和硬盘用来存储。出现两种存储硬件的格式主要是因为cpu的计算速度很快，而硬盘的
8 读写速度很慢，为了更加高效的利用cpu的资源就出现了一种中间的存储也就是内存。但是内存不能持久化存储，断电易丢失。因此，在读取数据的时候就出现了
9 这样一种现象，数据从硬盘读取到内存，然后通过cpu操作内存来实现一系列的操作。
10 3. 运行程序，硬件的工作过程
11 1. 程序保存在硬盘中
12 2. 程序要运行必须先加载到内存
13 3. cpu从内存中读取指令,然后翻译执行
14 4. 进制之间的转换
15 名词：bit，bytes, kbytes, mbytes, gbytes, tbytes
16 1bytes = 8bit
17 1kbytes = 1024bytes
18 1mbytes = 1024kbytes ...依次类推
19 5. 操作系统
20 操作系统是一个协调\管理\控制计算机硬件资源与软件资源的一个控制程序。可以把复杂的硬件操作封装成简单的功能接口用来给用户或者应用程序使用，
21 以及合理的管理应用程序之间的资源分配。
22 6. 编程语言的分类
23 机器语言: 直接使用二进制指令编写的程序，运行效率非常高，但是开发效率非常低。
24 汇编语言: 使用一些英文的标签来代替二进制指令去编写的程序，比机器语言的开发效率高，但是开发效率比起高级语言要低很多。
25 高级语言: 直接使用人能够理解的表达方式去编写程序，开发效率比机器语言和汇编语言都要搞，但是执行效率很低。
26 编译型语言: 执行效率高于解释型语言，开发效率低于解释型语言。
27 解释性语言: 执行效率低于编译型语言，开发效率高于编译型语言。
28 总结：
29 执行效率： 机器语言>汇编语言>编译型语言>解释型语言
30 开发效率： 机器语言<汇编语言<编译型语言<解释型语言
31 7. 执行python程序的两种方式
32 (1).交互式环境: 输入代码立即执行，但是不能保存文件
33 (2).写入文件: 可以保存文件
34 8. 变量: 是用来记录当前事物的某种状态，之后状态可以进行变化。
35 变量的命名规范
36 (1).字母数字下划线
37 (2).不能以数字开头
38 (3).对变量值有一定的描述性功能
39 (4).不能是python中的关键字
40 变量名的命名风格
41 (1).驼峰体
42 (2).下划线纯小写
43 变量的三个特征
44 (1).id 内存地址
45 (2).type 变量的类型
46 (3).value 变量的值
47 常量
48 常量的命名规范: python中默认是没有常量的，只是约定俗成的全大写的就是变量，我们不应该对其进行修改。
49 9. 引用计数
50 是python垃圾回收机制引入的一个名词，主要是用来显示当前变量值被关联的次数，如果为0，就会被python自动进行回收。
51 10. 数据类型
52 数据指的是变量的值，数据类型指的是变量值的类型。在日常生活中事物有多种形态，对应于程序中也应该有多种形态，也就是多种类型。
53 11. python2和python3的区别
54 (1).input和raw_input,python2中的input必须要输入明确的数据类型，输入的是什么输出就是什么
55 (2).编码python2:ascci, python3:utf-8
56 (3).print()和print
57 12. 运算
58 算数运算：+-*/ // % **
59 比较运算: 只能在同类型之间进行比较，int和float都属于数字类型
60 赋值运算
61 增量赋值:类似于a += 1这种形式
62 链式赋值:类似于a = b = 1这种形式
63 交叉赋值:类似于x, y = y, x这种形式
64 解压赋值:类似于a, b, c, d = [1, 2, 3, 4], 多了少了都不行
65 逻辑运算:判断顺序: 比较运算>not>and>or
66 身份运算:is比较的是两个变量值的地址，==比较的是两个变量值的值
67 13. 运行python程序的三个步骤
68 (1).打开python解释器
69 (2).将硬盘中的python程序加载到内存中(前两不就和正常的读取文件一样)
70 (3).检测python语言并执行(这一步才开始正式的读取python的语法)
71 14. 小整数池
72 小整数池是python中为了节省内存空间而创建的一种机制，也就是说在一定的数据范围内，无论创建了多少分，使用的都是这一个地址。
73 15. if判断的四种语法
74 (1). if 条件:
75 code
76 (2). if 条件:
77 code
78 else:
79 code
80 (3). if 条件:
81 code
82 elif 条件:
83 code
84 (4). if 条件:
85 if 条件:
86 code
87 16. 结束while循环的两种方式
88 (1): 通过条件的更改最终使得进入while循环的条件不满足
89 (2): 通过break关键字跳出循环
90 17. while else的用法
91 格式:
92 while 条件:
93 code1
94 else:
95 code2
96 当while循环因为条件不满足而正常退出的时候，会执行code2的代码
97 18. for循环主要用来做什么
98 python语言中真正的循环只有while一个，也就是说所有的事物都是可以通过while循环去获得值得，for循环主要是用来做循环取值的。
99 19. 可变类型与不可变类型是按照什么标准划分的
100 通过改变变量的值来看内存地址是否发生改变来划分的。
101 不可变类型: int,float,str,tuple 值变内存地址也变
102 可变类型: list,dict,set 值变内存地址不会发生改变
103 20. 计算机系统分为哪三层
104 (1).应用程序层
105 (2).操作系统层
106 (3).计算机硬件层
107 21. 字符编码
108 人类与计算机打交道用到的都是人类的字符，而计算机只能识别二进制，因此我们需要将人类的字符编码成计算机能够识别的语言，
109 从而实现人机的交互。而字符编码表就是将人类的字符与计算机二进制进行一一对应的关系表。
110 编码和解码
111 我们通过字符编码表将人类的字符转换成计算机能够识别的字符的过程就叫做编码
112 我们通过字符编码表将计算机的二进制代码转换成我们的能够识别的字符的过程叫做解码。
113 存在的一些字符编码表
114 ascii 只能识别英文
115 gbk 1bytes代表英文， 2bytes代表中文
116 unicode 全部都是2bytes
117 (1).能够兼容万国编码
118 (3).与各个国家的字符编码都有一一映射关系
119 utf-8 1bytes代表英文，3bytes代表中文
120 它只是unicode的一种转换格式，并不能与各个国家的语言进行一一的映射
121 解决乱码的核心法则
122 用什么编码方式编码的就用什么编码方式进行解码
123 python2默认的编码方式：ascii
124 python3默认的编码方式：utf-8
125 #coding:文件头的两个作用
126 (1):告诉程序员当前程序应该以什么样的编码方式进行存储
127 (2):告诉python解释器在加载当前程序的时候应该以什么样的编码方式进行解码。
128 22. 字符编码的操作核心法则（3条）
129 (1).python2中如果出现中文前面加上u。 eg: a = u'中国'
130 (2).在文件开头要写上 #coding:utf-8
131 (3).python3通过encode编码之后可以得到bytes类型
132 23. 文件
133 文件是操作系统帮我们虚拟出来的一个可以操作计算机硬盘的一个接口。我们可以通过操作系统将对文件的操作转换成对硬盘的操作，
134 从而将应用程序持久化存储起来。
135 24. 文件处理的三个步骤
136 (1).通过关键字open打开系统调用得到一个文件句柄(应用程序的内存资源===>操作系统的内存资源)
137 (2).操作文件（读和写）
138 (3).通过close关闭一个文件句柄，也就是回收操作系统的资源。
139 25. 上下文管理的方式
140 通过with open关键字打开一个文件，从而得到一个文件句柄，我们不再需要去关注什么时候应该关闭掉文件，因为
141 上下文管理会自动帮我们关闭文件，从而回收操作系统资源。
142 26. 操作文件内容的三种纯净模式
143 r: (默认的)只读模式，文件不存在则报错。
144 w:只写模式，文件不存在则创建，存在则清空写入
145 a:只写模式，文件不存在则创建，存在则追加写入
146 27. 控制文件内容格式的两种模式
147 t文本模式:
148 (1).只能针对文本文件
149 (2).读写文件都是以字符串为单位的
150 (3).必须指定encoding
151 b:二进制模式
152 (1).针对所有文件
153 (2).读写文件都是以字节为单位的
154 (3).不能指定encoding
155 28. 文件指针移动的单位是字节还是字符
156 只有在rt模式下移动的是字符，其余的都是字节模式
157 29. 文件是否可以修改？
158 文件准确来说是磁盘的映射，磁盘不能改，文件当然也就不能进行修改。但是我们可以通过以下的方式进行间接的修改
159 方式一: 将磁盘的文件一次性的读入内存中，在内存中修改完成之后再覆盖写入到硬盘空间。
160 优点: 同一时间内硬盘中不会存在两个文件。
161 缺点: 文件太大的时候会占用更多的内存空间。
162 方式二: 以读的方式一行一行的读入到内存中，然后一行行修改重新写入到一个临时文件中，最后将源文件删除，临时文件的名称改成源文件的名称
163 优点: 占用系统内存较少
164 缺点: 同一时间硬盘空间中数据会存在两份。
165 30. 函数
166 函数就是实现某一功能的代码块。通过函数我们可以解决代码冗余的问题，从而提高程序的可扩展性以及可读性。
167 31. 函数的分类(2类)
168 (1).内置函数: python解释器帮我们编写好的为了实现某种功能的函数，可以不用定义直接进行使用。
169 (2).自定义函数: 自己自定的为了实现某一个功能的函数。
170 32. 使用函数的原则
171 先定义后调用
172 33. 函数的两个明确阶段
173 (1).函数定义阶段
174 (2).函数调用阶段
175 34. 函数定义的三种形式
176 (1).有参函数
177 (2).无参函数
178 (3).空函数
179 35. 函数调用的三种形式
180 (1).语句的形式 func()
181 (2).表达式的形式 res = func() * 12
182 (3).当做参数传递的形式 res = max(max(1, 2), 3)
183 36. return的特点
184 return返回值:
185 (1).没有类型的限制
186 (2).没有个数的限制
187 <1>返回0个或者没有返回 都是none
188 <2>返回1个 就是值本身
189 <3>返回多个 是个元组
190 return结束函数的功能，可以有多个return，但是只会执行一次
191 37. 函数参数的两大类
192 形参（形参又分为哪四类）: 在函数定义阶段，括号内定义的参数
193 位置形参: 按照从左到右的顺序依次定义的形参
194 <1>: 必须传值，不能多不能少
195 默认形参: 按照key=value的形式定义的形参
196 <1>: 可以传值，也可以不传值
197 <2>: 默认形参必须在位置形参后面
198 <3>: 默认形参的值在函数定义阶段就已经固定死了，定义阶段后的改动不会影响该值
199 <4>: 默认形参的值通常应该是不可变类型
200 可变长形参:
201 *argv:*会将溢出的位置实参存成元组的形式，然后赋值给*后的argv
202 **kwargvs: **会将溢出的关键字实存成字典的形式，然后赋值给**后面kwargs
203 命名关键字形参
204 实参（实参又分为哪三类）: 在函数调用阶段，括号内定义的参数
205 位置实参
206 与位置形参一一对应
207 关键字实参
208 <1>: 关键字实参必须放在位置实参的后面
209 <2>: 不能重复传值
210 可变实参: 指的是在调用阶段，实参值个数是不固定的,
211 38. 为什么说函数是第一类对象？
212 函数的内存地址可以像一个变量值一样去使用。
213 39. 函数与变量的四种使用方式
214 <1>.赋值
215 <2>.当做参数进行传递
216 <3>.作为返回值返回
217 <4>.可以当做容器类型的参数 应用: 功能字典
218 40. 函数的嵌套定义以及其应用场景
219 函数的嵌套定义: 指的是在一个函数内重新定义多个函数，但是不会进行调用。
220 应用场景: 可以将一系列相关的功能封装到一块提供给用户进行使用。例如: 对于园的一些操作求周长面积等封装到一个函数里面。
221 41. 函数的嵌套调用以及其应用场景
222 函数的嵌套调用: 指的是在一个函数内调用了其他的函数。
223 应用场景: 主要是用来将一个复杂的过程分成好几个函数同时来完成，最后通过一个函数进行封装。
224 42. 什么是名称空间
225 名称空间指的是存放变量名与内存地址绑定关系的地方。
226 43. 名称空间的分类（三类）
227 <1>.内置名称空间
228 解释器启动的时候就会产生，解释器关闭的时候就会销毁
229 <2>.全局名称空间
230 python程序执行的时候产生，python程序执行完毕之后销毁
231 <3>.局部名称空间
232 函数调用时临时产生，函数调用完毕之后则销毁
233 44. 名称空间的产生顺序
234 内置名称空间---> 全局名称空间_---> 局部名称空间
235 45. 名称空间的销毁顺序
236 局部名称空间---> 全局名称空间_---> 内置名称空间
237 46. 什么是作用域
238 作用域指的是变量名的作用范围
239 47. 作用域的分类（两种）
240 全局作用域: 包含了全局和内置名称空间的名字
241 全局存活，全局有效
242 局部作用域: 包含了局部命名空间的名字
243 临时存活，局部有效
244 48. 作用域关系的核心要义（一句话）
245 作用域关系在函数定义阶段已经定义死了，与函数调用无关。
246 49. 什么是闭包函数
247 在函数内部定义了一个函数，该函数又包含了对外层函数名字的引用。
248 50. 为函数体传值的两种方式（分别的特点）
249 (1). 通过参数进行传值 每次调用都要进行传值
250 (2). 通过闭包函数进行传值 可以传一次得到一个返回值，之后直接调用返回值就可以，在某些方面可以简化用户的操作
251 51. 什么是装饰器
252 为原函数增加新的功能的工具就是装饰器。我们可以通过装饰器在不修改功能源代码以及其调用方式的情况下为原函数增加新的功能。
253 加载装饰器就是将原函数名偷梁换柱成了装饰器最内层那个wrapper函数
254 # 在加载完毕后，调用原函数其实就是在调用wrapper函数
255 52. 装饰器的分类（两大类）
256 <1>有参装饰器
257 <2>无参装饰器
258 53. 什么是语法糖
259 语法糖(syntactic sugar)是指编程语言中可以更容易的表达一个操作的语法，它可以使程序员更加容易去使用这门语言：
260 操作可以变得更加清晰、方便，或者更加符合程序员的编程习惯
261 54. 装饰器的语法糖
262 @装饰器的名字:要在被装饰对象正上方单独一行写上
263 55. 有参装饰器的模板
264 def outter2(x,y,z):
265 def outter(func):
266 def wrapper(*args,**kwargs):
267 res=func(*args,**kwargs)
268 return res
269 return wrapper
270 return outter
271 56. 无参装饰器的模板
272 def outter(func):
273 def wrapper(*args,**kwargs):
274 res=func(*args,**kwargs)
275 return res
276 return wrapper
277 57. 叠加装饰器的加载顺序
278 自下而上
279 58. 叠加装饰器的执行顺序
280 自上而下
281 59. 什么是迭代器
282 迭代器就是一个迭代取值的工具，该工具的特点就是可以不依赖索引取值。
283 60. 迭代器的两个优点
284 <1>.提供了一种通用的不依赖索引的迭代取值方式
285 <2>.同一时刻在内存中只有一个值，更加节省内存
286 61. 迭代器的两个缺点
287 <1>.没有索引取值灵活，并且迭代器是一次性的
288 <2>.无法预知迭代器数据的个数
289 62. 什么是可迭代对象
290 但凡是有__iter__方法的都是可迭代对象，调用可迭代对象的__iter__方法可以得到一个迭代器对象。
291 63. 什么是迭代器对象
292 有__iter__和__next__方法的都是迭代器对象，调用迭代器对象的__iter__方法会得到它本身
293 64. python中的可迭代对象有哪些（6个）
294 list, tuple, dict, set, 文件对象, str
295 65. python中的迭代器对象有哪些（1个）
296 文件对象
297 66. for循环本质上是个迭代器循环，原理是什么（3步）
298 <1>.会调用对象__iter__将迭代器对象或者可迭代对象转换成迭代器对象
299 <2>.调用迭代器对象的__next__方法取值并且赋值给变量，运行循环体代码
300 <3>.循环往复，直到迭代器取值完毕之后抛出异常然后捕捉异常自动结束循环
301 67. 什么是生成器
302 生成器本质上就是一种迭代器，不过它是程序员自己通过yield关键字创建出来的一种迭代器对象。
303 68. python中提供生成器的关键字
304 yield，一旦函数中包含yield关键字，当我们去执行此函数的时候，就不会立刻的运行函数体代码了，会得到一个返回值，
305 该返回值就是一个生成器对象。
306 69. 三元表达式
307 a = x if x > y else y
308 70. 列表生成式
309 l = [i ** 2 for i in range(9) if i > 5]
310 71. 生成器表达式
311 c = (i**2 for i in range(3))
312 72. 字典生成式
313 d = {k:v for k,v in dd if k != 'sex'}
314 73. 什么是匿名函数
315 顾名思义: 没有名字的函数就是匿名函数。有些功能我们使用一次就不在使用了，所以我们需要匿名函数。
316 74. 匿名函数的应用场景（2个）
317 <1>.用在一些内置函数中当做参数, 例如: max,min,sorted,filter,reduce,map
318 <2>.
319 75. 什么是函数递归
320 函数的递归就是函数嵌套调用的一种特殊用法，特殊在调用一个函数的过程中又直接或者间接地调用了该函数本身。我们可以通过
321 在某些条件下使用递归要比使用while循环更加的简单。
322 76. 递归要满足的两个原则
323 <1>.每进入下一层递归，函数的规模都应该有所减少
324 <2>.递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件
325 77. 递归的两个明确的阶段
326 <1>.回溯:一层一层地递归调用下去
327 <2>.递推:在某一层结束掉递归，然后一层一层返回。
328 78. 什么是面向过程编程
329 面向过程的核心在过程二字，基于该思想写程序脑子里应该始终思考过程二字，就好比设计一个流水线，是一种机械式的思维方式
330 79. 面向过程编程的优点和缺点
331 优点: 将复杂的问题流程化，进而简单化
332 缺点: 扩展性差
333 80. 什么是面向对象编程
334 面向对象的核心在对象二字，基于该思想写程序就像是在创造一个世界，世界里的一切都是对象，是一种上帝式的思维方式。
335 81. 面向对象编程的优点和缺点
336 优点:扩展性强
337 缺点: 编程较为复杂
338 82. 什么是模块
339 模块就是一组功能的集合，本质上就是一个py文件。
340 83. 模块的作用
341 让我们可以从文件级别去管理我们的代码。可以提高我们程序的可维护性与可读性。
342 84. 模块的分类（4类）
343 <1>.内置模块
344 <2>.自定义模块
345 <3>.包
346 <4>编译为dll的c或者c++
347 85. 模块导入的两种方式，区别是什么
348 <1>.import导入
349 <2>.from ... import导入
350 86. import导入模块的三个步骤
351 <1>.在当前模块中创建一个名称空间
352 <2>.执行模块中的代码，将名称和地址的对应关系存储到名称空间中
353 <3>.在执行文件中产生一个新的名称指向被导入的名称空间
354 87. import导入的三种语法
355 <1>. import 模块名
356 <2>. import 模块名1, 模块名2
357 <2>. import 模块名 as mmm
358 88. from导入模块的三个步骤
359 <1>.在当前模块中创建一个名称空间
360 <2>.执行模块中的代码，将名称和地址的对应关系存储到名称空间中
361 <3>.复制被导入模块中的名称到当前名称空间中，之后可以直接进行使用
362 89. from导入模块的三种语法
363 <1> from 模块 import 变量
364 <2> from 模块 import 变量1, 变量2
365 <3> from 模块 import 变量1 as mmm
366 <4> from 模块 import *
367 90. 模块的搜索顺序
368 内置模块--->内存中已经加载的模块--->sys.path中已经存在的模块
369 91. 什么是包
370 包是一堆模块的集合。
371 92. __init__文件是干什么用的
372 导入该包内的所有模块，用户使用起来较为简单，无需关系包内的东西，只需要导入__init__就可以使用包内的所有模块。
373 93. __init__文件应该包含哪些内容
374 仅仅只是用于导入包内的模块，不应该包含任何的业务逻辑。
375 94. 包的作用
376 我们可以从文件夹的级别去管理我们的代码。提高可读性与维护性。
377 95. 相对导入和绝对导入
378 相对导入:相对于被导入模块的路径, .表示当前目录 ..当前往上一级目录
379 绝对导入:从sys.path开始的完整路径称之为绝对导入
380 96. 相对路径和绝对路径
381 97. 文件的两种执行方式，区别是什么？
382 <1>.直接通过python解释器调用执行, __name__的值为__main__
383 <2>.通过模块的导入执行的, __name__的值为模块名
384 区别在于__name__的值不一样
385 98. 什么是对象
386 对象是特征与技能的结合体。
387 99. 什么是类，面向对象编程为什么要有类
388 类是一系列对象的相同特征与技能的结合体。在现实世界中是先有对象才有类的，但是在程序中，是先有类，才有对象的。
389 100. 什么叫做面向对象是更高程度的一种封装
390 将一系列的特征与技能封装到一个对象上面，只需要将对象给你，你就可以得到对象的特征和技能。
391 101. 类的两种用途
392 <1>.类本质上就是一个名称空间，我们可以通过类对名称空间进行增删改查
393 <2>.用来创建对象，
394 (1).创建一个空对象
395 (2).创建对象的过程会自动的调用__init__方法，然后将对象本身作为第一个参数传递进去。
396 102. __init__方法在什么时候会被触发
397 在创建对象的时候会被自动的触发，并把空对象作为第一个参数传递给类。
398 103. python3中类与类型是一个概念吗
399 python3中统一了类与类型的概念
400 104. 什么是继承
401 子类可以重用父类的属性就叫做继承，它描述的是一种遗传的关系。我们可以通过继承来减少代码之间的冗余。
402 105. 什么是组合
403 一个对象的属性来自于另外一个对象的现象就称之为组合，也是为了减少类与类之间代码的冗余。
404 106. 什么是多态
405 描述的是一种事物的多种形态，在代码中主要为了统一标准。我们可以在不考虑对象的类型的情况下直接去使用对象下的方法。
406 107. 什么是封装
407 将类的数据属性进行隐藏的一种过程，这种隐藏并不是单纯的隐藏，是对内不对外的。
408 108. 继承分为哪两类， 区别是什么
409 <1>.单继承
410 <2>.多继承
411 109. 类分为哪两类， 区别是什么
412 <1>.新式类: 继承了object类的子类，以及子类的子类...都称为新式类。
413 <2>.经典类: 没有继承object类的子类，以及子类的子类...都称之为经典类。
414 在python2中才会区分新式类和经典类，python3中默认都是继承object类的新式类
415
416 110. 重用父类功能的两种方式， 分别有什么特点
417 <1>.指名道姓的访问某个类中的问题，与继承无关。
418 <2>.通过super(父类，self)方法去调用父类中的__init__方法，严格依照继承的关系
419 调用super方法会得到一个特殊的对象，该对象是专门用来访问父类中的属性的，super会严格按照mro列表进行查找。
420 111. 单继承背景下属性的查找顺序
421 对象--->子类---->父类--->object类
422 112. 多继承背景下属性的查找顺序（两类）
423 菱形继承
424 新式类:会从左到右，当左右的分支都查找不到的时候才会去查找聚合点
425 经典类:会从左到右，但是在第一个分支的时候就会把聚合点给查找
426 非菱形继承
427 从左到右依次查找，一个分支查找完成之后才会查找另一个分支
428 113. 封装的特点是什么？
429 封装不是单纯意义上的隐藏，对外不对内的。
430 114. 封装数据属性的目的
431 将数据属性封装起来,类外部的使用就无法直接操作该数据属性了
432 需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格
433 控制使用者对属性的操作
434 115. 封装函数属性的目的
435 隔离复杂度
436 116. 隐藏的__开头的属性有哪些特点（4个）
437 (1). 只是一种语法意义上的变形,即__开头的属性会在检测语法时发生变形_类名__属性名
438 (2). 这种隐藏式对外不对内的,因为在类内部检测语法时所有的代码统一都发生的变形
439 (3). 这种变形只在检测语法时发生一次,在类定义之后新增的__开头的属性并不会发生变形
440 (4). 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头
441 117. property装饰器主要是用来解决什么问题的
442 有一些属性会跟随数据属性变化而变化，因此我们要把它设计成方法属性，为了让用户使用的时候像使用数据属性一样的，我们就需要在
443 方法上面加上@property
444 118. 什么是绑定方法与非绑定方法
445 绑定方法:
446 绑定对象的方法
447 绑定类的方法
448 非绑定方法: 就像正常的函数一样
449 119. classmethod装饰器是用来绑定什么的
450 绑定类的
451 120. staticmethod装饰器是用来绑定什么的
452 绑定对象的
453 121. 什么是反射？
454 反射就是想通过字符串的形式来对对象的属性进行增删查改
455 122. 反射的四个方法（增删改查）
456 hashattr(obj, 'name')
457 setattr(obj, 'name', 'egon')
458 delattr(obj, 'name')
459 getattr(obj, 'name')
460
461 组件
462 is 比较的是两个地址
463 == 比较的两个变量的值
464 id 打印出来的是变量的内存地址信息
465 input python中交互关键字
466 global 全局变量
467 nonlocal
468 __all__ 在模块的导入过程中，我们可以通过__all__来控制外部可以使用此模块的哪些内容
469 __name__ 执行文件的两种方式会导致__name__的值不一样, 直接执行__name__==__main__,导入模块执行会__name__等于模块名
470 sys.modules 当前内存中加载的模块名称mdcmd,是字典的形式
471 sys.path 当前的系统路径,不是内置模块，内存中也不存在此模块的时候，就会按照顺序到sys.path这个列表中去查询
472 __init__方法 在类中出现的，当创建对象的时候会自动的调用此方法，并把创建的空对象当做第一个参数传递进去
473 __init__文件 在包中出现的，用来导入包内的其他模块。在导入包的时候其实执行的__init__模块
474 __dict__ 对象或者类去查看名称空间用的，是一个字典
475 __file__ 当前文件的绝对路径,(win中也就是从盘符开始的路径)
476 super函数 目前学到的只是继承父类的属性的时候用到的，super(父类名，self).方法名, 会给我们返回一个特殊的对象，按照mro列表中的顺序进行属性查找的。
477 __str__ 在类中创建一个__str__方法, 一定要有返回值，否则会报错，这样直接print(对象)的时候会给我们打印返回的值
478 __del__ 在类中创建一个__del__方法，在方法中删除系统资源，代表在对象被删除的时候会给我们自动的删除没有被回收的系统资源
479 continue: 不执行当前continue之后的代码, 直接进入下一次循环, 不应该将continue作为最后一步执行的代码
480 break 跳出当前循环
481 while...else 不是因为break而跳出循环的时候就会执行else的代码
482 a, b, *_ = [1, 2, 3, 4] 在解压赋值的时候，如果我们不想要后面的一些值就需要以这样的方式来书写
483 __iter__ 在迭代器和可迭代对象的时候学习的，使用此方法之后会把可迭代对象转换成迭代器对象
484 __next__ 具有此方法的对象都是迭代器对象，我们可以通过这个方法获得迭代器对象的值
485 lambda 匿名函数 lambda 参数一, 参数二: 表达式 返回值就是表达式的值
486
487
488 数据类型
489 进制之间的转换问题：
490 hex(256) 十进制转成十六进制 将十六进制转成十进制int('0x100', 16)
491 oct(256) 十进制转成八进制 将八进制转成十进制int('0o400', 8)
492 bin(256) 十进制转成二进制 将二进制转成十进制int('0b100', 2)
493 int
494 int() 没有参数就返回0
495 int(0.7) 是浮点就省略后面的值
496 int('1') 字符串转换只能是里面只能是整形
497 float
498 float() 没有参数返回0.0
499 float('1')
500 float('1.1') 字符串可以带有小数点
501 str 任何类型都是可以转换成字符串类型的
502 strip() 去除两边的特定字符，可以去除多个字符'abcdefabc'.strip('abc')===》'def'
503 split() 以特定的字符分割字符串s.split('*', 2) # 从左往右以*为分割点分割两次
504 join() 将列表，元祖，字典转换成str的方法，拼接的值里面必须是字符串类型的，否则会报错
505 endswith 以什么结尾
506 startswith 以什么开始
507 upper 全部变成大写
508 lower 全部变成小写
509 replace 参数一为旧值，参数二为新值，参数三为替换的次数，默认是全部
510 find, index 找对应的索引，index找不到报错，find找不到返回-1，找到的时候返回索引的位置
511 rfind, rindex 其实就是找最后一个的索引位置
512
513 不常用的方法：
514 captilize 第一个字符大写 '*ab'.capitalize()===》'ab'
515 title 每个单词首字母大写 'abc*ab'.title()===》'abc*ab'
516 swapcase 大小写反转
517
518 center() 第一个参数是个数，第二个参数是字符
519 ljust s.ljust(10, '*')====>hello*****
520 rjust s.rjust(10, '*')====>*****hello
521 zfill 在字符串左边 填充0
522 list 任何可迭代类型的数据都可以被转换成列表
523 修改的方法
524 增: append，insert, extend
525 append 把一个整体添加到列表的最后面
526 insert 把一个数据整体的添加到索引的位置上面，第一个参数是索引，第二个参数是数据
527 extend 把可迭代类型的数据一个一个的添加到列表的最后面
528 删: pop, remove
529 pop 根据索引删除值并且将删除的值返回回去
530 remove 根据列表的内容删除一个值，没有则报错
531 index，count
532 index 根据索引找到对应的值，找不到则报错
533 count 计算当前值出现的次数
534 copy，clear
535 copy 复制一个相同的列表
536 clear 清空当前列表
537 sort, reverse
538 sort 排序默认是升序，当参数reverse=true的时候就是倒序，排序的列表中必须全部是数字或者字母，否则会报错
539 reverse 反转
540 dict 只能转换如下类型[('name', 'hu'), ('age', 18)], 字典的key必须是不可变类型
541 python2和python3在处理字典的时候会返回不一样的值，python3会返回一个迭代器，而python2直接会把值给返回出来
542 copy，clear
543 copy 复制一个相同的字典
544 clear 清空当前字典
545 get 如果字典中不存在key，不会报错，会返回一个none. a.get('sex')
546 pop 根据key去删除字典的值，并且会把删除key对应的value返回回来， key不存在就报错
547 popitem 随机的删除一个键值对，并把键值对以元祖的形式返回回来，如果key不存在则报错
548 update 和列表的extend很相似，原字典中有这个key直接更新，没有就添加
549 fromkeys
550 #fromkeys可以通过已经给定的key快速的创建一个初始化的字典
551 res1 = {}.fromkeys('str', none)
552 res2 = {}.fromkeys(['name', 'age', 'sex'], none)
553 print(res1)
554 print(res2)
555 # 结果
556 # {'s': none, 't': none, 'r': none}
557 # {'name': none, 'age': none, 'sex': none}
558 setdefault
559 # setdefault有两个参数，第一个参数是key，如果key在原字典中存在，则直接返回原字典对应的key的值
560 # 如果原字典中key不存在，则添加key到原字典中，value的值为第二个参数，并且返回第二个参数
561 a = {'name': 'hu', 'age': 18}
562 res = a.setdefault('sex', none)
563 print(a, res)
564
565 # 结果：
566 # {'name': 'hu', 'age': 18, 'sex': none} none
567 tuple
568 index 寻找值所对应的索引,找不到则报错
569 count 寻找值出现的次数
570 set 值必须是不可变类型, 集合是无序不重复的
571 集合运算
572 交集 【&】符号代表交集
573 并集 【|】符号代表并集
574 差集 【-】符号代表差集，有顺序之分print(linuxs - pythons) # 在linux中但是不在python中
575 对称差集 【^】符号代表对称差集
576 父子 【>=】父子关系
577 集合方法
578 add 添加值如果存在，就不变
579 pop 随机删除一个，并把结果返回
580 remove 删除元素，元素不存在就报错
581 discard 元素如果存在就删除，不存在就不变
582 update 将一个集合更新到一个集合中，如果有则不变，没有则添加
583 isdisjoint 如果两个集合灭有交集，返回true
584 文件操作的方法
585 1. 不需要参数
586 readable 查看当前文件句柄是否可读
587 writeable 查看当前文件句柄是否可写
588 tell 查看当前指针距离文件头的字节个数
589 close 关闭当前文件
590 flush 将当前缓冲区的内容刷新到文件中
591
592 fileno
593 isatty
594 2. 需要一个参数（只有在rt模式下读取的才是字符）
595 read 默认读取文件内的所有内容，传入一个参数代表读出几个字节的
596 readline 读取当前指针所在行的值，传递的参数代表的是读取几个字节
597 readlines 把每一行的值转换成bytes类型，最后返回一个列表
598 write 将内容写入到文件中
599 writelines
600 # 下面这两种方法是一样的
601 for i in line:
602 f.write(i)
603 f.writelines(line)
604 3. 需要两个参数
605 seek 第一个参数代表移动的字节数，第二个参数0代表开头，1代表当前位置，2代表文件末尾
606 内置函数（64个,目前只是写了自己还不是很熟悉的）
607 max 求最大值, res = max(salaries, key=lambda key: salaries[key]), key是比较标准
608 min 求最小值,
609 sorted 从大到小顺序排列 sorted(salaries, key=lambda key: salaries[key], reverse=true)
610
611
612 filter 过滤 res = filter(lambda item: not item.endswith('_dsb'), test) 如果不是以_dsb结尾的就保留下来，返回一个迭代器
613 它不能向map和reduce一样对数据进行修改, 应用想去掉列表中的某个值x
614 reduce reduce需要导入才能进行使用
615 # 求1-100的和
616 # 这第三个参数是初始值，如果没有，则会从迭代对象中找到一个值赋值给它
617 from functools import reduce
618 res = reduce(lambda x, y: x + y, range(100), 100)
619 print(res, type(res))
620
621 # 拼接字符串
622 test = ['yuanhao_dsb', 'egon_dsb', 'wupeiqi_dsb', 'alex_dsb', 'egon']
623 from functools import reduce
624 res = reduce(lambda x, y: x + y, test, '10000')
625 print(res, type(res))
626 应用在拼接字符串或者是数字的叠加过程
627 map 映射 res = map(lambda item: item + '_dsb', lists)将lists的每个参数传递给item进行映射之后返回一个迭代器
628 应用在对某一类值进行修改
629 sum sum就是单纯的求和
630 round 对浮点数进行四舍五入取值
631 power 返回幂运算值或者与其指定的数值的模
632 divmod 返回两个数值的商和余数
633 dir 返回对象或者当前作用域内的属性列表
634 ascii 返回对象的可打印表字符串表现方式
635 vars 返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
636 all 判断可迭代对象每个元素是否都是true
637 any 判断可迭代对象中是否又true的元素
638 zip 聚合传入的每个迭代器中的相同位置的元素，返回一个新的元祖类型迭代器
639 reversed 反转序列生成新的可迭代对象
640 bytearray 根据传入的参数创建一个新的字节数组
641 bytes 根据传入的参数创建一个新的不可变字节数组
642 memoryview 根据传入的参数创建一个新的内存查看对象
643 frozenset 根据传入的参数创建一个新的不可变集合
644
645 enumerate 根据可迭代对象创建枚举对象
646 slice 根据传入的参数创建一个切片对象
647 super 根据传入的参数创建一个新的子类和父类的关系的代理对象
648 object 创建一个新的object对象
649
650 常用模块（14个）
651 time
652 time.time() 1539593357.4160235
653 time.localtime() 做为一种中间格式用来转换不同的时间格式
654 time.strftime('%y-%m-%d %x') '2018-10-15 16:57:24'
655 time.asctime() 'mon oct 15 18:23:37 2018'
656 time.ctime() 'mon oct 15 18:23:44 2018'
657
658 time.asctime(b) # 通过asctime把结构化时间转换成固定的外国人接受的时间
659 time.ctime(a) # 通过ctime将时间戳转换成外国人能够接受的时间
660
661 datetime
662 datetime.datetime.now() 获取当前时间 2018-10-15 18:40:17.028194
663 datetime.datetime.fromtimestamp(time.time()) 将时间戳转换成对应的时间
664 datetime.datetime.now() + datetime.timedelta(hours=3) 将当前时间加上三个小时
665
666 c_time.replace(month=11, year=2020, minute=10) 替换c_time的时间
667 sys
668 1. sys.argv # 这个是传入的参数，返回的是列表的形式，第一个是当前执行文件的名称
669 2. sys.path # 系统的环境变量，可以通过append方法进行更改
670 3. sys.modules # 内存已经加载的模块，以字典的形式存在
671 4. sys.version # 解释器的版本
672 5. sys.platform # 当前执行的平台
673 6. sys.exit() # 退出当前执行的python解释器
674
675 # 了解
676 7. sys.api_version # api版本号
677 8. sys.maxsize # 最大值得整数32位为 2 ** 32 - 1 64位为2 ** 64 -1
678 9. sys.maxunicode # 最大的unicode 0x10ffff
679 os
680 1. 目录操作
681 增
682 os.mkdir 创建一个单级目录
683 os.makedirs 创建多级目录，递归创建
684 删
685 os.rmdir 删除一个目录
686 os.removedirs 递归删除目录，如果目录为空
687 改
688 chdir 改变当前目录
689 pardir 当前执行目录的父目录
690 curdir 当前执行文件的目录
691 查
692 getcwd() 获得当前解释器执行文件目录
693 listdir() 以列表的形式返回当前目录下面有什么内容
694 2. 文件操作
695 删
696 os.remove() 删除文件
697 改
698 os.rename() 修改文件名称
699 查
700 os.stat 查看当前文件的状态信息
701 os.path.getsize() 查看当前文件的大小
702 os.path.getatime() 查看当前文件的创建时间
703 os.path.getmtime() 查看当前文件的修改时间
704 3. 变量信息
705 os.stat # 文件的状态信息
706 os.name # win是‘nt’， linux平台是'posix'
707 os.sep # 操作系统特定的路径分隔符
708 os.linesep # 换行符win为'\t\n', linux为'\t'
709 os.pathsep # 分割文件路径的字符串win为;, linux为：
710 os.environ # 系统环境变量
711 os.system() # 运行shell命令，直接显示
712 4. 路径的判断
713 os.path.exists() # 判断路径是否存在
714 os.path.isfile() # 判断是否是个文件
715 os.path.isdir() # 判断是否是个目录
716 os.path.join() # 拼接路径
717 5. 路径操作
718 os.path.split() # 以列表的形式返回文件名和目录
719 os.path.basename # 获得得就是split的文件名
720 os.path.dirname # 获得得就是split的目录
721 5. 规范化路径
722 os.path.normcase() # 将大写变小写，并将所有斜杠转成反斜杠(返回的是原字符串)
723 os.path.normpath() # 会把反斜杠转换成斜杠，然后可以识别相对路径
724 os.path.abspath() # 返回path规范化的绝对路径
725 random
726 random.random() # 得到一个（0-1）之间的浮点数
727 random.uniform(1, 3) # 得到一个(1, 3)之间的一个小数
728
729 random.randint(1, 3) # 得到一个[1, 3]之间的整数
730 random.randrange(1, 3) # 得到一个[1, 3)之间的一个整数
731
732 random.choice([1, '23', [4, 5]]) # 获得列表中的一个值
733 random.choices([1, '23', [4, 5]], k=2) # 获得列表中的两个值返回一个列表
734 random.sample([1, '23', [4, 5]], k=2) # 列表元素任意2个组合
735
736 # 打乱顺序
737 l = [1,2,3,4,5]
738 random.shuffle(l) # 传递的必须是一个列表
739 hashlib
740 password = hashlib.md5('123'.encode('utf-8'))
741 password.update(''.encode('utf-8')
742 password.hexdigest()
743
744 json, pickle
745 f.write(pickle.dumps(user))
746 pickle.dump(user, f)
747 pickle.load(f)
748 res = pickle.loads(f.read())
749 shelve
750 import shelve
751 # shelve只有一个open函数
752 # 打开文件，文件可以存在也可以不存在，
753 f = shelve.open(r'shelve.txt', writeback=true)
754 # 在关闭之前可读可写参数writeback=true代表的是否可以进行修改
755 # f['user'] = {'name': 'hu'}
756 print(f['user'])
757 f['user']['sex'] = 'male'
758 f.close()
759 shutil
760 文件处理：
761 shutil.copyfileobj 传入的是两个对象，源文件，目的文件
762 shutil.copyfile 传入的是两个路径，原路径，目的路径
763 shutil.copymode 只复制文件的权限，目的恩瑾可定是要存在
764 shutil.copystat 只复制文件的状态信息，修改时间，查看时间，更改时间，flag是
765 shutil.copy 拷贝文件和权限
766 shutil.copy2 拷贝文件和状态信息
767 shutil.move() 更改文件名称
768 文件夹处理
769 shutil.copytree 拷贝目录
770 shutil.ignore_patterns 根据这个模块去设置是否不拷贝某个类型的文件
771 shutil.rmtree 删除目录
772 压缩包处理
773 shutil.make_archive() 压缩后的目录名称，格式，源目录
774 shutile.unpack_archive() 压缩后的目录名称， 格式，解压后的目录
775
776 tarfile.open().add()
777 zipfile.zipfile().write()
778 xml
779 import xml.etree.elementtree as et
780 tree = et.parse('xml文件名称')
781 root = tree.getroot()
782 .......一系列的标签查找与替换操作
783
784 root.iter('标签名称')
785 root.find('标签名称')
786 root.findall('标签名称')
787
788 node.text 标签内容
789 node.attrib 标签属性
790 node.tag 标签名
791
792 node.set('属性名', '属性值')
793
794 tree.write('xml文件名称')
795
796 configparser开始的标准写法
797
798 import configparser
799 config = configparser.configparsesr()
800 config.read('a.txt', encoding='utf-8')
801 .....一系列检查修改操作之后
802
803 config.sections()
804 config.get('某个分区', '某个key')
805 config.set('某个分区', '某个key', 'value')
806 config.has_section('某个分区')
807 config.has_option('某个分区'， 'key')
808
809 config.write(open('conf.cfg', 'wt', encoding='utf-8'))
810
811 logging 日志模块的使用方法
812 import logging.config
813 logger = logging.config.dictconfig(config=配置文件里面的配置字典)
814 return logging.getlogger('日志生成器的名称')
815 re
816 位置匹配
817 \a 开头
818 \z 结尾
819 ^ 开头
820 $ 结尾
821 范围匹配
822 \d 数字 （\d相反是非数字）
823 \w 数字字母下划线 （\w相反）
824 \s 空字符(\t\n\f\b) （\s相反）
825 [...] 手动指定范围，ascii码表返回
826 [^...] 指定范围以外的内容
827 重复匹配
828 * 0次或者多次
829 + 一次或者多次
830 ? 0次或者一次 非贪婪模式
831 {n} 精确匹配前面n个表达式
832 {n, m} 匹配n到m次由前面的正则表达式定义的片段，贪婪模式
833
834 分组
835 ()括号内的表达式是一个分组
836 subprocess
837 cmd = 'dir h:\python_study\day23'
838 find = 'findstr "py"'
839
840 sub1 = subprocess.popen(cmd,
841 stdout=subprocess.pipe,
842 shell=true,)
843 # 把sub1的标准输出输入到sub2的输入中
844 sub2 = subprocess.popen(find,
845 stdout=subprocess.pipe,
846 stdin=sub1.stdout)
847
848 print(sub2.stdout.read().decode('gbk'))
849 小工具
850 cp拷贝文件
851 递归实现二分法的过程
852 递归实现冒泡排序的过程
853
854 logging的常用配置文件内容
855 """日志配置文件内容"""
856 from conf import settings
857 import os
858 # from lib.common import get_config_module
859
860 standard_format = '%(asctime)s %(name)s %(funcname)s %(module)s %(message)s'
861 simple_format = '%(asctime)s %(module)s %(message)s'
862 complete_format = '%(asctime)s %(name)s %(funcname)s %(lineon)s %(module)s %(message)s'
863
864 # 拼接日志文件存储路径
865 logfile_path = os.path.join(settings.log_dir, 'atm_log', 'atm.log')
866 user_logfile_path = os.path.join(settings.log_dir, 'usr_log', 'usr_log')
867
868
869 # print(logfile_path, user_logfile_path)
870 # 这个就是之前通过手工的方式创建的四个日志核心组件
871 logging_dic = {
872 # 日志字典的版本，这个自己设置的
873 'version': 1,
874 # 日志格式定义字段，通过一定格式的字符串进行创建
875 'formatters': {
876 # 定义了日志的表示格式标准格式，简单格式和完整格式
877 'standard': {
878 'format': standard_format
879 },
880 # 简单格式
881 'simple': {
882 'format': simple_format
883 },
884 # 完整格式
885 "complete":{
886 "format": complete_format
887 }
888 },
889 # 日志过滤器，暂时设置成空
890 'filters': {},
891 # 日志处理器
892 'handlers': {
893 # 定义了两种日志处理器
894 # 把日志内容打印到终端
895 'console': {
896 'level': 'debug', # 日志级别
897 'class': 'logging.streamhandler', # 日志流处理器
898 'formatter': 'simple' # 使用的打印格式是上面设置的simple
899 },
900 'default': {
901 'level': 'debug',
902 'class': 'logging.handlers.rotatingfilehandler', # 设置文件通过一定大小之后就换文件
903 'formatter': 'standard', # 写入文件的格式是上面定义的标准格式
904 'filename': logfile_path, # 写入文件的路径
905 'maxbytes': 1024 * 1024 * 5, # 日志文件的最大大小为5m 超出后 换文件
906 'backupcount': 5, # 最多留五个日志文件
907 'encoding': 'utf-8', # 写入的时候编码方式
908 },
909 'user_stream': {
910 'level': 'debug',
911 'class': 'logging.handlers.rotatingfilehandler', # 设置文件通过一定大小之后就换文件
912 'formatter': 'standard', # 写入文件的格式是上面定义的标准格式
913 'filename': user_logfile_path, # 写入文件的路径
914 'maxbytes': 1024 * 1024 * 5, # 日志文件的最大大小为5m 超出后 换文件
915 'backupcount': 5, # 最多留五个日志文件
916 'encoding': 'utf-8', # 写入的时候编码方式
917 },
918 },
919 # 日志生成器
920 'loggers': {
921 # 在getlogger的时候 如果指定的名称 不存在 或者不给名称 用的就是默认的
922 # 在这里如果key为空 它就是默认的
923 # 你可以自己定义生成器的名称 并且他们还能使用相同的默认配置
924 '': {
925 'handlers': ['default'],
926 'level': 'debug',
927 'propagate': false,
928 },
929 # 在getlogger的时候 如果指定的名称 不存在 或者不给名称 用的就是默认的
930 # 在这里如果key为空 它就是默认的
931 # 你可以自己定义生成器的名称 并且他们还能使用相同的默认配置
932 'user_log': {
933 'handlers': ['user_stream', 'console'],
934 'level': 'debug',
935 'propagate': false,
936 },
937 },
938
939 }
940 format参数中可能用到的格式化串：
941 %(name)s logger的名字
942 %(levelno)s 数字形式的日志级别
943 %(levelname)s 文本形式的日志级别
944 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
945 %(filename)s 调用日志输出函数的模块的文件名
946 %(module)s 调用日志输出函数的模块名
947 %(funcname)s 调用日志输出函数的函数名
948 %(lineno)d 调用日志输出函数的语句所在的代码行
949 %(created)f 当前时间，用unix标准的表示时间的浮 点数表示
950 %(relativecreated)d 输出日志信息时的，自logger创建以 来的毫秒数
951 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
952 %(thread)d 线程id。可能没有
953 %(threadname)s 线程名。可能没有
954 %(process)d 进程id。可能没有
955 %(message)s用户输出的消息
956
957 时间中可能用到的格式化字符串
958 %a locale’s abbreviated weekday name.
959 %a locale’s full weekday name.
960 %b locale’s abbreviated month name.
961 %b locale’s full month name.
962 %c locale’s appropriate date and time representation.
963 %d day of the month as a decimal number [01,31].
964 %h hour (24-hour clock) as a decimal number [00,23].
965 %i hour (12-hour clock) as a decimal number [01,12].
966 %j day of the year as a decimal number [001,366].
967 %m month as a decimal number [01,12].
968 %m minute as a decimal number [00,59].
969 %p locale’s equivalent of either am or pm. (1)
970 %s second as a decimal number [00,61]. (2)
971 %u week number of the year (sunday as the first day of the week) as a decimal number [00,53]. all days in a new year preceding the first sunday are considered to be in week 0. (3)
972 %w weekday as a decimal number [0(sunday),6].
973 %w week number of the year (monday as the first day of the week) as a decimal number [00,53]. all days in a new year preceding the first monday are considered to be in week 0. (3)
974 %x locale’s appropriate date representation.
975 %x locale’s appropriate time representation.
976 %y year without century as a decimal number [00,99].
977 %y year with century as a decimal number.
978 %z time zone offset indicating a positive or negative time difference from utc/gmt of the form +hhmm or -hhmm, where h represents decimal hour digits and m represents decimal minute digits [-23:59, +23:59].
979 %z time zone name (no characters if no time zone exists).
980 %% a literal '%' character.
分割线-----------------------------------------------------------------------下面都是没有带答案的
一. 概念题
1. 编程
2. cpu, 内存，硬盘
3. 运行程序，硬件的工作过程
4. 进制之间的转换
5. 操作系统
6. 编程语言的分类
机器语言
汇编语言
高级语言
编译型语言
解释性语言
7. 执行python程序的两种方式
8. 变量
变量的命名规范
变量名的命名风格
变量的三个特征
常量
常量的命名规范
9. 引用计数
10. 数据类型
11. python2和python3的区别
12. 运算
比较运算
赋值运算
增量赋值
链式赋值
交叉赋值
解压赋值
逻辑运算
身份运算
13. 运行python程序的三个步骤
14. 小整数池
15. if判断的四种语法
16. 结束while循环的两种方式
17. while else的用法
18. for主要用来做循环取值
19. 可变类型与不可变类型是按照什么标准划分的
20. 计算机系统分为哪三层
21. 字符编码
编码和解码
解决乱码的核心法则
python2默认的编码方式
python3默认的编码方式
#coding:文件头的作用
22. 字符编码的操作核心法则（3条）
23. 文件
24. 文件处理的三个步骤
25. 上下文管理的方式
26. 操作文件内容的三种纯净模式
27. 控制文件内容格式的两种模式
28. 文件指针移动的单位是字节还是字符
29. 文件是否可以修改？
文件'修改'的两种方式
30. 函数
31. 函数的分类
32. 使用函数的原则
33. 函数的两个明确阶段
34. 函数定义的三种形式
35. 函数调用的三种形式
36. return的特点
yield的特点
37. 函数参数的两大类
形参（形参又分为几类）
实参（实参又分为几类）
38. 为什么说函数是第一类对象？
39. 函数与变量的四种使用方式
40. 函数的嵌套定义以及其应用场景
41. 函数的嵌套调用以及其应用场景
42. 什么是名称空间
43. 名称空间的分类（三类）
44. 名称空间的产生顺序
45. 名称空间的销毁顺序
46. 什么是作用域
47. 作用域的分类（两种）
48. 作用域关系的核心要义（一句话）
49. 什么是闭包函数
50. 为函数体传值的两种方式（分别的特点）
51. 什么是装饰器
52. 装饰器的分类（两大类）
53. 什么是语法糖
54. 装饰器的语法糖
55. 有参装饰器的模板
56. 无参装饰器的模板
57. 叠加装饰器的加载顺序
58. 叠加装饰器的执行顺序
59. 什么是迭代器
60. 迭代器的两个优点
61. 迭代器的两个缺点
62. 什么是可迭代对象
63. 什么是迭代器对象
64. python中的可迭代对象有哪些（6个）
65. python中的迭代器对象有哪些（1个）
66. for循环本质上是个迭代器循环，原理是什么（3步）
67. 什么是生成器
68. python中提供生成器的关键字
69. 三元表达式
70. 列表生成式
71. 生成器表达式
72. 字典生成式
73. 什么是匿名函数
74. 匿名函数的应用场景（2个）
75. 什么是函数递归
76. 递归要满足的两个原则
77. 递归的两个明确的阶段
78. 什么是面向过程编程
79. 面向过程编程的优点和缺点
80. 什么是面向对象编程
81. 面向对象编程的优点和缺点
赞 (0)
打赏
微信扫一扫
相关文章:
-
-
11.11京东手机潮流风尚发布,引领下一个手机消费季 自9月以来，各大手机品牌厂商的秋季新品发布会如约而至，并在11.11前夕迎来新一轮高潮... [阅读全文]
-
一、基本概念 程序： 指令集，静态， 进程： 当程序运行时，会创建进程，是操作系统资源分配的基本单位 线程： 进程的基本执行单元，每个进程至少包含一... [阅读全文]
-
前言 学习是一个循序渐进的过程，不在于你学了多少，而在于你学会了多少。(装个b好吧，hhhh) 知识总结 之前一直想在网上找一个总结好的笔记，但是一... [阅读全文]
-
测试的一种方法是打日志日志打的好不好直接关系到bug的解决主要的包------logging日志的级别（level）级别可自定义DEBUGINFOW... [阅读全文]
-
常用模块（四） 八、configparser 模块 官方介绍：A configuration file consists of sections, ... [阅读全文]
-
版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。
发表评论