1. 序列

1.1 什么是序列

Python 中的序列是一種數(shù)據(jù)類型，用于存儲一組有序的元素。序列是 Python 中最基本的數(shù)據(jù)結構之一，具有以下基本特性：

• 有序性：序列中的元素按照一定的順序排列，可以通過索引訪問和操作特定位置的元素。
• 可迭代性：序列可以進行迭代操作，例如使用循環(huán)遍歷序列中的元素。
• 可變性：某些序列類型（如列表和字節(jié)數(shù)組）是可變的，可以對其進行添加、刪除、修改元素等操作；而另一些序列類型（如字符串和元組）是不可變的，不能直接修改其元素，只能通過創(chuàng)建新的序列實現(xiàn)變化。
• 支持多種元素類型：序列可以包含不同類型的元素，如整數(shù)、浮點數(shù)、字符串等。
• 長度可變：可變序列的長度可以動態(tài)增加或減少，不可變序列的長度固定。

1.2 基本操作

對序列進行操作時，可以使用一些常用的操作符和函數(shù)：

1.2.1 索引

序列中的元素可以通過索引訪問，索引從 0 開始。例如，序列 my_list 中的第一個元素可以通過 my_list[0] 來獲取。

1.2.2 切片

切片：可以使用切片操作來獲取序列中的子序列。切片使用起始索引和結束索引來指定子序列的范圍。例如，my_list[1:4] 將返回從索引 1 到索引 3 的子序列。

（1）語法一

語法：列表[起始:結束]

通過切片獲取元素時，會包括起始位置的元素，不會包括結束位置的元素

做切片操作時，總會返回一個新的列表，不會影響原來的列表

起始和結束位置的索引都可以省略不寫

如果省略結束位置，則會一直截取到最后

如果省略起始位置，則會從第一個元素開始截取

如果起始位置和結束位置全部省略，則相當于創(chuàng)建了一個列表的副本

（2）語法二

語法：列表[起始:結束:步長]

步長表示，每次獲取元素的間隔，默認值是1
print(stus[0:5:3])
步長不能是0，但是可以是負數(shù)
print(stus[::0]) ValueError: slice step cannot be zero
如果是負數(shù)，則會從列表的后部向前邊取元素

（3）長度

長度：可以使用 len() 函數(shù)獲取序列的長度，即其中元素的個數(shù)。

（4）遍歷（迭代）

迭代：可以使用循環(huán)結構對序列進行迭代，逐個處理其中的元素。

（5）運算符①

運算符：序列支持一些常用的運算符，例如 + 運算符可以用于拼接兩個序列，* 運算符可以用于重復序列的元素。

（6）修改序列

修改序列：在某些情況下，序列是可變的，可以修改其中的元素。例如，列表是可變的，可以通過索引來修改列表中的元素。

（7）通用操作

連接操作：使用 + 運算符將兩個序列連接起來，生成一個新的序列。

重復操作：使用 * 運算符將序列重復指定次數(shù)，生成一個新的序列。

（8）運算符②

在 Python 中，in 和 not in 是用于判斷某個元素是否存在于序列中的成員運算符。

• in 運算符用于檢查元素是否存在于序列中，如果存在則返回 True，否則返回 False。
• not in 運算符則用于檢查元素是否不存在于序列中，如果不存在則返回 True，否則返回 False。

這兩個運算符可以應用于任何序列類型，包括字符串、列表、元組和字節(jié)數(shù)組序列等。

（9）其他內置函數(shù)

其他內置函數(shù)：min() 和 max() 用于獲取序列中的最小值和最大值，sum() 用于求序列元素的和等。

my_list = [1, 2, 3, 4, 5]  # 列表
my_tuple = (1, 2, 3, 4, 5)  # 元組
my_string = "Hello, World!"  # 字符串

# 通過索引訪問元素
print(my_list[0])  # 輸出: 1
print(my_tuple[2])  # 輸出: 3
print(my_string[7])  # 輸出: W

# 使用切片獲取子序列
print(my_list[1:4])  # 輸出: [2, 3, 4]
print(my_tuple[:3])  # 輸出: (1, 2, 3)
print(my_string[7:])  # 輸出: World!

# 獲取序列的長度
print(len(my_list))  # 輸出: 5
print(len(my_tuple))  # 輸出: 5
print(len(my_string))  # 輸出: 13

# 迭代序列
for item in my_list:
    print(item)

# 序列的運算符
new_list = my_list + [6, 7]  # 拼接兩個列表
print(new_list)  # 輸出: [1, 2, 3, 4, 5, 6, 7]

repeated_tuple = my_tuple * 3  # 元組重復三次
print(repeated_tuple)  # 輸出: (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 

# 修改序列
stus = ['孫悟空','豬八戒','沙和尚','唐僧','蜘蛛精','白骨精']
stus[0:0] = ['牛魔王'] # 向索引為0的位置插入元素

