# 1、定義：
# 1.1 整型int的定義
age=10  # 本質(zhì)age = int(10)

# 1.2 浮點(diǎn)型float的定義
salary=3000.3  # 本質(zhì)salary=float(3000.3)

# 注意：名字+括號(hào)的意思就是調(diào)用某個(gè)功能，比如
# print(...)調(diào)用打印功能
# int(...)調(diào)用創(chuàng)建整型數(shù)據(jù)的功能
# float(...)調(diào)用創(chuàng)建浮點(diǎn)型數(shù)據(jù)的功能

# 1、數(shù)據(jù)類型轉(zhuǎn)換
# 1.1 int可以將由純整數(shù)構(gòu)成的字符串直接轉(zhuǎn)換成整型，若包含其他任意非整數(shù)符號(hào)，則會(huì)報(bào)錯(cuò)
>>> s = '123'
>>> res = int(s)
>>> res,type(res)
(123, <class 'int'>)

>>> int('12.3') # 錯(cuò)誤演示：字符串內(nèi)包含了非整數(shù)符號(hào).
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'
        
# 1.2 float同樣可以用來(lái)做數(shù)據(jù)類型的轉(zhuǎn)換
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

# 定義：在單引號(hào)\雙引號(hào)\三引號(hào)內(nèi)包含一串字符
name1 = 'jason'  # 本質(zhì):name = str('任意形式內(nèi)容')
name2 = "lili"  # 本質(zhì):name = str("任意形式內(nèi)容")
name3 = """ricky"""  # 本質(zhì):name = str("""任意形式內(nèi)容""")

# 數(shù)據(jù)類型轉(zhuǎn)換：str()可以將任意數(shù)據(jù)類型轉(zhuǎn)換成字符串類型，例如 
>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3)))  # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>

>>> str1 = 'hello python!'


# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(從左往右)
>>> str1[6]
p
# 1.2 反向取(負(fù)號(hào)表示從右往左)
>>> str1[-4]
h
# 1.3 對(duì)于str來(lái)說(shuō)，只能按照索引取值，不能改
>>> str1[0]='H' # 報(bào)錯(cuò)TypeError


# 2.切片(顧頭不顧尾，步長(zhǎng))
# 2.1 顧頭不顧尾：取出索引為0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步長(zhǎng)：0:9:2,第三個(gè)參數(shù)2代表步長(zhǎng)，會(huì)從0開始，每次累加一個(gè)2即可，所以會(huì)取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
# 2.3 反向切片
>>> str1[::-1]  # -1表示從右往左依次取值
!nohtyp olleh

# 3.長(zhǎng)度len
# 3.1 獲取字符串的長(zhǎng)度，即字符的個(gè)數(shù)，但凡存在于引號(hào)內(nèi)的都算作字符)
>>> len(str1) # 空格也算字符
13

# 4.成員運(yùn)算 in 和 not in	
# 4.1 int:判斷hello 是否在 str1里面
>>> 'hello' in str1  
True
# 4.2 not in:判斷tony 是否不在 str1里面
>>> 'tony' not in str1 
True

# 5.strip移除字符串首尾指定的字符(默認(rèn)移除空格)
# 5.1 括號(hào)內(nèi)不指定字符，默認(rèn)移除首尾空格
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!

# 5.2 括號(hào)內(nèi)指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony

# 6.切分split
# 6.1 括號(hào)內(nèi)不指定字符，默認(rèn)以空格作為切分符號(hào)
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括號(hào)內(nèi)指定分隔字符，則按照括號(hào)內(nèi)指定的字符切割字符串
>>> str4 = '127.0.0.1'
>>> str4.split('.')  
['127', '0', '0', '1']  # 注意:split切割得到的結(jié)果是列表數(shù)據(jù)類型


# 7.循環(huán)
>>> str5 = '今天你好嗎？'
>>> for line in str5:  # 依次取出字符串中每一個(gè)字符
...     print(line)
...
今
天
你
好
嗎
？

>>> str1 = '**tony***'

>>> str1.strip('*')  # 移除左右兩邊的指定字符
'tony'
>>> str1.lstrip('*')  # 只移除左邊的指定字符
tony***
>>> str1.rstrip('*')  # 只移除右邊的指定字符
**tony

>>> str2 = 'My nAme is tonY！'

