從“CRUD”，看Python的常見資料類型

前言

最近一段時間換了新工作，忙于熟悉新環境、新業務，很久沒有更新推文了。

之前所寫這篇文章是因為最近在幫助團隊招聘、面試的過程中，看到很多人的履歷上都提及自己擅長功能測試，擅長Python以及各類的自動化測試架構、測試工具，而當我提問用過哪些方法進行測試用例設計時，大多數同學的回答都是等價類劃分、邊界值，其他的甚至都沒聽說過；當我問到Python有哪些常見的資料類型以及它們有哪些常用方法、哪些是可變類型等這些基礎的問題時，很多人都答不上來。

可見，很多小夥伴的基礎都還不是太牢靠。履歷上各種技術寫得再天花亂墜，如果基礎一問三不知，則會給人一種華而不實的感覺。借此篇文章，我将通過類比資料庫CRUD的方式，從新增、修改、删除、查詢等角度來介紹Python中常見的資料類型以及它們的一些特性，并作出總結，也權當是作一個自我鞏固複習的過程。

Python基本的資料類型

當問及Python有哪些常見的資料類型時，很多人都知道有整型(int)、浮點型(float)、布爾型(bool)、字元串型(string)、清單(list)、字典(dictionary)、元組(tuple)、集合(set)。但其實整型、浮點型、布爾型都可以歸結為數字型(number)，是以Python中基本資料類型如下：

• 數字型(number)
• 字元串型(string)
• 清單(list)
• 字典(dictionary)
• 元組(tuple)
• 集合(set)

清單(list)

一、建立清單

從形式上看，清單會将所有元素都放在一對中括号[ ]裡面，相鄰元素之間用逗号,分隔，如下所示：

[element1, element2, element3, ..., elementn]

在 Python 中，建立清單的方法可分為兩種：

1.使用 [ ] 直接建立清單

使用[ ]建立清單後，一般使用=将它指派給某個變量，具體格式如下：

listname = [element1 , element2 , element3 , ... , elementn]

其中，listname 表示變量名，element1 ~ elementn 表示清單元素。

# 使用[]建立清單
list_number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list_str = ["lucy", "kitty", "nick"]           

2.使用 list() 函數建立清單

除了使用[ ]建立清單外，Python 還提供了一個内置的函數 list()，使用它可以将其它資料類型轉換為清單類型。

# 使用list()函數将其他資料類型轉換為清單
# 轉換字元串
name = "hello"
list_name = list(name)
print(list_name)  # ['h', 'e', 'l', 'l', 'o']
# 轉換元組
tuple1 = ("age", "name", "height", "weight")
list_tu = list(tuple1)
print(list_tu)  # ['age', 'name', 'height', 'weight']
# 轉換字典
dict1 = {"name": "大剛", "age": 29, "height": "175cm", "weight": "70kg"}
list_dic = list(dict1)
print(list_dic)  # ['name', 'age', 'height', 'weight']           

二、通路清單元素

清單是 Python 序列的一種，我們可以使用索引（Index）通路清單中的某個元素（得到的是一個元素的值），也可以使用切片通路清單中的一組元素（得到的是一個新的子清單）。

◆ 使用索引通路清單元素的格式為：listname[i]

其中，listname 表示清單名字，i 表示索引值。清單的索引可以是正數，也可以是負數。

◆ 使用切片通路清單元素的格式為：listname[start : end : step]

其中，listname 表示清單名字，start 表示起始索引，end 表示結束索引，step 表示步長。

◆ 擷取清單所有元素：listname[:]

# 通路清單元素
list_number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list_number[0])  # 清單第一個元素，1
print(list_number[-1])  # 清單最後一個元素,9
print(list_number[0:5])  # 清單切片，[1, 2, 3, 4, 5]
print(list_number[0:-1:2])  # 清單切片、并指定步長，[1, 3, 5, 7]
print(list_number[-5:-1:1])  # 使用負數切片、并指定步長，[5, 6, 7, 8]
print(list_number[:])  # 擷取清單所有元素，[1, 2, 3, 4, 5, 6, 7, 8, 9]           

三、清單添加元素

實際開發中，經常需要對 Python 清單進行更新，包括向清單中添加元素、修改表中元素以及删除元素。一共有3種方法：

1.append()方法添加元素

append() 方法用于在清單的末尾追加元素，該方法的文法格式如下：listname.append(obj)

其中，listname 表示要添加元素的清單；obj 表示到添加到清單末尾的資料，它可以是單個元素，也可以是清單、元組等。

