Python

python基础基本知识点分享！列出来学习python所要掌握的基础知识点，涵盖基本概念、数据类型、运算符、控制流程、函数、面向对象、文件、异常处理八个部分，想要学习python的朋友可以根据这个脉络进行学习！

Python

环境搭建

基础软件

typora

https://www.typora.io/

notepad++

https://notepad-plus-plus.org/

飞秋

http://www.feiq18.com/

博客园

python相关软件

python2

python3

pycharm

问题：找不到安装的python命令？

添加环境变量

码云和git

码云https://gitee.com/

git常见用法

git init

git add

git commit

git push

pycharm快捷方式

Ctrl + z ：撤销

Ctrl + d ：快速复制上一行

Ctrl + shift + z ：回退撤销动作

Ctrl + ? ：多行注释，第一次用注释，第二次取消注释

Tab ：补全

Ctrl + Alt + L ： 代码格式化

Ctrl + Alt + i ：自动缩进

入门

计算机基础

CPU

计算及的计算和逻辑处理中心，相当于大脑

内存

暂时存放数据的地方，临时加载应用程序的数据，断电即消失

读取数据速度快

常见的内存大小：4G、8G、16G、32G。。。

硬盘

长期存放数据的地方

1TB=1024GB 1GB=1024MB 1MB=1024KB

读取速度较内存慢

操作系统

一个软件，一个作为连接计算机硬件和其他软件媒介的软件

python基础

python历史

python崇尚优美、清晰、简单

在2004年，Django框架诞生

python版本

python2：源码不统一，冗余有很多重复代码

python3：源码进行了统一，更清晰简单

python应用领域

云计算

WEB开发

科学计算、人工智能

爬虫

金融

图形GUI

python优缺点

优点

优雅、明确、简单

开发效率高——有非常强大的第三方库

高级语言——无需考虑底层细节

可移植性——可以移植到几乎所有平台上运行

可扩展性——可以使用利用C或C++编写的部分程序

可嵌入型——可以把python嵌入到C或C++的程序中

缺点

运行速度慢

代码无法加密

线程无法利用多CPU

python种类

CPython ：python官方推荐，使用C语言实现，可以转化成C语言识别的字节码

Jython ：可以转换成Java识别的字节码

IronPython ：可以转换成.net语言能识别的字节码（C#）

pypy ：变成动态编译型，可以实现开发快和执行效率快

编程语言分类

编译型和解释型

编译型

将代码一次性全部编译成二进制，然后在执行

编译器：是把源程序的每一行都编译成机器语言，并保存成二进制文件

优缺点

优点：执行效率高，由于编译成了二进制文件，所以可以脱离语言环境独立运行

缺点：开发效率低，不能跨平台

代表语言：C、C++、Go

解释型

逐行解释成二进制，然后逐行执行

解释器：只在执行程序时，逐条语句的解释成机器语言给计算机执行

优缺点

优点：开发效率高，可以跨平台，修改灵活

缺点：执行效率低

代表语言：Python、Ruby、PHP

动态语言和静态语言

动态语言

运行期间做数据类型检查的语言

代表语言：Python、Ruby

静态语言

在编译期间检查数据类型，在写程序时要声明所有变量

代表语言：C、C++、java

强类型定义语言和弱类型定义语言

强类型定义语言

总是强制类型定义的语言，变量被指定类型后必须经过强制转换才能变成另一种数据类型

弱类型定义语言

数据类型可以被忽略的语言，变量可以被赋予不同类型的数据值

变量

变量简介

为什么需要变量？

当表达式过于复杂，不便于书写时可以赋值给一个变量

什么是变量？

变量是将临时的值存储在内存里

变量可以重复使用

如何定义变量？

name = "小明"

name：变量名称

= : 赋值

"小明" : 值

说明

变量只能指向数据，不能指向变量

变量名称在内存中是唯一的

变量是从右向左执行

命名规则

变量名称只能是字母、数字或下划线组成

变量名称不能以数字开头

python中的关键字不能作为变量名

不建议使用中文或拼音

变量名称最好有意义

变量名称最好不要过长

变量名称区分大小写

变量名称推荐：驼峰法、下划线

常量

什么是常量？

常量就是把变量的名称全部大写，一直保持不变的量

如何定义？

ID = 12345

一般常量用在配置文件中

注释

为什么需要注释？

进行解释说明，便于理解

如何注释？

单行注释

