python基础知识你学会了多少
前言
学习是一个循序渐进的过程，不在于你学了多少，而在于你学会了多少。(装个b好吧，hhhh)
知识总结
之前一直想在网上找一个总结好的笔记，但是一直都没有找到，因此下定决心要总结一下，里面的都是在学习的过程中学到的一些最基础的一些概念啊，类型啊，方法啊之类的额，真的是花费了不少的时间，当然大佬请绕过好吧。。
概念
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.
知识总结
分割线-----------------------------------------------------------------------下面都是没有带答案的
一. 概念题
. 编程
. cpu, 内存，硬盘
. 运行程序，硬件的工作过程
. 进制之间的转换
. 操作系统
. 编程语言的分类
机器语言
汇编语言
高级语言
编译型语言
解释性语言
. 执行python程序的两种方式
. 变量
变量的命名规范
变量名的命名风格
变量的三个特征
常量
常量的命名规范
. 引用计数
. 数据类型
. python2和python3的区别
. 运算
比较运算
赋值运算
增量赋值
链式赋值
交叉赋值
解压赋值
逻辑运算
身份运算
. 运行python程序的三个步骤
. 小整数池
. if判断的四种语法
. 结束while循环的两种方式
. while else的用法
. for主要用来做循环取值
. 可变类型与不可变类型是按照什么标准划分的
. 计算机系统分为哪三层
. 字符编码
编码和解码
解决乱码的核心法则
python2默认的编码方式
python3默认的编码方式
#coding:文件头的作用
. 字符编码的操作核心法则（3条）
. 文件
. 文件处理的三个步骤
. 上下文管理的方式
. 操作文件内容的三种纯净模式
. 控制文件内容格式的两种模式
. 文件指针移动的单位是字节还是字符
. 文件是否可以修改？
文件'修改'的两种方式
. 函数
. 函数的分类
. 使用函数的原则
. 函数的两个明确阶段
. 函数定义的三种形式
. 函数调用的三种形式
. return的特点
yield的特点
. 函数参数的两大类
形参（形参又分为几类）
实参（实参又分为几类）
. 为什么说函数是第一类对象？
. 函数与变量的四种使用方式
. 函数的嵌套定义以及其应用场景
. 函数的嵌套调用以及其应用场景
. 什么是名称空间
. 名称空间的分类（三类）
. 名称空间的产生顺序
. 名称空间的销毁顺序
. 什么是作用域
. 作用域的分类（两种）
. 作用域关系的核心要义（一句话）
. 什么是闭包函数
. 为函数体传值的两种方式（分别的特点）
. 什么是装饰器
. 装饰器的分类（两大类）
. 什么是语法糖
. 装饰器的语法糖
. 有参装饰器的模板
. 无参装饰器的模板
. 叠加装饰器的加载顺序
. 叠加装饰器的执行顺序
. 什么是迭代器
. 迭代器的两个优点
. 迭代器的两个缺点
. 什么是可迭代对象
. 什么是迭代器对象
. python中的可迭代对象有哪些（6个）
. python中的迭代器对象有哪些（1个）
. for循环本质上是个迭代器循环，原理是什么（3步）
. 什么是生成器
. python中提供生成器的关键字
. 三元表达式
. 列表生成式
. 生成器表达式
. 字典生成式
. 什么是匿名函数
. 匿名函数的应用场景（2个）
. 什么是函数递归
. 递归要满足的两个原则
. 递归的两个明确的阶段
. 什么是面向过程编程
. 面向过程编程的优点和缺点
. 什么是面向对象编程
. 面向对象编程的优点和缺点
. 什么是模块
. 模块的作用
. 模块的分类（4类）
. 模块导入的两种方式，区别是什么
. import导入模块的三个步骤
. import导入的三种语法
. from导入模块的三个步骤
. from导入模块的三种语法
. 模块的搜索顺序
. 什么是包
. __init__文件是干什么用的
. __init__文件应该包含哪些内容
. 包的作用
. 相对导入和绝对导入
. 相对路径和绝对路径
. 文件的两种执行方式，区别是什么？
. 什么是对象
. 什么是类，面向对象编程为什么要有类
. 什么叫做面向对象是更高程度的一种封装
. 类的两种用途
. __init__方法在什么时候会被触发
. python3中类与类型是一个概念吗
. 什么是继承
. 什么是组合
. 什么是多态
. 什么是封装
. 继承分为哪两类， 区别是什么
. 类分为哪两类， 区别是什么
. 重用父类功能的两种方式， 分别有什么特点
. 单继承背景下属性的查找顺序
. 多继承背景下属性的查找顺序（两类）
菱形继承
非菱形继承
. 封装的特点是什么？
. 封装数据属性的目的
. 封装函数属性的目的
. 隐藏的__开头的属性有哪些特点（4个）
. property装饰器主要是用来解决什么问题的
. 什么是绑定方法与非绑定方法
. classmethod装饰器是用来绑定什么的
. staticmethod装饰器是用来绑定什么的
. 什么是反射？
. 反射的四个方法（增删改查）
二. 零散的知识点
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 参数一, 参数二: 表达式 返回值就是表达式的值
三. 数据类型
数据类型
int
float
str
list
tuple
dict
set
四. 文件操作的常用方法
文件操作的方法
read
write
readline
readlines
writeline
writelines
seek
tell
五. 常用模块
常用模块（14个）
time
datetime
sys
os
random
shutil
pickle
shelve
json
xml
configparser
logging
re
hashlib
subprocess
七. 内置模块
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对象
。
python基础知识你学会了多少的更多相关文章
- Python开发【第二篇】：Python基础知识
Python基础知识 一.初识基本数据类型 类型: int(整型) 在32位机器上,整数的位数为32位,取值范围为-2**31-2**31-1,即-2147483648-2147483647 在64位 ...
- python基础知识（二）
以下内容,作为python基础知识的补充,主要涉及基础数据类型的创建及特性,以及新数据类型Bytes类型的引入介绍
- python 基础知识(一)
python 基础知识(一) 一.python发展介绍 Python的创始人为Guido van Rossum.1989年圣诞节期间,在阿姆斯特丹,Guido为了打发圣诞节的无趣,决心开发一个新的脚本 ...
- python基础知识讲解——@classmethod和@staticmethod的作用
python基础知识讲解——@classmethod和@staticmethod的作用 在类的成员函数中,可以添加@classmethod和@staticmethod修饰符,这两者有一定的差异,简单来 ...
- python爬虫主要就是五个模块：爬虫启动入口模块，URL管理器存放已经爬虫的URL和待爬虫URL列表，html下载器，html解析器，html输出器 同时可以掌握到urllib2的使用、bs4（BeautifulSoup）页面解析器、re正则表达式、urlparse、python基础知识回顾（set集合操作）等相关内容。
本次python爬虫百步百科,里面详细分析了爬虫的步骤,对每一步代码都有详细的注释说明,可通过本案例掌握python爬虫的特点: 1.爬虫调度入口(crawler_main.py) # coding: ...
- python 爬虫与数据可视化--python基础知识
摘要:偶然机会接触到python语音,感觉语法简单.功能强大,刚好朋友分享了一个网课<python 爬虫与数据可视化>,于是在工作与闲暇时间学习起来,并做如下课程笔记整理,整体大概分为4个 ...
- python基础知识小结-运维笔记
接触python已有一段时间了,下面针对python基础知识的使用做一完整梳理:1)避免‘\n’等特殊字符的两种方式: a)利用转义字符‘\’ b)利用原始字符‘r’ print r'c:\now' ...
- Python基础知识（五）
# -*- coding: utf-8 -*-# @Time : 2018-12-25 19:31# @Author : 三斤春药# @Email : zhou_wanchun@qq.com# @Fi ...
- Python基础知识（Basic knowledge）
Python基础知识(Basic knowledge) 1.认识Python&基础环境搭建 2.Python基础(上) 3.Python基础(中) 4.Python基础(下) 5.Python ...
随机推荐
- 剑指offer相关问题
1. 变态跳台阶 Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+..........+Fib(n-n) =Fib(0)+Fib(1)+Fib(2)+..... ...
- switch与java
switch结构可以更好的解决等值判断问题switch 选择结构的语法:switch (表达式){case 常量 1://代码块1:break;case 常量 2://代码块2:break;..... ...
- Python实例---抽屉后台框架分析
1.1. 抽屉框架分析 --登陆注册分析 1.2. 前台获取form表单补充知识: <!DOCTYPE html> <html lang="en"> < ...
- 全网数据实时备份方案[inotify,sersync]
环境搭建 0.环境安装 gcc yum install gcc -y 1.安装inotify(源码软件包) 文件下载:https://files.cnblogs.com/files/ftl101 ...
- Linux traceroute命令详解
traceroute我们可以知道信息从你的计算机到互联网另一端的主机是走的什么路径.当然每次数据包由某一同样的出发点(source)到达某一同样的目的地(destination)走的路径可能会不一样, ...
- Exchange Server 2007 多名称证书配置
Exchange Server 2007上配置多名称证书,有两种方式,一种是通过Exchange Management Shell利用命令行工具进行创建:另一种是通过证书管理器控制台进行创建.本文将介 ...
- 使用NPOI 2.1.1读取EXCEL2003/2007返回DataTable
winform中打开excel的筛选器设置为:openFileDialog.Filter = "Excel 文件(*.xls)|*.xls;*.xlsx"; 一,不借助插件读取Ex ...
- CocoaPods -- ios项目中安装和使用CocoaPods
CocoaPods是什么? 当你开发iOS应用时,会经常使用到很多第三方开源类库,比如JSONKit,AFNetWorking等等.可能某个类库又用到其他类库,所以要使用它,必须得另外下载其他类库,而 ...
- Mof提权科普
今天再拿一个站的时候遇到了很多问题,拿站的过程就不说了,其中要用到mof提权,不管能不能提下,我进行一个mof提权的科普 这里我综合各类mof提权进行了 综合 首先说一下,无shell情况下的mysq ...
- 排序算法Java版，以及各自的复杂度，以及由堆排序产生的top K问题
常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结 ...