直接在jupyter寫筆記然后導出md格式真的太好用了

---

本文筆記來自小破站視頻BV1K14y1c75e

---

Python 基礎

1. 變量

1.1 三種基本變量類型

# 字符串 str
str_v = "123"

# 數字 int或float
num_v = 11
float_v = 12.0

# 布爾型 bool
bool_v = True

1.1.1 字符串

f字符串：在字符串中插入變量

iou = 0.98
print(f"iou is {iou}")

iou is 0.98

轉義字符：僅在print中生效

message = "The shop sells:\n\tlychee,\n\tfritters,\n\tfried fish."

print(message)

'The shop sells:\n\tlychee,\n\tfritters,\n\tfried fish.'

print(message)

The shop sells:lychee,fritters,fried fish.

1.1.2 布爾型

基于高級變量類型生成

# 以集合為例 其他都一樣
set_v = {1,2,3}
print(2 in set_v)
print(2 not in set_v)

True
False

not and or 非與或

同c中的 ! && || 不贅述

1.1.3 基礎變量的強制類型轉換

print(str(num_v))
print(str(float_v))
print(str(bool_v))

11
12.0
True

print(int(float_v))
print(int(str_v))
print(int(bool_v))

12
123
1

print(float(num_v))
print(float(str_v))
print(float(bool_v))

11.0
123.0
1.0

1.2 四種高級變量類型

# 集合 set
set_v = {1,3,2,4}

# 元組 tuple
tuple_v = (1,2,3)

# 列表 list
list_v = [1,2,3]

# 字典 dict
dict_v = {'a':1, 'b':2, 'c':3}

1.2.1 集合

無序、不可重復。集合出現的次數稀少，它更多是被看作字典的索引，即數據的標簽。后續pandas庫可以代替集合，還有字典。

另外集合不能存儲可變對象（列表、集合、字典、含有可變類型元素的元組），因為集合要求所有元素必須是可哈希的。

可以通過set函數或大括號創建集合

set([1,1,2,6,4,5,5])

{1, 2, 4, 5, 6}

{1,2,3,2,1}

{1, 2, 3}

注意請勿使用大括號創建空集合，否則會被誤認為字典

1.2.2 元組

可以通過規范括號法或者省略括號法來創建元組

(1,2,3)

(1, 2, 3)

1,2,3

(1, 2, 3)

高級變量類型可以容納所有的變量類型

'a', 1, True, {1,2,3}, (1,2,3), {'a':1, 'kk':2, '2': "ok"}

('a', 1, True, {1, 2, 3}, (1, 2, 3), {'a': 1, 'kk': 2, '2': 'ok'})

元組拆分法

# 極速創建新變量
a,b,c = 1,2,3
print(a,b,c)

1 2 3

# 極速交換變量
a,b = 1,2
b,a = a,b
print(a,b)

2 1

# 只要前兩個變量
value = 11,12,23,12,23,34
a, b, *rest = value
print(a,b,rest)

11 12 [23, 12, 23, 34]

1.2.3 列表

由若干個有序元素的變量組成。列表可以容納各種數據類型，但是列表要單獨存儲每一個元素的變量類型，列表越大約占空間。后續numpy庫將代替列表。

list_v = ['xxx', 12, True, (1,2,2,2), set([1,2,3]), {'a':1, 'b':2}]
list_v

['xxx', 12, True, (1, 2, 2, 2), {1, 2, 3}, {'a': 1, 'b': 2}]

訪問列表元素

# 通過索引訪問列表元素
print(list_v[0])
print(list_v[5])
# 索引-1表示倒數第一個元素
print(list_v[-1])
print(list_v[-6])

xxx
{'a': 1, 'b': 2}
{'a': 1, 'b': 2}
xxx

修改列表元素

list_v[-2]=(99,88,77)
list_v

['xxx', 12, True, (1, 2, 2, 2), (99, 88, 77), {'a': 1, 'b': 2}]

切片————訪問部分元素
切片的索引類似于數學上的左閉右開區間 [ , )

[ a, b, c, d, e ]|  |  |  |  | 0  1  2  3  4
-5 -4 -3 -2 -1