# 清單添加元素
list_app = [1, 2, 3]
# 添加元素-append
list_app.append(4)  # 在末尾添加
print(list_app)  # [1, 2, 3, 4]           

2.extend()方法添加元素

extend() 方法的文法格式如下：listname.extend(obj)

其中，listname 指的是要添加元素的清單；obj 表示到添加到清單末尾的資料，它可以是單個元素，也可以是清單、元組等。

# 清單添加元素
list_app = [1, 2, 3]
# 添加元素-extend
a = ['a', 'b', 'c']
list_app.extend(a)  # 清單添加清單，在末尾添加
print(list_app)  # [1, 2, 3, 4, 'a', 'b', 'c']
b = (110, 120, 119)
list_app.extend(b)  # 清單添加元組，在末尾添加
print(list_app)  # [1, 2, 3, 4, 'a', 'b', 'c', 110, 120, 119]           

3.insert()方法插入元素

insert() 的文法格式如下：listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 會将 obj 插入到 listname 清單第 index 個元素的位置。

# 清單添加元素
list_app = [1, 2, 3]
# 添加元素-insert
list_app.insert(0, 555)  # 在指定位置添加元素
print(list_app)  # [555, 1, 2, 3, 4, 'a', 'b', 'c', 110, 120, 119]           

四、清單删除元素

在 Python 清單中删除元素主要分為以下 3 種場景：

• 根據目标元素所在位置的索引進行删除，可以使用 del 關鍵字或者 pop() 方法；
• 根據元素本身的值進行删除，可使用清單（list類型）提供的 remove() 方法；
• 将清單中所有元素全部删除，可使用清單（list類型）提供的 clear() 方法。

1.del：根據索引值删除元素

• del 可以删除清單中的單個元素，格式為：del listname[index]
• del 也可以删除中間一段連續的元素，格式為：del listname[start : end]

# 清單删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# del-根據索引值删除元素
del list_del[0]  # 在指定位置添加元素
print(list_del)  # [2, 3, 4, 5, 6, 7, 8, 9]           

2.pop()：根據索引值删除元素

Python pop() 方法用來删除清單中指定索引處的元素，具體格式如下：listname.pop(index)

# 清單删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# pop-根據索引值删除元素
list_del.pop()  # 不添加索引，預設删除最後一個元素
print(list_del)  # [2, 3, 4, 5, 6, 7, 8]
list_del.pop(0)  # 添加索引，删除指定索引的元素
print(list_del)  # [3, 4, 5, 6, 7, 8]           

3.remove()：根據元素值進行删除

除了 del 關鍵字，Python 還提供了 remove() 方法，該方法會根據元素本身的值來進行删除操作。 删除不存在的元素時，會報錯。

# 清單删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove-根據元素值進行删除
list_del.remove(6)
print(list_del)  # [3, 4, 5, 7, 8]           

4.clear()：删除清單所有元素

Python clear() 用來删除清單的所有元素，即清空清單。

# 清單删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# clear-删除清單所有元素（清空清單）
list_del.clear()
print(list_del)  # []           

五、清單查找元素

Python 清單（list）提供了 index() 和 count() 方法，可以用來查找元素。

1.index() 方法

index() 方法用來查找某個元素在清單中出現的位置（也就是索引），如果該元素不存在，則會導緻 ValueError 錯誤，是以在查找之前最好使用 count() 方法判斷一下。

index() 的文法格式為：listname.index(obj, start, end)

其中，listname 表示清單名稱，obj 表示要查找的元素，start 表示起始位置，end 表示結束位置。

start 和 end 參數用來指定檢索範圍：

• start 和 end 可以都不寫，此時會檢索整個清單；
• 如果隻寫 start 不寫 end，那麼表示檢索從 start 到末尾的元素；
• 如果 start 和 end 都寫，那麼表示檢索 start 和 end 之間的元素。

2.count()方法

count() 方法用來統計某個元素在清單中出現的次數，基本文法格式為：listname.count(obj)

其中，listname 代表清單名，obj 表示要統計的元素。如果 count() 傳回 0，就表示清單中不存在該元素，是以 count() 也可以用來判斷清單中的某個元素是否存在。

# 清單元素出現次數統計
list_cou = ["c", "c++", "java", "python", "python", ".net", "c#", "go", "js", "java", "object-c", "python"]
print(list_cou.count("python"))  # 傳回3
if list_cou.count("java"):  # 判斷元素是否存在清單中，存在會傳回1，即True，故可以用來做判斷
    print("java存在于清單list_cou中")
