基本數據類型-列表_元組_字典_day4

1、列表（list)
書寫格式：[]

1 #經過list類建立的
2 
3 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]  

一、列表格式
二、列表中能夠嵌套任何類型

• 中括號起來
• ，分割每一個元素
• 列表中的元素能夠是 數字，字符串，列表，布爾值....全部的都能放進去
• "集合" ，內部放置任何東西

三、索引取值

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 print(li[3]) #索引取值

執行結果：

1 age

 

四、切片，切片結果也是列表

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 print(li[3:-1])  #切片，切片的結果也是列表

執行結果：

1 ['age', ['劉正文', ['19', 10], '龐麥郎'], 'ales']

五、for循環

  while循環

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 for item in li:
3     print(item)

執行結果：

1 1
2 12
3 9
4 age
5 ['劉正文', ['19', 10], '龐麥郎']
6 ales
7 True

 

六、索引

• 修改

        列表元素，能夠被修改

ps1:

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 li[1] = 120
3 print(li)

執行結果：

1 [1, 120, 9, 'age', ['劉正文', ['19', 10], '龐麥郎'], 'ales', True]

ps2:

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 li[1] = [11,22,33,44]
3 print(li)

執行結果：

1 [1, [11, 22, 33, 44], 9, 'age', ['劉正文', ['19', 10], '龐麥郎'], 'ales', True]

 

• 刪除

        刪除，第一種方式

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 del li[1]   #刪除12
3 print(li)

執行結果：

1 [1, 9, 'age', ['劉正文', ['19', 10], '龐麥郎'], 'ales', True]

 

七、切片

• 修改

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 li[1:3] = [120,90]   #修改12,9
3 print(li)

執行結果：

1 [1, 120, 90, 'age', ['劉正文', ['19', 10], '龐麥郎'], 'ales', True]

• 刪除

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 del li[2:6]
3 print(li)

執行結果：

1 [1, 12, True]

 

八、in操做

    做用：判斷這個元素是否在列表中

ps1:

值存在這個列表中，就是Ture

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 v = 1 in li   #1在這個列表中，就是True
3 print(v)

1 True

 

ps2:

值不存在這個列表中，就是Flase

1 li = [1, 12, 9, "age", ["劉正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 v = 120 in li
3 print(v)

執行結果：

1 False

 

ps3:

由於在列表中的元素，以逗號作爲分割，就是個總體，因此是Flase

1 li = [1, 12, 9, "age", ["史正文", ["19", 10, ],"龐麥郎"], "ales", True]
2 #由於在列表中的元素，以逗號作爲分割，就是個總體，因此是Flase
3 v = "劉正文" in li    #史正文在第4個素引的列表中，因此是Flase
4 print(v)

執行結果：

1 False

 

九、操做

1 li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True]
2 li[4][1][0][1]  #索引取值，能夠一直往裏面找

 

補充知識：

只要我想把某個值，轉成什麼，就寫上對應的類型，就能夠進行轉換

1 把字符串轉成整型
2 
3 a = "123"    
4 int(a)   
5 a = 123

1 把整型轉到字符串
2 
3 a = 123
4 str(a)

 

十、轉換

一、字符串轉換列表 li = list("asdfasdfasdf"), 內部使用for循環

1 s = "pouaskdfauspdfiajsdkfj"
2 new_li = list(s)
3 print(new_li)

執行結果：

1 ['p', 'o', 'u', 'a', 's', 'k', 'd', 'f', 'a', 'u', 's', 'p', 'd', 'f', 'i', 'a', 'j', 's', 'd', 'k', 'f', 'j']

二、列表轉換成字符串

    須要本身寫for循環一個一個處理，即有數字又有符串

1 li = [11,22,33,"123","alex"]
2 r = str(li) # 指的就是把上面列表打印出來
3 print(r)

執行結果：

1 [11, 22, 33, '123', 'alex']

 

列表轉換成字符串

1 li = [11,22,33,"123","alex"]
2 s = ""
3 for i in li:
4     s = s + str(i)
5 print(s)

執行結果：

1 112233123alex

 

三、直接使用字符串join方法：列表中的元素只有字符串

1 li = ["123","alex"]
2 v = "".join(li)
3 print(v)

執行結果：

1 123alex

 

四、補充：

一、字符串建立後，不可修改  replace:替換

1 v = "alex"
2 v = v.replace('l','el')
3 print(v)

執行結果：

1 aelex

二、列表

li = [11,22,33,44]
li[0]
li[0] = 999

s = "alex"
li[0]
s[0] = "E"

li = [11,22,33,44]
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
列表，有序；元素能夠被修改

列表
list
li = [111,22,33,44]

 

---

 

列表內容的總結：

1. 書寫格式
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
通常寫元組的時候，推薦在最後加入 ,
元素不可被修改，不能被增長或者刪除

2. 索引
v = tu[0]
print(v)

3. 切片
v = tu[0:2]
print(v)

4. 能夠被for循環，可迭代對象
for item in tu:
    print(item)

5. 轉換
s = "asdfasdf0"
li = ["asdf","asdfasdf"]
tu = ("asdf","asdf")

v = tuple(s)
print(v)

v = tuple(li)
print(v)

v = list(tu)
print(v)

v = "_".join(tu)
print(v)

li = ["asdf","asdfasdf"]
li.extend((11,22,33,))
print(li)

6.元組的一級元素不可修改/刪除/增長
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)

