input()用于輸入，其有返回值（即用戶輸入的值），默認返回字符串。括號里可放提示語句

一行代碼若想分為多行來寫，需要在每一行的末尾加上“\”

單個“/”表示數學中的除法，不會取整。“//”才會向下取整。

字符串類型可以乘以整數類型，相當于這個字符串被復制了整數倍，若做輸出，即會重復輸出。

條件語句

if [條件] :

[執行語句][執行語句]

elif [條件二]:

[執行語句] 

else :

[執行語句]

（要有縮進，[條件]外面不用中括號也不用小括號）

邏輯關鍵詞

(not 非) > (and 與) > (or 或)

方法與函數

方法：對象.方法名()

函數：函數名()

列表（list）

1. 與普通數據類型（字符串，整型，浮點型，布爾型）的區別：列表在調用函數或方法對其代表的值進行改變時，其本身值確實會被改變；而普通數據類型調用函數或方法進行改變時，其本身的值不會被改變，相當于是其值被復制了一遍，改變的是復制后的值，然后進行輸出或其他操作。

2. 常用方法：.remove(【元素】)（移除），.append(【元素】)（添加） .min(【列表】)（返回列表中的最小值）.max(【列表】)``.sort(【列表】)（給列表排序）len(【列表】)（返回列表長度）

3. 命名方式：a = [【元素】,【元素】] （可以為空，里面可以有任何元素（但必須是同一類型），用逗號分隔）

4. 賦值：a[1] = 【另一個元素】

字典（dictionary）

1. 命名方式：a = { 【key】 : 【value】, 【key】 : 【value】 } （key必須是不可變的數據結構）

2. 舊鍵賦新值或新增鍵值對：a[【key1】] = 【value2】

3. 判斷某個鍵是否已經存在：【key】 in a，若存在，則該表達式的值為True，否則為False

4. 刪除鍵值對：del a[【key1】]

5. 常用方法：.keys()（返回里面的所有鍵）.values()（返回里面的所有值）.items()（返回里面的所有鍵值對）

元組（tuple）

1. 命名方式：a = (【元素】, 【元素】)

2. 不可變，可作為字典的key

3. 訪問元組中的元素：a[1]、a[0]

循環（for）

1. 寫法：for 【變量名】 in 【可迭代的對象】:（變量名處可以是多個變量，相應的可迭代對象得有同樣多數量的值）

2. range(a, b)：a≤ x<b range(a, b, c) ：c為步長

格式化字符串

用format()方法或直接在字符串前加 ‘ f ’，舉例

y = 90
a = 90.2
c = "jijin"
str1 = "嘻嘻哈哈{0}紅紅火火{2}恍恍惚惚{1}是啊{0}".format(y, a, c)
#或者如下
str2 = "嘻嘻哈哈{y2}紅紅火火{c2}恍恍惚惚{a2}是啊{y2}".format(y2 = y, a2 = a, c2 = c)
#或者如下
str3 = "嘻嘻哈哈{y2}紅紅火火{c2}恍恍惚惚{a2}是啊{y2}".format(y2 = 90, a2 = 90.2, c2 = "jijin")
#或者如下
str4 = "嘻嘻哈哈{y}紅紅火火{c}恍恍惚惚{a}是啊{y}".format(y = y, a = a, c = c)
#或者如下
str5 = f"嘻嘻哈哈{y}紅紅火火{c}恍恍惚惚{a}是啊{y}"
#或者如下
str6 = f"嘻嘻哈哈{90}紅紅火火{'jijin'}恍恍惚惚{90.2}是啊{90}"#打印結果皆如下
嘻嘻哈哈90紅紅火火jijin恍恍惚惚90.2是啊90

若要控制浮點數的小數位數，比如三位小數，則在具體值或者變量的后面加上“:.3f”

函數

1. 寫法：

def fun1():#函數體#。。。def fun2(a, b):            #無需說明參數類型，也無需說明函數類型c = a+bprint(c)return a          #若沒寫 return 語句會有默認的 return None

引入模塊

1. import 【模塊】

