【Python 數據結構 1.零基礎復習】

目錄

一、輸入與輸出

1.輸入

2.格式化輸出

二、數字與變量

1.字符串 & 整型

2.字符串 & 整型 & 浮點型

3.變量

練習?2235. 兩整數相加?

三、運算與操作

1.四則運算

練習?2769. 找出最大的可達成數字

3.取整與取余

練習?2651. 計算列車到站時間

?編輯

四、真與假

1.布爾數

2.比較運算

Ⅰ、字符串的比較?

Ⅱ、浮點數和整數比較

3.邏輯運算

練習?2396. 嚴格回文的數字

思路與算法

練習?2236. 判斷根結點是否等于子結點之和

?編輯

五、簡單判斷

1.判斷語句

2.判斷條件

3.空值與非空

4.代碼塊

練習?2651. 計算列車到站時間

六、復雜判斷

1.if-else 雙向判斷

2.elif 多向判斷

elif 多向判斷

練習?2413. 最小偶倍數

七、列表

1.列表的定義

2.列表的基本特性

3.創建列表

Ⅰ、使用方括號創建列表

Ⅱ、使用?list()?構造函數創建列表

4.訪問列表元素

Ⅰ、使用索引訪問

Ⅱ、切片操作

5.修改列表

Ⅰ、添加元素

Ⅱ、修改元素

Ⅲ、刪除元素

6.列表的其他方法

Ⅰ、查找元素

Ⅱ、排序

Ⅲ、反轉

Ⅳ、列表推導式

Ⅴ、嵌套列表

7.列表與元組的區別

練習?LCR 182. 動態口令

練習?1929. 數組串聯

八、for循環

1.了解for循環

2.代碼執行順序

3.遍歷

練習?LCP 06. 拿硬幣

4.range整數列表

5.累加

6.計數器

7.循環中 if 判斷的應用

練習?2798. 滿足目標工作時長的員工數目

練習?LCP 01. 猜數字

練習?778. 特殊元素平方和

九、while循環

1.while循環

2.for和while循環的區別

3.死循環

練習?1295. 統計位數為偶數的數字

4.循環中斷 break

5.循環中斷 continue

練習?1470. 重新排列數組

?編輯

練習?1920. 基于排列構建數組

練習?2824. 統計和小于目標的下標對數目

練習 1365. 有多少小于當前數字的數字

?編輯

練習?2176. 統計數組中相等且可以被整除的數對

十、元組

1.元組的定義

元組的創建方法

2.元組的基礎特性

3.元組的運算

元組的解包

成員檢查

4.元組的刪除

十一、字典

1.字典的定義

字典的創建方法

2.查找字典元素

3.增加字典元素

4.刪除字典元素

5.常用方法

練習?2351. 第一個出現兩次的字母

練習?1512. 好數對的數目

解法 ①?

解法 ②

6.字典的高級應用場景

7.數據結構小結

列表、元組、字典的常見報錯

十二、函數使用

1.函數的定義

2.函數的調用

練習.1732. 找到最高海拔

3.函數名

4.函數參數

5.函數返回值

6.函數必選參數

7.函數默認參數

8.函數不定長參數

9.函數執行順序

10.Python中的一些內置函數

十三、類

1.類的定義

2.類的屬性

3.類的方法

十四、類和對象

1.對象

2.實例化

3.面向對象編程

十五、類和函數共性

1.封裝

2.變量作用域

3.跳轉

新的一年，一定會有新的奇跡發生

????????????????????????????????????????????????????????—— 25.2.28

一文速通復習 & 回顧? & 精煉 Python基礎語法

一、輸入與輸出

輸入：我們在計算機上輸入一些字符，用繪圖板給計算機繪制一些圖形，這些計算機收到的來自“外界”的數據傳遞，叫做輸入

輸出：我們通過編程讓計算機在屏幕上顯示一張圖，一行字，這些計算機對“外界”的數據傳遞，都叫做輸出

1.輸入

print()：中英文敏感，引號和括號都應用英文符

代碼：程序員用某種編程語言寫出來的文本，可以被計算機一行行執行

print("Hello World!")

2.格式化輸出

在編程中，格式化輸出是指按指定的格式輸出數據

包括控制輸出的格式精度、小數位數，以便更好的展示和處理數據

格式化輸出通常使用占位符和格式說明符來指定輸出的內容和格式

Python中輸出模板信息的方法，叫做格式化輸出，可以實現靈活輸出字符串，并能修改其中的變量

格式化輸出讓我們可以靈活的進行字符串的打印

print(f"歡迎{name}參加我的生日會")

二、數字與變量

在編程中整數和浮點數是兩種基礎的數據類型