元組，有序
v = tu[3][0][0]
print(v)
v=tu[3]
print(v)
tu[3][0] = 567
print(tu)

 

2、參數

一、追加 append

1 li = [11, 22, 33, 22, 44]
2 li.append(5)
3 li.append("alex")
4 li.append([1234,2323])
5 print(li)

執行結果：

1 [11, 22, 33, 22, 44, 5, 'alex', [1234, 2323]]

二、清空列表 clear

1 li = [11, 22, 33, 22, 44]
2 li.clear()   #清空列表中的值
3 print(li)

執行結果：

1 []

 

三、拷貝，淺拷貝 copy()

1 li = [11, 22, 33, 22, 44]
2 v = li.copy()
3 print(v)
4 print(li)

執行結果：

1 [11, 22, 33, 22, 44]
2 [11, 22, 33, 22, 44]

 

四、計算元素出現的次數  count

1 li = [11, 22, 33, 22, 44]
2 v = li.count(22)  #統計22出現了幾回，因此是2次
3 print(v)

執行結果：

2

 

五、擴展原列表，參數，可迭代對象 extend

1 li = [11, 22, 33, 22, 44]
2 li.extend([9898,"不得了"])
3 print(li)

執行結果：

1 [11, 22, 33, 22, 44, 9898, '不得了']

 

六、根據值獲取當前值索引位置（左邊優先） index

1 li = [11, 22, 33, 22, 44]
2 v = li.index(22)   #從0開始數
3 print(v)

執行結果：

1 1

 

七、在指定索引位置插入元素 insert

1 li = [11, 22, 33, 22, 44]
2 li.insert(0,99)
3 print(li)

執行結果：

1 [99, 11, 22, 33, 22, 44]

 

八、刪除某個值  pop 

1.指定索引

二、默認最後一個，並獲取刪除的值

ps1:

1 li = [11, 22, 33, 22, 44]
2 v = li.pop()
3 print(li)
4 print(v)

執行結果：

1 [11, 22, 33, 22]   #刪除了44
2 44   #獲取刪除的值

 

ps2:

1 li = [11, 22, 33, 22, 44]
2 v = li.pop(1)  #指定刪除的參數，刪除第1個，從0開始數
3 print(li)
4 print(v)

執行結果：

1 [11, 33, 22, 44]
2 22

 

九、刪除列表中的指定值，左邊優先  remove

PS:刪除的命令一共有幾個
 pop、remove、del li[0]、del li[7:9]、clear

1 li = [11, 22, 33, 22, 44]
2 li.remove(22)
3 print(li)

執行結果：

1 [11, 33, 22, 44]

 

十、將當前列表進行翻轉 reverse

1 li = [11, 22, 33, 22, 44]
2 li.reverse()
3 print(li)

執行結果：

1 [44, 22, 33, 22, 11]

 

