python
Python
概述
python解释器
python是解释形语言，需要下载python解释器将编写的python代码解释为机械码
在python官网 python.org 中下载
python的代码编辑工具有 pycharm vscode 等
字符串
print("1")
print('qwq')
#字符串连接
print("1"+"qwq")
#换行符 \n
print("1qwq\nqwqqwqw")
# \转义字符
print("1qwq\"qwqw")
#三引号多行
print("""
qwqwqqw
qwqwqwq
""")
数据类型
整型： int 正常整数
浮点型： float 小数
布尔类型： bool 有2个值 True 和 Flase 首字母要大写
字符串： str(string的缩写) 可以使用[索引]来定位字符，索引从0开始
空类型： NoneType 在python中 空类型 为 None
可以使用 type()函数传入变量获取变量的类型
#字符串
str = "qwq"
print(str[0]) #打印q
#布尔类型
result = True #首字母要大写
result2 = False
#空值
n = None
#获取类型
print(type(str))
#可以使用 类型() 方法来转换变量类型
int(str)
变量
python中的变量声明不用指明类型
标识符：
标识符就是变量的名字，标识符的命名规则：
只允许出现： 中文，英文，数字，下划线( _ )
不可以以数字开头
大小写敏感
vaule = 1 #整型
vaule2 = 1.0 #浮点形
value3 = "字符串" #字符串型等
注释
单行注释： #
多行注释： """ """ 在三引号内写注释
#单行
"""
多行
"""
逻辑运算符
python中逻辑运算符为 and(与) or(或) not(非) 分别对应着 && || !
pass关键字
当函数或类的语法课内什么代码不写时，会报错，可以使用pass 关键字占位
类型注解
在python3.5时引入了类型注解，可以表明该变量的类型
python的类型注解是提示性的，虽然指定了类型，但也可以声明成其他类型
语法：
变量: 类型
#基础数据类型
var1: int = 100
var2: bool = True
var2: str = "qwq"
#容器注解
var_1: list = [1,2,3]
var_2: list[int] = [1,2,3] #更详细的注解
var_3: list[int,str,bool] = [1,"qwq",True] #更详细的注解
var_4: dict[str,int] = {"value1":100}
#类对象类型
class Student:
pass
var: Student = Student()
使用注释的注解
var_1 = 100 # type: int
函数注解：
def 方法名(形参1: 类型,形参2: 类型) -> 返回值类型:
class Stu:
pass
#形参类型注解
def method(var1: int,var2: Stu) -> int:
数据类型
基础
字面量： 直接可以在语法中使用的值
整型： int 正常整数
浮点型： float 小数
布尔类型： bool 有2个值 True 和 Flase 首字母要大写
字符串： str(string的缩写) 可以使用[索引]来定位字符，索引从0开始
空类型： NoneType 在python中 空类型 为 None
可以使用 type()函数传入变量获取变量的类型
#字符串
str = "qwq"
print(str[0]) #打印q
#布尔类型
result = True #首字母要大写
result2 = False
#空值
n = None
#获取类型
print(type(str))
#可以使用 类型() 方法来转换变量类型
int(str)
运算符
+
-
*
/
// #取整除
% #取余
** #指数 a**10 ，a的10次幂
在运算符后加上 = 就变味复合赋值运算符
字符串
三种定义方法：
'单引号'
"双引号"
"""
三引号
支持换行
单独存在于代码内，则为注释作用
"""
字符串拼接:
#直接用 + 拼接
a = "1234"
print("qwq" + a)
#在拼接不属于字符串的变量时，需要进行类型转换(在java中是自动转换为字符串)
a = 1.01
print("qwq" + str(a))
字符串格式化：
#方法1
name = "littleD"
message = "你好 %s %s" % name,name # %s 字符串占位符
#方法2
message = f"你好 {name}" #在字符串前添加f 在字符串内 {变量} 内的变量会被替换成变量的值，{} 内也可是语句，结果是语句的最终的值
#该方法 不理会类型
# %d 整数
# %f 浮点数
精度控制：
a = 10.115
t = "qwq %5.2f" # [空格][空格][空格]10.12
#5代表整数部位的宽度，.后面的2代表小数的宽度，会四舍五入
#若5小于整数的宽度，则不生效
字符串也是容器:
字符串可作为一个不可变的容器
strings = "litted"
a = strings[0] #下标获取值
stirngs.index("itt") #获取匹配字符串的索引, 1
#replace 方法
news = strings.replace("d","D") #替换字符串，返回一个替换后的新字符串
print(news) #littleD
#split方法
t = "1-1-2-qwq"
result = t.split(-) #根据传入的字符串，以传入的字符串分割该字符串，分割出的字符串存入列表并返回
print(result) # ['1','1','2','qwq']
布尔类型
字面量True为真，False为假， python大小写敏感
字面量还可以通过 比较运算符得到
条件语句
== != >= <= > < 为判断两间关系是否是true或false
格式：
#1.
if 条件:
语句
#2.
if 条件:
语句
else:
语句
#3.多个条件判断
if 条件:
语句
else if 条件:
语句
elif 条件: #else if 和elif都可以
语句
else:
语句
注： python的if判断是根据缩进 判断语句是否属于其代码块内,python的一个缩进一般为4个空格，可以使用一个tab 代替
在if判断中 None值 代表 False
循环
for和range：
for i in range(5):
print(i) #0,1,2,3,4
for i in range(3,5): #包头不包尾
print(i) #3,4
for i in range(3,10,2): #第三个参数是步长
print(i) #3,5,7,9
使用for循环迭代：
可用for循环对 字典，列表，字符串进行迭代
#格式
for 变量名 in 迭代对象: #会将对待对象内的每个值赋值给变量
#例
names = ["1","2",3,4]
for name in names:
print("名字是" + str(name))
#迭代字典
names = {"1":123,"2":123,"3":123}
for key,value in names:
print("键：" + key + "值" + str(value))
while循环：
#格式
while 条件:
语句
#例
i = 0
while i <=5:
print(i) #0,1,2,3,4,5
i += 1
break和continue:
break:
直接在该位置结束整个循环
continue:
在该位置结束本次循环，进入下一次循环
while true:
if a >1:
break
for i in range(5):
if a > 1:
continue
#在嵌套循环中 break和continue只能在它所在的循环内起作用
函数
定义
在python中，解释器读取代码是从上到下读取，因此，对函数的定义需要再调用函数之前就定义
#格式
def 函数名(变量1,变量2):
语句
return 值 #不写的话默认为 return None
#可以传入函数作为参数,可以在函数内再定义函数
#return返回的值可以返回一个函数
函数内的变量
在python函数中的变量叫局部变量，变量作用域只在函数内起效，函数结束后，变量就会被销毁
在同一个模块中(也就是 .py文件) 模块内直接定义的变量叫全局变量，在整个模块内起作用，函数内可以获取全局变量的值，但是不可对其进行操作
global关键字
global可在函数内部声明局部变量为全局变量
在函数内想要声明和外部变量相同关键字的变量时，需要用global关键字
若要修改外部变量指向的值时也要用global关键字
若只是获取值，或只是修改变量指向的对象的内部的值，可以直接用另一个变量获取该变量的地址值
例:
a = 100
def test():
a = 10 #这里是重新定义了一个 a 变量，并不是获取全局变量
def test1():
global a #获取模块内的全局变量a
a = 1
print(a) # 1
多重参数使用形式
关键字参数：
函数调用时，可通过 键=值 的形式传参， 键就是函数内的形参名字
#调用函数时可指明传入的变量赋值给哪个参数
def test(t1,t2,t3):
test(t2=50,t1=60,t3=1)
#可以和位置参数混用，但位置参数必须在关键字参数前
test(100,t3=5,t2=1)
#可以在定义参数时指定参数的默认值，在调用时若不传入参数则使用默认值
def test(t1="qwq")
print(t1)
test() #qwq
缺省参数:
缺省参数(默认参数): 定义函数时可指定参数的默认值，在调用时可不穿该参数的值，传入的话，则使用传入参数的值
def method(t1,t2,t3="默认值"):
method(5,1)
可变参数：
可以传入不定数量的参数
位置传递：
使用 *变量名 定义函数，在传入参数时，参数会被一个元组接收
#可以传入可变参数
def test(*args):#获取的参数作为一个元组
for i in args:
print(i)
test(1,2,3,4)
关键字传递：
使用 **变量名 定义函数， 传入的参数需要以 键=值 的形式传递，并被一个字典接收
def test(**args): #获取的参数作为字典
for key,value in args:
test(key1="qwq",key2= "value") # 调用时，key不用使用引号引用
多返回值
python的返回值可以有多个变量
def method():
a,b = 1,21
return a,b
x,y = method()
Lambda函数
函数作为参数传递：
def method(fun):
fun(5,6)
print(type(fun))
def fun(x,y):
print(x + y)
method(fun) # 11 , <class 'function'>
lambda匿名函数：
使用def定义的函数是带有名字的
使用lambda定义的函数无函数名， 格式： lambda 参数: 函数体 //函数体只能包含一行代码
#格式
fun = lambda a : a = a + 1 #通过lambda关键字声明, : 前是参数，后是执行语句，默认带有return
print(fun(3)) # 4
#即
def fun(a):
return a = a + 1
def method(fun):
fun(5,6)
method(lambda x,y: x+y)
注：
在python中函数中传入可变类型(列表，字典，集合--集合用{} 声明)时，在函数内对可变类型进行修改，也会修改到传入的变量
就跟java一样，可变类型就是传入方法内的引用数据类型，传入的是该变量的地址值
数据容器
python中的数据容器
python中数据容器可以容纳任意数据类型的数据
数据容器分为5类：列表，元组，字符串，集合，字典
列表
列表： list类型 ,可有序，可重复,可以修改的存放任意类型的数据
#定义
[元素1，元素2，元素3] #字面量
name = [] #空列表
name = list() #也是空列表
names = [1,"qwq",1.0] #python的列表可以存放不同类型的值
操作列表:
#获取列表内的值
#根据下标索引获取 ，可以正向索引也可反向索引
#正向索引从0开始，反向索引从-1开始
names[0]
#获取嵌套列表
t = [[1,2,3],[1,1,1,5]]
t[1][-1] # 5
#列表.index(元素) : 查询指定元素在列表内的下标，若找不到则报 ValueError错误
names.index("qwq")
#修改元素
names[索引] = 值 #将对应索引的值重新赋值
#插入元素
names.insert(索引,元素) #在指定索引插入元素，在此索引后包括该索引位置的元素向后移动
#向列表末尾增加值
names.append("qwq")
#向列表末尾追加容器
names.extend([1,2,3,4]) #将容器内的一批元素加入目的容器
#删除元素
del names[0] #删除索引处的元素
names.remove(元素) #匹配值删除，删除该元素在列表中的第一个匹配项
names.pop() #根据索引弹出值，也可以使用一个变量接收弹出的值，若没有传入参数则弹出列表最后一个值
#清空列表内容
names.clear()
#获取列表内元素的数量
names.count(元素) #统计该元素在列表中的数量
len(names) #统计列表内所有元素的数量
"值" in names #查看值是否在names里 在就返回true 否则返回false
列表的遍历(迭代)：
#while循环遍历
i = 0
while(i<len(列表)):
a = 列表[i]
i += 1
#for循环遍历
for 临时变量 in 列表: #每次把列表内的元素赋值给变量
print(临时变量)
元组
元组同列表一样，但元组在定义之后就不可被修改
元组内若存的是引用类型的变量(如列表，自定义对象) ，可修改变量内部的值
#定义
(元素1,元素2,元素3) #字面量
#定义空元组
a = ()
a = tuple()
#注： 若元组只有一个元素，则该元素类型为那个唯一元素的类型
#元组的操作：
#除列表的添加修改元素操作不可用，其他操作同列表的相同
序列的切片
序列：
内容连续，有序，可使用下标索引的一类容器
切片：
语法： 序列对象[起始下标:结束下标:步长]
使用切片后，会获得一个新的序列
起始下标为空则默认从起始 0索引开始，结束下标默认到末尾( len(序列对象) )包含末尾，步长默认为1
包含起始下标处的元素，不包含结束下标的元素--包头不包尾
arr = ["1",2,3,4,5]
a = arr[1:3] #从索引1开始 索引3结束
print(a) #2,3
print(arr[::-1])#[5,4,3,2,"1"] 从末尾开始，开头结束，步长 -1 即为从末尾向开头切片
print(arr[3:0:-1])#[4,3,2] 从3开始，0结束，步长 -1 即为从末尾向开头切片
集合
集合(set)：无序，不重复，无索引
集合使用 {} 定义
#定义
{元素1,元素2,元素3} #字面量
a = {}
a = set() #空集合
对集合的操作：
#添加元素 集合.add(元素)
a = set()
a.add("qwq")
a.add("qwq") #集合会进行去重，最后集合内只有一个 "qwq" 元素
#移除元素 集合.remove(元素)
a.remove("qwq")
#随机取出(取出后该元素就从集合中删除)元素 pop
a.pop()
#清空集合 clear
#取出两个集合的差集 difference，不进行修改，获得新集合
set1 = {1,2,3}
set2 = {3,4,5}
print(set1.difference(set2)) #{1,2} set1有而set2没有
#消除差集difference_update 对调用的对象进行修改，传入的对象不修改
set1.difference_update(set2) #set1被修改为 {1,2} 消除相同的元素
#合并 union 获得新集合，不修改
print(set1.union(set2)) #{1,2,3,4,5}
#遍历
for t in a:
字典
字典(dict)：python中的字典就和java语言的Map集合一样，以键值对的形式存放数据
字典的键是独一的，不可重复， 值可重复
字典的键需要不可变的值，列表就不可使用，但python提供了不可变列表 -- 元组 元组声明使用 ()括号
#定义
name = {}
names = {"键1":"值1","键2","值2"}
name = dict() #空字典
操作
temp = {"t":"666","a":"1111","c":"qqqq"}
#根据键获取值
temp["t"] # 获取 "666值"
#新增元素，若该键存在，则新的值覆盖原来的值
temp["momo"] = "6666" #新增
temp["momo"] = "666" #覆盖
#删除元素 pop(key) 清空 .clear()
temp.pop("momo")
#keys() , 获取字典内的所有 key，作为集合返回
arr = temp.keys() # ["t","a","c"]
#遍历
for key in temp: #获取键
print(key)
for key,value in temp: #获取键和值
print("键：" + key + "值" + str(value))
#删除
del names["键1"] #根据 键 删除
#判断该键是否存在字典内
"键" in names
文件操作
打开文件：
open(name,mode,encoding)
#name文件的路径名
#mode 访问模式， 只读，只写，追加等 "r"为读， "w为写" "a为附加内容" "r+"为同时读写
# wb ，rb 二进制写入，读取， ab二进制附加
#encoding 编码格式
t = open("路径",读写方式,编码)
#编码方式和读写方式都可以省略，读写方式默认为 "r"
读取：
#读取
f = open("./1.txt","r",encoding="utf-8") #若文件不存在会报错
f.read() #读取全部内容，作为一个字符串返回
f.read(10) #读取10个字节的内容，作为字符串返回
f.readline() #读取一行的内容，作为字符串返回
f.readlines() #读取全部的内容，每行字符串形成列表返回
f.close #读取后，需要关闭流
#当读取到文件末尾时， 调用读取方法会得到空字符串 ""
#for循环读取文件行
for line in f:
print(line)
#也可使用该方法，会自动关闭流
with open("./1.txt","r",encoding="utf-8") as f: #f是打开文件的变量名
print(f.read())
写入：
#写入
f = open("./1.txt","w",encoding="utf-8")
f.wirte("qwq") #此时内容还没写入到文件中，而是存储在内存中
f.flush() #现在才被写入文件中
f.close() #关闭流，在关闭前，把所有内存中的数据写入文件
with open("./1.txt","w",encoding="utf-8") as file: #文件不存在会自动创建文件，若存在则会清空文件 若要不清空则 用 "a"
file.write("啦啦啦") #写入的字节会根据编码方式，将字符串编码成字节写入文件
异常
#格式
try:
语句
except ValueError:
处理语句
except NameError as a:
print(a)
except (error1,error2) as e: #捕获的多个异常放在元组内
except: #匹配所有异常 等同于 Exception:
语句
else: #匹配成功处理后执行
print("无异常发生")
finally: #无论错误是否发生都执行
#异常从上往下匹配，匹配到就结束，不再向下匹配
模块
定义
python模块(module) 是一个python文件，以.py结尾，能自定义函数，类和变量，以及可执行的代码
可以通过导入模块来使用模块内的类，函数，变量
python中可以导入其他的模块
引入方法：
格式: [from 模块名] import [模块 | 类 | 变量 | 函数 | *] ， []为可选内容
import 模块名 //以此方法引入后，调用模块内的成员时，使用 模块名.成员 即可调用
from 模块名 import 成员1,成员2 可以直接使用成员，就像成员在自己代码内一样
from 模块名 import * 引入所有的成员
在导入模块时，还可以使用as关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。
import module1 as m1
import time
time.sleep(5) #调用 time模块内的 sleep() 函数 ，也可使用模块的 类或变量
from time import sleep #从time模块 导入sleep函数
sleep(5) #可直接使用
from time import * #导入所有的成员(类，变量，函数)
#别名
import time as t
t.sleep(5)
from time import sleep,method as t1,t2
自定义模块：
python文件的文件名就是模块名
导入模块时避免执行语句：
在模块内直接定义的语句体在运行模块时会被执行， 在做为导入模块时，运行主模块时也会执行导入模块内的语句体
此时需要用到 _name_ 变量
若该模块为运行模块时，改变了会被赋值 '__main__' 因此可用于判断是否为运行模块
def method():
print("qwq")
if __name__ == '__main__':
method()
__all__变量：
在使用 from 模块 import * 导入时 用__all__变量可指定 * 导入的内容
注： 只对 import * 导入形式起作用
__all__ = ["method","value","class1"] #列表类型
def method():
value = 1
class class1:
python包
定义：
若内容过多，存放于一个模块内很难管理，可以使用python包
python包即为一个文件夹，里面存放着模块，在包内可以有一个 __init__.py 文件，该文件可控制包的行为
没有该文件也行， 只是不是包 而是一个文件夹，但功能也可与python包差不多
source:
main.py
lib:
inner.py
pack:
__init__.py
test.py
#main.py文件：
import lib.inner #导入 lib文件夹内的inner模块
lib.inner.成员
from lib import inner
inner.成员
#在导入包时，在包内模块内的类可以直接导入，不用导入类存在的模块
#如 a 包内存在 b模块，b模块内存在 c类则
from a import c #直接导入c类
#__init__.py :
__all__ = ['test'] #设定在 import * 时 导入的模块
第三方包
第三方包需要使用 python内置的pip安装
pip install 包名
pip install -i 镜像地址 包名 #使用镜像源下载
面向对象
类的声明
#类的声明
class 类名:
成员变量
#构造方法， 名字为__init__ 的方法就是构造方法
def __init__(self,参数): #self是调用这个方法的对象，一般写self
语句
#成员方法
def method(self,参数)
#可用self获取该对象内部的成员 (成员变量，成员方法)
#要访问对象的成员，必须使用self访问
#对象创建
o = 类名(参数)
#在调用时自动传入自身对象
o.method(参数)
魔术方法
如构造方法 __init__() 一样，是python的内置方法之一，这些有特殊功能的内置方法就叫 魔术方法
__str__
作用同java的 重写toString方法一样
__lt__
大于小于符号的比较方法
__le__
小于等于，大于等于符号
__eq__
== 符号
class student:
def __str__(self):
return f"student对象"
def __lt__(self,other): #other为与其比较大小的另一个对象
return self.age < other.age
def __le__(self,other):
return self.age <= other.age
def __eq__(self,other):
return self.age == other.age
print(student()) # student对象
私有成员
定义：
私有成员变量： 变量名以 __开头
私有成员方法： 变量名以 __开头
class student:
__variable = None #私有成员变量
__method(self):#私有成员方法
print("调用成功")
use(self):
self.__method() #类内部可以访问，在外部无法访问
studen().use() # 调用成功
studen().__method() #报错
类的继承
单继承：
语法：
class 子类(父类):
多继承：
语法：
class 子类(父类1,父类2)
多个父类中，若有重名的成员，则以声明的从左到右为优先级，左最先
先继承的保留，后继承的同名方法丢弃
class father:
def __init__(self,t1,t2):
class child(father):
def __init__(self,t1,t2,t3):
super().__init__(t1,t2) #调用父类的构造
self.t3 = t3 #这里若之前声明了成员变量，则为赋值，若没有声明，则为声明变量
成员重写：
子类可以定义和父类重名的成员，来将从父类继承下来的成员覆盖
调用父类成员：
在子类重写了父类成员时，若还要调用父类成员的话可用以下方法：
类名调用：
父类名.成员变量 父类名.成员方法(self) #需要传入自身对象
super()方法调用：
super().成员变量 super().成员方法()
class parent:
t = 5
def method(self):
print("1")
class child(parent):
t = 1 #重写
def method(self):
print("2")
def call(self):
method() #调用重写的方法 2
super().method() #父类方法 1
parent.method(self) #父类方法 1
高级使用
闭包
def outer(a):
b = 1
def inner():
nonlocal a,b #在嵌套(内部)函数直接获取外部变量
return inner #将内部函数返回
装饰器：
装饰器也是闭包，不过是接收外部传入的函数，并返回一个新的函数
语法糖：
def outer(fun):
def inner():
print(1)
fun()
print(2)
return inner
@outer #@后面跟装饰器方法名
def use():
print(3)
ues() # 1 3 2
多线程
使用
导入 threading 模块
import threading
def method(messege):
print(messege)
a = threading.Thread(target=method,agrs=("你好",)) #传入元组
a = threading.Thread(target=method,kwargs={"messeage":"你好"})
a.start()
#可以使用lock锁来保证在某一区域线程仅有一个线程访问，其他线程得等锁释放才能访问
balance = 0
lock = threading.Lock()
def run_thread(n):
for i in range(100000):
# 先要获取锁:
lock.acquire()
try:
# 放心地改吧:
change_it(n)
finally:
# 改完了一定要释放锁:
lock.release()
线程池
from mutiprocessing.dummy import Pool
import time
def method(t):
print(t)
time.sleep(2)
param_list = ["121",'qwq']
pool = Pool(4) #4个线程的线程池
results = pool.map(method,param_list) #把列表的数据作为参数依次传递给方法
#每个方法调用得到的返回的值存入列表内
协程
协程式在一个线程内执行的，只有一个线程，但其可以在执行过程中中断一个函数去执行另一个函数
在使用协程处时阻塞的，在执行完毕传入的协程任务时，才会释放对主线程的占用继续向下执行
引入 asyncio模块
import asyncio
#使用async 修饰的函数在调用后不会执行，而是返回一个协程对象
async def method():
print("abc")
return "成功"
c = method() #返回协程对象
#协程对象需要用事件循环对象运行
loop = asyncio.get_event_loop()
#将协程对象注册到loop并运行
loop.run_until_complete(c)
#使用task运行
task = loop.create_task(c)
loop.run_until_complete(task) #运行
#定义回调函数
def call_back(a):
print(a.result()) #回调函数注册后，会传入future对象作为参数，使用result方法获得返回值
#使用future，可调用回调函数
future = loop.ensure_future(c)
future.add_done_callback(call_back)
loop.run_until_complete(task) #运行
#传入多个协程对象
async def con(i):
#time.sleep(2) 不能出现同步方法， 在协程中，各个函数时在一个线程内运行的
#遇到阻塞操作需要使用 await 手动挂起
await asyncio.sleep(1)
print(i)
正则表达式
导入re模块
import re
#从头匹配
result = re.match("我是匹配规则","我是匹配对象")
result.span() #位置如 (0,3) 匹配的占位
result.group() #获取匹配到的值
#搜索整个字符串，找到第一个就结束
result = re.search("我是匹配规则","我是匹配对象")
result.span() #位置如 (0,3) 匹配的占位
result.group() #获取匹配到的值
#找全部，返回一个列表
result = re.findall("我是匹配规则","我是匹配对象",re.s) #re.s还可以是re.m,分为多行和单行匹配，re.s是多行，其匹配时会略过/n换行符
print(result) # []
venv管理工具
venv是python内置的管理工具用于管理python的依赖(pip3.3后内置)
创建venv： python -m venv 自定义名字
激活：
创建虚拟环境后，需要激活才可以使用，
windows： .\自定义名字\Scripts\activate
退出虚拟环境： deactivate
在虚拟环境中使用pip安装的依赖就会进入 创建的venv虚拟环境中
导出依赖：
在激活状态下 输入 pip freeze > ./requirements.txt 即可将依赖的名字以及版本号导出到 requirements.txt中
导入依赖：
在虚拟环境激活状态下在目录下放置 requirements.txt 输入 pip install -r requirements.txt 即可导入
浙公网安备 33010602011771号