基本資料型別(int, bool, str,list,tuple,dict)

一.python基本資料型別

1. int  整數. 主要用來進行數學運算

2. str  字串, 可以儲存少量資料並進行相應的操作,用雙引號或單引號或三引號括起來

3. bool 判斷真假, True, False

4. list 儲存大量資料.用[ ]表示

5. tuple 元組, 不可以發生改變，只讀列表 用( )表示

6. dict 字典, 儲存鍵值對, 一樣可以儲存大量資料{key:value}

7. set 集合, 儲存大量資料. 不可以重複. 其實就是不儲存value的dict

二. 整數(int)

在python3中所有的整數都是int型別. 但在python2中如果資料量比較大. 會使用long型別.

在python3中不存在long型別

整數可以進行的操作:

bit_length(). 計算整數在記憶體中佔用的二進位制碼的長度

三. 布林值(bool)

布林只有兩個值. True,False. 一般是沒有什麼操作的.

型別轉換的問題:

想把xx轉換成yy. yy(xx)

可以表示False的內容:0, "", [], tuple(), {}, None

所有的空都是False. 所有的非空是True

取值只有True, False. bool值沒有操作.

str    int int(str)

int    str str(int)

int    bool bool(int). 0是False 非0是True

bool   int int(bool) True是1, False是0

str     bool bool(str) 空字串是False, 不空是True

bool    str str(bool) 把bool值轉換成相應的"值"

四. 字串 (str)

字串，由單引號或雙引號或三引號',",''',闊起來的內容就是字串，字串是不可變的資料型別.不論你執行任何操作. 源字串是不會改變的, 每次操作都會返回新字串

1..字串相關操作：

1. upper() 轉換成大寫
2. stript() 去掉空白
3. replace(old, new) 把xxx替換成xxxx
4. split() 切割. 返回列表. 用多長的刀. 就要損失掉多少
5. startswith() 判斷是否以xxx開頭
6. find(), count(), index()
7. len()  計算字串長度. python的內建函式

2. for迴圈

for 變數 in 可迭代物件:

迴圈體, 也存在break和continue

else:

當迴圈結束的時候會執行

3. 切片和索引

3.1索引從0開始, 使用[下標]可以獲取到每一個字元, 還可以倒著數，切記索引是從0開始的。

 1 # 012345678
 2 
 3 s1 = "python最牛B"
 4 
 5 print(s1[0]) # 獲取第0個
 6 
 7 print(s1[1])
 8 
 9 print(s1[2])
10 
11 print(s1[3])
12 
13 print(s1[4])
14 
15 print(s1[5])
16 
17 print(s1[6])
18 
19 print(s1[7])
20 
21 print(s1[8])
22 
23 print(s1[9]) # 沒有9, 越界了,會報錯
24 
25 print(s1[-1]) # -1 表示倒數.
26 
27 print(s1[-2]) # 倒數第二個

3.2切片, 我們可以使用下標來擷取部分字串的內容

語法: str[start: end]

切片: [起始位置:結束位置:步長]

規則: 顧頭不顧尾, 從start開始擷取. 擷取到end位置. 但不包括end，預設從左到右取值，當步長為負可以從右往左取值

 1 s2 = "python最牛B"
 2 print(s2[0:3]) # 從0獲取到3. 不包含3. 結果: pyt
 3 print(s2[6:8]) # 結果 最牛
 4 print(s2[6:9]) # 最大是8. 但根據顧頭不顧腚, 想要取到8必須給9
 5 print(s2[6:10]) # 如果右邊已經過了最大值. 相當於獲取到最後
 6 print(s2[4:]) # 如果想獲取到最後. 那麼最後一個值可以不給.
 7 print(s2[-1:-5]) # 從-1 獲取到 -5 這樣是獲取不到任何結果的. 從-1向右數. 你怎麼數也數不到-5
 8 print(s2[-5:-1]) # 牛b, 取到資料了. 但是. 顧頭不顧尾. 怎麼取最後一個呢?
 9 print(s2[-5:]) # 什麼都不寫就是最後了
10 print(s2[:-1]) # 這個是取到倒數第一個
11 print(s2[:]) # 原樣輸出

跳著擷取