整數如 5、-3、(是沒有小數部分的數字）

浮點數如 3.14、-0.99是有包含小數部分的數字

編程中表示數字的是整形(int)和浮點型(float)

整型(integer)：整數

浮點型(floating-point)：小數

1.字符串 & 整型

編程中用來表示整數的型狀叫做整型，包括正數、負數、零

和字符串不同，整型是不需要用引號的

可以簡單的理解為，整型就是編程世界里的整數

2.字符串 & 整型 & 浮點型

編程中用來表示小數的類型叫做浮點型。

它和整型的相似點在于，都不需要用引號(只有字符串才需要)。

不同點是，浮點型有一個小數點。

同樣的，我們也可以簡單的記住，浮點型就是編程世界里的小數

3.變量

在 Python 中，變量是用來存儲信息的實體數字、字符串或更復雜的數據結構變量有有己的名稱

我們可以通過這個名稱訪問儲存在變量里的信息也可以改變其存儲的信息值

變量可以用來存儲各式各樣的數據，存儲的數據是可以變化的，所以叫做變量

我們可以把變量想象一個盒子，它里面可以裝各式各樣的數據。因為這個“盒子”里存儲的數據是“可以變化的”，所以我們叫他變量。

變量的名字有自己的命名規則，它可以由字母、數字、下劃線(_)組成，但是，它不能以數字開頭。?

python中的變量命名有一些風格，我們鼓勵google的變量命名風格，即所有變量只使用小寫字母和下劃線，單詞和單詞之間用下劃線連接。?

練習?2235. 兩整數相加?

給你兩個整數?num1?和?num2，返回這兩個整數的和。

示例 1：
輸入：num1 = 12, num2 = 5
輸出：17
解釋：num1 是 12，num2 是 5 ，它們的和是 12 + 5 = 17 ，因此返回 17 。
示例 2：
輸入：num1 = -10, num2 = 4
輸出：-6
解釋：num1 + num2 = -6 ，因此返回 -6 。
提示：

-100 <= num1, num2 <= 100

class Solution:def sum(self, num1: int, num2: int) -> int:return num1 + num2

三、運算與操作

1.四則運算

在編程中四則運算包括加、減、乘、除，這些操作可以對整數、浮點數等數據類型進行計算，用于構建復雜的算法和函數

加（+）、減（-）、乘（*）、除（/）?

字符串操作?

字符串之間可以通過?+ 號進行拼接，形成新的字符串

需要注意的是，不能把數字（整型/浮點型）與字符串之間使用加號+拼接，這會導致程序報錯

無論是用整型還是浮點型進行處除法/運算，計算結果一定是一個浮點型

對于四則運算來說，我們可以記住參與計算的有浮點型的話，結果一定是浮點型;參與計算是整型的話，結果一定是整型(除法例外)

練習?2769. 找出最大的可達成數字

給你兩個整數?num?和?t?。如果整數?x?可以在執行下述操作?不超過?t?次的情況下變為與?num?相等，則稱其為?可達成數字?：

每次操作將?x?的值增加或減少?1?，同時可以選擇將?num?的值增加或減少?1?。

返回所有可達成數字中的?最大?值?x。

示例 1：

輸入：num = 4, t = 1

輸出：6

解釋：

執行下述操作可以使最大可達成數字等于?num?：

最大可達成數字減少 1 ，同時?num?增加 1 。

示例 2：

輸入：num = 3, t = 2

輸出：7

解釋：

執行兩次下述操作可以使最大可達成數字等于 num ：

最大可達成數字減少 1 ，同時?num?增加 1。

class Solution:def theMaximumAchievableX(self, num: int, t: int) -> int:return num + 2 * t

3.取整與取余

在編程中，取整是指無論小數部分是多少都只保留整數部分

取余是當一個數除以另一個數后余下的部分

10除以3等于3余1所以取整結果是3，取余結果是1

除了傳統的四則運算，Python還可以進行求商和求余數的運算

取整運算符 //，它用來求商，10除以3，商是3，余數是1，計算結果就是3

取整數商的應用場景很多，例如在游戲開發中，取整操作可以用于處理游戲物體的位置和運動，確保游戲物體運動的更加平滑和自然

取模運算符 %，它用來求余數，10除以3，因為商是3，余數是1，計算結果就是1

取模運算符的效率會比減法運算符的效率偏低，我們要慎重使用

練習?2651. 計算列車到站時間

給你一個正整數?arrivalTime?表示列車正點到站的時間（單位：小時），另給你一個正整數?delayedTime?表示列車延誤的小時數。

返回列車實際到站的時間。

注意，該問題中的時間采用 24 小時制。

示例 1：
輸入：arrivalTime = 15, delayedTime = 5 
輸出：20 
解釋：列車正點到站時間是 15:00 ，延誤 5 小時，所以列車實際到站的時間是 15 + 5 = 20（20:00）。
示例 2：
輸入：arrivalTime = 13, delayedTime = 11
輸出：0
解釋：列車正點到站時間是 13:00 ，延誤 11 小時，所以列車實際到站的時間是 13 + 11 = 24（在 24 小時制中表示為 00:00 ，所以返回 0）。
提示：

1 <= arrivaltime <?24
1 <= delayedTime <= 24

class Solution:def findDelayedArrivalTime(self, arrivalTime: int, delayedTime: int) -> int:return (arrivalTime + delayedTime) % 24

四、真與假

1.布爾數

在編程中，布爾數是用于表示邏輯值的一種數據類型，它只有兩個值：真和假

布爾數常用于條件判斷，邏輯運算等操作

在編程中，我們用 True 和 False 來表達真和假這兩種狀態，首字母需要大寫，他們又叫布爾數

True 和 False 都是常量，所以我們可以把他們賦值給一個變量

2.比較運算

在編程中，比較運算是一種基本運算，用于比較兩個數值或字符串的大小關系，比較運算的結果，通常是一個布爾值用于判斷條件是否成立

比較運算：>、<、>=、<=、==、!=?

在編程中，我們會使用數學符號來進行比較運算，比如比較兩個數的大小

等于符號（==）和不等于符號（!=）

賦值符號是一個等號，作用是把一個數據裝入變量；

等于符號是兩個等號，作用是比較兩個數是否相等。

Ⅰ、字符串的比較?

字符串之間可以使用等于（==）和不等于（!=）來比較這兩個字符串是否一樣

Ⅱ、浮點數和整數比較

浮點數和整數也是可以進行比較的

3.邏輯運算

在編程中，邏輯運算指的是對邏輯關系進行運算和處理的操作

它用于判斷條件是否滿足，確定程序執行路徑等

常見的邏輯運算符包括與(and)、或(or)、非(not)它們用于組合和比較條件以實現程序的邏輯控制

and又叫“與運算”，假設你是一個28歲的女生，那么“你28歲”并且“你是女生”，這句話表述就是真的，但是“你28歲”并且“你是男生”，這句表述就是假的

and運算需要參與運算的兩個條件都為真，結果才是真；有一個為假，結果就是假。

or又叫“或運算”，假設你是一個28歲的女生，那么“你28歲”或者“你是男生”，雖然前一句是真，后一句是假，但這個表述也為真。這時候只有“你不是28歲”或者“你是男生”這句表述是假的。因為前一句和后一句都是假的。

or運算只要參與運算的其中一個條件為真，就為真。除非兩個條件都為假，才是假。?

not運算又叫“否運算”，假設你28歲，那么“你不是28歲”就是個假的表述，“你不是10歲”就是個真的表述。

not運算里面，not真為假，not假為真

練習?2396. 嚴格回文的數字

如果一個整數?n?在?b?進制下（b?為?2?到?n - 2?之間的所有整數）對應的字符串?全部?都是?回文的?，那么我們稱這個數?n?是?嚴格回文?的。

給你一個整數?n?，如果?n?是?嚴格回文?的，請返回?true?，否則返回?false?。

如果一個字符串從前往后讀和從后往前讀完全相同，那么這個字符串是?回文的?。

示例 1：
輸入：n = 9
輸出：false
解釋：在 2 進制下：9 = 1001 ，是回文的。
在 3 進制下：9 = 100 ，不是回文的。
所以，9 不是嚴格回文數字，我們返回 false 。
注意在 4, 5, 6 和 7 進制下，n = 9 都不是回文的。
示例 2：
輸入：n = 4
輸出：false
解釋：我們只考慮 2 進制：4 = 100 ，不是回文的。
所以我們返回 false 。
提示：

4 <= n <= 105

思路與算法

在題目的條件下，答案一定為 false，證明如下：

根據帶余除法，n=qb+r，其中 0≤r<b。

取 b=n?2，那么當 n>4 時，上式的 q=1，r=2，也就是說 n 在 n?2 進制下的數值為 12，不是回文數。

而對于 n=4，在 b=2 進制下的數值為 100，也不是回文數。

因此直接返回 false 即可。

class Solution:def isStrictlyPalindromic(self, n: int) -> bool:return False

練習?2236. 判斷根結點是否等于子結點之和

給你一個?二叉樹?的根結點?root，該二叉樹由恰好?3?個結點組成：根結點、左子結點和右子結點。

如果根結點值等于兩個子結點值之和，返回?true?，否則返回?false?。

示例 1：
輸入：root = [10,4,6]
輸出：true
解釋：根結點、左子結點和右子結點的值分別是 10 、4 和 6 。
由于 10 等于 4 + 6 ，因此返回 true 。
示例 2：
輸入：root = [5,3,1]
輸出：false
解釋：根結點、左子結點和右子結點的值分別是 5 、3 和 1 。
由于 5 不等于 3 + 1 ，因此返回 false 。
提示：

樹只包含根結點、左子結點和右子結點
-100 <= Node.val <= 100

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def checkTree(self, root: Optional[TreeNode]) -> bool:return root.val == root.left.val + root.right.val

五、簡單判斷

在編程中，if 語句是一種用于根據條件執行不同代碼塊?的控制結構，它根據特定條件的真假來分支程序的執行路徑。通過使用 if 語句，程序可以根據不同的情況執行不同的操作，從而實現邏輯判斷和條件處理

布爾數用在什么地方呢？它可以用在代碼中判斷語句的判斷條件，幫助我們進行判斷，進而決定執行那些代碼

1.判斷語句

這種在代碼中根據不同的條件，執行不同代碼的結構，我們叫它“判斷語句”

如果判斷條件為真（True），我們就讓程序執行某行代碼；如果判斷條件為假（False），就讓程序不執行某行代碼。

一個if判斷是由關鍵字if，判斷條件，冒號：和?“所屬”代碼構成的

需要注意的是，關鍵字 if 和判斷條件之間有個空格

if 是python中的關鍵字，是“如果”的意思，表明后面的條件如果成立，就會執行一些代碼。

if 后面是一個判斷條件。 if?語句僅在結果為真(True )時執行歸屬于if的代碼。嘗試在輸入
框填入 True，如果判斷條件的結果為假(False )，歸屬于if的代碼就不獪被執行，而會直接跳過

?英文冒號 : 是 if 判斷語句的固定格式，表示該句代碼的結束

在判斷的歸屬代碼前需要有四個空格，這四個空格的作用是用來告訴計算機：這些代碼歸屬于這個if判斷語句

2.判斷條件

在編程中，if 語句中的判斷條件決定了 if 語句是否執行，這個條件可以是布爾數、比較運算或者邏輯運算等等

if 后跟隨判斷條件，判斷條件本質上是看它是真(True) 還是假(False)，它既可以直接是個布爾數(比如前面提到的代碼案例)；也可以是一個比較運算或者邏輯運算，因為它們的運算結果也是一個True 或者 False

在 if 判斷中，我們知道了如果判斷條件是 True ，就會執行它“所屬”的代碼;如果判斷條件是False ，就不會執行。除了直接使用布爾數 True 和 False，我們還可以使用運算結果是布爾數的一些“條件”，比如比較運算 5?>3，它的運算結果是True，這時 if 判斷也會執行代碼。

除了比較運算，邏輯運算也能得到一個True/False的布爾數，因為邏輯運算也經常被用作判斷的條件。

需要注意的是，判斷條件涉及到的比較運算和邏輯運算，默認是從左到右計算的，除非有括號，括號里的需要最先計算(如圖中的①②③執行順序)

當然作為代碼風格的一部分，我們建議把每個單獨有實際意義的運算，都用括號括起來

3.空值與非空

在編程中，空值指沒有任何值或未賦值的狀態，非空則指變量已被賦予某些值，即該變量包含有效數據或信息

如果一個變量是有數據的，在Python中這個變量就等價于True?

關鍵字 None 代表空值，就是什么都沒有。作為判斷條件，空值等價于False，所以if判斷語句內的
代碼不會執行。

除了空值None以外，其他只要有數據的值，都是非空值，比如所有的常量數值，包括整型，浮點型，字符

我們可以簡單的理解為，當判斷條件是一個變量或者常量的時候，如果它是一個有具體數據的非空值，那么它等價于 True ;如果它是一個沒有具體數據的空值的時候，那么它等價于 False

4.代碼塊

代碼塊，是編程中一組按邏輯組織的語句，它可以組合控制結構如循環和條件語句進行具體的操作Python里的縮進（Indentation）是四個空格，同樣縮進四個空格的代碼塊，屬于同一個層級

同樣縮進的代碼屬于同一層級，下一級縮進的代碼“從屬于”上一級，比如第二行代碼就“從屬于”第一行的條件判斷

if 判斷后的判斷條件為True，則程序執行歸屬于if 判斷的一個代碼塊。縮進就是為了組織代碼塊(Code Block)，區分代碼的層級

同一層級（即同樣縮進四個空格）的代碼集合叫做代碼塊（Code Block），代碼塊中的代碼會按照由上至下的順序執行

練習?2651. 計算列車到站時間

給你一個正整數?arrivalTime?表示列車正點到站的時間（單位：小時），另給你一個正整數?delayedTime?表示列車延誤的小時數。

返回列車實際到站的時間。

注意，該問題中的時間采用 24 小時制。

示例 1：
輸入：arrivalTime = 15, delayedTime = 5 
輸出：20 
解釋：列車正點到站時間是 15:00 ，延誤 5 小時，所以列車實際到站的時間是 15 + 5 = 20（20:00）。
示例 2：
輸入：arrivalTime = 13, delayedTime = 11
輸出：0
解釋：列車正點到站時間是 13:00 ，延誤 11 小時，所以列車實際到站的時間是 13 + 11 = 24（在 24 小時制中表示為 00:00 ，所以返回 0）。
提示：

1 <= arrivaltime <?24
1 <= delayedTime <= 24

class Solution:def findDelayedArrivalTime(self, arrivalTime: int, delayedTime: int) -> int:if arrivalTime + delayedTime >= 24:return arrivalTime + delayedTime -24else:      return arrivalTime + delayedTime

六、復雜判斷

1.if-else 雙向判斷

在編程中，if-else 是一種基本的控制結構

用于根據條件的真假，執行不同的代碼塊，if 后的條件為真時，執行特定操作；否則執行 else 后的操作

兩段代碼表達了一樣的意思，但第二種寫法更加簡潔，它只需要一個關鍵字 else 就可以了

if-else 判斷結構由關鍵字 else和英文冒號 :?構成?

else 是和 if 配對的關鍵詞，else 無法單獨出現，它的前面一定有一個跟它配對的 if

if 的條件成立的話，if 內部的代碼塊會被執行，而 else 的作用就是，如果 if 的條件不成立，那么else 內部的代碼塊就會被執行，它們之間的關系就類似于漢語中的“如果-否則”

為什么 else 不需要像 if 一樣后面跟一個判斷條件呢？這是因為 else 囊括了所有 if 條件以外的條件：只要 if 判斷的條件不成立，就會進入 else 的范疇。

else 只會跟最近的一個 if 進行配對，所以我們可以看到這段代碼輸出了兩句話：“周四吃肯德雞” 和 “周四隨便吃吃”。因為第一個 if 判斷是成立的，所以輸出了第一句話：第二個 if 判斷是不成立的，所以這里進入了 else 的代碼分支，又輸出了第二句話

2.elif 多向判斷

在編程中，elif 是 else if 的簡寫，用于在 if 語句之后，添加額外的條件判斷

如果 if 語句的條件為假，那么程序將檢查 elif?語句的條件

這種有三個或者更多的判斷條件的情況，代碼中也有對應的處理機制，那就是 elif 關鍵字，這個關鍵字是 else if 的縮寫。我們可以看到，使用 elif 以后，判斷條件變得更簡潔了。?

使用三個 if 的時候，我們需要對三個 if 判斷的條件都做清晰的界定;但是使用 if-elif-else 判斷結構的時候，我們只需要對前兩個的判斷條件做清晰的界定，除此以外的所有情況，都在else里面執行。

elif 多向判斷

在 if-elif-else 的判斷中，elif 后面也有判斷條件和固定語法格式：

if score >= 90:print("成績等級：A")
elif score >= 80:print("成績等級：B")
elif score >= 70:print("成績等級：C")
elif score >= 60:print("成績等級：D")
else:print("成績等級：F")

elif 語句由三部分構成，關鍵字 elif，具體的判斷條件，英文冒號?:

if、elif 、else 三者是獨立互斥的關系，就是說，程序只會執行其中一個分支的代碼塊。要么執行 if 的代碼塊，要么執行 elif 的代碼塊，如果前兩個條件都不符合，就執行else的代碼塊。

當判斷的條件超過3個時，中間的多個條件都可以使用 elif?

練習?2413. 最小偶倍數

給你一個正整數?n?，返回?2?和?n?的最小公倍數（正整數）。

示例 1：
輸入：n = 5
輸出：10
解釋：5 和 2 的最小公倍數是 10 。
示例 2：
輸入：n = 6
輸出：6
解釋：6 和 2 的最小公倍數是 6 。注意數字會是它自身的倍數。
提示：

1 <= n <= 150

class Solution:def smallestEvenMultiple(self, n: int) -> int:return n if n % 2 == 0 else n * 2

七、列表

1.列表的定義

Python 列表（List）是一種有序、可變且允許重復元素的數據結構。列表使用方括號?[]?表示，元素之間用逗號?,?分隔。列表是 Python 中最常用的數據結構之一，適用于存儲和管理一系列項目。

變量就像一個盒子，可以裝各種東西，但一次只能裝1種；

而列表就像收納盒，可以有序地在每一個盒子中，裝上不同的東西。

列表中的元素，可以是數字、字符串、字符串和數字混合，甚至嵌套列表(列表中有列表)。

2.列表的基本特性

有序：列表中的元素按照插入順序排列，可以通過索引（索引是在數據結構中用來定位和尋找數據的檢索方式）訪問。在存儲的過程中，每一項元素都有固定的位置，方便查找和修改列表中的元素

?可變：可以在創建后添加、刪除或修改列表中的元素。

?允許重復：列表中可以包含重復的元素。

?異構：列表中的元素可以是不同類型的，如整數、字符串、浮點數、其他列表等。

3.創建列表

Ⅰ、使用方括號創建列表

# 創建一個空列表
empty_list = []# 創建一個包含多個元素的列表
fruits = ['apple', 'banana', 'cherry']# 創建一個包含不同類型元素的列表
mixed_list = [1, 'apple', 3.14, True]

Ⅱ、使用?`list()`?構造函數創建列表

# 從字符串創建列表
char_list = list('hello')
print(char_list)  # 輸出: ['h', 'e', 'l', 'l', 'o']# 從元組創建列表
tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)
print(list_from_tuple)  # 輸出: [1, 2, 3]

