字符串

• 字符串的定義方式

1. 單引號定義字符串 ‘ ’
2. 雙引號定義字符串 “ ”
3. 三引號定義字符串 ‘’‘內(nèi)容’‘’或者 “”“內(nèi)容”“”
4. 字符串定義時辜限，引號可以互相嵌套

• 轉(zhuǎn)義字符

一個普通的字符出現(xiàn)在轉(zhuǎn)義符 \ 的后面時漆弄，實現(xiàn)了另外一種意義

    作為轉(zhuǎn)義符時，在\后面出現(xiàn)的字符可能會實現(xiàn)另外一種意義。

    作為續(xù)行符時剔宪，在行尾使用了\后歌粥，可以換行繼續(xù)書寫內(nèi)容

\n 代表一個換行符

\r 代表光標(biāo)位置（從\r出現(xiàn)的位置開始作為光標(biāo)的起點）

\t 代表一個水平制表符（table 縮進(jìn)）,按四下

\b 代表一個退格符

\\ 反轉(zhuǎn)義\，輸出了\院仿，取消\的轉(zhuǎn)義效果

#續(xù)行符
var = '123'\
            '456'
print(var)#123456

#轉(zhuǎn)義符
paper = '回復(fù)\n啊額會不會\n被哈把\n和部分誒俄碧'
print(paper)
#回復(fù)
#啊額會不會
#被哈把
#和部分誒俄碧

#\r 代表光標(biāo)位置（從\r出現(xiàn)的位置開始作為光標(biāo)的起點）
paper = '回復(fù)\r啊額會不會\n被哈把\n和部分誒俄碧'
print(paper)
#啊額會不會
#被哈把
#和部分誒俄碧

# \t 代表一個水平制表符（table 縮進(jìn)）,按四下
paper = '回復(fù)\r啊額會不會\t被哈把\n和部分誒俄碧'
print(paper)
#啊額會不會  被哈把
#和部分誒俄碧

# \b 代表一個退格符,回刪一下
paper = '回復(fù)，\b啊額會不，會\b被哈把和部分誒俄碧'
print(paper)#回復(fù)啊額會不歹垫，被哈把和部分誒俄碧

#`\\` 反轉(zhuǎn)義\剥汤，輸出了\，取消\的轉(zhuǎn)義效果
var = '123\\456'
print(var)#123\456


# 把轉(zhuǎn)義字符作為普通字符輸出,在字符串的前面加 r''
paper = r'回復(fù)排惨，\b啊額會不吭敢，會\b被哈把和部分誒俄碧'
print(paper)#回復(fù)，\b啊額會不暮芭，會\b被哈把和部分誒俄碧

• 字符串相關(guān)的操作

+操作

*操作

[ ] 切片操作

字符串[開始值：結(jié)束值：步進(jìn)值]

開始值：默認(rèn)為0鹿驼，結(jié)束值默認(rèn)是最后一個下標(biāo)，步進(jìn)值默認(rèn)為1

#兩種拼接方式
vara = '君不見辕宏，黃河之水天上來畜晰，奔流到海不復(fù)回.'
varb = '君不見，高堂明鏡悲白發(fā)瑞筐，朝如青絲暮成雪'
res1 = vara + varb
res2 = '將進(jìn)酒 '+'李白'
print(res1)
print(res2)

# 字符串 * 操作
vars = '小太陽' * 5
print(vars)

# - 字符串 [] 切片操作 
# 字符串的索引操作凄鼻，字符串中只能使用[]下標(biāo) 訪問，不能修改
vars = '君不見聚假，黃河之水天上來块蚌，奔流到海不復(fù)回'
print(vars[5])#河
print(vars[-5])#到
'''
字符串的切片操作
str[開始值：結(jié)束值：步進(jìn)值]
開始值：默認(rèn)為0，結(jié)束值默認(rèn)是最后一個下標(biāo)膘格，步進(jìn)值默認(rèn)為1
'''
print(vars)
print(vars[5]) # 寫一個值就是獲取指定下標(biāo)的元素
print(vars[2:5]) # 從2下標(biāo)開始取值峭范，一直到下標(biāo)5之前，能取到2闯袒，取不到5
print(vars[4:8:2]) # 黃河之水 ==> 黃之
print(vars[::]) # 從頭取到尾
print(vars[::2]) # 從頭取到尾虎敦，每隔一個取一個
print(vars[::-1])  # 字符串倒轉(zhuǎn)過來
print(vars[::-2])  # 字符串倒轉(zhuǎn)過來，每隔一個取一個
print(vars[1::])  # 不見政敢，黃河之水天上來其徙，奔流到海不復(fù)回
print(vars[1::2])  # 不，河水上喷户，流海復(fù)

• 字符串格式化的方法

.format()
f ' '

