python標識符
- 以下劃線開頭的標識符是有特殊意義的。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 而導入。
- 以雙下劃線開頭的 __foo 代表類的私有成員，以雙下劃線開頭和結尾的 foo 代表 Python 裏特殊方法專用的標識，如
init() 代表類的構造函數。
數字
- Python的除法（"/"）總是返回一個float浮點型的數字
ret = 10 / 5
print(ret) # 打印值爲2.0
- 做 floor 除法 並且得到一個整數結果(返回商的整數部分) 可以使用 // 運算符
print(17 / 3) # 打印結果小數：5.666666666666667
print(17 // 3) # 打印結果整數：5
- 使用**做n次方運算
print(5 ** 2) # 5的2次方，打印結果：25
print(2 ** 8) # 2的8次方，打印結果：256
行和縮進
- 學習 Python 與其他語言最大的區別就是，Python 的代碼塊不使用大括號 {} 來控制類，函數以及其他邏輯判斷。python 最具特色的就是用縮進來寫模塊。
- 縮進的空白數量是可變的，但是所有代碼塊語句必須包含相同的縮進空白數量，這個必須嚴格執行。同一個基本塊內的每一行必須按相同的量縮進。如下所示：
if True:
print "True"
else:
print "False"
以下代碼將提示錯誤：
if True:
print "Answer"
print "True"
else:
print "Answer"
# 沒有嚴格縮進，在執行時會報錯
print "False"
多行語句
- Python語句中一般以新行作爲語句的結束符。但是我們可以使用斜槓（ \）將一行的語句分爲多行顯示，如下所示：
total = item_one + \
item_two + \
item_three
python註釋
- python中單行註釋採用#開頭
- python中多行註釋使用三個單引號或多個多引號，所示如下：
"""
這是多行註釋，使用雙引號。
這是多行註釋，使用雙引號。
這是多行註釋，使用雙引號。
"""
輸入函數
- python3的輸入函數只有input()，所示如下：
name = input("請輸入學生姓名：")
print(name)
print輸出
- print默認輸出是換行的，如果實現不換行需要在變量末尾加上逗號。
x = "a"
y = "b"
# 換行輸出
print(a)
print(b)
# 不換行輸出
print(x,y)
字符串
- 字符串可以被括在單引號(’…’)或者雙引號("…")中。字符串中的特殊字符用反斜槓()轉義
name = 'python'
language = "python"
- 不想讓 \ 被解釋爲特殊字符開頭的字符，您可以通過添加 r 使用 原始字符串
print('C:\some\name') # here \n means newline!
# 輸出結果：C:\some
ame
print(r'C:\some\name') # note the r before the quote!
# 輸出結果：C:\some\name
- 字符串可以用+操作符連接，也可用*操作符重複多次。
- 字符串可以索引，第一個字符的索引值爲0.python沒有字符類型，一個字符就是一個長度爲1的字符串。索引可以是負數，此時從右側開始計數。
- 除了索引，還支持切片。索引用於獲得單個字符，切片用於獲得子字符串（開始索引總包括在內，結束索引總排除在外）。切片索引具有非常有用的默認值;省略的第一個索引默認爲零，省略第二個索引默認爲切片字符串的長度。
str = 3 * 'un' + 'mmm'
print(str); # 輸出：unununmmm
print(str[0]) # 輸出：u
print(str[-1]) # 輸出str字符串的最後一個字符：m
# 切片
print(str[0:2]) # 輸出子串：un
word = "Python"
print(word[0:2]) # 獲取位置0（包括）到位置2（不包括）的字符串 打印結果：Py
print(word[:2] + word[2:]) #省略的第一個索引默認爲零，省略第二個索引默認爲切片字符串的長度。打印結果： Python
列表
- Python 有幾個 複合 數據類型，用來組合其他的值。最有用的是 列表，可以寫成中括號中的一列用逗號分隔的值。列表可以包含不同類型的元素，但是通常一個列表中的所有元素都擁有相同的類型。
- 與字符串 （和所有其他內置 序列 類型）相似，列表可以被索引和切片︰
squares = [1, 4, 9, 16, 25]
print(squares) # 打印結果：[1, 4, 9, 16, 25]
print(squares[0]) # 打印結果：1
print(squares[-1]) # 打印結果：25
print(squares[-3:]) # 打印結果：[9, 16, 25]
- 列表支持用"+"連接兩個列表。與字符串的不可變特性不同，列表是可變的類型。
- 列表可以嵌套 （創建包含其他列表的列表），例如：
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x) # 打印結果：[['a', 'b', 'c'], [1, 2, 3]]
print(x[0]) # 打印結果：['a', 'b', 'c']
print(x[0][1]) # 打印結果：b
一個賦值符號（"="）給多個變量賦值
- 示例：
a, b = 0, 1 # 變量 a 和 b 同時獲得新值 0 和 1
while b < 10:
print(b)
a, b = b, a+b # 等號右邊的表達式在賦值之前首先被完全解析 首次進入循環體時：a,b = b, a+b --解析--> a,b = 1, 0+1
if語句
- 可以有0個或多個 elif 塊,，並且 else 塊是可選的。
x = int(input("Please enter an integer: "))
if x < 0:
x = 0
print('Negative changed to zero')
elif x == 0:
print('Zero')
elif x == 1:
print('Single')
else:
print('More')
for語句
- Python 的 for 語句可以按照元素出現的順序迭代任何序列（列表或字符串）。
words = ['cat', 'window', 'defenestrate']
for w in words:
print(w, len(w)) # len()爲內置函數
# 打印結果
cat 3
window 6
defenestrate 12
range()函數
- 如果需要遍歷一個數字序列，內置函數 range() 會派上用場。它生成算術級數：
for i in range(8):
print(i) # 打印結果：0 1 2 3 4 5 6 7
for i in range(2,10)
print(i) # 打印結果：2 3 4 5 6 7 8 9 即，計數器2 <= i < 10,計數器i每次都是用 i + 1與 10比較大小，若小於10則i = i + 1,否則不執行賦值語句。
break和continue語句，以及循環中else子句
- break語句和 C 中的類似，用於跳出最近的 for 或 while 循環。循環語句可以有一個 else 子句;當（for）循環迭代完整個列表或（while）循環條件變爲假，而非由break語句終止時，就會執行這個else語句。下面循環搜索質數的代碼例示了這一點：
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else: # else 子句屬於 for 循環，而不是 和if 語句配對
# loop fell through without finding a factor
print(n, 'is a prime number')
pass語句
- pass 語句什麼也不做。當語法上需要語句但程序不需要動作時，可以使用它。
定義函數
def fib(n): # return Fibonacci series up to n
"""Return a list containing the Fibonacci series up to n."""
result = []
a, b = 0, 1
while a < n:
result.append(a) # result = result + [a]，但是它更高效
a, b = b, a+b
return result
# 默認參數值的函數
def ask_ok(prompt, retries=4, reminder='Please try again!'):
while True:
ok = input(prompt)
if ok in ('y', 'ye', 'yes'):
return True
if ok in ('n', 'no', 'nop', 'nope'):
return False
retries = retries - 1
if retries < 0:
raise ValueError('invalid user response')
print(reminder)
// 重要的警告︰默認值只初始化一次。當默認值是一個可變對象（如列表，字典或大多數類的實例）時，默認值會不同。例如，下面的函數在後續調用過程中會累積傳給它的參數：
def f(a, L=[]):
L.append(a)
return L
print(f(1)) # 打印結果：[1]
print(f(2)) # 打印結果：[1,2]
print(f(3)) # 打印結果：[1,2,3]
// 如果你不想默認值在隨後的調用中共享，可以像這樣編寫函數：
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
# 關鍵字參數
def func(a, b = 5, c = 8)
pass
func(3, 7) # a = 3, b = 7, c = 8
func(25, c = 24) # a = 25, b = 5, c = 8
func(c = 50, a = 100) # a = 100, b = 5, c = 50
# 可變參數
//想定義的函數裏面能夠有任意數量的變量，也就是參數數量是可變的，這可以通過使用星號來實現
def total(a=5, *numbers, **phonebook): #當我們聲明一個諸如 *param 的星號參數時，從此處開始直到結束的所有位置參數（Positional Arguments）都將被收集並彙集成一個稱爲“param”的元組（Tuple）。類似地，當我們聲明一個諸如 **param 的雙星號參數時，從此處開始直至結束的所有關鍵字參數都將被收集並彙集成一個名爲 param 的字典（Dictionary）。
print('a', a)
#遍歷元組中的所有項目
for single_item in numbers:
print('single_item', single_item)
#遍歷字典中的所有項目
for first_part, second_part in phonebook.items():
print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))
// 輸出結果如下：
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None
關鍵字 def 引入函數的定義。其後必須跟有函數名和以括號標明的形式參數列表。組成函數體的語句從下一行開始，且必須縮進。
函數體的第一行可以是一個可選的字符串文本；此字符串是該函數的文檔字符串，或稱爲docstring。有工具使用 docstrings 自動生成在線的或可打印的文檔，或者讓用戶在代碼中交互瀏覽；在編寫的代碼中包含 docstrings 是很好的做法。
數據結構
- 列表
列表 是一種用於保存一系列有序項目的集合，也就是說，你可以利用列表保存一串項目的序列。項目的列表應該用方括號括起來，這樣 Python 才能理解到你正在指定一張列表。一旦你創建了一張列表，你可以添加、移除或搜索列表中的項目。既然我們可以添加或刪除項目，我們會說列表是一種可變的（Mutable）數據類型，意即，這種類型是可以被改變的。示例：shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] // shoplist爲列表類型 - 元組
元組（Tuple）用於將多個對象保存到一起。你可以將它們近似地看作列表，但是元組不能提供列表類能夠提供給你的廣泛的功能。元組的一大特徵類似於字符串，它們是不可變的，也就是說，你不能編輯或更改元組。元組是通過特別指定項目來定義的，在指定項目時，你可以給它們加上括號，並在括號內部用逗號進行分隔。元組通常用於保證某一語句或某一用戶定義的函數可以安全地採用一組數值，意即元組內的數值不會改變。singleton = (2,) 此爲包含一個項目的元組的寫法。示例：zoo = (‘python’, ‘elephant’, ‘penguin’) // zoo爲元組類型 - 字典
字典就像一本地址簿，如果你知道了他或她的姓名，你就可以在這裏找到其地址或是能夠聯繫上對方的更多詳細信息，換言之，我們將鍵值（Keys）（即姓名）與（Values）（即地址等詳細信息）聯立到一起。在這裏要注意到鍵值必須是唯一的，正如在現實中面對兩個完全同名的人你沒辦法找出有關他們的正確信息。另外要注意的是你只能使用不可變的對象（如字符串）作爲字典的鍵值，但是你可以使用可變或不可變的對象作爲字典中的值。基本上這段話也可以翻譯爲你只能使用簡單對象作爲鍵值。在字典中，你可以通過使用符號構成 d = {key : value1 , key2 : value2} 這樣的形式，來成對地指定鍵值與值。在這裏要注意到成對的鍵值與值之間使用冒號分隔，而每一對鍵值與值則使用逗號進行區分，它們全都由一對花括號括起。 - 集合
集合（Set）是簡單對象的無序集合（Collection）。當集合中的項目存在與否比起次序或其出現次數更加重要時，我們就會使用集合。示例：bri = set([‘brazil’, ‘russia’, ‘india’]) - 序列
列表、元組和字符串可以看作序列（Sequence）的某種表現形式，列表、元組與字符串，同樣擁有一種切片（Slicing）運算符，它能夠允許我們序列中的某段切片——也就是序列之中的一部分。可以在切片操作中提供第三個參數，這一參數將被視爲切片的步長（Step）（在默認情況下，步長大小爲 1）
面向對象編程
self
- 類方法與普通函數只有一種特定的區別——前者必須多加一個參數在參數列表開頭，這個名字必須添加到參數列表的開頭，但是你不用在你調用這個功能時爲這個參數賦值，Python 會爲它提供。這種特定的變量引用的是對象本身，按照慣例，它被賦予 self 這一名稱。該self類似於Java中的this引用。
類
- 最簡單的類（Class）可以通過下面的案例來展示：
class Person:
pass # 一個空的代碼塊
p = Person() # 實例化對象
print(p)
__init__ 方法
- _init_ 方法是Python類中的構造函數，在對象被實例化時由系統調用。在下例中，population 屬於 Person 類，因此它是一個類變量。name 變量屬於一個對象（通過使用 self 分配），因此它是一個對象變量。
class Person:
# 這是一個類變量
population = 0
# name變量是一個對象變量，通過self分配，不同於Java不需要在類定義時先聲明對象變量。
def __init__(self, name):
self.name = name
# 靜態方法
@classmethod
def how_many(cls):
print("{} persons".format(cls.population))
p = Person("czy")
print(p)
類中屬性的私有化
- 使用數據成員並在其名字中使用雙下劃線作爲前綴，形成諸如 __privatevar 這樣的形式，Python 會使用名稱調整（Name-mangling）來使其有效地成爲一個私有變量。
繼承
class SchoolMember:
'''代表任何學校裏的成員。'''
def __init__(self, name, age):
self.name = name
self.age = age
print('(Initialized SchoolMember: {})'.format(self.name))
def tell(self):
'''告訴我有關我的細節。'''
print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")
class Teacher(SchoolMember):
'''代表一位老師。'''
def __init__(self, name, age, salary):
SchoolMember.__init__(self, name, age)
self.salary = salary
print('(Initialized Teacher: {})'.format(self.name))
def tell(self):
SchoolMember.tell(self)
print('Salary: "{:d}"'.format(self.salary))
class Student(SchoolMember):
'''代表一位學生。'''
def __init__(self, name, age, marks):
SchoolMember.__init__(self, name, age)
self.marks = marks
print('(Initialized Student: {})'.format(self.name))
def tell(self):
SchoolMember.tell(self)
print('Marks: "{:d}"'.format(self.marks))
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)
# 打印一行空白行
print()
members = [t, s]
for member in members:
# 對全體師生工作
member.tell()
- 由上式看出，使用繼承，在定義類時我們需要在類後面跟一個包含基類名稱的元組。
- 在 Teacher 和 Student 子類中定義了 init 方法，Python 不會自動調用基類 SchoolMember 的構造函數，你必須自己顯式地調用它。相反，如果我們沒有在一個子類中定義一個 init 方法，Python 將會自動調用基類的構造函數。
- Python支持多繼承
Pickle，持久化存儲對象
- Python 提供了一個叫作 Pickle 的標準模塊，通過它你可以將任何純 Python 對象存儲到一個文件中，並在稍後將其取回。這叫作持久地（Persistently）存儲對象。
import pickle
# 我們存儲相關對象的文件的名稱
shoplistfile = 'shoplist.data'
# 需要購買的物品清單
shoplist = ['apple', 'mango', 'carrot']
# 準備寫入文件
f = open(shoplistfile, 'wb')
# 轉儲對象至文件
pickle.dump(shoplist, f) # 調用dump函數，這被叫做封裝
f.close()
# 清除 shoplist 變量
del shoplist
# 重新打開存儲文件
f = open(shoplistfile, 'rb')
# 從文件中載入對象
storedlist = pickle.load(f) #load函數，接收返回的對象，這被叫做拆封
print(storedlist)
assert語句
- assert 語句用以斷言（Assert）某事是真的。例如說你非常確定你正在使用的列表中至少包含一個元素，並想確認這一點，如果其不是真的，就拋出一個錯誤，assert 語句就是這種情況下的理想選擇。當語句斷言失敗時，將會拋出 AssertionError。
Python入門書籍參考資料