十一、列表的排序(從大到小） sort(reverse=True)

1 li = [11, 22, 33, 22, 44]
2 li.sort()
3 li.sort(reverse=True)
4 print(li)

執行結果：

1 [44, 33, 22, 22, 11]

 

十二、enumrate

爲一個可迭代的對象添加序號，可迭代的對象你能夠理解成能用for循環的就是可迭代的。默認是編號是從0開始，能夠設置從1開始

1 li = ["手機", "電腦", "鼠標墊", "遊艇"]
2 for k, i in enumerate(li,1): 3 print(k,i)

執行結果

1 1 手機
2 2 電腦
3 3 鼠標墊
4 4 遊艇

 

1三、欠三個，之後再講

cmp

key

sorted

 

---

 3、元組  

書寫格式：()

一、元組的一級元素不可修改/刪除/增長

ps1:

1 tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
2 #元組，有序
3 v = tu[3][0][0]
4 print(v)

執行結果：

1 33

ps2:

1 tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
2 v = tu[3]    #從0開始數， " " （） [] 都只能算一個數 
3 print(v)

執行結果：

1 [(33, 44), 9]

ps3:

列表能夠被替換

1 tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
2 tu[3][0] = 567   #獲取到，列表能夠被替換
3 print(tu)

執行結果：

1 (111, 'alex', (11, 22), [567], True, 33, 44)

 

二、列表和元組的使用說明：

1 何時用列表，何時用元組
2 能夠被修改的就用list
3 不能被修改的就用元組
4 元組要修改的話，能夠轉成列表，再替換

 

---

 4、字典（dict)  

字典{}，列表[], 元組()

總結：

一、字典是以鍵值對的方式出現：key:value
二、字典的value的值能夠是任何值
三、布爾值、列表、字典不能做爲字典的key,但元組能夠，作爲列表的key
四、字典是無序的

 

書寫格式：{}

 一、基本結構，字典是以鍵值對的方式出現

info = {
        "k1":"v1", #鍵值對
        "k2":"v2"
 }

「k1」:"v1" 表示爲：key:value 前面是key,後面是值

 

二、字典的value（值）能夠是任何值

 1 info = {
 2     "k1": 18,
 3     "k2": True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11, 22),
14         }
15     ],
16     "k4": (11, 22, 33, 44)
17 }
18 print(info)

執行結果：

1 {'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44), 'k1': 18, 'k2': True}

 

三、布爾值、列表、字典不能做爲字典的key

ps1:

1 info ={
2     1: 'asdf',
3     "k1": 'asdf',
4     True: "123",   #布爾值不能做爲字典的key，只能是值
5 }
6 print(info)

執行結果：

1 {1: '123', 'k1': 'asdf'} 

 

ps2:

 1 info = {
 2     1: 'asdf',
 3     "k1": 'asdf',
 4      True: "123",
 5     #[11,22]: 123   #列表不能作爲字典的key，會報錯。
 6     (11,22): 123,   #元組能夠，作爲列表的key
 7     #{'k1':'v1'}: 123  #字典不能夠作爲字典的key("TypeError: unhashable type:'dict')
 8 
 9 }
10 print(info)

執行結果：

1 {1: '123', 'k1': 'asdf', (11, 22): 123}

 

四、字典無序

 1 info = {
 2     "k1": 18,
 3     "k2": True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11, 22),
14         }
15     ],
16     "k4": (11, 22, 33, 44)
17 }
18 print(info)

執行結果：

兩次結果進行比較，會發現字典是無序的。

運行程序1次得出的結果：

1 {'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18, 'k2': True, 'k4': (11, 22, 33, 44)}

 再運行程序得出的結果：

1 {'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18, 'k2': True}

 

五、索引方式找到指定元素

ps1：

取18的值

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 v = info['k1']   #獲取key的值，就是18
19 print(v)
20 v = info[2]      #獲取2的值，就是True
21 print(v)

執行結果：

1 18
2 True

 

ps2:

找到11

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),   #找到11
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 v = info['k3'][5]['kk3'][0]  #找到11; 最後元組拿到第一個元素，加[0]
19 print(v)

執行結果：

1 11

 

六、字典支持 del 刪除

 ps1:

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 del info['k1']

執行結果：

      #刪除掉了，因此什麼都沒有

 

ps2:

刪除kk1

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 del info['k3'][5]['kk1']  #刪除'kk1': 'vv1',

19 print(info)

執行結果：

1 {'k1': 18, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 2: True, 'k4': (11, 22, 33, 44)}

 

七、字典的for循環

ps1:

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info:
19     print(item)

執行結果：

1 {2: True, 'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k1': 18}
2 2
3 k4
4 k3
5 k1

 

ps2:

dict裏面的功能

info.keys() 默認循環他全部的key

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.keys():
19     print(item)

執行結果：

1 {'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18}
2 k4
3 2
4 k3
5 k1

 

ps3:

循環他的values()

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.values():
19     print(item)

執行結果：

1 {2: True, 'k4': (11, 22, 33, 44), 'k1': 18, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}]}
2 True
3 (11, 22, 33, 44)
4 18
5 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]

 

ps4: 

即想獲取key，又想獲取values

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.keys():    #即想獲取key，又想獲取values
19     print(item,info[item])

