Python学习笔记之入门基础

课程链接：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="^^^")

占位格式符

格式：%(name)widthtypecode

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)            #2print(num2)           #3print(num1 * num2)  #6
p(num2=3,num1=2)# 不定长参数：实参是元组的话在形参前面加 *
def mySum(* t):res = 0for s in t:res += sprint(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)     # 10def 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 + bcha = a - breturn (he, cha)
res = caculate(6, 7)
print(res[0])   #13
print(res[1])   #-1he, 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 + bcha = a - breturn (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 + cdef reduce(a, b, c):return a - b - cif flag == " + ":return sumif flag == " - ":return reduce
res = getFunc(" - ")
print(res(1, 2, 3))

匿名函数

也称为 "lambda函数"，顾名思义, 就是指没有名字的函数

注意：只能写一个表达式，表达式的结果就是返回值。所以, 只适用于一些简单的操作处理

sum = lambda x, y: x + y
print(sum(1, 3))        #4l = [{"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 = 3def 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 = 3def test2():                  def test2():a = 4                              nonlocal aprint(a)                       a = 4print(a)                          print(a)test2()                            print(a)print(a)                        test2() return test2                    print(a)
test = test1()                     return test2
3                               test = test1()
4                               3
3                               44

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]()       #3def test():focus = []for i in range(1, 4):def test2(num):def inner():print(num)return innerfocus.append(test2(i))return focusnewFucus = 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():                                  @checkprint("发说说")                         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 innerreturn 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 1return 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)        #6a = 999
def test(): a = 6        print(a)
print(a)        #999
test()          #6
print(a)        #999

a = 999
def test():global aa = 6print(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()