else:
    print("清單list_cou中不存在java元素")           

六、清單反轉、排序

1.reverse

清單元素反轉，用法：listname.reverse()

# reverse-清單元素反轉，不改變ID
list_rev = [5, 6, 7, 1, 2, 3, 4]
list_rev.reverse()
print(list_rev)  # [4, 3, 2, 1, 7, 6, 5]           

2.sort

清單排序，覆寫原清單，不改變ID，用法：listname.sort()

# sort-清單排序，覆寫原清單，不改變ID
list_sor = [5, 6, 7, 1, 2, 3, 4]
print(id(list_sor))  # 48733864
list_sor.sort()
print(list_sor)  # [1, 2, 3, 4, 5, 6, 7]
print(id(list_sor))  # 48733864           

3.sorted

清單排序，生成新清單，用法：sorted(listname)

# sorted-清單排序，生成新清單
list_std = [8, 5, 6, 9, 4, 1]
print(id(list_std))  # 原ID：60944456
list_std_new = sorted(list_std)
print(list_std_new)  # [1, 4, 5, 6, 8, 9]
print(id(list_std_new))  # 生成的新清單的ID：60944520           

七、清單總結

操作	用法示例
C-建立清單	[] list()函數
R-通路清單元素	使用索引通路清單元素的格式為：listname[i] 使用切片通路清單元素的格式為：listname[start : end : step] 擷取清單所有元素：listname[:]
U-清單添加元素	append：末尾追加元素 extend：末尾添加元素，可以是單個元素、清單、元組 insert：清單指定位置添加元素
D-清單删除元素	del：根據索引值删除元素，可以是單個元素，也可以是一段元素 pop：删除指定索引位置的元素 remove：根據元素值進行删除 clear：删除清單所有元素（清空清單）
其他	count：統計某個元素在清單中出現的次數，也可以判斷元素是否存在 index：查找某個元素在清單中出現的位置 reverse：清單元素反轉 sort：清單排序，不生成新清單 sorted：清單排序，生成新清單

元組(tuple)

元組（tuple）是 Python 中另一個重要的序列結構，和清單類似，元組也是由一系列按特定順序排序的元素組成，清單和元組都是有序序列。

一、list清單和tuple元組

元組和清單（list）的不同之處在于：

◆ 清單的元素是可以更改的，包括修改元素值，删除和插入元素，是以清單是可變序列；

◆ 而元組一旦被建立，它的元素就不可更改了，是以元組是不可變序列。

元組也可以看做是不可變的清單，通常情況下，元組用于儲存無需修改的内容。

二、建立元組

Python 提供了兩種建立元組的方法：

1.使用( )直接建立

通過( )建立元組後，一般使用=将它指派給某個變量，具體格式為：

tuplename = (element1, element2, ..., elementn)，例如：

# 通過()建立元組
t1 = ("c", "c++", "java", "python", "ruby")
print(t1)  # ('c', 'c++', 'java', 'python', 'ruby')
# 擷取指定索引值
print(t1[2]) # java
# 查詢指定範圍内是否存在指定值，存在傳回索引位置，不存在報錯
print(t1.index('java', 0, -1)) # 2           

2.使用tuple()函數建立元組

除了使用( )建立元組外，Python 還提供了一個内置的函數 tuple()，用來将其它資料類型轉換為元組類型。例如：

# 使用tuple()函數将其他資料類型轉換為元組
list_1 = [1, 3, 5, 7, 9]
t2 = tuple(list_1)  # 清單強轉為元組
print(t2)  # (1, 3, 5, 7, 9)
str_1 = "hello world"
t3 = tuple(str_1)  # 字元串強轉為元組
print(t3)  # ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
dict_1 = {"name": "chen", "age": 28, "height": "75kg"}
t4 = tuple(dict_1)  # 字典強轉為元組
print(t4)  # ('name', 'age', 'height')           

字典(dictionary)

Python 字典（dict）是 Python 中唯一的映射類型，是一種無序的、可變的序列，它的元素以“鍵值對（key-value）”的形式存儲。字典中，習慣将各元素對應的索引稱為鍵（key），各個鍵對應的元素稱為值（value），鍵及其關聯的值稱為“鍵值對”。總的來說，字典類型所具有的主要特征如下 所示：

一、建立字典

1.使用 { } 建立字典