# 注释内容

当行注释

多行注释

'''多行注释'''或"""多行注释"""

多行注释时，第一个注释符要顶头写

在哪里使用？

在难以理解的代码后进行注释

在函数、类等进行注释

基础数据类型

为什么需要数据类型？

计算机并不能分清数字和字符串之间的区别，需要人为的进行定义区分

常见的数据类型

number —— 数字

string —— 字符串

list —— 列表

tuple —— 元组

set —— 集合

dictionary —— 字典

判断数据类型

type()

int 整型

范围

32位机器

-2**31～2**31-1，即-2147483648～2147483647

64位机器

-2**63～2**63-1，即-9223372036854775808～9223372036854775807

数值运算

+ ： 加

- ： 减

* ： 乘

/ ： 除

// ： 除法取整

% ： 取余

** ： 乘方

进制转换

十进制转二进制

二进制转十进制

str 字符串

什么是字符串？

在python中，用引号引起来的都是字符串

'字符串'

"字符串"

'''字符串'''

"""字符串"""

单引号和双引号没有区别，可以配合使用

当字符串内容需要换行时，可以使用三个单引号或三个双引号

字符串操作

字符串拼接 ： 都是字符串的情况下，利用 + 进行拼接

字符串的复制：字符串和整型用*连接，进行多次复制

索引

字符串中的每个字母都是一个元素

索引值从0开始，从左到右

索引值也可以从-1开始，从右到左

字符串方法

取值

按照索引取值

按照切片取值

顾头不顾尾

可以加步长

upper ：大写

lower ：小写

startswith ：判断字符串以。。开头

endswith ：判断字符串以。。结尾

replace ：替换

strip ：去掉首尾空格、\n，\t

split ：分割（分割后称为列表）

join ：拼接

count ： 统计次数

format ： 字符串格式化

isalnum ：判断字符串是否由字母，数字和中文组成

isalpha ：判断字符串由字母或中文组成

isdecimal ：判断字符串由十进制的整数组成

isdigit ：判断字符串由阿拉伯数字组成（不推荐）

capitalize ：首字母大写，其余小写

swapcase ：大小写反转

title ： 每个单词的首字母大写

center ： 居中

find ：通过元素找索引

index ： 通过索引找元素

bool 布尔型

True：真

False：假

str 为空时

int ：0

list：[]

tuple：()

dict：{}

set：set()

None

数据类型转换

str(x) ：将x转换成字符串型

int(x) ：将x转换成整型（前提必须为纯数字）

bool(x) ：将x转为布尔值，当x为数字时，非0即True；当x为字符串时，字符串为空时False

运算符

算数运算符

+ ：加

- ：减

* ：乘

/ ：除

% ：取余

** ：幂

// ：取整除

比较运算符

== ：等于

!= ： 不等于

> ：大于

>= ：大于等于

赋值运算符

=：简单的赋值运算符

+=：加法赋值运算符；例 a += 2 等价于 a = a + 2

-= ：减法赋值运算符；例：a -= 2 等价于 a = a - 2

*= ：乘法赋值运算符；例：a *= 2 等价于 a = a * 2

/= ：除法赋值运算符；例：a /= 2 等价于 a = a / 2

%= ：取模赋值运算符；例：a %= 2 等价于 a = a % 2

**= ：幂赋值运算符；例：a **= 2 等价于 a = a ** 2

//= ：取整除赋值运算符；例：a //= 2 等价于 a = a // 2

逻辑运算符

and：和

都为真，取and后面的值

都为假，取and前面的值

一真一假，取假的值

or ： 或

都为真，取or前面的值

都为假，取or后面的值

一真一假，取真的值

not ： 非

优先级

() > not > and >or

同等优先级的情况下，从左到右依次计算

成员运算符

in

not in

用户交互

input

input交互得到的数据类型都是字符串

流程控制语句

结构

if...else

if ...if...if...

if...elif...elif...

if ...elif ..elif...else..

if ....if...else...else

if 嵌套最多嵌套3层

if...

while循环

在条件满足的情况下是个死循环

结构

while...

while...else...

如何终止循环

条件改变

break

break

退出循环

continue

退出当前循环，进行下次循环

编码

ASCII

美国信息交换标准编码

一个字符占用一个8位的二进制数表示

最多有256个字符，即2**8 = 256

8bit = 1Byte

GBK 国标

一个中文字符占用2个8位的二进制数，即16位；英文依然占8位

