课程链接：Python入门教程——基础阶段_哔哩哔哩_bilibili
Python学习笔记
注释
单行注释： *
多行注释： 1.多行前面加#
2."""注释信息"""
3.'''注释信息''‘
如果代码字符有问题，可能是版本的问题，在代码中加入# encoding=utf-8或者是# *coding:utf-8*(Python3直接支持，Python2默认不支持)
变量
| 变量名 |
|---|
| 变量名=值 |
| 变量名1，变量名2 = 值1，值2 |
| 变量名1=变量名2=值 |
变量注意事项：1.一个变量只能引用一个数值 2.命名规范 字母数字下划线 见名知意 驼峰标识 关键字 区分大小写 3.变量名使用之前一点要赋值
n的m次方 n ** m 除 / 整除 // 在行列的问题里面，会用得到整除和除余（行用整除列用余）
运算符
非布尔类型的值，如果作为真假来限定，一般都是非零即真，非空即真。
print(1 or True) ? ?1 print(0 and True) ? 0 print(1 and 3) ? ? ?3 ? ? ? 输出当前识别到的表达式 print(0 and True) ? 0 print(bool(1)) ? ? ?True
输入和输出
Python2
以下三个输出是一样的，都是：我的名字是ss，年龄是23
name = "ss" age = 24 print "我的名字是：", name, ", 年龄是：",age
name = "ss" age = 24 result = "我的名字是%s, 年龄是%d"%(name, age) print result
name = "ss"
age = 24
print "我的名字是{0}, 年龄是{1}".format(name,age)
#输出到文件中(把xxxxxx输出到text,txt文件中)
f = open("test.txt","w")
print >>f,"xxxxxx"
输出不自动换行，后面加逗号即可
输出的各个数据，使用分隔符分割
print ?"a", "-", "b", "-", "c" a - b - c
print "-".join(["a", "b", "c"]) a-b-c
Python3
print() ?#把Python2的代码放在括号里面就可以了
#输出到文件中(把xxxxxx输出到text,txt文件中)
f = open("test.txt","w" )
print("xxxxxx",file = f)
输出不自动换行，但是输出可以编辑，通过end函数
#end里面写的是跟在前面字符串后面的东西
print("123",end="/n")
#代表输出换行
print("")
输出的各个数据，使用分隔符分割，用sep函数
print("1", "2", "3", sep="^^^")
占位格式符
mathScore = 100
englishScore = 90
print("我的数学成绩是%d, 英文的分数是%d"%(mathScore,englishScore))
print("我的数学成绩是%d, 英文的分数是%d"%(englishScore,mathScore))
print("我的数学成绩是%(es)d, 英文的分数是%(ms)d"%({"es":englishScore,"ms":mathScore}))
print("我的数学成绩是%(ms)d, 英文的分数是%(es)d"%({"es":englishScore,"ms":mathScore}))
在%和d之间填写数字表示占用的宽度，+表示宽度在数字的左边，—表示在右边
print("%d" % mathScore)
0表示用0填充
min = 3
sec = 5
print("%02d:%02d"%(min,sec))
#2d表示占用的宽度为2，0表示空余位置补0，但是0如果换成其他数字即与2合在一起表示所占用的宽度
score = 59.9
print("%d"%score)
print("%f"%score)
print("%.2f"%score)
?
当字符串中存在格式化标志时，用两个%%表示%
分支
if else与 if elif
| 建议:不要写嵌套层次太深的代码 |
|---|
| Python中没有类似其他语言中的switch...case的用法 |
while
一定要注意循环结束条件，防止死循环
在Python中，没有类似其他语言的do...while循环
for
| for s in ss: |
|---|
| 取出ss中的每一个元素赋值给s,在循环体中可以直接使用s的值 |
break 打断整个循环，跳出整个循环
continue 结束本次循环，继续执行下次循环
pass 它是空语句，不做任何事情，一般用作占位语句
内建函数
| abs(num) 绝对值 |
|---|
| max(num1,num2...) 最大值 |
| min(num1,num2...) 最小值 |
| round(变量名，n)表示四舍五入，n表示四舍五入的位数 |
| pow(x,y) x的y的次幂 |
math模块函数（需要导入包 import math）
随机函数（需要导入包 import random）
import random print(random.random()) # 从一个序列中，随机挑选一个数值 seq = [1, 3, 5, 7, 9] print(random.choice(seq)) # 范围之内的随机小数 [] print(random.uniform(1,3)) # 范围之内的随机整数 [] print(random.randint(1,3)) # 给定区间内的一随机整数 【) 2为步长，1，3 5 7...13 print(random.randrange(1,14,2))
数字常量 π == pi
# 三角函数里面的参数是一个弧度，角度 hudu1 = 1/ 6 * math.pi hudu2 = math.radians(30) # radians可以把角度转为弧度 print(math.sin(hudu1)) print(math.sin(hudu2))
转义符（一个字节个数）
# 我是ss 在打印的两边引号前面加上转义字符 \ name = "我是\"ss\"" print(name)
# 续行符 \只可以续一行 name = "s"\ "s"\ "123" print(name)
原始字符串
# 输出里面所有的内容，包括一下符号在内容前面加原始字符串r name = r"我是 \n \t ss" print(name)
单双号混合使用可以避免使用引号转义符
name = '我是"ss"' print(name)
一般内容需要写成一行，如果跨行的话，需要连行符 \ 或者小括号（所有的内容）
三引号 """ """ 可以直接跨行书写，也可以用于注释
print("ss \t"* 10)
字符串函数操作
字符串的切片又指针的方式 []
seq = "asdfghj" print(seq[0]) # a print(seq[-1]) # j print(seq[0]) # a print(seq[-1]) # j print(seq[0:3]) # asd # 步长为2,若写的步长>0，从左到右，<0，从右到左 # 步长要注意不能够从头部跳到尾部，或者从尾部跳到头部 print(seq[0:3:2]) # ad print(seq[0:len(seq):1]) # asdfghj print(seq[::]) # asdfghj print(seq[::-1]) # jhgfdsa # 0这个位置取不到 print(seq[6:0:-1]) # jhgfds print(seq[-1:-6:-1]) # jhgfd
字符串中如果是内建函数可以直接使用，不是的话就用 ：对象.方法(参数)
查找计算函数
# find()从左到右查找，找到之后马上停止，区间是 [ )
name = "wo shi ss"
print(name.find("s")) 3
print(name.find("s",4)) 7
print(name.find("s",8)) 8
print(name.find("s",3,7)) 3
print(name.find("s",4,7)) -1
# rfind()从右到左查找，找到之后马上停止，区间是 [ )
# index()与find()不一样的是找不到直接报错
# rindex()与index()方向相反
# count()表示查找个数
转换类函数
# replace()并不会修改原字符串，而是输出一次修改后的。后面的数字表示更换的个数
name = "wo shi ss"
print(name.replace("s","z",1))
# capitalize()改变字符串首字母单词大写
print(name.capitalize())
# title()字符串中每个单词的首字母大写,如果有分隔符的话，分隔符两边算单词
print(name.title())
# lower()讲字符串中每个字符都变成小写
print(name.lower())
# upper()讲字符串中每个字符都变成大写
print(name.upper())
填充压缩类函数
# lstrip()仅仅只移除左侧的字符,而且是第一个字符集，像/n,/t，空格都算。移除的是括号里面的字符集所有的每个字符，而不是一个整体
name = " wo shi ss "
print("|" + name.lstrip() + "|") # |wo shi ss |
name = "wwoo shi ss "
print("|" + name.lstrip() + "|") # |wwoo shi ss |
print("|" + name.lstrip("wo") + "|") # | shi ss |
name = " wwoo shi ss wwoo "
print("|" + name.lstrip("wo") + "|") # | wwoo shi ss wwoo |
name = "wwoo shi ss wwoo "
print("|" + name.lstrip("wo") + "|") # | shi ss wwoo |
name = "awwoo shi ss wwoo "
print("|" + name.lstrip("wo") + "|") # |awwoo shi ss wwoo |
# rstrip()从右边开始
分割拼接类函数
# split(分隔符，分割次数（不是份数）) 将一个大的字符串分割成几个小的字符串
info = "11-22-33-44"
print(info.split("-")) #['11', '22', '33', '44']
print(info.split("-",2)) #['11', '22', '33-44']
# partition(分隔符) 查收到分隔符，返回 （分隔符左侧内容，分隔符，分隔符右侧内容）
print(info.partition("-")) #('11', '-', '22-33-44')
# 没有的话，返回 (原字符串，"","")
print(info.partition("|")) #('11-22-33-44', '', '')
# rpartition() 从右边开始
# splitlines(布尔类型) 按照换行符(\r,\n)，将字符串拆成多个元素，保存到列表中
name = "wo \n shi \r ss"
print(name.splitlines()) #['wo ', ' shi ', ' ss']
print(name.splitlines(True)) #['wo \n', ' shi \r', ' ss']
#join() 根据指定字符串，将指定的可迭代对象进行拼接，形成新的字符串
items = ["ss","23","131231"]
result = "+".join(items)
print(result) #ss+23+131231
判定操作类函数
# isalpha() 字符串中所有字母是否都是字符
# isdigit() 字符串中是否所有字符都是数字
# isalnum() 字符串是否所有的字符都是数字或者字母
# isspace() 字符串中是否所有字符都是空白符
# startswitch("需要判定的字符串的前缀"，判断开始位置，判定结束位置) 字符串是否以某个前缀开头
items = "2021-11-13:某某报告.xls"
print(items.startswith("2021-11")) #True
print(items.startswith("2021-11",0,2)) #False
# endswitch() 字符串是否以某个后缀结尾
# in 判定一个字符串，是否被另外一个字符串包含
print("sz" in "wo shi ssz") #True
print("sz" in "wo shi z") #False
# not 判定一个字符串，是否不被另外一个字符串包含
列表
概念
字符串：不可变
列表：有序的可变的元素组合（可以存放不同的数据类型）
列表是可以嵌套的
# 列表推导式 num = [1,2,3,4,5] list = [nums ** 2 for nums in num] print(list) #[1, 4, 9, 16, 25] # for前面表示对for后面这个列表要进行的操作 list = [2 for nums in num] print(list) #[2, 2, 2, 2, 2] list = [nums ** 2 for nums in num if nums % 2 != 0] print(list) #[1, 9, 25] list = [nums ** 2 for nums in num for nums1 in num] print(list) #[1, 1, 1, 1, 1, 4, 4, 4, 4, 4, 9, 9, 9, 9, 9, 16, 16, 16, 16, 16, 25, 25, 25, 25, 25]
列表增加
#append() 在列表中追加一个新的元素，加最后。而且会修改原列表，本身方法没有什么访问值，所以返回是None num = [1,2,3,4,5] num.append(6) result = num.append(6) print(num) #[1, 2, 3, 4, 5, 6, 6] print(result) #None #insert() 插入所给定的值前面 num = [1,2,3,4,5] num.insert(3,6) result = num.insert(3,6) print(num) #[1, 2, 3, 6, 6, 4, 5] print(result) #None #extend() 往列表中扩展另外一个可迭代序列 #乘法运算 ["a"] * 3 = ["a","a","a"] #加法运算 ["a"] + ["b"] = ["a","b"]
extend()是用来扩充两个集合的，append()是把一个元素追加到另外一个集合中去。
列表删除
#delete 删除一个指定元素
#pop(索引值) 移除并返回列表中指定索引所对应元素，索引值默认是-1
#remove() 移除列表中指定元素，如果有多个一样的，则只会删除最左边的一个（注意循环内删除列表元素所带来的坑）
for num in nums:
print(num)
if num == 2:
nums.remove(2)
print(nums)
1
2
2
4
2
[1, 3, 4, 2]
通过上面这个例子可以看出一个问题：当我们想移除一个列表中所有的指定元素时，不要在遍历当中，遍历内部这么去干
列表修改
当我们以后想要修改一个列表中的某一个元素时，一定是通过这个索引来操作指定元素的
列表查询
# 获取单个元素 index:正左负右
# 如果有多个相同的值的话可以加入查询的范围
index(str, beg=0, end=len(string))
# 获取多个元素(切片) items[start:end:step]
# 遍历常用方式：根据元素进行遍历和根据索引进行遍历，枚举函数
# 根据元素进行遍历： for items in list
values = ["a", "b", "a", "d"]
currentIndex = 0
for v in values:
print("v",end=" ")
print(values.index(v,currentIndex))
currentIndex += 1
v 0
v 1
v 2
v 3
# 根据索引进行遍历 for index in range(len(list))
values = ["a", "b", "a", "d", "d", "t"]
indexs = range(len(values))
for index in indexs:
print(index,values[index],end=" ")
0 a 1 b 2 a 3 d 4 d 5 t
# 枚举函数(了解) enumerate函数用于遍历序列中的元素以及它们的下标
values = ["a", "b", "a", "d", "d", "t"]
for index,value in enumerate(values):
print(index,end=" ")
print(value)
0 a
1 b
2 a
3 d
4 d
5 t
# 使用迭代器进行遍历
l = [1, 2, 3, 4, 5]
it = iter(l)
for v in it:
print(v)
print("----")
for v in it:
print(v)
# 迭代器不能重复
1
2
3
4
5
----
?
列表的判定和比较
# in 和 not in # cmp() 比较大小，从左到右逐一比较，但是python3版本中不支持这个函数，在python3版本中我们使用比较运算符进行比较
列表的排序
# 内建函数sorted(可迭代对象, key=None, reverse=False) reverse默认是False升序，如果是True,则是降序。如果可迭代对象是元组，则从左到右进行比较
s = [("sz",18), ("sz1",17), ("sz2",16), ("sz3",15)]
result = sorted(s)
print(result) # [('sz', 18), ('sz1', 17), ('sz2', 16), ('sz3', 15)]
def getKey(x):
return x[1]
result = sorted(s,key=getKey)
print(result) # [('sz3', 15), ('sz2', 16), ('sz1', 17), ('sz', 18)]
result = sorted(s,key=getKey,reverse=True)
print(result) # [('sz', 18), ('sz1', 17), ('sz2', 16), ('sz3', 15)]
# 列表对象方法list.sort(key=None, reverse=False)
s = [("sz",18), ("sz1",17), ("sz2",16), ("sz3",15)]
def getKey(x):
return x[1]
result = s.sort(key= getKey,reverse = False)
print(result,s) # None [('sz3', 15), ('sz2', 16), ('sz1', 17), ('sz', 18)]
列表的乱序和反转
# random.shuffle(list) 可以随机打乱一个列表,但是要导入random模块 import random l = [1, 2, 3, 4, 5] res = random.shuffle(l) print(res,l) # None [2, 5, 1, 4, 3] # reverse() 进行反转 res = l.reverse() print(res,l) # None [5, 4, 3, 2, 1] # 用切片的方式，与reverse不同的是不改变其本身 res = l[::-1] print(res,l) # [5, 4, 3, 2, 1] [1, 2, 3, 4, 5]
元组
概念
元组：有序的不可变的元素集合（故元组只能查询）
一个元素的写法 （1,）
多个元素的写法 (1, 2, 3) ("asdf", [1, 2], 4)
多个对象，以逗号隔开，默认为元组 1, 2, 3, "ss"
从列表转换成元组 tuple()
注意：以后我们给一个变量命名时，千万不要命名成一个类型
元组可以是嵌套的
元素查询
# 获取单个元素 tuple[index] # 获取多个元素 tuple[start:end:step]
元素获取判定比较
# tuple.count(item) 统计元组中指定元素的个数 # tuple.index(item) 获取元组中指定元素的索引 # len(tup) 返回元组中元素的个数 # max(tup) 返回元组中元素最大的值 # min(tup) 返回元组中元素最小的值 # 判定 in 和 not in # cmp() 比较如果比较的是元组, 则针对每个元素, 从左到右逐一比较左 > 右 1；左 == 右 0；左 < 右 -1；Python3.x不支持
元组拼接拆包
拼接：+，*
拆包：a, b = (b, a)
字典
概念
字典：无序的，可变的键值对集合
# {key: value, key: value...}
# fromkeys(S, v=None) 类和对象都可以调用
# 类调用
d = dict.fromkeys("abc",666)
print(d) # {'a': 666, 'b': 666, 'c': 666}
# 对象调用(用处不大，一般不使用)
d = {1: 2, 3: 4}.fromkeys("abc",666)
print(d) # {'a': 666, 'b': 666, 'c': 666}
# key不能重复，如果重复后面就会把前面的给覆盖。而且字典必须是任意不可变类型（列表，字典，可变集合等是可变的，数值，布尔，字符串，元组是不可变的）
字典增加
d = {"name": "sz", "age": "18"}
d["height"] = 180
print(d,type(d))
{'name': 'sz', 'age': '18', 'height': 180} <class 'dict'>
字典删除
# del key必须要存在
d = {"name": "sz", "age": "18"}
del d["age"]
print(d)
# pop(key) 删除指定的键值对, 并返回对应的值。如果key, 不存在, 那么直接返回给定的default值; 不作删除动作。如果没有给定默认值, 则报错
# popitem() 删除按升序排序后的第一个键值对, 并以元组的形式返回该键值对
# clear() 删除字典内所有键值对.注意字典对象本身还存在, 只不过内容被清空，与del不一样
字典改
# 只能改值，不能改key
# dic[key] = value 修改单个键值对
d = {"name": "sz", "age": "18"}
d["age"] = 20
d["age1"] = 22
print(d) # {'name': 'sz', 'age': 20, 'age1': 22}
# 批量修改键值对 update()
d.update({"age": 666, "address" : "上海"})
print(d) # {'name': 'sz', 'age': 666, 'address': '上海'}
字典查询
# dic[key] 获取单个值
d = {"name": "sz", "age": "18"}
print(d["age"]) 18
# dic.get(key[, default]) 获取单个值.如果没有默认值,则为None,原字典不会新增这个键值对,
d = {"name": "sz", "age": "18"}
v = d.get("age1",666)
print(v) 666
# setdefault(key[,default]) 获取单个值,如果key不存在, 则设置给定默认值, 并返回该值,无默认值则返回None
d = {"name": "sz", "age": "18"}
v = d.setdefault("age1")
print(v,d) #None {'name': 'sz', 'age': '18', 'age1': None}
v = d.setdefault("age1",666)
print(v,d) #666 {'name': 'sz', 'age': '18', 'age1': 666}
# values() 获取所有的值
# keys() 获取所有的键
# items() 获取字典的键值对
# Python2.x和Python3.x版本之间关于获取键, 获取值, 获取item, 之间的区别:Python2.x 直接是一个列表,可通过下标进行获取指定元素。Python3.x 中是Dictionary view objects(字典视觉对象)（字典本身发生变化，view objects也会发生变化）
d = {"name": "sz", "age": "18"}
vs = d.values()
print(vs) #dict_values(['sz', '18'])
print(vs[0]) #TypeError: 'dict_values' object is not subscriptable
print(list(vs)[0]) #sz
d["address"] = 666
print(d) #{'name': 'sz', 'age': '18', 'address': 666}
# 遍历有两种：key()和items(),推荐使用items()
d = {"name": "sz", "age": 18, "address": "上海"}
keys = d.keys()
for key in keys:
print(key,end=" ")
print(d[key])
name sz
age 18
address 上海
its = d.items()
for k, v in its:
print(k, v)
name sz
age 18
address 上海
字典计算和判定
# len() 键值对的个数 # x in dic 判断dic中的key是否x # x not in dic 判断dic中的key是否x
集合
概念
集合：无序的, 不可随机访问的, 不可重复的元素集合
集合分为可变集合（增，删，改）和不可变集合（创建好之后无法增删改），可变集合类型为set，不可变集合类型为forzenset
# 可变集合定义 set()
# 可变集合推导式（有两种）
s = set(x for x in range(0,10))
tup = {x for x in range(0,10)}
print(s,type(s)) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
print(tup,type(tup)) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
# 不可变集合定义 forzenset()
# 不可变集合推导式（只有一种）
s = frozenset(x for x in range(0,10))
print(s,type(s)) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) <class 'frozenset'>
注意：1.创建一个空集合时, 需要使用set() 或者 frozenset(), 不能使用 s = {}，否则会把它识别成字典
2.集合中的元素, 必须是可哈希的值（如果一个对象在自己的生命周期中有一哈希值（hash value）是不可改变的，那么它就是可哈希的（hashable）的）
3.集合中的元素不可重复，如果重复，则合并一个（利用此特性可以用于去除重复性）
可变集合增
# add()
可变集合删
# remove() 删除指定元素，如果集合中没有这个元素，则返回一个错误 # discard() 删除指定元素，若没有这个元素，则do nothing # pop() 随机删除并返回一个集合中的元素，若集合为空，则返回一个错误 # clear() 清空一个集合中的所有元素,不是删除这个集合
可变集合改
元素为不可变类型, 不能修改
可变集合查
无法通过索引或key进行查询，通过for in 和迭代器进行遍历
集合遍历(可变和不可变一样)
# for in
s = {1, 2, 3}
for v in s:
print(v)
# 迭代器
its = iter(s)
for s in its:
print(s)
集合之间交集
# intersection() 交集
# 注意可变与不可变集合混合运算，返回结果类型以运算符左侧为主
s1 = frozenset([1, 2, 3, 4, 5])
s2 = {4, 5, 6}
res = s2.intersection(s1)
print(res,type(res)) #{4, 5} <class 'set'>
res = s1.intersection(s2)
print(res,type(res)) #frozenset({4, 5}) <class 'frozenset'>
# intersection(Iterable)注意里面的Iterable是可哈希的
s1 = {"1", "2", "3", "4", "5"}
print(s1.intersection(["1", "2", ["1", "2"]])) #TypeError: unhashable type: 'list'
s1 = {"1", "2", "3", "4", "5"}
print(s1.intersection("123")) #{'1', '2', '3'}
print(s1.intersection({"1":"a", "2": "b"})) #{'1', '2'}
# & 交集()
集合之间并集
# union() 本身不发生变化
# |
# update() 本身变为更新之后的值
s1 = {1, 2, 3}
s2 = {1, 2, 4}
print(s1.union(s2),s1) #{1, 2, 3, 4} {1, 2, 3}
print(s1.update(s2),s1) #None {1, 2, 3, 4}
集合之间差集
# difference() # - # difference_update()
集合之间判定
# isdisjoint() 两个集合不相交 # issuperset()一个集合包含另一个集合(完全包含) # issubset() 一个集合包含于另一个集合
时间日历
time模块
# 获取当前时间戳:从0时区的1970年1月1日0时0分0秒, 到所给定日期时间的秒数 import time res = time.time() years = res / (24 * 60 * 60 * 365) + 1970 print(years) #2021.9165015272404 # 获取时间元组：time.localtime([seconds])，seconds为可选的时间戳，默认为当前的时间戳 res = time.localtime() print(res) time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=33, tm_sec=41, tm_wday=3, tm_yday=1, tm_isdst=0)
?
获取格式化的时间
# 秒 -> 可读时间: time.ctime([seconds]) t = time.time() print(time.ctime()) #Thu Nov 18 20:33:12 2021 # 时间元组 -> 可读时间: time.asctime([p_tuple]) res = time.localtime() time_tuple = time.asctime(res) print(time_tuple) #Thu Nov 18 20:33:12 2021
格式化日期字符串 <--> 时间戳
时间元组 -> 格式化日期
# time.strftime(格式字符串, 时间元组)
res1 = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
res2 = time.strftime("%y-%m-%d %H:%M:%S", time.localtime())
print(res1) #2021-11-18 20:32:12
print(res2) #21-11-18 20:32:12
?
格式化日期 -> 时间元组
# time.strptime(日期字符串, 格式符字符串) time.mktime(时间元组)
pt = time.strptime("2021-11-18 20:34:23", "%Y-%m-%d %H:%M:%S")
print(pt)
t = time.mktime(pt)
print(t)
获取当前CPU时间
# Python3.8已移除clock()方法,可以使用time.perf_counter()或time.process_time()方法替代。
休眠
# 推迟线程的执行, 可简单理解为, 让程序暂停 sleep()
calendar模块
提供与日历相关的功能，比如: 为给定的月份或年份打印文本日历的功能
# 获取某月日历 calendar.month(年, 月) import calendar print(calendar.month(2021, 6))
datetime模块
Python处理日期和时间的标准库，这个模块里面有datetime类，此外常用的还有date类，以及time类
# 获取当天日期 import datetime t = datetime.datetime.now() print(t.today()) #2021-11-18 21:04:54.359243 print(t.year) #2021 ... # 计算n天之后的日期 t = datetime.datetime.now() res = t + datetime.timedelta(days= 7) print(t, res) #2021-11-18 21:09:32.082433 2021-11-25 21:09:32.082433 # 获取两个日期的时间差 first = datetime.datetime(2021, 9, 1, 12, 0, 0) second = datetime.datetime(2021, 9, 2, 12, 1, 1) res = second - first print(res) #1 day, 0:01:01 print(res.total_seconds()) #86461.0
Python函数
概念
写了一段代码实现了某个小功能; 然后把这些代码集中到一块, 起一个名字; 下一次就可以根据这个名字再次使用这个代码块, 这就是函数
分类
内建函数，三方函数以及自定义函数
函数的基本使用
定义
def 函数名(): 函数体
def p():
print(4)
p()
#4
函数的参数
"参数名称"即为形参。在调用函数的时候, 传递的真实数据, 即为实参
# 一个参数
def p(num):
print(num * 2)
p(2)
#4
# 多个参数（严格按照顺序）
def p(num1,num2):
print(num1 * num2)
p(2,3)
#6
# 多个参数（不需要严格按照顺序）
def p(num1,num2):
print(num1) #2
print(num2) #3
print(num1 * num2) #6
p(num2=3,num1=2)
# 不定长参数：实参是元组的话在形参前面加 *
def mySum(* t):
res = 0
for s in t:
res += s
print(res) #10
mySum((1, 2, 3, 4))
# 不定长参数：实参是字典的话在形参前面加 **
def mySum(** dic):
print(dic) #{'name': 'ss', 'sex': '男'}
mySum(name = "ss", sex = "男")
# 把传递的参数, 包装成一个集合, 称之为"装包"，把集合参数, 再次分解成单独的个体, 称之为"拆包"
def Sum(a, b, c, d):
print(a + b + c + d) # 10
def test(* args):
print(* args,type(args)) # 1 2 3 4 <class 'tuple'> 此处是拆包
Sum(* args) # 此处是装包
test(1, 2, 3, 4)
# 缺省参数：有默认值的参数 def 函数名(变量名1=默认值1, 变量名2=默认值2):
注意：传递有值传递和引用传递（地址传递），在python中只有引用传递（地址传递）但是，如果数据类型是可
可变类型，则可以改变原件。如果数据类型是不可变类型，则不可以改变原件。
函数的返回值
当我们通过某个函数, 处理好数据之后, 想要拿到处理的结果
语言：def 函数(): 函数体 return 数据
注意：return 后续代码不会被执行
如果想要返回多个数据, 可先把多个数据包装成一个集合, 整体返回（列表，元组，字典）
def caculate(a, b):
he = a + b
cha = a - b
return (he, cha)
res = caculate(6, 7)
print(res[0]) #13
print(res[1]) #-1
he, cha = caculate(6, 7)
print(he) #13
print(cha) #-1
函数的使用描述
当我们编写三方函数, 为了方便他人使用, 就需要描述清楚我们所写的函数功能以及使用方式等信息。直接在函数体的最上面, 添加三个双引号对注释
查看函数使用文档：help(函数)
一般函数的描述, 需要说明如下几个信息：函数的功能，参数（含义，类型，是否可以省略，默认值）以及返回值（含义，类型）
def caculate(a, b = 1):
"""
计算两个数据的和，差
:param a:数值1，数值类型，不可选，没有默认值
:param b:数值2，数值类型，可选，默认值：1
:return:返回的是计算的结果，元组：（）和，差
"""
he = a + b
cha = a - b
return (he, cha)
help(caculate)
偏函数
当我们写一个参数比较多的函数时, 如果有些参数, 大部分场景下都是某一个固定值, 那么为了简化使用, 就可以创建一个新函数, 指定我们要使用的函数的某个参数, 为某个固定的值; 这个新函数就是"偏函数"
# 借助functools模块的partial函数 partial(函数, 特定参数=偏爱值)
import functools
def test(a, b, c, d = 1):
print(a + b+ c + d)
newTest = functools.partial(test, c =5)
newTest(1, 1)
高阶函数
当一个函数A的参数, 接收的又是另一个函数时, 则把这个函数A成为是"高阶函数"
l = [{"name": "ss1", "age" : 18}, {"name": "ss2", "age" : 19},{"name": "ss3", "age" : 17}]
def getKey(x):
return x["age"]
res = sorted(l, key=getKey)
print(res) #[{'name': 'ss3', 'age': 17}, {'name': 'ss1', 'age': 18}, {'name': 'ss2', 'age': 19}]
返回函数
是指一个函数内部, 它返回的数据是另外一个函数; 把这样的操作成为"返回函数"
def getFunc(flag):
def sum(a, b, c):
return a + b + c
def reduce(a, b, c):
return a - b - c
if flag == " + ":
return sum
if flag == " - ":
return reduce
res = getFunc(" - ")
print(res(1, 2, 3))
匿名函数
也称为 "lambda函数"，顾名思义, 就是指没有名字的函数
注意：只能写一个表达式，表达式的结果就是返回值。所以, 只适用于一些简单的操作处理
sum = lambda x, y: x + y
print(sum(1, 3)) #4
l = [{"name": "ss1", "age" : 18}, {"name": "ss2", "age" : 19},{"name": "ss3", "age" : 17}]
res = sorted(l, key= lambda x: x["age"])
print(res) #[{'name': 'ss3', 'age': 17}, {'name': 'ss1', 'age': 18}, {'name': 'ss2', 'age': 19}]
闭包
在函数嵌套的前提下，内层函数引用了外层函数的变量(包括参数)，外层函数又把内层函数当做返回值进行返回，这个内层函数+所引用的外层变量, 称为 "闭包"
ef test1():
a = 3
def test2():
print(a)
return test2
test = test1()
test()
3
# 根据配置信息, 生成不同的分割线函数
def line(content, length):
def line():
print("-" * (length // 2) + content + "-" * (length // 2))
return line
line1 = line("闭包", 20)
line1() #----------闭包----------
line2 = line("闭包啊啊啊", 30)
line2() #---------------闭包啊啊啊---------------
注意：1. 闭包中, 如果要修改引用的外层变量，需要使用 nonlocal 变量声明，否则当做是闭包内新定义的变量。
def test1(): def test1():
a = 3 a = 3
def test2(): def test2():
a = 4 nonlocal a
print(a) a = 4
print(a) print(a)
test2() print(a)
print(a) test2()
return test2 print(a)
test = test1() return test2
3 test = test1()
4 3
3 4
4
2.当闭包内, 引用了一个后期会发生变化的变量时, 一定要注意：函数是被调用时, 才去确定变量标识所对应的值
def test():
focus = []
for i in range(1, 4):
def test2():
print(i)
focus.append(test2)
return focus
newFucus = test()
print(newFucus)
newFucus[0]() #3
newFucus[1]() #3
newFucus[2]() #3
def test():
focus = []
for i in range(1, 4):
def test2(num):
def inner():
print(num)
return inner
focus.append(test2(i))
return focus
newFucus = test()
print(newFucus)
newFucus[0]() #1
newFucus[1]() #2
newFucus[2]() #3
装饰器
作用
在函数名以及函数体不改变的前提下, 给一个函数附加一些额外代码
语法
@装饰器 ? def 被装饰函数(): ? code
注意
装饰器的执行时间是立即执行
def check(func): def check(func):
def inner(): print("ss")
print("登录验证操作...") def inner():
func() print("登录验证操作...")
return inner func()
@check return inner
def fss(): @check
print("发说说") def fss():
fss() print("发说说")
登录验证操作... ss
发说说
进阶
装饰器叠加：从上到下装饰，从下到上执行
# 对有参函数进行装饰:1.无论什么场景, 保证函数调用参数个数一致2.为了通用, 可以使用不定长参数, 结合 拆包操作进行处理
def zsq(func):
def inner(* args, ** kwargs):
print("*" * 30)
func(* args, ** kwargs)
return inner
@zsq
def pnum(num1, num2, num3):
print(num1, num2, num3)
@zsq
def pnum2(num):
print(num)
pnum(1, 2, num3=666)
pnum2(2)
******************************
1 2 666
******************************
2
# 对有返回值的函数进行装饰:无论什么场景, 保证函数返回值一致
def zsq(func):
def inner(* args, ** kwargs):
print("*" * 30)
return func(* args, ** kwargs)
return inner
@zsq
def pnum(num1, num2, num3):
print(num1, num2, num3)
return num1 + num2 + num3
@zsq
def pnum2(num):
print(num)
res1 = pnum(1, 2, num3=666)
res2 = pnum2(2)
print(res1, res2)
******************************
1 2 666
******************************
2
669 None
# 带有参数的装饰器:通过@装饰器(参数)的方式, 调用这个函数, 并传递参数; 并把返回值, 再次当做装饰器进行使用
# 先计算@后面的内容, 把这个内容当做是装饰器
def getzsq(char):
def zsq(func):
def inner():
print(char * 30)
func()
return inner
return zsq
@getzsq("*") #括号里面的参数自己设置
def f1():
print("666")
f1()
******************************
666
生成器
概念
生成器是一个特殊的，更高级的迭代器，但是迭代器不一定是生成器
创建方式
生成器表达式：把列表推导式的[] 修改成 ()
生成器函数：函数中包含 yield语句，这个函数的执行结果就是 "生成器"（即函数每一次运行结果在 yield 这停止）
产生数据的方式
1.next()函数
2.使用 生成器.next() 方法
send()方法
send方法有一个参数，指定的是上一次被挂起的yield语句的返回值
相比于.next() 可以额外的给yield 语句 传值。注意第一次调用，要t.send(None)
关闭生成器
生成器.close()
后续如果继续调用, 会抛出StopIteration异常提示
注意：1.碰到return，会直接终止, 抛出StopIteration异常提示
2.生成器只会遍历一次
递归函数
不是一种函数，是指函数的一种调用方式
def jicheng(n):
if n == 1:
return 1
return n * jicheng(n - 1)
res = jicheng(4)
print(res) #24
函数作用域
Python是静态作用域，也就是说在Python中，变量的作用域源于它在代码中的位置; 在不同的位置, 可能有不同的命名空间，有不同的具体的操作范围
LEGB规则
L-Local：函数内的命名空间——当前整个函数体范围
E-Enclosing function locals：外部嵌套函数的命名空间——闭包函数
G-Global：全局命名空间——当前模块(文件)
B-Builtin：内建模块命名空间——所有模块(文件)
按照L -> E -> G -> B 的顺序进行查找
变量类型
有全局变量和局部变量，查看局部变量用 locals()，查看全局变量用 globals()。
全局变量和局部变量重名，获取是就近原则，修改是global 全局变量
a = 999 #全局变量
def test():
global a #此处不能用nonlocal,因为它仅仅适用于闭包，不适用于用函数内部改变全局变量
a = 6 #局部变量：这里如果直接使用赋值表达式，其实是代表定义一个新的变量
print(a)
print(a) #999
test() #6
print(a) #6
a = 999
def test():
a = 6
print(a)
print(a) #999
test() #6
print(a) #999
a = 999
def test():
global a
a = 6
print(a)
print(locals()) #此时a是全局变量
print(globals())
test()
6
{}
...(太多了就么有复制)
建议：在进行全局变量命名时，一般命名为 g_xxx（俗称而已）。
文件操作
文件打开
open("文件"，"模式")————模式有四种：
r：以只读方式打开文件，文件的指针将会放在文件的开头（文件不存在, 会报错）
w：以只写方式打开文件，文件的指针将会放在文件的开头吗，所以, 写入的新内容, 会覆盖旧的内容（文件不存在, 会自动创建一个新文件）
a：文件的指针将会放在文件结尾，所以, 写入的内容, 会新增到文件末尾（文件不存在, 会自动创建一个新文件）
增加b：以二进制格式进行操作文件读写（图片，音频，视频这些）
# 新建一个xx2照片，它是存在的xxx照片的一半
fromfile = open("xxx.png", "rb")
fromContent = fromfile.read()
print(fromContent)
fromfile.close()
toFile = open("xx2.png","wb")
content = fromContent[0: len(fromContent) // 2]
toFile.write(content)
toFile.close()
增加+：代表都是以 "读写模式" 进行打开
文件的使用流程
定位
seek(偏移量，[0,1,2])：0表示开头，1表示当前位置，2表示末尾
注意：文本文件的操作模式下(不带b)只能写0，如果想要写1/2, 必须在二进制文件操作模式下(带b)
读
read(字节数)：字节数默认是文件内容长度，可以自己修改
readline([limit])：读取一行数据，limit是限制的最大字节数
readlines()：会自动的将文件按换行符进行处理，将处理好的每一行组成一个列表返回
for in：可以直接遍历 f 本身，也可以遍历行列表
import collections.abc
f = open("s.text", "r")
print(isinstance(f,collections.abc.Iterator))
for i in f:
print(i,end="")
f.close()
True
11
22
33
44
content = f.read()
for i in content:
print(i,end="")
f.close()
11
22
33
44
readable()：判断是否可读
写
write("内容")：返回值是写入的字节长度
writeable()：判定是否可写
关闭
close()：如果不执行这一句，数据会保存在缓冲区，不会立即保存到磁盘文件中
flush()：清空缓冲区内容到磁盘文件中
文件的相关操作
此方法都是在os模块中运行，记得每次import os
重命名：os.rename(‘old_name’, 'new_name') ——修改单级目录：目录/文件 名称
os.renames(‘old_name’, 'new_name')——修改多级目录：目录/文件 名称
删除：os.remove('文件名')
创建文件夹：os.mkdir("文件夹名称")——一个
获取当前目录：os.getcwd()
改变默认目录：os.chdir("目标目录")
获取目录列表：os.listdir("./")
返回指定的文件夹包含的文件或文件夹的名字的列表：os.listdir()
判断括号里的文件是否存在的意思：os.path.exists()