>>> str2.lower()  # 將英文字符串全部變小寫
my name is tony！
>>> str2.upper()  # 將英文字符串全部變大寫
MY NAME IS TONY！

>>> str3 = 'tony jam'

# startswith()判斷字符串是否以括號(hào)內(nèi)指定的字符開頭，結(jié)果為布爾值True或False
>>> str3.startswith('t') 
True
>>> str3.startswith('j')
False
# endswith()判斷字符串是否以括號(hào)內(nèi)指定的字符結(jié)尾，結(jié)果為布爾值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')  
False

# format括號(hào)內(nèi)在傳參數(shù)時(shí)完全可以打亂順序，但仍然能指名道姓地為指定的參數(shù)傳值，name=‘tony'就是傳給{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'

>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'

# 類似于%s的用法，傳入的值會(huì)按照位置與{}一一對(duì)應(yīng)
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4 
my name is tony, my age is 18!

# 把format傳入的多個(gè)值當(dāng)作一個(gè)列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!

>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4  
my name is 18, my age is tony!

>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4  
my name is 18, my age is 18!

# split會(huì)按照從左到右的順序?qū)ψ址M(jìn)行切分，可以指定切割次數(shù)
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  

# rsplit剛好與split相反，從右往左切割，可以指定切割次數(shù)
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']

# 從可迭代對(duì)象中取出多個(gè)字符串，然后按照指定的分隔符進(jìn)行拼接，拼接的結(jié)果為字符串
>>> '%'.join('hello') # 從字符串'hello'中取出多個(gè)字符串，然后按照%作為分隔符號(hào)進(jìn)行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 從列表中取出多個(gè)字符串，然后按照*作為分隔符號(hào)進(jìn)行拼接
'tony|18|read'

# 用新的字符替換字符串中舊的字符
>>> str7 = 'my name is tony, my age is 18!'  # 將tony的年齡由18歲改成73歲
>>> str7 = str7.replace('18', '73')  # 語(yǔ)法:replace('舊內(nèi)容', '新內(nèi)容')
>>> str7
my name is tony, my age is 73!

# 可以指定修改的個(gè)數(shù)
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一個(gè)my改為MY
>>> str7
'MY name is tony, my age is 18!'

# 判斷字符串是否是純數(shù)字組成，返回結(jié)果為True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True

>>> str8 = '123g123'
>>> str8.isdigit()
False

# 1.find,rfind,index,rindex,count
# 1.1 find：從指定范圍內(nèi)查找子字符串的起始索引，找得到則返回?cái)?shù)字1，找不到則返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引為1和2(顧頭不顧尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到時(shí)會(huì)報(bào)錯(cuò)
>>> msg.index('e',2,4) # 報(bào)錯(cuò)ValueError
# 1.3 rfind與rindex：略
# 1.4 count:統(tǒng)計(jì)字符串在大字符串中出現(xiàn)的次數(shù)
>>> msg = "hello everyone"
>>> msg.count('e')  # 統(tǒng)計(jì)字符串e出現(xiàn)的次數(shù)
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范圍內(nèi)出現(xiàn)的次數(shù)
1

# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-')  # 總寬度為30，字符串居中顯示，不夠用-填充
-------------tony-------------
>>> name.ljust(30,'*')  # 總寬度為30，字符串左對(duì)齊顯示，不夠用*填充
tony**************************
>>> name.rjust(30,'*')  # 總寬度為30，字符串右對(duì)齊顯示，不夠用*填充
**************************tony
>>> name.zfill(50)  # 總寬度為50，字符串右對(duì)齊顯示，不夠用0填充
0000000000000000000000000000000000000000000000tony

# 3.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab鍵)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格數(shù)
tony hello

# 4.captalize,swapcase,title
# 4.1 captalize：首字母大寫
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小寫翻轉(zhuǎn)
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每個(gè)單詞的首字母大寫
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 

# 5.is數(shù)字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中無(wú)需加u就是unicode
num3 = '四' #中文數(shù)字
num4 = 'Ⅳ' #羅馬數(shù)字

#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False

#isdecimal:uncicode(bytes類型無(wú)isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False

#isnumberic:unicode,中文數(shù)字,羅馬數(shù)字(bytes類型無(wú)isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True

# 三者不能判斷浮點(diǎn)數(shù)
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False

