一.數據類型
1.1 數字類型
1.1.1 整數 int 例子：age=18 完整寫法 age=int(18) #用來表示整數
用途：表示整數相關的比如：年齡，等級，編號
定義方式：age=18，level=10，num=999
n=int('123123123') #整數類型只能對字符串內的數字轉換爲整數，不能加小數點或者字符串
1.1.2 浮點性 float 例子：age=18.1 完整寫法 age=float(18.1) #用來表示小數點
n = float('121111') #浮點性只能對字符串內的數字或者帶小數點(最多一個小數點)的數字轉換爲浮點型
總結：int 與float類型
1.只能存一個值 2.屬於不可變類型
1.2 字符串類型 str
1.用來表示描述性的東西等~
2.定義方式：name='sudada' #定義字符串類型需要加引號 (單 ''，雙 ""，三 (''' ''' 或 """ """))
name='sudada'
print(type(name))
<class 'str'>
反而言之：name="111111" 引號內"111111"也被定義爲字符串類型，或者說加了引號的內容都被認爲是字符串
當一段內容裏面有單引號和雙引號時：
怎麼區分：外面用單引號裏面就用雙引號，反之亦然
name='my name is "szq"'
print(name)
my name is "szq"
1.2.1 字符串str的常用操作和內置方法
1.2.1.1 字符串str優先掌握的操作：
1、按索引取值(正向取+反向取) ：只能取，不能修改索引值
msg='hello'
msg[1]='E'
print(msg)
運行後會報錯：提示字符串不能修改
TypeError: 'str' object does not support item assignment
2、切片--顧頭不顧尾([0:3]切片時不能取到最後一個索引值)，切片--步長([0:3:2]隔2個步長取一個索引值)
切片與切分的區別：1.切片是按照索引取值，切分(split)是指定分隔符取值
2.切片後得到的值爲"字符串類型"，切分(split)後得到的值爲"列表類型"，可將字符串類型的數據通過切分(split)轉換爲列表類型的數據。
msg='hello world'
print(msg[0:9]) #從'hello world'中取值,取從0開始9結束的索引值
運行後得到 hello wor
print(msg[0:9:2]) #從'hello world'這個值的[0-9]索引數據中取值,每隔2個步長取一個值
運行後得到 hlowr
msg='hello world'
print(msg.split()) #默認以空格分隔
運行後得到['hello', 'world']
例子如下：切片([0:9])後得到的值爲"字符串類型"，切分(split)後得到的值爲"列表類型"
msg='hello world'
print(type(msg[0:9])) 運行後得到 <class 'str'>
print(type(msg.split(' '))) 運行後得到 <class 'list'>
3、長度len #查看字符串的長度(有幾個字符串)
msg = 'hello world'
print(len(msg))
運行後得到
11
4、成員運算in和not in #判斷某一個值(字符串)是否存在與一個變量中 in 表示存在，not in 表示不存在。
msg='szq is baby'
print('szq' in msg) 運行後得到 True
print('szq' not in msg) 運行後得到 False
5、移除空白strip strip 首先設定一些需要被移除的字符，然後strip從左右兩邊開始匹配，當左右兩邊的任意一個值不等於被移除的字符，那麼匹配結束。
舉例說明：
5.1、name='*** szq* /**'，現在我要保留'szq'這個值
name="****_szq**/*"
res=name.strip('*_/')
print(res)
szq #打印後得到的值爲"szq"，而字符"szq"左右兩邊的其他符號" * /"都被移除了
5.2、name='s / *** szq* /**'，現在我要保留'szq'這個值
name='s / *** szq* /**'
res=name.strip('* /')
print(res)
s / *** szq
這裏得到的值爲"s / *** szq"，因爲strip('* /')(要移除的字符爲'* /')，而左邊的第一個字符爲"s"，那麼左邊就不滿足匹配條件，右邊第一個字符爲"*"，屬於要移除的字符，那麼繼續往左一直到字符"q"這裏時結束，因爲字符"q"，不屬於移除的字符
5.3、name='s / *** szq* /**'，設置name.strip('* s')，需要移除的字符爲"* s"
name='s / *** szq* /**'
res=name.strip('* s')
print(res)
/ *** szq* /
這裏得到的值爲"/ *** szq* /"，strip('* s')(要移除的字符爲'* s')，從左邊開始匹配，第一個不滿足的是"/"，那麼左邊的匹配結束，然後從右邊開始，第一個不滿足的是"/"，那麼右邊的匹配結束
6、切分-split(Python內置參數) #msg.split() 默認以"空格"爲分隔符 msg.split() == msg.split(' ')
msg='root:x:0:0::/root:/bin/bash'
res=msg.split(':') #對變量"msg"的值進行切分,以":(冒號)"爲分隔符
print(res)
運行後得到一個新的值：(id，值都會發生改變)
['root', 'x', '0', '0', '', '/root', '/bin/bash'] #這裏看出,原值已被修改,:(冒號)已替換爲逗號分隔
#split把字符串切分成了一個列表
7、循環
name='szq'
for n in name: #相當於：for n in 'szq'
print(n)
>>：s
>>：z
>>：q
這裏可以看出，for循環內，對變量n依次賦值爲"szq"(依次賦值爲"s" "z" "q")，那麼在取變量n的值的時候，就能夠依次取出"s" "z" "q"多個值
8、實踐用法
while True:
cmd=input('>>:').strip() #把用戶輸入的"空"值都給移除掉(空格也被包含在內)
#cmd=cmd.strip()
if len(cmd) == 0 :continue #配置len使用,只用輸入的值不爲"空"時，程序纔會做出迴應
elif cmd == 'q':break
print('%s is running' %(cmd))
這段代碼的意思是：除了輸入"q"將退出外，無論輸入任何空的值，都將跳過(可以理解爲Xshell裏面再命令行裏面一直敲回車或者空格時，Xshell並不會迴應任何類容)
1.2.1.2 字符串str需要掌握的操作：
strip的多種用法：lstrip和rstrip，lstrip:移除左邊指定的字符串，rstrip:移除右邊指定的字符串
name='**********sudada////'
lres=name.lstrip('*') #移除字符串"**********sudada////",左邊所有的字符"*"
rres=name.rstrip('/') #移除字符串"**********sudada////",右邊所有的字符"/"
print(lres)
print(rres)
>>：sudada////
>>：**********sudada
lower和upper的用法：lower將大寫的字符串改爲小寫，upper將小寫的字符串改爲大寫
msg='Abc'
print(msg)
print(msg.lower())
print(msg.upper())
>>：Abc #原值不會受到影響
>>：abc #使用lower後，大寫的字符串會改爲小寫
>>：ABC #使用upper後，小寫的字符串會改爲大寫
startswith和endswith的用法：startswith:以~~開頭，endswith:以~~結尾
msg='my name is sudada'
print(msg.startswith('my')) #判斷當前字符串是否以字符串"my"開頭
print(msg.endswith('da')) #判斷當前字符串是否以字符串"da"結尾
>>：True
>>：True
format格式化輸出的三種玩法：在這裏我們使用第3種用法 --可自定義的格式化輸出
print('my name is %s my age is %s' %('sudada',18)) #格式化輸出%s的用法
>>：my name is sudada my age is 18
print('my name is {} my age is {}'.format('sudada',18)) #{}不指定內容,在傳參時會根據.format('sudada',18)的值來依次傳參
>>：my name is sudada my age is 18
print('my name is {name} my age is {age}'.format(name='sudada',age=18)) #{}指定了變量名"{name}",在傳參時會根據變量名這隻的值來傳參
>>：my name is sudada my age is 18 #使用這種方式
split與rsplit：split從左往右切分，rsplit從右往左切分 #split把字符串切分成了一個列表
info='root:0:0::/root:/bin/bash'
print(info.split(':',1)) #split設置切分的分隔符爲":"(冒號)，從左往右切分1次
>>：['root', '0:0::/root:/bin/bash'] #第一個切分出來的當做一個值，後面剩餘所有值當做一個值
print(info.rsplit(':',1)) #rsplit設置切分的分隔符爲":"(冒號)，從右往左切分1次
>>：['root:0:0::/root', '/bin/bash']
print(info.split(':',-1)) #split(':')不加切分次數，默認切分所有
>>：['root', '0', '0', '', '/root', '/bin/bash']
join的用法：把列表拼接成字符串(與split相反) # join只能用於值全都爲字符串的列表，如果列表中的某一個值爲數字或其他，則會報錯！
a=['root', '0', '0', '', '/root', '/bin/bash'] #這是一個列表
a_list=':'.join(a) #指定分隔符爲":"(冒號)，join(a)：可以理解爲"join(['root', '0', '0', '', '/root', '/bin/bash'])"
print(a_list)
# >>：root:0:0::/root:/bin/bash
b_list=':::'.join(a) #指定分隔符爲":::"(冒號)，join(a)：可以理解爲"join(['root', '0', '0', '', '/root', '/bin/bash'])"
print(b_list)
# >>：root:::0:::0::::::/root:::/bin/bash
例子：join與split功能對比使用
linux="root:/bin/bash:/sbin/:/usr/bin/"
print(linux.split(":"))
# ['root', '/bin/bash', '/sbin/', '/usr/bin/']
linux_list=['root', '/bin/bash', '/sbin/', '/usr/bin/']
data=":".join(linux_list)
print(data)
# root:/bin/bash:/sbin/:/usr/bin/
replace的用法：將一個值替換成另外一個值
msg='wsp say name is wsp'
print(msg.replace('wsp','SB')) #把"wsp"替換成"SB"，默認替換所有的值
>>：SB say name is SB
print(msg.replace('wsp','SB',1)) #只對第一個"wsp"替換成"SB"
>>：SB say name is wsp
isdigit的用法：判斷一個值的內容是否全爲數字，例子"aaa123123aaa":這個就不滿足
while True:
age=input('>>:').strip()
if not age.isdigit():continue #判斷輸入的值是否爲數字，如果不爲數字的話，那麼就continue，重新輸入
age=int(age)
if age > 30:
print('too big')
elif age < 30:
print('too small')
else:
print('success')
1.2.1.3、字符串str總結
1.字符串只能存一個值，因爲字符串是一個整體，也可以把字符串當做一個列表，通過索引取值
2.字符串屬於有序(能夠通過索引取值的都可以稱爲"有序")
3.字符串屬於不可變類型(無論通過lower或upper或split或者strip，它的原值一直沒有發生任何改變)
1.3 列表類型 list
作用：存放多個值，存取按照索引來獲取值 status[0],status[1]，0代表第一個位置，1代表第二個位置
定義：在[]內，用逗號分開多個值，每個值可以是任意數據類型
打印一個列表的值：print(變量名[索引])
例子1：定義一個列表
status=[1,'sudada',[1,2,'hah']] #定義一個變量status,賦值爲 [1,'sudada',[1,2,'hah']]
print(status[0]) #取第1個值 status[0] #類似Shell裏面的數組
print(status[1]) #取第2個值 status[1]
print(status[2]) #取第3個值 status[2]
print(status) #取全部的值
print(type(status)) #取類型
1 #取第1個值
sudada #取第2個值
[1, 2, 'hah'] #取第3個值
[1, 'sudada', [1, 2, 'hah']] #取全部的值
<class 'list'> #打印類型
例子2：當列表裏面定義列表，並取列表的值
szq_info=['szq',18,['mutong',200,'shanghai']]
print(szq_info[1])
18 #print(szq_info[1]) #得到的值 18
print(szq_info[2])
['mutong', 200, 'shanghai'] #print(szq_info[2]) #得到的值 ['mutong', 200, 'shanghai']
shanghai
print(szq_info[2][2])
#print(szq_info[2][2]) #得到的值shanghai, #這裏就相當於取['mutong', 200, 'shanghai']這個列表裏面的第3個值
1.3.1 列表得取值多種用法
str = [1, 4, 5, 6, 7, 9, 11, 14, 16]
print(str[-1]) # 截取最後一個元素
print(str[0:3]) # 截取第一位到第三位的字符
print(str) # 截取字符串的全部字符
print(str[6:]) # 截取第七個字符到結尾
print(str[:-3]) # 截取從頭開始到倒數第三個字符之前
print(str[2]) # 截取第三個字符
print(str[::-1]) # 創造一個與原字符串順序相反的字符串
print(str[-3:-1]) # 截取倒數第三位與倒數第一位之前的字符
print(str[-3:]) # 截取倒數第三位到結尾
print(str[:-5:-3]) # 逆序截取後個數，每3個取一個，而且取是逆向取值
print(str[:10:2]) # 前10個數，每兩個取一個
Python -- 去除list中的空字符：
方法1：
Python內建filter()函數 - 過濾list
filter()把傳入的函數依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素
def not_empty(s):
return s and s.strip()
res = filter(not_empty, ['1', '', '2', None, '3', ' '])
# 結果: ['1', '2', '3']
方法2：
while '' in index:
index.remove('')
1.3.1 列表list的常用操作和內置方法
1.3.1.1 列表list優先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可以取也可以改(屬於可變類型)
sudada=['a','b','c','d','e','f']
print(sudada[-1]) #取倒數第一個索引的值
>>：f
print(id(sudada)) #sudada[0]未修改之前的ID
>>：2374574175368
sudada[0]='A'
print(sudada[0])
>>：A
print(id(sudada)) #sudada[0]修改過之後的ID
>>：2374574175368
對列表中的某一個值(sudada[0]='A')做修改之後，雖然值發生了改變，但是值的id不會改變，符合可變類型
注意：列表修改值得時候，只能對已存在的值進行修改，若值或者索引不存在，那麼不能修改
sudada=['a','b','c','d','e','f']
sudada[10]='A'
print(sudada[10])
報錯：IndexError: list assignment index out of range
2、切片(顧頭不顧尾，步長)
sudada=['aaaa','b','c','d','e','f']
print(sudada[0:5]) #取索引0-5的值(正向取值)
>>：['aaaa', 'b', 'c', 'd', 'e']
print(sudada[0:5:2]) #取索引0-5的值，每隔2個步長取一個值
>>：['aaaa', 'c', 'e']
print(sudada[-1::-1])
>>：['f', 'e', 'd', 'c', 'b', 'aaaa'] #把列表反向取值
反向索引--也要記住顧頭不顧尾：
sudada=['a','b','c','d','e','f']
print(sudada[5:0:-1]) #可以理解爲：取索引5-0的值(也就是反過來取值)
>>：['f', 'e', 'd', 'c', 'b']
print(sudada[5:0:-2]) #取索引5-0的值，每隔2個步長取一個值
>>：['f', 'd', 'b']
3、長度 len
sudada=['aaaa','b','c','d','e','f']
print(len(sudada))
>>：6 #可以理解爲索引的個數(或者說是字符串的個數)
4、成員運算in和not in #判斷某一個值(字符串)是否存在與一個變量中 in 表示存在，not in 表示不存在。
msg='sudada is baby'
print('sudada' in msg) 運行後得到 True
print('sudada' not in msg) 運行後得到 False
5、追加append 與插入insert
5.1 追加append：name.append('FFF') #從列表末尾開始追加內容
name=['aaa','bbb','ccc','ddd','eee'] #這裏5個索引值
name.append('FFF') #使用內置參數name.append('FFF')，往列表末尾追加一個索引內容'FFF'
print(name)
>>：['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'FFF'] #追加一個索引內容後的現實效果
5.2 插入insert：name.insert(2,'AAA') #根據指定的索引值插入，插入到指定的索引值前面
name=['aaa','bbb','ccc','ddd','eee']
name.insert(2,'AAA') #指定插入的內容在哪一個索引前面
print(name)
>>：['aaa', 'bbb', 'AAA', 'ccc', 'ddd', 'eee'] #插入後的效果
6、刪除列表中某一個元素 del
方法1：使用del指定列表的索引刪除 #這種方法不是列表特有的刪除方法
name=['aaa','bbb','ccc','ddd','eee']
del name[0] #可以使用del，然後指定列表的索引刪除
print(name)
>>：['bbb', 'ccc', 'ddd', 'eee']
方法2：name.remove('aaa') #指定要刪除的元素，remove方法沒有返回值
name=['aaa','bbb','ccc','ddd','eee']
name.remove('aaa')
print(name)
>> ：['bbb', 'ccc', 'ddd', 'eee']
name.remove(0) #使用name.remove刪除列表的元素是，刪除的元素必須是"in list"存在於列表中的，否則報錯如下
ValueError: list.remove(x): x not in list
方法3：從列表中取走一個值pop，被取走的值，可以被引用 # name.pop(0)，指定索引刪除，原值會改變
name=['aaa','bbb','ccc','ddd','eee']
name.pop(0) #按照索引刪除一個元素
print(name)
#>>：['bbb', 'ccc', 'ddd', 'eee'] #已經把列表的索引"0"刪除了
print(name.pop(0)) #刪除後有返回值(已經刪掉的元素)，超出索引則報錯
#>>：bbb
7、for 循環
name='szq'
for n in name: #相當於：for n in 'szq',把字符串'szq'的每一個字符單獨打印出來
print(n)
>>：s
>>：z
>>：q
這裏可以看出，for循環內，對變量n依次賦值爲"szq"(依次賦值爲"s" "z" "q")，那麼在取變量n的值的時候，就能夠依次取出"s" "z" "q"多個值
1.3.1.2 列表list需要掌握的操作：
1、反轉 reverse #反轉(修改列表的值，按照倒序排列，使用reverse後原值也會被修改)
name=['aaa','bbb','ccc','ddd','eee']
name.reverse() #反轉，把列表裏面的值倒序排列
print(name.reverse())
>>：None
print(name) #reverse修改的是原值，直接把原值從正序改爲了倒序
>>：['eee', 'ddd', 'ccc', 'bbb', 'aaa']
2、count 統計元素的個數(當前列表中有幾個'aaa')
name=['aaa','bbb','ccc','ddd','eee']
name.count('aaa')
print(name.count('aaa')) #統計元素的個數(當前列表中有幾個'aaa')
>>：1
3、clear 清空列表中所有的值
name=['aaa','bbb','ccc','ddd','eee']
name.clear()
print(name.clear()) #清空列表中所有的值
>>：None
print(name)
>>：[]
4、copy 複製
name=['aaa','bbb','ccc','ddd','eee']
l=name.copy() #複製一份內容
print(l)
>>：['aaa', 'bbb', 'ccc', 'ddd', 'eee']
5、index 查看索引值的序列號
name=['aaa','bbb','ccc','ddd','eee']
name.index('aaa')
print(name.index('aaa'))
>>：0 #'aaa'在列表中處於第0個索引
6、sort 排序 #對同類型的元素排序，從小到大排序(數字和字符串不能做比較)
name=[-1,99,22,-3,23]
name.sort() #對同類型的元素排序，從小到大
print(name)
>>：[-3, -1, 22, 23, 99]
name=['aaa','bbb','ccc','ddd','eee']
name.sort() #字符串比較大小，從字符串的第一個元素開始比較誰大誰小
print(name)
['aaa', 'bbb', 'ccc', 'ddd', 'eee']
1.3.1.3、列表list總結
1、列表能存多個值
2、列表屬於有序(可以按照索引取值的都爲有序)
3、列表屬於可變類型
1.4 隊列與堆棧
1.4.1 隊列-(先進先出)
#入隊列：
name=[]
name.append('aaa') #使用append追加，每次追加的內容都在末尾
name.append('bbb')
name.append('ccc')
print(name)
>>：['aaa', 'bbb', 'ccc']
#出隊列：
name.pop(0) #使用pop取值，符合先進先出的規則，那麼就要取第一個索引的值'aaa'
print(name)
>>：['bbb', 'ccc'] #取出'aaa'，之後剩下['bbb', 'ccc']
name.pop(0)
print(name)
>>：['ccc'] #取出'bbb'，之後剩下['ccc']
name.pop(0)
print(name)
>>：[] #取出'ccc'，之後剩下[]
或者：
#入隊列：
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
#出隊列：
print(name.pop(0))
>>：aaa #第一個取出的值
print(name.pop(0))
>>：bbb #第二個取出的值
print(name.pop(0))
>>：ccc #最後一個取出的值
1.4.2 堆棧-(先進後出，或後進先出)
#入棧
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
#出棧
name.pop(-1) #這裏是有pop(-1)，取倒數第一個值
print(name)
>>：['aaa', 'bbb'] #取出'ccc'後，還剩下['aaa', 'bbb']
name.pop(-1)
print(name)
>>：['aaa'] #取出'bbb'後，還剩下['aaa']
name.pop(-1)
print(name)
>>：[] #取出'aaa'後，還剩下[]
或者：
#入棧
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
>>：['aaa', 'bbb', 'ccc']
#出棧
print(name.pop(-1))
>>：ccc #第一個取出的值
print(name.pop(-1))
>>：bbb #第二個取出的值
print(name.pop(-1))
>>：aaa #最後一個取出的值
1.5 元組 tuple (不可變的列表) #可以理解爲一個列表但是值不能被修改
1.5.1 元組的用法和列表是一樣的，只不過元組屬於不可變類型
1.5.2 元組屬於有序，可以存多個值，屬於不可變類型
1.6 字典類型 dict
定義：在{}內，以逗號分隔，每個元素是用key : value的形式
強調：key通常是字符串類型(不可變類型)，value可以是任意類型，key和value之間通過冒號":"，來建立對應關係
打印一個字典的值：print(變量名[Key])
例子1：字典的寫法
szq_info={'aaa':111, #'aaa'就是一個Key
'bbb':222,
'ccc':333,
'ddd':['11','22','33'] #'ddd'也是一個Key,它的值爲['11','22','33']
}
print(szq_info['aaa'])
111 #獲取到Key(aaa)對應的value(111)
print(szq_info['ddd'][1])
22 #獲取到Key(ddd)對應的value['11','22','33']，取第二個索引
1.6.1 列表List與字典Dict的組合應用
students=[
{'name':'szq','age':18,'hobby':['read','sleep']},
{'name':'wusp','age':28,'hobby':['read','sleep']},
{'name':'zhangold','age':38,'hobby':['read','sleep']}
]
print(students[1]) #取第2個索引的值
{'name': 'wusp', 'age': 28, 'hobby': ['read', 'sleep']}
print(students[1]['name']) #取第2個索引的值，然後取Key 'name'，取Key 'hobby'
wusp
print(students[1]['hobby']) #取第2個索引的值，然後取Key 'hobby'
['read', 'sleep']
print(students[1]['hobby'][1]) #取第2個索引的值,然後取Key 'hobby' 得到['read','sleep']，然後在取第2個索引的值
sleep
1.6.1.1 字典dir優先掌握的操作：
1、按key存取值：可存可取
name={'aaa':1123,'bbb':1223}
name['aaa']=333 #修改key'aaa'對應的value的值爲'333'
print(name) #字典屬於可變類型
>> ：{'aaa': 333, 'bbb': 1223} #發現key對應的值已經被改變
2、長度len #判斷字典中 Key的個數
name={'aaa':1123,'bbb':1223}
name['aaa']=333
print(len(name))
>> ：2
3、成員運算in和not in #for循環中取得變量是key
name={'aaa':1123,'bbb':1223}
name['aaa']=333
for n in name: #for循環中取得變量是key
print(n)
>> ： aaa
>> ： bbb
4、刪除 popitem的用法和pop的用法
4.1、popitem的用法：刪除字典中裏面的最後一個鍵值對，通過調用name.popitem()獲取到被刪除的鍵值對
name={'aaa':111,'bbb':222,"ccc":333}
print(name.popitem()) # popitem表示刪除掉一個鍵值對items()
>> ：('ccc', 333) # 執行name.popitem()，得到一個元組類型數據
4.2、pop的用法：刪除字典裏面的一個key，通過調用name.pop('aaa')獲取到被刪除key對應的value
name={'aaa':1123,'bbb':1223}
print(name.pop('aaa')) #pop後面接key，那麼得到刪除的key對應的值
>> ：1123
print(name) #使用pop刪除後，那麼這個key對應的鍵值對就會被刪除
>>：{'bbb': 1223}
4.3、如果刪除的key不存在，那麼使用default默認輸出一個值，但是原值不會改變
name={'aaa':1123,'bbb':1223}
print(name.pop('aaaaaa','沒有這個key,請重新定義Key')) #如果定義了一個不存在的key，那麼給一個默認輸出
>>：{沒有這個key,請重新定義Key
print(name) #那麼原值不會發生任何改變
>>：{{'aaa': 1123, 'bbb': 1223}
5、鍵keys()，值values()，鍵值對items()
5.1、keys 取出所有的key
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.keys()) #.keys指的是字典的所有key
>>：dict_keys(['apple', 'tesla', 'mac', 'lenovo', 'chicken'])
在使用for循環時，使用.keys可以拿到字典中所有的key(不過for循環本身即可完成)
for n in msg_dic.keys():
print(n)
>>：apple
>>：tesla
>>：mac
>>：lenovo
>>：chicken
5.2 values 取出所有的value
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.values()) #.value指的是所有的key對應的value
>>：dict_values([10, 100000, 3000, 30000, 10])
在使用for循環時，使用.values可以拿到字典中所有的key對應的value(相當於取所有的值)
for n in msg_dic.values():
print(n)
>>：10
>>：100000
>>：3000
>>：30000
>>：10
5.3 items 取出所有的鍵值對
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.items())
>>：dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)])
在使用for循環時，使用.items可以拿到字典中所有的鍵值對 (轉換成了元組的形式)
for n in msg_dic.items():
print(n)
>>：('apple', 10)
>>：('tesla', 100000)
>>：('mac', 3000)
>>：('lenovo', 30000)
>>：('chicken', 10)
使用for循環轉換，把items拿到的元祖形式裝換爲普通形式：
for k,v in msg_dic.items(): #items取出的是所有的鍵值對，那麼定義變量k==keys,v==values,就能得到所有的keys和values
print(k,v)
>>：apple 10
>>：tesla 100000
>>：mac 3000
>>：lenovo 30000
>>：chicken 10
6、循環(循環字典)
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
for n in msg_dic: #n定義爲字典的中所有的key
print(n) #打印n得到所有的key
>>：apple
>>：tesl
>>：mac
>>：lenovo
>>：chicken
print(msg_dic[n]) #打印字典中所有的key，得到所有的key對應的value
>>：10
>>：100000
>>：3000
>>：30000
>>：10
print(n,msg_dic[n]) #打印字典中所有的key及對應的value
>>：apple 10
>>：tesla 100000
>>：mac 3000
>>：lenovo 30000
>>：chicken 10
1.6.1.2 字典dir需要掌握的操作：
1、msg.get('aaa') # 如key('aaa')不存在字典中，那麼返回空值，而不是報錯
msg={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg.get('aaa','值不存在'))
>> ：None #默認返回空值
>> ：值不存在 #可以添加提醒項，若key不存在則返回提示項
2、msg.update({'a':1,'b':2}) # 修改字典的值爲設定的值
msg={'aaa':111,'bbb':222}
print(msg)
>> ：{'aaa':111,'bbb':222}
msg.update({'aaa': 'AAA', 'bbb': 'BBB', "ccc":333})
# 把.update({'aaa':'AAA','bbb':'BBB'})裏面的鍵值賦值給msg,有則修改，無則添加。
print(msg)
{'aaa': 'AAA', 'bbb': 'BBB', 'ccc': 333}
3.1、 msg.setdefault('aaa',666) #若key('aaa')存在字典中，那麼則不會修改原有的值
msg={'aaa':111,'bbb':222}
msg.setdefault('aaa',666) #若key('aaa')存在字典中，那麼則不會修改原有的值
print(msg)
>> ：{'aaa': 111, 'bbb': 222}
3.2、msg.setdefault('sudada',666) #若key('sudada')不存在字典內，那麼則在字典中追加一個鍵值對{'sudada': 666}
msg={'aaa':111,'bbb':222}
msg.setdefault('sudada',666) #若key('sudada')不存在字典內，那麼則在字典中追加一個鍵值對{'sudada': 666}
print(msg)
>> ：{'aaa': 111, 'bbb': 222, 'sudada': 666}
總結setdefault：有則不變，無則增加
setdefault例子：博客裏面，統計單詞個數
1.6.1.3、字典dir總結
1、字典能存多個值
2、字典屬於無序(可以按照索引取值的都爲有序)
3、字典屬於可變類型
1.6.1.3、python dict與zip的使用
1、zip函數：接受任意多個（包括0個和1個）序列作爲參數，返回一個tuple列表。
# 例子1：
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
注意：Python3.x和Python2.x這裏的差別
Python3.x
xyz = list(zip(x, y, z))
Python2.x
xyz = zip(x, y, z)
print(xyz)
輸出結果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
# 例子2：
x = [1, 2, 3]
y = [4, 5, 6, 7]
xy = list(zip(x, y))
print(xy)
輸出結果：[(1, 4), (2, 5), (3, 6)]
# 例子3：
x = [1, 2, 3]
x = list(zip(x))
print(x)
輸出結果：[(1,), (2,), (3,)]
# 例子4：
x = list(zip())
print(x)
輸出結果：[]
# 例子5：
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = list(zip(x, y, z))
print(xyz )
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
u = list(zip(*xyz))
print(u)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
一般認爲這是一個unzip的過程，它的運行機制是這樣的：
在運行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
那麼，zip(*xyz) 等價於 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))
所以，運行結果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
注：在函數調用中使用*list/tuple的方式表示將list/tuple分開，作爲位置參數傳遞給對應函數（前提是對應函數支持不定個數的位置參數）
2、zip函數在字典裏面的使用
# 例子1：zip函數利用字符串創建字典
key = 'abcde'
value = range(1, 6)
print(dict(zip(key, value)))
輸出結果：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 例子2：使用items()來遍歷字典
d={'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
for key,value in d.items():
print(key,value)
或者：
for n in d:
print(n,d[n])
a 1
b 2
c 3
d 4
e 5
# 例子3：dict(dict1, **dict2)合併兩個字典
a={'a':1,'b':2,'c':3}
b={'d':11,'e':22,'f':33}
print(dict(a,**b))
輸出結果：{'a': 1, 'b': 2, 'c': 3, 'd': 11, 'e': 22, 'f': 33}
# 例子4：合併多個字典：如果多個字典內有重複的key，那麼以"**b"字典爲準
a={'a':1,'b':2,'c':3}
b={'d':11,'e':22,'f':33}
c=dict(a,**b)
d={'aa': 1, 'bb': 2, 'c': 3333, 'd': 4, 'e': 5}
print(dict(c,**d))
輸出結果：{'a': 1, 'b': 2, 'c': 3333, 'd': 4, 'e': 5, 'f': 33, 'aa': 1, 'bb': 2}
# 例子5：使用fromkeys() 函數用於創建一個新字典，以序列seq中元素做字典的鍵，value爲字典所有鍵對應的初始值。
seq={'name','age','score'}
d=dict.fromkeys(seq,100)
print(d)
輸出結果：{'score': 100, 'name': 100, 'age': 100}
1.7 布爾類型 - 只有2種值， "True"或者"False"
a=3
b=5
print(a>b)
False #3>5不成立則爲False
print(a<b)
True #3<5成立則爲True
1.7.1 布爾類型補充知識：所有的數據類型都自帶布爾值(True或False )
1.這裏需要知道：什麼樣的數據類型自帶的布爾值是爲False(假)
即：0，None，空(字符串沒有定義的值)
if not cmd:continue #if 後面接條件，當條件爲真(True)時，執行continue。那麼只有在cmd的值爲"空"(False)時，cmd爲假，那麼not cmd即爲"真"(True)。 #這裏取了個反值
1.8 可變或者不可變類型
1.8.1 可變類型定義：值發生改變，但是id沒有發生改變--【可變類型是不可hash的】
1.列表類型(list)
2.字典類型(dict)
l=['a','b','c','d']
print(id(l),l)
3130959555272 ['a', 'b', 'c', 'd'] #第一次打印得到ID和值
l[0]='A'
print(id(l),l)
3130959555272 ['A', 'b', 'c', 'd'] #第二次打印得到ID和值
#運行後可以看出，第二次與第一次相比較，值發生改變，但是id沒有發生改變，滿足可變數據類型！
1.8.2 不可變類型定義：值發生改變，id也發生改變--【不可變類型是可以hash的】
1.數字類型(int與float)，
2.字符串類型(str)，
3.元組類型(tuple)，
1.9、集合{}類型(set)
2.定義方式
2.1 {}內用逗號分隔開多個元素，每一個元素必須爲不可變類型(也就是集合內只能存不可變類型)
2.2 集合內的元素不能重複
2.3 集合無序(不能被索引取值)
s={1,'a',3} #集合內定義值得方式
print(type(s))
>>：<class 'set'>
3、集合優先掌握的操作
1、長度len
s={1,'a',3}
print(len(s))
>>：3
2、成員運算in和not in
s={1,'a',3}
print('a' in s)
>>：True
print('b' not in s)
>>：True
3、|合集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A | B) #並集(A與B所有的值加起來)
>>：{3333, 333, 111, 'bbb', 222, 'aaa'}
4、&交集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A & B) #交集(A與B都存在的值)
>>：{333, 'aaa', 111}
5、-差集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A - B) #差集(A減B:該值在A存在但是在B不存在)
>>：{3333}
>print(B - A) #差集(B減A:該值在B存在但是在A不存在)
>>：{'bbb', 222}
6、^對稱差集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A ^ B) #對稱差集(取A與B之間不重複的值(A與B去重後得到的值))
>>：{3333, 'bbb', 222}
7、父集(>,>=) 與 子集(<,<=)
# 集合之間做比較：指的是包含於被包含的關係
s1={1,2,3}
s2={1,2}
print(s1 >= s2) #s1包含s2
>>：True
print(s2 <= s1) #s2被s1包含
>>：True
4、集合需要掌握的操作
1、difference與difference_update（差集）
s1={'a','b','c'}
s2={'b','d','f'}
print(s1.difference(s2)) #s1與s2的差集
# >>：{'a', 'c'}
s1.difference_update(s2) #這步操作實際上就是把s1與s2的差集賦值給s1(重新定義了s1)
print(s1)
# >>：{'a', 'c'}
2、add（添加）
s1={'a','b','c'}
s2={'b','d','f'}
s1.add('d') #在集合內添加一個值
print(s1)
# >>：{'c', 'd', 'a', 'b'}
3、刪除集合內的元素
s1={'a','b','c'}
s2={'b','d','f'}
s1.remove('a') #把集合內的元素'a'刪除(刪除後無返回值)
print(s1)
# >>：{'c', 'b'}
s1.discard('a') #把集合內的元素'a'刪除(刪除後無返回值)
print(s1)
# >>：{'b', 'c'}
s1.pop() #隨機刪除集合內的元素(有返回值)
print(s1)
# >>：{'a', 'c'}
# >>：{'b', 'c'}
例子1：替換列表裏面的某個元素(這裏指的某些特殊字符) -- 根據excel獲取IP值那個腳本學到的
import re
list_a=['外網IP', '75.126.166.229', '75.126.134.229', '75.126.214.83|10.80.142.94', '75.126.134.226',]
list_d={' ':'\|'} """ key=" " 空 value='\|' """
list_b=",".join(list_a)
for n in list_d.keys():
list_b=re.sub(list_d[n],n,list_b)
"""
參數介紹：
re.sub 正在表達式裏面'替換'的用法
list_d[n] == '\|'
n == ' '
list_b == '外網IP,75.126.166.229,75.126.134.229,75.126.214.83 10.80.142.94,75.126.134.226'
意思介紹：
把字符'\|'替換爲空' '，針對內容'外網IP,75.126.166.229,75.126.134.229,75.126.214.83 10.80.142.94,75.126.134.226'
"""
print(list_b.split(","))
>>：['外網IP', '75.126.166.229', '75.126.134.229', '75.126.214.83 10.80.142.94', '75.126.134.226']
例子2：替換列表裏面的某個元素
import re
a = ["123", "456", "789"]
d = {
"B": "2",
"E": "5",
"H": "8"
}
b = ",".join(a)
print(b)
# 123,456,789
for i in d.keys():
b = re.sub(d[i], i, b)
"""
參數介紹：
d[i] = key對應的值
i = 字典d裏面的key
b = '123,456,789'
意思介紹：
把數字"2" "5" "8"替換爲"B" "E" "H"，針對內容'123,456,789'
"""
print(b.split(","))
# ['1B3', '4E6', '7H9']
例子：將三個列表內的數據並排顯示
total = []
a=['外網IP', '75.126.166.229', '75.126.134.229', '75.126.214.83']
b=['內網IP', '10.84.248.207', '10.86.92.198', '10.81.223.142']
c=['root', 'C6SWlKJ3', 'F3PcL98m', 'Dd59nlVA', 'AqGb6qfh', 'V5']
for q,w,e in zip(a,b,c):
total.append(q+' '+w+' '+e)
for n in total:
print(n)
>>：外網IP 內網IP root
>>：75.126.166.229 10.84.248.207 C6SWlKJ3
>>：75.126.134.229 10.86.92.198 F3PcL98m
>>：75.126.214.83 10.81.223.142 Dd59nlVA
1.10、eval函數 eval函數就是實現list、dict、tuple與str之間的轉化
1、字符串轉換成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
print(b)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
2、字符串轉換成字典
aa = "{1: 'a', 2: 'b'}"
bb = eval(aa)
print(bb)
{1: 'a', 2: 'b'}
3、字符串轉換成元組
aaa = "([1,2], [3,4], [5,6], [7,8], (9,0))"
bbb = eval(aaa)
print(bbb)
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))