# 連接操作
print(my_list + [6, 7])     # 輸出：[1, 2, 3, 4, 5, 6, 7]

# 重復操作
print(my_list * 2)          # 輸出：[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

# 成員關系判斷
print(3 in my_list)         # 輸出：True 

2. python中各種類型的序列

2.1 字符串序列（str）

2.1.1 定義

?定義：由字符組成的不可變序列。

用途：用于存儲和操作文本數(shù)據(jù)。

2.1.2 示例

# 訪問序列元素：
my_string = "Hello"
print(my_string[0])           # 輸出第一個字符: 'H'

# 切片操作：
my_string = "Hello, World"
print(my_string[7:])          # 輸出從索引為 7 到末尾的子字符串: 'World'

# 序列拼接和重復：
my_string1 = "Hello"
my_string2 = "World"
concatenated_string = my_string1 + ", " + my_string2   # 連接兩個字符串
print(concatenated_string)                             # 輸出拼接后的字符串: 'Hello, World'

# 序列成員檢查：
my_string = "Hello"
print('H' in my_string)         # 檢查字符是否

# 字符串中的成員運算
string = "Hello, World!"
print('H' in string)           # 輸出：True，'H' 存在于字符串中
print('X' not in string)       # 輸出：True，'X' 不存在于字符串中

2.2 列表序列（list）

2.2.1 定義

• 定義：由任意類型的元素組成的可變序列，用方括號 [ ] 表示。

• 用途：用于存儲和操作多個元素的集合。

2.2.2 示例

# 訪問序列元素
my_list = [1, 2, 3, 4]
print(my_list[2])             # 輸出索引為 2 的元素: 3

# 切片操作：
my_list = [1, 2, 3, 4, 5]
print(my_list[1:4])           # 輸出索引為 1 到 3 的子列表: [2, 3, 4]

# 序列拼接和重復：
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
concatenated_list = my_list1 + my_list2                # 連接兩個列表
print(concatenated_list)                               # 輸出拼接后的列表: [1, 2, 3, 4, 5, 6]

# 列表中的成員運算
list = [1, 2, 3, 4, 5]
print(3 in list)               # 輸出：True，3 存在于列表中
print(6 not in list)           # 輸出：True，6 不存在于列表中

2.3 元組序列（tuple）

2.3.1 定義

• 定義：由任意類型的元素組成的不可變序列，用圓括號 ( ) 表示。

• 用途：用于存儲和保護一組數(shù)據(jù)，通常在函數(shù)返回多個值時使用。

2.3.2 示例

# 訪問序列元素：
my_tuple = (10, 20, 30)
print(my_tuple[-1])           # 輸出最后一個元素: 30

# 切片操作：
my_tuple = (10, 20, 30, 40)
print(my_tuple[:2])           # 輸出從開始到索引為 1 的子元組: (10, 20)

# 序列拼接和重復：
my_tuple1 = (10, 20)
my_tuple2 = (30, 40)
concatenated_tuple = my_tuple1 + my_tuple2             # 連接兩個元組
print(concatenated_tuple)                              # 輸出拼接后的元組: (10, 20, 30, 40)

# 元組中的成員運算
tuple = (1, 2, 3, 4, 5)
print(2 in tuple)              # 輸出：True，2 存在于元組中
print(6 not in tuple)          # 輸出：True，6 不存在于元組中

2.4 范圍序列（range）

2.4.1 定義

• 定義：由指定范圍內的整數(shù)組成的不可變序列。

• 用途：用于生成一系列連續(xù)的整數(shù)，通常在循環(huán)中使用。

2.4.2 示例

# 訪問序列元素：
my_range = range(5)
print(my_range[2])            # 輸出索引為 2 的元素: 2

# 切片操作：
my_range = range(5)
print(list(my_range[2:4]))    # 輸出索引為 2 到 3 的子列表: [2, 3]

# 序列拼接和重復：
my_range = range(3)
repeated_range = my_range * 3                          # 重復范圍三次
print(list(repeated_range))                            # 輸出重復后的列表: [0, 1, 2, 0, 1, 2, 0, 1, 2]

2.5 字節(jié)數(shù)組序列（bytearray）

2.5.1 定義

• 定義：由字節(jié)組成的可變序列。

• 用途：用于在二進制數(shù)據(jù)上執(zhí)行可變操作。

2.5.2 示例

# 創(chuàng)建空的字節(jié)數(shù)組序列
my_bytes = bytearray()

# 創(chuàng)建包含字節(jié)數(shù)據(jù)的字節(jié)數(shù)組序列
my_bytes = bytearray(b'Hello')