# 1 format  普通方式
a = '李白'
vars = '{}乘舟將欲行雷蹂，互聞岸上踏歌聲'.format(a)
vars = '{}乘舟將欲行彰亥，互聞岸上{}'.format(a,'踏歌聲')

# 2 format  通過索引傳參                  0   1   2
vars = '{2}乘舟將欲行，互聞岸上{1}'.format('a','b','c')

# 3 format  關(guān)鍵字傳參
vars = '{a}乘舟將欲行，互聞岸上吻氧'.format(a='李白',b='踏歌聲')

# 4 format  容器類型數(shù)據(jù)傳參
vars = '豪放派：{0[0]}茧痕，婉約派：{0[1]}斑匪，蛋黃派：{0[2]}'.format(['李白','辛棄疾','達(dá)利園'])

#字典傳參风皿，**data當(dāng)前的關(guān)鍵字必須按照定義的方式傳遞進(jìn)來
data = {'a':'辛棄疾','b':'蛋黃派'}
vars = '{a}乘舟將欲行，互聞岸上璃谨'.format(**data)

# 3.7中新增的 格式化方法 f方法
vars = f'{data["a"]}乘舟將欲行沙庐，互聞岸上{data["b"]}'
print(vars)

# 限定小數(shù)的位數(shù)
vars = '圓周率是多少：{:.4f}'.format(3.1415926)
print(vars)#3.1416

字符串相關(guān)函數(shù)

• ? 英文字符與字符檢測相關(guān)函數(shù)

vars = 'too young to naive'
# 返回字符串的副本鲤妥，該字符串的首個字符大寫，其余小寫拱雏。
# str.capitalize()
res1 = vars.capitalize()
# 把字符串中的一個單詞的首字母大寫
res2 = vars.title()
# 把字符串全部改為 大寫
res3 = vars.upper()
# 把字符串全部改為 小寫
res4 = vars.lower()
# 字符串中的大小寫字符轉(zhuǎn)換棉安，大寫轉(zhuǎn)小寫，小寫轉(zhuǎn)大寫
res5 = vars.swapcase()
# 檢測字符串是否為全部大寫字母組成
res6 = vars.isupper()
# 檢測字符串是否為全部小寫字母組成
res7 = vars.islower()
# 檢測字符串是否符合標(biāo)題title的要求
res8 = vars.istitle()
# 檢測字符串是否由數(shù)字和字母組成铸抑，如果字符串中包含來非數(shù)字字母的其它字符贡耽，比如空格則返回False
res9 = vars.isalnum()
# 檢測字符串是否全部由字符(包含英文字符和中文)組成，不含空格鹊汛，數(shù)字
res10 = vars.isalpha()
# 檢測字符串是否由純數(shù)字字符組成
res11 = vars.isdigit()
# 檢測當(dāng)前字符串是否為 空格 字符組成 ' '
res12 = vars.isspace()
# 檢測字符串是否以指定的字符開始的蒲赂，也可以指定開始和結(jié)束的位置
res13 = vars.startswith('t')

res14 = vars.startswith('y',4)
# 檢測字符串是否以 指定的字符 結(jié)束的，也可以指定開始和結(jié)束的位置
res15 = vars.endswith('e')
res16 = vars.endswith('e',13,18)

• 查找與操作相關(guān)函數(shù)(重點)

vars = 'too young to naive'
# find() 方法 柒昏，找到則返回字符中符合條件的第一個字符出現(xiàn)的索引位置凳宙。未找到返回 -1
res = vars.find('na')
print(res)#13
print(vars[res:res+5])#naive

# 字符串查找相關(guān)函數(shù)
# 從左向右 獲取指定字符在字符串中第一次出現(xiàn)的索引位置熙揍，未找到則返回 -1
#str.find(sub[, start[, end]])
res1 = vars.find('to')
res2 = vars.find('young',0,14)

# 從右向左 獲取指定字符在字符串中第一次出現(xiàn)的索引位置职祷，未找到則返回 -1
res3 = vars.rfind('to')
res4 = vars.rfind('to',0,14)
print(res1)#0
print(res2)#0
print(res3)#10
print(res4)#10

vars = 'too young to naive'

# index() 方法
res = vars.index('you') # 找到則返回索引位置，未找到則報錯 ValueError
print(res)#4

# str.index() 和find方法一樣届囚，只不過如果沒有找到則報錯 # ValueError: substring not found

# str.rindex() 和 rfind方法一樣有梆，沒有找到則引發(fā)異常 # ValueError: substring not found
res = vars.rindex('you')#4

# str.count(sub[, start[, end]])# 統(tǒng)計一個字符在字符串中出現(xiàn)的字符
res = vars.count('o')#4

• 字符串操作相關(guān)函數(shù)( 重點)