由于字典中每個元素都包含兩部分，分别是鍵（key）和值（value），是以在建立字典時，鍵和值之間使用冒号:分隔，相鄰元素之間使用逗号,分隔，所有元素放在大括号{ }中。使用{ }建立字典的文法格式如下：dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

# 使用{}建立
dict1 = {"name": "大剛", "age": 29, "phone": 15252162666}           

2.通過 fromkeys() 方法建立字典

Python 中，還可以使用 dict 字典類型提供的 fromkeys() 方法建立帶有預設值的字典，具體格式為：

dictname = dict.fromkeys(list，value=None)

其中，list 參數表示字典中所有鍵的清單（list）；value 參數表示預設值，如果不寫，則為空值 None。

# 通過 fromkeys() 方法建立字典
c = ['name', 'age', 'weight']
dict5 = dict.fromkeys(c)
dict6 = dict.fromkeys(c, "0")
print(dict5)  # {'name': None, 'age': None, 'weight': None}
print(dict6)  # {'name': '0', 'age': '0', 'weight': '0'}           

3.通過 dict() 映射函數建立字典

格式1：

dict1 = dict(key1=value1, key2=value2, key3=value3)

格式2：

demo = [('two',2), ('one',1), ('three',3)]

dict2 = dict(demo)

格式3：

keys = ['one', 'two', 'three'] # 還可以是字元串或元組

values = [1, 2, 3] # 還可以是字元串或元組

dict3 = dict( zip(keys, values) )

# 使用dict()方法建立
dict2 = dict(age=29, name="大剛", city="xuzhou")  # dict(key1=value1,key2=value2)
print(dict2)  # {'age': 29, 'name': '大剛', 'city': 'xuzhou'}

info = (("name", "大剛"), ("age", 29), ("city", "nanjing"), ("number", 227))
dict3 = dict(info)  # 使用dict()方法強制轉換二維元組為字典
print(dict3)  # {'name': '大剛', 'age': 29, 'city': 'nanjing', 'number': 227}

a = [1, 2, 3, 4]
b = ["a", "b", "c", "d"]
dict4 = dict(zip(a, b))  # 使用dict()方法結合zip()方法将等長的清單轉換為字典
print(dict4)  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}           

二、通路字典元素

清單和元組是通過下标來通路元素的，而字典不同，它通過鍵來通路對應的值。

1.通過 dictname[key] 通路

其中，dictname 表示字典變量的名字，key 表示鍵名。注意，鍵必須是存在的，否則會抛出異常。

tup = (['one', 100], ['two', 200], ['three', 300], ['four', 400])
dict1 = dict(tup)
print(dict1['one'])  # 鍵存在，傳回對應value
print(dict1['six'])  # 鍵不存在，抛出異常           

運作結果如下：

2.通過 get() 方法擷取

格式為：dictname.get(key[,default])

其中，dictname 表示字典變量的名字；key 表示指定的鍵；default 用于指定要查詢的鍵不存在時，此方法傳回的預設值，如果不手動指定，會傳回 None。

# 通路字典元素
dict7 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
print(dict7["age"])  # 28
print(dict7.get("age"))  # 28
print(dict7.get("age", 18))  # 28，設定預設傳回值，檢索到key時，傳回key的實際值
print(dict7.get("age111", 18))  # 18，設定預設傳回值，未檢索到key時，傳回預設值           

三、字典添加鍵值對

為字典添加新的鍵值對很簡單，直接給不存在的 key 指派即可，具體文法格式如下：

dictname[key] = value

各個部分的說明：

◆ dictname 表示字典名稱；

◆ key 表示新的鍵；

◆ value 表示新的值，隻要是 Python 支援的資料類型都可以；

# 字典添加鍵值對
dict8 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
dict8["number"] = 227  # 如果存在此鍵，則更新鍵值，不存在則添加新鍵值對
print(dict8)  # {'age': 28, 'name': 'tom', 'city': 'xuzhou', 'number': 227}           

四、字典更新鍵值對

1.update() 方法

update() 方法可以使用一個字典所包含的鍵值對來更新已有的字典。

在執行 update() 方法時，如果被更新的字典中己包含對應的鍵值對，那麼原 value 會被覆寫；如果被更新的字典中不包含對應的鍵值對，則該鍵值對被添加進去。

# 更新字典
dict14 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"age": 18})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"num": 227})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}           

2.setdefault() 方法

setdefault() 方法用來傳回某個 key 對應的 value，其文法格式如下：

dictname.setdefault(key, defaultvalue=None)

說明，dictname 表示字典名稱，key 表示鍵，defaultvalue 表示預設值（可以不寫，不寫的話是 None）。