'''
總結(jié):
	最常用的是isdigit,可以判斷bytes和unicode類型,這也是最常見的數(shù)字應(yīng)用場(chǎng)景
	如果要判斷中文數(shù)字或羅馬數(shù)字,則需要用到isnumeric。
'''

# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含數(shù)字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是純小寫
True
>>> name.isupper()  # 字符串是否是純大寫
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的單詞首字母是否都是大寫
False

# 定義：在[]內(nèi),用逗號(hào)分隔開多個(gè)任意數(shù)據(jù)類型的值
l1 = [1,'a',[1,2]]  # 本質(zhì):l1 = list([1,'a',[1,2]])

# 但凡能被for循環(huán)遍歷的數(shù)據(jù)類型都可以傳給list()轉(zhuǎn)換成列表類型，list()會(huì)跟for循環(huán)一樣遍歷出數(shù)據(jù)類型中包含的每一個(gè)元素然后放到列表中
>>> list('wdad') # 結(jié)果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 結(jié)果：[1, 2, 3]
>>> list({"name":"jason","age":18}) #結(jié)果：['name', 'age']
>>> list((1,2,3)) # 結(jié)果：[1, 2, 3] 
>>> list({1,2,3,4}) # 結(jié)果：[1, 2, 3, 4]

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
# 1.1 正向取(從左往右)
>>> my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]  
tony
# 1.2 反向取(負(fù)號(hào)表示從右往左)
>>> my_friends[-1]  
5
# 1.3 對(duì)于list來(lái)說(shuō)，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在則報(bào)錯(cuò)
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]


# 2.切片(顧頭不顧尾，步長(zhǎng))
# 2.1 顧頭不顧尾：取出索引為0到3的元素
>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]
# 2.2 步長(zhǎng)：0:4:2,第三個(gè)參數(shù)2代表步長(zhǎng)，會(huì)從0開始，每次累加一個(gè)2即可，所以會(huì)取出索引0、2的元素
>>> my_friends[0:4:2]  
['tony', 'tom']

# 3.長(zhǎng)度
>>> len(my_friends)
5

# 4.成員運(yùn)算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

# 5.添加
# 5.1 append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']

# 5.2 extend()一次性在列表尾部添加多個(gè)元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']

# 5.3 insert()在指定位置插入元素
>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c']

# 6.刪除
# 6.1 del
>>> l = [11,22,33,44]
>>> del l[2]  # 刪除索引為2的元素
>>> l
[11,22,44]

# 6.2 pop()默認(rèn)刪除列表最后一個(gè)元素，并將刪除的值返回，括號(hào)內(nèi)可以通過加索引值來(lái)指定刪除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22

# 6.3 remove()括號(hào)內(nèi)指名道姓表示要?jiǎng)h除哪個(gè)元素，沒有返回值
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 從左往右查找第一個(gè)括號(hào)內(nèi)需要?jiǎng)h除的元素
>>> print(res)
None

# 7.reverse()顛倒列表內(nèi)元素順序
>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]

# 8.sort()給列表內(nèi)所有元素排序
# 8.1 排序時(shí)列表元素之間必須是相同數(shù)據(jù)類型，不可混搭，否則報(bào)錯(cuò)
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默認(rèn)從小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用來(lái)指定是否跌倒排序，默認(rèn)為False
>>> l 
[55, 42, 22, 11, 7, 3]
# 8.2 了解知識(shí)：
# 我們常用的數(shù)字類型直接比較大小，但其實(shí)，字符串、列表等都可以比較大小，原理相同：都是依次比較對(duì)應(yīng)位置的元素的大小，如果分出大小，則無(wú)需比較下一個(gè)元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之間的大小取決于它們?cè)贏SCII表中的先后順序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1與s2的第一個(gè)字符沒有分出勝負(fù)，但第二個(gè)字符'z'>'b',所以s2>s1成立
True
# 所以我們也可以對(duì)下面這個(gè)列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']

# 9.循環(huán)
# 循環(huán)遍歷my_friends列表里面的值
for line in my_friends:
	print(line) 
'tony'
'jack'
'jason'
4
5

>>> l=[1,2,3,4,5,6]
>>> l[0:3:1] 
[1, 2, 3]  # 正向步長(zhǎng)
>>> l[2::-1] 
[3, 2, 1]  # 反向步長(zhǎng)

# 通過索引取值實(shí)現(xiàn)列表翻轉(zhuǎn)
>>> l[::-1]
[6, 5, 4, 3, 2, 1]

