Python第二週Round2-其餘數據類型，列表，元祖，字典

這周太忙了，決算審計成天加班，上級公司年底檢查，在加上家中趙女士須要參加考試，真的是沒有時間，如今騰出空來，把這周學的知識總結一下。

先談下感覺把，學習真的是一件很辛苦的事，在年輕的時候感受力量是無窮的，沒啥事，幹就是了，可是如今感受有點慫x了，談什麼堅持啊，有時間睡個覺多美滋滋啊~不過python語言仍是很友好的，目前仍是動力十足的，加油。

---

1、列表list

列表數據類型是一種基本的數據類型，用於存儲多個數據，屬於可迭代的對象，且能夠修改，如li=[11,"小果果",33]

（一）列表的基本操做有下：

• 1.索引，用[n]表示，在前面有過敘述，表示列表中某個位置的元素是啥；
• 2.切片，用[n,n+j]表示；
• 3.相加，add
• 4.刪除，del
• 5.長度，len
• 6.循環，for i in li：
• 7.包含，

（二）列表的其餘須要注意的地方

1.經過使用list函數能夠將字符串轉換爲一個序列。(注意：list函數適用於全部類型的序列，而不僅是字符串)；

2.列表可使用全部適用於序列的標準操做，如索引、分片、鏈接和乘法；

（三）基本方法

1.append()

li = [11, 22, 33, "小果果是個笨蛋"]
li.append("，你認爲對不對？")
print(li)  # 輸出 [11, 22, 33, '小果果是個笨蛋', '，你認爲對不對？']

　　

根據輸出的結果，之後規定，字符串用單引號' '來表示，雖然用雙引號也沒有錯誤，可是要養成良好的習慣，不是嗎？

 

2.count() 

用於統計某個元素在列表中出現的次數

# 字符串的count()函數，我怎麼記得沒有記呢，是否是老年癡呆來？
li = "小果果是個笨蛋"
print(li.count("果"))  # 輸出 2

# 列表的count()函數，
li = [11, 22, 33, "小果果是個笨蛋"]
print(li.count(11))  # 輸出 1

　　

3.extend() 

能夠在列表末尾一次性追加另外一個序列中的多個值，和鏈接操做不一樣，extend方法是修改了被擴展的序列(調用extend方法的序列)，而原始的鏈接操做返回的是一個全新的列表

# 1.語法 L.extend(iterable)‘interable 可迭代對象’;
# 2.該方法沒有返回值，但會在原來的列表末尾追加可迭代對象中的元素,例子中，c的輸出值爲'None'；
# 3.把要拓展的list放到前面，括號裏面爲添加的數據
a = ['小果果是一隻狗', '棕色的', '捲毛的']
b = ['乖巧的', '母的', '沒有起牀氣的']
d = a + b
print(a)  # 輸出 ['小果果是一隻狗', '棕色的', '捲毛的'] 代表a列表沒有被改變，d爲一個全新的序列
c = a.extend(b)  # 輸出 None
print(a)  # 輸出 ['小果果是一隻狗', '棕色的', '捲毛的', '乖巧的', '母的', '沒有起牀氣的']

　　

重點：對於append()方法和extend()方法的區別

(1).append()方法是將要添加的對象看做一個總體加到添加對象的末尾，能夠是一個int，啥均可以（由於任何數據類型均可以添加到list當中）

(2).extend()方法必須是添加可迭代對象，interable的數據，若是添加int類型，bool類型，對不起，報錯。且添加的是對象中的每個可迭代對象。

4.index()用於從列表中找出某個值第一個匹配項的索引位置

 輸出的是int類型

 

5.insert()

# 1.語法：L.insert(index, object) -- insert object before index
# 2.做爲一個總體插入
a = ['小果果是一隻狗', '棕色的', '捲毛的']
b = [11, 22, 33, 44]
a.insert(2, b)
print(a) #輸出 ['小果果是一隻狗', '棕色的', [11, 22, 33, 44], '捲毛的']

　　

6.pop()

移除列表中的一個元素(默認是最後一個)，而且返回該元素的值。經過pop方法能夠實現一種常見的數據結構——棧（LIFO，後進先出）。

