Python的基礎數據類型

1.Python中提供了六種內置的數據類型，一般用于存儲數據：
–數值Number
–字符串String
–列表List
–元組Tuple
–字典Dictionary
–集合Set
2.Python中的數據類型可以做以下幾個分類：
–有序：可以使用下標（索引）訪問元素
–無序：不可以使用下標（索引）訪問元素
–可變：可以被修改
–不可變：不可以被修改

	有序	無序
可變	列表	字典、集合
不可變	字符串、元組	數值

數值類型

Python3中數值類型支持：

類型	值	范圍
int	1,2	（-無窮，+無窮）
float(無double)	1.2,3.7E-2（科學計數法，10的-2次方）	（-無窮，+無窮）
boolean（繼承了int類型）	True（參與計算的話，True默認1，False默認0）	[True,False]
complex	x+yj	x是實數部分，y是虛數部分

基本算術運算

a = 10
b = 3# 加法
sum_result = a + b  # 結果為13# 減法
sub_result = a - b  # 結果為7# 乘法
mul_result = a * b  # 結果為30# 除法（浮點數）
div_result = a / b  # 結果為3.333...# 整數除法（向下取整）
floor_div = a // b  # 結果為3# 取模（余數）
mod_result = a % b  # 結果為1# 冪運算
power_result = a ** b  # 結果為1000

數值類型轉換

x = 5.7# 轉換為整數（截斷小數）
int_x = int(x)  # 結果為5# 轉換為浮點數
float_x = float(10)  # 結果為10.0# 復數運算
complex_num = complex(2, 3)  # 結果為2+3j

數學函數

import math# 平方根
sqrt_val = math.sqrt(16)  # 結果為4.0# 對數
log_val = math.log(10, 2)  # 以2為底10的對數# 三角函數
sin_val = math.sin(math.pi / 2)  # 結果為1.0# 階乘
factorial_val = math.factorial(5)  # 結果為120# 求和
c = math.sum(a,b) # 最大值最小值
a = math.max(c,b)
a = math.min(c,b)# 返回兩個數值的商和余數
a,b = math.divmod(y,x)#### 其他常用函數
- 冪運算：`math.pow(x, y)` 計算x的y次方
- 絕對值：`math.fabs(x)` 浮點數絕對值,整數求絕對值math.abs(x)
- 取整：`math.ceil(x)`向上取整，`math.floor(x)`向下取整
- 常量：`math.pi`圓周率，`math.e`自然對數底數注意：對于復數運算，需要使用cmath模塊而非math模塊。## 數學函數詳解

隨機數生成

import random# 生成0到1之間的隨機浮點數
rand_float = random.random()# 生成指定范圍內的整數
rand_int = random.randint(1, 100)# 從序列中隨機選擇
rand_choice = random.choice([1, 2, 3, 4, 5])

數值比較與邏輯運算

x = 5
y = 10# 比較運算
greater = x > y  # False
equal = x == 5  # True# 邏輯運算
logical_and = (x < 10) and (y > 5)  # True
logical_or = (x == 5) or (y == 0)  # True

字符和字符串

字符串的基本定義

在Python中，字符串是由零個或多個字符組成的不可變序列，用單引號（'）、雙引號（"）或三引號（'''或"""）包裹。例如：

str1 = 'Hello'
str2 = "World"
str3 = '''多行
字符串'''

字符串的特性

• 不可變性：字符串一旦創建，其內容無法修改。若需改變，需創建新字符串。
• 編碼支持：Python 3默認使用Unicode編碼（UTF-8），可直接處理多語言字符。
• 轉義字符：通過反斜杠（\）插入特殊字符，如\n（換行）、\t（制表符）。

多行字符串

三引號允許字符串跨越多行，保留換行和縮進格式：

multi_line = """這是
一個多行
字符串"""

原始字符串（Raw String）

在字符串前加r或R，忽略轉義字符，常用于正則表達式或文件路徑：

raw_str = r"C:\new_folder\temp"

字符串的常見操作

• 拼接：用+連接字符串。
• 重復：用*重復字符串，如'a' * 3得到'aaa'。
• 索引與切片：通過下標訪問字符或子串，如str1[0]或str1[1:4]。
• 切片的批量操作：str[a: b :c]，a是其實元素的位置，b是終止元素的位置，c是步長。str[::]表示取所有；str[::2]表示每兩個取一個。abc同樣可以為負數。

字符串格式化

Python提供多種格式化方法：

• f-string（Python 3.6+）：

  name = "Alice"
  greeting = f"Hello, {name}"
  

• format()方法：

  template = "{} {}".format("Hello", "Bob")
  

• 百分號（%）格式化（舊式）：

  formatted = "Value: %d" % 42
  

字符串的基本定義

在Python中，字符串是由零個或多個字符組成的不可變序列，用單引號（'）、雙引號（"）或三引號（'''或"""）包裹。例如：