# 在()內(nèi)用逗號(hào)分隔開多個(gè)任意類型的值
>>> countries = ("中國(guó)"，"美國(guó)"，"英國(guó)")  # 本質(zhì):countries = tuple("中國(guó)"，"美國(guó)"，"英國(guó)")
# 強(qiáng)調(diào)：如果元組內(nèi)只有一個(gè)值，則必須加一個(gè)逗號(hào)，否則()就只是包含的意思而非定義元組
>>> countries = ("中國(guó)"，)  # 本質(zhì):countries = tuple("中國(guó)")

# 但凡能被for循環(huán)的遍歷的數(shù)據(jù)類型都可以傳給tuple()轉(zhuǎn)換成元組類型
>>> tuple('wdad') # 結(jié)果：('w', 'd', 'a', 'd') 
>>> tuple([1,2,3]) # 結(jié)果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 結(jié)果：('name', 'age')
>>> tuple((1,2,3)) # 結(jié)果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 結(jié)果：(1, 2, 3, 4)
# tuple()會(huì)跟for循環(huán)一樣遍歷出數(shù)據(jù)類型中包含的每一個(gè)元素然后放到元組中

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否則報(bào)錯(cuò)！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 報(bào)錯(cuò)：TypeError:

# 2、切片(顧頭不顧尾，步長(zhǎng))
>>> tuple1[0:6:2] 
(1, 15000.0, 22)

# 3、長(zhǎng)度
>>> len(tuple1)  
6

# 4、成員運(yùn)算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 

# 5、循環(huán)
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

# 定義：在{}內(nèi)用逗號(hào)分隔開多元素，每一個(gè)元素都是key:value的形式，其中value可以是任意類型，而key則必須是不可變類型，詳見第八小節(jié)，通常key應(yīng)該是str類型，因?yàn)閟tr類型會(huì)對(duì)value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本質(zhì)info=dict({....})
# 也可以這么定義字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

# 轉(zhuǎn)換1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}

# 轉(zhuǎn)換2：fromkeys會(huì)從元組中取出每個(gè)值當(dāng)做key，然后與None組成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 對(duì)于賦值操作，如果key原先不存在于字典，則會(huì)新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 對(duì)于賦值操作，如果key原先存在于字典，則會(huì)修改對(duì)應(yīng)value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}


# 2、長(zhǎng)度len
>>> len(dic) 
3


# 3、成員運(yùn)算in和not in
>>> 'name' in dic  # 判斷某個(gè)值是否是字典的key
True


# 4、刪除
>>> dic.pop('name')  # 通過指定字典的key來(lái)刪除字典的鍵值對(duì)
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}


# 5、鍵keys()，值values()，鍵值對(duì)items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 獲取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 獲取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 獲取字典所有的鍵值對(duì)
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])


# 6、循環(huán)
# 6.1 默認(rèn)遍歷的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍歷key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍歷value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍歷key與value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，則獲取key對(duì)應(yīng)的value值
>>> res=dic.get('xxx') # key不存在，不會(huì)報(bào)錯(cuò)而是默認(rèn)返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在時(shí)，可以設(shè)置默認(rèn)返回的值
>>> print(res)
666 
# ps:字典取值建議使用get方法

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 刪除指定的key對(duì)應(yīng)的鍵值對(duì),并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 隨機(jī)刪除一組鍵值對(duì),并將刪除的鍵值放到元組內(nèi)返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')

# 用新字典更新舊字典，有則修改，無(wú)則添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

# key不存在則新增鍵值對(duì)，并將新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了鍵值對(duì)
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在則不做任何修改，并返回已存在key對(duì)應(yīng)的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不變
{'k1': 111, 'k2': 222}

"""
定義：在{}內(nèi)用逗號(hào)分隔開多個(gè)元素，集合具備以下三個(gè)特點(diǎn)：
     1：每個(gè)元素必須是不可變類型
     2：集合內(nèi)沒有重復(fù)的元素
     3：集合內(nèi)元素?zé)o序
"""
s = {1,2,3,4}  # 本質(zhì) s = set({1,2,3,4})

# 注意1：列表類型是索引對(duì)應(yīng)值，字典是key對(duì)應(yīng)值，均可以取得單個(gè)指定的值，而集合類型既沒有索引也沒有key與值對(duì)應(yīng)，所以無(wú)法取得單個(gè)的值，而且對(duì)于集合來(lái)說(shuō)，主要用于去重與關(guān)系元素，根本沒有取出單個(gè)指定值這種需求。