最多表示65535个字符，2**16 = 65535

兼容了ASCII，并扩充了中文

Unicode

收录了世界上全部的编码

扩充到了32位，即4个8位的二进制数

UTF-8

可变长编码

ASCII编码的用1个字节，欧洲字符用2个字节，中文字符用3个字节。。

单位转换

8bit = 1Byte

1024Byte = 1KB

1024KB = 1MB

1024MB =1GB

1024GB = 1TB

1024TB = 1PB

1024 PB = 1EB

1024EB = 1ZB

1024ZB = 1YB

1024YB = 1NB

1024NB = 1DB

编码和解码

encode()

dencode()

基础

for 循环

结构：for 变量 in 可迭代对象: 循环体

注意：数据类型中只有整型和布尔值不能被for循环

break ：跳出循环

continue ： 跳过本次循环，继续下次循环

range

类似列表，自定制范围的数据列表

顾头不顾尾

python3和python2区别

python2 ：默认是列表

python3 ：不是列表，是个可迭代对象，可以用list()转成列表

python2中的xrange 和python3中的range类似

列表

列表初识

为什么需要列表？

字符串只能存储少量数据

字符串存储数据类型单一

什么是列表？

可以存储任意数据类型，每个元素以逗号隔开

python常用的数据类型：list

列表是有序的

32位的python限制是536870912 个元素

64位python的限制是 1152921504606846975 个元素

在内存中如何存放？

在内存中开辟空间，存放每个元素的内存ID，可以用id()查看

修改列表中的元素时，是修改的列表内存空间中存放的元素的内存ID

列表的操作

列表的创建

方式一：lst = [1,2,"a"]

方式二： lst = list("abc")

方式三 ：列表推导式

增

append ：追加

insert ： 插入

extend ： 迭代追加

删

pop ： 按照索引删除

默认删除最后一个元素

有返回值

remove ：指定元素删除

clear ： 清空

del ：删除

按照索引删除

切片步长删除

删除列表

改

按照索引修改

按照切片修改

步长为1时，可以修改任意多的元素

步长>1时，修改的元素必须一一对应

查

按照索引查询

按照切片 + 步长查询

for循环

其他操作

index ：通过元素取索引

sort ：排序

reverse ：反转

+ ：列表相加

* : 列表和整型之间相乘，结果中元素的内存空间是共用的

列表的嵌套

元组

元组初识

元组就是只读列表，不支持增删改，但是元组里的可变数据类型可以更改

元组中只有一个元素的时候，要在元素后面加个逗号

存储大量数据，有序，不可变，支持索引

元组应用：

存储重要数据，防止更改，一般应用在配置文件中

元组的拆包

元组中如果只有一个元素，并且没有逗号，那么他就是不是元组，它与该元素的数据类型相同

元组操作

index ：根据元素查找索引

count ：统计个数

元组也可以进行 + * ，同列表

字典

字典初识

为什么需要字典？

列表可以存储大量数据，但是数据之间的关联性不强

列表的查询速度慢

什么是字典？

容器数据类型:dict

字典的格式？

{key1:value1,key2:value2}

字典的key必须是不可变数据类型：int ,str,bool,tuple；是唯一的，如果有重复的键，后面的键会覆盖前面的键的值

value 可以是任意数据类型

字典的特性

字典python3.5 版本及之前是无序的

字典python3.6 版本按照建立时的顺序排列的

字典python3.7版本是有序的

字典的查询速度非常快

字典的缺点：以空间换时间

字典操作

字典的创建

方式一：dic = dict((("a",1),("b",3),(1,"f")))

方式二：dic = dict(a=1,b=2)

方式三：dic = dict({"a":2,"b":5})

方式四：fromkeys

格式：dic = dict.fromkeys("abc",10)

增

直接增加

setdefault

字典里有相同的键时不会添加，没有相同的键会添加

删

pop ：根据key进行删除

有返回值

如果删除的是不存在的key，会报错，但是可以通过定义返回值规避报错

clear ：清空

del ：根据键删除

popitem：随机删除

但是只删除最后一个

改

直接修改

update

查

for 循环

按照键取值

get

当键不存在时可以设置返回值

keys() ：取出所有的key值

数据类型是个高仿列表，可以for循环，也可以通过list转为列表

values() ： 取出所有的value值

同上

items() ： 取出所有键值对

键值对放在元组里

解构

字典嵌套

集合