# 字典key設定預設值
dict16 = {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('name', 'lucy')  # 鍵存在時，不更新
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('city', 'xuzhou')  # 鍵不存在時，更新字典
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227, 'city': 'xuzhou'}           

五、字典删除鍵值對

1.pop() 和 popitem() 方法

pop() 和 popitem() 都用來删除字典中的鍵值對，不同的是，pop() 用來删除指定的鍵值對，而popitem() 用來随機删除一個鍵值對，文法格式如下：

◆ dictname.pop(key)

◆ dictname.popitem()

# 删除字典元素
dict15 = {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
dict15.pop('age')  # 删除指定鍵值對
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
pi = dict15.popitem()  # 删除最後一個鍵值對，傳回值是被删除的鍵值對
print(pi)  # ('num', 227)
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
del dict15["city"]  # 通過del删除指定鍵值對
print(dict15)  # {'name': 'tom'}           

六、字典的一些其他方法

1.判斷字典中是否存在指定鍵值對

判斷字典是否包含指定鍵值對的鍵，可以使用 in 或 not in 運算符。

# 判斷字典是否包含指定鍵值對的鍵
dict9 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
assert 'name' in dict9
assert 'address' not in dict9           

2.keys()、values() 和 items() 方法

◆ keys() 方法用于傳回字典中的所有鍵（key）；

◆ values() 方法用于傳回字典中所有鍵對應的值（value）；

◆ items() 用于傳回字典中所有的鍵值對（key-value）；

# 傳回字典中的所有鍵
print(dict9.keys())  # dict_keys(['age', 'name', 'city'])
# 傳回字典中的所有鍵的鍵值
print(dict9.values())  # dict_values([28, 'tom', 'xuzhou'])
# 傳回字典中的所有鍵值對
print(dict9.items())  # dict_items([('age', 28), ('name', 'tom'), ('city', 'xuzhou')])           

3.檢視dict所有方法

Python 字典的資料類型為 dict，我們可使用 dir(dict) 來檢視該類型包含哪些方法

>>> dir(dict)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']           

七、copy()方法-深拷貝與淺拷貝

copy() 方法傳回一個字典的拷貝，也即傳回一個具有相同鍵值對的新字典。

深拷貝與淺拷貝：

◆ 淺拷貝：若拷貝的對象是一個可變對象，如字典、清單等，拷貝的隻是記憶體位址，隻要其中一個被更改，則拷貝前和拷貝後的對象都會被更改

◆ 深拷貝：deepcopy()方法copy的對象，會新生成一個記憶體位址，故被拷貝對象的可變元素被更改後不會影響拷貝後的結果

# 拷貝字典
import copy
dict10 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
# 淺拷貝：通過dict自帶的copy方法
dict11 = dict10.copy()
# 淺拷貝：通過引入copy子產品的copy()方法拷貝
dict12 = copy.copy(dict10)
# 深拷貝：通過引入copy子產品的deepcopy()方法拷貝
dict13 = copy.deepcopy(dict10)
dict10["city"].remove('xuzhou')
print(dict11)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict12)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict13)  # {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}           

八、字典總結

• 清單和元組都是有序序列，字典是無需序列；
• 清單和字典都是可變序列，元組是不可變序列；

操作	用法示例
C-建立字典	{ } fromkeys() 方法 dict() 映射函數，也可以強制轉換其他類型資料為字典，如：元組
R-通路字典鍵值對	dictname[key]，注意，鍵必須是存在的，否則會抛出異常。 dictname.get(key[,default])，未檢索到key時，傳回預設值default
U-字典添加或更新鍵值對	dictname[key] = value：如果存在此鍵，則更新鍵值，不存在則添加新鍵值對，value可以是Python任意資料類型 update(key: value) ：存在則更新鍵值，不存在則添加此鍵值對 setdefault(key, value)：鍵存在時、不更新鍵值，鍵不存在時添加此鍵值對
D-字典删除鍵值對	pop() 用來删除指定的鍵值對 popitem() 用來随機删除一個鍵值對 del dictname[key]：根據鍵名稱删除鍵值對
其他	assert key (not) in dictname：判斷字典中是否(不)存在指定鍵值對 keys()：傳回字典中的所有鍵（key） values()：傳回字典中所有鍵對應的值（value） items()：傳回字典中所有的鍵值對（key-value）

字元串(string)

一、字元串切片

從本質上講，字元串是由多個字元構成的，字元之間是有順序的，這個順序号稱為索引（index）。