2. from 【模塊】 import 【函數】

3. from 【模塊】 import *

4. 引入第三方庫，需要先在互聯網上下載，用命令pip install來安裝，pypi.org這個網站可以對第三方庫進行搜素。

類

#定義一個類
class Cat:def __init__(self, name, age):  #構造函數，必寫，名字固定為 __init__() （注意，左右各兩個橫線）  第一個參數必須是self，代表自己self.name = name              #左側即為對象擁有的屬性，在構造函數里定義，不能在外面定義。self.age = ageself.color = "white"def meow(self):                  #自定義方法，第一個參數也必須是selfprint(f"{self.name} is meowing.")def show_info(self):print(f"{self.name} is {self.age} years old and {self.color} in color.")#創建一個對象
cat1 = Cat("Fluffy", 3)     #創建對象的時候可以不用傳入self的值
cat1.meow()                 #調用方法的時候也可以不用傳入self的值
cat1.show_info()#輸出結果
Fluffy is meowing.
Fluffy is 3 years old and white in color.

繼承

class Mammal:# 定義哺乳動物類，初始化時接受一個名字參數def __init__(self, name):self.name = nameself.has_tail = Truedef speak(self):print(f"{self.name} speaks.")class Dog(Mammal):# 定義狗類，繼承自哺乳動物類，初始化時接受一個名字參數def __init__(self, name):super().__init__(name)# 重寫說話方法，打印狗叫的信息def speak(self):print(f"{self.name} barks.")# 定義取物方法，打印狗取物的信息def fetch(self):print(f"{self.name} is fetching.")class Human(Mammal):# 定義人類，繼承自哺乳動物類，初始化時接受一個名字參數def __init__(self, name):super().__init__(name)self.has_tail = Flase     #修改父類繼承過來的屬性# 重寫說話方法，打印人說話的信息def speak(self):print(f"{self.name} talks.")# 打印人是否有尾巴的信息def show_has_tail(self):print("Do humen have tails? " + str(self.has_tail))# 創建一個Dog對象，名字為Rufus
dog = Dog("Rufus")  
dog.speak()  # 調用Dog對象的speak方法
dog.fetch()  # 調用Dog對象的fetch方法# 創建一個Cat對象，名字為Whiskers
human = Human("Jack")  
human.speak()  # 調用Human對象的speak方法
human.show_has_tail() # 調用human對象的show_has_tail方法# 輸出結果
Rufus barks.
Rufus is fetching.
Jack talks.
Do humen have tails? False

文件路徑常識（對于Windows系統來說）（相對路徑）

在同一目錄下的文件，如果想要相互找到彼此的話，可以直接使用文件名，不用前面再加一個“./”

讀取文件

1. 使用函數open()，open("【文件路徑】", "【模式】", "【encoding=】")

2. 【文件路徑】：可以寫絕對路徑，也可以寫相對路徑。

3. 【模式】：傳入一個字符串，常用的有"r"（只讀），和"w"（只寫）兩種模式。若不寫，則默認為只讀模式。讀取模式下，如果程序找不到對應的文件名的話，就會報一個"FileNotFoundError"的錯誤。

4. 【encoding】：也是可選的參數，可不寫

5. open()函數會返回一個文件對象，可以后續對它進行讀取和寫入的操作。

6. 讀取（“r”）：

   1. 例如，把文件對象賦值給一個變量f，f.read()就可以一次性讀取文件里的所有內容，并以字符串返回，print(f.read())即可將其打印出來。

   2. 一個文件對象的read()方法不可以連續調用，因為每次調用都會讀取全部的內容出來，并且它會記錄上次讀取到哪。所以，第一次調用完之后，第二次調用時只能讀取到空的字符串了。

   3. 若不想全部讀取，那就傳入一個數字作為參數，表示一次讀取多少字節。