list_v = ['a', 'b', 'c', 'd', 'e']
# 切片有兩種理解方式
# 若兩個參數st和ed都是正數[st,ed] 就理解為從st開始切到ed
print(list_v[1:4])       # 從1開始切到4前
print(list_v[1: ])       # 從1開始切到結尾 or 切除開頭一個
print(list_v[ :4])       # 從開頭切到4前
# 若兩個參數一正一負[a:-b] 可以理解為切除開頭a個和結尾b個，除此之外都按照第一個理解方式來理解
print(list_v[2:-2])      # 從2開始切到-2前 or 切除開頭兩個和結尾兩個
print(list_v[2: ])       # 從2開始切到結尾 or 切除開頭兩個
print(list_v[ :-2])      # 從開頭切到-2前 or 切除結尾兩個

['b', 'c', 'd']
['b', 'c', 'd', 'e']
['a', 'b', 'c', 'd']
['c']
['c', 'd', 'e']
['a', 'b', 'c']

# 有3個參數時，第三個參數就是每個x個元素采樣一次
list_v = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list_v[ : :2])
print(list_v[ : :3])
print(list_v[1:-1:2]) # 切除一頭一尾后 每隔2個元素采樣一次

['a', 'c', 'e', 'g']
['a', 'd', 'g']
['b', 'd', 'f']

注意：對列表切片之后會生成一個新的獨立的對象。為此，numpy的切片被設定為原對象的一個視圖，不會在內存中創建一個新的對象

列表元素的添加

使用+ *來添加原列表

list_v = [1,2,3]
print(list_v + [4,6])     # 尾部新增元素
print(list_v * 2)         # 復制兩倍的自己

[1, 2, 3, 4, 6]
[1, 2, 3, 1, 2, 3]

1.2.4 字典

可以理解為升級版的列表，就是自定義索引的列表。字典中的元素值可以是任何數據類型變量，但字典的鍵只能是數或者字符串，常常是字符串。

xjtu = {'CS': 'A+','SE': 'A-','EE': 'B+','ME': 'A+'
}
xjtu

{'CS': 'A+', 'SE': 'A-', 'EE': 'B+', 'ME': 'A+'}

# 添加元素
xjtu['Math'] = 'A'
xjtu['Bio'] = 'A'
xjtu['Phys'] ='B+'
xjtu['Psych'] ='B-'
xjtu

{'CS': 'A+','SE': 'A-','EE': 'B+','ME': 'A+','Math': 'A','Bio': 'A','Phys': 'B+','Psych': 'B-'}

# 修改元素
xjtu['SE'] = 'B+'
xjtu

{'CS': 'A+','SE': 'B+','EE': 'B+','ME': 'A+','Math': 'A','Bio': 'A','Phys': 'B+','Psych': 'B-'}

# 刪除元素
del xjtu['Math']
xjtu

{'CS': 'A+','SE': 'B+','EE': 'B+','ME': 'A+','Bio': 'A','Phys': 'B+','Psych': 'B-'}

1.2.5 高級變量之間的轉換

基本結構

set([1,2,3])                              # 轉化為 集合
tuple([1,2,3])                            # 轉化為 元組
list({1,2,3})                             # 轉化為 列表
dict(zip( ('a','b','c'), {1,2,3} ))         # 轉化為 字典

{'a': 1, 'b': 2, 'c': 3}

注意：轉為字典盡量不要使用集合，因為集合無序，會造成錯誤。

dict(zip({'a','b','c'}, {1,2,3}))    # 順序被打亂

{'b': 1, 'c': 2, 'a': 3}

2. 語句

2.1 if-else

# 示例1: 成績等級評定
score = 85
if score >= 90:grade = "A"
elif score >= 80:grade = "B"
elif score >= 70:grade = "C"
elif score >= 60:grade = "D"
else:grade = "F"print(f"分數 {score} 的等級是: {grade}")

分數 85 的等級是: B

三元表達式

# 傳統寫法
age = 20
if age >= 18:status = "成人"
else:status = "未成年"# 三元表達式寫法
status = "成人" if age >= 18 else "未成年"
print(status) # 另一個例子
x = 10
y = 20
max_value = x if x > y else y
print(f"最大值是: {max_value}") 

成人
最大值是: 20

與高級數據類型的結合，這里以列表為例

# 檢查列表是否包含特定元素
fruits = ["apple", "banana", "orange"]
if "banana" in fruits:print("列表中有香蕉")
else:print("列表中沒有香蕉")# 檢查列表是否為空
my_list = []
if my_list:print("列表不為空")
else:print("列表為空")