vars = 'user_admin_id_123'

# str.split() 按照**指定的字符**進(jìn)行分隔**，把一個字符串分隔成**一個列表**
print(vars.split('_')) # ['user', 'admin', 'id', '123']
print(vars.split('_')[2:4])#['id', '123']

vars = 'uid=123&type=ab&kw=hh'
res = vars.split('&')#先按照&進(jìn)行分隔
for i in res:
     r = i.split('=')#再按照=進(jìn)行分隔
     print(r.pop())#pop()用于移除列表中的一個元素（默認(rèn)最后一個元素）意系，并且返回該元素的值泥耀。

    # 可以指定分隔的次數(shù)
  # str.rsplit(sep=None,maxsplit=-1)
res = vars.split('_',2) 
#['user', 'admin', 'id_123']

res = vars.rsplit('_') 
# ['user', 'admin', 'id', '123']

res = vars.rsplit('_',2) #從最右邊開始拆分，指定分割的次數(shù)
# ['user_admin', 'id', '123']

 arr = ['user', 'admin', 'id', '123']
#str.join() 按照指定的字符蛔添，把任何容器類型中的數(shù)據(jù)鏈接成一個字符串
res = '-'.join(arr) # user-admin-id-123

vars = '###這是一個是#文章的標(biāo)題##'
# 可以去除字符串左右兩側(cè)的指定字符
# str.strip()
res = vars.strip('#')
print(vars,len(vars))# ###這是一個是#文章的標(biāo)題## 16
print(res,len(res))# 這是一個是#文章的標(biāo)題 11

# str.lstrip() 去除字符串左側(cè)的指定字符
# str.rstrip() 去除字符串右側(cè)的指定字符

# str.replace() 替換
vars = 'iloveyoutosimidailoveyou'
res1 = vars.replace('love','like')
res2 = vars.replace('love','LOVE',1)#替換一次


vars = 'love'
res1 = vars.center(10)
res2 = vars.center(12,'*')
res3 = vars.ljust(10,'*')
res4 = vars.rjust(10,'*')

print(res1)
print(res2)
print(res3)
print(res4)

列表

• 定義

一組有序的數(shù)據(jù)組合痰催，列表中的數(shù)據(jù)可以被修改

• 使用[ ]定義

• 使用list( )定義

• 在定義列表中的元素時，需要在每個元素之間使用逗號迎瞧，進(jìn)行分隔夸溶。[1,2,3,4]

• 列表中的元素可以是任意類型的，通常用于存放同類項目的集合

• 基本操作

# 列表定義與基本操作

varlist1 = [1,2,3,4]
varlist2 = ['a','b','c','d']

# 列表的拼接凶硅。把多個列表的元素拼接成一個列表
res = varlist1+varlist2+[11,22,33]

# 列表元素的重復(fù)
res = varlist1*3#重復(fù)列表1的內(nèi)容
#不能列表乘列表

# 檢測元素是否存在于列表
res = 'a' in varlist1#False

# 列表的索引操作
'''
0   1   2   3
'a','b','c','d'
-4  -3  -2  -1
'''

# 通過下標(biāo)獲取指定的元素
res = varlist2[2]
res = varlist2[-3]

# 通過下標(biāo)修改元素
varlist2[2] = 'cc'

# 不能通過下標(biāo)添加元素,
varlist2[4] = 'ff'  #IndexError: list assignment index out of range

#向列表元素中追加元素
varlist2.append('ff')
print(varlist2)

# 列表元素的刪除,通過下標(biāo)進(jìn)行元素的刪除
del varlist2[2]#del 列表[下標(biāo)]
res = varlist2.pop()#pop()函數(shù) 刪除元素
print(res)

# 獲取列表的長度 len()
res = len(varlist2)
print(res)

• 列表的切片

列表[開始索引:結(jié)束索引:步進(jìn)值]

1缝裁、列表[開始索引:] ==> 從開始索引到列表的最后

2、列表[:結(jié)束值] ==> 從開始到指定的結(jié)束索引之前

3足绅、列表[開始索引:結(jié)束索引] ==> 從開始索引到指定結(jié)束索引之前

4捷绑、 列表[開始索引:結(jié)束索引:步進(jìn)值] ==> 從指定索引開始到指定索引前結(jié)束，按照指定步進(jìn)進(jìn)行取值切片

5氢妈、列表[:] 或 列表[::] ==> 所有列表元素的切片

6粹污、列表[::-1] ==> 倒著獲取列表的元素

varlist = ['劉德華','張學(xué)友','張國榮','黎明','郭富城','小沈陽','劉能','宋小寶','趙四']