# 跳著取, 步長 
 1 s1 = "python最牛B"
 2 
 3 print(s2[1:5:2]) # 從第一個開始取, 取到第5個,每2個取1個, 結果: yh, 分析: 1:5=>ytho => yh
 4 
 5 print(s2[:5:2]) # 從頭開始到第五個. 每兩個取一個
 6 
 7 print(s2[4::2]) # 從4開始取到最後. 每兩個取一個
 8 
 9 print(s2[-5::2]) # 從-5取到最後.每兩個取一個
10 
11 print(s2[-1:-5]) # -1:-5什麼都沒有. 因為是從左往右獲取的.
12 
13 print(s2[-1:-5:-1]) # 步長是-1. 這時就從右往左取值了
14 
15 print(s2[-5::-3]) # 從倒數第5個開始. 到最開始. 每3個取一個, 結果oy

步長: 如果是整數, 則從左往右取. 如果是負數. 則從右往左取. 預設是1

切片語法:

str[start:end:step]

start: 起始位置

end: 結束位置

step:步長

4. 字串的相關操作方法

切記, 字串是不可變的物件, 所以任何操作對原字串是不會有任何影響的

1. capitalize大小寫轉來轉去

1 a = "python"
2 
3 a.capitalize()
4 
5 print(a) # 輸出發現並沒有任何的變化. 因為這裡的字串本身是不會發生改變的. 需要我們重新獲取
6 
7 b = a.capitalize()
8 
9 print(b)

2.大小寫的轉換

 1 a = "python"
 2 
 3 b = a.lower() # 全部轉換成小寫
 4 
 5 print(b)
 6 
 7 b1 = a.upper() # 全部轉換成大寫
 8 
 9 print(b1)
10 
11 # 應用, 校驗使用者輸入的驗證碼是否合法
12 
13 verify_code = "abDe"
14 
15 user_verify_code = input("請輸入驗證碼:")
16 
17 if verify_code.upper() == user_verify_code.upper():
18 
19     print("驗證成功")
20 
21 else:
22 
23     print("驗證失敗")
24 
25 ret = a.swapcase() # 大小寫互相轉換
26 
27 print(ret)

3.字串居中

1 a = "Python"
2 
3 b = a.center(10, "*") # 拉長成10, 把原字串放中間.其餘位置補*
4 
5 print(b)

4.更改tab的長度

1 a = "Yong jie\tpython"
2 
3 print(a)
4 
5 print(a.expandtabs()) # 可以改變\t的長度, 預設長度更改為8

5.去空格strip左右兩端的空格lstrip去掉左邊空格rstrip去掉右邊空格

 1 a = " Yong jie haha"
 2 
 3 b= a.strip() # 去掉左右兩端的空格
 4 
 5 print(b)
 6 
 7 b1= a.lstrip() # 去掉左邊空格
 8 
 9 print(b1)
10 
11 b2= a.rstrip() # 去掉右邊空格
12 
13 print(b2)

例題:應用模擬使用者登入. 忽略使用者輸入的空格

 1 username = input("請輸入使用者名稱:").strip()
 2 
 3 password = input("請輸入密碼: ").strip()
 4 
 5 if username == 'YongJie' and password == 'root':
 6 
 7     print("登入成功")
 8 
 9 else:
10 
11     print("登入失敗")

指定元素去掉的元素

1 a = "abcdefgabc"
2 
3 print(a.strip("abc")) # defg 也可以指定去掉的元素,

字串替換

 1 a = "python_C_JAVA_vb_PHP"
 2 
 3 b = a.replace('vb', '牛') # 把vb替換成牛
 4 
 5 print(a) # "python_C_JAVA_vb_PHP" 切記, 字串是不可變物件. 所有操作都是產生新字串返回
 6 
 7 print(b) # "python_C_JAVA_牛_PHP"
 8 b1 = a.replace('y', 'nb', 1) # 把y替換成nb, 替換1個
 9 
10 print(b1) #pnbthon_C_JAVA_vb_PHP

字串切割

 1 a = 'python,PHP,C,java,css'
 2 
 3 
 4 
 5 b = a.split(",") # 字串切割, 根據,進行切割切割出來的是列表
 6 
 7 print(b)　　#['python', 'PHP', 'C', 'java', 'css']
 8 a1 = """詩人
 9 
10 學者
11 
12 感嘆號
13 
14 渣渣"""
15 
16 print(a1.split("\n")) # 用\n切割
17 
18 ['詩人', '', '學者', '', '感嘆號', '', '渣渣']

