7. 基本資料型別的內建方法

1. 列表的內建方法

1.1 優先掌握的內建方法

1.1.1 強制型別轉換

可以將可迭代型別轉換為列表型別

print(list('messi'))  # ['m', 'e', 's', 's', 'i']
print(list((1, 2, 3)))  # [1, 2, 3]
print(list({4, 5, 6}))  # [4, 5, 6]

list方法在強制轉換字典的時候預設轉換出來的是字典的鍵

print(list({'name': 'messi', 'goals': 91}))  # ['name', 'goals']

強調：列表轉換成字串之後無法再重新轉回列表

1.1.2 索引取值

正向索引/負向索引

1.1.3 切片

與字串切片方法一樣

列表[起始索引：終止索引：步長]

a = ['messi', 'ronaldo', 'neymar', 'kylian', 'haaland']
print(a[0:3])  # ['messi', 'ronaldo', 'neymar']
print(a[0:3:2])  # ['messi', 'neymar']
# 將列表順序翻轉
print(a[::-1])  # ['haaland', 'kylian', 'neymar', 'ronaldo', 'messi']

1.1.4 計算長度

len

1.1.5 成員運算

in / not in

判斷某個元素是否在當前列表中

1.1.6 向列表中新增元素

方式一：新增在列表結尾

a = [1, 2, 3]
a.append(4)
print(a)  # [1, 2, 3, 4]

方式二：插入到指定的索引位置

a = [1, 2, 3]
a.insert(0, 'messi')
print(a)  # ['messi', 1, 2, 3]

方式三：將兩個列表整合到一起（擴充套件列表）

# for迴圈將兩個列表整合到一起
a = [1, 2, 3]
b = [4, 5, 6]
for i in b:
    a.append(i)
print(a)  # [1, 2, 3, 4, 5, 6]

# extend方法將兩個列表整合到一起
a = ['messi', 'neymar', 'ronaldo']
b = [1, 2, 3]
a.extend(b)
print(a)  # ['messi', 'neymar', 'ronaldo', 1, 2, 3]

1.1.7 刪除列表中的元素

方式一：按照指定的值刪除指定的元素remove

a = ['messi', 'neymar', 'ronaldo', 'kylian', 'haaland']
print(a.remove('messi'))  # None  沒有返回值
print(a)  # ['neymar', 'ronaldo', 'kylian', 'haaland']

方式二：彈出指定元素pop

a = [1, 2, 3, 4, 5, 6]
# 預設彈出最後一個元素
print(a.pop())  # 6  有返回值
print(a)  # [1, 2, 3, 4, 5]
# 彈出指定索引對應的元素
print(a.pop(2))  # 3  有返回值
print(a)  # [1, 2, 4, 5]

方式三：刪除指定索引對應的元素del

a = [1, 2, 3, 4, 5, 6]
del a[2]  # 不能返回，使用print會報錯
print(a)  # [1, 2, 4, 5, 6]

方式四：將列表清空clear

a = [1, 2, 3]
a.clear()
print(a)  # []

1.1.8 翻轉元素，作用在原列表reverse

a = [1, 2, 3, 4, 5, 6]
# 使用通用方法翻轉
print(a[::-1])  # [6, 5, 4, 3, 2, 1]
print(a)  # [1, 2, 3, 4, 5, 6]  原列表沒有得到改變
# 使用reverse方法翻轉
print(a.reverse())  # None 沒有返回值
print(a)  # [6, 5, 4, 3, 2, 1] 原列表得到改變

1.1.9 對列表中的元素進行排序，作用在原列表sort

a = [2, 4, 5, 9, 1, 3, 8, 6, 7]
# 預設的排序方式是正序
print(a.sort())  # None  沒有返回值
print(a)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 給sort加上引數reverse
b = [2, 4, 5, 9, 1, 3, 8, 6, 7]
b.sort(reverse=True)
print(b)  # [9, 8, 7, 6, 5, 4, 3, 2, 1] 列表先正序，後翻轉
c = [2, 4, 5, 9, 1, 3, 8, 6, 7]
c.sort(reverse=False)
print(c)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 補充方法：sorted(列表)，把列表當引數而不是呼叫
d = [2, 4, 5, 9, 1, 3, 8, 6, 7]
print(sorted(d))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]  有返回值
print(d)  # [2, 4, 5, 9, 1, 3, 8, 6, 7]

總結：

sort 使用方法：列表.sort() 沒有返回值 作用在原列表

sorted 使用方法：sorted(列表) 有返回值 不會作用在原列表

1.1.10 列表遍歷迴圈

for迴圈

while迴圈

2. 元組的內建方法

回顧：

一個元素的元組要加，逗號

不加逗號變成了元素原本的型別

在定義字串或者其它資料型別時加了，逗號就成了元組

2.1 強制型別轉換

可以將可迭代型別轉換成元組

2.2 索引取值

2.3 切片

[起始索引：結束索引：步長]

a = (1, 2, 3, 4, 5, 6)
print(a[1:3])  # (2, 3)
print(a[0:5:2])  # (1, 3, 5)
print(a[::-1])  # (6, 5, 4, 3, 2, 1)

sort方法是列表的排序方法，不是元組的

2.4 計算長度

len

2.5 成員運算

in / not in

2.6 遍歷

for迴圈

while迴圈

2.7 元組拼接

a = (1, 2, 3)
b = (4, 5, 6)
# 方式一：元組.__add__(元組)   返回一個新的元組，不會作用在原來的元組
print(a.__add__((666,)))  # (1, 2, 3, 666)
print(a)  # (1, 2, 3)
# 方式二：使用 + 進行拼接
print(a + b)  # (1, 2, 3, 4, 5, 6)

2.8 元組的重複

