1.注釋
單行：#
多行：三個'單引號'或三個"雙引號"
'''
print("hello world")
'''
或
"""
print("hello world")
"""
2.編碼
python2 = assic = 不支持中文
文件中有中文，不管是否為注釋，python2執行報錯。
解決：程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*
python3 = unicode = 默認支持中文
3.模塊：
在計算機程序的開發過程中，隨着程序代碼越寫越多，在一個文件里代碼就會越來越長，越來越不容易維護。
為了編寫可維護的代碼，我們把很多函數分組，分別放到不同的文件里，這樣，每個文件包含的代碼就相對較少，很多編程語言都采用這種組織代碼的方式。在Python中，一個.py文件就稱之為一個模塊（Module）。
使用模塊有什么好處？
最大的好處是大大提高了代碼的可維護性。其次，編寫代碼不必從零開始。當一個模塊編寫完畢，就可以被其他地方引用。我們在編寫程序的時候，也經常引用其他模塊，包括Python內置的模塊和來自第三方的模塊。
使用模塊還可以避免函數名和變量名沖突。相同名字的函數和變量完全可以分別存在不同的模塊中，因此，我們自己在編寫模塊時，不必考慮名字會與其他模塊沖突。但是也要注意，盡量不要與內置函數名字沖突。點這里查看Python的所有內置函數。
你也許還想到，如果不同的人編寫的模塊名相同怎么辦？為了避免模塊名沖突，Python又引入了按目錄來組織模塊的方法，稱為包（Package）。
舉個例子，一個abc.py的文件就是一個名字叫abc的模塊，一個xyz.py的文件就是一個名字叫xyz的模塊。
現在，假設我們的abc和xyz這兩個模塊名字與其他模塊沖突了，於是我們可以通過包來組織模塊，避免沖突。方法是選擇一個頂層包名，比如mycompany，按照如下目錄存放：
mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py引入了包以后，只要頂層的包名不與別人沖突，那所有模塊都不會與別人沖突。現在，abc.py模塊的名字就變成了mycompany.abc，類似的，xyz.py的模塊名變成了mycompany.xyz。
請注意，每一個包目錄下面都會有一個__init__.py的文件，這個文件是必須存在的，否則，Python就把這個目錄當成普通目錄，而不是一個包。__init__.py可以是空文件，也可以有Python代碼，因為__init__.py本身就是一個模塊，而它的模塊名就是mycompany。
類似的，可以有多級目錄，組成多級層次的包結構。比如如下的目錄結構：
mycompany
├─ web
│ ├─ __init__.py
│ ├─ utils.py
│ └─ www.py
├─ __init__.py
├─ abc.py
└─ xyz.py文件www.py的模塊名就是mycompany.web.www，兩個文件utils.py的模塊名分別是mycompany.utils和mycompany.web.utils。
注意：自己創建模塊時要注意命名，不能和Python自帶的模塊名稱沖突。例如，系統自帶了sys模塊，自己的模塊就不可命名為sys.py，否則將無法導入系統自帶的sys模塊。
導入模塊：
import package
from Package import specific_submodule
Import 模塊名
From 模塊名 import 子模塊1,子模塊2,......
總結：
模塊是一組Python代碼的集合，可以使用其他模塊，也可以被其他模塊使用。
創建自己的模塊時，要注意：
- 模塊名要遵循Python變量命名規范，不要使用中文、特殊字符；
- 模塊名不要和系統模塊名沖突，最好先查看系統是否已存在該模塊，檢查方法是在Python交互環境執行
import abc，若成功則說明系統存在此模塊。
4.輸入
name = input("請輸入名字：")
5.輸出
print("name is %s"%name)
print("name:%s, age:%d"%(name,age))
print("name:{0}, age:{1}".format(name,age)) #(標號可不寫，為默認順序)
print("name:{name}, age:{age}".format(name = "你的名字",age = 60))
import math
print('常量 PI 的值近似為 {0:.3f}。'.format(math.pi)) #常量 PI 的值近似為 3.142。
table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}
print('tbl_b: {0[tbl_b]:d}; tbl_a: {0[tbl_a]:d}; tbl_c: {0[tbl_c]:d}'.format(table))
#tbl_b: 2; tbl_a: 1; tbl_c: 3
table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}
print('tbl_b: {tbl_b:d}; tbl_a: {tbl_a:d}; tbl_c: {tbl_c:d}'.format(**table))
#tbl_b: 2; tbl_a: 1; tbl_c: 3
6.類型轉換
a = int("100") # 轉換為數字
a = str("100“) # 轉換為字符串
7.python2與python3
python2中input的內容當做執行的內容，python3當做字符串。如a = input(“”). python2中的raw_input相當於python3中的inpout。
python2 中支持 <> 是不等於的意思，python3不支持，應該用 != 表示
8.運算符
一、算述運算符：
1 + 1 = 2 (加法)
4 - 10 = -6 #(減法 - 得到負數或是一個數減去另一個數)
"a" * 5 = "aaaaa" #(乘法 - 兩個數相乘或是返回一個被重復若干次的字符串)
2 ** 3 = 8 #(冪 - 返回2的3次冪)
5 / 2 = 2.5 #(除法）
5 // 2 = 2 #(取商 - 返回商的整數部分)
5 % 2 = 1 #（取余 - 返回除法的余數）
二、賦值運算符：
i += 1 等價於 i = i + 1
i -= 1 等價於 i = i - 1
i *= 2 等價於 i = i * 2
i /= 2 等價於 i = i / 2
i //= 2 等價於 i = i // 2
i %= 2 等價於 i = i % 2
i **= 2 等價於 i = i ** 2
9.邏輯運算符
not , and , or
優先級（短路原則）：
and：條件1 and 條件2 ，如果條件1為假，那么這個and前后兩個條件組成的表達式的計算結果就一定為假，就不判斷條件2了
or：條件1 or 條件2，如果前面的第一個條件為真，那么這個or前后兩個條件組成的表達式的計算結果就一定為真，就不判斷條件2了
10.流程
表達式及操作運算符、常量及變量：
（1）表達式：由操作數和運算符組成的一句代碼或語句，表達式可以求值，可以放在" = "的右邊，用來給變量賦值。
（2）操作運算符：
< 小於
<= 小於或等於
> 大於
>= 大於或等於
== 等於，比較對象是否相等（注意區分 = ，= 是賦值，==是比較）
!= 不等於
（3）常量：固定不變的量，字母大寫
（4）變量: 存儲信息，以后被調用
命名規則：
-
- 1.字母數字下划線組成
- 2.不能以數字開頭，不能含有特殊字符和空格
- 3.不能以保留字命名
- 4.不能以漢字命名
- 5.定義的變量名應該有意義
- 6.駝峰式命名、下划線分割單詞
- 7.變量名區分大小寫
(if...elif...else)
if 條件（如果）:
elif 條件（或如果）:
else否則:
注意：
- 1、每個條件后面要使用冒號 :，表示接下來是滿足條件后要執行的語句塊。
- 2、使用縮進來划分語句塊，相同縮進數的語句在一起組成一個語句塊。
- 3、在Python中沒有switch – case語句。
例：
# 該實例演示了數字猜謎游戲
number = 7
guess = 0
print("數字猜謎游戲!")
while guess != number:
guess = int(input("請輸入你猜的數字："))
if guess == number:
print("恭喜，你猜對了！")
elif guess < number:
print("猜的數字小了...")
elif guess > number:
print("猜的數字大了...")
# 執行結果：
數字猜謎游戲!
請輸入你猜的數字：5
猜的數字小了...
請輸入你猜的數字：6
猜的數字小了...
請輸入你猜的數字：8
猜的數字大了...
請輸入你猜的數字：9
猜的數字大了...
請輸入你猜的數字：7
恭喜，你猜對了！
if 嵌套：在嵌套 if 語句中，可以把 if...elif...else 結構放在另外一個 if...elif...else 結構中。
if 表達式1: 語句 if 表達式2: 語句 elif 表達式3: 語句 else: 語句 elif 表達式4: 語句 else: 語句
例：
num=int(input("輸入一個數字："))
if num%2==0:
if num%3==0:
print ("你輸入的數字可以整除 2 和 3")
else:
print ("你輸入的數字可以整除 2，但不能整除 3")
else:
if num%3==0:
print ("你輸入的數字可以整除 3，但不能整除 2")
else:
print ("你輸入的數字不能整除 2 和 3")
# 執行結果：
輸入一個數字：5
你輸入的數字不能整除 2 和 3
輸入一個數字：6
你輸入的數字可以整除 2 和 3
(while)
while 判斷條件: #（while：當...的時候）
語句
一、需要注意冒號和縮進。另外，在Python中沒有do...while循環。
例：while 循環使用 else 語句
i = 0
while i < 5:
print (i, " 小於 5")
i += 1 # 變量自增
else:
print (i, " 等於 5")
# 輸出結果：
0 小於 5
1 小於 5
2 小於 5
3 小於 5
4 小於 5
5 等於 5
二、以下實例使用了 while 來計算 1 到 100 的總和：
i = 100
sum = 0
counter = 1
while counter <= i:
sum = sum + counter
counter += 1
print("1 到 %d 之和為: %d" % (i,sum))
# 輸出結果：
1 到 100 之和為: 5050
(for)
一、for循環可以遍歷任何序列的項目，如一個列表或者一個字符串。
例：
languages = ["C", "C++", "Perl", "Python"]
for x in languages:
print (x)
# 輸出結果：
C
C++
Perl
Python
二、以下 for 實例中使用了 break 語句，break 語句用於跳出當前循環體。
例：
sites = ["Baidu", "Google","frank-me","Taobao"]
for site in sites:
if site == "frank-me":
print("我的網址")
break
print("循環數據 " + site)
else:
print("到此為止!")
print("結束!")
# 輸出結果：
循環數據 Baidu
循環數據 Google
我的網址
結束!
注意： i++,++i 在python中不允許使用。
(range函數)
一、如果你需要遍歷數字序列，可以使用內置range()函數，它會生成數列。
例：
for i in range(5):
print(i)
# 輸出結果：
0
1
2
3
4
二、也可以使用range指定區間的值。
例：
for i in range(5,9) :
print(i)
# 輸出結果：
5
6
7
8
三、也可以使range以指定數字開始並指定不同的增量(甚至可以是負數，有時這也叫做'步長')。
例：
for i in range(0, 10, 3) :
print(i)
# 輸出結果：
0
3
6
9
四、您可以結合range()和len()函數以遍歷一個序列的索引
例：
>>> a = ['Google', 'Baidu', 'frank-me', 'Taobao', 'QQ']
>>> for i in range(len(a)):
>>> print(i, a[i])
# 輸出結果：
0 Google
1 Baidu
2 frank-me
3 Taobao
4 QQ
五、可以使用range()函數來創建一個列表，用for直接歷遍
>>> for i in list(range(5)):
... print( i )
# 輸出結果：
0
1
2
3
4
break和continue語句及循環中的else子句
一、break 語句可以跳出 for 和 while 的循環體。如果你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行。
例：
for letter in 'frank-me': # 第一個實例
if letter == '-': # 當符號為“-”時，跳出
break
print ('當前字符為 :', letter)
var = 10 # 第二個實例
while var > 0:
print ('當期變量值為 :', var)
var = var -1
if var == 5: # 到數字5(包含5)時不往下執行
break
print ("See you!")
# 輸出結果：
當前字符為 : f
當前字符為 : r
當前字符為 : a
當前字符為 : n
當前字符為 : k
當期變量值為 : 10
當期變量值為 : 9
當期變量值為 : 8
當期變量值為 : 7
當期變量值為 : 6
See you!
二、continue語句被用來告訴Python跳過當前循環塊中的剩余語句，然后繼續進行下一輪循環。
例：
for letter in 'frank-me': # 第一個實例
if letter == '-': # 字符為 "-" 時跳過輸出，繼續往下執行
continue
print ('當前字符 :', letter)
var = 10 # 第二個實例
while var > 0:
var = var -1
if var == 5: # 變量為 5 時跳過輸出，繼續往下執行
continue
print ('當前變量值 :', var)
print ("See you!")
# 輸出結果：
當前字符 : f
當前字符 : r
當前字符 : a
當前字符 : n
當前字符 : k
當前字符 : m
當前字符 : e
當前變量值 : 9
當前變量值 : 8
當前變量值 : 7
當前變量值 : 6
當前變量值 : 4
當前變量值 : 3
當前變量值 : 2
當前變量值 : 1
當前變量值 : 0
See you!
三、循環語句可以有 else 子句，它在窮盡列表(以for循環)或條件變為 false (以while循環)導致循環終止時被執行,但循環被break終止時不執行。
例：
for i in range(2, 10):
for x in range(2, i):
if i % x == 0:
print(i, '=', x, '*', i//x)
break
else:
# 循環中沒有找到元素
print(i, '是質數')
# 輸出結果：
2 是質數
3 是質數
4 = 2 * 2
5 是質數
6 = 2 * 3
7 是質數
8 = 2 * 4
9 = 3 * 3
for-else
for中沒有break,則else一定會執行
for temp in strs:
print(temp)
else:
print("")
const 修改變量為不可變。
(pass語句)
pass是空語句，是為了保持程序結構的完整性。
pass 不做任何事情，一般用做占位語句。
while True:
pass # 等待鍵盤中斷 (Ctrl+C)
最小的類：
class EmptyClass:
pass
例：
for letter in 'frank-me':
if letter == '-':
pass
print ('- 執行 pass')
print ('當前字符 :', letter)
print ("See you!")
# 輸出結果：
當前字符 : f
當前字符 : r
當前字符 : a
當前字符 : n
當前字符 : k
- 執行 pass
當前字符 : -
當前字符 : m
當前字符 : e
See you!
11.字符串(不可變)
一、創建
‘ str ’，“ str ”單引號或雙引號包裹起來的內容
順序，序列
-- 偏移量，索引，直標
長度
--len()返回一個序列的長度
** 單個字符,即長度為1的字符串
二、索引
test_str[0]
** 特別的：最后一元素的索引“-1”，“-2”代表倒數第二，依此類推
切片
-- test_str[strat:end]
-- start:起始索引（包含這個元素）
-- end：結束索引（不包含這個元素）
-- start < end
不可變
-- 不能修改
切片例：
str = "dasfaf"
str[2:4] #(取得2到3的),
str[2:] #(到最后),
str[2:-1:2] #(步長2，隔一個取一個)
逆序：
str = "abcdefABCDEF"
str[0:] # out:"abcdefABCDEF" （順序）
str[-1:] # out:"F" （倒數第一個）
str[-1:0] # out:""
str[-1:0:-1] # out:"FEDCBAfedcb" （逆序，不含第一個）
str[-1::-1], str[::-1] # out:"FEDCBAfedcba"（逆序）
三、字符串連接：
a = b + c #或者
a = "===%s==="%(b+c) #或者
a = "==={}===".format(b+c)
四、常見操作
find： str.find("abc") # 從左向右有返回第一個匹配字符串的起始下標，沒有返回-1。rfind():從右向左。
str.index("abc") #找到返回起始下標，沒有拋出異常。 存在rindex().
str.count("abc") #匹配的個數。
str.replace("abc", "def") #同java，把左邊的替換成右邊的 。
str.replace("abc", "def",1) #第三個參數是從左到右替換個數。
str.split(" ") #同java ，通過指定分隔符（包括空格、換行(\n)、制表符(\t)等）對字符串進行切片，如果參數 num 有指定
值，則僅分隔 num 個子字符串。
str.capitalize() #字符串的第一個字母大寫。
str.title() #字符串的每個單詞的首字母大寫。
str.startswith("abc"), str.endswith("abc") #同java，用於檢查字符串是否是以指定子字符串開頭，如果是則返回 True，
否則返回 False。如果參數 beg 和 end 指定值，則在指定范圍內檢查。
str.lower() str.uper() #所有的字母小寫和大寫。
str.center(50) #居中顯示，行總長50 " abc "
str.ljust(50), str.rjust(50) #左(右)對齊
str.lstrip() #刪除左邊空格
str.rstrip() #右邊空格
str.strip() #刪除兩端空格.
12.列表 (類似數組，可變，針對自身的變化)
運算符
| 表達式 |
結果 |
描述 |
| len([1, 2, 3]) |
3 |
計算元素個數 |
| [1, 2, 3] + [4, 5, 6] |
[1, 2, 3, 4, 5, 6] |
連接 |
| [‘Hi!’] * 4 |
[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] |
復制 |
| 3 in [1, 2, 3] |
True |
元素是否存在 |
| for x in [1, 2, 3]: print(x, end=” “) |
1 2 3 |
迭代 |
創建
序列
list1 = [1,2,3,4,5,6]
例：
["zhangsan","lisi"]
#定義
names = ["zhangsan", "lisi", 3.14] #列表中的數據可以是不同的數據類型。 可以下標，和切片。
增刪改查
增
-- 1.list.append(item)向尾部添加
-- 2.list.insert(index,item) 向指定的地方插入
例：#增
names.append("abc") #-->插入到最后;
names.insert(0, "bcc") #-->插入指定位置。
names = names1 + names2 #兩個列表用連接符
names1.extend(names2) #擴充
#注意：append添加的元素；extend連接的列表
刪
-- list.pop(index) #-->index 默認-1 （最后一個）
例：#刪
names.pop() #-->刪除最后一個；
names.remove("lisi") #-->根據內容刪除;
del names[0] #-->下標刪除
改
-- 直接復制
例：#改
names[0] = "abc"
查
索引
操作同字符串
例：#查
name[1:] # "lisi"
in, not in #是否存在 （if "zhangsan" in names:）
#可以for... in 循環遍歷
len(names) #元素個數
13.字典（可變）
a = {"name":"yy", "age": 12}
增
a["name"] = "yy" #直接寫key-value
刪
del a["name"]
改
a["name"] = "zz" #相同key的值覆蓋。
查
a["name"], a.get("name")
例：
>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params
{'server': 'mpilgrim', 'database': 'master', 'uid': 'sa', 'pwd': 'secret'}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'database=master', 'uid=sa', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;database=master;uid=sa;pwd=secret'
字典常見操作
len(params) #鍵值對的個數
params.keys() 或 dict.keys(params) #返回key的列表
if "uid" in params.keys(): #判斷是否存在某個key
print("yes")
params.values() #返回value的列表
14.元組(類似列表，不可變)
列表可以增刪改，元組不能改
tup1 = (); #空元組
例：
>>> tup1 = (50)
>>> type(tup1) # 不加逗號，類型為整型
# 執行結果：
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗號，類型為元組
# 執行結果：
<class 'tuple'>
訪問：
例：
tup1 = ('Google', 'Baidu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ",tup1[0])
# 執行結果：
tup1[0]: Google
print ("tup2[1:5]: ", tup2[1:5])
# 執行結果：
tup2[1:5]: (2, 3, 4, 5)
修改：
例：
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 以下修改元組元素操作是非法的。
# tup1[0] = 100
# 創建一個新的元組
tup3 = tup1 + tup2;
print (tup3) #(12, 34.56, 'abc', 'xyz')
刪除
tup = ('Google', 'Baidu', 1997, 2000)
print (tup)
del tup;
類似拆包
a = (11,12)
b = a
b #out (11,12)
c,d = a #類似拆包
c #out 11
d #out 12
例：
info = {"name":"ysw", "age":24}
for temp in info:
print(temp)
# 執行結果：
name
age
for temp in info.items():
print("key=%s,value=%s"%(temp[0],temp[1]))
#or（或者）
for a,b in info.items():
print("key=%s,value=%s"%(a,b))
# 執行結果
key=name,value=ysw
key=age,value=24
遍歷技巧：
一、在字典中遍歷時，關鍵字和對應的值可以使用 items() 方法同時解讀出來
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
print(k, v)
# 執行結果：
gallahad the pure
robin the brave
二、在序列中遍歷時，索引位置和對應值可以使用 enumerate() 函數同時得到
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
# 執行結果：
0 tic
1 tac
2 toe
三、同時遍歷兩個或更多的序列，可以使用 zip() 組合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
# 執行結果：
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
四、要反向遍歷一個序列，首先指定這個序列，然后調用 reversed() 函數
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
# 執行結果：
9
7
5
3
1
五、要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
# 執行結果：
apple
banana
orange
pear
15.函數
def abc():
print("")
abc()
#注意： 函數的定義需要在函數的調用之前，否則報錯。
可更改與不可更改對象：
在python中，strings,tuples和numbers是不可更改對象，list.dict等則是可更改對象。
- 不可變類型：變量賦值 a=5后在賦值a=10,生成了新的對象，原對象丟棄。
- 可變類型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
python 函數的參數傳遞：
- 不可變類型:類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身
- 可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會受影響
一、默認函數參數
def printinfo( name, age = 35 ):
"打印任何傳入的字符串"
print ("名字: ", name);
print ("年齡: ", age);
return;
printinfo( age=50, name="baidu" );
print ("------------------------")
printinfo( name="baidu" );
# 執行結果：
名字: baidu
年齡: 50
------------------------
名字: baidu
年齡: 35
二、可變參數
例：
def printinfo( *vartuple ):
"打印任何傳入的參數"
print ("輸出: ")
for var in vartuple:
print (var)
return;
printinfo(10,32,22)
#匿名函數(lambda創建匿名函數)
sum = lambda arg1, arg2: arg1 + arg2;
print ("相加后的值為 : ", sum( 10, 20 ))
print ("相加后的值為 : ", sum( 20, 20 ))
# 執行結果：
輸出:
10
32
22
相加后的值為 : 30
相加后的值為 : 40
三、global關鍵字修改外部作用域變量
例：
num = 1
def fun1():
global num # 需要使用 global 關鍵字聲明
print(num)
num = 123
print(num)
fun1()
# 執行結果：
1
123
四、nonlocal 修改嵌套作用域變量
例：
def outer():
num = 10
def inner():
nonlocal num # nonlocal關鍵字聲明
num = 100
print(num)
inner()
print(num)
outer()
# 執行結果：
100
100
16.迭代器和生成器
一、字符串，列表和元組對象都可用於創建迭代器。
例：
list = [1,2,3,4]
it = iter(list)
print(next(it))
print(next(it))
#執行結果
1
2
for x in it: #遍歷
print(x, end = "")
#執行結果：
1 2 3 4
例：
import sys
list = [1,2,3,4]
it = iter(list)
while True:
try:
print(next(it))
except StopIteration:
sys.exit()
# 執行結果：
1
2
3
4
二、生成器(TODO)
yield 的函數，生成器是返回迭代器的函數，只能用於迭代操作。
例：
import sys
def fibonacci(n): # 生成器函數 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a # 相當於generator的print(a)
a, b = b, a + b # 注意，賦值語句相當於：t = (b,a+b), t 是一個tuple,a = t[0] , b = t[1]
counter += 1
f = fibonacci(10) # f 是一個迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
#執行結果：
0 1 1 2 3 5 8 13 21 34 55
17.模塊
Python 提供了一個辦法，把某些定義存放在文件中，為一些腳本或者交互式的解釋器實例使用，這個文件被稱為模塊。
- import語句，想使用 Python 源文件，只需在另一個源文件里執行 import 語句。
例：
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
#!/usr/bin/python3
# Filename: test.py
import support #導入模塊，即文件名
# 現在可以調用模塊里包含的函數了
support.print_func()
from…import語句,從模塊中導入一個指定的部分到當前命名空間中。
#導入模塊 fibo 的 fib 函數
from fibo import fib, fib2
>>> fib(500)
- From…import* 語句，把一個模塊的所有內容全都導入到當前的命名空間。
- 模塊除了方法定義，還可以包括可執行的代碼。這些代碼一般用來初始化這個模塊。這些代碼只有在第一次被導入時才會被執行。
- name屬性,一個模塊被另一個程序第一次引入時，其主程序將運行。如果我們想在模塊被引入時，模塊中的某一程序塊不執行,可以用name屬性。
例：
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在運行')
else:
print('我來自另一模塊')
#執行結果：
程序自身在運行
- Python 會根據 sys.path 中的目錄來尋找這個包中包含的子目錄。
- 目錄只有包含一個叫做 init.py 的文件才會被認作是一個包，主要是為了避免一些濫俗的名字（比如叫做 string）不小心的影響搜索路徑中的有效模塊。
- 推薦：from Package import specific_submodule
18.文件
open()方法返回文件，第二個參數為文件打開方式。默認只讀r / 寫w，a追加…
f = open("/tmp/test.txt","w")
f.write("人生苦短，我用python！")
f.close()
- f.read(size) 讀取文件內容，size為空或負數則全部返回。
- f.readline() 會從文件中讀取單獨的一行。換行符為 ‘\n’。f.readline() 如果返回一個空字符串, 說明已經已經讀取到最后一行。
- f.readlines() 讀取文件所有行，並以列表返回。
- f.write(string) 將 string 寫入到文件中, 然后返回寫入的字符數。如果要寫入一些不是字符串的東西, 那么將需要先進行轉換。
19.類
類方法
例：
class MyClass:
i = 12345
#類方法必須有一個額外的第一個參數，慣例是self，不固定；代表的的類的實例而非類
def f(self):
return "hello world"
x = MyClass()
print("MyClass 類的屬性 i 為：", x.i)
print("MyClass 類的方法 f 輸出為：", x.f())
#執行結果：
MyClass 類的屬性 i 為： 12345
MyClass 類的方法 f 輸出為： hello world
構造方法
例：
class Complex:
#構造方法
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)
# 執行結果：
3.0 -4.5
例：
類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部無法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
# 實例化類
p = people('baidu',10,30)
p.speak()
# 執行結果：
baidu 說: 我 10 歲。
繼承
例：
類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部無法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#調用父類的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
#另一個類，多重繼承之前的准備
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
#多重繼承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("frank",25,80,4,"Python")
test.speak() #方法名同，默認調用的是在括號中排前地父類的方法
# 執行結果：
我叫 frank，我是一個演說家，我演講的主題是 Python
20.正則表達式
re.match與re.search的區別
re.match只匹配字符串的開始，如果字符串開始不符合正則表達式，則匹配失敗，函數返回None；而re.search匹配整個字符串，直到找到一個匹配。
例：
import re
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print ("match --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
#執行結果
No match!!
例：
import re
line = "Cats are smarter than dogs";
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print ("search --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
#執行結果
search --> matchObj.group() : dogs
檢索和替換
例：
import re
phone = "2018-666-666 # 這是一個電話號碼"
num = re.sub(r'#.*$', "", phone) # 刪除“#”后面的注釋內容
print ("電話號碼 : ", num)
#執行結果
電話號碼 : 2018-666-666
例：
import re
phone = "2018-666-666 # 這是一個電話號碼"
num = re.sub(r'\D', "", phone) # 移除非數字的內容
print ("電話號碼 : ", num)
#執行結果
電話號碼 : 2018666666
最后用一張圖來概括：
