Python中列表、元組、字典、集合與字符串，相關函數，持續更新中……

• 2020 年 10 月 16 日
• 筆記
• Python

本篇博客為博主第一次學 Python 所做的筆記（希望讀者能夠少點浮躁，認真閱讀，平心靜氣學習！）

補充：

• 列表、元組和字符串共同屬性：
  • 屬於有序序列，其中的元素有嚴格的先後順序
  • 都支持雙向索引，索引範圍 [ -L, L-1 ] ，L — 表示列表、元組和字符串的長度（分正向索引和反向索引）。
    • 正向索引：0 表示第 1 個元素，1 表示第 2 個元素，2 表示第 3 個元素…
    • 反向索引：-1 表示最後 1 個元素，-2 表示倒數第 2 個元素，-3 表示倒數第 3 個元素…

一、列表（關於列表的所有內容）：

放在一對方括號中，相鄰元素之間使用逗號分隔。

• 同一個列表元素的數據類型可以各不相同。
• 列表包含：
  1. 整數、浮點數、複數、字符串 等 基本類型元素。
  2. 列表、元組、字典、集合、函數 或 其他任意對象。

創建列表：

• 使用方括號直接創建
• list() 函數把元組、range 對象、字符串、字典、集合，以及 map 對象、zip 對象、enumerate 對象或其他類似對象 轉換 為列表。
• 內置函數（ sorted() ）、標準庫函數（ random.sample() ）或擴展函數（ jieba.lcut() ）也會返回列表

函數：

1. 訪問元素：

• 用戶可以使用整數作為下標來隨機訪問其中任意位置上的元素

  data = list(range())
  # data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  print(data[1])
  # 結果 1
  print(data[-1])
  # 結果 9
  ……
  

• 如果指定的下標不在有效範圍內，代碼會拋出異常提示下表越界

2. 其他常用方法：

lst – 表示列表對象

3. 推導式：

使用 非常簡潔 的方式對列表或其他可迭代對象的元素進行遍歷、過濾或再次計算，快速生成滿足特定需求的新列表。

# 格式：
[expression for expr1 in sequence1 if condition
			for expr2 in sequence2 if condition2
			for expr3 in sequence3 if condition3
			...
			for exprN in sequenceN if conditionN
]

# 例子：
data = [num for num in range(20) if num%2==1]
# 等價於 =>
data = []
for num in range(20):
	if num%2 == 1:
		data.append(num)

二、元組（關於元組的所有內容）：

創建元組：

• 用圓括號放若干元素創建元組（如果只有一個元素，則需要多加一個逗號 (3,)）
• 用 tuple() 函數把 列表、字典、集合、字符串 以及 range 對象、map 對象、zip 對象 或 其他類似對象轉換為元組

元組的好處（與列表對比）：

三、字典（關於字典的所有內容）：

• 屬於容器對象，其中包含若干元素，每個元素包含 「鍵」 和 「值」 兩部分，之間使用冒號分隔，表示一種對應關係。
• 不同元素之間使用逗號分隔，所有元素放在一對大括號中。
• 「鍵」，可以是 Python 中任意不可變數據，例如整數、複數、字符串、元組等類型；不能是列表、集合、字典或其他可變類型，包含列表等可變數據的元組也不能作為字典的 「鍵」

函數：

1. 訪問：

# 初始化
data = dict(name = "張三"， age = 8, sex = 'M')

• 把 「鍵」 最為下標可以返回對應的 「值」（不存在的話會拋出異常）

print(data('name'))
# 結果：張三

• get() 方法獲取指定的 「鍵」 對應的 「值」（不存在返回空值或指定的值）

print(data.get('age'))
# 結果：18