4.訪問列表元素

Ⅰ、使用索引訪問

索引是在數據結構中用來定位和尋找數據的檢索方式

正索引：從左到右，索引從?0?開始。

?負索引：從右到左，索引從?-1?開始。

Ⅱ、切片操作

列表切片是從原始列表中提取列表的一部分的過程

左閉右開的區間，取左不取右，元素數 = 冒號右邊數字 - 冒號左邊數字

開始位置數字不填，默認從第一個元素開始切片

結束位置數字不填，默認取到最后一個元素

開始和結束位置數字都不填，[:] 默認取出所有元素

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']# 獲取前三個元素
first_three = fruits[:3]
print(first_three)  # 輸出: ['apple', 'banana', 'cherry']# 獲取第三個到第五個元素
middle = fruits[2:5]
print(middle)  # 輸出: ['cherry', 'date', 'elderberry']# 獲取從第三個元素開始到末尾
from_third = fruits[2:]
print(from_third)  # 輸出: ['cherry', 'date', 'elderberry']

5.修改列表

Ⅰ、添加元素

append()：在列表末尾添加一個元素。

extend()：在列表末尾添加多個元素（通常是一個可迭代對象）。

insert()：在指定位置插入一個元素。插入元素可以理解為：你想把這個新元素放到第幾位，括號中就要填上對應的索引位置，后面的元素都會給新來的元素讓位，插入的元素可以是不同數據類型，包括：字符串、整型、浮點型、元組以及列表等