# 1.語法  L.pop([index]) -> item -- remove and return item at index (default last)；
# 2.超出index的值會報錯返回。
a = ['小果果是一隻狗', '棕色的', '捲毛的']
a.pop(2)
print(a)  # 輸出 ['小果果是一隻狗', '棕色的']

　　

其實就是一個定點刪除的功能，無切片刪除功能。

 

6.remove()

移除列表中某個值的第一個匹配項

# 1.語法 L.remove(value) -> None -- remove first occurrence of value.
# 2.返回值爲None，也就是說無數據返回，直接對list進行了修改，同extend等，列表不少都是這樣的，畢竟是能夠修改的數據類型，須要記住！
# 3.無數據時，報錯返回！
a = ['小果果是一隻狗', '棕色的', '捲毛的']
a.remove('棕色的')
print(a)  # 輸出 ['小果果是一隻狗', '捲毛的']

　　

7.reverse()

將列表中的元素反向存放

# 1.語法 L.reverse() -- reverse *IN PLACE*
a = ['小果果是一隻狗', '棕色的', '捲毛的']
a.reverse()
print(a)  # 輸出 ['捲毛的', '棕色的', '小果果是一隻狗']

　　

8.sort()

對列表進行排序。注意：sort函數時沒有返回值的(None),它做用於源list。能夠經過sorted函數來獲取已排序的列表副本。

# 1.L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
# 2.key-- 可選參數, 若是指定了該參數會使用該參數的方法進行排序。
# reverse-- 可選參數，是否反向排序，默認爲False。
# 3.新函數: sorted() 可對全部可迭代的對象進行排序，返回list數據。
a = ['小果果是一隻狗', '棕色的', '捲毛的']
a.sort()
print(a)  # 輸出 ['捲毛的', '棕色的', '小果果是一隻狗']
print(sorted('hello'))  # 輸出 ['e', 'h', 'l', 'l', 'o']

　　

排序規則（list中）：

(1)int數據，默認是升序排列；

(2)str類型中的漢字排序問題：此問題很難，是個很是複雜的問題，後續學景氣了，在回來解決，若是對中文排序的問題。（或許有模塊，可是如今還沒接觸，暫且看成一個負責的問題看待）

問題2：函數和方法的區別，後續補充。

 

---

 

2、元祖

元組和列表最大的區別在於：元組不能修改。

（一）基本規則

建立元組很簡單，只須要將元素用括號括起來，並使用逗號分隔符(即便只有一個元素)來分隔各個元素便可：

在tuple的末尾加個逗號','以示專業，沒有任何區別，至於爲何，我也不知道，老炮兒說的。

a = ('阿', '吃', '拔', '阿大', '拔蘿蔔', '吃飯',)
print(type(a))  # 輸出 <class 'tuple'>

　　

（二）基本用法

• 1.索引
• 2.切片
• 3.循環
• 4.長度
• 5.包含

 

（三）tuple的方法

就倆 count()和index()

---

3、字典

（一）基本規則

字典（dict）中的值沒有特定順序。

鍵能夠是數字、字符串甚至是元組。鍵通常是惟一的，若是重複最後的一個鍵值對會替換前面的，值不須要惟一。

字典是無序的，每次輸出，順序都會隨機發生變化

a = {1: '阿', 2: '吃', 3: '拔', 4: '阿大', 5: '拔蘿蔔', 6: '吃飯', }
print(type(a))  # 輸出 <class 'dict'>

　　

（二）基本方法

• 1.索引
• 2.新增
• 3.刪除
• 4.鍵、值、鍵值對
• 5.循環——說明也是可迭代對象
• 6.長度　

（三）其餘方法

這裏在ppycharm中調用使用手冊時，出了個小插曲~

敲入 dict()，而後ctrl+單擊時，並無出現字典的方法

而敲入dict{}，而後就出現了~很奇怪，至因而爲何，暫時沒有相通，後續學完這段課程整理時候，在回來作解釋。

1.clear()

函數會清除字典中全部的項

# 語法 D.clear() -> None.  Remove all items from D
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
a.clear()
print(a)  # 輸出 {}

　　

2.copy()

函數會返回一個具備相同key-value對的新字典(淺複製)