初识集合

python基础数据类型之一，集合:set

容器型数据类型

集合中的元素都是不可变的数据类型，但是集合本身是可变的

集合里的元素只能是bool,int,str,tuple

集合是无序的，没有索引

集合的特性：自动去重

集合操作

集合的创建

方法一：set1 = set({1,2,"abc",True})

方法二：set2 = {1,2,"abc"}

方法三：set("abc")

空集合

s1 = set()

增

add

update：迭代增加

删

remove：按照元素删除

pop：随机删除，有返回值

clear ：清空

del

改

先删后增

其他操作

& : 交集

| ：并集

- ： 差集

^ ： 反交集

> ： 超集

frozenset ： 冻结集合

数据类型总结

类型总结

有序

数字

字符串

列表

元组

无序

字典

集合

可变数据类型

列表

字典

集合

不可变数据类型

字符串

数字

元组

取值

索引取值

str，list，tuple

直接取值

set，int，bool

通过键取值

dict

类型转换

元组->列表 : list(tuple)

列表->元组 : tuple(list)

列表->字符串 : str.join(list)

字符串->列表 : str.split()

字典->字符串 : str(dict)

缓存机制

is 和 ==

is：判断内存空间是否相同

== ： 判断值是否相同

代码块

一个文件，一个函数，一个模块，一个类，终端中的一行命令就是一个代码块

前提条件：在同一代码块内，版本3.6版本以下

作用对象：int,str,bool

具体规则

int：>-5的数字在同一代码块小可以复用

bool：值相同内存空间相同

str：几乎所有的自付出你都符合

非乘法得到的字符串都复用

乘法>=2时，满足仅含大小写字母，数字，下划线，总长度<=20

中文，特殊字符乘法的时候只能乘1或0

小数据池

不同代码块的缓存机制，也被称为驻留机制

前提条件：在不同代码块下，版本3.6以下

具体规则

int：-5~256

布尔值：值相同内存空间相同

字符串

字符串长度0或1符合机制

字符串长度>1，且致函大小写字母，数字，下划线时才会默认驻留

乘数>=2时，仅含大小写字母，数字，下划线时，总长度<=20

深浅copy

赋值

多个标签贴在同一个内存空间上

浅拷贝

利用copy()生成新的列表外壳，新开辟内存空间，但是里面的元素都是共用的

浅拷贝后，修改源列表的元素时，新拷贝的列表不进行变化

修改源列表中可变数据类型中的元素时，新拷贝的列表进行变化

深copy

不可变的数据类型共用内存空间

可变的数据类型新开辟内存空间

文件操作

文件操作初识

文件打开需要什么参数？

文件路径

打开方式

编码方式

基本格式

f = open("C:\txt",encoding="utf-8",mode="r")

with open("C:\txt",encoding="utf-8",mode="r") as f

不需要手动close文件句柄

操作三部曲

打开文件

对文件句柄进行相关操作

关闭文件

常见问题

路径问题

Windows的路径分割符是\，可能会有不可预知的问题

解决方法：在路径最前方加个r

编码问题

UnicodeDecodeError：文件存储时与文件打开时用的编码不一致

文件的读

r

read()：全部读出来

read(n)：按照字符读取

readline()：按照行读取

readlines()：一行一行读取，并将每行作为一个元素存放在列表中

for ：循环句柄，适合大文件

rb

操作的是非文本文件，rb模式不需要设置encoding

r+

打开一个文件用于读写。文件指针默认将会放在文件开头

注意：在读写模式下，先写后读，那么文件中的默认光标是在开始，先写则写入的内容会将原内容覆盖，直到覆盖到你写完的内容，然后在后面开始读取

r+b

文件的写

w

文件不存在时新建文件并写入；文件存在时，先清空后写入

文件句柄关闭之后再以w模式打开才会再次清空，只要没有关闭就可以持续写入

wb

w+

w+b

文件的追加

a

文件不存在时，会新建文件，之后再追加；文件存在时，会直接在最后追加内容

ab

a+

a+b

文件的其他操作

tell()

可以获得光标的位置，查看的是字节数

seek()

seek(n)光标移动到n位置，注意：移动单位byte

seek(0)：移动到开头

seek(0,2)：移动到结尾

seek(0,1)：移动到当前位置

flush

强制刷新

文件的改操作

以读的模式打开原文件

以写的模式创建新文件

将原文件内容读出来，修改成新内容，写入新文件