格式化輸出

 1 a = "我叫%s, 今年%d歲了, 我喜歡%s" % ('YJ', 19, 'Python') # 第一種寫法
 2 
 3 print(a)
 4 
 5 a1 = "我叫{}, 今年{}歲了, 我喜歡{}".format("YJ", 19, "Python") # 按位置格式化
 6 
 7 print(a1)
 8 
 9 a2 = "我叫{0}, 今年{2}歲了, 我喜歡{1}".format("YJ", "Python", 19) # 指定位置
10 
11 print(a2)
12 
13 a3 = "我叫{name}, 今年{age}歲了, 我喜歡{singer}".format(name="YJ", singer=Python", age=19) # 指定關鍵字,推薦使用這種
14 
15 print(a3)

查詢

1 a = "我叫YJ, 我喜歡python, java, c等程式語言"
2 b = a.startswith("YJ") # 判斷是否以YJ開頭
3 print(b)
4 b1 = a.startswith("我叫YJ") # 判斷是否以我叫YJ開頭
5 print(b1)

 1 a = "我叫YJ, 我喜歡python, java, c等程式語言"
 2 b2= a.endswith("語言") # 是否以'語言'結尾
 3 
 4 print(b2)
 5 
 6 b3= a.endswith("語言.") # 是否以'語言結尾
 7 
 8 print(b3)
 9 
10 b4= a.count("p") # 查詢"p"出現的次數
11 
12 print(b4)
13 
14 b5= a.find("java") # 查詢'java'出現的位置
15 
16 print(b5)
17 
18 b6= a.find("我叫YJ") # 查詢'我叫YJ'的位置, 如果沒有返回-1
19 
20 print(a)
21 
22 b8= a.index("我叫YJ") # 求索引位置. 注意. 如果找不到索引. 程式會報錯
23 
24 print(b8)

條件判斷

 1 a = "123.16"
 2 
 3 a1 = "abc"
 4 
 5 a2 = "_abc!@"
 6 
 7 # 是否由字母和數字組成
 8 
 9 print(a.isalnum())
10 
11 print(a1.isalnum())
12 
13 print(a2.isalnum())
14 
15 # 是否由字母組成
16 
17 print(a.isalpha())
18 
19 print(a1.isalpha())
20 
21 print(a2.isalpha())
22 
23 # 是否由數字組成, 不包括小數點
24 
25 print(a.isdigit())
26 
27 print(a.isdecimal())
28 
29 print(a.isnumeric()) # 這個比較牛B. 中文都識別.
30 
31 print(a1.isdigit())
32 
33 print(a2.isdigit())

例題:用演算法判斷某一個字串是否是小數

 1 a = "-123.12"
 2 
 3 a = a.replace("-", "") # 替換掉負號
 4 
 5 if a.isdigit():
 6 
 7 　　print("是整數")
 8 
 9 else:
10 
11 　　if a.count(".") == 1 and not a.startswith(".") and not a.endswith("."):
12 
13 　　　　print("是小數")
14 
15 　　else:
16 
17 　　　　print("不是小數")

計算字串的長度

1 a = "我們不一樣,不一樣"
2 
3 b = len(a) # 計算字串的長度
4 
5 print(b)
#注意: len()是python的內建函式所以訪問方式也不一樣你就記著len()和print()一樣就行了

迭代

我們可以使用for迴圈來便利(獲取)字串中的每一個字元

語法:

for 變數 in 可迭代物件:

pass

可迭代物件: 可以一個一個往外取值的物件

 1 a = "大家好, 我是YJ, 前端的小朋友們,你們好麼?"
 2 
 3 # 用while迴圈
 4 
 5 index = 0
 6 
 7 while index < len(a):
 8 
 9     print(a[index]) # 利用索引切片來完成字元的查詢
10 
11     index = index + 1
12 
13 # for迴圈, 把a中的每一個字元拿出來賦值給前面的c
14 
15 for c in a:
16 
17     print(c)

in有兩種用法:

1. 在for中. 是把每一個元素獲取到賦值給前面的變數

2. 不在for中. 判斷xxx是否出現在str中.

1 a = "大家好, 我是YJ, 前端的小朋友們,你們好麼?"
2 
3 print('YJ' in a)　　#True

 

例題:計算在字串"I am YJ, I'm 19years old, I like Python!"

 1 a = "I am YJ, I'm 19years old, I like Python!"
 2 
 3 count = 0
 4 
 5 for c in a:
 6 
 7     if c.isdigit():
 8 
 9         count = count + 1
10 
11 print(count)　　#2

list,tuple主要內容:

1. 列表

2. 列表的增刪改查

3. 列表的巢狀

4. 元組和元組巢狀

5. range

一. 列表

1. 什麼是列表:

列表是一個可變的資料型別, 列表是python的基礎資料型別之一,列表由[]來表示, 每一項元素使用逗號隔開. 列表什麼都能裝. 能裝物件的物件,列表可以裝大量的資料

lst = [1, 'python', "程式設計師", [1,8,0,"百度"], ("我","叫", "元", "組"), "abc", {"我叫":"dict字典"},{"我叫集合","集合"}]

列表相比於字串. 不僅可以存放不同的資料型別. 而且可以存放大量的資料. 32位

python可以存放: 536870912個元素, 64位可以存放: 1152921504606846975個元素.而且列表是有序的(按照你儲存的順序),有索引, 可以切片方便取值.

2. 列表的索引和切片

列表和字串一樣，也有索引和切片，只不過切出來的內容是列表，索引的下標從0開始

列表的索引:

[起始位置:結束位置:步長]

 1 lst = ["python", "Java", "PHP", "C", "VB"]
 2 
 3 print(lst[0]) # 獲取第一個元素
 4 
 5 print(lst[1])
 6 
 7 print(lst[2])
 8 
 9 lst[3] = "我很牛" # 注意. 列表是可以發生改變的. 這裡和字串不一樣
10 
11 print(lst) # ["python", "Java", "PHP", "我很牛", "VB"]
12 
13 s = "華強北"
14 
15 s[1] = "帥" #字串不允許改變會報錯
16 print(s)
17 #TypeError: 'str' object does not support item assignment 

列表的切片:

 1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
 2 
 3 print(lst[0:3]) # ['python', 'PHP', 'JAVA']
 4 
 5 print(lst[:3]) # ['python', 'PHP', 'JAVA']
 6 
 7 print(lst[1::2]) # ['PHP', 'C'] 也有步長
 8 
 9 print(lst[2::-1]) # ['JAVA', 'PHP', 'python'] 也可以倒著取
10 
11 print(lst[-1:-3:-2]) # 倒著帶步長

二. 列表的增刪改查

增, 注意, list和str是不一樣的. lst可以發生改變. 所以直接就在原來的物件上進行了操作

1. append() 追加

2. insert(index, 元素) 在index位置新增元素

3. extend() 迭代新增

例:append() 追加

1 lst = ["Python", "JAVA", "PHP", "C"]　　#定義一個列表
2 
3 print(lst)
4 
5 lst.append("YJ")　　#新增YJ元素預設在後面新增
6 
7 print(lst)

例:insert(index, 元素) 追加

 1 lst = []
 2 
 3 while True:
 4 
 5     content = input("請輸入你要錄入的語言, 輸入Q退出:")
 6 
 7     if content.upper() == 'Q':
 8 
 9         break
10 
11     lst.append(content)
12 
13     print("您新增的語言有:",lst)
14 
15 lst = ["Python", "Java", "PHP"]
16 
17 lst.insert(1, "YJ") # 在1的位置插入YJ. 原來的元素向後移動一位
18 
19 print(lst)

例:extend() 迭代新增

1 lst = ["Python", "Java", "PHP"]
2 
3 lst.extend(["YJ", "TX"])
4 
5 print(lst)
#['Python', 'Java', 'PHP', 'YJ', 'TX']

刪除

1. pop(index) 按照位置刪除元素

2.remove(元素) 直接刪除元素

3. clear() 清空列表

4. del 切片

1.pop(index) 按照位置刪除元素

 1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
 2 
 3 deleted = lst.pop() # 刪除最後一個
 4 
 5 print("被刪除的元素是：", deleted)
 6 
 7 print(lst)
 8 
 9 華強北
10 
11 el = lst.pop(2) # 刪除2號元素
12 
13 print(el)
14 
15 JAVA
16 
17 print(lst)
18 
19 ['python', 'PHP', 'C', '華強北']

2.remove(元素) 直接刪除元素

 1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
 2 
 3 lst.remove("華強北") # 刪除指定元素
 4 
 5 print(lst)
 6 
 7 ['python', 'PHP', 'C']
 8 
 9 # lst.remove("YJ") # 刪除不存在的元素會報錯
10 
11 # print(lst)
12 
13 # ValueError: list.remove(x): x not in list

3. clear() 清空列表

1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
2 
3 lst.clear() # 清空list
4 
5 print(lst)
6 
7 []

4. del 切片.

1 del lst[1:3]
2 
3 print(lst)
4 
5 ['python', 'C', '華強北']

修改

1.索引修改

1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
2 
3 lst[1] = "YJ" # 把1號元素修改成YJ
4 
5 print(lst)
6 
7 ['python', 'YJ', 'JAVA', 'C', '華強北']

2.切片修改

 1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
 2 
 3 lst[1:4] = ["堅持","加油"] 
 4 
 5 print(lst)
 6 
 7 ['python', '堅持', '加油', '華強北']
 8 
 9 lst[1:4] = ["程式設計師"] 
10 
11 print(lst)
12 
13 ['python', '程式設計師']

 查詢, 列表是一個可迭代物件, 所以可以進行for迴圈

 1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
 2 
 3 for el in lst:
 4 
 5     print(el)
 6 
 7 python
 8 PHP
 9 JAVA
10 C
11 華強北

其他操作

1.count查詢出現的次數

1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
2 
3 c = lst.count("PHP") # 查詢PHP出現的次數
4 
5 print(c)
6 
7 1

2.sort() 排序 reverse=True降序

 1 lst = [1, 11, 22, 2]
 2 
 3 lst.sort() # 排序. 預設升序
 4 
 5 print(lst)
 6 
 7 [1, 2, 11, 22]
 8 
 9 lst.sort(reverse=True) # 降序
10 
11 print(lst)
12 
13 [22, 11, 2, 1]

3. reverse() 翻轉

1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
2 
3 lst.reverse()
4 
5 print(lst)
6 
7 ['華強北', 'C', 'JAVA', 'PHP', 'python']

4.len() 求長度

1 lst = ["python", "PHP", "JAVA", "C", "華強北"]
2 
3 a = len(lst) # 列表的長度
4 
5 print(a)
6 
7 5

三. 列表的巢狀

採用降維操作.一層一層的看就好.

 1 lst = [1, "太帥", "yJ", ["PYTHON", ["可口可樂"], "雪碧"]]
 2 
 3 # 找到yJ
 4 
 5 print(lst[2])
 6 
 7 YJ
 8 
 9 # 找到太帥和yJ
10 
11 print(lst[1:3])
12 
13 ['太帥', 'yJ']
14 
15 # 找到太帥的帥字
16 
17 print(lst[1][1])
18 
19 帥
20 
21 # 將yJ拿到. 然後首字母大寫. 再扔回去
22 
23 s = lst[2]
24 
25 s = s.capitalize()
26 
27 lst[2] = s
28 
29 print(lst)
30 
31 [1, '太帥', 'Yj', ['PYTHON', ['可口可樂'], '雪碧']]
32 
33 # 簡寫
34 
35 lst[2] = lst[2].capitalize()
36 
37 print(lst)
38 
39 [1, '太帥', 'Yj', ['PYTHON', ['可口可樂'], '雪碧']]
40 
41 # 把太帥換成太醜
42 
43 lst[1] = lst[1].replace("帥", "醜")
44 
45 print(lst)
46 
47 [1, '太醜', 'yJ', ['PYTHON', ['可口可樂'], '雪碧']]

四. 元組和元組巢狀

元組: 俗稱不可變的列表.又被成為只讀列表, 元組也是python的基本資料型別之一, 用小括號括起來, 裡面可以放任何資料型別的資料, 查詢可以. 迴圈也可以. 切片也可以. 但就是不能改，如果元祖中只有一個元素就使用這樣的格式(元素, )

空元組: tuple()

元祖是一個可迭代物件, 可以使用for迴圈

 1 tu = (1, "太帥", "YJ", "太牛", "hello")
 2 
 3 print(tu)
 4 
 5 (1, '太帥', 'YJ', '太牛', 'hello')
 6 
 7 print(tu[0])
 8 
 9 1
10 
11 print(tu[2])
12 
13 YJ
14 
15 print(tu[2:5]) # 切片之後還是元組
16 
17 ('YJ', '太牛', 'hello')
18 
19 # for迴圈遍歷元組
20 
21 for el in tu:
22 
23 print(el)
24 
25 1
26 
27 太帥
28 
29 YJ
30 
31 太牛
32 
33 hello

嘗試修改元組

 1 tu = (1, "太帥", "YJ", "太牛", "hello")
 2 
 3 # tu[1] = "程式設計師" # 報錯 TypeError: 'tuple' object does not support item assignment
 4 
 5 tu = (1, "哈哈", [], "呵呵")
 6 
 7 print(tu)
 8 
 9 (1, '哈哈', [], '呵呵')
10 
11 # tu[2] = ["fdsaf"] # 這麼改不行
12 
13 tu[2].append("青青草原") # 可以改了. 沒報錯
14 
15 tu[2].append("我最狂")
16 
17 print(tu)
18 
19 (1, '哈哈', ['青青草原', '我最狂'], '呵呵')

關於不可變, 注意: 這裡元組的不可變的意思是子元素不可變. 而子元素內部的子元素是可以變, 這取決於子元素是否是可變物件.

元組中如果只有一個元素. 一定要新增一個逗號, 否則就不是元組

1 tu = (1,)
2 
3 print(type(tu))
4 
5 <class 'tuple'>

元組也有count(), index(), len()等方法.

五. range

range可以幫我們獲取到一組資料. 通過for迴圈能夠獲取到這些資料.

range(n) 從0到n-1

range(m,n) 從m到n-1

range(m,n,q) 從m到n-1 每q個取1個

綜上就是切片

 1 for num in range(10):
 2 
 3 　　print(num)
 4 
 5 　　0
 6 
 7 　　1
 8 
 9 　　2
10 
11 　　3
12 
13 　　4
14 
15 　　5
16 
17 　　6
18 
19 　　7
20 
21 　　8
22 
23 　　9

 1 for num in range(1, 10, 2):　　#隔著來輸出步長為2
 2 　　print(num)
 3 
 4 　　1
 5 
 6 　　3
 7 
 8 　　5
 9 
10 　　7
11 
12 　　9

 1 for num in range(10, 1, -2): # 反著來, 和切片一樣
 2 
 3 　　print(num)
 4 
 5 　　10
 6 
 7 　　8
 8 
 9 　　6
10 
11 　　4
12 
13 　　2

六 range和for迴圈來獲取列表中的索引

        for i in range(len(列表)):

            i 索引

            列表[i] 元素

七. dict字典主要內容:

1. 字典的簡單介紹

2. 字典增刪改查和其他操作

3. 字典的巢狀

一. 字典的簡單介紹

字典(dict)是python中唯一的一個對映型別.他是以{ }括起來的鍵值對組成. 在dict中key是唯一的. 在儲存的時候, 根據key來計算出一個記憶體地址. 然後將key-value儲存在這個地址中.這種演算法被稱為hash演算法, 所以, 切記, 在dict中儲存的key-value中的key'必須是可hash的,如果你搞不懂什麼是可雜湊, 暫時可以這樣記, 可以改變的都是不可雜湊的,那麼可雜湊就意味著不可變. 這個是為了能準確的計算記憶體地址而規定的.

已知的可雜湊(不可變)的資料型別: int, str, tuple, bool

不可雜湊(可變)的資料型別: list, dict, set

語法 :{key1: value1, key2: value2....}

注意: key必須是不可變(可雜湊)的. value沒有要求.可以儲存任意型別的資料

建立一個合法字典:

 1 dic = {123: 456, True: 999, "id": 1, "name": 'YJ', "age": 19, "stu": ['帥哥', '美女'], (1, 2, 3): '很666'}
 2 
 3 print(dic[123])
 4 
 5 print(dic[True])
 6 
 7 print(dic['id'])
 8 
 9 print(dic['stu'])
10 
11 print(dic[(1, 2, 3)])

不合法字典如:

1 dic = {[1, 2, 3]: '嘿嘿嘿'} # list是可變的. 不能作為key
2 
3 dic = {{1: 2}: "哈哈哈"} # dict是可變的. 不能作為key
4 
5 dic = {{1, 2, 3}: '呵呵呵'} # set是可變的, 不能作為key

dict儲存的資料不是按照我們新增進去的順序儲存的. 是按照hash表的順序儲存的. 而hash表

不是連續的. 所以不能進行切片工作. 它只能通過key來獲取dict中的資料

二. 字典的增刪改查和其他相關操作

1. 增加

1 dic = {}
2 
3 dic['name'] = 'YJ' # 如果dict中沒有出現這個key, 就會新增⼀一個key-value的組合進dict
4 
5 dic['age'] = 19
6 
7 print(dic)

如果dict中沒有出現過這個key-value. 可以通過setdefault設定預設值

1 dic.setdefault('Python') # 也可以往裡面設定值.
2 
3 dic.setdefault("Guido", "Python") # 如果dict中已經存在了. 那麼setdefault將不會起作用
4 
5 print(dic)

2. 刪除

 1 dic = {"stu":"hahah"}
 2 a = dic.pop("stu")　　#指定鍵刪除
 3 print(dic)
 4 
 5 {}
 6 
 7 del dic["stu"]　　#指定鍵刪除
 8 print(dic)
 9 
10 {}

隨機刪除

 1 ret = dic.popitem() 

清空字典中的所有內容

 1 dic.clear() 

3. 修改

 1 dic = {"id": 123, "name": 'YJ', "age": 19}
 2 
 3 dic1 = {"id": 456, "name": "GUIDO", "ok": "wtf"}
 4 
 5 dic.update(dic1) # 把dic1中的內容更更新到dic中. 如果key重名. 則修改替換. 如果不存在ket,則新增
 6 
 7  8 
 9 print(dic)
10 
11 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'}
12 
13 print(dic1)
14 
15 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}