# 注意2:{}既可以用于定義dict，也可以用于定義集合，但是字典內(nèi)的元素必須是key:value的格式，現(xiàn)在我們想定義一個(gè)空字典和空集合，該如何準(zhǔn)確去定義兩者?
d = {} # 默認(rèn)是空字典 
s = set() # 這才是定義空集合

# 但凡能被for循環(huán)的遍歷的數(shù)據(jù)類型（強(qiáng)調(diào)：遍歷出的每一個(gè)值都必須為不可變類型）都可以傳給set()轉(zhuǎn)換成集合類型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

>>> friends1 = {"zero","kevin","jason","egon"} # 用戶1的好友們 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用戶2的好友們

# 1.合集(|)：求兩個(gè)用戶所有的好友（重復(fù)好友只留一個(gè)）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求兩個(gè)用戶的共同好友
>>> friends1 & friends2
{'jason', 'egon'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用戶1獨(dú)有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用戶2獨(dú)有的好友
{'ricky', 'Jy'}

# 4.對(duì)稱差集(^) # 求兩個(gè)用戶獨(dú)有的好友們（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一個(gè)集合是否包含另外一個(gè)集合
# 6.1 包含則返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含關(guān)系，則返回True
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False


# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

# 1. 只能針對(duì)不可變類型
# 2. 集合本身是無(wú)序的，去重之后無(wú)法保留原來(lái)的順序

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 將列表轉(zhuǎn)成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再將集合轉(zhuǎn)回列表
>>> l_new
['b', 'a', 1] # 去除了重復(fù)，但是打亂了順序

# 針對(duì)不可變類型，并且保證順序則需要我們自己寫代碼實(shí)現(xiàn)，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 結(jié)果：既去除了重復(fù)，又保證了順序，而且是針對(duì)不可變類型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

# 1.長(zhǎng)度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成員運(yùn)算
>>> 'c' in s
True

# 3.循環(huán)
>>> for item in s:
...     print(item)
... 
c
a
b

"""
一.關(guān)系運(yùn)算
　　有如下兩個(gè)集合，pythons是報(bào)名python課程的學(xué)員名字集合，linuxs是報(bào)名linux課程的學(xué)員名字集合
　　pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即報(bào)名python又報(bào)名linux課程的學(xué)員名字集合
　　2. 求出所有報(bào)名的學(xué)生名字集合
　　3. 求出只報(bào)名python課程的學(xué)員名字
　　4. 求出沒有同時(shí)這兩門課程的學(xué)員名字集合
"""
# 求出即報(bào)名python又報(bào)名linux課程的學(xué)員名字集合
>>> pythons & linuxs
# 求出所有報(bào)名的學(xué)生名字集合
>>> pythons | linuxs
# 求出只報(bào)名python課程的學(xué)員名字
>>> pythons - linuxs
# 求出沒有同時(shí)這兩門課程的學(xué)員名字集合
>>> pythons ^ linuxs

>>> x = 10
>>> id(x)
1830448896 
>>> x = 20
>>> id(x)
1830448928
# 內(nèi)存地址改變了，說(shuō)明整型是不可變數(shù)據(jù)類型，浮點(diǎn)型也一樣

>>> x = "Jy"
>>> id(x)
938809263920 
>>> x = "Ricky"
>>> id(x)
938809264088
# 內(nèi)存地址改變了，說(shuō)明字符串是不可變數(shù)據(jù)類型

>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 對(duì)列表的值進(jìn)行操作時(shí)，值改變但內(nèi)存地址不變，所以列表是可變數(shù)據(jù)類型

>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 報(bào)錯(cuò)：TypeError
>>> t1.append('lili') # 報(bào)錯(cuò)：TypeError
# 元組內(nèi)的元素?zé)o法修改，指的是元組內(nèi)索引指向的內(nèi)存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元組中存在可變類型，是可以修改，但是修改后的內(nèi)存地址不變
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不變
(4327403152, 4327403072, 4327422472)

>>> dic = {'name':'egon','sex':'male','age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 對(duì)字典進(jìn)行操作時(shí)，值改變的情況下，字典的id也是不變，即字典也是可變數(shù)據(jù)類型