# 從開始索引到列表的最后
res = varlist[2:] # ['張國榮','黎明','郭富城','小沈陽','劉能','宋小寶','趙四']
# 從開始到指定的結(jié)束索引之前
res = varlist[:2] # ['劉德華','張學(xué)友']
# 從開始索引到指定結(jié)束索引之前
res = varlist[2:6] # ['張國榮', '黎明', '郭富城', '小沈陽']
# 從指定索引開始到指定索引前結(jié)束，按照指定步進(jìn)進(jìn)行取值切片
res = varlist[2:6:2] # ['張國榮', '郭富城']
# 所有列表元素的切片
res = varlist[:]
res = varlist[::]
# 倒著輸出列表的元素
res = varlist[::-1]

# 使用切片方法 對列表數(shù)據(jù)進(jìn)行更新和刪除
print(varlist)

# 從指定下標(biāo)開始首量，到指定下標(biāo)前結(jié)束壮吩，并替換為對應(yīng)的數(shù)據(jù)(容器類型數(shù)據(jù)str list，會拆分成每個元素進(jìn)行賦值)
varlist[2:6] = ['a','b','c',1,2,3]
varlist[2:6:2] = ['a','b'] # 需要與要更新的元素個數(shù)對應(yīng)

# 切片刪除
del varlist[2:6]
del varlist[2:6:2]

• 列表相關(guān)函數(shù)

varlist = ['劉德華','張學(xué)友','張國榮','張學(xué)友','黎明','郭富城','小沈陽','劉能','宋小寶','趙四']

# len()  檢測當(dāng)前列表的長度，列表中元素的個數(shù)
res = len(varlist)

# count() 檢測當(dāng)前列表中指定元素出現(xiàn)的次數(shù)
res = varlist.count('張學(xué)友')

# append() 向列表的尾部追加新的元素粥航，返回值為 None
varlist.append('kris')

# insert() 可以向列表中指定的索引位置添加新的元素琅捏，
varlist.insert(20,'aa')
 
# pop() 可以對指定索引位置上的元素做 出棧 操作，返回出棧的元素
res = varlist.pop() # 默認(rèn)會把列表中的最后一個元素 出棧
res = varlist.pop(2) # 會在列表中把指定索引的元素進(jìn)行 出棧

varlist = [1,2,3,4,11,22,33,44,1,2,3,4]
# remove() 可以指定列表中的元素 進(jìn)行 刪除,只刪除第一個递雀。如果沒有找到柄延，則報錯
res = varlist.remove(1)

# index() 可以查找指定元素在列表中第一次出現(xiàn)的索引位置
res = varlist.index(1)
res = varlist.index(1,5,10) # 可以在指定索引范圍5-10內(nèi)查找元素的索引位置

# extend() 接收一個容器類型的數(shù)據(jù)，把容器中的元素追加到原列表中
varlist.extend('123')

# s.clear() # 清空列表內(nèi)容
varlist.clear()


# reverse() 列表翻轉(zhuǎn)
varlist.reverse()

# sort() 對列表進(jìn)行排序
res = varlist.sort() # 默認(rèn)對元素進(jìn)行從小到大的排序
res = varlist.sort(reverse=True) # 對元素進(jìn)行從大到小的排序
res = varlist.sort(key=abs) # 可以傳遞一個函數(shù)缀程，按照函數(shù)的處理結(jié)果進(jìn)行排序



# copy()  拷貝搜吧，復(fù)制當(dāng)前的列表、
varlist = ['a','b','c']
res = varlist.copy()

# 對copy后的列表進(jìn)行操作
del res[2]
'''
['a', 'b']print(res)
['a', 'b', 'c']print(varlist)
'''

# 定義 多維列表
varlist = ['a','b','c',[11,22,33]]

res = varlist.copy()

# 對copy的列表進(jìn)行一個操作
del res[1] # 對一維列表進(jìn)行操作杨凑，沒有問題
print(res)#['a', 'c', [11, 22, 33]]
print(varlist)#['a', 'b', 'c', [11, 22, 33]]

del res[3][1] # 對多維列表中的元素滤奈，進(jìn)行操作，則出現(xiàn)了撩满，全部改變的情況
print(res)#['a', 'b', 'c', [11, 33]]
print(varlist)#['a', 'b', 'c', [11, 33]]

• 淺拷貝—只能拷貝當(dāng)前列表蜒程，不能拷貝列表中的多維列表元素

# 淺拷貝 

varlist = [1,2,3]
# 簡單的拷貝 就可以把列表復(fù)制一份
newlist = varlist.copy()
# 對新拷貝的列表進(jìn)行操作，也是獨立的
del newlist[1]
#兩者id不同
print(varlist,id(varlist))#[1, 2, 3] 4332224992
print(newlist,id(newlist))#[1, 3] 4332227552