1.擷取單個字元

在方括号[ ]中使用索引即可通路對應的字元，具體的文法格式為：

strname[index]

Python 允許從字元串的兩端使用索引：

• 當以字元串的左端（字元串的開頭）為起點時，索引是從 0 開始計數的；字元串的第一個字元的索引為 0，第二個字元的索引為 1，第三個字元串的索引為 2 ……以此類推
• 當以字元串的右端（字元串的末尾）為起點時，索引是從 -1 開始計數的；字元串的倒數第一個字元的索引為 -1，倒數第二個字元的索引為 -2，倒數第三個字元的索引為 -3 ……以此類推

str1 = "life is short,i need PYTHON"
# 字元串查找
print(str1.find('s', 0, -1))  # 查找指定範圍内是否存在某字元，是傳回下标，不存在傳回-1
# 擷取單個字元
a = str1[0]  # 第一個字元
b = str1[-1]  # 最後一個字元
print(a)  # 1
print(b)  # N           

2.擷取多個字元（字元串截取/切片）

使用[ ]除了可以擷取單個字元外，還可以指定一個範圍來擷取多個字元，也就是一個子串或者片段，具體格式為：

strname[start : end : step]

# 擷取多個字元（字元串切片）
c = str1[0:3]  # 擷取str1的第1個到第3個之間的字元，步長預設為1
d = str1[0:5:2]  # 擷取str1的第1個到第5個之間的字元，指定預設為2           

二、len()：擷取對象長度和位元組長度

Python 中，要想知道一個對象長度，或者一個字元串占用多少個位元組，可以使用 len 函數。len 函數的基本文法格式為：

len（obj）

其中 obj用于指定要進行長度統計的對象，可以是字元串、清單、元組、字典等。 通過使用 encode() 方法，将字元串進行編碼後再擷取它的位元組數。例如，采用 UTF-8 編碼方式，計算“人生苦短，我用Python”的位元組數，可以執行如下代碼：

# 擷取對象長度
str2 = "人生苦短，我用PYTHON"
print(len(str2))  # 13
print(len(str2.encode()))  # 27，使用encode()方法轉碼為位元組，一個中文字元占用3個位元組           

三、join()方法：合并字元串

Python join() 方法用于将序列中的元素以指定的字元連接配接生成一個新的字元串。文法格式：

newstr = str.join(iterable)

此方法中各參數的含義如下：

• newstr：表示合并後生成的新字元串；
• str：用于指定合并時的分隔符；
• iterable：做合并操作的源字元串資料，允許以清單、元組等形式提供。

# 合并字元串
list_a = ['a', 'b', 'c', 'd', 'e']
print("".join(list_a))  # abcde 預設連接配接符
print("#".join(list_a))  # a#b#c#d#e  指定連接配接符
# 字元串拼接
str_a = "人生苦短"
str_b = "我用PYTHON"
print(str_a + str_b)  # 人生苦短我用PYTHON
# 字元串追加字元
print(str_b.join(str_a))  # 人我用PYTHON生我用PYTHON苦我用PYTHON短  輸出的為無序的字元串           

四、split()方法：字元串分隔

# 字元串分隔
str2 = "life is short,i need python"
print(str2.split(' '))  # ['life', 'is', 'short,i', 'need', 'PYTHON']           

五、替換與删除指定字元

• str.replace(old, new,count)，替換指定字元(不加count預設全替換)
• str.replace(old, '',count)，将指定字元用空字元代替、進而達到删除的目的(不加count預設全替換)

# 字元串替換指定字元（用大寫的LIFE字元代替小寫的life）
print(str2.replace('life', 'LIFE'))  # LIFE is short,i need python
# 字元串删除指定字元（用空字元代替字元i，進而達到删除目的）
print(str2.replace('i', ''))  # lfe s short, need python           

六、字元串格式化輸出

1.來自C語言的%方式

%号格式化字元串的方式繼承自古老的C語言，這在很多程式設計語言都有類似的實作。%s是一個占位符，它僅代表一段字元串，并不是拼接的實際内容。實際的拼接内容在一個單獨的%号後面，放在一個元組裡。 類似的占位符還有：

• %d（代表一個整數）
• %f（代表一個浮點數）
• %x（代表一個16進制數）

%占位符既是這種拼接方 式的特點，同時也是其限制因為每種占位符都有特定意義，實際使用起來較為麻煩。