fruits = ['apple', 'banana']# 添加一個元素
fruits.append('cherry')
print(fruits)  # 輸出: ['apple', 'banana', 'cherry']# 添加多個元素
fruits.extend(['date', 'elderberry'])
print(fruits)  # 輸出: ['apple', 'banana', 'cherry', 'date', 'elderberry']# 在指定位置插入元素
fruits.insert(1, 'blueberry')
print(fruits)  # 輸出: ['apple', 'blueberry', 'banana', 'cherry', 'date', 'elderberry']

Ⅱ、修改元素

通過索引值直接修改元素

fruits = ['apple', 'blueberry', 'banana', 'cherry']# 修改第二個元素
fruits[1] = 'blackberry'
print(fruits)  # 輸出: ['apple', 'blackberry', 'banana', 'cherry']

Ⅲ、刪除元素

del：刪除指定索引的元素。

remove()：刪除第一個匹配的元素。

pop()：刪除并返回指定索引的元素，默認刪除最后一個元素。

fruits = ['apple', 'blackberry', 'banana', 'cherry']# 刪除第二個元素
del fruits[1]
print(fruits)  # 輸出: ['apple', 'banana', 'cherry']# 刪除第一個 'banana'
fruits.remove('banana')
print(fruits)  # 輸出: ['apple', 'cherry']# 刪除并返回最后一個元素
last_fruit = fruits.pop()
print(last_fruit)  # 輸出: cherry
print(fruits)      # 輸出: ['apple']

6.列表的其他方法

Ⅰ、查找元素

index()：返回第一個匹配元素的索引。

count()：返回元素在列表中出現的次數。

fruits = ['apple', 'banana', 'cherry', 'banana']# 查找 'banana' 的索引
index = fruits.index('banana')
print(index)  # 輸出: 1# 統計 'banana' 出現的次數
count = fruits.count('banana')
print(count)  # 輸出: 2

Ⅱ、排序

sort()：對列表進行原地排序。

sorted()：返回一個新的排序后的列表，原列表不變。

fruits = ['banana', 'apple', 'cherry']# 原地排序
fruits.sort()
print(fruits)  # 輸出: ['apple', 'banana', 'cherry']# 返回一個新的排序后的列表
sorted_fruits = sorted(fruits)
print(sorted_fruits)  # 輸出: ['apple', 'banana', 'cherry']
print(fruits)         # 輸出: ['apple', 'banana', 'cherry']

Ⅲ、反轉

reverse()：原地反轉列表。

reversed()：返回一個迭代器。

fruits = ['apple', 'banana', 'cherry']# 原地反轉
fruits.reverse()
print(fruits)  # 輸出: ['cherry', 'banana', 'apple']# 使用 reversed() 返回迭代器
for fruit in reversed(fruits):print(fruit)
# 輸出:
# apple
# banana
# cherry

Ⅳ、列表推導式

# 創建一個包含0到9的平方的列表
squares = [x**2 for x in range(10)]
print(squares)  # 輸出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]# 過濾出偶數的平方
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 輸出: [0, 4, 16, 36, 64]

Ⅴ、嵌套列表

列表中包含其他列表，形成嵌套結構

matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 訪問第二行第三列的元素
element = matrix[1][2]
print(element)  # 輸出: 6

7.列表與元組的區別

列表和元組都是序列類型

特性	列表 (List)	元組 (Tuple)
可變性	可變	不可變
語法	使用方括號?`[]`	使用圓括號?`()`
性能	由于可變性，操作較慢	由于不可變性，操作較快
適用場景	需要頻繁修改的數據集合	不需要修改的數據集合，如函數返回多個值

練習?LCR 182. 動態口令

某公司門禁密碼使用動態口令技術。初始密碼為字符串?password，密碼更新均遵循以下步驟：

設定一個正整數目標值?target
將?password?前?target?個字符按原順序移動至字符串末尾

請返回更新后的密碼字符串。

示例 1：
輸入: password = "s3cur1tyC0d3", target = 4
輸出: "r1tyC0d3s3cu"
示例 2：
輸入: password = "lrloseumgh", target = 6
輸出:?"umghlrlose"
提示：

1 <= target?< password.length <= 10000

class Solution:def dynamicPassword(self, password: str, target: int) -> str:return password[target:] + password[:target]

練習?1929. 數組串聯

給你一個長度為?n?的整數數組?nums?。請你構建一個長度為?2n?的答案數組?ans?，數組下標?從 0 開始計數?，對于所有?0 <= i < n?的?i?，滿足下述所有要求：

ans[i] == nums[i]
ans[i + n] == nums[i]

具體而言，ans?由兩個?nums?數組?串聯?形成。

返回數組?ans?。

示例 1：
輸入：nums = [1,2,1]
輸出：[1,2,1,1,2,1]
解釋：數組 ans 按下述方式形成：
- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
- ans = [1,2,1,1,2,1]
示例 2：
輸入：nums = [1,3,2,1]
輸出：[1,3,2,1,1,3,2,1]
解釋：數組 ans 按下述方式形成：
- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
- ans = [1,3,2,1,1,3,2,1]
提示：

n == nums.length
1 <= n <= 1000
1 <= nums[i] <= 1000

class Solution:def getConcatenation(self, nums: List[int]) -> List[int]:return nums + nums

class Solution:def getConcatenation(self, nums: List[int]) -> List[int]:nums.extend(nums)return nums

八、for循環

1.了解for循環

循環是一種控制流結構，兩種常見的循環是：for循環?和 while循環，用于處理定量和無限任務

自然界中，一直重復的四季更替，晝夜交替，陰晴圓缺叫做循環。在程序中，滿足條件的情況下，重復執行同一段代碼就叫做循環

2.代碼執行順序

代碼執行順序是一個很重要的概念，關系著你在排查錯誤的時候，按照什么樣的順序去查代碼常見的代碼執行順序有：順序、選擇、循環、跳轉

3.遍歷

遍歷指的是依次訪問某個數據結構中的每一個元素，通常使用 for 或者 while 進行遍歷

除了遍歷列表，for循環還可以遍歷字符串，并逐個獲取字符串的每個字符在輸入框中填入變量 word 查看輸出結果。

練習?LCP 06. 拿硬幣

桌上有?n?堆力扣幣，每堆的數量保存在數組?coins?中。我們每次可以選擇任意一堆，拿走其中的一枚或者兩枚，求拿完所有力扣幣的最少次數。

示例 1：

輸入：[4,2,1]

輸出：4

解釋：第一堆力扣幣最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，總共 4 次即可拿完。

示例 2：

輸入：[2,3,10]

輸出：8

限制：

1 <= n <= 4
1 <= coins[i] <= 10

class Solution:def minCount(self, coins: List[int]) -> int:n = 0for i in coins:if i % 2 == 0:n = n + i // 2else:n = n + i // 2 + 1return n

4.range整數列表

在 Python 中，range()用于生成一系列連續整數，它在循環和其他需要迭代的場景中特別有用

range()方法可以創建一個整數列表，一般用在 for 循環中。

聲明：Python的版本不同，range()生成的格式不同，在Python2中是列表，Python3中是可迭代對象，用法是類似的。

當range()函數只填寫1個參數時，range(a)表示生成的整數從0開始，到a結束且不包含a

當range()函數中填寫2個數時，例如range(a,b)，表示生成的整數從a開始，到b結束且不包含b

range()函數中填寫3個參數時，range(a,b,c)表示生成的整數從a開始，到b結束且不包含b，整數之間的間隔為c，如果不填寫，默認整數間隔為1

range(a, b, c)的三個參數，表示開始，結束和步長

開始：計數從a開始，默認是從0開始

結束：計數到b結束，但不包括b

步長：默認為1

5.累加

在編程中，累加指的是持續將某個值加到一個變量上，例如：在循環中你可能會設置一個累加器變量然后在每次選代時增加某個值

for循環可以實現數字的累加，累加的過程如下：

total = 0
for i in range(101):total = total + i
print(total)

6.計數器

在編程中，計數器常用于在循環中追蹤已經執行了多少次迭代，通常會初始化一個計數器變量，然后在每次循環時將其遞增

for循環中使用if語句時，要注意縮進。

第一個縮進，代表著for循環中的代碼需要增加縮進，表明是一個代碼塊。

第二個縮進，使用if語句時，語句里面的內容也需要增加縮進

7.循環中 if 判斷的應用

可以通過 for循環結合 if判斷，篩選需要的元素

練習?2798. 滿足目標工作時長的員工數目

公司里共有?n?名員工，按從?0?到?n - 1?編號。每個員工?i?已經在公司工作了?hours[i]?小時。

公司要求每位員工工作?至少?target?小時。

給你一個下標從?0?開始、長度為?n?的非負整數數組?hours?和一個非負整數?target?。

請你用整數表示并返回工作至少?target?小時的員工數。

示例 1：
輸入：hours = [0,1,2,3,4], target = 2
輸出：3
解釋：公司要求每位員工工作至少 2 小時。
- 員工 0 工作 0 小時，不滿足要求。
- 員工 1 工作 1 小時，不滿足要求。
- 員工 2 工作 2 小時，滿足要求。
- 員工 3 工作 3 小時，滿足要求。
- 員工 4 工作 4 小時，滿足要求。
共有 3 位滿足要求的員工。
示例 2：
輸入：hours = [5,1,4,2,2], target = 6
輸出：0
解釋：公司要求每位員工工作至少 6 小時。
共有 0 位滿足要求的員工。
提示：

1 <= n == hours.length <= 50
0 <=?hours[i], target <= 105

class Solution:def numberOfEmployeesWhoMetTarget(self, hours: List[int], target: int) -> int:n = 0for i in hours:if i >= target:n = n + 1return n

練習?LCP 01. 猜數字

小A 和小B 在玩猜數字。小B 每次從 1, 2, 3 中隨機選擇一個，小A 每次也從 1, 2, 3 中選擇一個猜。他們一共進行三次這個游戲，請返回小A 猜對了幾次？

輸入的guess數組為小A 每次的猜測，answer數組為小B 每次的選擇。guess和answer的長度都等于3。

示例 1：
輸入：guess = [1,2,3], answer = [1,2,3]
輸出：3
解釋：小A 每次都猜對了。
示例 2：
輸入：guess = [2,2,3], answer = [3,2,1]
輸出：1
解釋：小A 只猜對了第二次。
限制：

guess的長度 = 3
answer的長度 = 3
guess的元素取值為?{1, 2, 3}?之一。
answer的元素取值為?{1, 2, 3}?之一。

class Solution:def game(self, guess: List[int], answer: List[int]) -> int:sum = 0for i in range(3):if guess[i] == answer[i]:sum = sum + 1return sum

練習?778. 特殊元素平方和

給你一個下標從?1?開始、長度為?n?的整數數組?nums?。

對?nums?中的元素?nums[i]?而言，如果?n?能夠被?i?整除，即?n % i == 0?，則認為?num[i]?是一個?特殊元素?。

返回?nums?中所有?特殊元素?的?平方和?。

示例 1：

輸入：nums = [1,2,3,4]
輸出：21
解釋：nums 中共有 3 個特殊元素：nums[1]，因為 4 被 1 整除；nums[2]，因為 4 被 2 整除；以及 nums[4]，因為 4 被 4 整除。 
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21 。

示例 2：

輸入：nums = [2,7,1,19,18,3]
輸出：63
解釋：nums 中共有 4 個特殊元素：nums[1]，因為 6 被 1 整除；nums[2] ，因為 6 被 2 整除；nums[3]，因為 6 被 3 整除；以及 nums[6]，因為 6 被 6 整除。 
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63 。

提示：

1 <= nums.length == n <= 50
1 <= nums[i] <= 50

len()：len()函數通過調用對象的__len__()方法獲取長度，適用于序列（如字符串、列表、元組）和集合（如字典、集合）等可迭代對象

class Solution:def sumOfSquares(self, nums: List[int]) -> int:sum = 0n = len(nums)for i in range(n):if n % (i + 1) == 0:sum += nums[i] ** 2return sum

九、while循環

1.while循環

在Python中，while循環是一種控制流語句，它允許一段代碼特續執行，直到滿足特定條件后停止這使我們能夠有效地創建不定數量的選代

條件循環，又稱while循環，以判斷條件是否成立，來決定是否執行循環內的代碼。當判斷為True時，代碼會循環執行，當判斷為False時，則終止循環。

在while循環中，有一個判斷條件，來決定是否執行循環內的代碼。判斷為True，則繼續執行循環;判斷為False，就會終止循環；這樣的判斷條件，就是邊界條件。

2.for和while循環的區別

在大多數情況下，for循環和while循環可以互換使用

for循環在每一次循環的時候，是按照從頭到尾的順序自動遍歷，給變量 i 賦值列表中的元素

while循環則沒有構建列表而是通過在邊界條件內，依次給變量 i 值加1，并輸出實現。

也就是說，兩種循環的終止條件不一樣。for循環的終止條件是遍歷完整個列表；while循環的終止條件是邊界條件，也就是 i<3

3.死循環

循環雖然好用，但是不合理的邊界條件設計會讓計算機卡住，走不出循環

for 循環通常是對一個數據集合比如列表的遍歷。數據集合的大小是固定的，所以循環次數是固定的，循環可以有始有終。

但 while 循環是通過循環條件來控制的，如果循環條件不滿足，則會跳出循環；如果條件一直滿足，就會一直執行，甚至出現死循環。

在編程中，一個靠自身無法終止的程序稱為"死循環"，死循環是一種循環類型，當一個循環永遠無法終止的時候，我們就說它是一個死循環。就像是困在沒有出口的密室，只能一直在里面循環無法逃脫。

練習?1295. 統計位數為偶數的數字

給你一個整數數組?nums，請你返回其中位數為?偶數?的數字的個數。

示例 1：

輸入：nums = [12,345,2,6,7896]
輸出：2
解釋：
12 是 2 位數字（位數為偶數）?
345 是 3 位數字（位數為奇數）??
2 是 1 位數字（位數為奇數）?
6 是 1 位數字 位數為奇數）?
7896 是 4 位數字（位數為偶數）??
因此只有 12 和 7896 是位數為偶數的數字

示例 2：

輸入：nums = [555,901,482,1771]
輸出：1 
解釋： 
只有 1771 是位數為偶數的數字。

提示：

1 <= nums.length <= 500
1 <= nums[i] <= 105

class Solution:def findNumbers(self, nums: List[int]) -> int:sum = 0for i in nums:num = 0while i:num += 1i //= 10if num % 2 == 0:sum += 1return sum

4.循環中斷 break

在 Python 中，break語句是一種控制流工具，它用于終止當前的循環

break是結束循環，它的作用是讓當前的while或者for循環停止。

同樣的，while循環中也可以使用break來跳出循環，一般用法是在邊界條件之外再加一個循環終止的條件。

5.循環中斷 continue

在 Python 中，continue語句是一種控制流工具它用于跳過當前循環的剩余部分直接進入下一輪循環這使我們可以在滿足某些條件時忽略循環的其些步驟

continue是結束本次循環，繼續下一次循環，實際上循環還沒有停止；就像打游戲，有很多條命，掉了一條還可以繼續玩，只是需要從頭開始

練習?1470. 重新排列數組

給你一個數組?nums?，數組中有?2n?個元素，按?[x1,x2,...,xn,y1,y2,...,yn]?的格式排列。

請你將數組按?[x1,y1,x2,y2,...,xn,yn]?格式重新排列，返回重排后的數組。

示例 1：
輸入：nums = [2,5,1,3,4,7], n = 3
輸出：[2,3,5,4,1,7] 
解釋：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案為 [2,3,5,4,1,7]
示例 2：
輸入：nums = [1,2,3,4,4,3,2,1], n = 4
輸出：[1,4,2,3,3,2,4,1]
示例 3：
輸入：nums = [1,1,2,2], n = 2
輸出：[1,2,1,2]
提示：

1 <= n <= 500
nums.length == 2n
1 <= nums[i] <= 10^3

class Solution:def shuffle(self, nums: List[int], n: int) -> List[int]:list = []for i in range(n):list.append(nums[i])list.append(nums[n+i])return list

練習?1920. 基于排列構建數組

給你一個?從 0 開始的排列?nums（下標也從 0 開始）。請你構建一個?同樣長度?的數組?ans?，其中，對于每個?i（0 <= i < nums.length），都滿足?ans[i] = nums[nums[i]]?。返回構建好的數組?ans?。

從 0 開始的排列?nums?是一個由?0?到?nums.length - 1（0?和?nums.length - 1?也包含在內）的不同整數組成的數組。

示例 1：
輸入：nums = [0,2,1,5,3,4]
輸出：[0,1,2,4,5,3]
解釋：數組 ans 構建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]= [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]= [0,1,2,4,5,3]
示例 2：
輸入：nums = [5,0,1,2,3,4]
輸出：[4,5,0,1,2,3]
解釋：數組 ans 構建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]= [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]= [4,5,0,1,2,3]
提示：

1 <= nums.length <= 1000
0 <= nums[i] < nums.length
nums?中的元素?互不相同

class Solution:def buildArray(self, nums: List[int]) -> List[int]:n = len(nums)ans = []for i in range(n):ans.append(nums[nums[i]])return ans

練習?2824. 統計和小于目標的下標對數目

給你一個下標從?0?開始長度為?n?的整數數組?nums?和一個整數?target?，請你返回滿足?0 <= i < j < n?且?nums[i] + nums[j] < target?的下標對?(i, j)?的數目。

示例 1：

輸入：nums = [-1,1,2,3,1], target = 2
輸出：3
解釋：總共有 3 個下標對滿足題目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ，0 < 2 且 nums[0] + nums[2] = 1 < target 
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = 0 < target
注意 (0, 3) 不計入答案因為 nums[0] + nums[3] 不是嚴格小于 target 。

示例 2：

輸入：nums = [-6,2,5,-2,-7,-1,3], target = -2
輸出：10
解釋：總共有 10 個下標對滿足題目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = -4 < target
- (0, 3) ，0 < 3 且 nums[0] + nums[3] = -8 < target
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = -13 < target
- (0, 5) ，0 < 5 且 nums[0] + nums[5] = -7 < target
- (0, 6) ，0 < 6 且 nums[0] + nums[6] = -3 < target
- (1, 4) ，1 < 4 且 nums[1] + nums[4] = -5 < target
- (3, 4) ，3 < 4 且 nums[3] + nums[4] = -9 < target
- (3, 5) ，3 < 5 且 nums[3] + nums[5] = -3 < target
- (4, 5) ，4 < 5 且 nums[4] + nums[5] = -8 < target
- (4, 6) ，4 < 6 且 nums[4] + nums[6] = -4 < target

提示：

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

class Solution:def countPairs(self, nums: List[int], target: int) -> int:n = len(nums)sum = 0for i in range(n):for j in range(i+1, n):if nums[i] + nums[j] < target:sum += 1return sum

練習 1365. 有多少小于當前數字的數字

給你一個數組?nums，對于其中每個元素?nums[i]，請你統計數組中比它小的所有數字的數目。

換而言之，對于每個?nums[i]?你必須計算出有效的?j?的數量，其中?j?滿足?j != i?且?nums[j] < nums[i]?。

以數組形式返回答案。

示例 1：
輸入：nums = [8,1,2,2,3]
輸出：[4,0,1,1,3]
解釋： 
對于 nums[0]=8 存在四個比它小的數字：（1，2，2 和 3）。 
對于 nums[1]=1 不存在比它小的數字。
對于 nums[2]=2 存在一個比它小的數字：（1）。 
對于 nums[3]=2 存在一個比它小的數字：（1）。 
對于 nums[4]=3 存在三個比它小的數字：（1，2 和 2）。
示例 2：
輸入：nums = [6,5,4,8]
輸出：[2,1,0,3]
示例 3：
輸入：nums = [7,7,7,7]
輸出：[0,0,0,0]
提示：

2 <= nums.length <= 500
0 <= nums[i] <= 100

class Solution:def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:n = len(nums)ans = []for i in range(n):num = 0for j in range(n):if i != j and nums[j] < nums[i]:num += 1ans.append(num)return ans

練習?2176. 統計數組中相等且可以被整除的數對

給你一個下標從?0?開始長度為?n?的整數數組?nums?和一個整數?k?，請你返回滿足?0 <= i < j < n?，nums[i] == nums[j]?且?(i * j)?能被?k?整除的數對?(i, j)?的?數目?。

示例 1：
輸入：nums = [3,1,2,2,2,1,3], k = 2
輸出：4
解釋：
總共有 4 對數符合所有要求：
- nums[0] == nums[6] 且 0 * 6 == 0 ，能被 2 整除。
- nums[2] == nums[3] 且 2 * 3 == 6 ，能被 2 整除。
- nums[2] == nums[4] 且 2 * 4 == 8 ，能被 2 整除。
- nums[3] == nums[4] 且 3 * 4 == 12 ，能被 2 整除。
示例 2：
輸入：nums = [1,2,3,4], k = 1
輸出：0
解釋：由于數組中沒有重復數值，所以沒有數對 (i,j) 符合所有要求。
提示：

1 <= nums.length <= 100
1 <= nums[i], k <= 100

class Solution:def countPairs(self, nums: List[int], k: int) -> int:n = len(nums)sum = 0for i in range(n):for j in range(i+1, n):if nums[i] == nums[j] and i * j % k == 0:sum += 1return sum

十、元組

1.元組的定義

在 Python 中，元組是不可變的有序元素序列，這意味著創建后，不能更改、添加或刪除元組中元素

列表就像是一個收納盒，可以有序地存放不同類型的數據

Python中類似的收納盒不止一種，不同類型的收納盒我們統稱為數據結構

數據結構是用來存儲、組織數據，并能對數據進行一定便捷操作的工具。

Python已經為我們準備了列表(list)，元組(tuple)，字典(dict)等好用的數據結構。

如果說列表像收納盒，可以有序地在盒子中裝上不同的東西。那么元組就像是上了永久密碼鎖的收納盒，同樣可以有序的裝東西，可是里面的東西不可被改變

元組的創建方法

元組使用圓括號 ()，而列表使用方括號 []

列表轉元組：tuple(list_data)

字符串轉元組：tuple("123")?

元組和列表一樣，可以存儲不同類型的數據，元組中的元素，可以是數字，字符串、字符串和數字混合

元素不可修改主要是為了數據安全，例如防止寫代碼的人因為自己的錯誤，誤修改了里面的數據，或者是一些隱私數據被篡改。

2.元組的基礎特性

Ⅰ、不可變性：元組一旦創建，元素不可修改（增刪改操作均會引發異常）。這種特性使其適合存儲需要保護的數據

Ⅱ、有序性：元組中的元素按插入順序存儲，支持索引和切片訪問

Ⅲ、可哈希性：因為不可變，元組可作為字典的鍵或集合的元素，而列表不行

3.元組的運算

元組內的元素雖然不可以更改，但元組之間可以使用+、+=、*號進行運算，運算后會生成一個新的元組。接下來我們以 + 為例了解元組之間的運算。

使用"+"號連接兩個元組，就變成了一個新的元組，它包含了兩個元組中的所有元素。

將多個元組合并為一個元組，較多應用于數據分析中

例如，我們可能會從多個文件或數據庫中讀取數據，然后將它們合并成一個元組，以便進行后續的
處理。

tuple_1 = (1, 2, 3)
tuple_2 = (4, 5, 6)tuple_3 + tuple_1 + tuple_2
# tuple_3 = (1, 2, 3, 4, 5, 6)

列表支持的功能，元組都支持，除了改變元素?

元組的解包

將元組元素分配給多個變量，支持星號表達式處理不匹配的元素個數

a, b, *rest = (1, 2, 3, 4, 5)  # a=1, b=2, rest=[3,4,5]

成員檢查

使用 in 關鍵字判斷元素是否存在

if 3 in my_tuple:print("存在")

4.元組的刪除

元組中的元素值是不允許刪除的，但我們可以使用?del語句?來刪除整個元組。

tuple_1 = (1, 2, 3, 4)
del tuple_1

當元組被刪除后，輸出變量時會有異常信息，輸出如下所示，表明元組已被刪除

del 關鍵字不僅能刪除元組，也能刪除整個列表，以及列表中的元素?

十一、字典

1.字典的定義

在 Python 中，字典是一種無序的可變數據類型，它存儲鍵值對，字典的"鍵"是唯一的，而"值"可以是任何數據類型

在Python中，將兩種數據關聯在一起形成一個元素，由多個這樣的元素組成的數據類型稱為字典，又稱為dictionary

字典中的鍵可以由任意不可修改的數據類型組成(數字，字符串，元組)，組成字典元素的兩個數據一一對應，分別是鍵(key) 和值(value)

在一個字典中不會有相同的兩個鍵，而每一個鍵也只能對應一個值

字典(dictionary)是一種數據類型，按照鍵值對的方式存儲數據。鍵是索引 key，值是數據 value，鍵和值之間的分隔符為 :，鍵值對之間使用?,?分隔。?

字典的創建方法

Ⅰ、直接定義：使用花括號{}，鍵值對用冒號：分隔

empty_dict = {}  # 空字典
person = {"name": "Bob", "age": 30}  # 帶初始鍵值對

Ⅱ、構造函數：通過dict()函數創建，支持鍵值對序列或關鍵字參數

dict_from_list = dict([("a", 1), ("b", 2)])  # 從列表創建
dict_from_kwargs = dict(name="Charlie", age=22)  # 從關鍵字參數創建

Ⅲ、字典推導式：快速生成字典，支持過濾和轉換

squares = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

字典使用花括號{}，元組使用圓括號 ()，而列表使用方括號 []

2.查找字典元素

字典和列表一樣，也會有查找、刪除、添加、修改等功能，但因為字典是沒有順序的結構，在功能的使用上，有所不同。

字典是沒有順序的，也就沒有索引，所以只能通過字典的鍵(key) 來查找對應的值(value)

我們同樣通過索引的方式查找鍵對應的值，索引用方括號[]，在其中填入鍵。

鍵相當于列表中的下標

通過鍵(key) 的索引查找列表元素值(value)

使用 get(key, default) 安全訪問

3.增加字典元素

字典作為一種可變的數據類型，也可以進行添加與修改，但添加與修改的方式與列表不同。

字典是可以改變的，就像圖書館的書籍也是可以增補的。但是字典中的元素也是要以鍵值對一一對應的形式添加或刪除

字典的鍵是不能重復的，當我們嘗試添加一個已經存在的鍵時，就會將該元素覆蓋。所以對字典的修改，就是對字典的某個已經存在的鍵重新賦值，修改字典，其實是對字典中已經存在的鍵重新賦值

4.刪除字典元素

使用 del語句會刪除整個元組，在字典中，del語句用來刪除指定的鍵值對。

dict.pop(key)：刪除并返回值

dict.popitem()：刪除并返回最后一個鍵值對

dict.clear()：清空字典?

5.常用方法

① .keys()：返回所有鍵的視圖

② .values()：返回所有值的視圖

③ .items()：返回所有鍵值對的視圖

④ .update(dict2)：合并字典

⑤ .setdefault(key,default)：安全獲取值，若不存在則設置默認值?

練習?2351. 第一個出現兩次的字母

給你一個由小寫英文字母組成的字符串?s?，請你找出并返回第一個出現?兩次?的字母。

注意：

如果?a?的?第二次?出現比?b?的?第二次?出現在字符串中的位置更靠前，則認為字母?a?在字母?b?之前出現兩次。
s?包含至少一個出現兩次的字母。

示例 1：
輸入：s = "abccbaacz"
輸出："c"
解釋：
字母 'a' 在下標 0 、5 和 6 處出現。
字母 'b' 在下標 1 和 4 處出現。
字母 'c' 在下標 2 、3 和 7 處出現。
字母 'z' 在下標 8 處出現。
字母 'c' 是第一個出現兩次的字母，因為在所有字母中，'c' 第二次出現的下標是最小的。
示例 2：
輸入：s = "abcdd"
輸出："d"
解釋：
只有字母 'd' 出現兩次，所以返回 'd' 。
提示：

2 <= s.length <= 100
s?由小寫英文字母組成
s?包含至少一個重復字母

class Solution:def repeatedCharacter(self, s: str) -> str:dict = {}for i in s:if dict.get(i):return idict[i] = 1

練習?1512. 好數對的數目

給你一個整數數組?nums?。

如果一組數字?(i,j)?滿足?nums[i]?==?nums[j]?且?i?<?j?，就可以認為這是一組?好數對?。

返回好數對的數目。

示例 1：
輸入：nums = [1,2,3,1,1,3]
輸出：4
解釋：有 4 組好數對，分別是 (0,3), (0,4), (3,4), (2,5) ，下標從 0 開始
示例 2：
輸入：nums = [1,1,1,1]
輸出：6
解釋：數組中的每組數字都是好數對
示例 3：
輸入：nums = [1,2,3]
輸出：0
提示：

1 <= nums.length <= 100
1 <= nums[i] <= 100

解法 ①?

class Solution:def numIdenticalPairs(self, nums: List[int]) -> int:n = len(nums)num = 0for i in range(n):for j in range(i + 1, n):if nums[i] == nums[j]:num += 1return num

解法 ②

dict.get()：是字典操作的核心功能之一，用于安全獲取鍵對應的值

dict.get(key, default=None)

key：要查找的鍵

default：（可選），若鍵不存在，返回該默認值（默認為None）

class Solution:def numIdenticalPairs(self, nums: List[int]) -> int:dict = {}n = len(nums)num = 0for i in range(n):num += dict.get(nums[i], 0)dict[ nums[i] ] = dict.get(nums[i], 0) + 1return num

6.字典的高級應用場景

Ⅰ、統計詞頻：通過遍歷字符串并累加字典值

text = "apple banana apple"
word_count = {}
for word in text.split():word_count[word] = word_count.get(word, 0) + 1

Ⅱ、快速查找表

city_codes = {"Beijing": 10, "Shanghai": 21}
print(city_codes["Shanghai"])  # 輸出：21

Ⅲ、嵌套結構：字典可嵌套其他字典或列表，表示復雜數據關系

employee = {"name": "Alice","address": {"city": "New York", "zip": "10001"},"skills": ["Python", "SQL"]
}
print(employee["address"]["city"])  # 輸出：New York

Ⅳ、函數返回多值：通過字典打包返回多個值，提升代碼可讀性。

def get_user_info():return {"name": "Bob", "age": 25, "city": "Los Angeles"}
info = get_user_info()
print(info["name"])  # 輸出：Bob

7.數據結構小結

列表，元組，字典三種數據結構的共同特點是：

1.可以存儲多個元素

2.存儲的元素可以是不同的類型

列表是有序的可變的數據結構

有序：可以通過索引來訪問列表中的元素

可變：可以通過賦值、刪除、插入等操作來修改列表中的元素。?

元組是一種有序的不可變的數據結構

有序：可以通過索引來訪問元組中的元素。

不可變：元組中的元素不能被修改，但元素與元素之間可以進行運算或者整體刪除。

字典是一種無序的可變的數據結構

無序：使用鍵值對的方式來存儲元素，通過鍵來訪問字典中的元素。

可變：字典可以通過賦值、刪除、插入等操作來修改字典中的元素。

定義元組、列表個字典的方式如圖所示，分別使用英文小括號()，方括號[]、花括號{}，三種數據結構的每一項元素都是由逗號分隔開

元組和列表使用索引來訪問某一個位置的元素，字典通過鍵來查找對應的值

我們可以使用切片的方式來截取元組和列表中多個連續的元素。

切片需要使用冒號來分隔切片開始的位置和終止的位置。

同時，遵循“取左不取右的原則，取左邊的數據，不取右邊的數據

切片時，開始位置和結束位置的數字，還有三種情況：

① 只填寫結束位置的數字；默認從第一個元素開始切片

② 只填寫開始位置的數字；默認從開始位置切片，取到最后一個元素

③ 兩側數字都不填寫；?取列表中的所有元素

修改列表：可以用列表的索引訪問需要修改的元素并重新賦值

修改字典：使用字典的鍵訪問需要修改的元素并重新賦值

修改元組：元組不能被修改

在列表中插入元素，使用insert()語句可以在列表的任意位置添加元素

元組的計算：元組中的元素雖然不能改變，但元組之間可以進行數學運算形成新的元組。
使用"+"號連接兩個元組，就變成了一個新的元組，它包含了兩個元組中的所有元素。

在字典中添加元素：在字典中添加新元素的方法是指定一個新的鍵，并對它進行賦值

刪除字典元素

使用del方法，通過元素的鍵來刪除，會刪掉整個鍵值對，也可能是刪除整個字典

刪除整個元組

使用del方法，不能刪除元組中的個別元素，但可以刪除整個元組

刪除整個列表

使用del方法，同樣能刪除整個列表，也可以刪除列表中的元素

使用pop方法，也可以刪除列表中的元素

列表、元組、字典的常見報錯

我們在索引和查找指定元素時，最常出現的錯誤提示是“索引錯誤”，indexError如圖所示元組-共有5個元素，索引的范圍是0-4。不存在索引為5，會出現"out of range"的報錯

那要如何快速找到元組的元素個數，避免出現索引超過的錯誤呢？此時可以使用len()函數

len()方法象一個尺子，可以獲取測量對象的長度

len()方法可以通過直接索引數據結構來獲得其長度，也就是元素個數

十二、函數使用

1.函數的定義

在編程中，函數是一段用于執行特定任務的可重用代碼塊，可以通過定義函數名和參數列表來創建函數

print()?我們已經很熟悉了，它還有個專業的名詞叫做函數(function)，每個函數都有自己特定的功能，比如print()的功能就是在電腦屏幕上打印輸出一些數據。

函數具有三個特點，第一個是特定功能，比如有些函數的功能是打印輸出一些數據，有些函數的功能是完成特定的計算；第二個是輸入，使用函數的時候可以輸入一些數據；第三個是輸出，使用函數以后，它會輸出一些數據；