str1 = 'Hello'
str2 = "World"
str3 = '''多行
字符串'''

字符串的特性

• 不可變性：字符串一旦創建，其內容無法修改。若需改變，需創建新字符串。
• 編碼支持：Python 3默認使用Unicode編碼（UTF-8），可直接處理多語言字符。
• 轉義字符：通過反斜杠（\）插入特殊字符，如\n（換行）、\t（制表符）。

多行字符串

三引號允許字符串跨越多行，保留換行和縮進格式：

multi_line = """這是
一個多行
字符串"""

原始字符串（Raw String）

在字符串前加r或R，忽略轉義字符，常用于正則表達式或文件路徑：

raw_str = r"C:\new_folder\temp"

字符串的常見操作

• 拼接1：用+連接字符串。
• 拼接2：“–”.join(“HUAWEI”) ==> ‘H–U–A–W–E–I’
• 重復：用*重復字符串，如'a' * 3得到'aaa'。
• 索引與切片：通過下標訪問字符或子串，如str1[0]或str1[1:4]。
• 分割：str.split(str1),以str1為分隔符對字符串切割， “python”.split(‘t’) ==> [‘py’, ‘hon’]
• 替換：“python”.replace(‘py’,‘PY’) ==> ‘PYthon’
• 大寫： “python”.upper()==>‘PYTHON’
• 小寫：“PYTHON”.lower()==>‘python’
• 格式化輸出：print(“我的名字叫%s，今年%a歲”%(“Zonda”,26))==>我的名字叫Zonda，今年26歲

元組

元組的定義

元組（Tuple）是Python中的一種不可變有序序列，用于存儲多個元素。元組使用圓括號()定義，元素之間用逗號分隔。即使只有一個元素，也需要在元素后加逗號以區分元組和其他數據類型。

# 定義元組
tuple1 = (1, 2, 3)          # 多元素元組
tuple2 = ("a",)             # 單元素元組（需加逗號）
tuple3 = tuple([4, 5, 6])   # 通過構造函數創建

元組的特性

不可變性：元組一旦創建，其 元素不可修改、刪除或添加。但若元素本身是可變對象（如列表），其內容可修改。
有序性：元組中的元素按定義順序存儲，支持索引和切片操作。

# 不可變示例
t = (1, 2, [3, 4])
t[2][0] = 5  # 合法，修改元組中的列表元素
t[0] = 10    # 非法，拋出TypeError

元組的常見操作

索引與切片：通過下標訪問元素，切片返回新元組。
遍歷：使用for循環遍歷元組。
拼接與重復：+拼接元組，*重復元組。

t = (1, 2, 3, 4)
print(t[1])       # 輸出: 2
print(t[1:3])     # 輸出: (2, 3)
new_t = t + (5,)  # 拼接: (1, 2, 3, 4, 5)

元組與列表的區別

可變性：列表可變，元組不可變。
性能：元組因不可變性，通常比列表更高效，適合作為字典鍵或常量集合。
用途：列表用于動態數據，元組用于保護數據不被修改。

# 元組作為字典鍵
dict_key = {("a", "b"): "value"}
```### 元組的定義  
元組（Tuple）是Python中的一種不可變有序序列，用于存儲多個元素。元組使用圓括號`()`定義，元素之間用逗號分隔。即使只有一個元素，也需要在元素后加逗號以區分元組和其他數據類型。  ```python
# 定義元組
tuple1 = (1, 2, 3)          # 多元素元組
tuple2 = ("a",)             # 單元素元組（需加逗號）
tuple3 = tuple([4, 5, 6])   # 通過構造函數創建

