python基础知识你学会了多少

 概念

     1. 编程

         语言是一个事物与另外一个事物沟通的介质，编程语言是程序员与计算机沟通的一个介质。

         编程就是程序员用计算机能够理解的表达方式（编程语言）来讲自己的思维逻辑写下来的一个过程。

         编程的结果就是产生了一堆的文件，我们把这些文件称之为软件或者程序。

     2. cpu, 内存，硬盘

         cpu，内存，硬盘统称为计算机的三大核心硬件。cpu主要主要用来计算，内存和硬盘用来存储。出现两种存储硬件的格式主要是因为cpu的计算速度很快，而硬盘的

         读写速度很慢，为了更加高效的利用cpu的资源就出现了一种中间的存储也就是内存。但是内存不能持久化存储，断电易丢失。因此，在读取数据的时候就出现了

         这样一种现象，数据从硬盘读取到内存，然后通过cpu操作内存来实现一系列的操作。

     3. 运行程序，硬件的工作过程

         1. 程序保存在硬盘中

         2. 程序要运行必须先加载到内存

         3. cpu从内存中读取指令,然后翻译执行

     4. 进制之间的转换

         名词：bit，Bytes, KBytes, MBytes, GBytes, TBytes

         1Bytes = 8bit

         1KBytes = 1024Bytes

         1MBytes = 1024KBytes ...依次类推

     5. 操作系统

         操作系统是一个协调\管理\控制计算机硬件资源与软件资源的一个控制程序。可以把复杂的硬件操作封装成简单的功能接口用来给用户或者应用程序使用，

         以及合理的管理应用程序之间的资源分配。

     6. 编程语言的分类

         机器语言: 直接使用二进制指令编写的程序，运行效率非常高，但是开发效率非常低。

         汇编语言: 使用一些英文的标签来代替二进制指令去编写的程序，比机器语言的开发效率高，但是开发效率比起高级语言要低很多。

         高级语言: 直接使用人能够理解的表达方式去编写程序，开发效率比机器语言和汇编语言都要搞，但是执行效率很低。

             编译型语言: 执行效率高于解释型语言，开发效率低于解释型语言。

             解释性语言: 执行效率低于编译型语言，开发效率高于编译型语言。

         总结：

             执行效率： 机器语言>汇编语言>编译型语言>解释型语言

             开发效率： 机器语言<汇编语言<编译型语言<解释型语言

     7. 执行python程序的两种方式

         (1).交互式环境: 输入代码立即执行，但是不能保存文件

         (2).写入文件: 可以保存文件

     8. 变量: 是用来记录当前事物的某种状态，之后状态可以进行变化。

         变量的命名规范

             (1).字母数字下划线

             (2).不能以数字开头

             (3).对变量值有一定的描述性功能

             (4).不能是python中的关键字

         变量名的命名风格

             (1).驼峰体

             (2).下划线纯小写

         变量的三个特征

             (1).id  内存地址

             (2).type 变量的类型

             (3).value 变量的值

         常量

             常量的命名规范: python中默认是没有常量的，只是约定俗成的全大写的就是变量，我们不应该对其进行修改。

     9.  引用计数

         是python垃圾回收机制引入的一个名词，主要是用来显示当前变量值被关联的次数，如果为0，就会被python自动进行回收。

     10. 数据类型

         数据指的是变量的值，数据类型指的是变量值的类型。在日常生活中事物有多种形态，对应于程序中也应该有多种形态，也就是多种类型。

     11. python2和python3的区别

         (1).input和raw_input,python2中的input必须要输入明确的数据类型，输入的是什么输出就是什么

         (2).编码python2:ascci, python3:utf-8

         (3).print()和print

     12. 运算

         算数运算：+-*/ // % **

         比较运算: 只能在同类型之间进行比较，int和float都属于数字类型

         赋值运算

             增量赋值:类似于a += 1这种形式

             链式赋值:类似于a = b = 1这种形式

             交叉赋值:类似于x, y = y, x这种形式

             解压赋值:类似于a, b, c, d = [1, 2, 3, 4], 多了少了都不行

         逻辑运算:判断顺序: 比较运算>not>and>or

         身份运算:is比较的是两个变量值的地址，==比较的是两个变量值的值

     13. 运行python程序的三个步骤

         (1).打开python解释器

         (2).将硬盘中的python程序加载到内存中(前两不就和正常的读取文件一样)

         (3).检测python语言并执行(这一步才开始正式的读取python的语法)

     14. 小整数池

         小整数池是python中为了节省内存空间而创建的一种机制，也就是说在一定的数据范围内，无论创建了多少分，使用的都是这一个地址。

     15. if判断的四种语法

         (1). if 条件:

                 code

         (2). if 条件:

                 code

              else:

                 code

         (3). if 条件:

                 code

              elif 条件:

                 code

         (4). if 条件:

                 if 条件:

                     code

     16. 结束while循环的两种方式

         (1): 通过条件的更改最终使得进入while循环的条件不满足

         (2): 通过break关键字跳出循环

     17. while else的用法

         格式:

             while 条件:

                 code1

             else:

                 code2

         当while循环因为条件不满足而正常退出的时候，会执行code2的代码

     18. for循环主要用来做什么

         python语言中真正的循环只有while一个，也就是说所有的事物都是可以通过while循环去获得值得，for循环主要是用来做循环取值的。

     19. 可变类型与不可变类型是按照什么标准划分的

         通过改变变量的值来看内存地址是否发生改变来划分的。

         不可变类型: int,float,str,tuple 值变内存地址也变

         可变类型: list,dict,set 值变内存地址不会发生改变

     20. 计算机系统分为哪三层

         (1).应用程序层

         (2).操作系统层

         (3).计算机硬件层

     21. 字符编码

         人类与计算机打交道用到的都是人类的字符，而计算机只能识别二进制，因此我们需要将人类的字符编码成计算机能够识别的语言，

         从而实现人机的交互。而字符编码表就是将人类的字符与计算机二进制进行一一对应的关系表。

         编码和解码

             我们通过字符编码表将人类的字符转换成计算机能够识别的字符的过程就叫做编码

             我们通过字符编码表将计算机的二进制代码转换成我们的能够识别的字符的过程叫做解码。

         存在的一些字符编码表

             ascii          只能识别英文

             gbk     1Bytes代表英文， 2Bytes代表中文

             unicode    全部都是2Bytes

                 (1).能够兼容万国编码

                 (3).与各个国家的字符编码都有一一映射关系

             utf-8     1Bytes代表英文，3Bytes代表中文

                 它只是unicode的一种转换格式，并不能与各个国家的语言进行一一的映射

         解决乱码的核心法则

             用什么编码方式编码的就用什么编码方式进行解码

         python2默认的编码方式：ascii

         python3默认的编码方式：utf-8

         #coding:文件头的两个作用

             (1):告诉程序员当前程序应该以什么样的编码方式进行存储

             (2):告诉python解释器在加载当前程序的时候应该以什么样的编码方式进行解码。

     22. 字符编码的操作核心法则（3条）

         (1).python2中如果出现中文前面加上u。 eg: a = u'中国'

         (2).在文件开头要写上 #coding:utf-8

         (3).python3通过encode编码之后可以得到bytes类型

     23. 文件

         文件是操作系统帮我们虚拟出来的一个可以操作计算机硬盘的一个接口。我们可以通过操作系统将对文件的操作转换成对硬盘的操作，

         从而将应用程序持久化存储起来。

     24. 文件处理的三个步骤

         (1).通过关键字open打开系统调用得到一个文件句柄(应用程序的内存资源===>操作系统的内存资源)

         (2).操作文件（读和写）

         (3).通过close关闭一个文件句柄，也就是回收操作系统的资源。

     25. 上下文管理的方式

         通过with open关键字打开一个文件，从而得到一个文件句柄，我们不再需要去关注什么时候应该关闭掉文件，因为

         上下文管理会自动帮我们关闭文件，从而回收操作系统资源。

     26. 操作文件内容的三种纯净模式

         r: (默认的)只读模式，文件不存在则报错。

         w:只写模式，文件不存在则创建，存在则清空写入

         a:只写模式，文件不存在则创建，存在则追加写入

     27. 控制文件内容格式的两种模式

         t文本模式:

             (1).只能针对文本文件

             (2).读写文件都是以字符串为单位的

             (3).必须指定encoding

         b:二进制模式

             (1).针对所有文件

             (2).读写文件都是以字节为单位的

             (3).不能指定encoding

     28. 文件指针移动的单位是字节还是字符

         只有在rt模式下移动的是字符，其余的都是字节模式

     29. 文件是否可以修改？

         文件准确来说是磁盘的映射，磁盘不能改，文件当然也就不能进行修改。但是我们可以通过以下的方式进行间接的修改

         方式一: 将磁盘的文件一次性的读入内存中，在内存中修改完成之后再覆盖写入到硬盘空间。

             优点: 同一时间内硬盘中不会存在两个文件。

             缺点: 文件太大的时候会占用更多的内存空间。

         方式二: 以读的方式一行一行的读入到内存中，然后一行行修改重新写入到一个临时文件中，最后将源文件删除，临时文件的名称改成源文件的名称

             优点: 占用系统内存较少

             缺点: 同一时间硬盘空间中数据会存在两份。

     30. 函数

         函数就是实现某一功能的代码块。通过函数我们可以解决代码冗余的问题，从而提高程序的可扩展性以及可读性。

     31. 函数的分类(2类)

         (1).内置函数: Python解释器帮我们编写好的为了实现某种功能的函数，可以不用定义直接进行使用。

         (2).自定义函数: 自己自定的为了实现某一个功能的函数。

     32. 使用函数的原则

         先定义后调用

     33. 函数的两个明确阶段

         (1).函数定义阶段

         (2).函数调用阶段

     34. 函数定义的三种形式

         (1).有参函数

         (2).无参函数

         (3).空函数

     35. 函数调用的三种形式

         (1).语句的形式 func()

         (2).表达式的形式  res = func() * 12

         (3).当做参数传递的形式 res = max(max(1, 2), 3)

     36. return的特点

         return返回值:

             (1).没有类型的限制

             (2).没有个数的限制

                 <1>返回0个或者没有返回 都是None

                 <2>返回1个  就是值本身

                 <3>返回多个 是个元组

         return结束函数的功能，可以有多个return，但是只会执行一次

     37. 函数参数的两大类

         形参（形参又分为哪四类）: 在函数定义阶段，括号内定义的参数

             位置形参: 按照从左到右的顺序依次定义的形参

                 <1>: 必须传值，不能多不能少

             默认形参: 按照key=value的形式定义的形参

                 <1>: 可以传值，也可以不传值

                 <2>: 默认形参必须在位置形参后面

                 <3>: 默认形参的值在函数定义阶段就已经固定死了，定义阶段后的改动不会影响该值

                 <4>: 默认形参的值通常应该是不可变类型

             可变长形参:

                 *argv:*会将溢出的位置实参存成元组的形式，然后赋值给*后的argv

                 **kwargvs: **会将溢出的关键字实存成字典的形式，然后赋值给**后面kwargs

             命名关键字形参

         实参（实参又分为哪三类）: 在函数调用阶段，括号内定义的参数

             位置实参

                 与位置形参一一对应

             关键字实参

                 <1>: 关键字实参必须放在位置实参的后面

                 <2>: 不能重复传值

             可变实参: 指的是在调用阶段，实参值个数是不固定的,

     38. 为什么说函数是第一类对象？

         函数的内存地址可以像一个变量值一样去使用。

     39. 函数与变量的四种使用方式

         <1>.赋值

         <2>.当做参数进行传递

         <3>.作为返回值返回

         <4>.可以当做容器类型的参数 应用: 功能字典

     40. 函数的嵌套定义以及其应用场景

         函数的嵌套定义: 指的是在一个函数内重新定义多个函数，但是不会进行调用。

         应用场景: 可以将一系列相关的功能封装到一块提供给用户进行使用。例如: 对于园的一些操作求周长面积等封装到一个函数里面。

     41. 函数的嵌套调用以及其应用场景

         函数的嵌套调用: 指的是在一个函数内调用了其他的函数。

         应用场景: 主要是用来将一个复杂的过程分成好几个函数同时来完成，最后通过一个函数进行封装。

     42. 什么是名称空间

         名称空间指的是存放变量名与内存地址绑定关系的地方。

     43. 名称空间的分类（三类）

         <1>.内置名称空间

             解释器启动的时候就会产生，解释器关闭的时候就会销毁

         <2>.全局名称空间

             python程序执行的时候产生，Python程序执行完毕之后销毁

         <3>.局部名称空间

             函数调用时临时产生，函数调用完毕之后则销毁

     44. 名称空间的产生顺序

         内置名称空间---> 全局名称空间_---> 局部名称空间

     45. 名称空间的销毁顺序

         局部名称空间---> 全局名称空间_---> 内置名称空间

     46. 什么是作用域

         作用域指的是变量名的作用范围

     47. 作用域的分类（两种）

         全局作用域: 包含了全局和内置名称空间的名字

             全局存活，全局有效

         局部作用域: 包含了局部命名空间的名字

             临时存活，局部有效

     48. 作用域关系的核心要义（一句话）

         作用域关系在函数定义阶段已经定义死了，与函数调用无关。

     49. 什么是闭包函数

         在函数内部定义了一个函数，该函数又包含了对外层函数名字的引用。

     50. 为函数体传值的两种方式（分别的特点）

         (1). 通过参数进行传值    每次调用都要进行传值

         (2). 通过闭包函数进行传值   可以传一次得到一个返回值，之后直接调用返回值就可以，在某些方面可以简化用户的操作

     51. 什么是装饰器

         为原函数增加新的功能的工具就是装饰器。我们可以通过装饰器在不修改功能源代码以及其调用方式的情况下为原函数增加新的功能。

         加载装饰器就是将原函数名偷梁换柱成了装饰器最内层那个wrapper函数

         # 在加载完毕后，调用原函数其实就是在调用wrapper函数

     52. 装饰器的分类（两大类）

         <1>有参装饰器

         <2>无参装饰器

     53. 什么是语法糖

         语法糖(syntactic sugar)是指编程语言中可以更容易的表达一个操作的语法，它可以使程序员更加容易去使用这门语言：

         操作可以变得更加清晰、方便，或者更加符合程序员的编程习惯

     54. 装饰器的语法糖

         @装饰器的名字:要在被装饰对象正上方单独一行写上

     55. 有参装饰器的模板

         def outter2(x,y,z):

             def outter(func):

                 def wrapper(*args,**kwargs):

                     res=func(*args,**kwargs)

                     return res

                 return wrapper

             return outter

     56. 无参装饰器的模板

         def outter(func):

             def wrapper(*args,**kwargs):

                 res=func(*args,**kwargs)

                 return res

             return wrapper

     57. 叠加装饰器的加载顺序

         自下而上

     58. 叠加装饰器的执行顺序

         自上而下

     59. 什么是迭代器

         迭代器就是一个迭代取值的工具，该工具的特点就是可以不依赖索引取值。

     60. 迭代器的两个优点

         <1>.提供了一种通用的不依赖索引的迭代取值方式

         <2>.同一时刻在内存中只有一个值，更加节省内存

     61. 迭代器的两个缺点

         <1>.没有索引取值灵活，并且迭代器是一次性的

         <2>.无法预知迭代器数据的个数

     62. 什么是可迭代对象

         但凡是有__iter__方法的都是可迭代对象，调用可迭代对象的__iter__方法可以得到一个迭代器对象。

     63. 什么是迭代器对象

         有__iter__和__next__方法的都是迭代器对象，调用迭代器对象的__iter__方法会得到它本身

     64. python中的可迭代对象有哪些（6个）

         list, tuple, dict, set, 文件对象, str

     65. python中的迭代器对象有哪些（1个）

         文件对象

     66. for循环本质上是个迭代器循环，原理是什么（3步）

         <1>.会调用对象__iter__将迭代器对象或者可迭代对象转换成迭代器对象

         <2>.调用迭代器对象的__next__方法取值并且赋值给变量，运行循环体代码

         <3>.循环往复，直到迭代器取值完毕之后抛出异常然后捕捉异常自动结束循环

     67. 什么是生成器

         生成器本质上就是一种迭代器，不过它是程序员自己通过yield关键字创建出来的一种迭代器对象。

     68. python中提供生成器的关键字

         yield，一旦函数中包含yield关键字，当我们去执行此函数的时候，就不会立刻的运行函数体代码了，会得到一个返回值，

         该返回值就是一个生成器对象。

     69. 三元表达式

         a = x if x > y else y

     70. 列表生成式

         l = [i ** 2 for i in range(9) if i > 5]

     71. 生成器表达式

         c = (i**2 for i in range(3))

     72. 字典生成式

         d = {k:v for k,v in dd if k != 'sex'}

     73. 什么是匿名函数

         顾名思义: 没有名字的函数就是匿名函数。有些功能我们使用一次就不在使用了，所以我们需要匿名函数。

     74. 匿名函数的应用场景（2个）

         <1>.用在一些内置函数中当做参数, 例如: max,min,sorted,filter,reduce,map

         <2>.

     75. 什么是函数递归

         函数的递归就是函数嵌套调用的一种特殊用法，特殊在调用一个函数的过程中又直接或者间接地调用了该函数本身。我们可以通过

         在某些条件下使用递归要比使用while循环更加的简单。

     76. 递归要满足的两个原则

         <1>.每进入下一层递归，函数的规模都应该有所减少

         <2>.递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件

     77. 递归的两个明确的阶段

         <1>.回溯:一层一层地递归调用下去

         <2>.递推:在某一层结束掉递归，然后一层一层返回。

     78. 什么是面向过程编程

         面向过程的核心在过程二字，基于该思想写程序脑子里应该始终思考过程二字，就好比设计一个流水线，是一种机械式的思维方式

     79. 面向过程编程的优点和缺点

         优点: 将复杂的问题流程化，进而简单化

         缺点: 扩展性差

     80. 什么是面向对象编程

         面向对象的核心在对象二字，基于该思想写程序就像是在创造一个世界，世界里的一切都是对象，是一种上帝式的思维方式。

     81. 面向对象编程的优点和缺点

         优点:扩展性强

         缺点: 编程较为复杂

     82. 什么是模块

         模块就是一组功能的集合，本质上就是一个py文件。

     83. 模块的作用

         让我们可以从文件级别去管理我们的代码。可以提高我们程序的可维护性与可读性。

     84. 模块的分类（4类）

         <1>.内置模块

         <2>.自定义模块

         <3>.包

         <4>编译为DLL的c或者C++

     85. 模块导入的两种方式，区别是什么

         <1>.import导入

         <2>.from ... import导入

     86. import导入模块的三个步骤

         <1>.在当前模块中创建一个名称空间

         <2>.执行模块中的代码，将名称和地址的对应关系存储到名称空间中

         <3>.在执行文件中产生一个新的名称指向被导入的名称空间

     87. import导入的三种语法

         <1>. import 模块名

         <2>. import 模块名1, 模块名2

         <2>. import 模块名 as mmm

     88. from导入模块的三个步骤

         <1>.在当前模块中创建一个名称空间

         <2>.执行模块中的代码，将名称和地址的对应关系存储到名称空间中

         <3>.复制被导入模块中的名称到当前名称空间中，之后可以直接进行使用

     89. from导入模块的三种语法

         <1> from 模块 import 变量

         <2> from 模块 import 变量1, 变量2

         <3> from 模块 import 变量1 as mmm

         <4> from 模块 import *

     90. 模块的搜索顺序

         内置模块--->内存中已经加载的模块--->sys.path中已经存在的模块

     91. 什么是包

         包是一堆模块的集合。

     92. __init__文件是干什么用的

         导入该包内的所有模块，用户使用起来较为简单，无需关系包内的东西，只需要导入__init__就可以使用包内的所有模块。

     93. __init__文件应该包含哪些内容

         仅仅只是用于导入包内的模块，不应该包含任何的业务逻辑。

     94. 包的作用

         我们可以从文件夹的级别去管理我们的代码。提高可读性与维护性。

     95. 相对导入和绝对导入

         相对导入:相对于被导入模块的路径, .表示当前目录   ..当前往上一级目录

         绝对导入:从sys.path开始的完整路径称之为绝对导入

     96. 相对路径和绝对路径

     97. 文件的两种执行方式，区别是什么？

         <1>.直接通过python解释器调用执行, __name__的值为__main__

         <2>.通过模块的导入执行的, __name__的值为模块名

         区别在于__name__的值不一样

     98. 什么是对象

         对象是特征与技能的结合体。

     99. 什么是类，面向对象编程为什么要有类

         类是一系列对象的相同特征与技能的结合体。在现实世界中是先有对象才有类的，但是在程序中，是先有类，才有对象的。

     100. 什么叫做面向对象是更高程度的一种封装

         将一系列的特征与技能封装到一个对象上面，只需要将对象给你，你就可以得到对象的特征和技能。

     101. 类的两种用途

         <1>.类本质上就是一个名称空间，我们可以通过类对名称空间进行增删改查

         <2>.用来创建对象，

             (1).创建一个空对象

             (2).创建对象的过程会自动的调用__init__方法，然后将对象本身作为第一个参数传递进去。

     102. __init__方法在什么时候会被触发

         在创建对象的时候会被自动的触发，并把空对象作为第一个参数传递给类。

     103. python3中类与类型是一个概念吗

         python3中统一了类与类型的概念

     104. 什么是继承

         子类可以重用父类的属性就叫做继承，它描述的是一种遗传的关系。我们可以通过继承来减少代码之间的冗余。

     105. 什么是组合

         一个对象的属性来自于另外一个对象的现象就称之为组合，也是为了减少类与类之间代码的冗余。

     106. 什么是多态

         描述的是一种事物的多种形态，在代码中主要为了统一标准。我们可以在不考虑对象的类型的情况下直接去使用对象下的方法。

     107. 什么是封装

         将类的数据属性进行隐藏的一种过程，这种隐藏并不是单纯的隐藏，是对内不对外的。

     108. 继承分为哪两类， 区别是什么

         <1>.单继承

         <2>.多继承

     109. 类分为哪两类， 区别是什么

         <1>.新式类: 继承了object类的子类，以及子类的子类...都称为新式类。

         <2>.经典类: 没有继承object类的子类，以及子类的子类...都称之为经典类。

         在python2中才会区分新式类和经典类，python3中默认都是继承object类的新式类

     110. 重用父类功能的两种方式， 分别有什么特点

         <1>.指名道姓的访问某个类中的问题，与继承无关。

         <2>.通过super(父类，self)方法去调用父类中的__init__方法，严格依照继承的关系

             调用super方法会得到一个特殊的对象，该对象是专门用来访问父类中的属性的，super会严格按照mro列表进行查找。

     111. 单继承背景下属性的查找顺序

         对象--->子类---->父类--->object类

     112. 多继承背景下属性的查找顺序（两类）

         菱形继承

             新式类:会从左到右，当左右的分支都查找不到的时候才会去查找聚合点

             经典类:会从左到右，但是在第一个分支的时候就会把聚合点给查找

         非菱形继承

             从左到右依次查找，一个分支查找完成之后才会查找另一个分支

     113. 封装的特点是什么？

         封装不是单纯意义上的隐藏，对外不对内的。

     114. 封装数据属性的目的

         将数据属性封装起来,类外部的使用就无法直接操作该数据属性了

         需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格

         控制使用者对属性的操作

     115. 封装函数属性的目的

         隔离复杂度

     116. 隐藏的__开头的属性有哪些特点（4个）

         (1). 只是一种语法意义上的变形,即__开头的属性会在检测语法时发生变形_类名__属性名

         (2). 这种隐藏式对外不对内的,因为在类内部检测语法时所有的代码统一都发生的变形

         (3). 这种变形只在检测语法时发生一次,在类定义之后新增的__开头的属性并不会发生变形

         (4). 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

     117. property装饰器主要是用来解决什么问题的

         有一些属性会跟随数据属性变化而变化，因此我们要把它设计成方法属性，为了让用户使用的时候像使用数据属性一样的，我们就需要在

         方法上面加上@property

     118. 什么是绑定方法与非绑定方法

         绑定方法:

             绑定对象的方法

             绑定类的方法

         非绑定方法: 就像正常的函数一样

     119. classmethod装饰器是用来绑定什么的

         绑定类的

     120. staticmethod装饰器是用来绑定什么的

         绑定对象的

     121. 什么是反射？

         反射就是想通过字符串的形式来对对象的属性进行增删查改

     122. 反射的四个方法（增删改查）

         hashattr(obj, 'name')

         setattr(obj, 'name', 'egon')

         delattr(obj, 'name')

         getattr(obj, 'name')

 组件

     is              比较的是两个地址

     ==              比较的两个变量的值

     id              打印出来的是变量的内存地址信息

     input           python中交互关键字

     global          全局变量

     nonlocal

     __all__         在模块的导入过程中，我们可以通过__all__来控制外部可以使用此模块的哪些内容

     __name__        执行文件的两种方式会导致__name__的值不一样, 直接执行__name__==__main__,导入模块执行会__name__等于模块名

     sys.modules     当前内存中加载的模块名称mdcmd,是字典的形式

     sys.path        当前的系统路径,不是内置模块，内存中也不存在此模块的时候，就会按照顺序到sys.path这个列表中去查询

     __init__方法     在类中出现的，当创建对象的时候会自动的调用此方法，并把创建的空对象当做第一个参数传递进去

     __init__文件     在包中出现的，用来导入包内的其他模块。在导入包的时候其实执行的__init__模块

     __dict__        对象或者类去查看名称空间用的，是一个字典

     __file__        当前文件的绝对路径,(win中也就是从盘符开始的路径)

     super函数        目前学到的只是继承父类的属性的时候用到的，super(父类名，self).方法名, 会给我们返回一个特殊的对象，按照mro列表中的顺序进行属性查找的。

     __str__         在类中创建一个__str__方法, 一定要有返回值，否则会报错，这样直接print(对象)的时候会给我们打印返回的值

     __del__         在类中创建一个__del__方法，在方法中删除系统资源，代表在对象被删除的时候会给我们自动的删除没有被回收的系统资源

     continue:       不执行当前continue之后的代码, 直接进入下一次循环, 不应该将continue作为最后一步执行的代码

     break           跳出当前循环

     while...else    不是因为break而跳出循环的时候就会执行else的代码

     a, b, *_ = [1, 2, 3, 4]      在解压赋值的时候，如果我们不想要后面的一些值就需要以这样的方式来书写

     __iter__        在迭代器和可迭代对象的时候学习的，使用此方法之后会把可迭代对象转换成迭代器对象

     __next__        具有此方法的对象都是迭代器对象，我们可以通过这个方法获得迭代器对象的值

     lambda          匿名函数   lambda  参数一, 参数二: 表达式   返回值就是表达式的值

 数据类型

     进制之间的转换问题：

         hex(256)    十进制转成十六进制      将十六进制转成十进制int('0x100', 16)

         oct(256)    十进制转成八进制        将八进制转成十进制int('0o400', 8)

         bin(256)    十进制转成二进制        将二进制转成十进制int('0b100', 2)

     int

         int()       没有参数就返回0

         int(0.7)    是浮点就省略后面的值

         int('')    字符串转换只能是里面只能是整形

     float

         float()     没有参数返回0.0

         float('')

         float('1.1')    字符串可以带有小数点

     str 任何类型都是可以转换成字符串类型的

         strip()             去除两边的特定字符，可以去除多个字符'abcdefabc'.strip('abc')===》'def'

         split()             以特定的字符分割字符串s.split('*', 2)  # 从左往右以*为分割点分割两次

         join()              将列表，元祖，字典转换成str的方法，拼接的值里面必须是字符串类型的，否则会报错

         endswith        以什么结尾

         startswith      以什么开始

         upper           全部变成大写

         lower           全部变成小写

         replace         参数一为旧值，参数二为新值，参数三为替换的次数，默认是全部

         find, index     找对应的索引，index找不到报错，find找不到返回-1，找到的时候返回索引的位置

         rfind, rindex   其实就是找最后一个的索引位置

         不常用的方法：

             captilize   第一个字符大写  '*ab'.capitalize()===》'Ab'

             title       每个单词首字母大写  'abc*ab'.title()===》'Abc*Ab'

             swapcase    大小写反转

             center()    第一个参数是个数，第二个参数是字符

             ljust       s.ljust(10, '*')====>hello*****

             rjust       s.rjust(10, '*')====>*****hello

             zfill       在字符串左边 填充0

     list 任何可迭代类型的数据都可以被转换成列表

         修改的方法

             增: append，insert, extend

                 append 把一个整体添加到列表的最后面

                 insert 把一个数据整体的添加到索引的位置上面，第一个参数是索引，第二个参数是数据

                 extend 把可迭代类型的数据一个一个的添加到列表的最后面

             删: pop, remove

                 pop    根据索引删除值并且将删除的值返回回去

                 remove  根据列表的内容删除一个值，没有则报错

         index，count

             index 根据索引找到对应的值，找不到则报错

             count 计算当前值出现的次数

         copy，clear

             copy  复制一个相同的列表

             clear 清空当前列表

         sort, reverse

             sort 排序默认是升序，当参数reverse=True的时候就是倒序，排序的列表中必须全部是数字或者字母，否则会报错

             reverse 反转

     dict 只能转换如下类型[('name', 'hu'), ('age', 18)], 字典的key必须是不可变类型

         python2和python3在处理字典的时候会返回不一样的值，python3会返回一个迭代器，而python2直接会把值给返回出来

         copy，clear

             copy  复制一个相同的字典

             clear 清空当前字典

         get     如果字典中不存在key，不会报错，会返回一个None. a.get('sex')

         pop     根据key去删除字典的值，并且会把删除key对应的value返回回来， key不存在就报错

         popitem     随机的删除一个键值对，并把键值对以元祖的形式返回回来，如果key不存在则报错

         update      和列表的extend很相似，原字典中有这个key直接更新，没有就添加

         fromkeys

             #fromkeys可以通过已经给定的key快速的创建一个初始化的字典

             res1 = {}.fromkeys('str', None)

             res2 = {}.fromkeys(['name', 'age', 'sex'], None)

             print(res1)

             print(res2)

             # 结果

             # {'s': None, 't': None, 'r': None}

             # {'name': None, 'age': None, 'sex': None}

         setdefault

             # setdefault有两个参数，第一个参数是key，如果key在原字典中存在，则直接返回原字典对应的key的值

             # 如果原字典中key不存在，则添加key到原字典中，value的值为第二个参数，并且返回第二个参数

             a = {'name': 'hu', 'age': 18}

             res = a.setdefault('sex', None)

             print(a, res)

             # 结果：

             # {'name': 'hu', 'age': 18, 'sex': None} None

     tuple

         index   寻找值所对应的索引,找不到则报错

         count   寻找值出现的次数

     set 值必须是不可变类型, 集合是无序不重复的

         集合运算

             交集          【&】符号代表交集

             并集          【|】符号代表并集

             差集          【-】符号代表差集，有顺序之分print(linuxs - pythons)  # 在linux中但是不在python中

             对称差集        【^】符号代表对称差集

             父子           【>=】父子关系

         集合方法

             add         添加值如果存在，就不变

             pop         随机删除一个，并把结果返回

             remove      删除元素，元素不存在就报错

             discard     元素如果存在就删除，不存在就不变

             update      将一个集合更新到一个集合中，如果有则不变，没有则添加

             isdisjoint  如果两个集合灭有交集，返回True

 文件操作的方法

     1. 不需要参数

         readable        查看当前文件句柄是否可读

         writeable       查看当前文件句柄是否可写

         tell            查看当前指针距离文件头的字节个数

         close           关闭当前文件

         flush           将当前缓冲区的内容刷新到文件中

         fileno

         isatty

     2. 需要一个参数（只有在rt模式下读取的才是字符）

         read            默认读取文件内的所有内容，传入一个参数代表读出几个字节的

         readline        读取当前指针所在行的值，传递的参数代表的是读取几个字节

         readlines       把每一行的值转换成bytes类型，最后返回一个列表

         write           将内容写入到文件中

         writelines

             # 下面这两种方法是一样的

             for i in line:

                 f.write(i)

             f.writelines(line)

     3. 需要两个参数

         seek    第一个参数代表移动的字节数，第二个参数0代表开头，1代表当前位置，2代表文件末尾

 内置函数（64个,目前只是写了自己还不是很熟悉的）

     max         求最大值, res = max(salaries, key=lambda key: salaries[key]), key是比较标准

     min         求最小值,

     sorted      从大到小顺序排列   sorted(salaries, key=lambda key: salaries[key], reverse=True)

     filter      过滤 res = filter(lambda item: not item.endswith('_dsb'), test) 如果不是以_dsb结尾的就保留下来，返回一个迭代器

                 它不能向map和reduce一样对数据进行修改, 应用想去掉列表中的某个值x

     reduce      reduce需要导入才能进行使用

                 # 求1-100的和

                 # 这第三个参数是初始值，如果没有，则会从迭代对象中找到一个值赋值给它

                 from functools import reduce

                 res = reduce(lambda x, y: x + y, range(100), 100)

                 print(res, type(res))

                 # 拼接字符串

                 test = ['yuanhao_dsb', 'egon_dsb', 'wupeiqi_dsb', 'alex_dsb', 'egon']

                 from functools import reduce

                 res = reduce(lambda x, y: x + y, test, '')

                 print(res, type(res))

                 应用在拼接字符串或者是数字的叠加过程

     map         映射  res = map(lambda item: item + '_dsb', lists)将lists的每个参数传递给item进行映射之后返回一个迭代器

                 应用在对某一类值进行修改

     sum     sum就是单纯的求和

     round    对浮点数进行四舍五入取值

     power   返回幂运算值或者与其指定的数值的模

     divmod  返回两个数值的商和余数

     dir    返回对象或者当前作用域内的属性列表

     ascii  返回对象的可打印表字符串表现方式

     vars  返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

     all   判断可迭代对象每个元素是否都是True

     any　　判断可迭代对象中是否又True的元素

     zip   聚合传入的每个迭代器中的相同位置的元素，返回一个新的元祖类型迭代器

     reversed   反转序列生成新的可迭代对象

     bytearray    根据传入的参数创建一个新的字节数组

     bytes     根据传入的参数创建一个新的不可变字节数组

     memoryview  根据传入的参数创建一个新的内存查看对象

     frozenset  根据传入的参数创建一个新的不可变集合

     enumerate   根据可迭代对象创建枚举对象

     slice   根据传入的参数创建一个切片对象

     super   根据传入的参数创建一个新的子类和父类的关系的代理对象

     object  创建一个新的object对象

 常用模块（14个）

     time

         time.time()  1539593357.4160235

         time.localtime()  做为一种中间格式用来转换不同的时间格式

         time.strftime('%Y-%m-%d %X')   '2018-10-15 16:57:24'

         time.asctime()      'Mon Oct 15 18:23:37 2018'

         time.ctime()    'Mon Oct 15 18:23:44 2018'

         time.asctime(b)   # 通过asctime把结构化时间转换成固定的外国人接受的时间

         time.ctime(a)  # 通过ctime将时间戳转换成外国人能够接受的时间

     datetime

         datetime.datetime.now()    获取当前时间       2018-10-15 18:40:17.028194

         datetime.datetime.fromtimestamp(time.time())  将时间戳转换成对应的时间

         datetime.datetime.now() + datetime.timedelta(hours=3) 将当前时间加上三个小时

         c_time.replace(month=11, year=2020, minute=10)  替换c_time的时间

     sys

         1. sys.argv    # 这个是传入的参数，返回的是列表的形式，第一个是当前执行文件的名称

         2. sys.path　　 # 系统的环境变量，可以通过append方法进行更改

         3. sys.modules　　# 内存已经加载的模块，以字典的形式存在

         4. sys.version　　# 解释器的版本

         5. sys.platform   # 当前执行的平台

         6. sys.exit()    # 退出当前执行的python解释器

         # 了解

         7. sys.api_version   # api版本号

         8. sys.maxsize　　# 最大值得整数32位为 2 ** 32 - 1 64位为2 ** 64 -1

         9. sys.maxunicode   # 最大的unicode  0x10FFFF

     os

         1. 目录操作

             增

                 os.mkdir     创建一个单级目录

                 os.makedirs  创建多级目录，递归创建

             删

                 os.rmdir     删除一个目录

                 os.removedirs  递归删除目录，如果目录为空

             改

                 chdir       改变当前目录

                 pardir      当前执行目录的父目录

                 curdir      当前执行文件的目录

             查

                 getcwd()    获得当前解释器执行文件目录

                 listdir()   以列表的形式返回当前目录下面有什么内容

         2. 文件操作

             删

                 os.remove()   删除文件

             改

                 os.rename()   修改文件名称

             查

                 os.stat        查看当前文件的状态信息

                 os.path.getsize()   查看当前文件的大小

                 os.path.getatime()   查看当前文件的创建时间

                 os.path.getmtime()   查看当前文件的修改时间

         3. 变量信息

             os.stat     # 文件的状态信息

             os.name     # win是‘nt’， linux平台是'posix'

             os.sep      # 操作系统特定的路径分隔符

             os.linesep  # 换行符win为'\t\n', linux为'\t'

             os.pathsep  # 分割文件路径的字符串win为;, linux为：

             os.environ  # 系统环境变量

             os.system() # 运行shell命令，直接显示

         4. 路径的判断

             os.path.exists()   # 判断路径是否存在

             os.path.isfile()   # 判断是否是个文件

             os.path.isdir()    # 判断是否是个目录

             os.path.join()     # 拼接路径

         5. 路径操作

             os.path.split()  # 以列表的形式返回文件名和目录

             os.path.basename # 获得得就是split的文件名

             os.path.dirname  # 获得得就是split的目录

         5. 规范化路径

             os.path.normcase()  # 将大写变小写，并将所有斜杠转成反斜杠(返回的是原字符串)

             os.path.normpath()  # 会把反斜杠转换成斜杠，然后可以识别相对路径

             os.path.abspath()   # 返回path规范化的绝对路径

     random

         random.random()   # 得到一个（0-1）之间的浮点数

         random.uniform(1, 3)  # 得到一个(1, 3)之间的一个小数

         random.randint(1, 3)  # 得到一个[1, 3]之间的整数

         random.randrange(1, 3)   # 得到一个[1, 3)之间的一个整数

         random.choice([1, '', [4, 5]])  # 获得列表中的一个值

         random.choices([1, '', [4, 5]], k=2)   # 获得列表中的两个值返回一个列表

         random.sample([1, '', [4, 5]], k=2)  # 列表元素任意2个组合

         # 打乱顺序

         l = [1,2,3,4,5]

         random.shuffle(l) # 传递的必须是一个列表

     hashlib

         password = hashlib.md5(''.encode('utf-8'))

         password.update(''.encode('utf-8')

         password.hexdigest()

     json, pickle

         f.write(pickle.dumps(user))

         pickle.dump(user, f)

         pickle.load(f)

         res = pickle.loads(f.read())

     shelve

         import shelve

         # shelve只有一个open函数

         # 打开文件，文件可以存在也可以不存在，

         f = shelve.open(r'shelve.txt', writeback=True)

         # 在关闭之前可读可写参数writeback=True代表的是否可以进行修改

         # f['user'] = {'name': 'hu'}

         print(f['user'])

         f['user']['sex'] = 'male'

         f.close()

     shutil

         文件处理：

             shutil.copyfileobj  传入的是两个对象，源文件，目的文件

             shutil.copyfile     传入的是两个路径，原路径，目的路径

             shutil.copymode     只复制文件的权限，目的恩瑾可定是要存在

             shutil.copystat     只复制文件的状态信息，修改时间，查看时间，更改时间，flag是

             shutil.copy         拷贝文件和权限

             shutil.copy2        拷贝文件和状态信息

             shutil.move()       更改文件名称

         文件夹处理

             shutil.copytree     拷贝目录

             shutil.ignore_patterns  根据这个模块去设置是否不拷贝某个类型的文件

             shutil.rmtree       删除目录

         压缩包处理

             shutil.make_archive()    压缩后的目录名称，格式，源目录

             shutile.unpack_archive() 压缩后的目录名称， 格式，解压后的目录

             tarfile.open().add()

             zipfile.ZipFile().write()

     xml

         import xml.etree.ElementTree as ET

         tree = ET.parse('xml文件名称')

         root = tree.getroot()

         .......一系列的标签查找与替换操作

         root.iter('标签名称')

         root.find('标签名称')

         root.findall('标签名称')

         node.text     标签内容

         node.attrib    标签属性

         node.tag        标签名

         node.set('属性名', '属性值')

         tree.write('xml文件名称')

     configparser开始的标准写法

         import configparser

         config = configparser.ConfigParsesr()

         config.read('a.txt', encoding='utf-8')

         .....一系列检查修改操作之后

         config.sections()

         config.get('某个分区', '某个key')

         config.set('某个分区', '某个key', 'value')

         config.has_section('某个分区')

         config.has_option('某个分区'， 'key')

         config.write(open('conf.cfg', 'wt', encoding='utf-8'))

     logging  日志模块的使用方法

         import logging.config

         logger = logging.config.dictConfig(config=配置文件里面的配置字典)

         return logging.getLogger('日志生成器的名称')

     re

         位置匹配

             \A 开头

             \Z 结尾

             ^  开头

             $  结尾

         范围匹配

             \d   数字   （\D相反是非数字）

             \w   数字字母下划线  （\W相反）

             \s   空字符(\t\n\f\b) （\s相反）

             [...]   手动指定范围，ascii码表返回

             [^...]  指定范围以外的内容

         重复匹配

             *   0次或者多次

             +   一次或者多次

             ?   0次或者一次     非贪婪模式

             {n} 精确匹配前面n个表达式

             {n, m} 匹配n到m次由前面的正则表达式定义的片段，贪婪模式

         分组

             ()括号内的表达式是一个分组

     subprocess

         cmd = 'dir H:\python_study\day23'

         find = 'findstr "py"'

         sub1 = subprocess.Popen(cmd,

                                 stdout=subprocess.PIPE,

                                 shell=True,)

         # 把sub1的标准输出输入到sub2的输入中

         sub2 = subprocess.Popen(find,

                                 stdout=subprocess.PIPE,

                                 stdin=sub1.stdout)

         print(sub2.stdout.read().decode('gbk'))

 小工具

     cp拷贝文件

     递归实现二分法的过程

     递归实现冒泡排序的过程

 logging的常用配置文件内容

     """日志配置文件内容"""

     from conf import settings

     import os

     # from lib.common import get_config_module

     STANDARD_FORMAT = '%(asctime)s %(name)s %(funcName)s %(module)s %(message)s'

     SIMPLE_FORMAT = '%(asctime)s %(module)s %(message)s'

     COMPLETE_FORMAT = '%(asctime)s %(name)s %(funcName)s %(lineon)s %(module)s %(message)s'

     # 拼接日志文件存储路径

     LOGFILE_PATH = os.path.join(settings.LOG_DIR, 'atm_log', 'atm.log')

     USER_LOGFILE_PATH = os.path.join(settings.LOG_DIR, 'usr_log', 'usr_log')

     # print(LOGFILE_PATH, USER_LOGFILE_PATH)

     # 这个就是之前通过手工的方式创建的四个日志核心组件

     LOGGING_DIC = {

         # 日志字典的版本，这个自己设置的

         'version': 1,

         # 日志格式定义字段，通过一定格式的字符串进行创建

         'formatters': {

             # 定义了日志的表示格式标准格式，简单格式和完整格式

             'standard': {

                 'format': STANDARD_FORMAT

             },

             # 简单格式

             'simple': {

                 'format': SIMPLE_FORMAT

             },

             # 完整格式

             "complete":{

                 "format": COMPLETE_FORMAT

             }

         },

         # 日志过滤器，暂时设置成空

         'filters': {},

         # 日志处理器

         'handlers': {

             # 定义了两种日志处理器

             # 把日志内容打印到终端

             'console': {

                 'level': 'DEBUG',  # 日志级别

                 'class': 'logging.StreamHandler',  # 日志流处理器

                 'formatter': 'simple'   # 使用的打印格式是上面设置的simple

             },

             'default': {

                 'level': 'DEBUG',

                 'class': 'logging.handlers.RotatingFileHandler',   # 设置文件通过一定大小之后就换文件

                 'formatter': 'standard',  # 写入文件的格式是上面定义的标准格式

                 'filename': LOGFILE_PATH,  # 写入文件的路径

                 'maxBytes': 1024 * 1024 * 5,  # 日志文件的最大大小为5M 超出后 换文件

                 'backupCount': 5,   # 最多留五个日志文件

                 'encoding': 'utf-8',     # 写入的时候编码方式

             },

             'user_stream': {

                 'level': 'DEBUG',

                 'class': 'logging.handlers.RotatingFileHandler',  # 设置文件通过一定大小之后就换文件

                 'formatter': 'standard',  # 写入文件的格式是上面定义的标准格式

                 'filename': USER_LOGFILE_PATH,  # 写入文件的路径

                 'maxBytes': 1024 * 1024 * 5,  # 日志文件的最大大小为5M 超出后 换文件

                 'backupCount': 5,  # 最多留五个日志文件

                 'encoding': 'utf-8',  # 写入的时候编码方式

             },

         },

         # 日志生成器

         'loggers': {

             # 在getLogger的时候  如果指定的名称 不存在 或者不给名称 用的就是默认的

             # 在这里如果key为空 它就是默认的

             # 你可以自己定义生成器的名称 并且他们还能使用相同的默认配置

             '': {

                 'handlers': ['default'],

                 'level': 'DEBUG',

                 'propagate': False,

             },

             # 在getLogger的时候  如果指定的名称 不存在 或者不给名称 用的就是默认的

             # 在这里如果key为空 它就是默认的

             # 你可以自己定义生成器的名称 并且他们还能使用相同的默认配置

             'user_log': {

                 'handlers': ['user_stream', 'console'],

                 'level': 'DEBUG',

                 'propagate': False,

             },

         },

     }

 format参数中可能用到的格式化串：

     %(name)s Logger的名字

     %(levelno)s 数字形式的日志级别

     %(levelname)s 文本形式的日志级别

     %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有

     %(filename)s 调用日志输出函数的模块的文件名

     %(module)s 调用日志输出函数的模块名

     %(funcName)s 调用日志输出函数的函数名

     %(lineno)d 调用日志输出函数的语句所在的代码行

     %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示

     %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数

     %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

     %(thread)d 线程ID。可能没有

     %(threadName)s 线程名。可能没有

     %(process)d 进程ID。可能没有

     %(message)s用户输出的消息

 时间中可能用到的格式化字符串

     %a    Locale’s abbreviated weekday name.

     %A    Locale’s full weekday name.

     %b    Locale’s abbreviated month name.

     %B    Locale’s full month name.

     %c    Locale’s appropriate date and time representation.

     %d    Day of the month as a decimal number [01,31].

     %H    Hour (24-hour clock) as a decimal number [00,23].

     %I    Hour (12-hour clock) as a decimal number [01,12].

     %j    Day of the year as a decimal number [001,366].

     %m    Month as a decimal number [01,12].

     %M    Minute as a decimal number [00,59].

     %p    Locale’s equivalent of either AM or PM.    (1)

     %S    Second as a decimal number [00,61].    (2)

     %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)

     %w    Weekday as a decimal number [0(Sunday),6].

     %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)

     %x    Locale’s appropriate date representation.

     %X    Locale’s appropriate time representation.

     %y    Year without century as a decimal number [00,99].

     %Y    Year with century as a decimal number.

     %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].

     %Z    Time zone name (no characters if no time zone exists).

     %%    A literal '%' character.