執行結果：

1 {'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k1': 18}
2 k4 (11, 22, 33, 44)
3 2 True
4 k3 [11, [], (), 22, 33, {'kk2': 'vv2', 'kk1': 'vv1', 'kk3': (11, 22)}]
5 k1 18

 

ps5:

獲取鍵值對

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             'kk1': 'vv1',
12             'kk2': 'vv2',
13             'kk3': (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for k,v in info.items():
19     print(k,v)

執行結果：

1 {'k1': 18, 2: True, 'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}]}
2 k1 18
3 2 True
4 k4 (11, 22, 33, 44)
5 k3 [11, [], (), 22, 33, {'kk2': 'vv2', 'kk1': 'vv1', 'kk3': (11, 22)}]

 

ps6:

True 1 False 0

1 info ={
2     "k1": 'asdf',
3     True: "123",
4     # [11,22]: 123
5     (11,22): 123,
6     # {'k1':' v1'}: 123
7 
8 }
9 print(info)

執行結果：

1 {True: '123', 'k1': 'asdf', (11, 22): 123}

 

ps7:  打印序號,並取出key和value的值

1 #打印序號,並取出key和value的值
2 dic = {'k1':123,123:123,'999':123}
3 for i,v ,in enumerate(dic.items(),1):
4     print(i,v[0],v[1])
5 
6 for i,v in enumerate(dic,1):
7     print(i,v,dic[v])

---

 複習字典：

字典:{},列表:[], 元組:()

總結：

一、字典key:value
二、字典的value的值能夠是任何值
三、布爾值、列表、字典不能做爲字典的key,但元組能夠，作爲列表的key
四、字典是無序的

 

1、字典的增長，刪除，修改，查詢

示例：

1 info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}

一、增長和修改

增長key和vlaue

 1 #修改value
 2 info['nulige']=18
 3 print(info)
 4 
 5 #增長
 6 info.update({'sunkai':18})
 7 print(info)
 8 
 9 #增長key和vlaue(沒有就增長，有就修改）
10 info['lihuafen']=35
11 print(info)

 往字典的列表中加入元 素

 1 #往wusir字典中加入一個元素44
 2 
 3 info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': [11,22,33]}
 4 info['wusir'].append(44)
 5 print(info)
 6 
 7 
 8 #往wusir字典的第一個位置插入個元素18
 9 info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': [11,22,33]}
10 info['wusir'].insert(0,44)
11 print(info)

 

二、刪除

 1 #刪除
 2 del info['nulige']
 3 print(info)
 4 
 5 #刪除
 6 info.pop('alex')
 7 print(info)
 8 
 9 #清空字典
10 info.clear()
11 print(info) #{}

 

三、查詢

獲取字典的key和values

 1 #取字典的key
 2 
 3 #法1：
 4 for item in info:
 5 print(item)
 6 
 7 #法2：
 8 for item in info.keys():
 9 print(item)
10 
11 #取字典的values
12 for item in info.values():
13 print(item)
14 
15 #取key和values
16 for item in info.keys():
17 print(item,info[item])

 

四、獲取字典鍵值對應的值

1 for k,v in info.items():
2 print(k,v)
3 
4 #結果：
5 nulige 28
6 alex 30
7 wusir woman
8 liuyang man

 

五、打印序號，取key和value

 1 info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}
 2 
 3 法一：
 4 for i,v,in enumerate(info.items(),1):
 5     print(i,v[0],v[1])
 6 
 7 法二：
 8 for i,v in enumerate(info,1):
 9     print(i,v,info[v])
10 
11 執行結果：
12 1 nulige 28
13 2 alex 30
14 3 wusir woman
15 4 liuyang man

 

六、計算字典總個數

1 info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}
2 print(len(info))
3 
4 #執行結果：
5 4

 

5、整理必須掌握的東西

1、數字
int(..)

2、字符串
replace/find/join/strip/startswith/split/upper/lower/format
tempalte = "i am {name}, age : {age}"
# v = tempalte.format(name='alex',age=19)
v = tempalte.format(**{"name": 'alex','age': 19})
print(v)

3、列表
append、extend、insert
索引、切片、循環

4、元組
忽略
索引、切片、循環         以及元素不能被修改

5、字典
get/update/keys/values/items
for,索引

dic = {
    "k1": 'v1'
}

v = "k1" in dic
print(v)

v = "v1" in dic.values()
print(v)

6、布爾值
0 1
bool(...)
None ""  () []  {} 0 ==> False