基礎語法
默認情況下，Python 3 源碼文件以 UTF-8 編碼，所有字符串都是 unicode 字符串。
標識符：第一個字符必須是字母或下劃線，其他的部分由字母、數字和下劃線組成，對大小寫敏感。
註釋：Python中單行註釋以 # 開頭，多行註釋可以用多個 # 號，還有 ‘’’ 和 “”"。
python最具特色的就是使用縮進來表示代碼塊，不需要使用大括號 {} ，語句末尾不需要分號；。同一行顯示多條語句之間使用分號(;)分割。
可以使用反斜槓()來實現多行語句。在 [], {}, 或 () 中的多行語句，不需要使用反斜槓()。
total = item_one + \
item_two + \
item_three
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
數字(Number)類型有四種類型：整數、布爾型、浮點數和複數。
int (整數), 如 1, 只有一種整數類型 int，表示爲長整型
bool (布爾), 如 True。
float (浮點數), 如 1.23、3E-2
complex (複數), 如 1 + 2j、 1.1 + 2.2j
字符串(String)：單引號和雙引號使用完全相同。
使用三引號(’’'或""")可以指定一個多行字符串。
轉義符 ‘’
反斜槓可以用來轉義，使用r可以讓反斜槓不發生轉義（ raw string）。 如 r"this is a line with \n" 則\n會顯示，並不是換行。
按字面意義級聯字符串，如"this " "is " "string"會被自動轉換爲this is string。
字符串可以用 + 運算符連接在一起，用 * 運算符重複。
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
Python中的字符串不能改變。
Python 沒有單獨的字符類型，一個字符就是長度爲 1 的字符串。
print(str * 2) # 輸出字符串兩次
print(str + '你好') # 連接字符串
print(str[0]) # 輸出字符串第一個字符
print(str[2:5]) # 輸出從第三個開始到第五個的字符
print(str[2:]) # 輸出從第三個開始的後的所有字符
print('hello\nrunoob') # 使用反斜槓(\)+n轉義特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一個 r，表示原始字符串，不會發生轉義
空行與代碼縮進不同，空行的作用在於分隔兩段不同功能或含義的代碼，便於日後代碼的維護或重構。
像if、while、def和class這樣的複合語句，首行以關鍵字開始，以**冒號( : )**結束
print 默認輸出是換行的，如果要實現不換行需要在變量末尾加上 end=""：
# 不換行輸出
print( x, end=" " )
用 import 或者 from…import 來導入相應的模塊
將整個模塊(somemodule)導入，格式爲： import somemodule
從某個模塊中導入某個函數,格式爲： from somemodule import somefunction
從某個模塊中導入多個函數,格式爲： from somemodule import firstfunc, secondfunc, thirdfunc
將某個模塊中的全部函數導入，格式爲： from somemodule import *
基本數據類型
Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以後該變量纔會被創建。
變量就是變量，沒有類型，我們所說的"類型"是變量所指的內存中對象的類型。
#!/usr/bin/python3
# 變量不需要聲明，直接賦值
counter = 100 # 整型變量
miles = 1000.0 # 浮點型變量
name = "runoob" # 字符串
print (counter)
print (miles)
print (name)
標準數據類型有六個：Number（數字）、String（字符串）、List（列表）、Tuple（元組）、Set（集合）、Dictionary（字典）。
不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
Number（數字）：支持 int、float、bool、complex（複數）。只有一種整數類型 int，表示爲長整型。內置的 type() 函數可以用來查詢變量所指的對象類型。也可以用 isinstance 來判斷。
通過使用del語句刪除單個或多個對象
del var
del var_a, var_b
Python可以同時爲多個變量賦值，如a, b = 1, 2。
2、一個變量可以通過賦值指向不同類型的對象。
3、數值的除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。
4、在混合計算時，Python會把整型轉換成爲浮點數。
字符串用單引號 ’ 或雙引號 " 括起來，用反斜槓 \ 轉義特殊字符，兩種索引方式，從左往右以0開始，從右往左以-1開始。
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
與 C 字符串不同的是，Python 字符串不能被改變。向一個索引位置賦值，比如word[0] = 'm’會導致錯誤。
List（列表）列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
列表被截取後返回一個包含所需元素的新列表。加號 + 是列表連接運算符，星號 * 是重複操作。
和字符串一樣，list可以被索引和切片；List可以使用+操作符進行拼接；List中的元素是可以改變的。
列表截取可以接收第三個參數，參數作用是截取的步長，如果第三個參數爲負數表示逆向讀取，用於翻轉字符串。
def reverseWords(input):
# 通過空格將字符串分隔符，把各個單詞分隔爲列表
inputWords = input.split(" ")
# 翻轉字符串
# 假設列表 list = [1,2,3,4],
# list[0]=1, list[1]=2 ，而 -1 表示最後一個元素 list[-1]=4 ( 與 list[3]=4 一樣)
# inputWords[-1::-1] 有三個參數
# 第一個參數 -1 表示最後一個元素
# 第二個參數爲空，表示移動到列表末尾
# 第三個參數爲步長，-1 表示逆向
inputWords=inputWords[-1::-1]
# 重新組合字符串
output = ' '.join(inputWords)
return output
if __name__ == "__main__":
input = 'I like runoob'
rw = reverseWords(input)
print(rw)
Tuple（元組）：元組的元素不能修改，元組寫在小括號 () 裏，元素之間用逗號隔開。元組中的元素類型也可以不相同。元組也可以被索引和切片，方法一樣。元組也可以使用+操作符進行拼接。
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 輸出完整元組
print (tuple[0]) # 輸出元組的第一個元素
print (tuple[1:3]) # 輸出從第二個元素開始到第三個元素
print (tuple[2:]) # 輸出從第三個元素開始的所有元素
print (tinytuple * 2) # 輸出兩次元組
print (tuple + tinytuple) # 連接元組
>>> tup[0] = 11 # 修改元組元素的操作是非法的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素後添加逗號
Set（集合）：基本功能是進行成員關係測試和刪除重複元素。可以使用大括號 { } 或者 set() 函數創建集合。創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 輸出集合，重複的元素被自動去掉
# 成員測試
if 'Rose' in student :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的並集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同時存在的元素
輸出結果：
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
Dictionary（字典）列表是有序的對象集合，字典是無序的對象集合。區別在於：字典當中的元素是通過鍵來存取的。**字典用 { } 標識，**它是一個無序的 鍵(key) : 值(value) 的集合。鍵(key)必須使用不可變類型（數學/字符串/元組），在同一個字典中，鍵(key)必須是唯一的。
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 教程"
dict[2] = "2 - 工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 輸出鍵爲 'one' 的值
print (dict[2]) # 輸出鍵爲 2 的值
print (tinydict) # 輸出完整的字典
print (tinydict.keys()) # 輸出所有鍵
print (tinydict.values()) # 輸出所有值
輸出結果：
1 - 教程
2 - 工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site']) //
dict_values(['runoob', 1, 'www.runoob.com']) //列表
#構造函數 dict() 可以直接從鍵值對序列中構建字典
>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
>>> {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}
數據類型轉換
數據類型的轉換，只需要將數據類型作爲函數名即可。函數返回一個新的對象，表示轉換的值。
long(x, base=10) #將數字或字符串轉換爲一個長整型，base進制數默認十進制
>>> long(1)
1L
>>> long('123')
123L
int(x, base=10) #將一個字符串或數字轉換爲整型。
>>>complex(1, 2) #創建一個複數
(1 + 2j)
float(x) #將x轉換到一個浮點數
str(x) #將對象 x 轉換爲字符串
eval(str) #用來計算在字符串中的有效Python表達式,並返回一個對象
>>>x = 7
>>> eval( '3 * x' )
21
tuple(s) #將序列 s 轉換爲一個元組
list(s) # 將序列 s 轉換爲一個列表
set(s) #轉換爲可變集合
dict(d) #創建一個字典。d 必須是一個序列 (key,value)元組。
chr(x) #將一個整數轉換爲一個字符
unichr(x) #將一個整數轉換爲Unicode字符
ord(x) #將一個字符轉換爲它的整數值
hex(x) #將一個整數轉換爲一個十六進制字符串
oct(x) #將一個整數轉換爲一個八進制字符串
repr(x) #將對象 x 轉換爲表達式字符串
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
Python 運算符
// 取整除 - 返回商的整數部分（向下取整）
算術運算符、比較運算符、賦值運算符（冪賦值運算符 c = c ** a）、位運算符、邏輯運算符（and、or、not）、成員運算符（in、not in）、身份運算符（is 、is not）。
數學常量：pi 數學常量 pi（圓周率，一般以π來表示）；e 數學常量 e，e即自然常數（自然常數）。
[ : ]截取字符串中的一部分，遵循左閉右開原則，str[0,2] 是不包含第 3 個字符的。
Python字符串格式化，格式符 %s 。
%c 格式化字符及其ASCII碼
%d 格式化整數
%u 格式化無符號整型
%o 格式化無符號八進制數
%x 格式化無符號十六進制數
%X 格式化無符號十六進制數（大寫）
%f 格式化浮點數字，可指定小數點後的精度
%e 用科學計數法格式化浮點數
%E 作用同%e，用科學計數法格式化浮點數
%g %f和%e的簡寫
%p 用十六進制數格式化變量的地址
使用 del 語句來刪除列表的的元素、列表**+ 號用於組合列表，* 號用於重複列表**。len([1, 2, 3]) 長度
列表截取與拼接、嵌套列表、
#列表函數&方法
len(list) #列表元素個數
max(list) #返回列表元素最大值
list(seq) #將元組轉換爲列表
min(list) #返回列表元素最小值
list.append(obj) #在列表末尾添加新的對象
list.count(obj) #統計某個元素在列表中出現的次數
list.extend(seq) #在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）
list.index(obj) #從列表中找出某個值第一個匹配項的索引位置
list.insert(index, obj) #將對象插入列表
list.pop([index=-1]) #移除列表中的一個元素（默認最後一個元素），並且返回該元素的值
list.remove(obj) #移除列表中某個值的第一個匹配項
list.reverse() #反向列表中元素
list.sort( key=None, reverse=False) #對原列表進行排序
list.clear() #清空列表
list.copy() #複製列表
元組創建
>>> tup3 = "a", "b", "c", "d"; # 不需要括號也可以
tup1 = (); #創建空元組
>>>tup1 = (50)
>>> type(tup1) # 不加逗號，類型爲整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗號，類型爲元組
<class 'tuple'>
#元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組
del tup
#元組索引，截取
tuple(seq) #將列表轉換爲元組。
min(tuple) #返回元組中元素最小值。
max(tuple) #返回元組中元素最大值。
len(tuple) #計算元組元素個數。
字典是另一種可變容器模型，且可存儲任意類型對象。
#向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新 Age
dict['School'] = "菜鳥教程" # 添加信息
#能刪單一的元素也能清空字典，清空只需一項操作
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 清空字典
del dict # 刪除字典
#不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，鍵必須不可變，所以可以用數字，字符串或元組充當，而用列表就不行
str(dict) #輸出字典，以可打印的字符串表示。
type(variable) #返回輸入的變量類型，如果變量是字典就返回字典類型。
集合（set）是一個無序的不重複元素序列。創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
s.add( x ) #集合的基本操作：添加元素
s.update( x ) #也可以添加元素，且參數可以是列表，元組，字典等
s.remove( x ) #移除元素
s.discard( x ) #也是移除集合中的元素，且如果元素不存在，不會發生錯誤
s.pop() #隨機刪除集合中的一個元素
len(s) #計算集合元素個數
s.clear() #清空集合
x in s #判斷元素是否在集合中存在
end 關鍵字關鍵字end可以用於將結果輸出到同一行，或者在輸出的末尾添加不同的字符。
if 語句if 嵌套
Python 中用 elif 代替了 else if，所以if語句的關鍵字爲：if – elif – else。
1.每個條件後面要使用冒號 :，表示接下來是滿足條件後要執行的語句塊。
2、使用縮進來劃分語句塊，相同縮進數的語句在一起組成一個語句塊。
3、在Python中沒有switch – case語句
循環語句：循環語句有 for 和 while。
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和爲: %d" % (n,sum))
無限循環
var = 1
while var == 1 : # 表達式永遠爲 true,通過設置條件表達式永遠不爲 false 來實現無限循環
num = int(input("輸入一個數字 :"))
print ("你輸入的數字是: ", num)
print ("Good bye!")
CTRL+C 來退出當前的無限循環
#while 循環使用 else 語句
count = 0
while count < 5:
print (count, " 小於 5")
count = count + 1
else:
print (count, " 大於或等於 5")
簡單語句組
flag = 1
while (flag): print ('歡迎!')
print ("Good bye!")
for循環可以遍歷任何序列的項目，如一個列表或者一個字符串
for <variable> in <sequence>:
<statements>
else:
<statements>
使用了 break 語句，break 語句用於跳出當前循環體
range()函數遍歷數字序列
>>>for i in range(5):
... print(i) #print()函數內置默認轉行，可以用end來....
...
0
1
2
3
4
使range以指定數字開始並指定不同的增量(甚至可以是負數，有時這也叫做'步長'):
結合range()和len()函數以遍歷一個序列的索引
>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>
使用range()函數來創建一個列表
>>>list(range(5))
[0, 1, 2, 3, 4]
break 語句可以跳出 for 和 while 的循環體。如果你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行。
continue語句被用來告訴Python跳過當前循環塊中的剩餘語句，然後繼續進行下一輪循環。
循環語句可以有 else 子句，它在窮盡列表(以for循環)或條件變爲 false (以while循環)導致循環終止時被執行,但循環被break終止時不執行。
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等於', x, '*', n//x)
break
else:
# 循環中沒有找到元素
print(n, ' 是質數')
pass 語句是空語句，爲了保持程序結構的完整性
迭代器與生成器
迭代是Python最強大的功能之一，是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。
迭代器有兩個基本的方法：iter() 和 next()。
字符串，列表或元組對象都可用於創建迭代器
>>> list=[1,2,3,4]
>>> it = iter(list) # 創建迭代器對象
>>> print (next(it)) # 輸出迭代器的下一個元素
1
>>> print (next(it))
2
list=[1,2,3,4]
it = iter(list) # 創建迭代器對象
for x in it:
print (x, end=" ")
創建一個迭代器
把一個類作爲一個迭代器使用需要在類中實現兩個方法 iter() 與 next() 。
面向對象編程中類都有一個構造函數，Python 的構造函數爲 init(), 它會在對象初始化的時候執行。
iter() 方法返回一個特殊的迭代器對象， 這個迭代器對象實現了 next() 方法並通過 StopIteration 異常標識迭代的完成。
next() 方法會返回下一個迭代器對象。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
StopIteration 異常用於標識迭代的完成，防止出現無限循環的情況，在 __next__() 方法可以設置**在完成指定循環次數**後**觸發 StopIteration 異常**來結束迭代。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
生成器
使用了 yield 的函數被稱爲生成器（generator）
跟普通函數不同的是，生成器是一個返回迭代器的函數，只能用於迭代操作，更簡單點理解生成器就是一個迭代器。
在調用生成器運行的過程中，每次遇到 yield 時函數會暫停並保存當前所有的運行信息，返回 yield 的值, 並在下一次執行 next() 方法時從當前位置繼續運行。
調用一個生成器函數，返回的是一個迭代器對象。
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函數 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
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
定義一個函數
函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，並且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。
def 函數名（參數列表）:
函數體
strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變類型：變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
python 中一切都是對象
調用函數時可使用的正式參數類型：
必需參數：以正確的順序傳入函數，調用時的數量必須和聲明時的一樣
關鍵字參數：允許函數調用時參數的順序與聲明時不一致
默認參數：如果沒有傳遞參數，則會使用默認參數
不定長參數：可能需要一個函數能處理比當初聲明時更多的參數
def functionname([formal_args,] *var_args_tuple )://加了星號 * 的參數會以元組(tuple)的形式導入，存放所有未命名的變量參數
"函數_文檔字符串"
function_suite
return [expression]
# 可寫函數說明
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 )
#參數帶兩個星號 **基本語法，加了兩個星號 ** 的參數會以字典的形式導入。
def functionname([formal_args,] **var_args_dict ):
"函數_文檔字符串"
function_suite
return [expression]
# 可寫函數說明
def printinfo( arg1, **vardict ):
"打印任何傳入的參數"
print ("輸出: ")
print (arg1)
print (vardict)
# 調用printinfo 函數
printinfo(1, a=2,b=3)
輸出:
1
{'a': 2, 'b': 3}
聲明函數時，參數中星號 * 可以單獨出現，如果單獨出現星號 * 後的參數必須用關鍵字傳入。
匿名函數： lambda 來創建匿名函數，lambda 只是一個表達式，函數體比 def 簡單很多，lambda 函數擁有自己的命名空間，且不能訪問自己參數列表之外或全局命名空間裏的參數。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda [arg1 [,arg2,.....argn]]:expression
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))
return語句用於退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。
變量作用域決定了在哪一部分程序可以訪問哪個特定的變量名稱。
L （Local） 局部作用域
E （Enclosing） 閉包函數外的函數中
G （Global） 全局作用域
B （Built-in） 內置作用域（內置函數所在模塊的範圍）
在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內置中找。
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 閉包函數外的函數中
def inner():
i_count = 2 # 局部作用域
內置作用域是通過一個名爲 builtin 的標準模塊來實現的，但是這個變量名自身並沒有放入內置作用域內，所以必須導入這個文件才能夠使用它。
Python 中只有模塊（module），類（class）以及函數（def、lambda）纔會引入新的作用域。
如果將 msg 定義在函數中，則它就是局部變量，外部不能訪問
>>> def test():
... msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>
說明了 msg_inner 未定義，無法使用，因爲它是局部變量，只有在函數內可以使用。
全局變量和局部變量
total = 0 # 這是一個全局變量
# 可寫函數說明
def sum( arg1, arg2 ):
#返回2個參數的和."
total = arg1 + arg2 # total在這裏是局部變量.
print ("函數內是局部變量 : ", total)
return total
#調用sum函數
sum( 10, 20 )
print ("函數外是全局變量 : ", total)#改爲sum( 10, 20 )
輸出結果：
函數內是局部變量 : 30
函數外是全局變量 : 0
global 和 nonlocal關鍵字：內部作用域想修改外部作用域的變量；修改嵌套作用域（enclosing 作用域，外層非全局作用域）中的變量
num = 1
def fun1():
global num # 需要使用 global 關鍵字聲明
print(num)
num = 123
print(num)
fun1()
print(num)
輸出結果：
1
123
123
def outer():
num = 10
def inner():
nonlocal num # nonlocal關鍵字聲明
num = 100
print(num)
inner()
print(num)
outer()
輸出結果：
100
100
a = 10
def test():
a = a + 1
print(a)
test()
以上程序執行，報錯信息如下：
Traceback (most recent call last):
File "test.py", line 7, in <module>
test()
File "test.py", line 5, in test
a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment
因爲 test 函數中的 a 使用的是局部，未定義，無法修改
a = 10
def test(a):
a = a + 1
print(a)
test(a)
執行輸出結果爲：
11
數據結構
將列表當做堆棧使用，堆棧作爲特定的數據結構，最先進入的元素最後一個被釋放（後進先出）。
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
將列表當作隊列使用在隊列裏第一加入的元素，第一個取出來；但是拿列表用作這樣的目的效率不高。在列表的最後添加或者彈出元素速度快
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
列表推導式
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
嵌套列表解析
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
del 語句
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
>>> del a
字典推導
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
構造函數 dict() 直接從鍵值對元組列表中構建字典
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
遍歷技巧
在字典中遍歷時，關鍵字和對應的值可以使用 items() 方法同時解讀出來
在序列中遍歷時，索引位置和對應值可以使用 enumerate() 函數同時得到
同時遍歷兩個或更多的序列，可以使用 zip() 組合
要反向遍歷一個序列，首先指定這個序列，然後調用 reversed() 函數
要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
>>> 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.
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear