python基礎(chǔ)語法

1、python基礎(chǔ)

1.1 編碼

默認(rèn)情況下，Python 3 源碼文件以 UTF-8 編碼，所有字符串都是 unicode 字符串。 當(dāng)然你也可以為源碼文件指定不同的編碼

1.2標(biāo)識符

標(biāo)識符就是我們編程的時候使用的“名字“ , 給類、接口、方法、變量、常量名，包名等起名字的字符序列

• 第一個字符必須是字母表中字母或下劃線 _ 。
• 標(biāo)識符的其他的部分由字母、數(shù)字和下劃線組成。
• 標(biāo)識符對大小寫敏感。
• 在 Python 3 中，可以用中文作為變量名，非 ASCII 標(biāo)識符也是允許的了。

1.3注釋

1.3.1注釋

單行注釋，單行注釋以#開頭

# print ("Hello, Python!")
print ("Hello, Python!") # 第二個注釋

輸出

Hello, Python!

多行注釋

'''
print ("Hello, Python!")
print ("Hello, Python!")
'''
 
"""
print ("Hello, Python!")
print ("Hello, Python!")
"""
print ("Hello, Python!")

輸出

Hello, Python!

1.4行與縮進

python最具特色的就是使用縮進來表示代碼塊，不需要使用大括號 {} 。在python中代碼利用縮進來形成代碼層，縮進的空格數(shù)是可變的，但是同一個代碼塊的語句必須包含相同的縮進空格數(shù)。

if True:
    print ("True")
else:
    print ("False")

當(dāng)縮進不一樣的時候會導(dǎo)致代碼錯誤

1.5 多行語句

Python 通常是一行寫完一條語句，但如果語句很長，我們可以使用反斜杠 \ 來實現(xiàn)多行語句，例如：

total = item_one + \
        item_two + \
        item_three

1.6變量

• 變量代表一個有名字的、具有特定屬性的一個存儲單元；
• 變量用來存放數(shù)據(jù)，也就是存放變量的值；
• 變量的值可以改變；
• 變量有特定的類型，類型決定了存儲單元的大小和變量值的范圍，運算符可應(yīng)用于變量上。

變量常被描述為可?于存儲值的盒?。在你剛接觸變量時，這種定義很有幫助，但它并沒有準(zhǔn)確地描述 Python 內(nèi)部表?變量的?式。?種好得多的定義是，變量是可以被賦值的標(biāo)簽，也可以說變量指向特定的值。

1.6.1變量的命名和使?

1. 變量名只能包含字?、數(shù)字和下劃線1。變量名能以字?或下劃線打頭，但不能以數(shù)字打頭。

   例如，可將變量命名為 message_1，但不能將其命名為 1_message。
   

2. 變量名不能包含空格，但能使?下劃線來分隔其中的單詞。

   例如，變量名 greeting_message 可?，但變量名 greeting message 會引發(fā)錯誤。
   

3. 不要將 Python 關(guān)鍵字和函數(shù)名?作變量名。

   例如，不要將 print ?作變量名，因為它被 Python 留作特殊?途。
   

4. 變量名應(yīng)既簡短?具有描述性。

   例如，name ? n 好，student_name ? s_n 好，name_length ?length_of_persons_name 好。
   

5. 慎??寫字? l 和?寫字? O，因為它們可能被?錯看成數(shù)字 1 和0。

6. 在 Python 3 中，變量名還可以包含其他 Unicode 字符。例如，中?字符也是?持的，但是不推薦。

1.6.1同時給多個變量賦值

可在??代碼中給多個變量賦值，這有助于縮短程序并提?其可讀性。這種做法最常?于將?系列數(shù)賦給?組變量。例如，下?演?了如何將變量 x、y 和 z 都初始化為零：

x, y, z = 0, 0, 0

在這樣做時，需要?逗號將變量名分開；對于要賦給變量的值，也需要做同樣的處理。Python 將按順序?qū)⒚總€值賦給對應(yīng)的變量。只要變量數(shù)和值的個數(shù)相同，Python 就能正確地將變量和值關(guān)聯(lián)起來。

1.7空行

函數(shù)之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數(shù)入口之間也用一行空行分隔，以突出函數(shù)入口的開始。

空行與代碼縮進不同，空行并不是 Python 語法的一部分。書寫時不插入空行，Python 解釋器運行也不會出錯。但是空行的作用在于分隔兩段不同功能或含義的代碼，便于日后代碼的維護或重構(gòu)。

記住：空行也是程序代碼的一部分。

1.8 輸入輸出

執(zhí)行下面的程序在按回車鍵后就會等待用戶輸入：

#!/usr/bin/python3  
input("\n\n按下 enter 鍵后退出。")

以上代碼中 ，\n\n 在結(jié)果輸出前會輸出兩個新的空行。一旦用戶按下 enter 鍵時，程序?qū)⑼顺觥?/p>

---

執(zhí)行下面的程序在按回車鍵后就會輸出：

print("hello word!")

1.9 python常量

常量（constant）是在程序的整個?命周期內(nèi)都保持不變的變量。Python 沒有內(nèi)置的常量類型，但 Python 程序員會使?全?寫字?來指出應(yīng)將某個變量視為常量，其值應(yīng)始終不變：

MAX_CONNECTIONS = 5000

在代碼中，要指出應(yīng)將特定的變量視為常量，可以將其變量名全?寫（也可以不大寫）

2、基礎(chǔ)語法

2.1數(shù)據(jù)類型

Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創(chuàng)建。

在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內(nèi)存中對象的類型。

等號（=）用來給變量賦值。

等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：

#!/usr/bin/python3

counter = 100      # 整型變量
miles  = 1000.0    # 浮點型變量
name   = "runoob"   # 字符串

print (counter)
print (miles)
print (name)

執(zhí)行以上程序會輸出如下結(jié)果：

100
1000.0
runoob

2.1.1 標(biāo)準(zhǔn)數(shù)據(jù)類型

Python3 中常見的數(shù)據(jù)類型有：

• Number（數(shù)字）
• String（字符串）
• bool（布爾類型）
• List（列表）
• Tuple（元組）
• Set（集合）
• Dictionary（字典）

Python3 的六個標(biāo)準(zhǔn)數(shù)據(jù)類型中：

• 不可變數(shù)據(jù)（3 個）：Number（數(shù)字）、String（字符串）、Tuple（元組）；
• 可變數(shù)據(jù)（3 個）：List（列表）、Dictionary（字典）、Set（集合）。

此外還有一些高級的數(shù)據(jù)類型，如: 字節(jié)數(shù)組類型(bytes)。

2.1.2數(shù)字(Number)類型

內(nèi)置的 type() 函數(shù)可以用來查詢變量所指的對象類型。

python中數(shù)字有四種類型：整數(shù)、布爾型、浮點數(shù)和復(fù)數(shù)。

• int (整數(shù)), 如 1, 只有一種整數(shù)類型 int，表示為長整型，沒有 python2 中的 Long。
• bool (布爾), 如 True。
• float (浮點數(shù)), 如 1.23、3E-2
• complex (復(fù)數(shù)) - 復(fù)數(shù)由實部和虛部組成，形式為 a + bj，其中 a 是實部，b 是虛部，j 表示虛數(shù)單位。如 1 + 2j、 1.1 + 2.2i

在python中可直接對整數(shù)（integer）執(zhí)?加（+）減（-）乘（*）除（/）運算。

2.1.2.1 賦值運算

• 1、Python可以同時為多個變量賦值，如a, b = 1, 2。
• 2、一個變量可以通過賦值指向不同類型的對象。
• 3、數(shù)值的除法包含兩個運算符：/ 返回一個浮點數(shù)，// 返回一個整數(shù)。
• 4、在混合計算時，Python會把整型轉(zhuǎn)換成為浮點數(shù)。

2.1.2.2 浮點數(shù)

在編程語言中，小數(shù)通常以浮點數(shù)的形式存儲。浮點數(shù)和定點數(shù)是相對的：小數(shù)在存儲過程中如果小數(shù)點發(fā)生移動，就稱為浮點數(shù)；如果小數(shù)點不動，就稱為定點數(shù)。書寫小數(shù)時必須包含一個小數(shù)點，否則會被 Python 當(dāng)作整數(shù)處理。

a = float(input("輸入一個小數(shù)"))
b = float(input("輸入一個小數(shù)"))
c = a * b
print(type(c))		#打印出來數(shù)據(jù)類型
print(f'a*b的值為{c:.2f}')

輸入一個小數(shù)1.33
輸入一個小數(shù)1.44
<class 'float'>
a*b的值為1.92

進程已結(jié)束，退出代碼為 0

2.1.2.3 布爾類型

布爾數(shù)據(jù)類型可以是兩個值之一，即True（真）或False（假）。在編程中，我們使用布爾值進行比較，并確定給定程序的控制流程。

布爾值表示與數(shù)學(xué)邏輯分支相關(guān)的真值，這影響計算機科學(xué)中的算法。在Python中，值True和False也始終使用大寫的T和F，因為它們在Python中是特殊值。
布爾比較運算符:

運算符	含義
==	等于
!=	不等于
<	小于
>	大于
<=	小于或者等于
>=	大于或者等于

x = 5
y = 8

print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)

x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

2.1.2.4 數(shù)字類型轉(zhuǎn)換

有時候，我們需要對數(shù)據(jù)內(nèi)置的類型進行轉(zhuǎn)換，數(shù)據(jù)類型的轉(zhuǎn)換，你只需要將數(shù)據(jù)類型作為函數(shù)名即可。

int(x) 將x轉(zhuǎn)換為一個整數(shù)。

float(x) 將x轉(zhuǎn)換到一個浮點數(shù)。

complex(x) 將x轉(zhuǎn)換到一個復(fù)數(shù)，實數(shù)部分為 x，虛數(shù)部分為 0。

complex(x, y) 將 x 和 y 轉(zhuǎn)換到一個復(fù)數(shù)，實數(shù)部分為 x，虛數(shù)部分為 y。x 和 y 是數(shù)字表達式。

2.1.2.5 列題

你正在幫助一個小型超市管理他們的庫存系統(tǒng)。為了簡化操作，你需要編寫一些Python代碼來處理商品的價格和數(shù)量。在這個練習(xí)中，我們將專注于使用Python的數(shù)字類型（如整數(shù)int、浮點數(shù)float）進行計算。

題目：超市購物折扣計算

題目描述
編寫一個 Python 程序，計算顧客購買商品的最終應(yīng)付金額。具體要求如下：

1. 輸入商品的單價（浮點數(shù)）和購買數(shù)量（整數(shù)）。
2. 計算總價（單價 × 數(shù)量）。
3. 如果總價 大于或等于 100 元，則享受 9 折 優(yōu)惠。
4. 輸出最終應(yīng)付金額，保留兩位小數(shù)（例如：應(yīng)付金額：135.00元）。

---

題解

知識點

1. 輸入類型轉(zhuǎn)換（float() 和 int()）。
2. 條件判斷（if 語句）。
3. 浮點數(shù)運算和格式化輸出。

實現(xiàn)思路

1. 讀取輸入：將用戶輸入的單價轉(zhuǎn)換為浮點數(shù)，數(shù)量轉(zhuǎn)換為整數(shù)。
2. 計算總價：用單價乘以數(shù)量得到初始總價。
3. 判斷折扣：如果總價大于等于 100 元，則打 9 折。
4. 格式化輸出：保留兩位小數(shù)，確保貨幣金額的規(guī)范顯示。

代碼示例

# 輸入單價和數(shù)量
price = float(input("請輸入商品單價："))
quantity = int(input("請輸入購買數(shù)量："))

# 計算總價
total = price * quantity

# 判斷是否滿足折扣條件
if total >= 100:
    total *= 0.9  # 打9折

# 格式化輸出結(jié)果（保留兩位小數(shù)）
print(f"應(yīng)付金額：{total:.2f}元")

---

示例輸入與輸出

1. 輸入：

   請輸入商品單價：50.0  
   請輸入購買數(shù)量：3  
   

   輸出：

   應(yīng)付金額：135.00元  
   

2. 輸入：

   請輸入商品單價：25.5  
   請輸入購買數(shù)量：4  
   

   輸出：

   應(yīng)付金額：91.80元  
   

3. 輸入：

   請輸入商品單價：10.0  
   請輸入購買數(shù)量：5  
   

   輸出：

   應(yīng)付金額：50.00元  
   

---

最終答案

price = float(input("請輸入商品單價："))
quantity = int(input("請輸入購買數(shù)量："))
total = price * quantity
if total >= 100:
    total *= 0.9
print(f"應(yīng)付金額：{total:.2f}元")

題目：時間轉(zhuǎn)換器

題目描述
編寫一個 Python 程序，將用戶輸入的總秒數(shù)轉(zhuǎn)換為“小時、分鐘、秒”的表示形式。例如，輸入 3661 秒，程序應(yīng)輸出 1小時1分1秒。程序需滿足以下要求：

1. 輸入為一個非負(fù)整數(shù)。
2. 輸出格式為 X小時Y分Z秒，其中 X、Y、Z 分別為計算得到的小時、分鐘和秒。
3. 即使某一部分為 0，也需完整顯示（例如輸入 3600 秒，輸出 1小時0分0秒）。

---

題解

知識點

1. 整數(shù)除法（//）和取余運算（%）。
2. 輸入輸出操作。
3. 字符串格式化。

實現(xiàn)思路

1. 計算小時：總秒數(shù)整除 3600（1小時=3600秒），得到小時數(shù)。
2. 計算剩余秒數(shù)：總秒數(shù)對 3600 取余，得到扣除小時部分后的剩余秒數(shù)。
3. 計算分鐘：剩余秒數(shù)整除 60（1分鐘=60秒），得到分鐘數(shù)。
4. 計算秒：剩余秒數(shù)對 60 取余，得到最終的秒數(shù)。
5. 格式化輸出：將小時、分鐘、秒按固定格式拼接為字符串。

代碼示例

# 讀取輸入
total_seconds = int(input("請輸入總秒數(shù)："))

# 計算小時、分鐘、秒
hours = total_seconds // 3600
remaining_seconds = total_seconds % 3600
minutes = remaining_seconds // 60
seconds = remaining_seconds % 60

# 格式化輸出
print(f"{hours}小時{minutes}分{seconds}秒")

---

示例輸入與輸出

1. 輸入：

   3661
   

   輸出：

   1小時1分1秒
   

2. 輸入：

   7200
   

   輸出：

   2小時0分0秒
   

3. 輸入：

   65
   

   輸出：

   0小時1分5秒
   

---

最終答案

total_seconds = int(input("請輸入總秒數(shù)："))
hours = total_seconds // 3600
remaining = total_seconds % 3600
minutes = remaining // 60
seconds = remaining % 60
print(f"{hours}小時{minutes}分{seconds}秒")

2.1.3 運算符

Python 語言支持以下類型的運算符:

• 算術(shù)運算符
• 比較（關(guān)系）運算符
• 賦值運算符
• 邏輯運算符
• 位運算符
• 成員運算符
• 身份運算符
• 運算符優(yōu)先級

2.1.3.1 python 算數(shù)運算符

2.1.3.2Python 比較運算符

2.1.3.3Python賦值運算符

2.1.3.4Python位運算符

按位運算符是把數(shù)字看作二進制來進行計算的。Python中的按位運算法則如下：

下表中變量 a 為 60，b 為 13二進制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b        # 12 = 0000 1100
print ("1 - c 的值為：", c)
 
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值為：", c)
 
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值為：", c)
 
c = ~a           # -61 = 1100 0011
print ("4 - c 的值為：", c)
 
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值為：", c)
 
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值為：", c)

1 - c 的值為： 12
2 - c 的值為： 61
3 - c 的值為： 49
4 - c 的值為： -61
5 - c 的值為： 240
6 - c 的值為： 15

2.1.3.5Python邏輯運算符

Python語言支持邏輯運算符，以下假設(shè)變量 a 為 10, b為 20:

2.1.3.6Python成員運算符

除了以上的一些運算符之外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 變量 a 在給定的列表中 list 中")
else:
   print ("1 - 變量 a 不在給定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 變量 b 不在給定的列表中 list 中")
else:
   print ("2 - 變量 b 在給定的列表中 list 中")
 
# 修改變量 a 的值
a = 2
if ( a in list ):
   print ("3 - 變量 a 在給定的列表中 list 中")
else:
   print ("3 - 變量 a 不在給定的列表中 list 中")

1 - 變量 a 不在給定的列表中 list 中
2 - 變量 b 不在給定的列表中 list 中
3 - 變量 a 在給定的列表中 list 中

2.1.3.7Python身份運算符

身份運算符用于比較兩個對象的存儲單元

2.1.3.8Python運算符優(yōu)先級

以下表格列出了從最高到最低優(yōu)先級的所有運算符， 相同單元格內(nèi)的運算符具有相同優(yōu)先級。 運算符均指二元運算，除非特別指出。 相同單元格內(nèi)的運算符從左至右分組（除了冪運算是從右至左分組）：

2.1.3.9 列題

題目1：矩形面積與周長計算器

題目描述
編寫一個 Python 程序，輸入矩形的長度和寬度（均為正數(shù)），計算并輸出其面積和周長。要求：

1. 輸入為兩個浮點數(shù)，分別表示長度和寬度。
2. 輸出格式為 面積：X，周長：Y，其中 X 和 Y 保留兩位小數(shù)。

---

**題解 **

知識點

1. 算術(shù)運算符（* 和 +）。
2. 輸入類型轉(zhuǎn)換與浮點數(shù)運算。
3. 字符串格式化保留小數(shù)位。

實現(xiàn)思路

1. 通過 input 讀取長度和寬度，并轉(zhuǎn)換為浮點數(shù)。
2. 面積公式：面積 = 長 × 寬。
3. 周長公式：周長 = 2 × (長 + 寬)。
4. 使用 f-string 格式化輸出結(jié)果，保留兩位小數(shù)。

代碼示例

length = float(input("請輸入矩形的長度："))
width = float(input("請輸入矩形的寬度："))

area = length * width
perimeter = 2 * (length + width)

print(f"面積：{area:.2f}，周長：{perimeter:.2f}")

---

示例輸入與輸出

1. 輸入：

   請輸入矩形的長度：5.0  
   請輸入矩形的寬度：3.0  
   

   輸出：

   面積：15.00，周長：16.00  
   

2. 輸入：

   請輸入矩形的長度：4.5  
   請輸入矩形的寬度：2.5  
   

   輸出：

   面積：11.25，周長：14.00  
   

---

最終答案

length = float(input("請輸入矩形的長度："))
width = float(input("請輸入矩形的寬度："))
print(f"面積：{length * width:.2f}，周長：{2 * (length + width):.2f}")

---

題目2：數(shù)字整除性判斷器

題目描述
編寫一個 Python 程序，判斷用戶輸入的整數(shù)是否能 同時被3和5整除。要求：

1. 輸入為一個正整數(shù)。
2. 輸出結(jié)果為 是 或 否。

---

**題解 **

知識點

1. 取余運算符（%）。
2. 邏輯運算符（and）。
3. 條件判斷（if-else）。

實現(xiàn)思路

1. 讀取輸入并轉(zhuǎn)換為整數(shù)。
2. 判斷條件：數(shù) % 3 == 0 且 數(shù) % 5 == 0。
3. 若條件滿足輸出“是”，否則輸出“否”。

代碼示例

num = int(input("請輸入一個正整數(shù)："))

if num % 3 == 0 and num % 5 == 0:
    print("是")
else:
    print("否")

---

示例輸入與輸出

輸入：

15  

輸出：

是  

---

最終答案

num = int(input("請輸入一個正整數(shù)："))
print("是" if num % 3 == 0 and num % 5 == 0 else "否")

2.2 String（字符串）

2.2.1 訪問字符串中的值

Python中的字符串用單引號 ' 或雙引號 " 括起來，同時使用反斜杠 ** 轉(zhuǎn)義特殊字符。

Python 不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。

字符串的截取的語法格式如下：

變量[頭下標(biāo):尾下標(biāo)]

索引值以 0 為開始值，-1 為從末尾的開始位置。

加號 + 是字符串的連接符， 星號 ***** 表示復(fù)制當(dāng)前字符串，與之結(jié)合的數(shù)字為復(fù)制的次數(shù)。

#!/usr/bin/python3

str = 'Runoob'  # 定義一個字符串變量
print(str)           # 打印整個字符串
print(str[0:-1])     # 打印字符串第一個到倒數(shù)第二個字符（不包含倒數(shù)第一個字符）
print(str[0])        # 打印字符串的第一個字符
print(str[2:5])      # 打印字符串第三到第五個字符（包含第五個字符）
print(str[2:])       # 打印字符串從第三個字符開始到末尾
print(str * 2)       # 打印字符串兩次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

運行結(jié)果

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 \轉(zhuǎn)義特殊字符，如果你不想讓反斜杠發(fā)生轉(zhuǎn)義，可以在字符串前面添加一個 r，表示原始字符串：

• 1、反斜杠可以用來轉(zhuǎn)義，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義。
• 2、字符串可以用+運算符連接在一起，用*運算符重復(fù)。
• 3、Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
• 4、Python中的字符串不能改變。

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

2.2.1字符串操作

title()函數(shù)：首字母輸出大寫

upper()函數(shù)：輸出全部大寫

lower()函數(shù)：輸出全部小寫

name = "Ada Lovelace"
name_1 = "ada aovelace"
print(name.upper())
print(name.lower())
print(name_1.title())

這些代碼的輸出如下：

ADA LOVELACE
ada lovelac
Ada Lovelacee

2.2.2 f 字符串

f字符串是一種格式化字符串的方法，它允許你在字符串中直接嵌入表達式。這種方法從Python 3.6版本開始引入，被稱為格式化字符串字面量或f-string。使用f-string時，你可以將變量或表達式放在花括號{}中，并在字符串前加上f或F來創(chuàng)建一個f-string，在f字符串的使用中當(dāng)有小數(shù)點時在{}中需要寫清楚小數(shù)點的位數(shù)：f‘<內(nèi)容>{<變量>:.<小數(shù)位數(shù)>f}<內(nèi)容>’

price = 49.99
a= "開局一根腸"
info = (
f'商品名稱: {a}\n'
f'價格: {price:.3f}元'
)
print(info)

商品名稱: 開局一根腸
價格: 49.990元

2.2.3 字符串運算

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 輸出結(jié)果：", a + b)
print("a * 2 輸出結(jié)果：", a * 2)
print("a[1] 輸出結(jié)果：", a[1])
print("a[1:4] 輸出結(jié)果：", a[1:4])
 
if( "H" in a) :
    print("H 在變量 a 中")
else :
    print("H 不在變量 a 中")
 
if( "M" not in a) :
    print("M 不在變量 a 中")
else :
    print("M 在變量 a 中")
 
print (r'\n')
print (R'\n')

a + b 輸出結(jié)果： HelloPython
a * 2 輸出結(jié)果： HelloHello
a[1] 輸出結(jié)果： e
a[1:4] 輸出結(jié)果： ell
H 在變量 a 中
M 不在變量 a 中
\n
\n

進程已結(jié)束，退出代碼為 0

2.3.4 如何在使?字符串時避免語法錯誤

語法錯誤是?種你會不時遇到的錯誤。當(dāng)程序包含?法的 Python 代碼時，就會導(dǎo)致語法錯誤。

1. 正確使用引號：確保你的字符串用一對匹配的單引號('')或雙引號("")括起來。不要混用不同類型的引號作為開始和結(jié)束符號。例如，'Hello, world!' 或 "Hello, world!" 都是正確的，但 'Hello, world!" 會產(chǎn)生語法錯誤。

2. 轉(zhuǎn)義字符：如果你需要在字符串中包含引號（即與包圍字符串的引號類型相同），可以使用反斜杠()進行轉(zhuǎn)義。例如，'He said, "Hello, world!"' 或 "It\'s a wonderful day."。如果你想包含一個實際的反斜杠，則需要使用兩個反斜杠(\\)。

3. 多行字符串：如果需要編寫多行文本，可以使用三重引號(''' 或 """)來定義多行字符串。例如：

   text = '''這是一個多行
   字符串示例'''
   

   或者

   text = """這也是一個
   多行字符串示例"""
   

4. 拼接字符串：當(dāng)需要將多個字符串組合在一起時，可以使用加號(+)來拼接它們。例如："Hello, " + "world!" 結(jié)果為 "Hello, world!"。

5. 格式化字符串：使用格式化字符串（如Python中的f-string、str.format()方法）可以更方便地插入變量值到字符串中。例如，在Python中使用f-string:

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

   這樣可以減少因為手動拼接字符串而產(chǎn)生的錯誤。

6. 檢查字符串邊界：確保對字符串的操作不會超出其邊界。例如，訪問或修改字符串中的某個字符時，確認(rèn)索引值在有效范圍內(nèi)。

2.3.5 列題

題目1：字符串反轉(zhuǎn)與長度計算

題目描述
編寫一個 Python 程序，輸入一個字符串，輸出該字符串的反轉(zhuǎn)形式及其長度。要求：

1. 輸入為一個字符串。
2. 輸出格式為 反轉(zhuǎn)字符串：X，長度：Y，其中 X 是反轉(zhuǎn)后的字符串，Y 是字符串的長度。

---

**題解 **

知識點

1. 字符串切片（[::-1]）。
2. 字符串長度計算（len()）。
3. 字符串格式化輸出。

實現(xiàn)思路

1. 使用 input 讀取字符串。
2. 通過切片 [::-1] 反轉(zhuǎn)字符串。
3. 使用 len() 計算字符串長度。
4. 格式化輸出結(jié)果。

代碼示例

s = input("請輸入一個字符串：")
reversed_s = s[::-1]
length = len(s)

print(f"反轉(zhuǎn)字符串：{reversed_s}，長度：{length}")

---

示例輸入與輸出

1. 輸入：

   hello  
   

   輸出：

   反轉(zhuǎn)字符串：olleh，長度：5  
   

2. 輸入：

   Python  
   

   輸出：

   反轉(zhuǎn)字符串：nohtyP，長度：6  
   

---

最終答案

s = input("請輸入一個字符串：")
print(f"反轉(zhuǎn)字符串：{s[::-1]}，長度：{len(s)}")

---

題目2：單詞首字母大寫

題目描述
編寫一個 Python 程序，輸入一個由多個單詞組成的字符串（單詞之間用空格分隔），將每個單詞的首字母大寫，并輸出結(jié)果。要求：

1. 輸入為一個字符串。
2. 輸出格式為 轉(zhuǎn)換后的字符串：X，其中 X 是每個單詞首字母大寫后的字符串。

---

**題解 **

知識點

1. 字符串方法（split() 和 join()）。
2. 字符串方法（capitalize() 或 title()）。
3. 字符串格式化輸出。

實現(xiàn)思路

1. 使用 input 讀取字符串。
2. 使用 split() 將字符串按空格分割為單詞列表。
3. 使用 capitalize() 或 title() 將每個單詞的首字母大寫。
4. 使用 join() 將單詞列表重新組合為字符串。
5. 格式化輸出結(jié)果。

代碼示例

s = input("請輸入一個字符串：")
words = s.split()
capitalized_words = [word.capitalize() for word in words]
result = " ".join(capitalized_words)

print(f"轉(zhuǎn)換后的字符串：{result}")

---

示例輸入與輸出

1. 輸入：

   hello world  
   

   輸出：

   轉(zhuǎn)換后的字符串：Hello World  
   

2. 輸入：

   python programming is fun  
   

   輸出：

   轉(zhuǎn)換后的字符串：Python Programming Is Fun  
   

---

最終答案

s = input("請輸入一個字符串：")
print(f"轉(zhuǎn)換后的字符串：{s.title()}")

注意：

• title() 方法可以直接將每個單詞的首字母大寫，但會將其余字母轉(zhuǎn)為小寫。
• 如果需要保留單詞中其他字母的大小寫，可以使用 capitalize() 方法逐個處理單詞。

2.3列表

• List（列表） 是 Python 中使用最頻繁的數(shù)據(jù)類型。由?系列按特定順序排列的元素組成。你不僅可以創(chuàng)建包含字?表中所有字?、數(shù)字 0?9 或所有家庭成員姓名的列表，還可以將任何東?加?列表，其中的元素之間可以沒有任何關(guān)系。

• 列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)實現(xiàn)。列表中元素的類型可以不相同，它支持?jǐn)?shù)字，字符串甚至可以包含列表（所謂嵌套）。

• 列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。

• 和字符串一樣，列表同樣可以被索引和截取，列表被截取后返回一個包含所需元素的新列表。

• 列表截取的語法格式如下：

變量[頭下標(biāo):尾下標(biāo)]

注意：

1. 列表寫在方括號之間，元素用逗號隔開。
2. 和字符串一樣，列表可以被索引和切片。
3. 列表可以使用 + 操作符進行拼接。
4. 列表中的元素是可以改變的。

2.3.1 訪問列表元素

在 Python 中，第?個列表元素的索引為 0，?不是 1。?多數(shù)編程語?是如此規(guī)定的，這與列表操作的底層實現(xiàn)有關(guān)。如果結(jié)果出乎意料，問問??是否犯了簡單?常?的差?錯誤。第?個列表元素的索引為 1。根據(jù)這種簡單的計數(shù)?式，要訪問列表的任何元素，都可將其位置減 1，并將結(jié)果作為索引。

列表是有序集合，因此要訪問列表的任何元素，只需將該元素的位置（索引）告訴 Python 即可。要訪問列表元素，可指出列表的名稱，再指出元素的索引，并將后者放在?括號內(nèi)。

索引從 0 ?不是 1 開始，-1 為從末尾的開始位置。

加號 + 是列表連接運算符，星號 * 是重復(fù)操作。

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]  # 定義一個列表
tinylist = [123, 'runoob']

print (list)            # 打印整個列表
print (list[0])         # 打印列表的第一個元素
print (list[1:3])       # 打印列表第二到第四個元素（不包含第四個元素）
print (list[2:])        # 打印列表從第三個元素開始到末尾
print (tinylist * 2)    # 打印tinylist列表兩次
print (list + tinylist)  # 打印兩個列表拼接在一起的結(jié)果

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

ython 列表截取可以接收第三個參數(shù)，參數(shù)作用是截取的步長，以下實例在索引 1 到索引 4 的位置并設(shè)置為步長為 2（間隔一個位置）來截取字符串：

list_1 = ['abcd', 786, 2.23, 'runoob', 70.2]
list_2 = ['a', 'b', 'c', 'd']

print(list_1[1:4:2])
print(list_1[1:4:2] + list_2)
print(list_2[1:4:2])
print(list_1 + list_2[1:4:2])

[786, 'runoob']
[786, 'runoob', 'a', 'b', 'c', 'd']
['b', 'd']
['abcd', 786, 2.23, 'runoob', 70.2, 'b', 'd']

2.3.2 修改、添加和刪除元素

2.3.2.1 更新列表，添加列表元素

可以直接對列表的數(shù)據(jù)項進行修改或更新，也可以使用 append() 方法來添加列表元素，使用 append() 方法來添加列表項（將元素追加（append）到列表末尾），

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]
print ("第三個元素為 : ", list[2])
list[2] = 2001
print ("更新后的第三個元素為 : ", list[2])

list_1 = ['Google', 'Runoob', 'Taobao']
list_1.append('Baidu')
print ("更新后的列表 : ", list_1)

第三個元素為 :  1997
更新后的第三個元素為 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

使? insert() ?法可在列表的任意位置添加新元素。為此，需要指定新元素的索引和值：

m = ['honda', 'yamaha', 'suzuki']
m.insert(0, 'ducati')
print(m)

在這個?例中，值 'ducati' 被插?到了列表開頭。insert() ?法,在索引 0 處添加空間，并將值 'ducati' 存儲到這個地?：

['ducati', 'honda', 'yamaha', 'suzuki']

2.3.2.2 從列表中刪除元素

• 如果知道要刪除的元素在列表中的位置，可使? del 語句：

  m = ['honda', 'yamaha', 'suzuki']
  print(m)
  del m[0]
  print(m)
  

  這?使? del 語句刪除了列表 m 中的第?個元素'honda'：

  ['honda', 'yamaha', 'suzuki']
  ['yamaha', 'suzuki']
  

  使? del 可刪除任意位置的列表元素，只需要知道其位置即可。例如，下?演?了如何刪除列表 m中的第?個元素'yamaha'：

  m = ['honda', 'yamaha', 'suzuki']
  print(m)
  del m[1]
  print(m)
  

  下?的輸出表明，已經(jīng)將第?款摩托?從列表中刪除了：

  ['honda', 'yamaha', 'suzuki']
  ['honda', 'suzuki']
  

• 使? pop() ?法刪除元素

  pop() 方法是 列表(List)對象的一個內(nèi)置方法，用于移除并返回列表中的元素。根據(jù)是否傳入索引參數(shù)，pop() 的行為會有所不同：

  基本用法

  1. 不帶參數(shù)調(diào)用：如果不向 pop() 方法傳遞任何參數(shù)，默認(rèn)會移除并返回列表的最后一個元素。這是最常用的場景。

     # 初始化一個列表m，包含三個字符串元素：'honda', 'yamaha', 'suzuki'
     m = ['honda', 'yamaha', 'suzuki']
     
     # 打印列表m的當(dāng)前狀態(tài)，此時列表包含所有三個初始元素
     print(m)
     
     # 調(diào)用pop()方法，不指定參數(shù)，默認(rèn)移除并返回列表m的最后一個元素
     # 這里將移除'suzuki'，因為它在列表的末尾
     popped_m = m.pop()
     
     # 打印執(zhí)行pop()方法之后的列表m
     # 注意，現(xiàn)在列表只包含前兩個元素：'honda', 'yamaha'
     print(m)
     
     # 打印被移除的元素，即最后一次調(diào)用pop()方法時從列表中移除的元素
     # 在這個例子中，它將是'suzuki'
     print(popped_m)
     

     ['honda', 'yamaha', 'suzuki']
     ['honda', 'yamaha']
     suzuki
     

  2. 帶索引參數(shù)調(diào)用：可以向 pop() 方法傳遞一個整數(shù)參數(shù)，指定要移除和返回的元素在列表中的位置（索引）。列表的索引是從0開始的，因此第一個元素的索引是0，第二個元素的索引是1，以此類推。如果指定了一個負(fù)數(shù)索引，它將從列表的末尾開始計數(shù)（例如，-1表示最后一個元素）。

     # 初始化一個列表m，包含三個字符串元素：'honda', 'yamaha', 'suzuki'
     m = ['honda', 'yamaha', 'suzuki']
     
     # 使用pop(0)方法移除并返回列表m中的第一個元素（索引為0的元素）
     # 這里將移除'honda'，因為它是列表中的第一個元素
     first_item = m.pop(0)
     
     # 打印被移除的第一個元素，即從列表中移除的元素，在這個例子中是'honda'
     print(first_item)  # 輸出: honda
     
     # 打印執(zhí)行pop(0)方法之后的列表m
     # 注意，現(xiàn)在列表m只包含剩下的兩個元素：'yamaha', 'suzuki'
     print(m)  # 輸出: ['yamaha', 'suzuki']
     

     honda
     ['yamaha', 'suzuki']
     

  注意事項

  • 如果嘗試對空列表調(diào)用 pop() 方法，或者提供的索引超出了列表的范圍（無論是正數(shù)還是負(fù)數(shù)索引），Python 將拋出 IndexError 異常。

    m = []
    item = m.pop()  # 這里將會拋出 IndexError: pop from empty list
    

  • 使用 pop() 方法可以從列表中按位置刪除元素，并且該方法還會返回被刪除的元素，這使得它非常適合用來實現(xiàn)棧(stack)數(shù)據(jù)結(jié)構(gòu)，其中你可以使用 append() 方法添加元素到列表末尾，并使用 pop() 方法從列表末尾移除元素。

• 刪除列表中任意位置的元素和根據(jù)值刪除元素

  使用 pop() 刪除任意位置的元素

  使用 pop() 方法可以從列表中刪除任意位置的元素，并返回這個元素。只需在括號內(nèi)指定元素的索引即可。

  #示例：刪除并打印列表中的第一個摩托車
  
  m = ['honda', 'yamaha', 'suzuki']
  first_owned = m.pop(0)
  print(f"The first motorcycle I owned was a {first_owned.title()}.")
  

  注意：使用 pop() 后，該元素將從列表中移除。

  提示：如果要刪除元素且不再使用它，用 del 語句；如果需要在刪除后繼續(xù)使用該元素，則使用 pop() 方法。

• 根據(jù)值刪除元素

  當(dāng)你知道要刪除的元素值但不知道其索引時，可以使用 remove() 方法。

  # 定義一個包含四個元素的列表m
  m = ['honda', 'yamaha', 'suzuki', 'ducati']
  print("原始列表:", m)
  
  # 使用remove()方法刪除列表中的'ducati'
  m.remove('ducati')  # 刪除'ducati'
  print("移除'ducati'后的列表:", m)
  
  # 如果需要引用被刪除的元素，可以先將其賦值給一個變量
  too_expensive = 'ducati'
  
  # 假設(shè)我們再次嘗試從列表中移除'ducati'（注意：此行在當(dāng)前上下文中不是必需的，因為'ducati'已經(jīng)被移除了）
  # 這里只是為了演示如果'ducati'依然存在于列表中時的操作
  if too_expensive in m:
      m.remove(too_expensive)
      print(f"再次嘗試移除'{too_expensive}'后的列表:", m)
  else:
      print(f"\nA {too_expensive.title()} 已經(jīng)不在列表中了，所以對我來說太貴了。")
  

  原始列表: ['honda', 'yamaha', 'suzuki', 'ducati']
  移除'ducati'后的列表: ['honda', 'yamaha', 'suzuki']
  
  A Ducati 已經(jīng)不在列表中了，所以對我來說太貴了。
  

• 注意：remove() 只刪除首次出現(xiàn)的指定值。若同一值出現(xiàn)多次，需結(jié)合循環(huán)使用以確保全部刪除。

2.3.3 列表管理

2.3.3.1 使用 sort() 方法對列表進行永久排序

sort() 方法可以對列表進行永久性排序，這意味著排序后列表的順序?qū)⒈桓淖儭?/p>

# 定義一個列表
cars = ['bmw', 'audi', 'toyota', 'subaru']
# 使用sort()方法按字母順序?qū)α斜磉M行永久排序
cars.sort()
print("永久排序后的列表:", cars)

永久排序后的列表: ['audi', 'bmw', 'subaru', 'toyota']

注意：sort() 方法默認(rèn)按升序（從小到大）排序。如果需要降序排序，可以傳遞參數(shù) reverse=True。

cars.sort(reverse=True)
print("永久降序排序后的列表:", cars)

永久降序排序后的列表: ['toyota', 'subaru', 'bmw', 'audi']

2.3.3.2 使用 sorted() 函數(shù)對列表進行臨時排序

如果你想保持列表原來的順序，但又想以特定順序顯示出來，可以使用 sorted() 函數(shù)。這不會影響列表的實際順序。

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("原始列表:", cars)
print("臨時排序后的列表:", sorted(cars))
print("再次打印原始列表驗證順序未變:", cars)

原始列表: ['bmw', 'audi', 'toyota', 'subaru']
臨時排序后的列表: ['audi', 'bmw', 'subaru', 'toyota']
再次打印原始列表驗證順序未變: ['bmw', 'audi', 'toyota', 'subaru']

同樣地，sorted() 函數(shù)也支持通過傳遞 reverse=True 實現(xiàn)降序排序。

2.3.3.3反向打印列表

使用 reverse() 方法可以反轉(zhuǎn)列表中的元素順序。這個操作也是永久性的，但你可以隨時再次調(diào)用 reverse() 來恢復(fù)原順序。

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.reverse()
print("反向打印列表:", cars)

反向打印列表: ['subaru', 'toyota', 'audi', 'bmw']

2.3.3.4 確定列表的長度

使用 len() 函數(shù)可以快速獲取列表中元素的數(shù)量。

cars = ['bmw', 'audi', 'toyota', 'subaru']
length = len(cars)
print("列表的長度是:", length)

列表的長度是: 4

這些方法和函數(shù)為處理列表提供了極大的靈活性，無論是對列表進行排序、反轉(zhuǎn)還是查詢其長度，都非常直觀易懂。

2.3.4嵌套列表及其列表截取拼接

列表可以包含其他列表作為其元素，這種結(jié)構(gòu)稱為嵌套列表。此外，我們還可以通過列表的切片（截取）和拼接操作來處理這些列表。

2.3.4.1嵌套列表

下面是一個簡單的例子，展示了如何創(chuàng)建一個嵌套列表，并訪問其中的元素：

# 創(chuàng)建一個嵌套列表
nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]

# 訪問嵌套列表中的元素
print("第一個子列表:", nested_list[0])  # 輸出: ['apple', 'banana']
print("第二個子列表的第一個元素:", nested_list[1][0])  # 輸出: carrot

第一個子列表: ['apple', 'banana']
第二個子列表的第一個元素: carrot

2.3.4.2列表截取

列表的切片操作允許我們獲取列表的一部分。下面是如何對列表進行切片操作的例子：

# 定義一個列表
fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# 獲取從索引1到3的元素（不包括索引3）
slice_of_fruits = fruits[1:3]
print("切片后的列表:", slice_of_fruits)  # 輸出: ['banana', 'cherry']

切片后的列表: ['banana', 'cherry']

2.3.4.3列表拼接

列表可以通過加法運算符 + 來拼接在一起，形成一個新的列表：

# 定義兩個列表
list_one = ['a', 'b', 'c']
list_two = ['d', 'e', 'f']

# 拼接列表
concatenated_list = list_one + list_two
print("拼接后的列表:", concatenated_list)  # 輸出: ['a', 'b', 'c', 'd', 'e', 'f']

拼接后的列表: ['a', 'b', 'c', 'd', 'e', 'f']

2.3.4.4綜合示例：嵌套列表的截取與拼接

假設(shè)我們有一個更復(fù)雜的嵌套列表，并希望對其進行一些操作：

# 創(chuàng)建一個更復(fù)雜的嵌套列表
complex_nested_list = [['red', 'blue'], ['green', 'yellow'], ['black', 'white']]

# 截取并打印第二個子列表
second_sublist = complex_nested_list[1]
print("第二個子列表:", second_sublist)  # 輸出: ['green', 'yellow']

# 對第二個子列表進行切片操作
slice_second_sublist = second_sublist[0:1]  # 取出'green'
print("第二個子列表的切片:", slice_second_sublist)  # 輸出: ['green']

# 拼接兩個子列表
concatenated_sublists = complex_nested_list[0] + complex_nested_list[2]
print("拼接后的子列表:", concatenated_sublists)  # 輸出: ['red', 'blue', 'black', 'white']

第二個子列表: ['green', 'yellow']
第二個子列表的切片: ['green']
拼接后的子列表: ['red', 'blue', 'black', 'white']

2.3.5列表函數(shù)&方法

2.3.6 列題

2.3.6.1題目1：創(chuàng)建和訪問列表

描述: 創(chuàng)建一個名為 colors 的列表，包含以下顏色名稱："red", "blue", "green", "yellow"。然后打印出該列表的第二個元素。

題解:

colors = ["red", "blue", "green", "yellow"]
print(colors[1])  # 注意索引從0開始，所以[1]是第二個元素

答案:

blue

---

2.3.6.2題目2：列表切片與拼接

描述: 給定兩個列表 list1 = ['a', 'b', 'c'] 和 list2 = ['d', 'e', 'f']。請完成以下任務(wù)：

1. 從 list1 中截取從第一個元素到第三個元素（不包括第三個）。
2. 將 list1 和 list2 拼接成一個新的列表，并打印出來。

題解:

list1 = ['a', 'b', 'c']
list2 = ['d', 'e', 'f']

# 截取部分
slice_of_list1 = list1[0:2]  # 取出'a', 'b'
print("截取后的列表:", slice_of_list1)

# 拼接列表
concatenated_list = list1 + list2
print("拼接后的列表:", concatenated_list)

答案:

截取后的列表: ['a', 'b']
拼接后的列表: ['a', 'b', 'c', 'd', 'e', 'f']

---

2.3.6.3題目3：嵌套列表與訪問特定元素

描述: 創(chuàng)建一個嵌套列表 nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]。請執(zhí)行以下操作：

1. 打印整個嵌套列表。
2. 訪問并打印第二個子列表中的第一個元素。

題解:

nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]

# 打印整個嵌套列表
print("嵌套列表:", nested_list)

# 訪問并打印第二個子列表的第一個元素
second_sublist_first_element = nested_list[1][0]
print("第二個子列表的第一個元素:", second_sublist_first_element)

答案:

嵌套列表: [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]
第二個子列表的第一個元素: carrot

2.4 元組

元組（Tuple）它與列表非常相似，但有一個重要的區(qū)別：元組是不可變的（immutable），這意味著一旦創(chuàng)建后，就不能修改其內(nèi)容。以下是一些關(guān)于元組的基礎(chǔ)知識：

2.4.1創(chuàng)建元組

元組可以用圓括號 () 來創(chuàng)建，元素之間用逗號分隔。

# 創(chuàng)建一個簡單的元組
simple_tuple = (1, 2, 3)

# 元組也可以不使用括號來定義
another_tuple = 4, 5, 6

# 包含不同類型元素的元組
mixed_tuple = ('apple', 10, True)

注意：即使只有一個元素，也需要在元素后面加上逗號，以表明這是一個元組而不是單個值。

single_element_tuple = ('only',)

2.4.2訪問元組中的元素

可以通過索引來訪問元組中的元素，索引從0開始。

my_tuple = ('a', 'b', 'c', 'd')
print(my_tuple[0])  # 輸出: a
print(my_tuple[2])  # 輸出: c

你也可以使用負(fù)數(shù)索引來從末尾訪問元素。

print(my_tuple[-1])  # 輸出: d

2.4.3元組切片

可以像列表一樣對元組進行切片操作，獲取子集。

my_tuple = ('a', 'b', 'c', 'd', 'e')
sub_tuple = my_tuple[1:4]  # 結(jié)果: ('b', 'c', 'd')
print(sub_tuple)

2.4.4遍歷元組

可以使用for循環(huán)遍歷元組中的所有元素。

my_tuple = ('apple', 'banana', 'cherry')
for item in my_tuple:
    print(item)

apple
banana
cherry

2.4.5不可變性

由于元組是不可變的，不能對其進行修改、添加或刪除操作。

my_tuple = (1, 2, 3)
# 下面的操作會拋出TypeError
# my_tuple[0] = 4  # 錯誤
# del my_tuple[1]  # 錯誤

但是，如果你的元組包含的是可變對象（如列表），這些可變對象本身是可以修改的。

tuple_with_list = ([1, 2], [3, 4])
tuple_with_list[0].append(3)  # 這是允許的
print(tuple_with_list)  # 輸出: ([1, 2, 3], [3, 4])

([1, 2, 3], [3, 4])

2.4.6元組方法

元組支持的方法較少，因為它們是不可變的。常見的方法包括：

• count(x)：返回元組中出現(xiàn)x的次數(shù)。
• index(x)：返回元組中第一次出現(xiàn)x的索引位置。

my_tuple = (1, 2, 3, 2, 4)
print(my_tuple.count(2))  # 輸出: 2
print(my_tuple.index(3))  # 輸出: 2

2
2

2.4.7元組的應(yīng)用場景

由于其不可變性，元組適用于那些不需要更改的數(shù)據(jù)集合。例如，用于存儲固定的信息，如日期、坐標(biāo)等，或者作為字典的鍵（因為字典的鍵必須是不可變類型）。

2.5 字典

2.5.1字典（Dictionary）詳細(xì)基礎(chǔ)知識

字典是Python中的一種內(nèi)置數(shù)據(jù)結(jié)構(gòu)，它允許你存儲鍵值對（key-value pairs）。每個鍵都是唯一的，并且通過鍵可以快速訪問對應(yīng)的值。字典是可變的，支持動態(tài)添加、修改和刪除元素。

2.5.2.創(chuàng)建字典

字典可以通過花括號 {} 來創(chuàng)建，鍵和值之間用冒號 : 分隔，鍵值對之間用逗號 , 分隔。也可以使用 dict() 構(gòu)造函數(shù)來創(chuàng)建字典。

# 使用花括號創(chuàng)建字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用dict()構(gòu)造函數(shù)創(chuàng)建字典
person = dict(name='Alice', age=25, city='New York')

# 創(chuàng)建空字典
empty_dict = {}

2.5.3.訪問字典中的值

通過鍵可以直接訪問字典中的值。如果試圖訪問不存在的鍵，會拋出 KeyError 異常。為了避免這種情況，可以使用 get() 方法，它會在鍵不存在時返回 None 或者指定的默認(rèn)值。

print(person['name'])  # 輸出: Alice

# 使用get()方法避免KeyError
print(person.get('country'))  # 輸出: None
print(person.get('country', 'Unknown'))  # 輸出: Unknown

2.5.4修改字典

字典是可變的，這意味著你可以隨時向字典中添加新的鍵值對，或者修改已有的鍵對應(yīng)的值。

# 添加新的鍵值對
person['email'] = 'alice@example.com'
print(person)  # 輸出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

# 修改已有的鍵對應(yīng)的值
person['age'] = 26
print(person)  # 輸出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

2.5.6.刪除鍵值對

可以使用 del 關(guān)鍵字刪除字典中的鍵值對，或者使用 pop() 方法刪除并返回該鍵對應(yīng)的值。

# 使用del關(guān)鍵字刪除鍵值對
del person['city']
print(person)  # 輸出: {'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}

# 使用pop()方法刪除并返回鍵對應(yīng)的值
age = person.pop('age')
print(person)  # 輸出: {'name': 'Alice', 'email': 'alice@example.com'}
print(age)  # 輸出: 26

2.5.7遍歷字典

可以遍歷字典的所有鍵、所有值或所有鍵值對。

# 遍歷所有鍵
for key in person:
    print(key)

# 遍歷所有值
for value in person.values():
    print(value)

# 遍歷所有鍵值對
for key, value in person.items():
    print(f"{key}: {value}")

2.5.8字典方法

字典提供了許多有用的方法：

• keys()：返回字典中所有的鍵。

  for key in person.keys():
      print(key)
  

• values()：返回字典中所有的值。

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

• items()：返回字典中所有的鍵值對（作為元組的形式）。

  for key, value in person.items():
      print(f"{key}: {value}")
  

• update()：將另一個字典的鍵值對更新到當(dāng)前字典中。

  new_info = {'age': 27, 'gender': 'female'}
  person.update(new_info)
  print(person)  # 輸出: {'name': 'Alice', 'email': 'alice@example.com', 'age': 27, 'gender': 'female'}
  

• clear()：清空字典中的所有元素。

  person.clear()
  print(person)  # 輸出: {}
  

• copy()：創(chuàng)建字典的一個淺拷貝。

  person_copy = person.copy()
  

• setdefault()：獲取指定鍵的值；如果鍵不存在，則插入指定的鍵值對并返回其值。

  age = person.setdefault('age', 30)
  print(age)  # 如果'age'鍵存在則返回其值，否則設(shè)置為30并返回30
  

這些詳細(xì)的說明涵蓋了如何創(chuàng)建、訪問、修改、刪除和遍歷字典，以及一些常用的方法。字典因其高效性和靈活性，在處理復(fù)雜數(shù)據(jù)結(jié)構(gòu)時非常有用。掌握字典的基本操作對于編寫高效的Python代碼至關(guān)重要。

部分?jǐn)?shù)據(jù)來源于菜鳥教程、python從入門到實踐