将原文件删除或改名备份

将新文件重命名成原文件名称

函数

初识函数

函数的优点

减少代码的重复性

提高代码可读性

以功能为导向，一个函数封装一个功能

结构和调用

函数什么时候执行？

当遇到函数名() 函数会执行

内存级别

定义函数在内存中开辟空间存放函数体

返回值

return

在函数中，遇到return直接结束函数的运行

return可以返回值个函数的调用者，默认为None

return返回多个值用逗号隔开，以元组的形式

return不能终止循环

参数

参数划分

形参：写在函数声明的位置的变量叫形参

位置参数

默认参数

关键字参数

实参：在函数调用的时候给参数传递的值叫实参

关键字参数

一一对应，但是位置可以打乱

位置参数

根据参数的位置，从左到右，一一对应

混合参数

优先级：位置参数 、关键字参数、默认参数

三元运算符

c = a if a > b else b

动态参数

动态位置参数

*args

函数定义部分为聚合；其他部分使用为打散

函数中未打散之前是元组

动态关键字参数

**kwargs

函数内部打散只能得到字典里的键

函数中未打散之前是字典

万能传参

优先级

位置参数、*args 、默认参数、**kwargs

名称空间

名称空间分类

全局空间

在.py文件中，函数外声明的变量都属于全局命名空间

局部空间

在函数中声明的变量会放在局部命名空间

内置空间

存在python解释器为我们提供的名字

加载顺序

内置空间

全局空间

局部空间

取值顺序

就近原则

和加载顺序相反

作用域

全局作用域

全局空间+内置空间

局部作用域

局部空间

函数嵌套

只要在执行代码是遇到函数名()，就会代用函数执行

函数调用执行后，函数体中开辟的空间就自动销毁了

在全局空间中，多个函数之间的局部空间不能共享

globa nonlocal

global

声明一个全局变量

在局部作用域想要修改全局作用域的全局变量时，需要使用此参数

nonlocal

不能修改全局变量

在最外层的函数中修改局部空间的变量值

只修改离它最近的一层获取的值，最近的一层没有获取到值时继续向父级寻找，直到全局变量，但是不涉及全局变量

函数名（第一类对象）的应用

函数名可以赋值给其他变量

函数名可以当做容器类数据的元素

函数名可以当做函数的参数

函数名可以作为函数的返回值

f-string格式化输出

f-string是Python3.6开始加入的标准库的格式化输出新写法

结构：F(f) + str ,在字符串中想替换的位置用{}占位

{}中可以是任意表达式，但是注意特殊符号，需要转成字符串才可以

迭代器

可迭代对象

定义

字面意思就是一个可以重复取值的东西

在python中，，凡是内部含有__iter__()方法的对象，都是可迭代对象

可以利用dir()查看内部方法

优缺点

优点

可以直观的查看里面的数据

缺点

占用内存

可迭代对象不能迭代取值

迭代器

定义

从字面意思来说迭代器就是一个可以迭代取值的工具

专业角度：迭代器就是实现了无参数__next__方法，返回序列中的下一个元素，如果没有元素了，那么抛出StopIteration异常.python中的迭代器还实现了__iter__()方法，因此迭代器也可以迭代。

简单来说：python中，内部含有__iter__()方法并且含有__next__()方法的就是迭代器

可迭代对象转化成迭代器

s.__iter__()

iter(s)

取值

s.__next__()

next(s)

优缺点

优点

节省内存

惰性机制

缺点

不能直观的查看里面的数据

不能逆行

对比

可迭代对象

是一个私有方法较多，操作灵活，比较直观，但是占内存，而且不能直接通过迭代循环取值的这么一个数据集

迭代器

是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集

递归

递归不断调用自己本身

有明确的终止条件

一递一归

生成器

创建生成器方法

通过生成器函数

yield

yield和return区别

return一般在函数中只设置一个，作用是终止函数，并且给函数的调用者返回值

yield在生成器函数中可设置多个，不会终止函数，但会记住上次执行的位置，next会获取对应yield生成的元素

生成器可以通过for循环

yield from ：将可迭代对象逐个返回

通过生成器推导式

python内置函数或者模块提供

推导式

循环推导式

[变量(加工过的变量) for 变量 in 可迭代数据]

列表推导式

[i for i in range(10)]

生成器推导式

(i for i in range(10))

字典推导式

{i:i+1 for i in range(10)}