# 通過索引訪問和修改字節(jié)
print(my_bytes[0])         # 輸出：72，對應 ASCII 碼中的 'H'
my_bytes[1] = 101          # 修改字節(jié)為 ASCII 碼中的 'e'

# 切片操作
print(my_bytes[2:4])       # 輸出：bytearray(b'll')
my_bytes[2:4] = b'xy'      # 替換字節(jié)

# 添加和刪除字節(jié)
my_bytes.append(111)       # 添加字節(jié)到末尾
del my_bytes[0]            # 刪除指定位置的字節(jié)

# 轉換為字符串
my_str = my_bytes.decode('utf-8')

# 字節(jié)數(shù)組序列中的成員運算
bytearray = bytearray(b'Hello')
print(108 in bytearray)        # 輸出：True，108 對應字節(jié) 'l' 存在于字節(jié)數(shù)組序列中
print(120 not in bytearray)    # 輸出：True，120 對應字節(jié) 'x' 不存在于字節(jié)數(shù)組序列中

# 其他常用操作
length = len(my_bytes)     # 獲取字節(jié)數(shù)組序列的長度
my_bytes.extend(b'World')  # 擴展字節(jié)數(shù)組序列

3. 字典

3.1 字典定義與說明

字典（Dictionary）是 Python 中的一種數(shù)據(jù)結構，用于存儲鍵-值（Key-Value）對。字典是可變的、無序的，且鍵（Key）必須是唯一的。在字典中，鍵用于查找、訪問和修改對應的值。

字典的定義使用花括號 {}，每個鍵-值對之間使用冒號 : 分隔。字典的基本語法如下：

# 創(chuàng)建字典
my_dict = {key1: value1, key2: value2, key3: value3}

其中，key1、key2、key3 是鍵，對應的 value1、value2、value3 是值。鍵和值可以是任意類型的對象，通常鍵是不可變的類型，如字符串、數(shù)字或元組，而值可以是任意類型的對象。

字典的特性包括：

• 鍵必須是唯一的，如果在同一個字典中使用相同的鍵進行賦值，后面的值會覆蓋前面的值。
• 字典中的鍵是無序的，不會按照定義時的順序進行存儲和訪問。
• 字典是可變的，可以添加、修改或刪除鍵-值對。
• 字典可以根據(jù)鍵來進行快速的查找和訪問，因此在需要根據(jù)某個標識獲取對應值的場景下很有用。

3.2 常用操作示例

以下是字典的一些常用操作示例：

# 創(chuàng)建字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 訪問字典中的值
print(my_dict['name'])      # 輸出：Alice
print(my_dict.get('age'))   # 輸出：25

# 修改字典中的值
my_dict['age'] = 26
print(my_dict['age'])       # 輸出：26

# 添加新的鍵-值對
my_dict['gender'] = 'Female'
print(my_dict)              # 輸出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'gender': 'Female'}

# 刪除鍵-值對
del my_dict['city']
print(my_dict)              # 輸出：{'name': 'Alice', 'age': 26, 'gender': 'Female'}

# 檢查鍵是否存在
print('age' in my_dict)     # 輸出：True
print('city' not in my_dict) # 輸出：True

# 獲取字典中所有的鍵和值
keys = my_dict.keys()
values = my_dict.values()
print(keys)                 # 輸出：dict_keys(['name', 'age', 'gender'])
print(values)               # 輸出：dict_values(['Alice', 26, 'Female'])

3.3 遍歷字典

遍歷字典可以使用字典對象的不同方法來實現(xiàn)。以下是幾種常用的遍歷字典的方式：

（1）遍歷鍵（keys）： 使用字典的 keys() 方法獲取所有鍵，然后通過循環(huán)遍歷鍵，再根據(jù)鍵獲取對應的值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

for key in my_dict.keys():
    print(key, my_dict[key])

（2）遍歷值（values）： 使用字典的 values() 方法獲取所有值，然后通過循環(huán)遍歷值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

for value in my_dict.values():
    print(value)

（3）遍歷鍵值對（items）： 使用字典的 items() 方法獲取所有鍵值對，然后通過循環(huán)遍歷鍵值對，可以同時獲取鍵和值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

for key, value in my_dict.items():
    print(key, value)

注意，字典是無序的，所以遍歷時不會按照鍵的順序進行輸出。如果需要按照特定的順序遍歷字典，可以使用 sorted() 函數(shù)對鍵進行排序，然后再進行遍歷。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

for key in sorted(my_dict.keys()):
    print(key, my_dict[key])

通過以上方法，你可以輕松地遍歷字典并獲取其中的鍵、值或鍵值對，根據(jù)具體需求選擇適合的遍歷方式。

3.4 復制字典

在 Python 中，復制字典有兩種方式：淺復制和深復制。