# 語法 D.copy() -> a shallow copy of D
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
b = a.copy()
print(b)  # 輸出 {1: '小果果', 2: '棕色的', 3: '捲毛的'}

　　

這裏又有一個小插曲，前面也講到了在元祖的最後加一個逗號，其實，實踐證實，在list/元祖/字典的最後加個逗號，都不會改變原來的值

3.fromkeys()

建立一個新字典，fromkeys(*args, **kwargs) 以*args中元素作字典的鍵，**kwargs爲字典全部鍵對應的初始值

# 語法 Returns a new dict with keys from iterable and values equal to value
# fromkeys(*args, **kwargs)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
b = 'aaaa'
new_a = dict.fromkeys(a)
new_b = dict.fromkeys(b, 2)
print(new_a, a)  # 輸出 {1: None, 2: None, 3: None} {1: '小果果', 2: '棕色的', 3: '捲毛的'}
print(new_b, b)  # 輸出 {'a': 2} aaaa

　　

須要注意的地方，在python的api文件中，*args和**kwargs是表示可使用任何數據類型或者值，可是對於fromkeys方法，其實只有元祖和字典是有用的，用其餘的，都沒啥意思。

且此函數api中標註爲  @staticmethod ，爲靜態方法，後續在細細探究，此地方留個疑問。

 

4.get()

能夠訪問字典中的項，若是不存在，返回一個None（或者自定義一個默認值）或者返回給定d的值

# 語法 D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None
# get(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
s = a.get(5, '哈哈')
print(s)  # 輸出 哈哈

　　

5.items()

循環獲取key和value，返回的爲列表數據。通常用於for語句迭代

# 語法 D.items() -> a set-like object providing a view on D's items
# items(self)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
s = a.items()
print(s)  # 輸出 dict_items([(1, '小果果'), (2, '棕色的'), (3, '捲毛的')])

　　

6.keys()

循環獲取字典中全部key，通常用於for循環迭代。

# 語法 D.keys() -> a set-like object providing a view on D's keys
# keys(self)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
s = a.keys()
print(s)  # 輸出 dict_keys([1, 2, 3])

　　

7.pop()

刪除指定的key，pop(self, k, d=None)  參數： k:待刪除的key    d:指定參數，若k存在，則沒吊用，若是k不存在，返回d的值

# 語法  D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
# If key is not found, d is returned if given, otherwise KeyError is raised
# pop(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的', }
a.pop(1)
print(a)  # 輸出 {2: '棕色的', 3: '捲毛的'}

　　

8.popitem()

隨機刪除一個鍵值對

# 語法  D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.
# popitem(self)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的'}
a.popitem()
print(a)  # 輸出 {2: '棕色的', 3: '捲毛的'}

　　

9.setdefault()

給字典設置(增長)新的鍵，存在就不設置(獲取當前key對應的值)，不存在就設置並返回當前key對應的值  setdefault(self, k, d=None) 參數：k:待設置(添加)的key 　　d:默認爲空，能夠指定value值

# 語法  D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
# setdefault(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的'}
a.setdefault(4, 'ss')
print(a)  # 輸出 {1: '小果果', 2: '棕色的', 3: '捲毛的', 4: 'ss'}

　　

 10.update()

更新字典

# 語法  D.update([E, ]**F) -> None
# update(self, E=None, **F)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的'}
b = {3: '母的', 4: '沒有起牀氣的', 5: None}
a.update(b)
print(a)  # 輸出 {1: '小果果', 2: '棕色的', 3: '母的', 4: '沒有起牀氣的', 5: None}

　　

幾點須要主義的：

（1）若是E中的keys和D中的keys是重合的，把E中的元素覆蓋到D中

（2）E只能是字典，試了試，用其餘的數據類型不能夠

（3）update()後，會根據keys的值，對字典進行排序

 

11.values()

將字典中的值以列表的形式返回，通常用於for循環，和keys()取得東西剛恰好相反。

# 語法  D.values() -> an object providing a view on D's values
# update(self, E=None, **F)
a = {1: '小果果', 2: '棕色的', 3: '捲毛的'}
print(a.values())  # 輸出 dict_values(['小果果', '棕色的', '捲毛的'])