集合推导式

{i for i in range(10)}

筛选推导式

[变量(加工过的变量) for 变量 in 可迭代数据 if 条件]

列表推导式

[i for i in range(10) if i % 2 == 0]

生成器推导式

(i for i in range(10) if i % 2 ==0)

字典推导式

{i:i+1 for i in range(10) if i % 2 == 0}

集合推导式

{i for i in range(10) if i % 2 ==0}

内置函数

内置函数（一）

all()

可迭代对象中，全都是True才是true

any()

可迭代对象中，有一个True就是True

bytes()

用于不同编码之间的转化

callable()

用于检查一个对象是否是可调用的；如果返回True，仍然可能调用失败；但是返回False，调用对象绝对不会成功。

chr()

输入位置数字找出其对应的字符

complex()

复数

divmod()

计算除数与被除数的结果，返回一个包含商和余数的元组

eval()

执行字符串类型的代码，并返回结果

exec()

同上，功能更强大

frozenset()

冻结集合

hash()

获取一个对象的哈希值

help()

用于查看函数或模块用途的详细说明

id()

input()

int()

用于讲一个字符串或数字转换成整型

iter()

__iter__()

locals

查看当前空间的变量

globals()

查看全局空间的变量

next()

__next__()

oct()

八进制

hex()

十六进制

ord()

输入字符找到该字符编码的位置

pow()

幂，三个参数为x**y的结果对z取余

repr()

返回一个对象的string形式

round()

保留浮点数的小数位数，默认保留整数

float

用于将整数和字符串转换成浮点数

内置函数（二）

abs() ： 绝对值

enumerate() ：枚举

max() ：最大值

min() ：最小值

sum() ：求和

open() ： 文件操作

range() ：生成一个序列值

print()：打印

sep = 多个元素之间的连接符

end = 多个print结果的连接符

file = open()

zip() ：拉链

format()

format(13,">20")：右对齐

format(13,"<20")：左对齐

format(13,"^20") ：居中

format(13,"08b") ：二进制（指定位数）

format(13,"08d") ：十进制（指定位数）

format(13,"08o") ：八进制（指定位数）

format(13,"08x") ：十六进制（指定位数）

filter() :过滤

map()：对象映射

reversed()：翻转

把原数据拷贝在翻转

sorted() ：排序

原数据拷贝后再翻转

reduxe() ： 累计算

匿名函数

格式

lambda x:x

lambda：关键字

形参可以不写，返回值必须写

闭包

什么是闭包？

在嵌套函数内，使用非全局变量且不是本层的变量就是闭包

为什么需要闭包？

保证数据的安全性，把数据放在函数里，禁止了全局修改

装饰器的本质

装饰器

开放封闭原则

对扩展开放

对修改是封闭

什么是装饰器？

在不改变原被装饰的函数的源代码以及调用方式下，为其添加额外的功能

多个装饰器装饰一个函数

当被装饰的函数上方有多个装饰器时，先执行距离被装饰函数最近的装饰器

模块

模块的定义和分类

什么是模块？

本质就是py文件

为什么要使用模块？

从文件级别组织程序，更方便管理，

拿来主义，提升开发效率，实现功能的重复利用

模块的分类

内置模块

第三方模块

自定义模块

import

第一次导入模块执行的三件事

在当前空间创建一个以模块名命名的名称空间

执行这个名称空间里的代码

通过模块.的方式引用该模块里的内容

被导入模块有独立的名称空间

为模块起别名：import t1 as t

可以将很长的模块名改成很短，方便使用

有利于代码的扩展和优化

from...import....

使用from...import 则是将模块中的名字直接导入到当前的名称空间，所以在当前空间中，直接使用名字就可以了，无需加前缀

import

缺点：占用内存空间

优点：不会和当前空间的名称发生冲突

from...import...

缺点：容易与当前执行文件中的名字冲突

优点：节省内存空间

from...import *

把文件中所有不是以下划线开头的名字都导入到当前名称空间，大部分情况下不该使用这种方式，可能会导致变量名覆盖且可读性极差。

__all__ = ["可以被导入的函数名和变量名"] ：当导入的模块中有上面这句话时，from ... import *只会导入列表里的东西

py文件的功能

脚本：一个文件就是整个程序

模块：文件中存放着一堆功能，用来被导入

python为我们内置了全局变量__name__

当文件被当做脚本执行时：__name__ 等于__main__