# 使用占位符
name = "dang"
age = 5
print("我叫%s，我今年%s歲了" % (name, age))  # 我叫dang，我今年5歲了
print("%d" % (20))  # 八進制  20
print("%o" % (20))  # 十進制  24
print("%x" % (20))  # 十六進制  14           

2.format()拼接方式

# format()拼接方式
name1 = "當當"
name2 = "剛剛"
age = 5
print("我叫{}，我今年{}歲了".format(name1, age))  # 我叫當當，我今年5歲了
print("我叫{1}，我叫{0}".format(name1, name2))  # 使用編号指定順序  "我叫剛剛，我叫當當"
print("我叫{name}，我今年{age}歲了".format(name=name1, age=age))  # 使用變量名指定順序  "我叫當當，我今年5歲了"           

3.f-string方式

f-string方式出自PEP 498（Literal String Interpolation，字面字元串插值），從Python3.6版本引入。其特點是在字元串前加 f 辨別，字元串中間則用花括号{}包裹其他字元串變量。

# f-string方式
name3 = "jigang.chen"
age = 28
print(f"我叫{name3}，我今年{age}歲了")  # 我叫jigang.chen，我今年28歲了
print(f"a total number is {20 * 2 + 8}")  # 處理表達式   a total number is 48
name = "PYTHON"
print(f"my name is {name.lower()}")  # 處理方法調用   my name is python           

七、字元串其他方法

str1 = "life is short,i need PYTHON"
# 計算某個字元出現的次數
print(str1.count('i'))  # 3
# 在指定區間内查找某個字元，并傳回該字元的索引
print(str1.find('f', 0, -1))  # 2
# 将字元串全部轉換為小寫
print(str1.lower())  # life is short,i need python           

八、字元串總結

操作	用法示例
C-建立字元串	strname1 = "life is short,i need PYTHON" strname2 = str(8888)
R-通路字元串元素	擷取單個元素：strname[index] 查找指定範圍内是否存在某字元，是傳回下标，不存在傳回-1：strname.find('s', 0, -1)) 字元串切片：strname[start : end : step]
U-修改字元串	合并字元串：newstr = str.join(iterable) 字元串分隔："life is short,i need python".split(" ")，通過空格進行分隔，會得到一個清單：['life', 'is', 'short,i', 'need', 'PYTHON'] 替換指定字元(不加count預設全替換)：strname.replace(old, new,count)
D-字元串删除元素	str.replace(old, '')，将指定字元用空字元代替、進而達到删除的目的，
其他	字元串格式化輸出： %方式："我叫%s，我今年%s歲了" % (name, age) format()拼接："我叫{}，我今年{}歲了".format(name, age) f-string方式：f"我叫{name}，我今年{age}歲了" 計算某個字元出現的次數：strname.count('i')) 在指定區間内查找某個字元，并傳回該字元的索引：strname.find('f', 0, -1) 将字元串全部轉換為小寫：strname.lower()

集合(set)

Python 中的集合，是一種無序的、可變的序列，和數學中的集合概念一樣，用來儲存不重複的元素，即集合中的元素都是唯一的，互不相同。形式上看，和字典類似，Python 集合會将所有元素放在一對大括号 {} 中，相鄰元素之間用“,”分隔，如下所示：

{element1,element2,...,elementn}

一、建立集合

1.使用 {} 建立

在 Python 中，建立 set 集合可以像清單、元素和字典一樣，直接将集合指派給變量，其文法格式如下：

setname = {element1,element2,...,elementn}

set1 = {1, 2, 3, 4, 5, 6}           

2.set()函數建立集合

set() 函數為 Python 的内置函數，其功能是将字元串、清單、元組、range 對象等可疊代對象轉換成集合。該函數的文法格式如下：

setname = set(iteration)

# 使用set()方法建立
list1 = [5, 6, 7, 8, 9]
tup1 = ('a', 'b', 'c')
set2 = set(list1)  # 将清單轉換為集合
set3 = set(tup1)  # 将元組轉換為集合，轉換結果是無序的
print(set2)  # {5, 6, 7, 8, 9}
print(set3)  # {'a', 'c', 'b'}           

二、向集合中添加元素

set 集合中添加元素，可以使用 set 類型提供的 add() 方法實作，該方法的文法格式為：

setname.add(element)

# 向集合中添加元素
set1.add('e')  # add()方法添加元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'e'}
set1.update(tup1)  # update()方法添加元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'c', 'e', 'b', 'a'}           

三、從集合中删除元素

删除現有 set 集合中的指定元素，可以使用 remove() 方法，該方法的文法格式如下：