元組*數字 將當前元組的所有元素重複指定次數併產生新的元組

a = ('j', 'q', 'k')
print(a * 3)  # ('j', 'q', 'k', 'j', 'q', 'k', 'j', 'q', 'k')

3. 布林型別的內建方法

強制型別轉換 bool()

在python中為假的情況：

1. 布林值False

2. 數字0

3. 空的其它型別

print(bool(False), type(bool(False)))  # False <class 'bool'>
print(bool(0), type(bool(0)))  # False <class 'bool'>
print(bool(''))  # False
print(bool([]))  # False
print(bool(()))  # False
print(bool({}))  # False

其它情況均為真：

1. 布林值True

2. 數字1

3. 有值的其它型別，空格也算字串也算有值

print(bool(True))  # True
print(bool(1))  # True
print(bool(['a']))  # True
print(bool(' '))  # True

4. 字典的內建方法

字典中的鍵必須是不可變的，通常使用字串、數字、布林值作為鍵

字典中的值可以是任意型別，包括數字、字串、列表、字典等

4.1 取值

# （1）字典[key]
#  這種方法取字典中沒有的鍵會報錯
a = {'name': 'kylian', 'id': 9, 'country': 'France', True: 'psg'}
print(a['id'])  # 9
print(a[True])  # psg
# （2）字典.get(鍵)
print(a.get('name'))  # kylian
print(a.get('hobby'))  # 如果字典中沒有當前的鍵，返回的就是None
print(a.get('hobby', 'goat'))  # goat 沒有鍵取不到值可以指定預設值

4.2 計算長度

len 計算字典中的鍵值對個數

4.3 成員運算

判斷某個鍵是否在字典中，而不是某個值

print('name' in a)  # True
print('kylian' in a)  # False

4.4 增加元素

字典的特性：有則新增，無則修改

（1）方式一：字典[key] = value

a = {'name': 'kylian', 'id': 9, 'country': 'France'}
a['club1'] = 'psg'
print(a)  # {'name': 'kylian', 'id': 9, 'country': 'France', 'club1': 'psg'}

（2）方式二：字典.update({key:value})

a = {'one': 1, 'two': 2, 'three': 3}
b = {'four': 4, 'five': 5, 'six': 6}
# 遍歷字典b，新增到字典a中
for i in b:
    a[i] = b[i]
print(a)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

（3）方式三：字典.update(key=value)

以上使用=的方式i是一個固定的值，以下使用鍵值對的形式i可隨遍歷而改變

（4）方式四：字典.update(字典)

m = {'a': 1, 'b': 2, 'c': 3}
n = {'d': 4, 'e': 5, 'f': 6}
m.update(n)
print(m)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

相比於方式二for迴圈遍歷增加一個字典所有元素，方式四程式碼更簡潔

（5）方式五：setdefault(key, value)

向字典中設定當前鍵對應的預設值

setdefault(key，value)方法用於獲取指定鍵的值；如果鍵不存在，則返回預設值，並在字典中新增新鍵值對；如果鍵存在，則返回鍵原本對應的值

4.5 刪除元素

info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
# 方式一：del字典[key]     按照鍵刪除字典對應的鍵值對
del info['club']  # 沒有返回值，不能用變數接收
print(info)  # {'name': 'kylian', 'id': 9, 'goal': 91}

# 方式二：字典.pop(key)    按照鍵刪除字典對應的鍵值對彈出
res = info.pop('id')
print(res)  # 9  相比於方式一有返回值，且可以用變數接收
print(info)  # {'name': 'kylian', 'goal': 91}

# 方式三：清空字典
info.clear()
print(info)  # {}

# 方式四：彈出最後一個位置的鍵值對
info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
res = info.popitem()
print(res)  # ('goal', 91)
print(info)  # {'name': 'kylian', 'id': 9, 'club': 'psg'}

4.6 取出字典中所有的鍵、所有的值、所有的鍵值對

info = {'a': '1', 'b': 2, 'c': 3}
# （1）獲取字典中所有的鍵
print(info.keys())
# dict_keys(['a', 'b', 'c']) 可以看成是列表，可以用for迴圈取出
print(type(info.keys()))  # <class 'dict_keys'>

# （2）獲取字典中所有的值
print(info.values())
# dict_values(['1', 2, 3]) 可以看成是列表

# （3）獲取字典中所有的鍵值對
print(info.items())
# dict_items([('a', '1'), ('b', 2), ('c', 3)]) 可以看成是列表巢狀元組
for k, v in info.items():
    print(k)  # a  b  c  
    print(v)  # 1  2  3

5. 集合的內建方法

集合的特點是無序且去重

5.1 強制型別轉換

print(set('messi'))  
# {'e', 'm', 's', 'i'}
print(set([1, 2, 3]))  
# {1, 2, 3}
print(set(('j', 'q', 'k')))  
# {'q', 'k', 'j'}
print(set({'a': 11, 'b': 22, 'c': 33}))  
# {'c', 'a', 'b'}

5.2 新增元素

a = {1, 2, 3, 4, 5}
# 新增單個元素
print(a.add(6))  # None
print(a)  # {1, 2, 3, 4, 5, 6}
# 一次新增多個元素
a.update((11, 22, 33))  # 只能是可迭代型別
print(a)  # {1, 2, 3, 4, 5, 6, 11, 22, 33}

5.3 刪除元素

# 方式二：pop
# 集合的pop預設彈出第一個元素，而列表的pop預設彈出最後一個元素
b = {'messi', 'ronaldo', 'neymar', 'kylian'}
print(b.pop())  # messi  索引為0的位置
print(b)  # {'ronaldo', 'neymar', 'kylian'}

5.4 其它方法

計算長度len

遍歷迴圈for

成員運算 in / 　 not in