1.1 python程序的構成
python程序可以分解為模塊、語句、表達式和對象。從概念上理解，其對應關系如下。
(1)python程序是由模塊組成，模塊對應的擴展名是.py的源文件。一個python程序由一個或者多個模塊組成的。
(2) 模塊由語句組成。模塊即python源文件。在執行python程序時按照依次執行模塊中的語句
(3)語句是python程序的過程構造塊，在創建對象、構造函數、變量賦值、調用函數、控制分支、創建循環、增加注解等。
(4)表達式用於創建和處理對象。
# 假設已知三角形三條邊a,b,c，求三角形的面積（s.py)。三角形的面積公式：s=sqrt(h*(h-a)*(h-b)*(h-c)),其中h表示三角形的周長
import math # 導入內置模塊math和定義的源文件s.py
a=3.0 # 變量賦值語句
b=4.0
c=5.0
h=(a+b+c)/2
s=math.sqrt(h*(h-a)*(h-b)*(h-c))
# 表達式語句，將表達式右邊的運算結果為一個新的float類對象，math.sqrt調用math模塊中的sqrt()函數，計算參數對象的平方根
print(s) # 調用函數表達式的語句
1.2 python對象和引用
1.2.1 python對象概述
計算機程序通常用於處理各種類型的數據（即對象），高級語言（java、python、JavaScript、go、c++)都是面向對象的語言，不同的數據屬於不同的數據類型，支持不同類型的運算操作。在python語言中，數據表示對象。對象的本質上是一個內存塊，擁有特定的值，支持特定類型的運算操作。
在python3中，一切皆對象。python語言中的每個對象由標識（identity）、類型（type）和值（value）標識。
（1)標識用於唯一地標識一個對象，通常對應對象在計算機內存中的位置。使用內置函數id(value)可以返回對象object的標識
（2）類型用於標識所屬的數據類型，數據類型用於限定對象的取值范圍以及允許執行的處理操作。使用內置函數type（object）可以返回對象object所屬的數據類型
（3）值用於表示對象的數據類型的值。使用內置函數print(object)可以返回對象object的值
通過內置的type()函數可以判斷一個對象的類型。通過內置的id()函數可以獲取一個對象唯一的id表示。也就是說對象三要素：要有內置的type()函數、內置的id()函數、打印它的值
# 用IDLE打開執行
123 # 輸出：123
id(123) # 輸出：2444759357616 是指這個數的id地址，該數據存儲在每個電腦的id是不一樣的
type(123) # 輸出：<class'int'>
print(123) # 輸出：123
# 函數和類也是對象，所以也有相應的類型和id
type(abs) # 輸出：<class 'builtin_function_or_method'>
id(abs) # 輸出：1708666055712
1.2.2 創建實例對象
python的數據類型定義了一個值的集合，在python代碼中使用字面量表示某個數據類型的值。
# 用字面量創建實例對象
12、101 # 表示int數據類型的值
0.17、3.14 # 表示float數據類型的值
True # 表示bool數據類型的值（False、True)
'hello' # 表示str數據類型的值
# 類對象創建實例對象
int(12) # 輸出：12
complex(1,2) # 輸出：1+2*j
1.2.3 數據類型
python的數據類型有整數數據類型（int）、浮點數據類型（float）、布爾數據類型（bool）、字符串數據類型（str)、列表（list)、元組（tuple)、字典（dictionary)、集合（set)。
1.2.4 變量和引用
python對象是位於計算機內存的一個內存中的一個內存數據塊。為了引用對象，用戶必須通過賦值語句把對象賦值給對。指向對象的引用即變量。
a=1 # 字面量表達式創建值為1的int類型實例對象，並綁定到變量a
b=2 # 字面量表達式創建值為2的int類型實例對象，並綁定到變量b
c-a+b # 表達式a+b創建值為3的int類型實例對象，並綁定到變量c
字面量用於創建之為字面量的對象，即某個數據類型的實例對象；表達式使用運算符實例實現多個操作數（對象）的運算操作，並返回結果對象。用戶可以把對象通過賦值語句賦值給一個變量，即把對象綁定到一個變量。
值得一說的是python是動態類型語言，也就是變量不需要聲明數據類型，只需要根據變量的賦值，python會自動的確定其數據類型（JavaScript也是如此）。同時，python是一門強類型的語言，每個變量指向的對象均屬於某個數據類型，即只支持該數據類型的運算操作。不同的數據類型是不可以進行運算操作。
a=1
b=2
c=a+b # 兩個變量都是int類型，之間可以相互轉換
d='2'+a # 前者是字符串類型，后者是int類型，之間不可以相互轉換，會報錯
1.2.5 對象的內存示意圖
python程序運行時會在內存中創建各種對象（位於堆內存中），通過賦值語句可以將對象綁定到變量（位於棧內存中），從而通過變量引用對象進行各種操作。多個變量可以引用同一個對象。如果一個對象不在被任何有效有效作用域中的變量引用，則會通過自動垃圾回收機制收回對該對象占用的內存。
對象=確定內存空間（堆內存）+存儲在這塊內存空間的值（棧內存）
# 交換兩個變量的示例以及相應的對象的示意圖
a=123 # a指向值為123的int型實例對象
b=456 # b指向值為456的int型實例對象
t=a # 變量t和a一樣，指向（引用）對象實例123
a=b # 變量a和b一樣，指向（引用）對象實例456
b=t # 變量b和t一樣，指向（引用）對象實例123
1.2.6 對象的值比較和引用的判定
通過 == 運算符可以判斷兩個變量指向對象的值是否相同；通過 is 運算符可以判斷兩個變量是否指向同一個對象,即兩個id是否相同
x='abc' # x指向值為'abc'的字符串類型對象
y='abc' # y指向值為'abc'的字符串類型對象
x==y # 輸出：true
x is y # 輸出：true
# == 相同，id不同的情況
x=[1,2,3] # x指向值為[1,2,3]的列表類型對象
y=[1,2,3] # y指向值為[1,2,3]的列表類型對象
x==y # 輸出：true 兩個變量指向對象的值都是[1,2,3]
x is y # 輸出：false 兩個變量分配的內存地址不一樣，id不一樣
1.2.7 可變對象和不可對象
python3對象可以分為不可變對象和可變對象。
不可變對象一旦創建，其值不能被修改，如果對原對象進行修改，就需要申請一片新的內存空間進行存儲新的值，因為原來的內存地址是不可修改的，新的內存地址存儲新對象；可變對象的值可以被修改，原對象可以在原內存地址上進行修改，無需創建一片新的內存地址。
不可變對象：整型（int)、浮點型（float）、復數（complex），布爾（bool）、字符串（str）、元組（tuple）
可變對象：列表（list)、字典（dict)、集合（set)
# 不可變對象
a=1 # a指向值為1的整數（int）數據類型對象
id(a) # a的內存地址(id)為 1833444075824
b=1 # b指向值為1的整數（int）數據類型對象
id(b) # b的內存地址(id)為 1833444075824
a=a+1 # 變量a加1后，將表達式的值重新賦值給變量a
id(a) # a的內存地址(id)為 1716666067280 ，原來a=1的內存地址不再被使用，自動回收原先內存地址
# 可變對象
c=[1,2,3] # c指向值為[1,2,3]的列表(list)類型對象
id(c) # c的內存地址(id)為 1716674412864
d=[1,2,3] # d指向值為[1,2,3]的列表(list)類型對象
id(d) # d的內存地址(id)為 1716674413248 和變量c的id不一樣
c.append(4) # 變量c添加一個元素4
id(c) # c的內存地址(id)為 1716674412864
通俗的說：不可變是指a的內存地址不能發生改變，內存地址為 1833444075824 的值在沒有被垃圾回收之前一直都是1（b的值和a一樣，所以b的內存地址和a一樣），不能改變。當a的值發生改變（對原變量進行操作后），變量a將開辟一個新的內存地址為 1716666067280，而這個內存地址的值為2。原來a=1的值和內存地址將被python的垃圾回收機制給自動回收。
可變是指在進行創建時兩個列表時，雖然兩個列表的值相同，但是內存地址並不相同，實則兩個列表開辟了兩個內存地址，具有同樣值的對象是不同的對象，即在內存中保存了多個同樣值的對象，地址值不同。在對變量c進行操作的時候（增加一個元素4）時，列表的內存地址並沒有發生改變，只是修改了變量c的值。
1.3 標識符及其命名規則
1.3.1標識符
標識符是變量、函數、類、模塊和其他對象的名稱。標識符的第一個字符必須是字母、下划線('_'),其后的字符可以是字母、下划線或數字，python的標識符是區分大小寫的。一些特殊的名稱，例如，if、for等作為python語言的保留關鍵字，不能作為標識符。
a_int、a_float、str1、func1 # 都是正確的變量名
99var、for、it's ok # 錯誤的變量名
# 避免使用雙下划線開始和結尾的名稱，__init__具有特殊意義
# 避免使用python預定義標識符作為自定義標識符名，如：dict、int、float等具有特殊意義的標識符
python3中的保留字
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not
python命名規則
| 類型 | 命名規則 | 舉例 |
|---|---|---|
| 模塊/包名 | 全小寫字母、簡單、有意義、如果需要可以使用下划線 | math、sys |
| 函數名 | 全小寫字母，可以使用下划線增加閱讀性 | foo()、my_foo() |
| 變量名 | 全小寫字母，可以使用下划線增加閱讀性 | age、my_var |
| 類名 | 駝峰命名法。多個單詞組成名稱，每個單詞除第一個字母大寫外其他字母均小寫 | MyClass |
| 常量名 | 全大寫字母，可以使用下划線增加閱讀性 | LEFT |
1.3.2 變量和賦值語句
計算機程序通常用於處理各種類型的數據（即對象），不同的數據屬於不同的數據類型，支持不同的運算操作。計算機程序處理的數據必須要放在內存中，通過訪問這些數據的內存地址來訪問這些數據。
對象：是某個類（類型）的實例，對象由唯一的id標識。
變量：對象可以通過標識符來引用，對象引用即指向具體對象實例的標識符。
變量的聲明和賦值用於把一個變量綁定到某個對象
（1）變量名=字面量或表達式
x=0;y=0;z=0 # 變量x、y和z均指向int對象0
str1='abc' # 變量str1指向值為'abc'的str類實例對象
a # 報錯，變量a未聲明和定義
（2）鏈式賦值語句 變量1=變量2=表達式，鏈式賦值用於多個變量賦同一個值
x=y=123 # 變量x和y均指向int對象123
x # 輸出：123
y # 輸出：123
（3）復合賦值語句(最常用)
| 運算符 | 含義 | 舉例 | 等效於 |
|---|---|---|---|
| += | 加法賦值 | sum+=1 | sum=sum+1 |
| 字符串拼接 | s+='foo' | s=s+'foo' | |
| -= | 減法賦值 | count-=1 | count=count-1 |
| *= | 乘法賦值 | x*=y+5 | x=x*(y+5) |
| /= | 除法賦值 | x/=y-3 | x=x/(y-3) |
| //= | 整除賦值 | x//=2 | x=x//2 |
| %= | 取模賦值 | x%=2 | x=x%2 |
| **= | 冪賦值 | x**=2 | x=x**2 |
| <<= | 左移賦值 | x<<=y | x=x<<y |
| >>= | 右移賦值 | x>>=y | x=x>>y |
| &= | 按位與賦值 | x&=y | x=x&y |
| |= | 按位或賦值 | x |=y | x=x|y |
| ^= | 按位異或賦值 | x^=y | x=x^y |
python后面幾個賦值與JavaScript的語法相似 見JavaScript語法 第三章 - 食屍之鬼 - 博客園 (cnblogs.com)
i=1 # 變量i指向int對象1
i+=1 # 先計算表達式i+1的值，然后創建一個值為2的int對象，並綁定到變量i
i # 輸出：2
i*=3 # 先計算表達式i*的值，然后創建一個值為6的int對象，並綁定到變量i
i # 輸出：6
（4）序列解包賦值 將序列數據類型解包為對應相同個數的變量
a,b=1,2 # 變量a指向int對象1，變量b指向int對象2
a # 輸出：1
b # 輸出：2
# 如果只解包部分值，則可以采用特殊變量'_'
*_,a,_=['123','345','456','678'] # '*'表示不確定的前面省略多少個，'_'表示省略的內容
a # 輸出：'456'，前面由*_表示前面所有的值進行省略，a在倒數第二個位置（a,_),最后一個數省略，所以a為'456'
1.3.3 刪除變量和常量
刪除變量 使用del語句刪除不在使用的變量
x=1 # 變量x指向int對象1
del x # 刪除變量x
x # 報錯：變量x未聲明和定義
常量 使用約定，全大寫字母（可以使用下划線增加閱讀性)表示常量名
PI = 3.14 # 浮點類型常量PI
E = 2.8 # 浮點類型常量E
1.4 表達式和運算符
1.4.1 表達式的組成
表達式是可以計算的代碼判斷，由操作數和運算符構成。操作數、運算符和圓括號按照一定的規則組成表達式。表達式通過運算后產生運算結果，返回結果對象。運算結果對象的類型由操作數和運算符共同決定。運算符包括+、-、*、/等。操作數包括文本常數（沒有名稱的常數值，例如'abc'，1）、變量（i=123）、類的成員變量/函數（math.pi)等，也可以包含子表達式。
import math # 導入math模塊
a,b=2,10 # 用序列解包賦值法，變量a指向int對象1，變量b指向int對象2
a+b # 輸出：12 表達式操作
1.4.2 表達式的書寫規則
python表達式遵守下列書寫規則：
（1）表達式從左到右在同一個基准上書寫，例如：數學公式 a的平方加b的平方應寫成 a ** 2+b ** 2
（2）乘號不能省略。例如,數學公式ab（表示a乘以b）應寫為a*b
（3）括號要成雙出現，而且只能使用圓括號，圓括號可以嵌套使用
# 例如 數學表達式：1/2*sin[(a(x+1)+b)]寫成python
math.sin(a*(x+1)+b)/2
1.4.3 python 運算符
| 運算符 | 描述 |
|---|---|
| lambda | Lambda 匿名函數表達式 |
| or | 布爾“或” |
| and | 布爾“與” |
| not x | 布爾“非” |
| in、not in | 成員檢測，檢測前面一個的數據是否在后面數據類型的里 |
| is、not is | 同一性質檢測，檢測前面一個數據和后面一個數據是否相同 |
| <、<=、>、！= | 比較 |
| |、^、& | 按位或、按位異或、按位與 |
| <<、>> | 移位 |
1.5 python語句
1.5.1 python語句
語句是python程序的過程構造塊，用於定義函數、定義類、創建對象、變量賦值、調用函數、控制分支、創建循環等。python常用語句分為簡單語句和復合語句。
簡單語句：表達式語句、賦值語句、assert語句（斷言語句）、pass語句、del語句、return語句、yield語句、raise語句、break語句、continue語句、import語句、global語句、nonlocal語句
復雜語句：if語句、while語句、for語句、try語句、with語句、函數定義、類定義
# 輸入圓的半徑r，計算並輸出圓的周長和面積
import math # import語句，導入math模塊
r=float(input("請輸入圓的半徑")) # 賦值語句：輸入圓的半徑r，並轉換為float數據類型
p=2*r*math.pi # 賦值語句：計算圓的周長
s=r**2*math.pi # 賦值語句： 計算圓的面積
print('圓的周長',p) # 表達式語句：輸出圓的周長
print('圓的面積',s) # 表達式語句：輸出圓的面積
1.5.2 python語句的書寫規則
python語句的書寫規則：
（1）使用換行符分隔，在一般情況下一行一條語句
（2）從第一行開始，前面不能有任何空格，否則會產生語法錯誤
（3）反斜杠（ \ )用於一個代碼跨越多行的情況，如果語句太長，可以使用續行符（ \ ),同時三行引號定義的字符串(""".....""")可以放在多行，而不必使用續行符
（4）分號（；）用於在一行書寫多條語句
print(123) # 報錯：IndentationError: unexpected indent 前面有空格
print(123) # 輸出：123
print("你好\
世界") # 輸出：你好世界
print("""123
234
456""") # 輸出：123
# 234
# 456
a=0;b=0;c=0 # 變量a、b和c均指向int對象0
1.5.3 符合語句及其縮進書寫規則
由多行代碼組成的語句稱為復合語句。復合語句（條件語句、循環語句、函數定義和類定義）由頭部語句和構造題語句塊組成。構造體語句塊由一條或多條語句組成。復合語句和構造體語句塊的縮進書寫規則。
（1）頭部語句由相應的關鍵字（例如for)開始,，構造體語句塊則為下一行開始的一行或多行縮進代碼
sum=0
for i in range(1,11):
sum+=sum+i
print(i,end='') # 輸出：1 2 3 4 5 6 7 8 9 10
print(sum) # 輸出：55
（2）通常縮進是相對頭部語句縮進4個空格，也可以是任意空格，但同一構造體代碼塊的多條語句縮進的空格數是一致的。如果語句不縮進，或者縮進不一致，會導致編譯錯誤。
（3）如果條件語句、循環語句、函數定義和類定義比較短，可以放在同一行
for i in range(1,11): print(i,end='')
1.5.4 注釋語句和空語句
注釋語句
python注釋語句以符號' # '開始，到行末結束。python注釋語句可以出現在在任何位置。python解釋器將忽略所有的注釋語句，注釋語句不會影響程序的執行結果。良好的注釋可以幫助用戶閱讀和理解程序
# 打印'hello world!'
print('hello world!') # 輸出：hello world
空語句
如果要表示一個空的代碼塊，可以使用pass語句
def no_thing():
pass #定義一個函數no_thing，但函數體部分暫時還沒有完成，又不能空着不寫內容，因此可以用pass來替代占個位置
1.6 函數和模塊、類和對象
1.6.1 函數的創建和調用
python語言中包括許多內置的函數，例如print()、max()等，用戶也可以自定義函數。函數是可以重復調用的代碼塊，使用函數可以有效的組織代碼，有效的提高代碼重用率。
python使用復合語句def創建函數對象，其語法為
def 函數名[形參列表]：
函數體
函數名([實參列表])
# 創建函數時可以聲明函數的參數，即形式參數，簡稱形參；在調用函數時需要提供函數需要的參數的值，即實際參數，簡稱實參
# 函數可以使用return返回值。無返回值的函數相當於其他編譯語言中的過程
# 例如：
def sayHello(): # 創建函數對象sayHello
print('hello world!') # 函數體
sayHello() # 輸出：hello world！ 調用函數 sayHello()
1.6.2 函數API
python語言中提供了海量的內置函數、標准庫函數、第三方模塊函數、使用這些函數的關鍵是了解調用方法，函數的調用方法由應用程序編程接口(API)確定。
| 模塊 | 函數調用方法 | 功能描述 |
|---|---|---|
| 內置函數 | print(x) | 輸出x |
| abs(x) | x的絕對值 | |
| type(o) | o的類型 | |
| len(a) | a的長度 | |
| python標准庫math模塊中的函數 | math.sin(x) | x的正弦 |
| math.cos(x) | x的余弦 | |
| math.sqrt(x) | x的平方根 |
a='123'
type(a) # 返回對象a所屬的數據類型。輸出：<class 'str'>
len(a) # 返回字符串a的長度。輸出:3
#標准庫模塊調用
# 方法一
import math
math.sin(1) # 輸出：Π/2
# 方法二
from math import sin
sin(1) # 輸出：Π/2
1.6.3 創建類對象
class 類名：
類體 # 可以定義屬於類的屬性、方法（def函數）
# 基於類對象可以創建其實例對象，然后訪問其方法或屬性
an=類名（參數列表）
an.對象方法 或 an，對象屬性
# 例如
class Person(self): # 定義類Person
def sayHello(self): # 定義類Person的函數sayHello()
print('hello world!')
p=Person() # 創建對象
p.sayHello() # 調用對象的方法 輸出：hello world！