在key, 則新增

1 print(dic)
2 
3 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'}
4 
5 print(dic1)
6 
7 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}

4. 查詢

查詢一般用key來查詢具體的資料.

1 print(dic['name'])
2 
3 # print(dic['sylar']) # 報錯
4 
5 print(dic.get("ok"))
6 
7 print(dic.get("sylar")) # None
8 
9 print(dic.get("sylar", "牛B")) # 牛B

5. 其他相關操作

 1 dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科比"}
 2 
 3 print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) #不用管它是什麼當成list來用就行
 4 
 5 for key in dic.keys():
 6 
 7 print(key)
 8 
 9 print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐比']) 一樣也當list來用
10 
11 for value in dic.values():
12 
13 print(value)
14 
15 print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age',
16 
17 18), ('ok', '科比')]) #這個東西也是list. 只不過list中裝的是tuple
18 
19 for key, value in dic.items(): # ?? 這個是解構
20 
21 print(key, value)
22 
23 # 解構
24 
25 a, b = 1, 2
26 
27 print(a, b)
28 
29 (c, d) = 3, 4
30 
31 print(c, d)
32 
33 e, f = [1, 2, 3] # 解構的時候注意數量必須匹配
34 
35 print(e, f)

三. 字典的巢狀

 1 dic1 = {
 2 
 3 "name": "YJ",
 4 
 5 "age": 19,
 6 
 7 "language": {
 8 
 9 "name": 'Python',
10 
11 "age": 28
12 
13 }
14 
15 }
16 
17 print(dic1.get("language").get("name"))

練習:

dic1 = {

'name':['yJ',2,3,5],

'job':'teacher',

'oldboy':{'YJ':['python1','python2',100]}

}

1，將name對應的列表追加一個元素’Python’。

2，將name對應的列表中的yJ首字母大寫。

3，oldboy對應的字典加一個鍵值對’YJ’,’加油’。

4，將oldboy對應的字典中的yJ對應的列表中的python2刪除。

2019年11月