函數的定義是指函數的具體代碼實現，我們需要這幾個部分：1.def 關鍵字(define)，就是用來定義函數的關鍵字；2.函數名 add_3，它標識了函數；3.函數參數部分(num):，4.最后是函數返回值的關鍵字 return?

2.函數的調用

函數的命名和變量一樣，我們只使用字母，數字和下劃線，同時不用數字開頭。建議的命名風格是：函數名一律使用小寫字母，字母(及數字)之間使用下劃線連接，同時盡量做到看函數名去表達函數的功能（見名知意）

完成了函數的定義以后，我們就可以開始使用這個函數了，使用函數的過程有個專業名詞：函數調用。需要注意的是，函數一定需要先定義，再調用，畢竟我們需要先有函數的代碼，才能執行它。

需要注意的是，函數定義的時候，是有冒號 :?的，以及下面的歸屬于這個函數的代碼塊是需要縮進的。而在函數調用的時候，我們則不需要這些。?

練習.1732. 找到最高海拔

有一個自行車手打算進行一場公路騎行，這條路線總共由?n + 1?個不同海拔的點組成。自行車手從海拔為?0?的點?0?開始騎行。

給你一個長度為?n?的整數數組?gain?，其中?gain[i]?是點?i?和點?i + 1?的?凈海拔高度差（0 <= i < n）。請你返回?最高點的海拔?。

示例 1：
輸入：gain = [-5,1,5,0,-7]
輸出：1
解釋：海拔高度依次為 [0,-5,-4,1,1,-6] 。最高海拔為 1 。
示例 2：
輸入：gain = [-4,-3,-2,-1,4,3,2]
輸出：0
解釋：海拔高度依次為 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔為 0 。
提示：

n == gain.length
1 <= n <= 100
-100 <= gain[i] <= 100

class Solution:def largestAltitude(self, gain: List[int]) -> int:high = 0last = 0for i in gain:last += ihigh = max(high, last)return high

3.函數名

函數名又叫函數的命名，我們知道，要定義一個函數，就需要用到關鍵字def，它是英文define（定義）的簡寫，def后面我們就可以定義這個函數的函數名了

函數名命名和變量名命名一樣，只能使用下劃線、字母和數字，且數字不能作為開頭

從代碼風格的角度來說，我們對函數名的命名有兩個原則：第一個是最好從函數名本身就能看出函數的功能；第二個是函數名一律小寫，如果有多個單詞我們可以用下劃線隔開

4.函數參數

函數需要一些輸入，我們稱它為函數參數

函數參數是我們在調用函數的時候，輸入給函數的數據。之前我們只使用過一個參數，現在我們來了解一下更進階的函數參數用法

函數參數是用來從“函數外部”向“函數內部”傳遞數據的，就是我們在代碼中調用函數的時候通過函數參數向函數傳入數據。

值得注意的是，函數定義中的參數數量，需要和函數調用時的參數數量，保持一致，否則程序會報
錯

5.函數返回值

函數需要一些輸出，我們稱它為函數返回值

那么函數內部如何向函數外部輸出數據呢？我們通過函數返回值來實現這一數據傳遞

函數返回值通過關鍵字return實現，空格后面的數據，就是具體返回給函數外部的數據

一個函數定義如果不顯性聲明返回值的話，這時候會返回一個空值None

6.函數必選參數

函數參數分為3種：① 必選參數；② 可選參數 ③ 不定長參數，分別對應不同的應用場景。

必選參數就是指在調用這個函數的時候，必須使用的參數，不輸入這個參數就無法正確調用函數

7.函數默認參數

第二種函數參數是默認參數，意思是它有一個默認值，在調用函數的時候，如果我們不輸入這個參數，它就使用默認值，所以叫默認參數

8.函數不定長參數

當我們需要更靈活地傳入參數時(比如：有時候傳入2個參數，有時候傳入5個參數這種參數個數不確定的場景)，我們就可以使用不定長參數

不定長參數又叫可變參數，“可變”具體是指參數的數量是靈活可變的，不固定的。

星號*是表明不定長參數的固定語法格式

def sum_up(*num):sum_number = 0for counter in num:sum_number = sum_number + counterreturn sum_numbernumber_1 = sum_up(1, 2, 3, 4)
print(number_1)number_2 = sum_up(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(number_2)

9.函數執行順序

入口丟進去的瓶子和水就是輸入，出口出來的瓶裝水就是輸出，“有魔法的加工盒”就是函數。不同的函數有不同的功能，就像有些“加工盒”加工出來的水是礦泉水，有些“加工盒”加工出來的“水”是果汁。

第一種執行順序是代碼默認的，它叫順序執行或者簡稱順序，也就是從上到下順序地執行每行代碼

print("一")
print("二")
print("三")
print("四")

第二種代碼執行順序是判斷，會根據判斷的不同條件執行不同的代碼分支

第三種執行順序是循環，它根據循環條件，決定執行幾次代碼

第四種順序是代碼的“跳轉執行”，簡稱跳轉，函數以及后面將要學習的類和對象，都涉及到類似這樣的執行順序

def add_three(num):new_number = num + 3return new_numbernumber1 = 10
number2 = add_three(number1)
print(number2)

10.Python中的一些內置函數

函數主要分為兩大部分：

第一部分是函數定義，它確定了函數功能和使用方法；

第二部分是函數調用，它完成了代碼中對函數的使用。

函數定義中，包含了三大主要部分:

① 函數名；② 函數參數；③ 函數返回值。

其中函數名和函數參數涉及到的關鍵字是def，函數返回值涉及的關鍵字是return

例如，print()、range()、len()等函數都是Python定義好的函數，我們只需要使用它就可以了

min()：首先是從一系列數字里面挑選出最小值(minimum)的內置函數

max()：從一系列數字里面挑選出最大值(maximum)的內置函數

十三、類

1.類的定義

Python中，類是一種用戶定義的復雜數據類型，類提供了一種組織代碼和數據的方式，用于創建現實世界的藍圖

下面的代碼就是一個代表老師“類別”的代碼，其中類的命名就來自于對class單詞的翻譯(一類種類的意思)。

class Teacher:def __init__(self):self.name = "Susan"self.subject = "English"self.age = 33self.height = 164self.weight = 105

我們可以看到，一個類的定義包括了：① 關鍵字class?② 類名 ③ 語法固定符號冒號(:) ④ 一個初始化函數_init_(self)

注意：init左右各有兩個下劃線，需要傳入self這個特殊的參數。

定義類中的函數時，要帶上”self“這個參數

每個類都有一個初始化函數? __init__(self)，它的功能是給一些“屬于”類的變量賦值。它叫初始化是因為，這個函數是跟隨類代碼初始化的時候就會調用的。

這個函數的init單詞左右各有2個下劃線，不要漏掉；類中函數定義時要帶上self變量，也不要漏掉

2.類的屬性

同樣的，一個類也有兩大部分構成，其中一個是類的屬性，類似于老師的名字、學科、年齡等等，在代碼中它是以變量的形式出現。

屬性(property)又叫成員變量，它是歸屬于類的一個變量，用來描述類的一些特性。

比如老師有名字(self.name)，有學科(self.subject)，有年齡(self.age)。這里的名字、學科、年齡，都是老師(Teacher)這個類的屬性。

為什么這個變量看起來有些奇怪，前面還有個前綴self.？這其實是用來表明這個屬性“歸屬于”這個類自己的(self)。比如?self.name，就代表著:“自己的名字”，self等于“自己”，句號.等于“的”，name等于“名字”。

3.類的方法

方法又叫成員函數，它是“歸屬于”類的一個函數，用來實現類的一些功能。

十四、類和對象

1.對象

類是指一個抽象的類別(比如”老師”)，是指代一個人群的所有人。

而生活中我們往往遇見的是一個個具體的人，比如你初中的語文老師阿飛，高中的政治老師阿番他們是一個具體的對象。

所以類和對象的關系是 —— 類是對象的模版，對象是類的實例。

即使只有初始化函數，當一個對象被創建以后，它也有了自己的數據

2.實例化

類的命名是字母直接連在一起，單詞的首字母大寫。對象的命名是遵從變量的命名規則，使用小寫字母，單詞之間用下劃線連接。

實例化就是以某個類為模板，創建對象的過程

class MobliePhone:def __init__(self, brand, the_type):self.brand = brandself.the_type =the_typedef print_brand_type(self):print(self.the_type)def print_brand(self):print(self_brand)mobile_phone_a = MobilePhone("IPhone", "18")
mobile_phone_b = MobilePhone("xiaomi", 12)

實例化的具體代碼執行時機，是在創建對象的時候。這時候默認調用了初始化函數__init__()。我們不用顯性或者編寫代碼來調用這個函數，是因為這個調用過程默認是靜默的。?