当文件被当做模块导入时：__name__等于模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

if __name__ == '__main__':

模块的搜索路径

相对路径

绝对路径

读取顺序：内存中已加载的模块 >> 自定义模块 >> 内置模块 >> 第三方模块

内置模块

time模块

time.time() ：时间戳

time.sleep() ：睡眠，阻塞

time.strftime("%Y-%m-%d %H:%M:%S") ： 格式化字符串时间

%y : 两位数的年份表示（00-99）

%Y ：四位数的年份表示（000-9999）

%m ：月份（01-12）

%d ：月内的一天 （01-31）

%H ：24小时制（00-23）

%I ：12小时制（01-12）

%M ：分钟数（00-59）

%S ：秒数（00-59）

%a ： 本地简化星期名称

%A 本地完整星期名称

%b：本地简化的月份名称

%B ：本地完整的月份名称

%c：本地相应的日期标书和时间表示

%j ：年内的一天（001-366）

%P ：本地A,M或P,M的等价符

%U ：一年中的星期数（00-53）星期天为星期开始

%w：星期（0-6）

%W：一年中的星期数（00-53）星期一为星期开始

%x：本地相应的日期表示

%X：本地相应的时间表示

%Z：当地时区的名称

time.gmtime()、time.localtime() ： 结构化时间

time.strptime() ：字符串转结构化时间

time.mktime() ：结构化时间转时间戳

时间格式转换

时间戳 >> 结构化时间

time.gmtime(时间戳)

time.localtime(时间戳)

结构化时间 >> 时间戳

time.mktime(结构化时间)

结构化时间 >> 字符串时间

time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(1000000))

字符串时间 >> 结构化时间

time.strptime("2010-10-10 10:10:10","%Y-%m-%d %H:%M:%S")

datetime模块

datetime.now() ：当前时间

datetime(2019,12,12,20,30,01) ：格式化时间

t = datetime.now() print(t.timestamp())：当前时间转时间戳

datetime.strptime() ：字符串转datetime对象