列表中有香蕉
列表為空

2.2 for

# 遍歷列表
fruits = ["蘋果", "香蕉", "橙子", "葡萄"]
for fruit in fruits:print(f"我喜歡吃{fruit}")# 帶索引遍歷列表
for index, fruit in enumerate(fruits): # index fruit順序不能反print(f"[{index}]: {fruit}")

我喜歡吃蘋果
我喜歡吃香蕉
我喜歡吃橙子
我喜歡吃葡萄
[0]: 蘋果
[1]: 香蕉
[2]: 橙子
[3]: 葡萄

# 遍歷字符串
word = "Python"
for char in word:print(char)

P
y
t
h
o
n

# 遍歷字典
student = {"姓名": "小明", "年齡": 20, "專業": "計算機"}# 遍歷鍵
for key in student:print(f"{key}")# 遍歷鍵值對
for key, value in student.items():print(f"{key}: {value}")

姓名
年齡
專業
姓名: 小明
年齡: 20
專業: 計算機

# 遍歷數字序列
for i in range(5): print(i)

0
1
2
3
4

# 指定起始和結束值
for i in range(2, 6): print(i)

2
3
4
5

# 指定步長
for i in range(0, 10, 2): print(i)

0
2
4
6
8

# 倒序循環
for i in range(5, 0, -1):print(i)

5
4
3
2
1

# else - 循環正常結束執行（非break退出）
for num in range(3):print(num)
else:print("循環正常結束")

0
1
2
循環正常結束

# 同時遍歷多個列表
names = ["小明", "小紅", "小剛"]
scores = [90, 85, 95]
subjects = ["數學", "英語", "語文"]for name, score, subject in zip(names, scores, subjects):print(f"{name}的{subject}成績是{score}分")

小明的數學成績是90分
小紅的英語成績是85分
小剛的語文成績是95分

2.3 while

count = 1
while count <= 5:print(f"計數: {count}")count += 1
print("循環結束")

計數: 1
計數: 2
計數: 3
計數: 4
計數: 5
循環結束

在循環語句中，continue break 的用法同c語言

2.4 列表推導式

基本結構：

# 傳統方式：創建平方數列表
squares = []
for i in range(5):squares.append(i ** 2)
print(squares)  # 列表推導式
squares = [i ** 2 for i in range(5)]
print(squares) 

[0, 1, 4, 9, 16]
[0, 1, 4, 9, 16]

# 條件過濾
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
short_fruits = [fruit for fruit in fruits if len(fruit) <= 5]
print(short_fruits)

['apple', 'date']

# if-else列表推導式
numbers = [1, 2, 3, 4, 5]
result = ["偶數" if num % 2 == 0 else "奇數" for num in numbers]
print(result) 

['奇數', '偶數', '奇數', '偶數', '奇數']

3. 函數

基本結構

def my_func(v):'''文檔字符串，用于解釋函數：這是我的函數'''return v

打印文檔字符串

my_func.__doc__

'文檔字符串，用于解釋函數：這是我的函數'

函數可以吞吐各個類型的變量

x = my_func(3)
x

3

可以利用元組吞吐多個值

def my_counter(a,b):return a+b, a*bx = my_counter(2,5)
x

(7, 10)

可以吞吐任意數量的參數

def menu(*args):return argsinfo = menu('fish','soup','beef','noodles')    
info

('fish', 'soup', 'beef', 'noodles')

可以同時傳入普通參數和一個任意數量參數

def stu_info(name, num, *hobbies):return name, num, hobbiesname, num, hb = stu_info('xxx', '22123', 'singing', 'dancing', 'dyno')
print(f"{name} 學號{num}，喜歡{hb}")

xxx 學號22123，喜歡('singing', 'dancing', 'dyno')

同時傳入普通參數和一個任意數量的鍵值對參數

def comment(com1, com2, **kwargs):'''先評價cs，再評價ee，可以自行補充'''kwargs['CS'] = com1kwargs['EE'] = com2return kwargs

關鍵字調用，可以不按順序寫

