本文是個人python學習筆記，學習資料為廖雪峰python教程，如需更多內容，請移步廖老師官方網站。

一 安裝

官網下載安裝包安裝，安裝好之後，在命令提示符輸入python進入Python交互模式：

輸入exit()退出交互模式。

執行python程序文件，需先切換到文件所在目錄下，再執行python 文件名:

二 語法基礎

2.1 IO

輸入：name=input() ; name=input(‘請輸入姓名：‘) ；

輸出：print(‘name‘,name),多個輸出內容用逗號間隔；

2.2 編寫基礎

python用#開頭標識註釋單行，多行註釋用三引號‘‘‘...‘‘‘，python大小寫敏感。一行語句以冒號:

字符串文本用單引號、雙引號括起來，如果字符串內本身包含單引號（或雙引號），則需要使用雙引號（或單引號）括起字符串，如果既有‘，也有“，則用\轉義。

1 name = input(‘請輸入姓名:‘)
2 print(‘I"am‘,name)
3 print("I‘am",name)
4 print(‘I\‘am "‘,name,‘\"‘)

輸出多行時，在交互模式下，用三引號‘‘‘開頭，系統自動換行，提示符從>>>變為...，結束時用‘‘‘。

代碼中，直接用換行，或用換行符\n。

1
 
 print(‘‘‘a1
2 a2
3 a3‘‘‘)
4 
5 print(‘b1\nb2\nb3‘)

Python中的控制None，相當於數據庫中的null。

變量：變量名是大小寫、數字、下劃線_的組合，不能用數字開頭。不需要定義變量的數據類型，變量的數據類型隨賦值的數據類型而定，故變量的數據類型是可以更改的。

常量：常量用大寫字母定義，但僅為書寫習慣，常量的值可以改變。

list:相當於數組，但是可以追加，也可以倒敘訪問元素，-1訪問最後一個，-2訪問倒數第二個。。。

>>> name = [‘張三‘,‘李四‘,‘王五‘]
>>> name
[
 
‘張三‘, ‘李四‘, ‘王五‘]
>>> name[0]
‘張三‘
>>> name[-1]
‘王五‘

>>> name.append(‘楊7‘)
>>> name[-1]
‘楊7‘
>>> len(name)
4

insert()將元素插入指定位置：

>>> name.insert(1,‘lily‘)
>>> name
[‘張三‘, ‘lily‘, ‘李四‘, ‘王五‘, ‘楊7‘]

pop()刪除list末尾元素，pop(i)刪除指定位置元素。

註：list元素可以是不同類型，list可以多維

tuple:元祖，初始化之後就不可以改變。當只有一個元素時需用逗號,與數學表達式區分。當元素的list時，list元素可修改。

>>> tmp = (1,)
>>> tmp
(1,)
>>> name2 = (‘張三‘,‘李四‘,[‘lily‘,‘may‘])
>>> name2
(‘張三‘, ‘李四‘, [‘lily‘, ‘may‘])
>>> name2[2][0]=‘莉莉‘
>>> name2
(‘張三‘, ‘李四‘, [‘莉莉‘, ‘may‘])

dict:鍵-值（key-value）存儲。使用in或get()函數判斷key是否存在，通過賦值直接增加鍵值對，使用pop()函數刪除鍵值對。key不能放入可變對象。

#dict初始化
score = {‘張三‘:89,‘李四‘:59,‘王五‘:92}
#使用in判斷key是否存在
if ‘張三‘ in score:
    print(‘張三的成績是‘,score[‘張三‘])
#使用get(key,returnvalue)函數判斷key是否存在，存在則返回value，不存在則返回returnvalue    
print(‘李四的成績是:‘,score.get(‘李四‘,‘沒有李四的成績‘))
print(‘lily的成績是:‘,score.get(‘lily‘,‘沒有lily的成績‘))

#增加一個鍵值對，放入楊7的成績
score[‘楊7‘] = 100
print(‘楊7的成績是:‘,score.get(‘楊7‘,‘沒有楊7的成績‘))

#刪除一個鍵值對
print(‘目前成績單是：‘,score)
score.pop(‘張三‘)
print(‘刪除後的成績單是：‘,score)

set:一組無序且不重復的key，創建時需用list輸入集合。key不能放入可變對象。可做交集(&)、並集(|)計算。使用add()函數增加key，使用remove()函數刪除key。

#set
level = set([‘A‘,‘B‘,‘C‘,‘D‘])
print(‘set level:‘,level)
#增加一個key
level.add(‘E‘)
print(‘增加後level:‘,level)
#刪除一個key
level.remove(‘B‘)
print(‘刪除後level:‘,level)

level2 = set([‘A‘,‘B‘])
print(‘set level2:‘,level2)

print(‘level與level2的交集：‘,level&level2)
print(‘level與level2的並集：‘,level|level2) 

除法：/ ; 地板除：// （/的整數部分） ; 取余數：%

不可變對象：str是不變對象，而list是可變對象。對於不變對象來說，調用對象自身的任意方法，也不會改變該對象自身的內容。相反，這些方法會創建新的對象並返回，這樣，就保證了不可變對象本身永遠是不可變的。

a = ‘abc‘
print(‘替換a：‘,a.replace(‘a‘,‘A‘))
print(‘a:‘,a)
b=a.replace(‘a‘,‘A‘)
print(‘b:‘,b)

2.3 字符串與編碼

python 3使用Unicode編碼字符串，字符串類型str，如果要在網絡上傳輸或保存到磁盤上，需要將str變為字節為單位的bytes類型，數據用帶b前綴的單引號或雙引號表示。

相關函數：

• ord()：查看單個字符的編碼
• chr()：把編碼轉化為字符

也可用十六進制表示str：

>>> ‘\u597d‘
‘好‘
>>>

• encode()：將Unicode編碼的str編碼為指定的bytes。（中文無法用ascii編碼）

>>> ‘ABC‘.encode(‘ascii‘)
b‘ABC‘
>>> ‘大家好‘.encode(‘utf-8‘)
b‘\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd‘

• decode():將網絡或磁盤上讀取的字節流轉變為str

>>> b‘ABC‘.decode(‘utf-8‘)
‘ABC‘
>>> b‘ABC‘.decode(‘ascii‘)
‘ABC‘
>>> b‘\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd‘.decode(‘utf-8‘，errors=‘ignore‘)
‘大家好‘

• len()：計算str包含的字符，或bytes包含的字節數

>>> len(b‘ABC‘)
3
>>> len(‘ABC‘)
3
>>> len(‘大家好‘)
3
>>> len(b‘\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd‘)
9
>>> len(‘大家好‘.encode(‘utf-8‘))
9

.py文件包含中文時，需要在文件開頭註釋使用utf-8編碼，並將文件保存為UTF-8 without BOM編碼格式：

# -*- coding: utf-8 -*-

占位符：

使用%做占位符：

>>> print(‘%s=%d‘ % (‘1+2‘,3))
1+2=3

format():逐一替換字符串占位符{0},{1}...

>>> ‘{0}={1}‘.format(‘1+2‘,3)
‘1+2=3‘

2.4 條件判斷

遇到第一個為true的判斷之後，執行相應的程序塊，後續的elif、else將不再執行。

if <條件判斷1>:
    <執行1>
elif <條件判斷2>:
    <執行2>
elif <條件判斷3>:
    <執行3>
else:
    <執行4>

2.5 循環

for i in ...:

input = input(‘請輸入數值：‘)
max = int(input)
#range(max)生成0到max-1的整數序列，再通過list()轉化為list
list = list(range(max))
print(list)
sum = 0
for i in list:
    sum = sum + i
print(sum)

while ...:

input = input(‘請輸入數值：‘)
max = int(input)
#range(max)生成0到max-1的整數序列，再通過list()轉化為list
list = list(range(max))
print(list)
sum = 0
n = 0
while n < len(list):
    sum = sum + list[n]
    n = n + 1
print(sum)

三 函數

可以把函數名賦給一個變量，相當於給這個函數起了一個“別名”

• 函數定義：def定義，執行之return返回，若不寫return，則返回None。交互環境調用時，需要先切換到源程序文件所在目錄，執行from abstest import my_abs，然後再調用。

def func1(x):
    return x*x

• 空函數：如果還沒想好代碼怎麽寫，可以用pass占位符，避免運行時的語法錯誤

def func1(x):
    pass

• 參數檢查：可使用isinstance()做參數的數據類型檢查
• 返回多個值：返回一個元組tuple，而多個變量可以同時接收一個tuple，按位置賦給對應的值

 1 #一元二次方程求解
 2 def quadratic(a, b, c):
 3 #b*b也可以寫成b**2，表示b的2次方
 4     p = b*b - 4*a*c
 5     if p >=0:
 6         aws = math.sqrt(p)/(2*a)
 7         aws1 = (-1)*b/(2*a) + aws
 8         aws2 = (-1)*b/(2*a) - aws
 9         return aws1,aws2
10     else:
11     #共軛復根
12         aws = math.sqrt(-1*p)/(2*a)
13         aws1 = str((-1)*b/(2*a)) + ‘+i‘+ str(aws)
14         aws2 = str((-1)*b/(2*a)) + ‘-i‘+ str(aws)
15         return aws1,aws2
16   
17 print(quadratic(3, 3, 1))
18 print(quadratic(1, 3, -4))

• 參數：位置參數、默認參數（調用時按順序賦值，也可以寫上參數名）、可變參數（參數前面加了一個*號，在函數內部，參數numbers接收到的是一個tuple，因此，函數代碼完全不變。但是，調用該函數時，可以傳入任意個參數，包括0個參數。實參如果是list或tuple，可在前面加個*號，把list或tuple的元素變成可變參數傳進去）、關鍵字參數（關鍵字參數前面加**表示，允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict）、命名關鍵字參數（可以傳入任意不受限制的關鍵字參數，同時顯示關鍵字參數名稱。*，*後面的參數被視為命名關鍵字參數）、參數組合（參數定義的順序必須是：必選參數、默認參數、可變參數、命名關鍵字參數和關鍵字參數）

 1 #-------可變參數  求平方和--------
 2 def cal(*num):
 3     sum = 0
 4     for n in num:
 5         sum = sum + n**2
 6 
 7     return sum
 8 
 9 #調用時參數可變
10 print(cal())
11 print(cal(1,2))
12 print(cal(1,2,3))
13 
14 #實參為list的調用方式
15 list = [1,3,5]
16 print(cal(*list))

#--------關鍵字參數-----------
def person(name,sex,age=20,**kw):
#kw在函數內部為dict
    print(‘name:‘,name,‘sex:‘,sex,‘age:‘,age,‘other:‘,kw)

#調用時可傳入0或任意個含參數名的參數,age為默認參數
person(‘甲‘,‘F‘,city=‘beijing‘,grade = 3)
person(‘甲‘,‘F‘,30,city=‘beijing‘,grade = 4)

 1 #-------------命名關鍵字參數-------------
 2 #city,grade為命名關鍵字參數，使用標識符,*,
 3 def person1(name,sex,*,city,grade):
 4     print(‘name:‘,name,‘sex:‘,sex,‘city:‘,city,‘grade:‘,grade)
 5 
 6 #調用時命名關鍵字參數必須傳入參數名,用來和位置參數區別
 7 person1(‘甲‘,‘F‘,city=‘beijing‘,grade = 3)
 8 
 9 #前面有可變參數時，不需要再使用標識符,*,
10 def person2(name,sex,*args,city,grade):
11     print(‘name:‘,name,‘sex:‘,sex,‘args:‘,args,‘city:‘,city,‘grade:‘,grade)
12 
13 person2(‘乙‘,‘F‘,15,20,city=‘beijing‘,grade = 3)
14 
15 #命名關鍵字參數有缺省值的，可以簡化調用
16 def person3(name,sex,*,age = 20,city,grade):
17     print(‘name:‘,name,‘sex:‘,sex,‘age:‘,age,‘city:‘,city,‘grade:‘,grade)
18 #調用時，age有缺省值，可以不給出
19 person3(‘丙‘,‘F‘,city=‘beijing‘,grade = 3)

對於任意函數，都可以通過類似func(*args, **kw)的形式調用它，無論它的參數是如何定義的。

遞歸函數：遞歸的函數調用通過棧實現，如果調用次數過多會導致棧溢出，python解釋器沒有對尾遞歸（在函數返回的時候，調用自身本身，並且，return語句不能包含表達式）進行優化，故python即便使用了尾遞歸，仍然會棧溢出。

 1 #漢諾塔問題
 2 def hanoi(n,a,b,c):
 3     if n ==1 :
 4         print(a,‘->‘,c)
 5     else:
 6         hanoi(n-1,a,c,b)
 7         print(a,‘->‘,c)
 8         hanoi(n-1,b,a,c)
 9 
10 
11 hanoi(3,‘A‘,‘B‘,‘C‘)

四 高級特性

4.1 切片

list、tuple、字符串都可以切片，從而簡化代碼。例：[0:3]表示取索引0、1、2；默認從0開始，所以也可以寫為[:3]；[1:3]表示取1、2；[-2:]表示取-2，-1；[-2]表示取-2。

range()可創建一個整數列表，一般用在for循環中。range(start, stop[, step])，計數從start開始，默認為0，計數到stop-1，不包含stop，step默認為1。

 1 #去除字符串首尾的空格
 2 def trim(s):
 3     while s[0] == ‘ ‘:
 4         s = s[1:]
 5         if len(s) ==0:
 6             return s
 7     while s[-1] == ‘ ‘:
 8         s = s[:-2]
 9         if len(s) ==0:
10             return s
11     return s

4.2 叠代

判斷對象是否可叠代：

>>> from collections import Iterable
>>> isinstance(‘abc‘, Iterable) # str是否可叠代
True
>>> isinstance([1,2,3], Iterable) # list是否可叠代
True
>>> isinstance(123, Iterable) # 整數是否可叠代
False

叠代方式：

dict：默認叠代key：for key in d；叠代value：for value in d.values()；同時叠代key-value：for k, v in d.items()

字符串：for ch in ‘ABC‘叠代每一個字符

Python內置的enumerate函數可以把一個list變成索引-元素對，這樣就可以在for循環中同時叠代索引和元素本身：for i, value in enumerate([‘A‘, ‘B‘, ‘C‘])

也支持同時引用了兩個變量：for x, y in [(1, 1), (2, 4), (3, 9)]

 1 #叠代查找一個list中最小和最大值，並返回一個tuple
 2 def findMinAndMax(L):
 3     min = L[0] if len(L) != 0 else None
 4     max = L[0] if len(L) != 0 else None
 5     if len(L) == 0:
 6         return (min,max)
 7     else:
 8         for i in L:
 9             if i > max:
10                 max = i
11             if i < min:
12                 min = i
13         return (min,max)

4.3 列表生成式

列表生成式即List Comprehensions，用戶創建list。range(a,b)可生成a到b-1的list。可與for、if配合使用

>>> l = [x * x for x in range(1, 11)]
>>> l
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> l = [x * x for x in range(1, 11) if x * x %2 ==0]
>>> l
[4, 16, 36, 64, 100]
>>> l = [x + y for x in ‘ABC‘ for y in ‘XY‘]
>>> l
[‘AX‘, ‘AY‘, ‘BX‘, ‘BY‘, ‘CX‘, ‘CY‘]

#list中的字符串字母變小寫
L1 = [‘Hello‘, ‘World‘, 18, ‘Apple‘, None]
L2 = [x.lower() for x in L1  if isinstance(x,str)]

4.4 生成器

如果list元素特別多時，若直接創建list會占用過多空間。若列表元素可根據某種算法推算出來，則可以在循環的過程中推算出後續的元素。Python中，一邊循環一邊計算的機制，稱為生成器：generator。

創建方法一：將list的[]改為()

>>> l = [x * x for x in range(11)]
>>> l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> g = (x * x for x in range(11))
>>> g
<generator object <genexpr> at 0x0000000000B5B308>

訪問元素時，可使用next(g)逐一計算下一個元素，直至沒有更多元素時，返回StopIteration錯誤。也可以使用for n in g訪問。

若算法比較復雜，可使用函數實現，並用yield關鍵字，將函數變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

1 #把楊輝三角每一行看做一個list，試寫一個generator，不斷輸出下一行的list：
2 def triangles():
3     L = [1]
4     while True:
5         yield L
6         L = [1] + [L[i] + L[i + 1] for i in range(len(L)-1)] + [1]

4.5 叠代器

凡是可作用於for循環的對象都是Iterable類型；

可以使用isinstance()判斷一個對象是否是Iterable對象：

1 >>> from collections import Iterable
2 >>> isinstance([],Iterable)
3 True
4 >>> from collections import Iterator

凡是可作用於next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；

可以使用isinstance()判斷一個對象是否是Iterator對象：

1 >>> isinstance([],Iterator)
2 False
3 >>> isinstance((x for x in range(0,10)),Iterator)
4 True

集合數據類型如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函數獲得一個Iterator對象。

>>> isinstance(iter([]),Iterator)
True

Python入門 （一）