• 支持元素迭代
  • 可以將其轉換為列表或元組

    print(list(data))
    # 結果：['name', 'age', 'sex']
    

  • 可以使用 for 循環遍歷其中的元素，默認情況下是遍歷字典中的 「鍵」

    for key, value in data.items():
    	print(key, value, sep='\t')
    # 結果：name 張三
    # 結果：age 18
    # 結果：sex M
    

  • 遍歷字典元素，必須使用字典對象的 items() 方法明確說明

    print(list(data.items()))
    # 結果：[('name', '張三'), ('age', '18'), ('sex', 'M')]
    

  • 遍歷字典的 「值」，則必須使用字典對象的 values() 方法明確說明

    print(list(data.values()))
    # 結果：['張三', '18', 'M']
    

2. 修改：

當以指定 「鍵」 為下標為字典元素賦值時：

• 若該 「鍵」 存在，表示修改該 「鍵」 對應的值：

soct = {'IP': '127.0.0.1', 'port': 80}
soct['port'] = 8080
print(soct)
# 結果：{'IP': '127.0.0.1', 'port': 8080}

• 若 「鍵」 不存在，表示添加一個新元素：

soct = {'IP': '127.0.0.1', 'port': 80}
soct['protocol'] = 'TCP'
print(soct)
# 結果：{'IP': '127.0.0.1', 'port': 80, 'protocol': 'TCP'}

3. 添加：

update() 方法可以將另一個字典的元素一次性全部添加到當前字典中，如果兩個字典中存在相同的 「鍵」，則以另一個字典中的 「值」 為準對當前字典進行更新：

sock = {'IP': '127.0.0.1', 'port': 80}
sock.update({'IP': '192.168.9.62', 'protocol': 'TCP'})
print(sock)
# {'IP': '192.168.9.62', 'protocol': 'TCP', 'port': 80}

4. 刪除：