f.read(10)  # 第一次，讀1-10字節的文件內容
f.read(10)  # 第二次，讀11-20字節的文件內容
f.readline() # 每次讀一行的文件內容，根據換行付來判斷什么時候本行結束
f.readlines() # 會讀取全部內容，并把每行作為列表元素返回，常與for循環結合
f.close()  # 關閉文件，釋放資源# 若容易忘記調用close()方法，可用如下寫法：
with open("./data.txt") as f :     # 用with寫法print(f.read())  # 對文件進行操作   要記得縮進
# 這樣，當縮進部分的代碼執行完后，資源會自動釋放

7. 寫入（“w”）：

   1. 寫入模式下，如果找不到文件名，會自動在路徑下創建一個新的文件。

   2. 若文件是存在的，那么會將文件原有內容清空，然后寫入新的內容。若不想原有內容被清空，則應該用“a”模式（附加模式）

   3. 用write()方法來進行寫入。如write("aaaa")。

8. 其他模式：

   1. “r+”：可讀也可寫入

   2. “a+”：可讀也可追加

   3. 寫入和追加是有區別的。追加是在文件末尾進行寫入。而寫入是看當前指針在哪個位置，最開始指針位置為1，如果之有過read操作，那么指針會后移，這時再調用write()的話，就是從上次read的結束位置開始寫入。

異常處理

try:user_weight = float(input("Enter your weight in kilograms: "))user_height = float(input("Enter your height in meters: "))bmi = user_weight / (user_height ** 2)
except ValueError:                     # If user enters non-numeric inputprint("Invalid input. Please enter a number.")
except ZeroDivisionError:               # If user enters height as zeroprint("Invalid input. Height cannot be zero.")
except:                                 # If any other error occursprint("An error occurred. Please try again.")
else:                                   # If no error occursprint("Your BMI is:", bmi)
finally:                               # This block is always executedprint("Thank you for using our BMI calculator.") again.")

測試

調用python自帶的庫：unittest

# 被測試函數所在文件 add_calculator
def add2(a, b):return a + b# 測試文件 test_add_calculator 
import unittest
from add_calculator import add2class TestAdd2(unittest.TestCase):      # 寫一個子類繼承于unittest.TestCase# 每一個方法就是一個測試用例，命名方式必須以test_開頭，只有這樣才能被unittest當作測試用例def test_positive_with_negative(self):                self.assertEqual(add2(100, -100), 0)def test_positive_with_positive(self):self.assertEqual(add2(100, 100), 200)def test_negative_with_negative(self):self.assertEqual(add2(-100, -100), -200)def test_negative_with_positive(self):self.assertEqual(add2(-100, 100), 0)if __name__ == '__main__':unittest.main()# 輸出結果
....               # 通過為 . 不通過為 F
----------------------------------------------------------------------
Ran 4 tests in 0.000sOK

本質上，assertTrue可以代替這些所有的方法。

但推薦使用更有針對性的方法，因為更有針對性的方法會給出更詳細具體的原因。

高階函數

高階函數可以把函數作為參數。作為參數的函數是直接把函數名作為參數傳入，后面不要帶括號和參數，因為如果帶括號和參數，傳入的就是函數的返回值了，而不是函數本身了。

匿名函數

無需名字，即用即扔。關鍵字：lambda

def calculate_and_print(num1, num2,  calc_func):  print(calc_func(num1,  num2))calculate_and_print(7, 5, lambda num1, num2: num1 * num2)  # 輸出35
# num1、num2為傳給匿名函數的參數，匿名函數不需要專門寫 return，直接放上要放回的結果即可（即上面冒號后面的 “num1 * num2”# lambda表達式的語法：lambda 參數1, 參數2, ... : 表達式
# lambda表達式也可以直接作為一個函數來計算，如下：
(lambda num1, num2: num1 * num2)(7, 5)  # 輸出35
# 但是一般不推薦這么做，因為lambda表達式的可讀性不高。# 匿名函數也有局限，即它的冒號后面不能有復雜的語句，只能是一行表達式。

本文是學習b站up主“林粒粒呀”《三小時python課程》時記的筆記
課程鏈接：你覺得自己這輩子都學不會編程？超超超基礎Python課程，3小時快速入門 【自學Python教程合集】【3小時快速入門Python】