本文基于B站 小甲鱼视频 进行总结!!!
目录
8.4.4 symmetric_difference_update
1.变量及运算
1.1变量使用规则
(1)变量可以以中文起头,可以单个 _
(2)变量交换 x,y=y,x
刘家森=123
李四=456
print(刘家森)
print(李四)
刘家森,李四=李四,刘家森
print(刘家森)
print(李四)
1.2转义字符和原始字符
(1)单引号中包含双引号,双引号中包含单引号,单引号中有单引号使用转义字符,使用转义字符让 \ 后面的字符被认为是普通字符
(2)字符串前 加 r 表明后面字符串都为原始字符串,也就是没有转义
(3)一个 \ 在末尾 表示下行接着上行写
(4)三个 ’ 三个 “ 也可以实现换行,但要注意开始和结束的 引号 相对应
(5)用 () 可以实现换行输入,代表一句代码
(6)print(i,end=" ") 表示输出一个 i 之后 空一个接着输出
print("let's go!")
print('"every place')
print("————————")
print("D:\there\two\one\now")
print("D:\\there\\two\\one\\now")
print(r"D:\there\two\one\now")
print("————————")
print("l\
j\
s")
potry="""
刘家森
牛逼
啊
"""
print(potry)
1.3字符串的加法和乘法
字符串的加法:字符串的拼接
字符串的乘法:字符串的多次输出
print('520'+'1314')
print("刘家森\n"*3)
1.4伪随机数
利用 import 调用 random 库 即可实现下面函数
(1)random.randint(1,10) 随机产生1-10的一个整数
(2)random.getstate 获取随机数种子
(3)random.setstate 设置随机数生成器内部状态
1.5数字类型及运算
(1)python中的 0.1+0.2 不等于 0.3,这是由于精度导致。解决这个问题使用 decimal。deciaml中可以传递 整型 或者 字符型,不能传入浮点型
(2)对于 复数,python中可以实现 x.real 或者 x.imag分别实现调用输出
(3) // 地板除,对于结果取比目标结果小的整数
(4) Fraction(0,1) 代表 分子为0 分母为1
(4)逻辑运算符 and or not ,其中 not 代表取反的意思
(5)短路逻辑:从左往右,只有当第一个操作数的值无法确定逻辑运算结果时,才对第二个操作数进行求值 比如说 1and2 因为结果要判断到2才能确定,所以结果为2
import decimal
a=decimal.Decimal('0.1')
b=decimal.Decimal('0.2')
print(a+b)
c=0.1
d=0.2
print(c+d)
print("——————————")
x=1+2j
print(x.real)
print(x.imag)
print("——————————")
print(3/2)
print(3//2)
print("——————————")
if(3<4 and 4<5):
print("true")
else:
print("false")
print("——————————")
if(3<4 or 40<5):
print("true")
else:
print("false")
print("——————————")
if(not 3<4) :
print("true")
else:
print("false")
2.分支和循环
2.1分支 if
(1)if
(2)if else
(3)if elif elif else 其中elif==else if
(4)成立执行语句 if 判断条件 else 不成立执行语句
(5)可进行分支嵌套
(6)else 可用于 while 。当while条件为假时进入else,但中途用break跳出则不进入else
if 3<5:
print("对")
print("————————if else————————")
if (2==3):
print("相等")
else:
print("不等")
print("———————if elif—————————")
score=input("请输入分数:")
score=int(score)
if (score==2):
print("2")
elif (score==3):
print("3")
elif(score==4):
print("4")
else:
print(0)
print("——————if其他写法——————————")
a=10
b=20
smart=a if a<b else b
print(smart)
print("———————分支嵌套—————————")
if(3>5):
print("3>5")
else:
if(3>4):
print("3>4")
else:
print("3<4")
2.2循环 while
(1)while 判断条件 执行语句
i=1
while i<=9:
j = 1
while j<=i:
print(j,"*",i,"=",j*i,end=" ")
j+=1
print()
i+=1
2.3循环 for
(1)for 变量 in 可迭代对象 :执行语句
(2)range(stop)生成0,stop-1的整数 range(start,stop)生成一个start,stop-1的整数 range(start,stop,step)step是改变的步进
注意事项:rangr(5,5)此时没有数字 range(4,5)此时只有4
for each in "hello":
print(each)
print("————————range(stop)————————————")
for i in range(10):
print(i,end=" ")
print("————————range(start,stop)————————————")
for i in range(5,5):
print(i,end=" ")
print("————————range(start,stop,step)————————————")
for i in range(10,5,-2):
print(i,end=" ")
3.列表
3.1列表定义
定义:可以存放不同数据类型的序列
语法:【1,12,“迷惑”】
rhyme=[1,2,3.1,"刘家森"]
print(rhyme)
print("————————for输出所有列表—————————")
for each in rhyme:
print(each)
3.2列表下标索引输出
(1)语法:列表名字【下标】
注意事项:(1)最后一个元素下标为 -1
(2)可以利用 len 函数找到最后元素下标,但要减1
print("————————列表下标输出—————————")
print(rhyme[0])
print(rhyme[3])
length = len(rhyme)
print(rhyme[length-1])
print(rhyme[-1])
3.3列表切片
作用:可以对列表进行多值输出,也就是按区域一次性输出很多
注意事项:(1)【:】代表从头到尾输出整个列表
(2)【:3】代表从下标0号位置输出下标为 3-1的数
(3)【3:】代表从下标为3的位置输出到所有
(4)【a:b】代表从下标a开始,输出到下标 b-1
(5)【::2】代表从左至右间距为2依次输出列表
(6)【::-1】代表从右往左间距为1依次输出列表(逆序输出)
print("————————列表切片—————————")
print(rhyme[0:3])
print(rhyme[2:4])
print(rhyme[0:7:2])
print(rhyme[::2])
print(rhyme[::-1])
3.4列表方法
3.4.1内容增加
语法:(1)末尾插入 append()添加单个 extend()添加多个
(2)容易位置插入 insert(a,b)在下标a出插入b值
作用:在列表末尾添加一个或多个指定元素
注意事项:(1)利用切片也可以实现增加,s【2:】=【7,8】 代表从当前2号下标开始后的数据等于 7,8,9
print("———————列表方法增加————————————")
heros=["钢铁侠","绿巨人"]
heros.append("黑寡妇")
print(heros)
heros.extend(["张三","李四","王五"])
print(heros)
print("———————切片方法增加————————————")
s=[1,2,3,4,5,6]
s[3:]=[7,8,9]
print(s)
print("———————列表方法容易位置增加————————————")
s.insert(3,4)
print(s)
3.4.2内容删除
语法:(1)remove(a)删除列表中的 a 如果有多个 a 那就只删除第一个,并且如果列表没有a则会报错
(2)pop(b)删除下标为b 的元素
(3)clear 清空整个列表
print("———————列表方法删除————————————")
x=[1,2,3,4,5,6]
x.remove(1)
print(x)
x.pop(2)
print(x)
x.clear()
print(x)
3.4.3内容替换
语法:(1)单值修改 利用下标值修改,s【下标】=“t替换值” 多值修改 利用切片修改
(2)排序 sort 升序 reverse 降序
print("——————插入————————")
s=[1,2,3,4,5,6]
s[3]=40
print(s)
s[2:]=[500,400,600]
print(s)
print("——————sort升排序————————")
s.sort()
print(s)
print("——————sort降排序————————")
s.reverse()
print(s)
3.4.4内容查找
语法:count () 查找指定元素并返回个数
index()查找指定元素的下标 多元素的话返回第一个
index(x,start,end)查找指定范围内的 x
copy 拷贝列表
print("——————插入————————")
s=[1,2,3,4,5,6]
s[3]=40
print(s)
s[2:]=[500,400,600]
print(s)
print("——————sort升排序————————")
s.sort()
print(s)
print("——————sort降排序————————")
s.reverse()
print(s)
print("——————查找————————")
x=[1,2,2,3,6,5,2,4]
print(x.count((2)))
print(x.index(6))
print(x.index(2,2,4))
print("——————拷贝————————")
x_copy=x.copy()
print(x_copy)
x_copy2=x[:]
print(x_copy2)
3.5列表运算
3.5.1加法
(1)列表之间相加 也就是列表元素拼接
(2)列表*x 也就是列表元素变为 x 倍
print("——————————列表加法————————")
s=[1,2,3]
x=[4,5,6]
y=s+x
print(y)
print(2*y)
3.5.2嵌套列表
本质:二维列表
初始化:通过for循环实现
访问:(1)for循环 (2)元素下标(类似二维数组)
is 同一性运算符 用于检验两个变量是否指向同一个对象的运算符
print("——————————嵌套列表————————")
martix=[[1,2,3],[4,5,6],[7,8,9]]
print(martix)
martix=[[1,2,3],
[4,5,6],
[7,8,9]
]
print(martix)
print("——————————访问嵌套列表————————")
for i in martix:
for each in i:
print(each,end=' ')#元素间隔
print()#换行
print(martix[0])
print(martix[0][0])
print("——————————嵌套列表初始化————————")
A=[0]*3
for i in range(3):#让 i 依次变为 0 1 2 这样做是为了给下面 A【i】进行赋值为 A【0】
A[i]=[0]*3
print(A)
3.6列表拷贝
3.6.1浅拷贝
对于一个列表 x ,将会产生一个不同内存地址,且数据一样的列表为 y。此时 x 和 y 之间互相不影响 适用于 一维列表,二维列表会出错。因为浅拷贝只是拷贝了外层,内存的数据是引用操作
print("————一维列表浅拷贝————————")
x=[1,2,3]
y=x.copy()
print(x)
print(y)
x[1]=10
print(x)
print(y)
print("————二维列表浅拷贝————————")
x=[[1,2,3],
[4,5,6],
[7,8,9]]
y=x.copy()
print(x)
print(y)
x[1][1]=50
print(x)
print(y)
3.6.2深拷贝
实现方法:利用copy模块调用copy函数,需要先 import copy库 使用 deepcopy 函数。它的原理是将原对象以及其子对象都进行了拷贝
import copy
print("————二维列表深拷贝————————")
x=[[1,2,3],
[4,5,6],
[7,8,9]]
y=copy.deepcopy(x)
print(x)
print(y)
x[1][1]=50
print(x)
print(y)
3.7列表推导式
语法:(1)【改变方法 for 目标 in 当前列表】 oho=[i * 2 for i in oho]
(2)【改变方法 for 目标 in 当前列表 if 条件判断】
s=[i for i in range(10) if i%2==0] 先执行 for 再执行 if 最后输出 i
(3)【改变方法 for 目标 in 当前列表 for 目标 in 当前列表】 嵌套方法
z=[x+y for x in "fishc" for y in "FISHC"](4)【改变方法 for 目标 in 当前列表 if 条件判断 for 目标 in 当前列表 if 条件判断】
x=[x+y for x in range(10) if x%2==0 for y in range(100,110) if y%2==0]注意事项:(1)ord 函数:把 字符 转为 Unicode 编码并保存为列表
(2)循环是通过迭代来改变列表各元素值,而列表推导式直接创建一个新的列表,然后再赋值为原先的这个变量名
print("——————for循环改变列表值——————————")
oho=[1,2,3,4,5]
for i in range(len(oho)):
oho[i]=oho[i] * 2
print(oho)
print("——————列表推导式一维列表——————————")
oho=[1,2,3,4,5]
oho=[i * 2 for i in oho]
print(oho)
x=[c*2 for c in "FinshC"]
print(x)
print("——————ord准换编码——————————")
code = [ord(x) for x in "FinshC"]
print(code)
print("——————列表推导式二维列表——————————")
martix=[[1,2,3],
[4,5,6],
[7,8,9]]
col2=[row[1] for row in martix]#获取每行下标为 1 的元素
print(col2)
diag=[martix[i][i] for i in range(len(martix))]
print(diag)
4.元组
4.1元组定义
语法:(元素1 ,元素2),这里和列表不一样,是()而不是【】,而且可以省去()
注意事项:元组内数据不可以再进行修改
ryhme=(1,2,3,4,5,6,"瘦死的骆驼比马大")
print(ryhme)
ryhme=1,2,3,4,5,6,"瘦死的骆驼比马大"
print(ryhme)
4.2元组的通用
(1)元组和列表在 运算中区别是:只能查找,不能增加修改
(2)生成一个元素元组:s=(1,) 生成一个整数 s=(1)
(3)如果元组中成员是列表,则可以进行修改
print("———————元组定义—————————————")
ryhme=(1,2,3,4,5,6,"瘦死的骆驼比马大")
print(ryhme)
ryhme=1,2,3,4,5,6,"瘦死的骆驼比马大"
print(ryhme)
print("———————元组下标访问—————————————")
print(ryhme[0])
print(ryhme[-1])
print("———————元组切片访问—————————————")
print(ryhme[0:3])
print(ryhme[::])
print(ryhme[3:])
print(ryhme[3:5])
print(ryhme[::-1])
print("———————元组查找—————————————")
num=(1,1,4,3,2,5)
print(num.count(1))
print(num.index(2))
print("———————元组加法—————————————")
x=1,2,3
y=4,5,6
s=x+y
print(s)
print(s*2)
print("———————元组for访问—————————————")
for each in s:
print(each,end=' ')
print()
print("———————元组for嵌套—————————————")
w=(1,2,3),(4,5,6)
for i in w:
for each in i:
print(each,end=' ')
print()
print("———————元组列表推导式—————————————")
s=1,2,3,4,5
s=[each *2 for each in s]
print(s)
4.3元组打包和解包
打包:生成一个元组也叫打包
解包:把元组数据根据 , 分隔输出
注意事项:(1)列表和字符串也具有该性质
(2)字符串在使用过程中必须根据有多少字符分几个包
(3)字符串技巧:一个包输出多字符 a,*b=x。这时 a 占一个 其余全是 b的
print("————————元组打包————————————————")
t=(123,"刘家森","ljs")
print(t)
print("————————元组解包————————————————")
x,y,z=t
print(x)
print(y)
print(z)
print("————————列表解包————————————————")
x=[123,345,21]
q,w,e=x
print(q)
print(w)
print(e)
print("————————字符串解包————————————————")
x="ljs"
q,w,e=x
print(q)
print(w)
a,*b=x
print(a)
print(b)
5.字符串
5.1字符串变换
5.1.1capitalize
capitalize()
把首字母变为大写,其他变为小写
print("————————capitalize————————————")
x="i lovE YOU"
print(x.capitalize())
5.1.2casefold
casefold()
把大写字母全部变为小写(任何语言)
print("————————casefold————————————")
x="I lovE YOU"
print(x.casefold())
5.1.3title
title()
将每个单词首字母变为大写,其他字母变为小写
print("————————title————————————")
x="i lovE yOU"
print(x.title())
5.1.4swapcase
swapcase()
将所有字母的大小写进行翻转
print("————————swapcase————————————")
x="i lovE yOu"
print(x.swapcase())
5.1.5upper
upper()
将所有字母变为大写
print("————————upper————————————")
x="i lovE yOu"
print(x.upper())
5.1.6lower
lower()
将所有字母变为小写(只能英语)
print("————————lower————————————")
x="i lovE yOu"
print(x.lower())
5.2字符串对齐
下面这些函数的第一个参数(字符串宽度) 必须大于字符串长度,否则直接输出该字符串。此外下列函数第二个参数代表填充的 字符,不写第二个参数默认为 空格
5.2.1center
center(width,fillchar=‘’) fillchar为填充字符串
字符串居中对齐
print("————————center————————————")
x='刘家森'
x=x.center(15)
print(x)
5.2.2ljust
ljust(width,fillchar=‘’) fillchar为填充字符串
字符串左对齐
print("————————ljust————————————")
x='刘家森'
x=x.ljust(15)
print(x)
5.2.3rjust
rjust(width,fillchar=‘’) fillchar为填充字符串
字符串右对齐
print("————————rjust————————————")
x='刘家森'
x=x.rjust(15)
print(x)
5.2.4zfill
zfill(width)
用 0 填充左侧
print("————————zfill————————————")
x='刘家森'
x=x.zfill(15)
print(x)
5.3字符串查找
5.3.1count
count(num,start,end)
查找某个字符串出现的次数(可选区间查找)
print("————————count————————————")
x='我来自我的家'
a=x.count("我")
print(a)
5.3.2find
find(num,start,end)
查找某个字符串的下标(从左往右)没找到返回 -1
print("————————find————————————")
x='我来自我的家'
a=x.find("我")
print(a)
5.3.3rfind
rfind(num,start,end)
查找某个字符串的下标(从右往左)没找到返回 -1
print("————————rfind————————————")
x='我来自我的家'
a=x.rfind("我")
print(a)
5.3.4index
index(num,start,end)
查找某个字符串的下标(从左往右) 没找到直接报错
print("————————index————————————")
x='我来自我的家'
a=x.index("我")
print(a)
5.3.5rinedx
rindex(num,start,end)
查找某个字符串的下标(从右往左) 没找到直接报错
print("————————rindex————————————")
x='我来自我的家'
a=x.rindex("我")
print(a)
5.4字符串替换
5.4.1expandtabs
expandtabs([tabsize=8])
将字符串中的 tab 全部替换为空格,里面参数为1个tab换成x个空格
print("————————expandtabs————————————")
code = """
print("123")
print("456")
"""
new_code=code.expandtabs(2)
print(new_code)
5.4.2replace
replace(old,new,count=-1)
将 原字符串 替换为 新字符串,里面参数为替换次数
print("————————replace————————————")
x="在吗?"
y="想你!"
x=x.replace(x,y)
print(x)
5.4.3translate
translate(table)
根据转换表格进行转换。可以加上忽略参数,这样在输出就不会显示
print("————————table————————————")
table = str.maketrans("abcdefg","1234567","love")#忽略了 love
x="acchgd love abc"
x=x.translate(table)
print(x)
5.5字符串判断
(1)下面判断函数都是返回一个 bool 类型数据
(2)从左往右的顺序执行函数,例如 x.upper.isupper。先执行全为大写再判断是否为大写
5.5.1startswith
startswith(prefix,start,end) prefix可以是一个元组 ((“我”,“你”,“它”))
判断查找的字符串是不是在第一个位置
print("——————startswith———————")
x="我爱你 ,我真的服了"
print(x.startswith("我爱你"))
5.5.2endswith
endswith(prefix,start,end) prefix可以是一个元组 ((“我”,“你”,“它”))
判断查找的字符串是不是在最后一个位置
print("——————endswith———————")
x="我爱你 ,我真的服了"
print(x.endswith("服了"))
5.5.3isupper
isupper()
判断字符串所有字母是否都为大写
print("——————isupper———————")
x="I LOVE YOU"
print(x.isupper())
5.5.4islower
islower()
判断字符串所有字母是否都为小写
print("——————islower———————")
x="i love you"
print(x.islower())
5.5.5istitle
istitle()
判断字符串所有字母是否以大写开始,其他全为小写
print("——————istitle———————")
x="I Love You"
print(x.istitle())
5.5.6isalpha
isalpha()
判断是否只有字母构成,注意空格
print("——————isalpha———————")
x="iloveyou"
print(x.isalpha())
5.5.7isascii
isascii()
判断字符串为空或字符串中的所有字符都是 ASCII
5.5.8isspace
isspace()
判断是否为空白字符串 \n 和 空格 为空白字符串
print("——————isspace———————")
x=" "
print(x.isspace())
5.5.9isprintable
isprintable()
判断所有字符是否可以打印 \n 不能打印
print("——————isprintable———————")
x=" \n "
print(x.isprintable())
5.5.10isdecimal
isdecimal()
检查是不是数字 一般只用于 1 2 3这种数字
5.5.11isdigit
isdigit()
检查是不是数字 支持
5.5.12isnumeric
isnumeric()
检查是不是数字 支持 一 Ⅰ等多种类型数字
5.5.13isalnum
isalnum()
当 isalpha isdecimal isnumerical isdigit返回 true 时,它也返回 true
5.5.14isidentifier
isidentifier()
判断字符串是否是一个合法的标识符
print("——————isidentifier———————")
x="a_1"#正确
y="1_a"#错误
print(x.isidentifier())
5.5.15iskeyword
iskeyword(“sub”) sub为要查找的字符
来查看该字符是否为python中的关键字
print("——————iskeyword———————")
import keyword
print(keyword.iskeyword("if"))
5.6字符串截取
5.6.1lstrip
lstrip(“sub“) sub默认情况为空,如果写上字符串abc 则代表去除左侧abc。但是有空格则都不去除
去除左侧的空格
print("——————lstrip———————")
x=" ljs"
print(x.lstrip())
5.6.2rstrip
lstrip(“sub“)sub默认情况为空,如果写上字符串abc 则代表去除右侧abc。但是有空格则都不去除
去除右侧的空格
print("——————rstrip———————")
x="ljs "
print(x.lstrip())
5.6.3strip
strip(“sub“)sub默认情况为空,如果写上字符串abc 则代表去除左右测abc。但是有空格则都不去除
去除左右侧的空格
print("——————strip———————")
x=" ljs "
print(x.strip())
x=" wx ljs wx"
print(x.strip("wx"))
5.6.4removeprefix
removeprefix()
删除指定的前缀 注意空格字符串
print("——————removeprefix———————")
x="www.ljs.com "
print(x.removeprefix("www."))
5.6.5removesuffix
removesuffix()
删除指定的后缀 注意空格字符串
print("——————removeprefix———————")
x="www.ljs.com "
print(x.removesuffix("com "))
5.7字符串拆分
5.7.1partition
partition(”sub“) sub为分隔的字符串
根据输入要求从左往右,把字符串分为三部分,第一部分:为分隔符左侧,第二部分为:分隔符,第三部分:为分隔符右侧
print("——————partition———————")
x="www.ljs.com "
print(x.partition("."))
5.7.2rpartition
rpartition(”sub“) sub为分隔的字符串
根据输入要求从右往左,把字符串分为三部分,第一部分:为分隔符左侧,第二部分为:分隔符,第三部分:为分隔符右侧
print("——————rpartition———————")
x="www.ljs.com "
print(x.rpartition("."))
5.7.3split
split(”sub“,num) 从左往右进行切割
(1)默认情况都不输入下是按空格划分无限次
(2)”sub“代表按sub进行分隔 , num代表切割次数
print("——————split———————")
x="www ljs com"
print(x.split())#默认输出
x="www.ljs.com"
print(x.split("."))
print(x.split(".",1))
5.7.4rsplit
rsplit(”sub“,num) 从右往左进行切割
(1)默认情况都不输入下是按空格划分无限次
(2)”sub“代表按sub进行分隔 , num代表切割次数
print("——————rsplit———————")
x="www ljs com"
print(x.rsplit())#默认输出
x="www.ljs.com"
print(x.rsplit("."))
print(x.rsplit(".",1))
5.7.5splitlines
splitlines(True)
按行进行分隔。如果写上true代表加上换行符输出
print("——————splitlines———————")
x="www\nljs\ncom"
y="www\nljs\rcom"
print(x.splitlines())
print(x.splitlines(True))
5.8字符串拼接
5.8.1join
”sub“.join(["一部分",”二部分“,”三部分“])
把sub插入到各个部分之间,里面可以是列表【】,也可以是元组()
print("——————join———————")
x='.'
y=x.join(["www","ljs","com"])
print(y)
5.9字符串格式化
5.9.1format基本语法
语法:”刘家森{}“.format(”帅“)
作用:把字符串中的量当作一个可以输出的值,方法是{}代表这里要输出的位置,format里面是输出的值
print("———————format默认单插入———————————")
year=2010
x="刘家森来自于{}"
y=x.format(year)
print(y)
5.9.2format插入方法
(1)默认多{}插入
print("———————format默认多插入———————————")
x="刘家森{},罗灿灿{}"
y=x.format("帅","美")
print(y)
(2)按 format 里面数据序号插入
print("———————format{}插值方法1———————————")
x="刘家森{1},罗灿灿{0}"
y=x.format("帅","美")
print(y)
x="刘家森{1},罗灿灿{1}"
y=x.format("帅","美")
print(y)
(3)format 里面数据名字插入
print("———————format{}插值方法2———————————")
x="{n1}美,{n2}美"
y=x.format(n1="刘家森",n2="罗灿灿")
print(y)
5.9.3format对齐
(1)居中对齐
print("———————format居中———————————")
x="{:^10}"#10代表宽度为10 :代表位置或者关键字 :右边是格式化选项
y=x.format(250)
print(y)
(2)右对齐
print("———————format右对齐1———————————")
x="{1:>10}{0:<10}"
y=x.format(520,250)
print(y)
print("———————format右对齐2———————————")
x="{left:>10}{right:<10}"
y=x.format(right=520,left=250)
print(y)
(3)数据填充
print("———————format填充0———————————")
x="{:010}"#第一个0 代表填充 0
y=x.format(520)
print(y)
print("———————format填充0+对齐———————————")
x="{1:a>10}{0:b<10}"# 填充 a b
y=x.format(520,250)
print(y)
5.9.4format +- 使用
print("———————format整数使用———————————")
x="{:+}{:-}"
y=x.format(250,-250)
print(y)
print("———————format , 当作千分符———————————")
x="{:,}"#位数不足则不显示
y=x.format(2515)
print(y)
print("———————format _ 当作千分符———————————")
x="{:_}"
y=x.format(2515)
print(y)
5.9.5format精度
(1)对于整型,可以采用 上述1 2 两个方案
(2)对于字符串,则是进行字符截取
(3)精度使用在 : 后面加 .2 代表精度为2
print("———————format 数字精度———————————")
x="{:.2f}"#保留2位精度
y=x.format(3.2515)
print(y)
x="{:.2g}"#保留2位数
y=x.format(3.2515)
print(y)
print("———————format 字符串精度———————————")
x="{:.5}"#保留3位精度 不能用于整数
y=x.format("liu and lcc")
print(y)
5.9.6format整型输出格式
print("———————format 整型输出格式二进制———————————")
x="{:b}"
y=x.format(16)
print(y)
print("———————format 整型输出格式Unicode———————————")
x="{:c}"
y=x.format(80)
print(y)
print("———————format 整型输出格式增加前缀———————————")
x="{:#b}"#实现输出前多一个 0b 表示二进制
y=x.format(16)
print(y)
5.9.7format浮点数输出
print("———————format 浮点数科学计数法输出———————————")
x="{:e}"#e是结果为e E是结果为E
y=x.format(16.3214)
print(y)
print("———————format 浮点数定点表示法输出———————————")
x="{:f}"#默认保留精度 6位
y=x.format(16.3214)
print(y)
print("———————format 浮点数 g 输出———————————")
x="{:g}"#如果format里面数大 则按e,如果小则按定点法
y=x.format(16003214)
z=x.format(125.321)
print(y)
print(z)
print("———————format 浮点数 % 输出———————————")
x="{:.2%}"#先乘100 再加%,默认精度 6
y=x.format(16.3214)
print(y)
5.9.8 f-字符串
作用:简化了 format 写法
语法:把之前 format 里面的数据写到 :前面,然后在 ” “ 前加入f或者F
注意事项:(1)支持3.6版本以上
print("———————f-字符串 基本使用———————————")
year=2010
x=F"刘家森来自:{year}"
y=F"刘家森来自:{1100}"
print(x)
print(y)
print("———————f-字符串 格式化———————————")
x=F"{-520:06}"
print(x)
x=F"{123456789:,}"
print(x)
print("———————f-字符串 精度———————————")
x=F"{3.1526:.2f}"
print(x)
print("———————f-字符串 复杂问题———————————")
a='+'
b='^'
c=10
d=3
e='g'
x=F"{3.1415:{a}{b}{c}.{d}{e}}"
print(x)
6.序列
(1)在 python中 所有对象 都有三个属性 ,唯一标识(不可修改无重复),类型,值
(2)id(s)查看 s 的唯一标识
6.1序列运算符
6.1.1 +
进行列表,元组,字符串的拼接
print("——————— + —————————————")
print([1,2,3]+[4,5,6])
print((1,2,3),(4,5,6))
print("123"+"456")
6.1.2 *
进行列表,元组,字符串的多倍输出
print("——————— * —————————————")
print([1,2,3]*3)
print((1,2,3)*3)
print("123"*3)
6.1.3 is
检测对象的 id 值 是否相等
print("——————— is —————————————")
a=1
b=1
if(a is b):
print("一样")
else:
print("不一样")
6.1.4 is not
检测对象的 id 值 是否不相等
print("——————— is not —————————————")
a=1
b=1
if(a is not b):
print("一样")
else:
print("不一样")
6.1.5 in
判断某个函数是否在序列中
print("——————— in —————————————")
a="ljslcc"
if('j' in a):
print("在")
else:
print("不在")
6.1.6 not in
判断某个函数是否不在序列中
print("——————— not in —————————————")
a="ljslcc"
if('j' not in a):
print("在")
else:
print("不在")
6.1.7 del
删除一个或多个指定的对象
rint("——————— del 基本用法—————————————")
x=[1,2,3,4,5,6]
print(x)
del x[0:2]#删除 0-2的元素
print(x)
print("——————— 切片实现 del —————————————")
x=[1,2,3,4,5,6]
x[0:3]=[]
print(x)
print("——————— del 缩进删除—————————————")
x=[1,2,3,4,5,6]
print(x)
del x[::2]#删除 0-2的元素
print(x)
6.2序列函数
6.2.1 list
把元组,字符串变为列表
print("——————— list—————————————")
x=list((1,2,3,4,5))
print(x)
x=list("123456")
print(x)
6.2.2 tuple
把列表,字符串变为元组
print("——————— tuple—————————————")
x=tuple([1,2,3,4,5])
print(x)
x=tuple("123456")
print(x)
6.2.3 str
把元组,列表变为字符串
print("——————— str—————————————")
x=str((1,2,3,4,5))
print(x)
x=str([1,2,3,4,5])
print(x)
6.2.4 min
对比传入所有参数 返回最小的
注意啊事项:(1)传入参数不能为空
(2)对于参数为空,引入默认设置输出方式
print("————————— min 单参数 —————————————")
s=[1,1,2,3,4]
print(min(s))
print("————————— min 无参 —————————————")
s=[]
print(min(s,default="BBQ了"))
print("————————— min 多参数—————————————")
s=[1,1,2,3,4]
x=[7,8,8]
print(min(s,x))#输出具有最小值的列表
6.2.5 max
对比传入所有参数 返回最大的
print("————————— max —————————————")
s="ljsandlcc"
print(max(s))
6.2.6 len
len(sub) 获取 sub 长度
获取变量的长度 len函数的范围有限,2的32/64次方-1
print("————————— len ————————————")
x="abcd"
print(len(x))
6.2.7 sum
sum(sub) 对 sub 内求和
进行输入参数求和,输入可以为元组,列表
print("————————— sum ————————————")
x=(1,2,3,4,5)
print(sum(x))
y=5
print(sum(x,y))
6.2.8 sorted
sorted()
元素升序排序。
注意事项:(1)与 sort 不一样在于 sorted不会改变之前的元素位置, sort会改变
(2)sorted 和 sort 一样 ,具有 关键参数控制排序方法(reverse:升降排序控制)(key:关键词控制排序)
(3)sort只能处理列表。 sorted可以处理元组,列表,字符串最后返回列表结果
print("————————— sorted ————————————")
x="aebcd"
print(sorted(x))#默认升序
print(x)
print("————————— sorted reverse参数————————————")
x="aebcd"
print(sorted(x,reverse=True))#降序
print("————————— sorted key参数————————————")
x=["ab","ba","abc","aaaa"]
print(sorted(x,key=len))#根据 长度 排序
6.2.9 reversed
reversed()
对元素进行反向排序
注意事项:(1)reversed返回的是参数反向迭代器,对原数据不改变
(2)reverse没返回值,改变了原数据,所以不能print(x.reverse())
print("————————— reversed ————————————")
x=[1,3,4,5]
print(list(reversed(x)))
print("————————— reverse ————————————")
x=[1,3,4,5]
x.reverse()
print(x)
6.2.10 all
all()
判断所有元素是否为真(0为假)
print("————————— all ————————————")
x=[0,1,2]
y=[1,2,3]
print(all(x))
print(all(y))
6.2.11 any
判断是否存在元素是否为真(0为假)
print("————————— any ————————————")
x=[0,1,2]
y=[1,2,3]
print(any(x))
print(any(y))
6.2.12 enumerate
把一个列表数据,通过自定义或者默认方式加上一个编号,构成二维元组
print("————————— enumerate ————————————")
x=["spring","summer","winter"]
print(list(enumerate(x)))
print(list(enumerate(x,5)))
6.2.13 zip
把列表或者字符串进行对应拼接构成新的元组。例如x列表的一号位置和y字符串的1号位置拼接成一个2维元组的一号位置
注意事项:(1)从元素个数最少的为基础开始组成
(2)如果想要对所有元素都进行拼接,可以利用 itertools库,调用zip_longest函数,这样对于少了的数据就用 none 拼接
print("————————— zip ————————————")
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
zipped=zip(x,y,z)
print(list(zipped))
print("————————— zip_longest————————————")
import itertools
x=[1,2,3,4,5]
y=[4,5,6,7]
z=[7,8,9]
zipped=itertools.zip_longest(x,y,z)
print(list(zipped))
6.2.14 map
根据自定义函数对可迭代对象的每个元素进行运算,并将运算之后的结果返回给迭代器
注意事项:(1)对于多参数情况,以最短为基础
print("————————— map 单参数————————————")
maped=map(ord,"ljsandlcc")
print(list(maped))
print("————————— map 多参数————————————")
maped=map(pow,(1,2,3),(2,2,2))
print(list(maped))
6.2.15 filter
根据自定义函数对可迭代对象的每个元素进行运算,并将运算之后的为真结果返回给迭代器
print("————————— filter 单参数————————————")
maped=filter(str.islower,"Jason")
print(list(maped))
6.2.16 iter
(1)一个迭代器肯定是一个可迭代对象
(2)可迭代对象(列表,元组)可以重复使用,迭代器(通过像map,iter函数得到)则是一次性的
print("————————— 迭代器————————————")
maped=filter(str.islower,"Jason")
for each in maped:
print(each)
print(list(maped))
print("————————— 迭代器对象————————————")
x=[1,2,3,4]
for each in x:
print(each)
print(x)
print("————————— iter————————————")
x=[1,2,3,4,5]
y=iter(x)
print(type(x))
print(type(y))
6.2.17 next
逐个将迭代器的元素提取出来
注意事项:(1)因为迭代器元素有限,为了防止元素都访问完之后继续访问程序异常,可以加入参数使得异常时输出自定义参数
print("————————— next————————————")
x=[1,2,3,4,5]
y=iter(x)
print(next(y))
print(next(y))
print(next(y))
print(next(y))
print(next(y))
print("————————— next 控制范围————————————")
x=[1,2,3,4,5]
y=iter(x)
print(next(y,"没了"))
print(next(y,"没了"))
print(next(y,"没了"))
print(next(y,"没了"))
print(next(y,"没了"))
print(next(y,"没了"))
7.字典
7.1字典创建
方法:(1){} 与 : 结合 a={"张三":"李四","1":"2"}
(2)dict 函数 b=dict(张三="1",李四="2",王五="3")
(3)dict+列表 c=dict([("z","1"),("x","2"),("q","3")])
(4)dict+(1) d=dict({"张三":"李四","1":"2"})
(5)dict+(1)+2 ) e=dict({"张三":"李四","1":"2"},王五="3")
(6)dict + zip f=dict(zip(["1","2","3"],["a","b","c"]))
注意事项:(1)字典内容不可以重复
print("———————— 字典 创建方法1————————————")
x={"张三":"李四","1":"2"}
print(type(x))
print(x["张三"])#输出李四
x["王五"]="赵6"#添加一对新的王五:赵六
print(x)
print("———————— 字典 创建方法2————————————")
x=dict(张三="1",李四="2",王五="3")
print(x)
print("———————— 字典 创建方法3————————————")
a=dict([("z","1"),("x","2"),("q","3")])
print(a)
print("———————— 字典 创建方法4————————————")
d=dict({"张三":"李四","1":"2"})
print(d)
print("———————— 字典 创建方法5————————————")
e=dict({"张三":"李四","1":"2"},王五="3")
print(e)
print("———————— 字典 创建方法6————————————")
f=dict(zip(["1","2","3"],["a","b","c"]))
print(f)
7.2字典内容操作
7.2.1 增加
formkeys(iterable,values) 把迭代器对象赋值给 values
方法:x【”A“】=250 键A赋值250.如果字典有 A 了则是修改,如果没有则是添加
print("———————— 字典 增加内容————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
x["a"]=250#添加内容
print(x)
7.2.2删除
(1)pop(键) 删除指定键
(2)popitem() 删除最后一个键
(3)del x【j键】 删除指定键或者字典
注意事项:(1)如果不存在删除的键,则出现异常,解决办法:pop(键,”没有该键“)
print("———————— 字典 删除内容————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
x.pop("j","没有")#删除键 j
print(x)
print("———————— 字典 删除最后内容————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
x.popitem()
print(x)
print("———————— 字典 删除del————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
del x['l']
print(x)
7.2.3清空
clear()
print("———————— 字典 清空————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
x.clear()
print(x)
7.2.4修改
方法:(1)update({other})other为字典或可迭代对象或多个键值对
(2)x【”A“】=250 键A重新赋值250.
print("———————— 字典 修改 多键值对————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x)
x.update({"l":1,"j":2})
print(x)
x.update(l='10',s='50')
print(x)
7.2.5查找
get(key,default)default为找不到清空下的输出
setdefault(key,default) 如果没找到,则给没找到的键 赋值自定义值
print("———————— 字典 查找get————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
print(x.get('l',"找不到"))
print("———————— 字典 查找setdefault————————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
m.setdefault('q',"找不到")
print(m)
7.3字典获取
视图对象:是字典的动态试图,当字典内容改变,视图对象内容也改变
7.3.1 items
获取字典的键值对视图对象
7.3.2 keys
获取字典的键视图对象
7.3.3 values
获取字典的值视图对象
print("———————— 字典 视图对象————————————")
x=dict.fromkeys("ljs",250)#初始化一个 字典
keys=x.keys()
values=x.values()
items=x.items()
print(keys)
print(values)
print(items)
x.pop('l')
print(keys)
print(values)
print(items)
7.3.4 len
获取字典长度
print("———————— 字典 len———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
print(len(m))
7.3.5 in & not in
判断键是否存在于字典中
print("———————— 字典 in———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
print('l' in m)
print("———————— 字典 not in———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
print('l' not in m)
7.3.6 list
把字典中所有的键变为列表,输出键值用values()
print("———————— 字典 list———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
n=list(m)
print(n)
7.3.7 iter
将字典的键构成一个迭代器
print("———————— 字典 iter———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
e=iter(m)
print(next(e))
print(next(e))
print(next(e,"没了"))
print(next(e,"没了"))
7.3.8 reversed
对字典内部键值对进行逆向操作
print("———————— 字典 reversed———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
e=reversed(m)
print(list(e))
7.4字典拷贝
copy() 浅拷贝
print("———————— 字典 浅拷贝copy———————————")
m=dict.fromkeys("ljs",250)#初始化一个 字典
n=m.copy()
print(m)
print(n)
7.5字典嵌套
字典里面的键值也为字典
print("———————— 字典 嵌套1———————————")
d={"张三":{"语文":60,"数学":60,"英语":60},"李四":{"语文":70,"数学":70,"英语":70}}
print(d)
print(d["张三"]["数学"])
print("———————— 字典 嵌套2———————————")
d={"张三":[60,70,80],"李四":[600,700,800]}
print(d)
print(d["张三"][1])#输出张三的 下标 1
7.6字典推导式
通过 for 循环加上字典,能够更快的得到新的 字典
print("———————— 字典 推导式———————————")
d={"a":1,"b":2,"c":3}
b={v:k for k,v in d.items()}
print(d)
print(b)
print("———————— 字典 推导式+判断条件———————————")
d={"a":1,"b":2,"c":3}
b={v:k for k,v in d.items() if v<=2}#第一个v:k代表v为键,k为键值,实习交换是因为里面的k,v顺序和v:k不一样
print(d)
print(b)
print("———————— 字典 推导式嵌套+判断条件————————————")
d={x:y for x in [1,2,3] for y in [2,4,6] if y<5}
print(d)
8.集合
8.1集合创建
方法:(1){字符串}
(2)推导式 s for s in “ljs"
(3)set 函数 a = set(”ljs“)
注意事项:(1)集合不能使用下标访问,因为集合是无序的
print("——————————集合创建方式1————————")
a={"ljs","lcc"}
print(type(a))
print("——————————集合创建方式2————————")
{s for s in "ljs"}
print("——————————集合创建方式3———————")
s=set("ljs")
print(s)
8.2集合唯一性
8.2.1
判断某个元素是否存在集合中
print("——————————集合in ———————")
s=set("ljs")
print('s' in s)
print("——————————集合not in ———————")
s=set("ljs")
print('s' not in s)
8.2.2 集合内容访问
通过推导式进行访问
print("——————————集合元素访问 ———————")
s=set("ljs")
for each in s:
print(each)
8.2.3集合内容去重
由于集合具有元素不重复的特点,所以可以对一个列表进行集合设置,从而实现去掉重复值
print("——————————集合元素去重 ———————")
s=list("ljsljs")
print(s)
s=set(s)
print(s)
8.3集合函数生成新集合
8.3.1 copy
实现集合的浅拷贝
print("——————————集合函数 copy ———————")
d=set("abc")
print(d)
t=d.copy()
print(t)
8.3.2 isdisjoint
判断两个集合是否相干(是否存在交集)
print("——————————集合函数 isdisjoint ———————")
s=set("ljs")
print((s.isdisjoint(set("lcc"))))#这里lcc和ljs具有交集 l 所以相干,所以是false
8.3.3 issubset
判断一个集合是否是另外一个集合的子集之后返回一个新集合
注意事项:(1)可以用 s <= set(“LJS”)来判断 s 是不是 LJS 的子集
(2)可以用 s < set(“LJS”)来判断 s 是不是 LJS 的真子集
(3)可以用 s >= set(“LJS”)来判断 s 是不是 LJS 的超集
(4)可以用 s > set(“LJS”)来判断 s 是不是 LJS 的真超集
(5)可以用 s | set(“LJS”)来判断 s 是不是 LJS 的并集
(6)可以用 s & set(“LJS”)来判断 s 是不是 LJS 的交集
(7)可以用 s - set(“LJS”)来判断 s 是不是 LJS 的差集
(8)可以用 s ^ set(“LJS”)来判断 s 是不是 LJS 的对称差集
print("——————————集合函数 issubset ———————")
d=set("abc")
print((d.issubset("abcd")))
8.3.4 issuperset
判断一个集合是否是另外一个集合的超集之后返回一个新集合(if B中容易元素都是 A的元素,则A为B超级)
print("——————————集合函数 issuperset ———————")
d=set("abcdef")
print((d.issuperset("abcd")))
8.3.5 union
把两个集合求并集之后返回一个新集合
print("——————————集合函数 union ———————")
q1=set("abcdef")
print((q1.union("gh","pl")))
8.3.6 intersection
求两个集合交集之后返回一个新集合
print("——————————集合函数 intersection ———————")
q1=set("abcdef")
print((q1.intersection("ach")))
8.3.7 difference
求两个集合的差集之后返回一个新集合
print("——————————集合函数 difference ———————")
q1=set("abcdef")
print((q1.difference("abgh")))
8.3.8 symmetric_differnece
求两个集合对称差集之后返回一个新集合(排除两个集合共有元素,由剩余元素组成的结合叫对称差集)
print("——————————集合函数 symmetric_difference ———————")
q1=set("abcdef")
print((q1.symmetric_difference("abgh")))
8.4 集合函数修改原集合
8.4.1 update
对集合进行数据(列表,字符串)插入
注意事项:(1)只能 set 不能 frozenset
(2)修改当前集合
(3)之前没有 update 的是返回一个修改之后的新集合,有 update 的是直接修改原集合
print("—————————set函数 updtae—————————————————")
x = set("ljs")
x.update(set("and"))
print(x)
8.4.2 intersection_update
与 intersection功能一样,区别在于没有返回值,是对原集合进行修改
print("—————————set函数 intersection_updtae—————————————————")
x = set("ljs")
x.intersection_update(set("andl"))
print(x)
8.4.3 difference_update
与 difference功能一样,区别在于没有返回值,是对原集合进行修改
print("—————————set函数 differnce_updtae—————————————————")
x = set("ljs")
x.difference_update(set("and"))
print(x)
8.4.4 symmetric_difference_update
与 symmetric 功能一样,区别在于没有返回值,是对原集合进行修改
print("—————————set函数 symmetric_difference_updtae—————————————————")
x = set("ljs")
x.symmetric_difference_update(set("andl"))
print(x)
8.4.5 add
将传入的字符串整体传入,而不是 update一样分开一个一个传入
print("—————————set函数 add—————————————————")
x = set("ljs")
x.add("andl")
print(x)
8.4.6 remove
删除集合中某个元素,如果元素不存在则抛出异常
print("—————————set函数 remove—————————————————")
x = set("ljs")
x.remove("l")
print(x)
8.4.7 discard
删除集合中某个元素,如果元素不存在则静默处理
print("—————————set函数 discard—————————————————")
x = set("ljs")
x.discard("al")
print(x)
8.4.8 pop
随机弹出集合中的一个元素
print("—————————set函数 pop—————————————————")
x = set("aljs")
x.pop()
print(x)
8.4.9 clear
清空集合内容
print("—————————set函数 clear—————————————————")
x = set("aljs")
x.clear()
print(x)
8.5可哈希
8.5.1基本概念
哈希值就像一个人的身份证,不同人的身份证不一样。并且人发生了变化,哈希值也会变化,所以可以通过哈希值对内容较大的数据进行控制
8.5.2语法
hash(object)获取 object 的哈希值
注意事项:(1)对于整数求哈希值,永远是其本身
(2)对于 1 和 1.0 的哈希值一样,但 1.01就不一样
(3)可变对象(列表,集合)没有哈希值
(4)不可变对象(字符串)有哈希值
(5)只有可哈希的对象才能作为字典的键以及集合元素
(6)要实现集合嵌套,不能用 set 而要用 frozenset 因为这是不可变集合
8.6散列表
可以快速的在列表进行查找里面的元素,比如说 列表是新华字典里面一页一页的找相同的字。而集合上则是按拼音进行查找。但集合也需要大量内存空间!
9.函数
9.1函数基本概念
9.1.1函数定义
def 函数名():
pass
print("————————函数定义————————————")
def myfunc():
# pass#空执行
for i in range(3):
print("ljs",end=' ')
myfunc()
print("\n")
9.1.2函数的参数
print("————————函数参数————————————")
def myfunc(name,times):
# pass#空执行
for i in range(times):
print(F"ljs{name}",end=' ')
myfunc(" and lcc",2)
print("\n")
9.1.3函数的返回值
函数如果没写 return 也会默认返回一个 none
print("————————函数返回值————————————")
def div(x,y):
if(y==0):
return "除数不能为0!!!"
else:
return x/y
result=div(4,2)
print(result)
print("\n")
9.2函数参数
9.2.1位置参数
根据参数位置是确定的,如果不按照这个顺序输入,结果就会不一样
def myfunc(s,vt,o):
return "".join((o,vt,s))#返回一个字符串,并且这个字符串调用了 join函数进行字符串拼接
print(myfunc("我","打","你"))
9.2.2关键字参数
根据参数名字确定,跟位置没关系
print("—————————关键字参数———————————————")
def myfunc(s,vt,o):
return "".join((o,vt,s))#返回一个字符串,并且这个字符串调用了 join函数进行字符串拼接
print(myfunc(o="我",vt="打",s="你"))
print()
9.2.3默认参数
默认参数必须放在后面,不能放在前面
注意事项:(1)对于一些函数,例如 sum abs 是不允许进行关键字参数,只能位置传递。
abs(x=-1)❌ abs(-1)✔
(2)关键字参数看 * 位置参数看 /
print("—————————默认参数———————————————")
def myfunc(s,vt,o="我"):
return "".join((o,vt,s))#返回一个字符串,并且这个字符串调用了 join函数进行字符串拼接
print(myfunc("你","打","刘家森"))
print()
9.2.4收集参数
定义:传入参数的数量随意,这样的参数叫收集参数
语法:* 形参名字
注意事项:(1)函数返回的多参数其实本质是元组,这个元组可以进行解包
(2)函数传入的收集参数本质是元组,利用了 * 进行打包
(3)如果收集参数后面还需要参数,那就必须用关键字参数
(4)利用 ** 两个 * 可以实现对收集参数进行 打包为字典
print("—————————收集参数———————————————")
def myfunc(*args):
print("有{}个参数".format(len(args)))
print("第2个参数是:{}".format(args[1]))
print("所有参数:{}".format(args))
myfunc("刘家森","罗灿灿","爱吃东西","哈哈哈","喵喵喵")
print()
print("—————————收集参数+关键字参数———————————————")
def myfunc(*args,a=1,b=2):
print("所有参数:{}".format(args),a,b)
myfunc("刘家森","罗灿灿")
print()
print("—————————收集参数 ** ———————————————")
def myfunc(**args):
print(args)
myfunc(a=1,b=2)
print()
9.2.5解包参数
为了实现传入的元组进行解包成单独模块
注意事项:(1) * 代表对元组进行解包
(2)** 代表对字典进行解包
print("—————————解包参数 * ———————————————")
args=(1,2,3,4)
def myfunc(a,b,c,d):
print(a,b,c,d)
myfunc(*args)#对 args 进行解包
print()
print("—————————解包参数 ** ———————————————")
args={'a':1,'b':2,'c':3,'d':4}
def myfunc(a,b,c,d):
print(a,b,c,d)
myfunc(**args)#对 args 进行解包为 键值
print()
9.3函数作用域
9.3.1局部作用域
指一个变量可以被访问的范围。当一个变量被定义在函数内部中,这个变量称为局部变量
print("—————————作用域 局部 ———————————————")
def myfunc():
x=520
print(x)
myfunc()
#print(x)这是一个局部变量,无法在全局中访问
9.3.2全局作用域
定义在函数外部的变量,作用域为全局,这个变量称为全局变量
print("—————————作用域 全局 ———————————————")
x = 520
def myfunc():
x=250
print(x)
myfunc()
print(x)#这是一个全局变量,无法在全局中访问
9.3.3语句 global
在局部变量前加一个 global 可以实现 局部变量修改全局变量的值
print("—————————作用域 global ———————————————")
x = 520
def myfunc():
global x
x=250
print(x)
myfunc()
print(x)
9.4嵌套函数
9.4.1嵌套函数定义
在一个函数内部在定义一个函数。在使用内部函数时,需要在内部提取调用
print("—————————嵌套函数 ———————————————")
def myfunc():
x=520
def myfund():
x=250
print("d:x=",x)
myfund()#嵌套函数需要在函数内部中 调用,外部不能调用
print("c:x=",x)
myfunc()
print()
9.4.2语句 nonlocal
在内部函数中去修改外部函数的变量
print("—————————嵌套函数 nonlocal———————————————")
def myfunc():
x=520
def myfund():
nonlocal x
x=250
print("d:x=",x)
myfund()#嵌套函数需要在函数内部中 调用,外部不能调用
print("c:x=",x)
myfunc()
print()
9.5 LEGB规则
L:local 局部作用域,局部作用域会消失
E:enclosed 嵌套函数外层函数作用域 外层作用域的值会保留下来
G:global 全局作用域
B:build-in 内置作用域 相当于内置函数变为了变量名
当作用域发生冲突时,例如 L 和 G,则 python 会使用 L 局部作用域
10.闭包
10.1闭包基本定义
简单解释就是说,内层函数调用了外层函数的变量,并且外层函数返回的是内存函数的引用。这样子就可以实现对一个变量重复改变使用。举个例子,一个点在坐标移动,它往右移动之后得到新坐标,这时再往上移动不是从原点出发,而是从第一次移动后的点
print("—————————闭包———————————————")
def power(exp):
def exp_of(base):
return base ** exp
return exp_of
square=power(2)
cube=power(3)
print(square(2))
print(square(5))
print(cube(2))
print(cube(5))
print("—————————闭包 nonlocal———————————————")
def outer():
x=0
y=0
def inner(x1,y1):
nonlocal x,y
x+=x1
y+=y1
print(F"x={x},y={y}")
return inner
move=outer()
print(move(1,2))
print(move(-1,2))
11.装饰器
11.1单装饰器
作用:在闭包基础之上,把函数的传入参数也设置为函数,这样就相当于先执行闭包的内层函数,再碰到外层的传入函数时,就执行调用的函数。
本质:再调用函数的时候,相当于把调用函数放进了装饰器里面!
语法(1):def 外层()+内层() return 内层
@外层
def 调用函数()
调用函数()
语法(2):def 外层()+内层() return 内层
def 调用函数()
调用函数 = 外层(调用函数)
调用函数()
rint("—————————函数作为参数传递 装饰器 ———————————————")
def time_master(func):
def call_func():
print("开始运行")
start=time.time()
func()
stop=time.time()
print("程序结束")
print(F"消耗{(stop-start):.2f} 秒")
return call_func
@time_master
def myfunc():
time.sleep(2)
print("正在运行")
myfunc()
11.2多装饰器
在被调用函数上存在多个装饰器,调用顺序从下往上
print("—————————函数作为参数传递 多装饰器 ———————————————")
def add(func):
def inner():
x=func()
return x+1
return inner
def cube(func):
def inner():
x=func()
return x*x*x
return inner
def square(func):
def inner():
x=func()
return x*x
return inner
@add
@cube
@square
def test():
return 2
print(test())
11.3装饰器+输入参数
语法(1):@外层函数(参数) 调用函数()
语法(2):调用函数=外层(参数)(调用函数)
print("—————————函数作为参数传递 装饰器+输入参数 ———————————————")
def logger(msg):
def time_master(func):
def call_func():
print("开始运行")
start = time.time()
func()
stop = time.time()
print("程序结束")
print(F"消耗{(stop - start):.2f} 秒")
return call_func
return time_master
@logger("A")
def funA():
time.sleep(1)
print("A")
@logger("B")
def funB():
time.sleep(2)
print("B")
funA()
funB()
12.lambda表达式
作用:解决一些简单的函数
语法:lambda arg1 arg2 : expression
print("—————————lambda基本规则———————————————")
square = lambda x : x*x
print(square(2))
print("—————————lambda—+列表———————————————")
y=[lambda x:x*x,2,3]
square=y[0](y[1])
print(square)
print("—————————lambda—+map———————————————")
mapped=map(lambda x:ord(x)+10,"Fljs")
print(list(mapped))
print("—————————lambda—+filter———————————————")
mapped=filter(lambda x:x%2,range(10))
print(list(mapped))
13.生成器
13.1生成器基本规则
作用:让函数退出之后还能保留状态,是一种特殊的迭代器
语法:yield 替换 return
print("——————————yield基本规则————————————")
def counter():
i=0
while(i < 5):
yield i
i+=1
for i in counter():
print(i)
print("——————————yield+next————————————")
c=counter()
print(next(c))
print(next(c))
print(next(c))
13.2生成器表达式
区别:列表推导式:一次性生成所有数据放到列表中
生成器推导式:一次只产生一个数据
方法:(1)使用 yield
(2)直接写
print("——————————生成器直接表达式————————————")
t=(i*i for i in range(5))
for i in t:
print(i)
14.算法
14.1递归
14.1.1递归基本规则
作用:函数调用自身的过程
print("———————递归基本规则-无限循环———————————")
# def func():
# print("ljs")
# func()
# print(func())
print("———————递归基本规则-条件循环———————————")
def func(i):
if i>0:
print(F"ljs{i}")
i-=1
func(i)
print(func(10))
14.1.2递归-阶层
print("———————递归基本规则-阶层1———————————")
def factIter(n):
result=n
for i in range(1,n):
result *=i
return result
print(factIter(5))
print("———————递归基本规则-阶层2———————————")
def factIter(n):
if n==1:
return 1
else:
return n*factIter(n-1)
print(factIter(5))
14.1.3递归-斐波那契数列
print("———————递归基本规则-斐波那契数列迭代———————————")
def fib(n):
a=1
b=1
c=1
while(n>2):
c=a+b
a=b
b=c
n -=1
return c
print(fib(12))
print("———————递归基本规则-斐波那契数列递归———————————")
def fibc(n):
if n==1 or n==2:
return 1
else:
return fibc(n-1)+fibc(n-2)
print(fibc(12))
14.2汉诺塔
def hanoi(n,x,y,z):
if n==1:
print(x,'-->',z)
else:
hanoi(n-1,x,z,y)
print(x,'-->',z)
hanoi(n-1,y,x,z)
n=int(input("次数"))
hanoi(n,'A','B','C')