sock = {'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}

• pop() 方法可以刪除指定 「鍵」 對應的元素，同時返回對應的 「值」。

print(sock.pop('IP'))
# 結果：192.168.9.62

• popitem() 方法用於刪除並返回一個包含兩個元素的元組，其中的兩個元素分別是字典元素的 「鍵」 和 「值」。

print(sock.popitem())
# 結果：('protocol', 'TCP')

• del 刪除指定的 「鍵」 對應的元素。

del sock['port']
print(sock)
# 結果：{'IP': '192.168.9.62', 'protocol': 'TCP'}

四、集合（關於集合的所有內容）：

無序、可變的容器對象，所有元素放在一對大括號中，元素之間使用逗號分隔，同一個集合內的每個元素都是唯一的，不允許重複。

0. 創建：

• 所有元素放在一對大括號中，創建集合

data = {30, 40, 50}

• 使用 set() 函數將列表、元組、字符串、range 對象等其他可迭代對象轉換為集合。
• 使用集合推導式生成特定的集合，如果原來的數據中存在重複元素，在轉換為集合的時候重複的元素只保留一個，自動除去重複元素。
• 如果原序列或迭代對象中有可變類型的數據，則無法轉換成為集合，拋出異常。

特點：

• 集合內數據要求：
  • 集合中只能包含數字、字符串、元組等不可變類型的數據
  • 不包含列表、字典、集合等可變類型的數據，包含列表等可變類型數據的元組也不能作為集合的元素。
• 元素是無序的，元素儲存順序和添加順序並不一致。

1. 訪問：

• 集合不支持使用下標直接訪問特定位置上的元素，也不支持使用 random 中的 choice() 函數從集合中隨機選取元素
• 支持使用 random 模塊中的 sample() 函數隨機選取部分元素。

2. 修改：

data = {30, 40, 50}
data.add(20)
print(data)
# 結果：{40, 50, 20, 30}

data = {30, 40, 50}
data.update({40, 60})
print(data)
# 結果：{50, 40, 60, 30}

3. 刪除：

data = {30, 40, 50}
data.remove(30)
print(data)
# 結果：{40, 50}

data = {30, 40, 50}
data.discard(30)
print(data)
# 結果：{40, 50}

data = {30, 40, 50}
data.pop()
print(data)
# 結果：{50, 30}

五、字符串（關於字符串的所有內容）：

字符串屬於不可變對象。

1. 編碼與解碼

2. 將數據格式轉化為特定格式的字符串

常用的格式：

• b（二進制格式）
• c（把整數轉換成 Unicode 字符）
• d（十進制格式）
• o（八進制格式）
• x（小寫十六進制格式）
• X（大寫十六進制格式）
• e/E（科學計數法格式）
• f/F（固定長度的浮點數格式）
• %（使用固定長度浮點數顯示百分數）

# 保留4位小數
# 0 表示參數下標，對應第一個參數
print('{0:.4f}'.format(10/3))
# 結果：3.3333
print('{0:.2%}'.format(1/3))
# 結果：33.33%

# 格式化為百分數字符串，總寬度為10，保留2位小數，> 表示右對齊
print('{0:>10.2%}'.format(1/3))
# 結果：    33.33%

# 逗號表示在數字字符串中插入逗號作為千分符，#x表示格式化為十六進制數
print("{0:,} in hex is: {0:#x}, in oct is {0:#o}".format(5555555))
# 結果：5,555,555 in hex is: 0x54c563, in oct is 0O25142543

# 可以先格式化下標為 1 的參數，再格式化下標為 0 的參數
print("{1} in hex is: {1: #x}, {0} in oct is {0:o}".format(6666, 66666))
# 結果：66666 in hex is: 0x1046a, 6666 in oct is 15012

# _表示在數字中插入下劃線來為千分符
print('{0:_}, {0:#_x}'.format(10000000))
# 結果：10_000_000, 0x98_9680

3. 單個字符串在字符串中的相關函數

4. 字符串的編輯修改

text = "python 是一門非常棒的編程語言。"
print(text.replace('棒', '優雅').replace('編程', '程序設計'))
# 結果：python 是一門非常優雅的程序設計語言。

table = ''.maketrans('0123456789', '零壹貳叄肆伍陸柒捌玖')
print('Tel:30647359'.translate(table))
# 結果：Tel:叄零陸肆柒叄伍玖

5. 字符串進行排版

print('居左'.ljust(20)+'結束')
# 結果：居左				結束
print('居右'.rjust(20, '#'))
# 結果：####################居右
print('居中'.center(20, '='))
# 結果：==========居中==========

6. 自定義分隔符對字符串分隔

不指定默認為空格、換行符和製表符等空白字符）作為分隔符對原字符串進行分隔

text = 'Beautiful is better than ugly.'
print(text.split())
# 結果：['Beautiful', 'is', 'better', 'than', 'ugly.']

print(text.split(maxsplit=1))
# 結果：['Beautiful', 'is better than ugly.']

print('1,2,3,4'.split(','))
# 結果：['1', '2', '3', '4']

print(','.join(['1', '2', '3', '4']))
# 結果：1,2,3,4

print(':'.join(map(str, range(1, 5))))
# 結果：1:2:3:4

7. 大小寫轉換

text = 'Explicit is better than implicit.'
print(text.lower())
# 結果：explicit is better than implicit.

print(text.upper())
# 結果：EXPLICIT IS BETTER THAN IMPLICIT.

print(text.capitalize())
# 結果：Explicit is better than implicit.

print(text.title())
# 結果：Explicit Is Better Than Implicit.

print(text.swapcase())
# 結果：eXPLICIT iS bETTER tHAN iMPLICIT.

8. 判斷字符串開始與結束單詞

測試字符串是否以指定的一個或幾個字符串（放在元組中）開始或結束

text = 'Simple is better than complex.'
print(text.startswith('simple'))
# 結果：False

print(text.startswith('Simple'))
# 結果：True

print(text.endswith(('.', '!', '?')))
# 結果：True

9. 刪除字符串指定字符

刪除字符串兩側、右側和左側的空白字符或指定的字符

text = '     ======test===#####     '
print(text.strip())
# 結果：======test===#####

print(text.strip('=# '))
# 結果：test