一.基礎語法

注釋

Python中單行注釋以 # 開頭，如下：

#!/usr/bin/python3# 第一個注釋
print ("Hello, Python!") # 第二個注釋

多行注釋可以用多個 # 號，還有 ‘’’ 和 “”"：

#!/usr/bin/python3# 第一個注釋
# 第二個注釋'''
第三注釋
第四注釋
'''"""
第五注釋
第六注釋
"""
print ("Hello, Python!")

行與縮進

python最具特色的就是使用縮進來表示代碼塊，而不使用大括號 {} 。

縮進的空格數是可變的，但是同一個代碼塊的語句必須包含相同的縮進空格數。如下：

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

以下代碼最后一行語句縮進數的空格數不一致，會導致運行錯誤：

if True:print ("Answer")print ("True")
else:print ("Answer")print ("False")    # 縮進不一致，會導致運行錯誤

File "test.py", line 6print ("False")    # 縮進不一致，會導致運行錯誤^
IndentationError: unindent does not match any outer indentation level

Python使用大括號，主要用于表示字典類型，而不是用于代碼塊的分隔。

多個語句構成代碼組

縮進相同的一組語句構成一個代碼塊，我們稱之代碼組。

像if、while、def和class這樣的復合語句，首行以關鍵字開始，以冒號( : )結束，該行之后的一行或多行代碼構成代碼組。

空行

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

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

記住：空行也是程序代碼的一部分。它們可以出現在代碼的任何位置。例如，你可以在函數之間或在代碼塊之間插入空行。

多行語句

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

total = item_one + \item_two + \item_three

在 [], {}, 或 () 中的多行語句，不需要使用反斜杠 \，例如：

total = ['item_one', 'item_two', 'item_three','item_four', 'item_five']

等待用戶輸入

執行下面的程序在輸入后按下enter鍵后就會退出程序：

a=input("按下 enter 鍵后退出。")
print(a)

同一行顯示多條語句

Python 可以在同一行中使用多條語句，語句之間使用分號 ; 分割

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

print 輸出

print 默認輸出是換行的，如果要實現不換行需要在變量末尾加上 end=“”：

x="a"
y="b"
# 換行輸出
print( x )
print( y )print('---------')
# 不換行輸出
print( x, end=" " )
print( y, end=" " )
print()

import 與 from…import

在 python 用 import 或者 from…import 來導入相應的模塊。

將整個模塊(somemodule)導入，格式為： import somemodule

從某個模塊中導入某個函數,格式為： from somemodule import somefunction

從某個模塊中導入多個函數,格式為： from somemodule import firstfunc, secondfunc, thirdfunc

將某個模塊中的全部函數導入，格式為： from somemodule import *

導入sys模塊

import sys
print('================Python import mode==========================')
print ('命令行參數為:')
for i in sys.argv:print (i)
print ('\n python 路徑為',sys.path)

導入 sys 模塊的 argv,path 成員

from sys import argv,path  #  導入特定的成員print('================python from import===================================')
print('path:',path) # 因為已經導入path成員，所以此處引用時不需要加sys.path

Python數據類型

變量

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

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

Python允許你同時為多個變量賦值。例如：

a = b = c = 1

可以為多個對象指定多個變量。例如：

a, b, c = 1, 2, "runoob"

數據類型

Python3 中常見的數據類型有：

Number,String,bool, List, Tuple（元組）, Set, Dictionary（字典）
不可變數據：Number、String、Tuple；
可變數據（3 個）：List、Dictionary、Set

Number類型

Number: int、float、bool、complex（復數）

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

內置的 type() 函數可以用來查詢變量所指的對象類型,也可以用 isinstance 來判斷

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))print(isinstance(a, str))

isinstance 和 type 的區別在于：

type()不會認為子類是一種父類類型。
isinstance()會認為子類是一種父類類型。

注意：Python3 中，bool 是 int 的子類，True 和 False 可以和數字相加， True==1、False==0 會返回 True，但可以通過 is 來判斷類型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

Python 數字數據類型用于存儲數值。

Number數據類型是不允許改變的，這就意味著如果改變數字數據類型的值，將重新分配內存空間。
可以用del語句刪除一些數字對象的引用。

del var1[,var2[,var3[....,varN]]]

數值運算

>>> 17 / 3  # 除法，得到一個浮點數
5.666666666666667
>>> 17 // 3 # 除法，得到一個整數
5
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

1、一個變量可以通過賦值指向不同類型的對象。
2、數值的除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。
3、在混合計算時，Python會把整型轉換成為浮點數。
4、在整數除法中，除法 / 總是返回一個浮點數，如果只想得到整數的結果，丟棄可能的分數部分，可以使用運算符 //

字符串(String)

• Python 中單引號 ’ 和雙引號 " 使用完全相同。
• 使用三引號(‘’’ 或 “”")可以指定一個多行字符串。

word = '字符串'
sentence = "這是一個句子。"
paragraph = """這是一個段落，
可以由多行組成"""

• 轉義符 \。
• 反斜杠可以用來轉義，使用 r 可以讓反斜杠不發生轉義。 如 r"this is a line with \n" 則 \n會顯示，并不是換行。 r 指raw，即 raw string
• 按字面意義級聯字符串，如 "this " "is " “string” 會被自動轉換為 this is string。
• 字符串可以用 + 運算符連接在一起，用 * 運算符重復。
• Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
• Python 中的字符串不能改變。
• Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串。
• 字符串切片 str[start:end]，其中 start（包含）是切片開始的索引，end（不包含）是切片結束的索引。
  字符串的切片可以加上步長參數 step，語法格式如下：str[start : end :step]

str='123456789'print(str)                 # 輸出字符串
print(str[0:-1])           # 輸出第一個到倒數第二個的所有字符
print(str[0])              # 輸出字符串第一個字符
print(str[2:5])            # 輸出從第三個開始到第六個的字符（不包含）
print(str[2:])             # 輸出從第三個開始后的所有字符
print(str[1:5:2])          # 輸出從第二個開始到第五個且每隔一個的字符（步長為2）
print(str * 2)             # 輸出字符串兩次

另外，反斜杠()可以作為續行符，表示下一行是上一行的延續。也可以使用 “”“…”“” 或者 ‘’‘…’‘’ 跨越多行。

str = 'Runoob'\"dad"# 定義一個字符串變量str2 = """這是一個
多行字符串。""" # 定義一個字符串變量print(str)           # 打印整個字符串
print(str2)           # 打印整個字符串

注意，Python 沒有單獨的字符類型，一個字符就是長度為1的字符串。

與 C 字符串不同的是，Python 字符串不能被改變。向一個索引位置賦值，比如 word[0] = ‘m’ 會導致錯誤。

Python 字符串格式化 %

#!/usr/bin/python3print ("我叫 %s 今年 %d 歲!" % ('小明', 10))

f-string

f-string 是 python3.6 之后版本添加的，稱之為字面量格式化字符串，是新的格式化字符串的語法。

f-string 格式化字符串以 f 開頭，后面跟著字符串，字符串中的表達式用大括號 {} 包起來，它會將變量或表達式計算后的值替換進去，實例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替換變量
'Hello Runoob'
>>> f'{1+2}'         # 使用表達式
'3'>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

bool（布爾類型）

布爾類型只有兩個值：True 和 False。

• bool 是 int 的子類，因此布爾值可以被看作整數來使用，其中 True 等價于 1。
• 布爾類型可以和其他數據類型進行比較，比如數字、字符串等。在比較時，Python 會將 True 視為 1，False 視為 0。
• 可以使用 bool() 函數將其他類型的值轉換為布爾值。以下值在轉換為布爾值時為 False：None、False、零 (0、0.0、0j)、空序列（如 ‘’、()、[]）和空映射（如 {}）。其他所有值轉換為布爾值時均為 True。

注意: 在 Python 中，所有非零的數字和非空的字符串、列表、元組等數據類型都被視為 True，只有 0、空字符串、空列表、空元組等被視為 False

x = 10
if x:print("x is non-zero and thus True in a boolean context")

List（列表）

List（列表） 是 Python 中使用最頻繁的數據類型。

列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
列表截取的語法格式 : 變量[頭下標:尾下標]
加號 + 是列表連接運算符，星號 * 是重復操作。
與Python字符串不一樣的是，列表中的元素是可以改變的

list = ['Google', 'Runoob', 1997, 2000]print ("第三個元素為 : ", list[2])
list[2] = 2001
print ("更新后的第三個元素為 : ", list[2])list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)del list[2]
print ("刪除第三個元素 : ", list)

嵌套列表

使用嵌套列表即在列表里創建其它列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

Tuple（元組）

元組（tuple）與列表類似，不同之處在于元組的元素不能修改。元組寫在小括號 () 里，元素之間用逗號隔開。元組中的元素類型也可以不相同

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = ()    # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號

如果你想創建只有一個元素的元組，需要注意在元素后面添加一個逗號，以區分它是一個元組而不是一個普通的值，這是因為在沒有逗號的情況下，Python會將括號解釋為數學運算中的括號，而不是元組的表示。

如果不添加逗號，如下所示，它將被解釋為一個普通的值而不是元組：

not_a_tuple = (42)

這樣的話，not_a_tuple 將是整數類型而不是元組類型。

Set集合

Python 中的集合（Set）是一種無序、可變的數據類型，用于存儲唯一的元素。
集合中的元素不會重復，并且可以進行交集、并集、差集等常見的集合操作。

在 Python 中，集合使用大括號 {} 表示，元素之間用逗號 , 分隔。另外，也可以使用 set() 函數創建集合。

注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。

parame = {value01,value02,…}
或者
set(value)
a = set(‘abracadabra’)
b= set(‘alacazam’)

print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同時存在的元素

Dictionary（字典）

列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合。
鍵(key)必須使用不可變類型。

在同一個字典中，鍵(key)必須是唯一的。

構造函數 dict() 可以直接從鍵值對序列中構建字典如下：

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}
{x: x**2 for x in (2, 4, 6)}
>>> {2: 4, 4: 16, 6: 36}
dict(Runoob=1, Google=2, Taobao=3)
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}del tinydict['Name']  # 刪除鍵 'Name'
print(len(tinydict))tinydict.clear()  # 清空字典
del tinydict  # 刪除字典之后再使用tinydict 會報錯

運算符

在 Python 3.8 及更高版本中，引入了一種新的語法特性，稱為"海象運算符"（Walrus Operator），它使用 := 符號。這個運算符的主要目的是在表達式中同時進行賦值和返回賦值的值。

使用海象運算符可以在一些情況下簡化代碼，尤其是在需要在表達式中使用賦值結果的情況下。這對于簡化循環條件或表達式中的重復計算很有用。

# 傳統寫法
n = 10
if n > 5:print(n)# 使用海象運算符
if (n := 10) > 5:print(n)

• Python邏輯運算符 and /or/not
• Python還支持成員運算符 in/not in，可以用于判斷字符串中是否包含給定的字符
• Python身份運算符 用于比較兩個對象的存儲單元 is/is not
  is 是判斷兩個標識符是不是引用自一個對象 x is y, 類似 id(x) == id(y) , 如果引用的是同一個對象則返回 True

is 與 == 區別：
is 用于判斷兩個變量引用對象是否為同一個， == 用于判斷引用變量的值是否相等。

python條件控制/循環

if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3

match subject:case <pattern_1>:<action_1>case <pattern_2>:<action_2>case <pattern_3>:<action_3>case _:<action_wildcard> (默認case)#一個 case 也可以設置多個匹配條件，條件使用 ｜ 隔開，例如：
...case 401|403|404:return "Not allowed"

n = 100 
sum = 0
counter = 1
while counter <= n:sum = sum + countercounter += 1
print("1 到 %d 之和為: %d" % (n,sum))

Python 中沒有 do…while 循環。

while 循環使用 else 語句

如果 while 后面的條件語句為 false 時，則當循環執行完畢（即遍歷完 iterable 中的所有元素）后，會執行 else 子句中的代碼，如果在循環過程中遇到了 break 語句，則會中斷循環，此時不會執行 else 子句。

語法格式如下：

while <expr>:<statement(s)>
else:<additional_statement(s)>

在 Python 中，for…else 語句用于在循環結束后執行一段代碼。

for <variable> in <sequence>:<statements>
else:<statements>

pass 語句

Python pass是空語句，是為了保持程序結構的完整性。

pass 不做任何事情，一般用做占位語句，如下實例

while True:
...     pass  # 等待鍵盤中斷 (Ctrl+C)

end 關鍵字

關鍵字end可以用于將結果輸出到同一行，或者在輸出的末尾添加不同的字符，實例如下：

# Fibonacci series: 斐波納契數列
# 兩個元素的總和確定了下一個數
a, b = 0, 1
while b < 1000:print(b, end=',')a, b = b, a+b

Python 推導式

Python 推導式是一種獨特的數據處理方式，可以從一個數據序列構建另一個新的數據序列的結構體。
Python 推導式是一種強大且簡潔的語法，適用于生成列表、字典、集合和生成器。
在使用推導式時，需要注意可讀性，盡量保持表達式簡潔，以免影響代碼的可讀性和可維護性。
Python 支持各種數據結構的推導式：
列表(list)推導式

表達式 for 變量 in 列表] 
[out_exp_res for out_exp in input_list]或者 [表達式 for 變量 in 列表 if 條件]
[out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表達式，可以是有返回值的函數。
• for out_exp in input_list：迭代 input_list 將 out_exp 傳入到 out_exp_res 表達式中。
• if condition：條件語句，可以過濾列表中不符合條件的值

字典(dict)推導式

{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

集合(set)推導式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

元組(tuple)推導式
元組推導式和列表推導式的用法也完全相同，只是元組推導式是用 () 圓括號將各部分括起來，而列表推導式用的是中括號 []，另外元組推導式返回的結果是一個生成器對象。

a = (x for x in range(1,10))
print(a)
b=tuple(a)       # 使用 tuple() 函數，可以直接將生成器對象轉換成元組
print(b)

Python函數定義

Python 定義函數使用 def 關鍵字，一般格式如下：

def 函數名（參數列表）:函數體

在 python 中，類型屬于對象，對象有不同類型的區分，變量是沒有類型的：
[1,2,3] 是 List 類型，“Runoob” 是 String 類型，而變量 a 是沒有類型，它僅僅是一個對象的引用（一個指針），可以是指向 List 類型對象，也可以是指向 String 類型對象。

可更改(mutable)與不可更改(immutable)對象
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象

Python 函數的參數傳遞：

不可變類型：類似 C++ 的值傳遞，如整數、字符串、元組。如 fun(a)，傳遞的只是 a 的值，沒有影響 a 對象本身。如果在 fun(a) 內部修改 a 的值，則是新生成一個 a 的對象。

可變類型：類似 C++ 的引用傳遞，如 列表，字典。如 fun(la)，則是將 la 真正的傳過去，修改后 fun 外部的 la 也會受影響

python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。

參數

以下是調用函數時可使用的正式參數類型：

• 必需參數 必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣
• 關鍵字參數 關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。
  使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

#可寫函數說明
def printinfo( name, age ):"打印任何傳入的字符串"print ("名字: ", name)print ("年齡: ", age)return#調用printinfo函數
printinfo( age=50, name="runoob" )

• 默認參數 調用函數時，如果沒有傳遞參數，則會使用默認參數。以下實例中如果沒有傳入 age 參數，則使用默認值：

def printinfo( name, age = 35 ):"打印任何傳入的字符串"print ("名字: ", name)print ("年齡: ", age)return

• 不定長參數

def functionname([formal_args,] *var_args_tuple ):"函數_文檔字符串"function_suitereturn [expression]

加了星號 * 的參數會以元組(tuple)的形式導入，存放所有未命名的變量參數。

# 可寫函數說明
def printinfo( arg1, *vartuple ):"打印任何傳入的參數"print ("輸出: ")print (arg1)print (vartuple)# 調用printinfo 函數
printinfo( 70, 60, 50 )

如果在函數調用時沒有指定參數，它就是一個空元組。我們也可以不向函數傳遞未命名的變量。如下實例：

# 可寫函數說明
def printinfo( arg1, *vartuple ):"打印任何傳入的參數"print ("輸出: ")print (arg1)for var in vartuple:print (var)return# 調用printinfo 函數
printinfo( 10 )
printinfo( 70, 60, 50 )

加了兩個星號 ** 的參數會以字典的形式導入