欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python基础知识你学会了多少

程序员文章站 2022-07-23 23:26:37
前言 学习是一个循序渐进的过程,不在于你学了多少,而在于你学会了多少。(装个b好吧,hhhh) 知识总结 之前一直想在网上找一个总结好的笔记,但是一直都没有找到,因此下定决心要总结一下,里面的都是在学习的过程中学到的一些最基础的一些概念啊,类型啊,方法啊之类的额,真的是花费了不少的时间,当然大佬请绕 ......

前言

学习是一个循序渐进的过程,不在于你学了多少,而在于你学会了多少。(装个b好吧,hhhh)

知识总结

之前一直想在网上找一个总结好的笔记,但是一直都没有找到,因此下定决心要总结一下,里面的都是在学习的过程中学到的一些最基础的一些概念啊,类型啊,方法啊之类的额,真的是花费了不少的时间,当然大佬请绕过好吧。。

python基础知识你学会了多少
  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)
打赏 python基础知识你学会了多少 微信扫一扫

相关文章:

版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站仅提供信息存储服务,不拥有所有权,不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 2386932994@qq.com 举报,一经查实将立刻删除。

发表评论

python基础知识你学会了多少
验证码: python基础知识你学会了多少