元組的特性

不可變性：元組一旦創建，其元素不可修改、刪除或添加。但若元素本身是可變對象（如列表），其內容可修改。
有序性：元組中的元素按定義順序存儲，支持索引和切片操作。

# 不可變示例
t = (1, 2, [3, 4])
t[2][0] = 5  # 合法，修改元組中的列表元素
t[0] = 10    # 非法，拋出TypeError

元組的常見操作

索引與切片：通過下標訪問元素，切片返回新元組。
遍歷：使用for循環遍歷元組。
拼接與重復：+拼接元組，*重復元組。

t = (1, 2, 3, 4)
print(t[1])       # 輸出: 2
print(t[1:3])     # 輸出: (2, 3)
new_t = t + (5,)  # 拼接: (1, 2, 3, 4, 5)

元組與列表的區別

可變性：列表可變，元組不可變。
性能：元組因不可變性，通常比列表更高效，適合作為字典鍵或常量集合。
用途：列表用于動態數據，元組用于保護數據不被修改。

# 元組作為字典鍵
dict_key = {("a", "b"): "value"}

列表

Python列表的定義

Python列表是一種有序、可變的數據結構，用于存儲多個元素。列表用方括號[]表示，元素之間用逗號分隔。列表可以包含不同類型的元素，例如整數、字符串、浮點數，甚至其他列表。

my_list = [1, 2, 3, "apple", 5.5]

Python列表的特點

列表是動態的，可以隨時添加或刪除元素。列表允許重復元素，并且可以通過索引訪問或修改元素。索引從0開始，負數索引表示從列表末尾開始計數。

fruits = ["apple", "banana", "cherry"]
print(fruits[1])  # 輸出: banana
print(fruits[-1]) # 輸出: cherry

列表的常用操作

列表支持多種操作，包括切片、拼接、復制等。切片操作可以獲取列表的子集，格式為list[start:end:step]。拼接操作可以使用+合并兩個列表。

numbers = [1, 2, 3, 4, 5]
print(numbers[1:4])  # 輸出: [2, 3, 4]
print(numbers[::2])  # 輸出: [1, 3, 5]

列表拼接操作：

list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2   # [1, 2, 3, 4]
list1.extend(list2)        # list1變為[1, 2, 3, 4]

可以將元組轉化為列表：

t1=(2,3,(1,2,3))
list1 = list(t1)
print(list1) #輸出[2, 3, (1, 2, 3)]

列表復制操作
復制分為淺拷貝和深拷貝。淺拷貝（copy()或切片）僅復制外層對象，深拷貝（deepcopy()）會遞歸復制所有嵌套對象。

import copy
original = [1, [2, 3]]
shallow = original.copy()          # 淺拷貝，嵌套列表共享引用
deep = copy.deepcopy(original)     # 深拷貝，完全獨立

列表查找

使用index()方法查找元素首次出現的索引，in運算符判斷元素是否存在。查找失敗時index()會拋出ValueError。

lst = [10, 20, 30, 20]
idx = lst.index(20)  # 返回1
exists = 30 in lst   # 返回True

列表排序

sort()方法原地排序，sorted()函數返回新列表。可通過key參數定制排序規則，reverse控制升降序。

lst = [3, 1, 4, 2]
lst.sort()                      # 原地排序變為[1, 2, 3, 4]
new_lst = sorted(lst, reverse=True)  # 生成[4, 3, 2, 1]

列表逆序

reverse()方法原地逆序，切片[::-1]生成新逆序列表。

lst = [1, 2, 3]
lst.reverse()       # 變為[3, 2, 1]
reversed_lst = lst[::-1]  # 生成[1, 2, 3]

數量統計

count()統計元素出現次數，len()獲取列表長度。

lst = [1, 2, 2, 3]
cnt = lst.count(2)   # 返回2
length = len(lst)    # 返回4
```### 列表查找
使用`index()`方法查找元素首次出現的索引，`in`運算符判斷元素是否存在。查找失敗時`index()`會拋出`ValueError`。
```python
lst = [10, 20, 30, 20]
idx = lst.index(20)  # 返回1
exists = 30 in lst   # 返回True