（1）淺復制（Shallow Copy）： 淺復制創(chuàng)建了一個新的字典對象，但是該新字典的鍵和值與原始字典相同。也就是說，新字典中的鍵和值是對原始字典中相同鍵和值的引用。

可以使用字典對象的 copy() 方法進行淺復制。

original_dict = {'name': 'Alice', 'age': 25}
new_dict = original_dict.copy()

print(new_dict)

輸出：

{'name': 'Alice', 'age': 25}

在淺復制中，如果原始字典中的值是可變對象（如列表、字典等），則新字典中對該值的修改也會反映在原始字典中。

（2）深復制（Deep Copy）： 深復制創(chuàng)建了一個完全獨立的字典對象，包括字典的所有鍵和值。修改新字典中的值不會影響原始字典。

可以使用 copy 模塊中的 deepcopy() 函數(shù)進行深復制。

import copy

original_dict = {'name': 'Alice', 'age': 25}
new_dict = copy.deepcopy(original_dict)

print(new_dict)

輸出：

{'name': 'Alice', 'age': 25}

在深復制中，無論原始字典中的值是可變對象還是不可變對象，新字典中的值都是完全獨立的，修改新字典中的值不會影響原始字典。

通過淺復制和深復制，你可以根據(jù)需要選擇適當?shù)姆绞絹韽椭谱值洹?/p>

4. 集合

4.1 Set集合

Python 中的集合（Set）是一種無序、可變的數(shù)據(jù)結構，它用于存儲唯一的元素。集合中的元素不能重復，且沒有固定的順序。

集合的主要特點包括：

• 元素唯一性：集合中的元素是唯一的，不能重復出現(xiàn)。
• 無序性：集合中的元素沒有固定的順序，每次遍歷的順序可能不同。
• 可變性：集合中的元素可以隨時添加、刪除和修改。

Python 提供了內置的 set 類型用于創(chuàng)建集合對象。可以使用花括號 {} 或 set() 函數(shù)來創(chuàng)建一個集合。例如：

# 創(chuàng)建一個集合
fruits = {'apple', 'banana', 'orange'}
print(fruits)

# 創(chuàng)建一個空集合
empty_set = set()
print(empty_set)

集合支持一系列的操作和方法，包括：

• 添加元素：使用 add() 方法向集合中添加元素。
• 移除元素：使用 remove() 方法從集合中移除指定的元素。
• 集合運算：例如并集、交集、差集等。
• 成員關系測試：使用 in 和 not in 來檢查元素是否屬于集合。
• 遍歷集合：使用 for 循環(huán)遍歷集合中的元素。

4.2 集合的基本操作

下面是一些示例代碼來演示集合的基本操作：

fruits = {'apple', 'banana', 'orange'}

# 添加元素
fruits.add('kiwi')
print(fruits)

# 移除元素
fruits.remove('banana')
print(fruits)

# 集合運算
fruits1 = {'apple', 'banana', 'orange'}
fruits2 = {'orange', 'kiwi', 'pineapple'}

union = fruits1 | fruits2  # 并集
intersection = fruits1 & fruits2  # 交集
difference = fruits1 - fruits2  # 差集

print(union)
print(intersection)
print(difference)

# 成員關系測試
print('banana' in fruits)
print('kiwi' not in fruits)

# 遍歷集合
for fruit in fruits:
    print(fruit)

輸出結果：

{'orange', 'kiwi', 'banana', 'apple'}
{'orange', 'kiwi', 'apple'}
{'kiwi', 'orange', 'pineapple', 'banana', 'apple'}
{'orange'}
{'kiwi', 'banana', 'apple'}
True
True
orange
kiwi
apple

4.3 集合的運算

# 在對集合做運算時，不會影響原來的集合，而是返回一個運算結果
# 創(chuàng)建兩個集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集運算
result = s & s2 # {3, 4, 5}

# | 并集運算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 異或集 獲取只在一個集合中出現(xiàn)的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 檢查一個集合是否是另一個集合的子集
# 如果a集合中的元素全部都在b集合中出現(xiàn)，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 檢查一個集合是否是另一個集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中還有a中沒有的元素，則b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 檢查一個集合是否是另一個的超集
# > 檢查一個集合是否是另一個的真超集
print('result =',result)

• 并集（Union）：返回兩個集合的所有元素，去除重復的部分。
• 交集（Intersection）：返回兩個集合中共同存在的元素。
• 差集（Difference）：返回第一個集合中存在，而第二個集合中不存在的元素。
• 對稱差（Symmetric Difference）：返回兩個集合中不重復的元素，即屬于一個集合但不屬于另一個集合的元素。

通過集合的運算，我們可以方便地對集合進行合并、求交、找出差異等操作，從而更加靈活地處理數(shù)據(jù)。文章來源地址http://www.zghlxwxcb.cn/news/detail-455568.html

到了這里，關于python入門（5）序列、字典、集合的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！