分支与循环

age=17
print("禁止访问") if age < 18 else print("欢迎访问")
#执行语句放在if前

a=3
b=5
small=a if a<b else b
print(small)

s=66
l=( 'D' if 0<=s<60 else
	'C' if 60<=s<80 else
	'B' if 80<=s<90 else
	'A' if 90<=s<100 else
	'S' if s==100 else
	"请输入0-100之间的分数^O^"	)
print(l)

age=18
ismale=True
if age <18:
	print("未满18岁")
else :
	if ismale:
		print("欢迎访问")
	else :
		print("禁止访问")

love = "yes"
while love == "yes":
	love = input("今天你还爱我吗？")

i=1
sum=0
while i<=10000:
	sum+=i
	i+=1
print(sum)

while True:
	print("死循环代码")

while True:
	ans=input("我可以退出循环了吗？")
	if ans=="可以":
		break
	print("好累")

i=0
while i<10:
	i+=1
	if i%2==0:
		continue
	print(i)

i=1
while i<5:
    print("循环内，i=",i)
    if i==2:
        break;
    i+=1
else:
    print("循环外，i=",i)

d=1
while d<=7:
	ans=input("今天有好好学习吗？")
	if(ans!="有"):
		break;
	d+=1
else:
	print("GOOD!")

i=1
while i<=9:
	j=1
	while j<=i:
		print(j,"*",i,"=",j*i,end=" ")
        #end=" "意思是末尾不换行，加空格。
		j+=1
	print()
	i+=1

#使用迭代法
for each in "fishc":
	print(each)
    
i=0
while i<len("fishc"):
    print("fishc"[i])
    i+=1

#用range（）让数字进行循环
for i in range(10):
	print(i)
	
for i in range(5,100):
	print(i)
	
for i in range(10,-10,-2):
	print(i)
    #前闭后开