列表的方法

列表提供了一系列內置方法，例如append()、extend()、insert()、remove()、pop()等。這些方法可以用于添加、刪除或修改列表中的元素。

#增加：
colors = ["red", "green"]
colors.append("blue")     # 添加元素
colors.insert(1, "yellow") # 插入元素
colors.extend(["yellow","blue","black"])#將可迭代的對象逐個插入列表尾部
#刪除：
colors.remove("green")    # 刪除元素
colors.pop(0) #刪除"red"并輸出
#查找：
colors.index("green")#返回給定元素第一次出現位置的下標，輸出為1

列表的遍歷

可以通過循環遍歷列表中的元素。常見的遍歷方式包括for循環和while循環。列表推導式是一種簡潔的生成列表的方式。

squares = [x**2 for x in range(5)]
print(squares)  # 輸出: [0, 1, 4, 9, 16]

也可以在遍歷的過程中加上條件

squares = [x**2 for x in range(5) if x % 2 == 1]
print(squares)  # 輸出: [1,9]

也可以兩個數字一起加條件遍歷

print([(x,y) for x in range(5) if x%2==1 for y in range(10) if y % 3 == 1])
#輸出[(1, 1), (1, 4), (1, 7), (3, 1), (3, 4), (3, 7)]

列表與元組的區別

列表是可變的，而元組是不可變的。如果需要修改數據，應使用列表；如果需要不可變的數據結構，應使用元組。元組用圓括號()表示。

my_tuple = (1, 2, 3)

以上內容涵蓋了Python列表的核心概念和常見操作，適用于初學者和需要快速回顧的開發人員。### Python列表的定義

Python列表是一種有序、可變的數據結構，用于存儲多個元素。列表用方括號[]表示，元素之間用逗號分隔。列表可以包含不同類型的元素，例如整數、字符串、浮點數，甚至其他列表。

my_list = [1, 2, 3, "apple", 5.5]

列表和數組

Python中的列表在外觀上和數組相似，但是兩者并不是一種結構。
–Python的內置數據結構中并沒有數組，需要借助工具包numpy實現。
–列表和數組可以相互轉化，但是本質是不一樣的。數組有維度，列表無維度。

>>> import numpy
>>> l = [1,2,3,4]
>>> print(l)
[1, 2, 3, 4]
>>> print(numpy.array(l))
[1 2 3 4]
>>> l2 = [[1,2],[3,4]]
>>> print(l2)
[[1, 2], [3, 4]]
>>> print(numpy.array(l2))
[[1 2][3 4]]

字典

字典的定義：字典的每個元素由兩部分組成-鍵和值，所以字典的元素也被稱為鍵值對。
–其中鍵是不可變且唯一的
–如果字典有相同的鍵，則后面的鍵對應的值會將前面的值覆蓋
–數據量大的時候，字典數據的訪問速度比列表快
–字典是無序可變的序列

deepseek解釋：字典（Dictionary）是Python中一種可變容器模型，可存儲任意類型對象。字典的每個元素由一個鍵（key）和一個值（value）組成，鍵和值之間用冒號分隔，元素之間用逗號分隔，整個字典包括在花括號中。

字典的鍵必須是唯一的，且不可變類型（如字符串、數字或元組）。值可以是任何數據類型，且可以重復。

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

字典的創建

字典可以通過多種方式創建。直接使用花括號是最常見的方法。

# 空字典
empty_dict = {}# 直接賦值
person = {'name': 'Bob', 'age': 30}# 使用dict()構造函數
person = dict(name='Bob', age=30)# 從鍵值對列表創建
person = dict([('name', 'Bob'), ('age', 30)])

字典的訪問

可以通過鍵來訪問字典中的值。如果鍵不存在，會引發KeyError。使用get()方法可以避免KeyError，并返回默認值。

person = {'name': 'Bob', 'age': 30}# 直接訪問
print(person['name'])  # 輸出: Bob# 使用get方法
print(person.get('name'))  # 輸出: Bob
print(person.get('gender', 'Unknown'))  # 輸出: Unknown