datetime.fromtimestamp(time.time() ： 时间戳转格式化

now = datetime.now() now.strftime("%Y-%m-%d %H:%M:%S") ：datetime对象转字符串

datetime.now() - timedelta(hours=10) ： 时间加减

random模块

random.random() ： 随机返回（0，1）范围的一个浮点数

random.uniform(1,2) :随机返回（1，2）范围的一个浮点数

random.randint(1，3)：随机返回(1，3]范围的一个整数

random.randrange(1,10,2) 随机返回一个[1,10]范围内的奇数，可以设置步长

random.choice([2,3,5,6,[123]]) 随机返回列表里的一个元素

random.choices([2,3,5,6,[123]],k=2) 随机返回列表中的两个元素组成一个列表(会重复)

random.sample([1,2,3,4],k=2) 随机返回列表中的2个元素，在组成一个列表返回（不会重复）

random.shuffle() 打乱排列顺序

json模块

dumps

loads

dump

load

pickle模块

dumps

loads

dump

load

os模块

os.getcwd() :获取当前工作目录

os.chdir ：改变工作目录

os.curdir：返回当前目录

os.pardir ：获取当前目录的父级目录字符串名称

os.makedirs()：生成多层递归目录

os.removedirs()：若目录为空，则删除，并递归到上一级目录，依次类推

os.mkdir()：创建单级目录

os.rmdir()：删除单级空目录

os.listdir()：列出指定目录下的所有文件和子目录

os.remove()：删除一个文件

os.rename()：重命名文件

os.stat()：获取文件/目录信息

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

os.path.split()：将path分割成目录和文件名二元组返回

os.path.dirname()：返回path的目录。

os.path.basename()：返回path最后的文件名

os.path.exists()：如果path存在，返回True,否则返回False

os.path.isabs()：如果path是绝对路径，返回True

os.path.isfile()：如果path是一个存在的文件，返回True。否则返回False

os.path.isdir()： 如果path是一个存在的目录，则返回True。否则返回False

os.path.join()：将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime()：返回path所指向的文件或者目录的最后访问时间

os.path.getmtime()：返回path所指向的文件或者目录的最后修改时间

os.path.getsize()：返回文件或文件夹的大小

sys模块

sys.argv：当前文件运行，命令行参数list ，第一个元素是程序本身路径

sys.exit()：退出程序，正常退出exit(0)，错误退出exit(1)

sys.version：获取python解释器的版本信息

sys.path：返回模块的搜索路径

sys.platform：返回操作系统平台名称

hashlib模块

特点

bytes类型数据 >> hashlib算法 >> 固定长度的字符串

不同的bytes类型数据转化成的结果一定不同

相同bytes类型数据转化成的结果一定相同

过程不可逆

用途

密码的加密

加密的内容

将要加密的内容转成字节

文件一致性校验

md5计算的就是bytes类型的数据的转换值，同一个bytes数据用同样的加密方式转化成的结果一定相同，如果不同的bytes数据（即使一个数据只是删除了一个空格）那么用同样的加密方式转化成的结果一定是不同的

常见的加密

MD5

SHA1

SHA256

SHA512

collections模块

namedtuple: 生成可以使用名字来访问元素内容的tuple

deque: 双端队列，可以快速的从另外一侧追加和推出对象

Counter: 计数器，主要用来计数

OrderedDict: 有序字典

defaultdict: 带有默认值的字典

re模块

正则表达式

\w

匹配字母（包含中文）数字或下划线

\W

匹配非字母（包含中文）数字或下划线

\s

匹配任意的空白符，包含换行符和制表符

\S

匹配任意非空白符

\d

匹配数字

\D

匹配非数字

\A

从字符开头语匹配

\Z

匹配字符串的结束，如果只是换行，只匹配到换行前的结果

\n

匹配一个换行符

\t

匹配一个制表符

^

匹配字符串的开始

$

匹配字符串的结尾

.

匹配任意字符，除了换行符，当re.DOTALL时，可以匹配到换行符

[..]

匹配中括号中的所有字符

[^]

取反

*

匹配0个或者多个前面的字符；贪婪模式

+

匹配0个或多个前面的字符；贪婪模式

?

匹配0个或1个前面的字符；非贪婪模式

{n}

精准匹配n个前面的字符

{n,m}

匹配最少n个最多m个前面的字符，贪婪模式

a|b

或者

()

匹配括号内的表达式

常用方法

findall

全部找到返回一个列表

search

任意位置查找，匹配到一个后就停止，返回一个对象，需要使用.group() 获取

match

开头位置匹配，如果没有返回None

split

分隔

sub

替换

compile

定义匹配规则

finditer

返回一个迭代器

给分组起名字

re.search("(?P<sss>\w{2})",a)

模块和包

文件夹下含有__init__.py文件的就是一个包

绝对路径导入

相对路径导入

logging模块

日志级别

DEBUG

INFO

WARNING

ERROR

CRITICAL

logging参数

filename

日志存放的文件

filemode

文件打开方式，默认为”a“

format

指定日志显示格式

datefmt

指定日期格式

level

日志级别

stream

指定输出到。。

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

字符串形式的当前时间

%(thread)d

线程ID

%(threadName)s

线程名

%(process)d

进程ID

%(message)s

用户输出的信息

日志分类

系统日志i

网站日志

开发辅助日志

用户信息日志

目录规范

代码分类

加载快

可读性高

查询修改维护简单

目录结构

bin

start.py

conf

settings.py

core

src.py

db

user.json

lib

common.py

log

access.log

README.md

软件定位，软件的基本功能

运行代码的方法：安装环境，启动命令

简要的使用说明

代码的目录结构说明

常见问题说明

面向对象

初识面向对象

类的结构

静态变量

动态方法

对象：类的具体表现

类：具有相同属性和功能的一类事物

优点

面向对象编程：是一类相似功能函数的集合，是代码更清晰合理化

面向对象，要拥有上帝视角看问题,类其实就是一个公共模板，对象就从具体的模板实例化出来的

从类名角度研究类

如果想查询类中的所有内容，通过__dict__方法，如果只是操作单个属性则用万能的点的方式

类名操作动态方法

前提：除了两个特殊方法（静态方法，类方法），一般不会通过类名操作一个类中的方法

从对象角度研究类

对象是从类中出来的，只要是类名加()，这就是一个实例化过程，这个就会实例化一个对象

实例化一个对象的三件事

在内存中开辟一个对象空间

自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self

在__init__方法中通过self给对象空间添加属性

对象查询对象中所有属性：对象.__dict__

类中的方法一般都是通过对象执行的（除了类方法，静态方法），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self

self是什么

self其实就是类中方法（函数）的第一个位置参数；自动接收。所以把类中的方法的第一个参数约定成self，代表这个就是对象