def introduce(name, age, city):print(f"我叫{name}，今年{age}歲，來自{city}")# 位置參數調用（必須按順序）
introduce("張三", 25, "北京")# 混合使用（位置參數必須在關鍵字參數之前）
introduce("錢七", city="杭州", age=40)

我叫張三，今年25歲，來自北京
我叫錢七，今年40歲，來自杭州

帶默認值的關鍵字參數

def create_user(name, age, role="user", active=True):print(f"創建用戶: {name}, 年齡: {age}, 角色: {role}, 狀態: {'活躍' if active else '禁用'}")# 使用默認值
create_user("Alice", 25)  # 角色: user, 狀態: 活躍# 覆蓋默認值
create_user("Bob", 30, role="admin")
create_user("Charlie", 35, active=False)
create_user("David", 40, role="moderator", active=True)# 關鍵字調用可以跳過有默認值的參數
create_user("Eve", 45, active=False)  # 角色使用默認值user

創建用戶: Alice, 年齡: 25, 角色: user, 狀態: 活躍
創建用戶: Bob, 年齡: 30, 角色: admin, 狀態: 活躍
創建用戶: Charlie, 年齡: 35, 角色: user, 狀態: 禁用
創建用戶: David, 年齡: 40, 角色: moderator, 狀態: 活躍
創建用戶: Eve, 年齡: 45, 角色: user, 狀態: 禁用

4. 類

4.1 創建和使用類

類的本質是在一堆函數之間傳遞參數。

類的名稱首字母必須大寫。

類中的函數叫方法，一個類包含一個 __init__ 方法（必須包含） + 很多自定義方法

class Counter:'''一臺可以加減的計算器'''def __init__(self, a, b):'''公共變量'''self.a = aself.b = bdef add(self):return self.a + self.bdef sub(self):return self.a - self.b

# 創建類的實例
cnt = Counter(5,6)     # 創建一個類的實例 cnt
print(cnt.a, cnt.b)    # 訪問屬性
print(cnt.sub())       # 調用方法

5 6
-1

函數內部的變量與外部是兩個空間，可以把self理解為船，使得自定義方法能在類里面互通，將需要互通的變量作為self的屬性進行傳遞。

4.2 屬性的默認值

可以給self的屬性一個默認值，此時默認值不用寫進__init()__的參數列表里

class Man:def __init__(self, name, age):self.name = nameself.age = ageself.gender = 'M'           # 默認屬性

xxx = Man('Mauri', 20)
print(xxx.name)
print(xxx.age)
print(xxx.gender)

Mauri
20
M

修改屬性的默認值

xxx.gender = 'MTF'
print(xxx.gender)

MTF

4.3 繼承

子類 class 類名(父類名)

# 父類
class Counter:'''一臺可以加減的計算器'''def __init__(self,a,b):'''公共變量'''self.a = aself.b = bdef add(self):return self.a - self.b       # 假設這里父類的加法寫錯了def sub(self):return self.a - self.b# 子類
class CounterPlus(Counter):'''可以加減乘除的高級計算器'''def __init__(self,a,b):super().__init__(a,b)             # 調用父類的構造函數def mul(self):return self.a * self.bdef div(self):return self.a / self.bdef add(self):return self.a + self.b        # 覆寫父類的加法

cnt = CounterPlus(5,6)
print(cnt.a, cnt.b)
print(cnt.add())
print(cnt.mul())
print(cnt.sub())

5 6
11
30
-1

4.4 掠奪

一個類可以通過掠奪獲得很多其他類的方法

# 一個無辜的類
class CounterBasic:'''一臺可以加減的計算器'''def __init__(self,a,b):'''公共變量'''self.a = aself.b = bdef add(self):return self.a + self.b       def sub(self):return self.a - self.b# 掠奪者
class CounterEvil(Counter):'''一臺原先只可以乘除的計算器，現在他要掠奪加減方法了'''def __init__(self,a,b):self.a = aself.b = b        self.counter = CounterBasic(a,b)def mul(self):return self.a * self.bdef div(self):return self.a / self.b

cnt = CounterEvil(3,4)
print(cnt.mul())
print(cnt.div())
print(cnt.counter.add())
print(cnt.counter.sub())

12
0.75
7
-1

掠奪的本質是將另一個類的實例當作self的屬性使用，相當于創建了一個內部的類的實例。此外，掠奪者和被掠奪者可以擁有同名方法，調用起來互不沖突。