# 多維列表
varlist = [1,2,3,['a','b','c']]
# 使用copy函數(shù) 拷貝一個多維列表
newlist = varlist.copy()
print(newlist,id(newlist))#[1, 2, 3, ['a', 'b', 'c']] 4361085408
print(varlist,id(varlist))#[1, 2, 3, ['a', 'b', 'c']] 4361898496


# 如果是一個被拷貝的列表伺帘，對它的多維列表元素進(jìn)行操作時昭躺，會導(dǎo)致原列表中的多維列表也發(fā)生了變化
del newlist[3][1]

#通過id檢測，發(fā)現(xiàn)列表中的多維列表是同一個元素（對象）
print(newlist[3],id(newlist[3]))#['a', 'c'] 4325397360
print(varlist[3],id(varlist[3]))#['a', 'c'] 4325397360

• 深拷貝—不光拷貝了當(dāng)前的列表伪嫁，同時把列表中的多維元素也拷貝了一份

import copy

varlist = [1,2,3,['a','b','c']]

# 使用 copy模塊中 深拷貝方法 deepcopy
newlist = copy.deepcopy(varlist)

del newlist[3][1]

print(varlist)
print(newlist)

print(newlist[3],id(newlist[3]))#['a', 'c'] 4483351248
print(varlist[3],id(varlist[3]))#['a', 'b', 'c'] 4483003568

• 列表推到式

提供一個更簡單的創(chuàng)建列表的方法

采用一種表達(dá)式的當(dāng)時领炫，對數(shù)據(jù)進(jìn)行過濾或處理，并且把結(jié)果組成一個新的列表

# 一张咳，基本的列表推到式使用方式
# 變量 = [變量或變量的處理結(jié)果 for 變量 in 容器類型數(shù)據(jù)]

# 1. 創(chuàng)建一個平方列表

# 使用普通方法完成
varlist = []
for i in range(10):
    varlist.append(i**2)
print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 使用 map函數(shù)和list完成
varlist = list(map(lambda x: x**2, range(10)))
print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 使用列表推到式完成 下面這個列表推到式和第一種方式是一樣的
varlist = [i**2 for i in range(10)]
print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 2. '1234' ==> [2,4,6,8]
# 常規(guī)方法完成需求
varstr = '1234'
newlist = []
for i in varstr:
    newlist.append(int(i)*2)
print(newlist)  # [2, 4, 6, 8]

# 使用列表推到式完成上面的需求
newlist = [int(i)*2 for i in varstr]
print(newlist)  # [2, 4, 6, 8]


# 使用列表推到式+位運算完成
newlist = [int(i) << 1 for i in varstr]
print(newlist)  # [2, 4, 6, 8]


# 二帝洪，帶有判斷條件的列表推到式
# 變量 = [變量或變量的處理結(jié)果 for i in 容器類型數(shù)據(jù) 條件表達(dá)式]
# 0-9 求所有的偶數(shù)，==> [0, 2, 4, 6, 8]
# 常規(guī)方法完成
newlist = []
for i in range(10):
    if i % 2 == 0:
        newlist.append(i)
print(newlist) # [0, 2, 4, 6, 8]

# 列表推到式完成
newlist = [i for i in range(10) if i % 2 == 0]
print(newlist)  # [0, 2, 4, 6, 8]


# 三脚猾， 帶有條件判斷的多循環(huán)的推到式
# [1,2,3],[3,1,4] ==> 把兩個列表中的元素 兩兩組合葱峡，要求組合的元素不能重復(fù)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

# 常規(guī)方法實現(xiàn)
newlist = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
            newlist.append((x,y))
print(newlist)