setname.remove(element)

# 集合删除元素
set1.remove('a')  # 删除指定元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'e', 'b', 'c'}
set1.pop()  # 從最開始位置删除元素
print(set1)  # {2, 3, 4, 5, 6, 'c', 'b', 'e'}
set1.discard('e')  # 删除指定元素，不存在則不做任何操作
print(set1)  # {2, 3, 4, 5, 6, 'c', 'b'}
set1.clear()  # 清空集合
print(set1)  # set()           

四、清空集合

清空現有 set 集合中的所有元素，可以使用 clear() 方法，該方法的文法格式如下：

setname.clear()

list1 = [1, 3, 4, 5, 6, 6]
set2 = set(list1)
print(set2)  # {1, 3, 4, 5, 6}
set2.clear()
print(set2)  # set()           

五、集合求交集、并集、差集

1.通過python運算符

運算操作	Python運算符	含義	例子
交集	&	取兩集合公共的元素	set1 & set2 >> [3]
并集	|	取兩集合全部的元素	set1 | set2 >> [1,2,3,4,5]
差集	-	取一個集合中另一個集合沒有的元素	set1 - set2 >> [1,2] set2 - set1 >> [4,5]
對稱差集	^	取集合A和B中不屬于A&B的元素	set1 ^ set2 >> [1,2,4,5]

2.通過函數

方法名	文法格式	含義
difference()	set3 = set1.difference(set2)	将set1中有而set2中沒有的元素賦給set3
intersection()	set3 = set1.intersection(set2)	取set1和set2的交集，賦給set3
union()	set3 = set1.union(set2)	取set1和set2的并集，賦給set3

示例：

# 集合交集、并集、差集
set_a = {'a', 'b', 'c', 'd'}
set_b = {'c', 'd', 'e', 'f'}
# 求交集
ict = set_a.intersection(set_b)  # intersection()方法
print(ict)  # {'c', 'd'}
set_ict = set_a & set_b  # 使用 & 運算符
print(set_ict)  # {'c', 'd'}
# 求并集
union = set_a.union(set_b)  # union()方法
print(union)  # {'f', 'd', 'e', 'b', 'c', 'a'}
set_union = set_a | set_b  # 使用 | 運算符
print(set_union)  # {'f', 'c', 'b', 'd', 'a', 'e'}
# 求差集
diff = set_a.difference(set_b)  # 使用difference()方法
print(diff)  # {'b', 'a'}  
set_diff = set_a - set_b  # 使用 - 運算符
print(set_diff)  # {'a', 'b'}           

六、集合其他用法

1.檢視集合所有方法

通過 dir(set) 指令可以檢視它有哪些方法：

>>> dir(set)
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 
'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']           

2.複制集合

# 複制集合
set4 = {1, 3, 5, 7, 9}
set5 = set4.copy()
print(set5)  # {1, 3, 5, 7, 9}           

3.清單去重

# 清單去重
list2 = [1, 1, 1, 3, 4, 5, 6, 6]
set6 = set(list2)
print(set6)  # {1, 3, 4, 5, 6}
list3 = list(set6)
print(list3)  # [1, 3, 4, 5, 6]           

七、集合總結

操作	用法示例
C-建立集合	通過{ }建立：setname = {element1,element2,...,elementn} 使用set()函數建立：setname = set(iteration)
R-通路集合元素
U-修改集合	集合添加元素：setname.add(element)
D-集合删除元素	集合删除元素：setname.remove(element) 清空集合：setname.clear()
其他	集合求交集、并集、差集： 差集：set3 = set1.difference(set2) 交集：set3 = set1.intersection(set2) 并集：set3 = set1.union(set2) 複制集合：newset = setname.copy()

結尾彩蛋

清單、元組、字元串都是有序序列，都可以通過索引（index）擷取元素，而字典、集合都是無序序列，無法通過索引擷取元素；

清單、字典、集合都是可變序列，而元組、字元串是不可變序列，一旦建立，元素就不能發生變化；

可能有人會疑惑，為什麼明明上述提到了字元串可以通過replace()方法替換元素，卻要說字元串是不可變元素呢？

是因為當對字元串進行拼接、替換字元等操作時，會在記憶體中開辟一個新的記憶體位址，也就是生成了新的字元串對象，而原始的字元串對象則保持不變。我們通過一段代碼簡單看一下：

str1 = "life is short,i need python"
str1.replace("life", "school life")

print(str1)           

列印出來的結果仍然是"life is short,i need python"