#1.for嵌套循環(huán)語句（打印乘法表）
for x in range(1,10): #外層循環(huán)
for y in range(1, 10): #內(nèi)層循環(huán)
txt='{}×{}={}'.format(y,x,y*x) #乘法格式
print(txt,end='\t') #'\t'是制表符，可產(chǎn)生一定的空白間距
print() #作用是內(nèi)循環(huán)一次就另起一行
#2.while嵌套循環(huán)語句（制作九九乘法表）
x,y=0,0 #多變量一次性賦值
while x<9: #外循環(huán)條件
x +=1
while y<x: #內(nèi)循環(huán)條件
y +=1
txt='{}×{}={}'.format(y,x,x*y) #格式化
print(txt,end='\t') #'\t'表示制表符，用于文本中創(chuàng)建水平間距
y=0 #內(nèi)循環(huán)一次結(jié)束后又重新賦值y為0
print() # 另起一行
#3.if多條件分支語句（判斷等級）
lst=[69,89,95,54]
for num in lst:
if num>=90:
print(num,'優(yōu)')
elif num>=80:
print(num,'良')
elif num>=60:
print(num,'中')
else:
print(num,'差')
#4.break在while和for循環(huán)中的應(yīng)用
# 例1：循環(huán)序列數(shù)，當(dāng)符合某個條件時終止循環(huán)
num=100
while True: #條件為True，循環(huán)將無限執(zhí)行
num +=1
print(num)
if num==111: #當(dāng)num等于111時
break #退出循環(huán)
print('-----')
# 例2：在一組數(shù)字中尋找第3個大于或等于90的數(shù)字
num=0 # 循環(huán)次數(shù)初始值
for score in [98,85,93,97,88,96]: # 從一組數(shù)字中循環(huán)提取各個數(shù)字
if score>=90: # 當(dāng)某個數(shù)字大于等于90時
# print(score) # 注釋最后3行，不注釋此行，則輸出所有大于等于90的數(shù)字（98 93 97 96）
num +=1 # 循環(huán)次數(shù)加1
if num==3: # 如果第3次找到符合條件的數(shù)字，
break # 立即退出循環(huán)
print(score) # 輸出該數(shù)字（97）
#5.continue在while和for循環(huán)中的應(yīng)用
# 例1:打印奇數(shù)
num=0
while num<5:
num +=1
if num%2==0: #除以2的余數(shù)等于0，即原數(shù)是偶數(shù)，則輸出奇數(shù)；反之，除以2的余數(shù)等于1，即原數(shù)是奇數(shù)，則輸出偶數(shù)
continue #退出本次循環(huán)。若用break,則退出整個循環(huán)。
print(num) # 輸出:1 3 5
# 例2：尋找等級
for num in [90,85,99,78,100]:
if num<90:
continue #退出本次循環(huán)。作用是整個循環(huán)結(jié)束后只輸出大于90的數(shù)
txt='{} 優(yōu)秀'.format(num)
print(txt) # 輸出:90 優(yōu)秀 99 優(yōu)秀 100 優(yōu)秀
#6.字符串切片（根據(jù)身份證號劃分年齡段）
#根據(jù)身份證號劃分年齡段(高齡組：70歲及以上；老齡組：65~69歲；老年組：60~64歲；成年組：60歲以下)
dic=dict(
張三=340828195512240114,
李四='34082819640425011x',
王老五=340828195305012610,
劉老六=340828195208091919,
陳小七=340828196811080127
)
# print(dic.items()) # 上行單名里的空格必須刪去
dic0 = {name: str(num)[6:14] for name,num in dic.items()} # 如果身份證號碼前后都用單引號，則此行str()可去掉
# print(dic0) # 身份證號碼截取出生年月日
dic1 = dict(sorted(dic0.items(), key=lambda x: x[1]))
# print(dic1) # 出生年月日按升序排列
from datetime import datetime
# now=datetime.now()
year=datetime.now().year
month=datetime.now().month
day=datetime.now().day
print('當(dāng)前日期：{}年{}月{}日'.format(year,month,day)) #當(dāng)前年、月、日
print('----------------')
def pdnianling(year,month,day,nian,yue,ri):
nl=year-nian
if (month<yue) or (month==yue and day<ri):
nl -= 1
return nl
m=0;n=0;j=0;k=0;q=0
for name,num in dic1.items():
nian = int(str(num)[0:4]) # 提取居民出生年份
yue = int(str(num)[4:6]) # 提取居民出生年份
ri = int(str(num)[6:8]) # 提取居民出生年份
# print(nian,yue,ri)
nl=pdnianling(year,month,day,nian,yue,ri)
m = m + 1
if nl>=70:
n=n+1
if n>1:
print('{:>18} {}'.format(name, nl)) # web用>18,終端用>10
else:
print('高齡組：{} {}'.format(name, nl))
elif int(nl)>= 65:
j=j+1
if j>1:
print('{:>18} {}'.format(name, nl))
else:
print('老齡組：{} {}'.format(name, nl))
elif int(nl)>= 60:
k=k+1
if k>1:
print('{:>18} {}'.format(name, nl))
else:
print('老年組：{} {}'.format(name, nl))
else:
q=q+1
if q>1:
print('{:>18} {}'.format(name, nl))
else:
print('成年組：{} {}'.format(name, nl))
print('----------------')
print('本次統(tǒng)計共'+str(m)+'人，其中：\n①高齡組(>=70)'+str(n)+'人，②老齡組(>=65,<70)'+str(j)+'人，\n③老年組(>=60,<65)'+str(k)+'人，④成年組(<60)'+str(q)+'人。')
#7.列表切片
# 例1：單元素切片
lst1=['張三',19,[80,89,97]]
print(lst1[0],lst1[1],lst1[2]) #返回張三 19 [80, 89, 97]
# print(lst1[-1],lst1[-2],lst1[-3]) #返回[80, 89, 97] 19 張三
# 例2：多元素切片
lst2=[7,3,12,54,6,9,88,2,47,33,55]
# print(lst2[2:5]) #返回[12, 54, 6]，左閉右開，正數(shù)從左0數(shù)起
# print(lst2[-9:-6]) #返回[12, 54, 6]，左閉右開，負(fù)數(shù)從右1數(shù)起
# print(lst2[:4]) #返回[7, 3, 12, 54]，左閉右開
# print(lst2[6:]) #返回[88, 2, 47, 33, 55]，包含結(jié)尾
# print(lst2[-5:]) #返回[88, 2, 47, 33, 55] 右空即閉
# print(lst2[5:-2]) #返回[9, 88, 2, 47]
# print(lst2[-6:9]) #返回[9, 88, 2, 47]
# print(lst2[:]) #返回全部列表內(nèi)容
print(lst2[::2]) #步長為2，即隔1位切出1個，效果同lst[0:12:2]，返回[7, 12, 6, 88, 47, 55]
# print(lst2[1:8:2]) #步長為2，在1到8位切片，返回[3, 54, 9, 2]
# print(lst2[::-1]) #步長為負(fù)數(shù)，就是倒切，返回[55, 33, 47, 2, 88, 9, 6, 54, 12, 3, 7]
# print(lst2[::-2]) #返回[55, 47, 88, 6, 12, 7]
#8.列表元素的增加、刪除和修改
# 1.列表元素的修改
lst=['張三',18,[100,90]] # 該列表包含三種類型的元素：字符串，數(shù)字，列表
# print(lst) # 返回['張三',18,[100,90]]
lst[0]='小明' # 同類型修改
lst[1]='18歲' # 不同類型修改，數(shù)字改為字符
lst[2]=190 # 不同類型修改，列表改為數(shù)字
# print(lst) # 返回['小明', '18歲', 190]
lst[0:2]=[100,200] # 實際只修改0和1兩個位置上的元素
print(lst)
# 2.列表元素的增加
lst=['張三']
lst +=['6年級']
# print(lst) # 返回['張三', '6年級']
lst.append('9班') # 列表內(nèi)尾部增加元素
# print(lst) # 返回['張三', '6年級', '9班']
lst.extend([85,96]) # 列表內(nèi)尾部增加元素
# print(lst) # 返回['張三', '6年級', '9班', 85, 96]
lst.insert(3,'12歲') # 在列表3的位置插入'12歲'
# print(lst) # 返回['張三', '6年級', '9班', '12歲', 85, 96]
# 3.列表元素的刪除
lst=['張三', '6年級', '9班', '12歲', 85, 96]
lst.remove('12歲') # 刪除'12歲'
print(lst) # 返回['張三', '6年級', '9班', 85, 96]
lst.pop() # 刪除列表內(nèi)尾部元素，相當(dāng)于-1位置
print(lst) # 返回['張三', '6年級', '9班', 85]
lst.pop(2) # 刪除列表內(nèi)2位置上的元素
print(lst) # 返回['張三', '6年級', 85]
del lst[1:] # 刪除列表內(nèi)1位置起的所有元素。del lst表示刪除整個列表
print(lst) # 返回['張三']
#9.列表推導(dǎo)式（列表推導(dǎo)式變異）
lst=[[1,2,3],[10,5,6],[8,5,3],[6,5,4]]
print([l[0]*l[1]*l[2] for l in lst]) # 表達式[l[0]*l[1]*l[2]意思是每次從列表lst里的列表提取的一組數(shù)字切片后相乘（見第9行）
print([x*y*z for x,y,z in lst]) # 因列表內(nèi)的列表包含3個元素，故可以x,y,z表示（見第14行）
# 循環(huán)1
lst3=[]
for l in lst:
# lst3 +=[l[0]*l[1]*l[2]]
lst3.append(l[0]*l[1]*l[2]) # 效果與上行同
print(lst3)
# 循環(huán)2
lst4=[]
for x,y,z in lst:
lst4 +=[x*y*z]
print(lst4)
#10.列表推導(dǎo)式（嵌套列表推導(dǎo)式）
# 嵌套列表推導(dǎo)式本質(zhì)上就是 for 嵌套循環(huán)的簡化，嵌套列表推導(dǎo)式的語法結(jié)構(gòu)：
# ［表達式 for 變量1 in 列表1 for 變量2 in 變量1 for 變量3 in 變量2..…]
# 注意：變量1，變量2，變量3……變量 n ，最后一個變量 n 可以不是可迭代對象。
lst=[[1,2],[3,4,5],[6,7]]
# 簡單列表可以直接連接
print([1,2]+[3,4,5]+[6,7]) # 直接連接，返回[1, 2, 3, 4, 5, 6, 7]
print(lst[0]+lst[1]+lst[2]) # 切片后連接，返回[1, 2, 3, 4, 5, 6, 7]
# 采用循環(huán)的辦法達到上面的效果
lst2=[]
for l in lst:
lst2 +=l
print(lst2) # 返回[1, 2, 3, 4, 5, 6, 7]
# 采用雙循環(huán)的辦法達到上面的效果
lst3=[]
for l in lst: # print(l) 返回[1, 2][3, 4, 5][6, 7]
for v in l: # print(v) 返回1 2 3 4 5 6 7
lst3 +=[v] # print(lst3) 列表內(nèi)元素逐次增加，打印7次，返回[1]……[1, 2, 3, 4, 5, 6, 7]
# print(lst3) # 列表內(nèi)元素逐層增加，打印3次，返回[1, 2][1, 2, 3, 4, 5][1, 2, 3, 4, 5, 6, 7]
# lst3.append(v) # 效果與20行同
print(lst3) # 打印1次，返回[1, 2, 3, 4, 5, 6, 7]
# 嵌套列表推導(dǎo)式
print([v for l in lst for v in l])
# 先從lst中循環(huán)提取各組元素賦給l，再從l中循環(huán)提取各個元素賦給v，最后將v表達出來（置前），整個過程在列表內(nèi)進行（加[]）。
#11.條件列表推導(dǎo)式（簡單條件與多條件）
#條件列表推導(dǎo)式的作用就是對列表做篩選，它的語法結(jié)構(gòu)是：
# [表達式 for 變量 in 列表 if 條件判斷]
# 1.簡單條件列表推導(dǎo)
lst=[85,68,98,74,95,82,93,88,74]
lst1=[n for n in lst if n>=90] # 從lst中循環(huán)讀取各個元素賦給變量n，如果n大于等于90，則置前顯示。
print(lst1) # 返回[98, 95, 93] 效果與8~11行同
lst2=[]
for n in lst:
if n>=90:
lst2.append(n)
print(lst2) # 返回[98, 95, 93]
# 2.多條件列表推導(dǎo)
lst=[[25],[68,43],[120],[14,25],[63,24],[45,12,46]]
print([l for l in lst if sum(l)>=100 and len(l)>=2])
# 從lst中循環(huán)讀取各個列表賦給變量l，如果l里元素的和大于等于100，且l包含元素的個數(shù)大于等于2，則置前顯示l。返回[[68, 43], [45, 12, 46]]
# 3.嵌套條件列表推導(dǎo)
print([n for l in lst for n in l if n>=50]) # 返回[68, 120, 63]
# 從lst中循環(huán)讀取各個列表賦給變量l，又從l中循環(huán)讀取各個元素賦給變量n，如果n大于等于50.則置前顯示n。
print([l for l in lst for n in l if n>=50]) # 返回[[68, 43], [120], [63, 24]]
# 從lst中循環(huán)讀取各個列表賦給變量l，又從l中循環(huán)讀取各個元素賦給變量n，如果n大于等于50.則置前顯示l（列表）。
#12.列表的轉(zhuǎn)換（轉(zhuǎn)換為列表和列表反轉(zhuǎn)）
# 1.轉(zhuǎn)換為列表
# print(list()) # 返回[]，list()相當(dāng)于創(chuàng)建空列表
print(list('123'),[n for n in '123']) # 用list轉(zhuǎn)換的列表與for循環(huán)形成的列表相同：['1', '2', '3'] ['1', '2', '3']
# print(list((1,2,3))) # 將元組(1,2,3)轉(zhuǎn)換為列表：[1, 2, 3]
# print(list({1,2,3})) # 將集合{1,2,3}轉(zhuǎn)換為列表：[1, 2, 3]
# print(list({'a':1,'b':2,'c':3})) # 將字典轉(zhuǎn)換為列表（只轉(zhuǎn)換鍵，不轉(zhuǎn)換值）：['a', 'b', 'c']
# print(list(range(1,5))) # range()可迭代對象的轉(zhuǎn)換：[1, 2, 3, 4]
# print([n for n in range(1,5)]) # 在列表內(nèi)應(yīng)用列表推導(dǎo)式亦可實現(xiàn)轉(zhuǎn)換：[1, 2, 3, 4]
# num=[]
# for n in range(1,5):
# num.append(n)
# print(num) # 9~12行，應(yīng)用for循環(huán)在空列表依次添加元素，同樣可 實現(xiàn)轉(zhuǎn)換：[1, 2, 3, 4]
# 2.列表反轉(zhuǎn)
lst=['a','b','c','d'] # 以[1,2,3,4]為例亦可
# lst.reverse() # 應(yīng)用反轉(zhuǎn)函數(shù)reverse()，最簡捷
# print(lst) # 返回['d', 'c', 'b', 'a']
print([lst[n] for n in range(len(lst)-1,-1,-1)]) # 用列表推導(dǎo)式實現(xiàn)反轉(zhuǎn)：['d', 'c', 'b', 'a']
# print(lst[::-1]) # 用切片的方法實現(xiàn)反轉(zhuǎn)：['d', 'c', 'b', 'a']
#13.列表的轉(zhuǎn)換（淺復(fù)制與深復(fù)制）
# 1.賦值
# lst1=[1,2,3,4]
# lst2=lst1
# print(lst1,lst2) # 返回[1, 2, 3, 4] [1, 2, 3, 4]
# lst1[0]=100 # 把lst1里的1換成100
# print(lst1,lst2) # lst2[0]同樣跟著變，返回[100, 2, 3, 4] [100, 2, 3, 4]
# lst2[3]=400 # 把lst2里的4換成400
# print(lst1,lst2) # lst1[3]也跟著變，返回[100, 2, 3, 400] [100, 2, 3, 400]
# 2.淺復(fù)制
# lst1=[1,2,3,4]
# lst2=lst1.copy()
# print(lst1,lst2) # 返回[1, 2, 3, 4] [1, 2, 3, 4]
# lst1[0]=100 # 修改lst1
# print(lst1,lst2) #lst2不變，返回[100, 2, 3, 4] [1, 2, 3, 4]
# lst2[3]=400 # 修改lst2
# print(lst1,lst2) #lst1不變，返回[1, 2, 3, 4] [1, 2, 3, 400]
# 特殊情況：
# lst3=[1,[2,3],4] # 列表中包含列表
# lst4=lst3.copy() # 復(fù)制時，1,4為不可變對象，可以復(fù)制，[2,3]為可變對象，只能是引用
# print(lst3,lst4) # 返回[1, [2, 3], 4] [1, [2, 3], 4]
# lst3[2]=10 # 改變lst3里非列表元素，lst4不變
# print(lst3,lst4) # 返回[1, [2, 3], 10] [1, [2, 3], 4]
# lst3[1][0]=100 # 改變lst3里列表元素，lst4跟著變
# print(lst3,lst4) # 返回 [1, [100, 3], 4] [1, [100, 3], 4]
# 3.深復(fù)制
import copy # 導(dǎo)入庫
lst3=[1,[2,3],4]
lst4=copy.deepcopy(lst3) # 這種復(fù)制是新建內(nèi)存，lst3與lst4互不影響
print(lst3,lst4) # 返回[1, [2, 3], 4] [1, [2, 3], 4]
# lst3[2]=10
# print(lst3,lst4) # 返回[1, [2, 3], 10] [1, [2, 3], 4]
lst3[1][0]=100
print(lst3,lst4) # 返回[1, [100, 3], 4] [1, [2, 3], 4]
#14.列表常用統(tǒng)計方式
#常見統(tǒng)計操作
lst=[100,99,81,86]
print(len(lst)) # 計數(shù)，返回4
print(sum(lst)) # 求和，返回366
print(max(lst)) # 求最大值，返回100
print(min(lst)) # 求最小值，返回81
print(sum(lst)/len(lst)) # 求平均值，返回91.5
#統(tǒng)計指定元素出現(xiàn)的次數(shù)
lst=['a','b','c','b','b']
print(lst.count('b')) # 查詢'b'在lst中出現(xiàn)的次數(shù)，返回3
print(lst.index('b')) # 查詢'b'在lst中出現(xiàn)的位置，返回1
print(lst.index('b',2)) #從第2位開始查詢'b'在lst中出現(xiàn)的位置，返回3
#15.元組的基本操作（循環(huán)與轉(zhuǎn)換）
#元組可以像列表一樣做元組推導(dǎo)式和for循環(huán)
# 1.元組推導(dǎo)式（返回generator<生成器>：按需生成并返回結(jié)果）
tup=(1,2,3)
tup1=(t*10 for t in tup)
# print(tup1) # 返回<generator object <genexpr> at 0x0000000001DF7890>
print(list(tup1)) # 用list可將元組轉(zhuǎn)換為列表，返回[10, 20, 30]
# 2.元組的for循環(huán)
tup2=()
for t in tup: # 用for循環(huán)打印列表
tup2 +=(t*10,)
print(tup2) # 返回(10, 20, 30)
# 3.元組的轉(zhuǎn)換：像使用list類函數(shù)可以將可迭代對象轉(zhuǎn)換為列表，對于元組則可以使用tuple類對象將可迭代對象轉(zhuǎn)換為元組。
print(list('123')) # 返回['1', '2', '3']
print(tuple('123')) # 將字符串轉(zhuǎn)換為元組，返回('1', '2', '3')
print(tuple([1,2,3])) # 將列表轉(zhuǎn)換為元組，返回(1, 2, 3)
print(tuple({1,2,3})) # 將集合轉(zhuǎn)換為元組，返回(1, 2, 3)
print(tuple({'a':1,'b':2,'c':3})) # 將字典鍵轉(zhuǎn)換為元組，返回('a', 'b', 'c')
print(tuple(zip([1,2],[10,20]))) # 將列表迭代器轉(zhuǎn)換為元組，返回((1, 10), (2, 20))
print(tuple(range(1,10))) # 將range()函數(shù)生成的整數(shù)系列轉(zhuǎn)換為元組，返回(1, 2, 3, 4, 5, 6, 7, 8, 9)
|
#16.字典的基礎(chǔ)操作（字典創(chuàng)建、刪除和數(shù)據(jù)獲�。�
# 字典的結(jié)構(gòu)：{key鍵 :value值}，鍵具有唯一性，須是不可變對象，如字符串、數(shù)字或元組；值可以重復(fù)，可以是任何可變對象。字典是無序的，只能通過鍵來存取對應(yīng)的值。
# 1.字典的創(chuàng)建
# 空字典創(chuàng)建的兩種方法
dic1=dict();print(dic1) # 返回{}
dic2={};print(dic2) # 返回{}
# # 非空字典創(chuàng)建的兩種方法
dic3=dict(王五=22,麻子=24);print(dic3) # 返回{'王五': 22, '麻子': 24}
dic4={'王五': 22, '麻子': 24};print(dic4) # 返回{'王五': 22, '麻子': 24}
# # 2.字典的刪除
# del dic4
# print(dic4) # 打印出錯
# 3.字典的數(shù)據(jù)獲取
dic={'張三':18,'李四':20}
# 獲取指定鍵的值
print(dic['李四']) # 返回20
# 獲取所有的鍵
print(dic.keys()) # 返回:dict_keys(['張三', '李四'])
# 獲取所有的值
print(dic.values()) # 返回:dict_values([18, 20])
# 獲取所有的鍵和值
print(dic.items()) # 返回:dict_items([('張三', 18), ('李四', 20)])
#17.字典鍵值的修改、增加和刪除
# 1.字典鍵值的增加
dic={}
# 向空字典里添加鍵值的兩種方法（update是更新、修改的意思，如果修改的鍵值原來不存在，就相當(dāng)于增加）
dic.update(李四=88);print(dic) # 返回{'李四': 88}
dic.update({'麻子':96});print(dic) # 返回{'李四': 88, '麻子': 96}
dic.update(李四=102);print(dic) # 修改李四的值，返回{'李四': 102, '麻子': 96}
# 2.字典鍵值的刪除
dic={'張三':84,'李四':88,'王二':79,'麻子':99}
print(dic) # 打印{'張三': 84, '李四': 88, '王二': 79, '麻子': 99}
dic.pop('張三');print(dic) # 刪除張三的鍵值，返回{'李四': 88, '王二': 79, '麻子': 99}
# dic.clear();print(dic) # 清空所有鍵值，返回{}
# del dic;print(dic) # 刪除整個字典，打印字典出錯
# 3.字典鍵值的修改
dic1={'張三':20,'李四':18,'麻子':35}
# 修改指定鍵的值
dic1['張三']=100;print(dic1) # 返回{'張三': 100, '李四': 18, '麻子': 35}
# 修改指定鍵（先刪后加）
# print(dic1.pop('李四')) # 刪除李四這個鍵，但保留其值，返回18
dic1['王五']=dic1.pop('李四');print(dic1) # '李四'改為'王五'，值不變。返回{'張三': 100, '麻子': 35, '王五': 18}
#18.字典的轉(zhuǎn)換（使用dict類與dict.fromkeys函數(shù)）
#將列表、元組等可迭代對象的元素轉(zhuǎn)換為對應(yīng)的字典
# 1.使用dict類創(chuàng)建轉(zhuǎn)換字典
# 創(chuàng)建字典：
dic1=dict(a=1,b=2);print(dic1) # 返回：{'a': 1, 'b': 2}
# 將元組轉(zhuǎn)換為字典：
dic2=dict((('a','b'),(1,2)));print(dic2) # 返回：{'a': 'b', 1: 2} ，'b'成了值，1成了鍵
dic2=dict(zip(('a','b'),(1,2)));print(dic2) # 轉(zhuǎn)換前先用zip函數(shù)將元組重新組合，返回：{'a': 1, 'b': 2}
# 將列表轉(zhuǎn)換為字典：
dic3=dict([['a',1],('b',2)]);print(dic3) # 返回：{'a': 1, 'b': 2}
# 2.使用dict.fromkeys函數(shù)轉(zhuǎn)換為字典
# 將元組轉(zhuǎn)換為字典：
dic1=dict.fromkeys(('a','b'),1);print(dic1) # 返回：{'a': 1, 'b': 1}
# 將列表轉(zhuǎn)換為字典：
dic2=dict.fromkeys(['a','b'],1);print(dic2) # 返回：{'a': 1, 'b': 1}
# 將字符串轉(zhuǎn)換為字典：
dic3=dict.fromkeys('abc',1);print(dic3) # 返回：{'a': 1, 'b': 1, 'c': 1}
# 兩種特殊情形：
dic4=dict.fromkeys(['a','a','b']);print(dic4) # 返回：{'a': None, 'b': None} 缺少值
dic5=dict.fromkeys([('a',1),('a',1)]);print(dic5) # 返回：{('a', 1): None} 將相同的('a',1)作為鍵，缺少值
#19.集合的創(chuàng)建與刪除
set1=set();print(set1) #創(chuàng)建空集合，返回：set()
set2={1,2,3};print(set2) #創(chuàng)建有元素的集合，返回：{1, 2, 3}
set3=frozenset(set2);print(set3) #轉(zhuǎn)換為不可變集合，返回：frozenset({1, 2, 3})
del set1 #刪除指定的集合
# print(set1) #打印出錯
set4={1,89,24,37,89,24};print(set4) #返回：{89, 1, 37, 24}
set5={'張三','李四','王五','張三','劉六'};print(set5) #返回：{'李四', '劉六', '張三', '王五'} （順序不固定）
#20.集合元素的添加與刪除
# 1.集合元素的添加
# set1={1,2,3} # 原集合
# set1.add(4);print(set1) # 向集合中添加單個元素，返回：{1, 2, 3, 4}
# set1.update({5,6,7});print(set1) # 向集合中添加多個元素，返回： {1, 2, 3, 4, 5, 6, 7}
# # update()函數(shù)的參數(shù)可以是任何可迭代的對象，比如字符串、列表、元組等
# set1.update('dehtfed');print(set1) # 向集合中添加字符串，返回：{1, 2, 3, 4, 5, 6, 7, 'e', 'f', 't', 'h', 'd'}
# set1.update([7,8,9,10]);print(set1) # 向集合中添加列表，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'd', 'f', 'h', 'e', 't'}
# set1.update((12,14,13));print(set1) # 向集合中添加元組，返回：{1, 2, 3, 4, 5, 6, 7, 'f', 8, 9, 10, 12, 13, 14, 't', 'e', 'd', 'h'}
set2={'張三','李四','王五'}
set2.add('張三');print(set2) # 添加已有的字符串，原集合不變，返回：{'李四', '王五', '張三'}
set2.add('劉六');print(set2) # 添加沒有的字符串，原集合元素增加，返回：{'王五', '劉六', '張三', '李四'}
# 2.集合元素的刪除
set1={'a','b','c','d'};print(set1) # 原集合;返回：{'c', 'b', 'd', 'a'}
set1.remove('a');print(set1) # 刪除集合中的元素“a”，返回：{'c', 'b', 'd'}
set1.discard('b');print(set1) # 刪除集合中的元素“b”，返回：{'c', 'd'}
set1.pop();print(set1) # 隨機刪除集合中的一個元素，返回：{'d'}
set1.clear();print(set1) # 清空集合中的所有元素，返回：set()
#21.集合的運算（并集、交集）
# 1.并集運算
# set1={1,2,3,4,5,6}
# set2={4,5,6,7,8,9}
# print(set1.union(set2)) # 將集合1與集合2作并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set2.union(set1)) # 將集合2與集合1作并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|set2) # 將集合1與集合2作并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set2|set1) # 將集合2與集合1作并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 2.交集運算
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
# set3=set1.intersection(set2) # 求集合1與集合2的交集，將結(jié)果存儲在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set2.intersection(set1) # 求集合2與集合1的交集，將結(jié)果存儲在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set1&set2 # 求集合1與集合2的交集，將結(jié)果存儲在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set2&set1 # 求集合2與集合1的交集，將結(jié)果存儲在集合3中
# print(set3) # 返回：{4, 5, 6}
# 兩個集合作交集運算,結(jié)果存入新集合中，可用 ③=①.intersection(②)
# 兩個集合作交集運算,結(jié)果存入其中一個集合①中，可用 ①.intersection_update(②)
print(set1) # 集合1返回：{1, 2, 3, 4, 5, 6}
set1.intersection_update(set2) # 集合1與集合2作交集運算，結(jié)果存入集合1
print(set1) # 集合1返回：{4, 5, 6}
print(set2) # 集合2返回：{4, 5, 6, 7, 8, 9}
set2.intersection_update(set1) # 集合2與集合1作交集運算，結(jié)果存入集合2
print(set2) # 集合2返回：{4, 5, 6}
#22.集合的運算（差集與對稱差集）
# 1.差集運算
# set1={1,2,3,4,5,6} # 集合1
# set2={4,5,6,7,8,9} # 集合2
# set3=set1.difference(set2);print(set3) # 集合1減去集合2，將結(jié)果存儲在新集合3中，返回：{1, 2, 3}
# set3=set2.difference(set1);print(set3) # 集合2減去集合1，將結(jié)果存儲在新集合3中，返回：{8, 9, 7}
# set3=set1-set2;print(set3) # 與5行同，返回：{1, 2, 3}
# set3=set2-set1;print(set3) # 與6行同，返回：{8, 9, 7}
# set1.difference_update(set2);print(set1) # 集合1減去集合2，將結(jié)果存儲在集合1中，返回：{1, 2, 3}
# set2.difference_update(set1);print(set2) # 集合2減去集合1，將結(jié)果存儲在集合2中，返回：{7, 8, 9}
# 2.對稱差集運算
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
# set=set1|set2;print(set) # 與下行對照，這是并集運算結(jié)果，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9} (重復(fù)者4,5,6都保留一個)
set3=set1.symmetric_difference(set2);print(set3) # 這是對稱差集運算結(jié)果，返回：{1, 2, 3, 7, 8, 9} (重復(fù)者4,5,6都不保留)
# 去掉集合1與集合2中相同的元素，將結(jié)果存儲在新集合3中。
set3=set2.symmetric_difference(set1);print(set3) # 去掉集合2與集合1中相同的元素，將結(jié)果存儲在新集合3中。返回：{1, 2, 3, 7, 8, 9}
set3=set1^set2;print(set3) # 與16行同
set3=set2^set1;print(set3) # 與18行同
# set1.symmetric_difference_update(set2);print(set1) # 去掉集合1與集合2中相同的元素，將結(jié)果存儲集合1中。返回：{1, 2, 3, 7, 8, 9}
set2.symmetric_difference_update(set1);print(set2) # 去掉集合2與集合1中相同的元素，將結(jié)果存儲集合2中。返回：{1, 2, 3, 7, 8, 9}
# 試行歸納如下：
# seta=set1|set2;print(seta) # 并集運算，返回： {1, 2, 3, 4, 5, 6, 7, 8, 9}
# setb=set1&set2;print(setb) # 交集運算，返回： {4, 5, 6}
# setc=seta-setb;print(setc) # 差集運算，返回： {1, 2, 3, 7, 8, 9}
# setd=seta^setb;print(setd) # 對稱差集運算,返回:{1, 2, 3, 7, 8, 9}
# 由此看出，兩個集合的對稱差集運算結(jié)果，實際上就是兩個集合的并集減去兩個集合的交集所得的差。
#23.集合的運算（集合運算小結(jié)）
# 集合運算 運算結(jié)果生成新集合 運算結(jié)果存儲在原集合
# 方式 函數(shù)方法 符號方法 函數(shù)方法
# 并集 set1.union(set2) set1|set2 —
# 交集 set1.intersection(set2) set1&set2 set1.intersection_update(set2)
# 差集 set1.difference(set2) set1-set2 set1.difference_update(set2)
# 對稱差集 set1.symmetric_difference(set2) set1^set2 set1.symmetric_difference_update(set2)
set1={1,2,3,4,5,6} # 集合1
set2={4,5,6,7,8,9} # 集合2
lst=[4,5,6,7,8,9] # 列表
print(set1.union(set2)) # 用函數(shù)方法進行集合1與集合2的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1|set2) # 用符號方法進行集合1與集合2的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(range(5,15))) # 用函數(shù)方法進行集合1與整數(shù)系列的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
print(set1.union(lst)) # 用函數(shù)方法進行集合1與列表的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|lst) # 用符號方法進行集合1與列表的并集運算，程序報錯！
# 所以，用函數(shù)方法進行集合運算，函數(shù)的參數(shù)不一定是集合類型，只要是可迭代的對象即可；
# 而使用符號方法，符號兩側(cè)必須是集合類型，否則會出錯。
# 從上面的小結(jié)中可以看出，在并集運算中，沒有運算結(jié)果存儲在原集合的函數(shù)方法，但可以通過集合的update函數(shù)來實現(xiàn)，相當(dāng)于向指定的集合添加元素。
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
set2.update('addfa') # 集合2與字符串的并集運算，實際向集合2添加a、d、f三個元素（去除重復(fù)的a、d）
print(set2) # 返回：{4, 5, 6, 7, 8, 9, 'd', 'f', 'a'}
#24.去重示例(輸入人名每行不超過170人)
# encoding:utf-8
a1=['張老三','劉老四','陳 五','周九弟','吳小十','楊六郎','黃七哥','趙八爺']
a2=['王老大','李老二','張老三','黃七哥','趙八爺','周九弟','陳 五','楊六郎','吳小十']
a3=['劉老四','黃七哥','趙八爺','周九弟']
b=set(a1)|set(a2)|set(a3)
chang=len(a1)+len(a2)+len(a3)
print('原列表人數(shù)分別是：'+str(len(a1))+'、'+str(len(a2))+'、'+str(len(a3))+'，共'+str(chang)+'人。')
print('去除重復(fù)姓名后人數(shù)是{}人。名單如下：'.format(len(b)))
print('，'.join(b))
#25.集合的運算（集合運算小結(jié)）
# 集合運算 運算結(jié)果生成新集合 運算結(jié)果存儲在原集合
# 方式 函數(shù)方法 符號方法 函數(shù)方法
# 并集 set1.union(set2) set1|set2 —
# 交集 set1.intersection(set2) set1&set2 set1.intersection_update(set2)
# 差集 set1.difference(set2) set1-set2 set1.difference_update(set2)
# 對稱差集 set1.symmetric_difference(set2) set1^set2 set1.symmetric_difference_update(set2)
set1={1,2,3,4,5,6} # 集合1
set2={4,5,6,7,8,9} # 集合2
lst=[4,5,6,7,8,9] # 列表
print(set1.union(set2)) # 用函數(shù)方法進行集合1與集合2的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1|set2) # 用符號方法進行集合1與集合2的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(range(5,15))) # 用函數(shù)方法進行集合1與整數(shù)系列的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
print(set1.union(lst)) # 用函數(shù)方法進行集合1與列表的并集運算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|lst) # 用符號方法進行集合1與列表的并集運算，程序報錯！
# 所以，用函數(shù)方法進行集合運算，函數(shù)的參數(shù)不一定是集合類型，只要是可迭代的對象即可；
# 而使用符號方法，符號兩側(cè)必須是集合類型，否則會出錯。
# 從上面的小結(jié)中可以看出，在并集運算中，沒有運算結(jié)果存儲在原集合的函數(shù)方法，但可以通過集合的update函數(shù)來實現(xiàn)，相當(dāng)于向指定的集合添加元素。
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
set2.update('addfa') # 集合2與字符串的并集運算，實際向集合2添加a、d、f三個元素（去除重復(fù)的a、d）
print(set2) # 返回：{4, 5, 6, 7, 8, 9, 'd', 'f', 'a'}
#26.自定義函數(shù)編寫規(guī)范（函數(shù)定義與創(chuàng)建）
# 自定義函數(shù)的格式
# def 函數(shù)名(參數(shù)):
# 函數(shù)體
# return 返回值
# 1.有返回值的自定義函數(shù)
def total_sum1(price,amount): # 這時的參數(shù)稱為形參（單價，數(shù)量）
money=price*amount # 金額=單價×數(shù)量
return money # 返回 金額
# 2.無返回值的自定義函數(shù)
def total_sum2(price,amount):
str='單價:{} 數(shù)量:{} 金額:{}'.format(price,amount,price*amount) # 將單價、數(shù)量、金額進行格式化處理，然后賦值給變量str
print(str) # 輸出str
print(total_sum1(15,10)) # 返回:150
total_sum2(10,20) # 返回:單價:10 數(shù)量:20 金額:200
#27.必選參數(shù)的寫法及應(yīng)用（判斷分?jǐn)?shù)等級）
# 判斷分?jǐn)?shù)等級的自定義函數(shù)
def level(number,lv1,lv2,lv3): # 函數(shù)名level，4個必選參數(shù)：分?jǐn)?shù)number、等級lv1、lv2、lv3
if number>=90: # 當(dāng)分?jǐn)?shù)大于或等于90分時
return lv1 # 返回等級lv1
elif number>=60: # 當(dāng)分?jǐn)?shù)大于或等于60分且小于90分時
return lv2 # 返回等級lv2
elif number>=0: # 當(dāng)分?jǐn)?shù)大于或等于0分且小于60分時
return lv3 # 返回等級lv3
# 自定義函數(shù)的調(diào)用
# print(level(59,'上','中','下')) # 返回：下
for score in [95,63,58,69,41,88,96]: # 將列表中的元素循環(huán)賦值給變量score
print(score,level(score,'優(yōu)','中','差')) # 將score,'優(yōu)','中','差'作為自定義函數(shù)level的4個參數(shù)，運行函數(shù)后打印分?jǐn)?shù)和結(jié)果
# 分行返回：95 優(yōu) 63 中 58 差 69 中 41 差 88 中 96 優(yōu)
# 也可以用列表推導(dǎo)式把判斷結(jié)果在一行中表達出來
print([level(score,'優(yōu)','中','差') for score in [95,63,58,69,41,88,96]]) # 返回等級：
# ['優(yōu)', '中', '差', '中', '差', '中', '優(yōu)']
print([(score,level(score,'優(yōu)','中','差')) for score in [95,63,58,69,41,88,96]]) # 返回分?jǐn)?shù)與等級：
# [(95, '優(yōu)'), (63, '中'), (58, '差'), (69, '中'), (41, '差'), (88, '中'), (96, '優(yōu)')]
#28.必選參數(shù)的寫法及應(yīng)用（給號碼分段）
# 給號碼分段的自定義函數(shù)
def intercept(s,num,delimiter): # 函數(shù)名：截取，參數(shù)：號碼、每段長度、分隔符
s1 = str(s) # 將分段對象轉(zhuǎn)換為字符串類型
lst = [s1[n:n + num] for n in range(0, len(s1), num)] # 仿照7行對數(shù)據(jù)進行分段處理
s2=delimiter.join(lst) # 合并分段的列表
return s2 # 返回合并結(jié)果
s='25364789551678957843529'
print(intercept(s,4,'-'))
#29.可選參數(shù)的寫法及應(yīng)用（默認(rèn)參數(shù)）
# iterable:必選參數(shù)，可切片的對象，如字符串、列表、元組
# start:可選參數(shù)，切片的起始位置，默認(rèn)值為0
# lenght:可選參數(shù)，切片的長度，默認(rèn)值為1
def mid(iterable,start=0,lenght=1):
return iterable[start:start+lenght] # 返回切片結(jié)果（從開始位置到開始位置加切片長度）
print(mid('abcdefgh')) # 返回：a
print(mid('abcdefgh',2)) # 返回：c
print(mid('abcdefgh',2,4)) # 返回：cdef
print(mid([32,35,56,2,75,234,65])) # 返回：[32]
print(mid([32,35,56,2,75,234,65],3,2)) # 返回：[2, 75]
#30.字符替換（單個字符與多個字符）
# 1.單個字符替換
str='三國演義，西游記、水滸，紅樓夢'
print(str.replace('，','|')) # 返回：三國演義|西游記、水滸|紅樓夢
# 2.多個字符替換(建立并應(yīng)用自定義增強版替換函數(shù))
def replaces(string,new,*old): # 替換函數(shù)（原字符串，要替換的新字符，被替換的舊字符（可以指定多個）
for i in old: # 循環(huán)提取各個舊字符賦給變量i
string=string.replace(i,new) # 將i的值替換為new的值，再賦給string參數(shù)
return string # 返回替換后的值給函數(shù)
print('《'+replaces(str,'》《','，','、','|')+'》') # 返回：《三國演義》《西游記》《水滸》《紅樓夢》
|