字典的修改

字典是可變的，可以通過鍵來修改或添加新的鍵值對。

person = {'name': 'Bob', 'age': 30}# 修改值
person['age'] = 31# 添加新鍵值對
person['city'] = 'London'print(person)  # 輸出: {'name': 'Bob', 'age': 31, 'city': 'London'}

字典的刪除

可以使用del語句、pop()方法或clear()方法來刪除字典中的元素。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}# 刪除特定鍵值對
del person['age']# 刪除并返回值
city = person.pop('city')# 清空字典
person.clear()print(person)  # 輸出: {}

字典的遍歷

字典可以通過多種方式遍歷，包括鍵、值或鍵值對。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}# 遍歷鍵
for key in person:print(key)# 遍歷值
for value in person.values():print(value)# 遍歷鍵值對
for key, value in person.items():print(key, value)

字典的常用方法

字典提供了多種內置方法，用于操作和查詢字典。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}# 獲取所有鍵
keys = person.keys()# 獲取所有值
values = person.values()# 獲取所有鍵值對
items = person.items()# 復制字典
person_copy = person.copy()# 更新字典
person.update({'age': 31, 'gender': 'Male'})

字典的嵌套

字典可以嵌套在其他字典中，形成復雜的數據結構。

people = {'person1': {'name': 'Alice', 'age': 25},'person2': {'name': 'Bob', 'age': 30}
}print(people['person1']['name'])  # 輸出: Alice

字典推導式

字典推導式提供了一種簡潔的創建字典的方法。

# 創建平方字典
squares = {x: x*x for x in range(6)}print(squares)  # 輸出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

集合

集合的定義

集合（set）是Python中的一種無序、可變且不重復元素的容器數據類型。其核心特性包括：

• 無序性：元素存儲順序與添加順序無關。
• 唯一性：自動去除重復元素。
• 可變性：支持增刪操作，但元素本身必須是不可變類型（如數字、字符串、元組）。

集合用大括號 {} 或 set() 函數定義，空集合必須使用 set()（{} 表示空字典）。

s1 = {1, 2, 3}          # 直接定義
s2 = set([1, 2, 2])     # 從列表轉換，結果為 {1, 2}

---

集合的操作方法

添加元素

• add(x)：添加單個元素。
• update(iterable)：合并其他可迭代對象（如列表、元組）的元素。

s = {1, 2}
s.add(3)               # {1, 2, 3}
s.update([4, 5])       # {1, 2, 3, 4, 5}

刪除元素

• remove(x)：刪除指定元素，若不存在則報錯。
• discard(x)：刪除元素，若不存在則不報錯。
• pop()：隨機刪除并返回一個元素（因集合無序）。
• clear()：清空集合。

s = {1, 2, 3}
s.remove(2)            # {1, 3}
s.discard(4)           # 無變化
s.pop()                # 可能返回 1 或 3，隨機刪除一個元素并返回

---

集合的運算

集合支持數學中的集合操作：

基本運算

• union() 或 |：并集。
• intersection() 或 &：交集。
• difference() 或 -：差集。
• symmetric_difference() 或 ^：對稱差集（僅在其中一個集合存在的元素）。

a = {1, 2, 3}
b = {3, 4, 5}
a.union(b)             # {1, 2, 3, 4, 5}
a & b                  # {3}
a - b                  # {1, 2}
a ^ b                  # {1, 2, 4, 5}

判斷方法

• issubset() 或 <=：子集判斷。
• issuperset() 或 >=：超集判斷。
• isdisjoint()：判斷是否無交集。

a = {1, 2}
b = {1, 2, 3}
a.issubset(b)          # True
b.issuperset(a)        # True
a.isdisjoint({4, 5})   # True

---

集合的應用場景

1. 去重：快速去除列表中的重復項。

   lst = [1, 2, 2, 3]
   unique = list(set(lst))  # [1, 2, 3]
   

2. 成員測試：檢查元素是否存在（比列表效率更高）。
3. 數學運算：處理交集、并集等邏輯問題。

集合通過哈希表實現，因此查找操作的時間復雜度為 O(1)，適合高頻查詢場景。