#找素数
for n in range(2,10):
	for x in range(2,n):
		if n%x==0:
			print(n,"=",x,"*",n//x)
            #n整除x
			break
	else:
		print(n,"是一个素数")

列表

str=[1,2,3,4,5,"上山打老虎"]
print(str)
#列表也是一种序列
for each in str:
    print(each)
 l=len(str)
#str[l-1]和str[-1]是一样的

#列表切片
str[0:3]
str[:3]
str[3:]
str[:]
str[0:6:2]#str[::2]
str[::-1]#将整个列表倒序输出

#列表的增删改查
#增
heroes=["钢铁侠","绿巨人"]
heroes.append("黑寡妇")#加入黑寡妇
heroes.extend(["鹰眼","灭霸","雷神"])

s=[1,2,3,4,5]
s[len(s):]=[6]#相当于s.append(6)
s[len(s):]=[7,8,9]#相当于s.extend([7,8,9])

s=[1,3,4,5]
s.insert(1,2)#在指定的位置插入指定的元素
s.insert(len(s),6)
#删
heroes.remove("灭霸")
"""
删除指定的元素：
1.若列表中存在多个匹配的元素，那么它只会删除第一个
2.若指定的元素不存在，那么程序就会报错
"""
heroes.pop(2)
heroes.clear()
#改：
heroes[4]="钢铁侠"
heroes[3:]=["武松","林冲","李逵"]

nums=[3,1,9,6,8,3,5,3]
nums.sort()
nums.reverse()#反转列表中的元素
nums.sort(revers=True)
#查
nums.count(3)
heroes.index("绿巨人")
#index()会返回第一个元素的下标值，但是可以指定查找区间
nums.index(3,1,7)
heroes[heroes.index("绿巨人")]="神奇女侠"
#浅拷贝
nums_copy1=nums.copy()
nums_copy2=nums[:]

s=[1,2,3]
t=[4,5,6]
s+t#[1,2,3,4,5,6]
s*3#[1,2,3,1,2,3,1,2,3]
matrix=[[1,2,3],[4,5,6],[7,8,9]]#二维列表

for i in matrix:
    for each in i:
        print(each,end=' ')
        print()
       
matrix[0]	#[1,2,3]
matrix[0][0]	#1

A=[0]*3	#[0,0,0]
for i in range(3)
	A[i]=[0]*3	#[[0,0,0],[0,0,0],[0,0,0]]
    
    x="fishc"
    y="fishc"
    x is y	#True,检验两个变量是否指向同一个变量的运算符
    
    x=[1,2,3]
    y=[1,2,3]
    x is y	#False 
    
x=[[1,2,3],[4,5,6],[7,8,9]]
y=x.copy()
#若x改变，y也会改变

import copy
x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.copy(x)#都是浅拷贝

y=copy.deepcopy(x)
#深拷贝：若x改变，y不会改变

oho=[1,2,3,4,5]
for i in range(len(oho)):
    oho[i]*=2
#使用列表推导式来实现：
oho=[1,2,3,4,5]
oho=[1*2 for i in oho]
#优点：效率快一倍

x=[i for i in range(10)]
#将i存到这个列表中 x=[0,1,2,3,4,5,6,7,8,9]
#相当于用循环：
x=[]
for i in range(10)
	x.append(i+1)

y=[c*2 for c in "fishc"]
#y=['ff','ii','ss','hh','cc']

code=[ord(c) for c in "fishc"]
#ord是内置函数
#code=[102, 105, 115, 104, 99]

matrix=[[1,2,3],[4,5,6],[7,8,9]]
col2=[row[1] for row in matrix]
#提取第二列上的元素col2=[2, 5, 8]
diag=[matrix[i][i] for i in range(len(matrix))]
#提取主对角线上的元素diag=[1, 5, 9]

#创建一个二维列表:
A=[0]*3
for i in range(3):
    A[i]=[0]*3	#A=[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
A[1][1]=1	#A=[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

s=[[0]*3 for i in range(3)]
#s=[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
s[1][1]=1
#s=[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

even=[i for i in range(10) if i%2==0]
even=[i+1 for i in range(10) if i%2==0]
word=["good","great","abc","fishc","fish"]
fword=[w for w in word if w[0]=='f']

#将二位列表降级为一个一维列表
matrix=[[1,2,3],[4,5,6],[7,8,9]]
flatton=[col for row in matrix for col in row]
#相当于用循环：
flatton=[]
for row in matrix:
    for col in in row:
        flatton.append(col)
        
#用列表推导式：
[x+y for x in "fishc" for y in "FISHC"]
#['fF', 'fI', 'fS', 'fH', 'fC', 'iF', 'iI', 'iS', 'iH', 'iC', 'sF', 'sI', 'sS', 'sH', 'sC', 'hF', 'hI', 'hS', 'hH', 'hC', 'cF', 'cI', 'cS', 'cH', 'cC']

_=[]
for x in "fishc":
    for y in "FISHC":
        _.append(x+y)
        
#用列表推导式：
[[x,y] for x in range(10) if x%2==0 for y in range(10) if y%3==0]
#用循环相当于：
_=[]
for x in range(10):
    if x%2==0:
        for y in range(10):
            if y%3==0:
                _.append([x,y])

元组

str=(1,2,3,4,5,"上山打老虎")
#等价于str=1,2,3,4,5,"上山打老虎"
str[0] str[-1] 
#元组内的元素不可更改
#元组也支持切片操作
str[:3]#(1, 2, 3)
str[3:]#(4, 5, '上山打老虎')
str[::2]#(1, 3, 5)
str[::-1]#('上山打老虎', 5, 4, 3, 2, 1)

nums=(3,1,9,6,8,3,5,3)
nums.count(3)
heroes=("蜘蛛侠","黑寡妇","绿巨人")
heroes.index("黑寡妇")

s=(1,2,3)
t=(4,5,6)
s+t	#两个元组进行拼接
s*3#(1, 2, 3, 1, 2, 3, 1, 2, 3)
w=s,t#嵌套((1, 2, 3), (4, 5, 6))
#元组也支持迭代;
for each in s:
    print(each)
    
for i in w:
    for each in i:
        print(each)
        
s=(1,2,3,4,5)
[each*2 for each in s]
#[2,4,6,8,10]
(each*2 for each in s)#生成器

x=(520)
type(x)#<class 'int'>
#生成只有一个元素的元组
x=(520,)
type(x)#<class 'tuple'>

#打包和解包(适用于任何的序列类型)
t=(123,"fishc",3.14)
x,y,z=t

x,y=10,20

s=[1,2,3]
t=[4,5,6]
w=(s,t)#此时的元组可修改，因为其中的元素指向一个可修改的列表

字符串

x="12321"
"是回文串"if x==x[::-1]  else "不是回文串"
#大小写变换类：
x="I love Fishc"
x.capitalize()#句子首字母大写，其余小写
x.casefold()#所有字母小写（可以处理其他语言的字符）
x.title()#每个单词的首字母大写
x.swapcase()#所有字母大小写反转
x.upper()#所有字母变大写
x.lower()#所有字母变小写（只能处理英文字母）
#左中右对齐类：要指定第一个width参数，第二个是要填充字符的参数
#若宽度小于原字符串的长度，则直接输出
x="有内鬼，终止交易"
x.center(15)#左右用“ ”填充，原字符串放到中间
x.center(15,)
x.center(15,"凎")#用凎进行填充

x.ljust(15)#左对齐
x.rjust(15)#右对齐
x.zfill(5)#用0去填充左侧，x可以为负数

#查找
x="上海自来水来自海上"
x.count("海")
x.count("海"，0，5)
x.find("海")#从左往右
x.rfind("海")#从右往左
x.find("龟")
x.index("龟")

#替换
code="""
	print("i love fishc")
   print("i love wife")"""
new_code=code.expandtabs(4)
print(new_code)#将tab缩进转换为空格缩进

"""在吗""".replace("在吗","想你")

table=str.maketrans("ABCDEFG","1234567")
"I love FISHC".translate(table)#'I love 6ISH3'
"I love FISHC".translate(str.maketrans("ABCDEFG","1234567"))
"I love FISHC".translate(str.maketrans("ABCDEFG","1234567"，"love"))
#将"love"给忽略掉

#判断和检测
x="我爱python"
x.startswith("我")#True "我"是否在字符串的开始位置
x.endswith("python")#True "python"在字符串的结束位置
x.startswith("我"，1)#False 索引值为1，相当于从"爱python"中找"我"
s.endswith("py",0,4)#True

x="它爱python"
if x.startswith(("你","我"，"它")):
    print("总有人喜爱python")
    
x="I Love Python"
x.istitle()#True
x.isupper()#False 是否所有字母都是大写字母
x.upper().isupper()#True
x.isalpha()#False 字符串中是否都是字母
"       n".isspace()#True
x.isprintable()#True(要注意转义字符不可打印)

x="12345"
x.isdecimal()#True
x.isdigit()#True
x.isnumeric()#True
#2²只有x.isdecimal()是False
#罗马数字和汉字只有x.isnumeric()是True
isalnum()#集大成者：只要isalpha() isdecimal() isnumeric() isdigit()中有一个是True 那结果就是True
x="I am a good gay"
x.isidentifier()#False 因为有空格，用来检查字符串是否合法（python的规则）

#使用keyword模块中的iskeyword()函数,判断是否为python中的关键字
import keyword
keyword.iskeyword("if")#True

#截取
"     左侧不要留白".lstrip()
"右侧不要留白      ".rstrip()
"    左右都不要留白    ".strip()
"www.ilovefishc.com".lstrip("wcom.")#'ilovefishc.com'
"www.ilovefishc.com".rstrip("wcom.")#'www.ilovefish'
"www.ilovefishc.com".strip("wcom.")#'ilovefish'
"www.ilovefishc.com".removeprefix("www.")#删除前缀
"www.ilovefishc.com".removesuffix("www.")#删除后缀

#拆分和拼接
"www.ilovefishc.com".partition(".")#('www', '.', 'ilovefishc.com')
"www.ilovefishc.com/python".rpartition("/")#('www.ilovefishc.com', '/', 'python')
"苟日新，日日新，又日新".split()#['苟日新，日日新，又日新']只是转换为列表中的元素而已
"苟日新 日日新 又日新".split()#['苟日新', '日日新', '又日新']
"苟日新，日日新，又日新".split('，')#['苟日新', '日日新', '又日新']
"苟日新，日日新，又日新".rsplit('，')#['苟日新', '日日新', '又日新']
"苟日新，日日新，又日新".rsplit('，',1)#['苟日新，日日新', '又日新'] 就切一次
"苟日新n日日新n又日新".splitlines()#['苟日新', '日日新', '又日新']按行分割
"苟日新n日日新n又日新".splitlines(True)#['苟日新n', '日日新n', '又日新']

".".join(["www","ilovefishc","com"])#'www.ilovefishc.com'
"^".join(("f","ish","c"))#'f^ish^c'
s="Fishc"
s+=s
s	#'FishcFishc'
"".join(("Fishc","Fishc"))#'FishcFishc' 用join的效率更高

#格式化字符串
year=2021
"Fishc工作室成立于{}年".format(year)#'Fishc工作室成立于2021年'
"1+2={},2的平方是{},3的立方是{}".format(1+2,2*2,3*3*3)
#'1+2=3,2的平方是4,3的立方是27'
"{1}看到{0}就很激动".format("零","一")#'一看到零就很激动'
"{0}{0}{1}{1}".format("是","非")#'是是非非'
"我叫{name},我爱{fav}".format(name="小甲鱼",fav="python")
#'我叫小甲鱼,我爱python'
"{}{}{}".format(1,"{}",2)#'1{}2'

#对齐
"{:^}".format(250)#'250'
"{:^10}".format(250)#   250    '
"{1:>10}{0:<10}".format(520,250)#'       250520       '
"{left:>10}{right:<10}".format(right=520,left=250)##'       250520       '
"{:010}".format(520)#'0000000520'
"{:010}".format(-520)#'-0000000520'感知正负号
"{1:%>10}{0:%<10}".format(520,250)#'%%%%%%%250520%%%%%%%'
"{:0=10}".format(520)#'0000000520'
"{:0=10}".format(-520)#'-0000000520'

#符号
"{:+} {:-}".format(520,-250)#'+520 -250'
#千分符
"{:,}".format(1234)#'1,234'
#精度(对于整数则是不允许的)
"{:.2f}".format(3.1415)#'3.14'
"{:.2g}".format(3.1415)#'3.1'
"{:.6}".format("I LOVE FishC")#'I LOVE'
#进制
"{:b}".format(80)#'1010000' 二进制
"{:c}".format(80)#'P'Unicode字符形式
"{:d}".format(80)#'80' 十进制
"{:o}".format(80)#'120' 八进制
"{:x}".format(80)#'50' 十六进制
"{:#b}".format(80)#'0b1010000' 二进制并且有前缀
#浮点数的表示
"{:e}".format(3.1415926)#'3.141593e+00'
"{:f}".format(3.14)#'3.140000'
"{:g}".format(1234.6789)#'1234.68'
"{:%}".format(0.98)#'98.000000%'
"{:.2%}".format(0.98)#'98.00%'
"{:.{prec}f}".format(3.1415,prec=2)#'3.14'
"{:{fill}{align}{width}.{prec}{ty}}".format(3.1415,fill="+",align="^",width=10,prec=3,ty="g")#'+++3.14+++'

#f-string f字符串
year=2021
f"Fishc工作室成立于{year}年" #'Fishc工作室成立于2021年'
f"1+2={1+2},2的平方是{2*2},3的立方是{3*3*3}"#'1+2=3,2的平方是4,3的立方是27'
f"{-520:010}"#'-000000520'

序列

"""可变序列和不可变序列"""
[1,2,3]+[4,5,6]#[1, 2, 3, 4, 5, 6]
(1,2,3)+(4,5,6)#(1, 2, 3, 4, 5, 6)
"132"+"456"#'132456'
[1,2,3]*3#[1, 2, 3, 1, 2, 3, 1, 2, 3]
s=[1,2,3]
id(s)#2626779336000
s*=3
id(s)#2626779336000

t=(1,2,3)
id(t)#2626811728576
t*=3
id(t)#2626811270640
#is 和 is not 判断是非问题
x="fishc"
y="fishc"
x is y#True
x=[1,2,3]
y=[1,2,3]
x is y#False
#in 和 not in判断包含问题
"c" in"fishc" #True
#dei语句用于删除指定的对象
x=[1,2,3]
y=(1,2,3)
del x,y#将二者清空了

x=[1,2,3,4,5]
del x[1:4]
x#[1, 5]

y=[1,2,3,4,5]
y[1:4]=[]#进行切片操作
y#[1, 5]

x=[1,2,3,4,5]
del x[::2]
x#[2, 4]

x=[1,2,3,4,5]
x.clear()
x#将列表x清空
y=[1,2,3,4,5]
del y[:]
y#[]

#和列表相关的一些函数：

#将字符串和元组转换为列表
list("Fishc")#['F', 'i', 's', 'h', 'c']
list((1,2,3,4,5))#[1, 2, 3, 4, 5]
#将字符串和列表转换为元组
tuple("Fishc")#('F', 'i', 's', 'h', 'c')
tuple([1,2,3,4,5])#(1, 2, 3, 4, 5)
#将列表和元组转换为字符串
str([1,2,3,4,5])#'[1, 2, 3, 4, 5]'
str((1,2,3,4,5))#'(1, 2, 3, 4, 5)'

s=[1,1,2,3,5]
min(s)#1
t="Fishc"
max(t)#'s'
s=[]
min(s)#会报错
#可以使用default()来避免报错
min(s,default="什么都没有，怎么找最小值")#'什么都没有，怎么找最小值'
min(1,2,3,0,6)#0
max(1,2,3,0,6)#6

len(range(2 ** 100))#求2的100次幂的长度会报错
s=[1,0,0,8,6]
sum(s)#15
sum(s,start=100)#115

s=[1,2,3,0,6]
sorted(s)#返回一个全新的列表，原来的列表不变[0, 1, 2, 3, 6]
s.sort()#返回改变后的列表
sorted(s,reverse=True)#排序后反转[6, 3, 2, 1, 0]
t=["Fishc","Apple","Book","Banana","Pen"]
sorted(t)#['Apple', 'Banana', 'Book', 'Fishc', 'Pen']比较字符的编码值
sorted(t,key=len)#['Pen', 'Book', 'Fishc', 'Apple', 'Banana']
				#比较每个字符串len返回的结果
#sorted()函数可以接受任何形式的可迭代对象作为参数
sorted("Fishc")#['F', 'c', 'h', 'i', 's']
sorted((1,0,0,8,6))#[0, 0, 1, 6, 8]

s=[1,2,5,8,0]
reversed(s)#<list_reverseiterator object at 0x000001BA7E94A280>
list(reversed(s))#[0, 8, 5, 2, 1]
list(reversed("Fishc"))#['c', 'h', 's', 'i', 'F']
list(reversed((1,2,5,9,3)))#[3, 9, 5, 2, 1]
list(reversed(range(0,10)))#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

x=[1,1,0]
y=[1,1,9]
all(x)#False判断可迭代对象中的元素是否都为真
all(y)#True
any(x)#True判断可迭代对象中是否有元素为真
any(y)#True

season=["Spring","Summer","Fall","Winter"]
enumerate(season)#得到一个enumerate object(枚举对象)
				#<enumerate object at 0x000001BA7EB53500>
list(enumerate(season))#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
#将每个元素抽取出来和从零开始的索引去组成一个新的列表
list(enumerate(season,10))
#[(10, 'Spring'), (11, 'Summer'), (12, 'Fall'), (13, 'Winter')]

x=[1,2,3]
y=[4,5,6]
zipped=zip(x,y)
list(zipped)#[(1, 4), (2, 5), (3, 6)]
z=[7,8,9]
zipped=zip(x,y,z)
list(zipped)#[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
z="Fishc"#当可迭代对象长度不一样的时候自动取最小的
zipped=zip(x,y,z)
list(zipped)#[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's')]
import itertools
zipped=itertools.zip_longest(x,y,z)
list(zipped)
#[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's'), (None, None, 'h'), (None, None, 'c')]

mapped=map(ord,"Fishc")
list(mapped)#[70, 105, 115, 104, 99]
		   #ord函数就是将字符转化为对应的编码值
mapped=map(pow,[2,3,10],[5,2,3])
list(mapped)#[32, 9, 1000]
#相当于[pow(2,5),pow(3,2),pow(10,3)]
list(map(max,[1,3,5],[2,2,2],[0,3,9,8]))#[2, 3, 9]剩下的8无法进行比较

list(filter(str.islower,"Fishc"))#将小写字母挑出来['i', 's', 'h', 'c']
#filter()函数是将调用函数结果为真的元素过滤出来

#迭代器（一次性的）和可迭代对象（可重复使用）
#例如map函数返回的就是一个迭代器
mapped=map(ord,"Fishc")
for each in mapped:
    print(each)#70 105 115 104 99
    
list(mapped)#[]

x=[1,2,3,4,5]
y=iter(x)
type(x)#<class 'list'> x的类型是列表
type(y)#<class 'list_iterator'> y是一个列表的迭代器

next(y)#1
next(y)#2
next(y)#3
next(y)#4
next(y)#5

z=iter(x)
next(z,"没有了，都用完了")#防止元素用完后出现异常

字典

x={"吕布","关羽"}
type(x)#<class 'set'> set是表示集合这种数据结构
#字典要有映射关系
y={"吕布":"口口布","关羽":"官习习"}
type(y)#<class 'dict'>
y["吕布"]#'口口布'
y["刘备"]="刘baby"
y#{'吕布': '口口布', '关羽': '官习习', '刘备': '刘baby'}
#创建字典的六种方法
a={'吕布': '口口布', '关羽': '官习习', '刘备': '刘baby'}
b=dict(吕布="口口布"，关羽="关习习")
c=dict([("吕布"，"口口布"),("关羽"，"关习习")])
d=dict({'吕布': '口口布', '关羽': '官习习', '刘备': '刘baby'})
e=dict({'吕布': '口口布', '关羽': '官习习'}, 刘备="刘baby")
f=dict(zip(["吕布","关羽","刘备"],["口口布","关习习","刘baby"]))
a==b==c==d==e==f#True
#增
d=dict.fromkeys("Fish",250)
d#{'F': 250, 'i': 250, 's': 250, 'h': 250}
d["c"]=67
d#{'F': 250, 'i': 250, 's': 250, 'h': 250, 'c': 67}
#在序列中元素可以重复，而在字典中键值对不可以重复
#删
d.pop("s")#弹出 250
d#{'F': 250, 'i': 250, 'h': 250, 'c': 67}
d.pop("狗","没有")#通过加入一个default参数来防止弹出没有的元素时的异常
d.popitem()#将字典中的最后一个键值对弹出(Python3.7以后的功能)
#('c', 67)

del d["i"]
d#{'F': 250, 'h': 250}
del d
d#删除整个字典
d=dict.fromkeys("FishC",250)
d.clear()
d#{}
#改
d=dict.fromkeys("FishC")
d#{'F': None, 'i': None, 's': None, 'h': None, 'C': None}
d['s']=115
d#{'F': None, 'i': 105, 's': 115, 'h': 104, 'C': None}
d.update({'i':105,'h':104})
d#{'F': None, 'i': 105, 's': None, 'h': 104, 'C': None}
d.update(F='70',c='67')
d#{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': None, 'c': '67'}
#查
d['c']#'67'这种方式区分大小写
d.get('c',"这里没有c")#'67'
d.setdefault("C","code")#有这个键值就返回键值，否则就返回default中的值
#三个视图对象（当字典发生改变时，它们三者也会发生改变）
keys=d.keys()
values=d.values()
items=d.items()
items#键值对dict_items([('F', '70'), ('i', 105), ('s', 115), ('h', 104), ('C', None), ('c', '67')])
keys#键dict_keys(['F', 'i', 's', 'h', 'C', 'c'])	
values#键值dict_values(['70', 105, 115, 104, None, '67'])
d.pop("c")#'67'弹出'c'这个键值对
e=d.copy()
e#浅拷贝{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': None}
len(d)#5查看字典中键值对的数量
#使用in和not in来判断某个键是否存在于字典中
'C' in d#True
'c' in d#False
'c' not in d#True

list(d)#['F', 'i', 's', 'h', 'C']将字典中的所有键转换为列表
list(d.values())#['70', 105, 115, 104, None]将字典中所有键值转换为列表
#用iter()函数将字典的键构成一个迭代器
e=iter(d)
next(e)#'F'
next(e)#'i'
next(e)#'s'
next(e)#'h'
next(e)#'C'
next(e)
"""Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    next(e)#
StopIteration"""
#在Python3.8后字典是有顺序的
list(reversed(d.values()))#[None, 104, 115, 105, '70']

#嵌套
d={"吕布":{"语文":60,"数学":70,"英语":80},"关羽":{"语文":80,"数学":90,"英语":70}}
d#{'吕布': {'语文': 60, '数学': 70, '英语': 80}, '关羽': {'语文': 80, '数学': 90, '英语': 70}}
d["吕布"]["数学"]#70
d={"吕布":[60,70,80]"关羽":[80,90,70]}
d["吕布"][1]#70

#字典推导式
d={'F':70,"i":105,'s':115,'h':104,'C':67}
b={v:k for k,v in d.items()}
b#{70: 'F', 105: 'i', 115: 's', 104: 'h', 67: 'C'}键和值互换
c={v:k for k,v in d.items() if v>100}
c#{105: 'i', 115: 's', 104: 'h'}筛选
d={x:ord(x) for x in "FishC3"}
d#求出字典每个字母的编码值{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, '3': 51}
#键:值保持唯一的映射关系，键值一直在更新，所以就保留最后一个6
d={x:y for x in [1,3,5] for y in [2,4,6]}
d#{1: 6, 3: 6, 5: 6}

集合

type({})#<class 'dict'>
type({"one"})#<class 'set'>
type({"one":1})#<class 'dict'>
#三种创建集合的方法
{"Fishc","Python"}#{'Fishc', 'Python'}
{s for s in "Fishc"}#{'c', 's', 'h', 'F', 'i'}集合的无序性
set("Fishc")#{'c', 's', 'h', 'F', 'i'}
#集合不能使用下标访问
#但是可以用 in 和 not in
s=set("Fishc")
'c'in s#True
'C'not in s#True
#可以用迭代的方式访问集合中的元素
for each in s:
    print(each)
"""
c
s
h
F
i
"""
#可以用集合来去重
set([1,1,2,3,5])#{1, 2, 3, 5}
s=[1,1,2,3,5]
len(s)==len(set(s))#False
t=s.copy()
t#[1, 1, 2, 3, 5]
s=set("Fishc")
s#{'c', 's', 'h', 'F', 'i'}
s.isdisjoint(set("Python"))#False
#s和集合Python并不是毫不相干，有一个"h"重复了
s.isdisjoint(set("JAVA"))#True 没有共同的元素
#可以直接传入一个可迭代对象来进行比较
s.isdisjoint("Python")#False
s.isdisjoint("JAVA")#True 没有共同的元素
s.issubset("Fishc.com.cn")#True s是这个字符串的子集
s.issuperset("Fish")#True s是"Fish"这个字符串的超集
s.union({1,2,3})#{1, 2, 3, 'c', 's', 'F', 'h', 'i'}合并两个集合
s.intersection("Fish")#{'F', 'h', 's', 'i'}交集
s.difference("Fish")#{'c'}差集
#以上三个函数都是支持多参数的
s.union({1,2,3},"Python")
#{1, 2, 'i', 3, 't', 'n', 'F', 'c', 'P', 'h', 's', 'y', 'o'}
s.intersection("Php","Python")#{'h'}三个集合的交集
s.difference("Php","Python")#{'i', 'F', 's', 'c'}二者和Fishc的差集
#求对称差集：除去它们共有的元素(不支持多参数)
s.symmetric_difference("Python")
#{'t', 'n', 'i', 'F', 'c', 'y', 'o', 'P', 's'}
#!!!与上面不同的是下面的这种方法不能直接使用可迭代对象。
#用<>=来比较集合的关系
s<=set("Fishc")#True
s<set("Fishc")#False
s>set("Fishc")#False
#用管道符来制造并集、交集、差集
#并集
s|{1,2,3}|set("Python")
#{1, 2, 'i', 3, 't', 'n', 'F', 'c', 'y', 'o', 'P', 'h', 's'}
#交集
s&set("Php")&set("Python")#{'h'}
#差集
s-set("Php")-set("Python")#{'F', 's', 'i', 'c'}
#对称差集
s^set("Python")
#{'t', 'n', 'i', 'F', 'c', 'P', 's', 'y', 'o'}
#不可变集合
t=frozenset("FishC")
t#frozenset({'C', 's', 'F', 'h', 'i'})
s=set("FishC")
s.update([1,1],"23")
s#{'C', 1, '3', 's', '2', 'F', 'h', 'i'}
t.update([1,1],"23")#会报错
s.intersection_update("FishC")
s#{'C', 's', 'F', 'h', 'i'}
s.difference_update("Php","Python")
s#{'C', 's', 'F', 'i'}
s.symmetric_difference_update("Python")
s#{'C', 'o', 'P', 'n', 's', 't', 'F', 'h', 'y', 'i'}

#往集合中添加元素
s.add("45")
s#{'C', 'o', 'P', 'n', 's', '45', 't', 'F', 'h', 'y', 'i'}
#将整个字符串作为一个元素插入到集合中，与.update()和.union()不同
#删除集合中指定的元素.remove(elem)和.discard(elem)
"""若指定元素不存在，remove()会抛出异常，discard()则会静默处理"""
s.remove("45")
s#{'C', 'o', 'P', 'n', 's', 't', 'F', 'h', 'y', 'i'}
#用.pop()从集合中随机弹出一个元素
s.pop()#'C'
s.pop()#'o'
#用.clear()将集合清空
s.clear()
s#set()

#可哈希--这个元素的哈希值在整个程序的生命周期中保持不变
#整数的哈希值等于其本身
#若两个值相等，则它们的哈希值相等
hash(1)#1
hash(1.001)#2305843009213441
#在python中不可变对象都是可哈希的，可变对象是不可哈希的
hash("FishC")#字符串是一个不可变对象3003973880237248566
hash([1,2,3])#列表是可变对象会报错
hash((1,2,3))#元组是不可变对象529344067295497451
#只有可哈希的对象，才有资格做字典的键
{"Python":520,"FishC":1314}
#{'Python': 520, 'FishC': 1314}
{[1,2,3]:"FishC"}#会报错，列表是可变对象，所以不能当字典的键
{"Python","FishC",520,1314}#{520, 'FishC', 'Python', 1314}
{"Python","FishC",520,1314,[1,1,2]}#会报错
x={1,2,3}
y={x,4,5}#会报错，集合是一个可变的容器，而可变容器是不可哈希的。
#集合的嵌套
x=frozenset(x)
y={x,4,5}
y#{frozenset({1, 2, 3}), 4, 5}

最后

以上就是高兴白昼为你收集整理的Python学习记录（小甲鱼C的课程）分支与循环列表元组字符串序列字典集合的全部内容，希望文章能够帮你解决Python学习记录（小甲鱼C的课程）分支与循环列表元组字符串序列字典集合所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。