# 使用列表推到式完成
newlist = [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(newlist)



# 四，對于嵌套循環(huán)的列表推到式

'''
# 下面這個 3x4的矩陣婚陪，它由3個長度為4的列表組成族沃，交換其行和列
[
 [1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
]

==>
[
    [1, 5, 9], 
    [2, 6, 10], 
    [3, 7, 11], 
    [4, 8, 12]
]
'''
arr = [
 [1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
]

# 常規(guī)方法完成
newlist = []
for i in range(4):
     res = []
     for row in arr:
         res.append(row[i])
     newlist.append(res)
 print(newlist)

# 使用列表推到式完成
newlist = [[row[i] for row in arr] for i in range(4)]
print(newlist)

元祖

• 定義

元組和列表一樣都是一組有序的數(shù)據(jù)的組合。

元組中的元素一但定義不可以修改泌参，因此元組稱為 不可變數(shù)據(jù)類型

• 定義空元組 變量 = (),或者 變量=tuple()
• 還可以使用 變量 = (1,2,3) 定義含有數(shù)據(jù)的元組
• 注意：如果元組中只有一個元素時脆淹，必須加逗號 變量=(1,)
• 特例：變量=1,2,3 這種方式也可以定義為一個元組

• 相關(guān)操作

由于是不可變的數(shù)據(jù)類型，只能使用索引進(jìn)行訪問沽一，不能進(jìn)行其它操作

元組可以和列表一樣使用切片方式獲取元素

#元組的切片操作 和列表是一樣的

vart = (1,2,3,4,5,5,4,3,2,1)
res = vart[:]  # 獲取全部
res = vart[::] # 獲取全部
res = vart[1:] # 從索引1開始獲取到最后
res = vart[1:3] # 從索引1開始到索引3之前
res = vart[:3]   # 從索引 0 開始 到 索引 3之前
res = vart[1:5:2] # 從索引1開始到索引5之前盖溺，步進(jìn)值為2
res = vart[::2]  # 從索引 0 開始 到 最后 ，步進(jìn)值為2
res = vart[5:1:-1] # 從索引5開始 到索引 1铣缠，步進(jìn)值為-1  倒著輸出

• 語法：

列表推導(dǎo)式 ==> [變量運算 for i in 容器] ==> 結(jié)果 是一個 列表
元組推導(dǎo)式 ==> (變量運算 for i in 容器) ==> 結(jié)果 是一個 生成器

列表推導(dǎo)式結(jié)果返回了一個列表烘嘱，元組推導(dǎo)式返回的是生成器

字典

字典也是一種數(shù)據(jù)的集合昆禽，由鍵值對組成的數(shù)據(jù)集合，字典中的鍵不能重復(fù)
字典中的鍵必須是不可變的數(shù)據(jù)類型蝇庭，常用的鍵主要是：字符串醉鳖，整型。哮内。盗棵。

• 字典的定義

# 1。 使用{}定義
vardict = {'a':1,'b':2,'c':2}

# 2北发。 使用 dict(key=value,key=value) 函數(shù)進(jìn)行定義
vardict = dict(name='zhangsan',sex='男',age=22)

# 3纹因。 數(shù)據(jù)類型的轉(zhuǎn)換  dict(二級容器類型) 列表或元組，并且是二級容易才可以轉(zhuǎn)換
vardict = dict([['a',1],['b',2],['c',3]])  # {'a': 1, 'b': 2, 'c': 3}

# 4琳拨。zip壓縮函數(shù)瞭恰，dict轉(zhuǎn)類型
var1 = [1,2,3,4]
var2 = ['a','b','c','d']

# 轉(zhuǎn)換的原理和上面的第三種 是一個原理
vardict = dict(zip(var1,var2))  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(vardict)# 1。 使用{}定義
vardict = {'a':1,'b':2,'c':2}

# 2狱庇。 使用 dict(key=value,key=value) 函數(shù)進(jìn)行定義
vardict = dict(name='zhangsan',sex='男',age=22)

# 3惊畏。 數(shù)據(jù)類型的轉(zhuǎn)換  dict(二級容器類型) 列表或元組，并且是二級容易才可以轉(zhuǎn)換
vardict = dict([['a',1],['b',2],['c',3]])  # {'a': 1, 'b': 2, 'c': 3}

# 4僵井。zip壓縮函數(shù)陕截，dict轉(zhuǎn)類型
var1 = [1,2,3,4]
var2 = ['a','b','c','d']

# 轉(zhuǎn)換的原理和上面的第三種 是一個原理
vardict = dict(zip(var1,var2))  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(vardict)

• 字典的操作

var1 = {'a': 1, 'b': 2, 'c': 3}
var2 = {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

# res = var1 +  var2 # XXXX  TypeError
# res = var1 * 3 # xxxx TypeError

# 獲取元素
res = var1['a']

# 修改元素
res = var1['a'] = 111

# 刪除元素
del var1['a']

# 添加元素
var1['aa'] = 'AA'

# 如果字典中的key重復(fù)了驳棱，會被覆蓋
# var1['aa'] = 'aa'

• 成員檢測和獲取

# 三 成員檢測和獲取  ,只能檢測key批什，不能檢測value
res = 'AA' in var1
res = 'AA' not in var1

# 獲取當(dāng)前字典的長度 只能檢測當(dāng)前又多少個鍵值對
res = len(var1)

# 獲取當(dāng)前字典中的所有 key 鍵
res = var1.keys()
# 獲取字典中所有的 value 值
res = var1.values()
# 獲取當(dāng)前字典中所有 鍵值對
res = var1.items()

• 字典的遍歷

# 四， 對字典進(jìn)行遍歷
# （1）在遍歷當(dāng)前的字典時社搅，只能獲取當(dāng)前的key
for i in var1:
    print(i) # 只能獲取 key
    print(var1[i]) # 通過字典的key獲取對應(yīng)value

#（2）遍歷字典時驻债，使用 items() 函數(shù)，可以在遍歷中獲取key和value
for k,v in var1.items():
    print(k)  # 遍歷時的 key
    print(v)  # 遍歷時的 value

print('===='*20)
# (3) 遍歷字典的所有key
for k in var1.keys():
    print(k)

print('===='*20)
# (4) 遍歷字典的所有 value
for v in var1.values():
    print(v)

• 字典的相關(guān)函數(shù)

len(字典) #獲取字典的鍵值對個數(shù)
dict.keys() # 獲取當(dāng)前字典的所有key 鍵形葬，組成的列表
dict.values() # 獲取當(dāng)前字典的所有 value 值合呐，組成的列表
dict.items() # 返回由字典項 ((鍵, 值) 對) 組成的一個新視圖
iter(d) 返回以字典的鍵為元素的迭代器。

vardict = {'a':1,'b':2,'c':3}

dict.pop(key) # 通過 key 從當(dāng)前字典中彈出鍵值對  刪除
res = vardict.pop('a')

dict.popitem()   LIFO: Last in, First out.后進(jìn)先出
res = vardict.popitem()  # 把最后加入到字典中的鍵值對刪除并返回一個元組

# 使用key獲取字典中不存在元素笙以，會報錯
print(vardict['aa'])
# 可以使用get獲取一個元素淌实，存在則返回，不存在默認(rèn)返回None
res = vardict.get('aa')
res = vardict.get('aa','abc')

# dict.update(),更新字典,如果key存在猖腕，則更新拆祈，對應(yīng)的key不存在則添加
# vardict.update(a=11,b=22)
# vardict.update({'c':33,'d':44})

# dict.setdefault(key[,default])
# 如果字典存在鍵 key ，返回它的值倘感。
# 如果不存在放坏，插入值為 default 的鍵 key ，并返回 default 老玛。
# default 默認(rèn)為 None淤年。
res = vardict.setdefault('aa','123')
print(res)
print(vardict)

• 字典推導(dǎo)式

# 把字典中的鍵值對位置進(jìn)行交換 {'a':1,'b':2,'c':3}
vardict = {'a':1,'b':2,'c':3}

# 普通方法實現(xiàn) 字典中的鍵值交換  {1: 'a', 2: 'b', 3: 'c'}
newdict = {}
for k,v in vardict.items():
    newdict[v] = k
# print(newdict)

# 使用字典推導(dǎo)式完成  {1: 'a', 2: 'b', 3: 'c'}
newdict = {v:k for k,v in vardict.items()}
# print(newdict)

# 注意：以下推導(dǎo)式钧敞，返回的結(jié)果是一個集合，集合推導(dǎo)式
newdict = {v for k,v in vardict.items()}
# print(newdict,type(newdict))


# 把以下字典中的是偶數(shù)的值麸粮，保留下來溉苛，并且交換鍵值對的位置
vardict = {'a':1,'b':2,'c':3,'d':4}

# 普通方式完成  {2: 'b', 4: 'd'}
# newdict = {}
# for k,v in vardict.items():
#     if v % 2 == 0:
#         newdict[v] = k
# print(newdict)

# 字典推導(dǎo)式完成  {2: 'b', 4: 'd'}
newdict = {v:k for k,v in vardict.items() if v % 2 == 0}
# print(newdict)

集合

• 確定的一組無序的數(shù)據(jù)的組合

• 確定的？ 當(dāng)前集合中元素的值不能重復(fù)
• 由多個數(shù)據(jù)組合的復(fù)合型數(shù)據(jù)（容器類型數(shù)據(jù)）
• 集合中的數(shù)據(jù)沒有順序
• 功能：成員檢測弄诲、從序列中去除重復(fù)項以及數(shù)學(xué)中的集合類計算炊昆，例如交集、并集威根、差集與對稱差集等等凤巨。

• 集合的定義

• 可以直接使用 {} 來定義集合
• 可以使用set()進(jìn)行集合的定義和轉(zhuǎn)換
• 使用集合推導(dǎo)式完成集合的定義

注意：集合中的元素不能重復(fù)，集合中存放的數(shù)據(jù)：Number,Strings,Tuple,冰凍集合

• 集合的基本操作和常規(guī)函數(shù)

# 定義集合
vars = {123,'abc',False,'love',True,(1,2,3),0,3.1415,'123'}
# 1洛搀。無序敢茁。
# 2。布爾類型 True 表示為 1留美，F(xiàn)alse 表示為 0彰檬，布爾和數(shù)字只存在一個
# 3。元素的值不能重復(fù)
# {0, 'abc', 'love', True, 3.1415, (1, 2, 3), 123}

# 檢測集合中的值
res = '123' in vars
res = '123' not in vars

# 獲取集合中元素的個數(shù) len()
# res = len(vars)

# 集合的遍歷
# for i in vars:
#     print(i,type(i))

# 向集合中追加元素 add()
res = vars.add('def')

# 刪除集合中的元素 隨機刪除一個元素并返回  abc False True 3.1415
# r1 = vars.pop()


# 指定刪除集合中的元素 remove() 返回None谎砾，不存在則報錯
# res = vars.remove('aaa')

# discard 指定刪除集合中的元素逢倍，不存在也不會報錯
# res = vars.discard('aaa')

# clear() 清空集合
# res = vars.clear()

# update(others) 更新集合，添加來自 others 中的所有元素景图。
res = vars.update({1,2,3,4,5})

#  當(dāng)前集合中的淺拷貝并不存在 深拷貝的問題
res = vars.copy()
'''
當(dāng)前集合中的淺拷貝并不存在 深拷貝的問題
    因為集合中的元素都是不可變较雕，包括元組和冰凍集合
    不存在拷貝后，對集合中不可變的二級容器進(jìn)行操作的問題
'''

• 集合的推導(dǎo)式

# 集合推導(dǎo)式
varset = {1,2,3,4}
# (1) 普通推導(dǎo)式
newset = {i<<1 for i in varset }

# (2) 帶有條件表達(dá)式的推導(dǎo)式
newset = {i<<1 for i in varset if i%2==0}

# (3) 多循環(huán)的集合推導(dǎo)式
vars1 = {1,2,3}
vars2 = {4,5,6}
# newset = set()
# for i in vars1:
#     for j in vars2:
#         print(i,j)
#         newset.add(i+j)
# print(newset)

newset = {i+j for i in vars1 for j in vars2}
# print(newset)

# (4) 帶條件表達(dá)式的多循環(huán)的集合推導(dǎo)式
newset = {i+j for i in vars1 for j in vars2 if i%2==0 and j%2==0}
print(newset)

• 集合的主要運算

• 交集 & set.intersection() set.intersection_update()
• 并集 | union() update()
• 差集 - difference(),difference_update()
• 對稱差集 ^ symmetric_difference() symmetric_difference_update()

vars1 = {'郭富城','劉德華','張學(xué)友','黎明','都敏俊',1}
vars2 = {'尼古拉斯趙四','劉能','小沈陽','宋小寶','都敏俊',1}

#  & 求兩個集合相交的部分
res = vars1 & vars2

# | 求兩個集合的并集挚币，就是把集合中所有元素全部集中起來亮蒋，（去除重復(fù)）
res = vars1 | vars2

# - 差集運算
res = vars1 - vars2 # vars1有，而妆毕，vars2 沒有的
res = vars2 - vars1 # vars2有慎玖，而，vars1 沒有的

# ^ 對稱差集
res = vars1 ^ vars2

# 交集運算函數(shù) intersection  intersection_update
# set.intersection()  # 返回交集的結(jié)果 新的集合
# res = vars1.intersection(vars2)

# set.intersection_update()  # 沒有返回值
# 計算兩個集合的相交部分笛粘，把計算結(jié)果重新賦值給第一個集合
# res = vars1.intersection_update(vars2)


# 并集運算函數(shù)  |    union()  update()
# res = vars1.union(vars2)  # 返回并集結(jié)果趁怔，新的集合
# 求并集運算，并且把結(jié)果賦值給第一個集合
# res = vars1.update(vars2) # 沒有返回值
# print(vars1)


# 差集運算  函數(shù) difference(),difference_update()
# res = vars1.difference(vars2) # 返回差集結(jié)果  新的集合
# 把差集的結(jié)果薪前，重新賦值給第一個集合
# res = vars1.difference_update(vars2) # 沒有返回值

# 求對稱差集
# res = vars1.symmetric_difference(vars2) # 返回對稱差集的結(jié)果  新的集合

# 把對稱差集的運算結(jié)果润努，重新賦值給第一個集合
res = vars1.symmetric_difference_update(vars2)# 沒有返回值

• 集合檢測

• issuperset() 檢測是否為超集
• issubset() 檢測是否為子集
• isdisjoint() 檢測是否不相交

# 檢測 超集  子集
vars1 = {1,2,3,4,5,6,7,8,9}
vars2 = {1,2,3}

# issuperset() 檢測是否為超集
res = vars1.issuperset(vars2)  # True  vars1是vars2的超集
res = vars2.issuperset(vars1)  # False

# issubset() 檢測是否為子集
res = vars1.issubset(vars2) #  False
res = vars2.issubset(vars1) #  True vars2是vars1的子集

# 檢測兩個集合是否相交
vars1 = {1,2,3}
vars2 = {5,6,3}
# isdisjoint 檢測是否不相交， 不相交返回True序六，相交則返回False
res = vars1.isdisjoint(vars2)
print(res)