大師兄的Python學習筆記(二）: 面向對象和類

一、在開始之前

1. 一些常見問題

• 應該學習一種語言還是多種語言？

在精通一種語言的基礎上掌握得越多越好。

• 應該學習哪種編程語言？

工具箱里有各種工具，每種工具都有各自的用途。

• 學習Python可以做什么？

• Python就像工具箱里的瑞士軍刀，基本什么都能做。
• 目前Python在自動化運維、Web開發、爬蟲、人工智能、機器學習和數據分析領域應用的比較多。

• Python的優點是什么？

• 語言優雅、明確、簡單。
• 開發效率高: Python的第三方庫超級強大，Github上有很多開源代碼。
• 高級語言：不用過多考慮底層細節
• 可移植性：基本所有平臺都可以使用，而且不會有太大的區別（還是有部分區別，比如fork()）
• 可擴展性：存在許多使用 C 語言或 Fortran 編寫擴展的方法。
• 可嵌入型：可以把Python嵌入C/C++程序，從而向程序用戶提供腳本功能。

• Python的缺點是什么？

• 相比C語言和Java速度慢（對于計算機來說），除非要求極高，一般感覺不到。
• 全局解釋器鎖GIL(Global Interpreter Lock)導致線程不能利用多CPU，有一些變通的解決方案。

• 應該學習Python2還是Python3?

• Python2和Python3版本語法不兼容，創始人 Guido van Rossum表示Python2將更新至2020年。所以除非有特殊需求，學習最新版本肯定是沒錯的。
• 截止本文發布，目前最新版本是Python3.8.0。

2. 環境搭建

Python是一門解釋型語言，我們需要先把寫完的代碼編譯成計算機能看懂的語言(字節碼 bytes)，才能交給它執行,所以需要安裝編譯器(complier)。這里推薦兩種方式二選一：

• 方式一：直接安裝python3: Python下載、 安裝教程
• 方式二：安裝Anaconda，Anaconda內置了Python編譯器和很多工具: 下載Anaconda 、安裝教程

3. 開發工具推薦

我們需要用開發工具來編寫代碼，比較常用的開發工具包括:Pycharm、Sublime、Eclipse等，個人推薦用Pycharm。另外，Jupyter Notebook也是一款非常好用的工具，推薦安裝。

• Pycharm Community下載、安裝教程、使用教程
• Jupyter Notebook、安裝教程

4. 入門書籍推薦

• 《Python學習手冊》
• 《Python編程 從入門到實踐》

5. 關于縮進

• Python對縮進要求非常嚴格,相同邏輯層保持相同的縮進。
• 在Pycharm中，可以使用TAB鍵進行縮進，用Shift+TAB鍵取消縮進。

# 實例:
a = 0 # 第一層
def func():
   b = 1 # 第二層
   def printf():
       print(b) # 第三層
   printf()
func()

6. 命名規范

6.1 命名規范

命名應當盡量使用全拼寫的單詞：

• 包、文件名: 全小寫，可以使用下劃線
  例：my_file.py
• 類名: 大駝峰
  例：MyClass
• 函數名: 小駝峰
  例：myFunction
• 變量：全小寫，可以采用POSIX命名習慣
  例: my_variable
• 常量: 全大寫，可以采用POSIX命名習慣
  例: MAX_LENGTH

6.2 關于名字中的下劃線_

• 名字前面一個_表示保護變量(protected) :
  例：_name
• 名字前面兩個_表示內部使用(private):
  例：__name
• 名字前后各兩個_表示魔法函數/語法糖:
  例：__init__
• 名字末尾一個_用來解決命名沖突
  例：name_
• 單獨一個_表示不重要或無意義變量
  例：_

6.3 需要避免的命名

• 不要用類型名稱命名
  例: name_list(錯誤用法!）
• 不要用以下關鍵詞命名:

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 

7. 一些馬上要用到的函數

7.1 print()函數

• print()用于打印輸出，是最常用的函數之一。
• 語法：print(<對象>)

1）打印字符串

>>>print('Hello World!')
Hello World!

2）打印整數

>>>print(123456)
123456

3）打印多個字符串

>>>print('Hello''World')
HelloWorld
>>>print('Hello','World')
Hello World

4）打印間隔符

>>>print('www','baidu','com',sep='.')
www.baidu.com

7.2 help()函數

• help函數用于查看函數或模塊用途的詳細說明。
• help是獲得幫助最直接的方式，但內容為全英文。
• 語法: help(<對象>）

>>>help(print)
Help on built-in function print in module builtins:

print(...)
   print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
   
   Prints the values to a stream, or to sys.stdout by default.
   Optional keyword arguments:
   file:  a file-like object (stream); defaults to the current sys.stdout.
   sep:   string inserted between values, default a space.
   end:   string appended after the last value, default a newline.
   flush: whether to forcibly flush the stream.

7.3 type()函數

• type()函數用于查看對象的類型。
• 語法: type(<對象>)

>>>i = 1
>>>print(type(help))
<class 'int'>

8. 關于注釋

注釋是給自己和其他程序員看的內容。

8.1 注釋方法

• # 單行注釋

#這里是單行注釋

• ''' ''' 或 """ """ 多行注釋

'''這里
        是
            多行
                    注釋'''

8.2 注釋規則

• 注釋越少越好，簡單的代碼不要注釋
• 對于復雜的操作，應該在操作開始前寫上若干行注釋
• 對于不是一目了然的代碼，應在其行尾添加注釋（為了提高可讀性，注釋應該至少離開代碼 2 個空格）
• 絕不要描述代碼，假設閱讀代碼的人比你更懂 Python，他只是不知道你的代碼要做什么

二、語法基礎

1. 變量

• 變量用來存儲值，通過訪問變量可以訪問值。
• 變量是所有編程語言的基礎，python變量屬于弱類型，在創建變量時不需要聲明變量類型。
• 單“=” 在python中是賦值運算符。

1）變量賦值語法如下:

<變量名> = <變量值>

>>>i = 1
>>>print(i)
1

2）為多個變量同時賦值：

>>>a,b = 1,2
>>>print(a,b)
1 2

3）兩個變量交換值:

>>>a,b = 1,2
>>>a,b = b,a
>>>print(a,b)
2 1

1.1 變量類型：數字

1) int 整形

• int就是整數。
• 可以是十進制、二進制、八進制、十六進制。
• print(<int>)時，會自動換算到十進制。

# 十進制數字
>>>i = 1
>>>print(i)
1
>>>print(type(i))
<class 'int'>

# 二進制數字
>>>i = 0b1101 # 0b代表二進制
>>>print(i) # print二進制數字時，會自動換算成十進制
13
>>>print(type(i))
<class 'int'>

# 八進制數字  
i = 0o427 # 0o代表八進制
>>>print(i) # print八進制數字時，會自動換算成十進制
279
>>>print(type(i))
<class 'int'>

# 十六進制數字  
>>>i = 0xE1FF # 0x代表十六進制
>>>print(i) # print十六進制數字時，會自動換算成十進制
57855
>>>print(type(i))
<class 'int'>

2) float 浮點數

>>>f = 1.2
>>>print(f)
1.2
>>>print(type(f)
<class 'float'>

# 也可以用科學計數法表示
>>>e = 2.4e2
>>>print(e) 
240
>>>print(type(e)
<class 'float'>

3) complex 復數

>>>x = 1 + 5j
>>>print(x)
(1+5j)
>>>print(type(x))
<class 'complex'>

4) bool 布爾值

True與1等值，False與0等值

1.2 變量類型：bool 布爾值

• bool只有True和False兩個值
• True與1等值，False與0等值。

>>>a = True
>>>print(type(a))
<class 'bool'>

>>>print(a == 1) # 說明True和1相等
True

>>>b = 0
>>>print(type(b))
<class 'int'>

>>>print(b == False) # 說明False和0相等
True

1.3 變量類型：string 字符串

• 字符串就是文字類型
• 字符串的形式:'<str>'
• string可以切片

>>>str = 'Hello World!'
>>>print(str)
'Hello World!'
>>>print(type(str))
<class 'str'>

>>>str = '9'
>>>print(str)
'9'
>>>print(type(str))
<class 'str'>

1.4 變量類型：列表 list

• 列表是由一個或多個值組成的序列
• 列表的形式:[<l1>,<l2>,<l3>]
• 列表的值可以是任何類型
• 列表有順序，有序號
• 列表可以嵌套

>>>l = [1,'hello',0.5]
>>>print(l)
[1, 'hello', 0.5]
>>>print(type(l))
<class 'list'>

1.5 變量類型：元組 tuple

• 元組和list類似，區別是內容不可修改。
• 元組的形式:(<t1>,<t2>,<t3>)

>>>tup = (1,'hello',0.5)
>>>print(tup)
(1,'hello',0.5)
>>>print(type(tup))
<class 'tuple'>

1.6 字典 dict

• 字典是一種組合數據，包含一個或多個鍵(key)和值(value)的配對, key和value必須配對出現。
• dict的key值必須是不可變的數據類型，而value值的數據類型可以是任意類型
• 字典的形式：{<key1>:<value1>,<key2>:<value2>}
• 字典沒有順序
• 字典可以嵌套

>>>dict = {'name':'qq','age':1,'type':'雪納瑞'}
>>>print(dict)
{'name': 'qq', 'age': 1, 'type': '雪納瑞'}
>>>print(type(dict))
<class 'dict'>

1.7 集合 set

• 集合是一組無序且不重復的值
• 集合的形式:{s1,s2,s3}
• 集合的值只能是可以hash的值，比如:str, int, float, tuple,冰凍集合等

# set是內容的集合，內容不能重復
>>>a = {'雪納瑞','貴賓','柯基','拉布拉多'}
>>>print(a)
{'柯基', '貴賓', '拉布拉多', '雪納瑞'}
>>>print(type(a))
<class 'set'>

1.8 None

None是一個空值，所以也是一個值。

>>>n = None
>>>print(n)
None
>>>print(type(n))
<class 'NoneType'>

2. 運算符

2.1 算數運算符

• 進行算數運算的符號
• 包括: + - * / % ** //
• Python沒有自增自減運算符。

>>>a = 1 + 2 #加法
>>>print(a)
3

>>>a = 2 - 1 #減法
>>>print(a)
1

>>>a = 2 * 2 #乘法
>>>print(a)
4

>>>a = 9 / 3 # 除法
>>>print(a)
3

>>>a = 9 // 4 #取商
>>>print(a)
2

>>>a = 9 % 4 #取余
>>>print(a)
1

>>>a = 10 ** 2 #冪運算
>>>print(a)
100

2.2 比較運算符

• 對兩個變量或值進行比較的運算符，包括: == != > < >= <=
• 比較的結果一定是布爾值: True / False

>>>a = 10 == 10 #相等
>>>print(a)
True

>>>a = 10 != 10 #不相等
>>>print(a)
False

>>>a = 1 > 2 #大于
>>>print(a)
False

>>>a = 1 < 2 #大于
>>>print(a)
True

>>>a = 1 >= 1 #大于等于
>>>print(a)
True

>>>a = 1 <= 2 #小于等于
>>>print(a)
True

2.3 賦值運算符

>>>a = 'hello' #賦值
>>>print(a)
'hello'

>>>a = 0
>>>a += 1 # 是a = a + 1 的縮寫,所有的數學運算符都有縮寫形式
>>>print(a)
1
>>>a += 1
>>>print(a)
2

2.4 位運算符

• 二進制換位運算，包括：& | ^ ~ << >>
• 涉及到二進制計算，初學者可以跳過。

>>>a = 0b01001101 # 二進制數字
>>>b = 0b00100100

>>>c = a & b #按位與運算符：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0
>>>print(bin(c)) #打印二進制數字
0b100

>>>c = a | b #按位或運算符：只要對應的二個二進位有一個為1時，結果位就為1。
>>>print(bin(c))
0b1101101

>>>c = a ^ b #按位異或運算符：當兩對應的二進位相異時，結果為1。
>>>print(bin(c))
0b1101001

>>>c = ~ a #按位取反運算符：對數據的每個二進制位取反,即把1變為0,把0變為1。
>>>print(bin(c))
-0b1001110

>>>c = a << 2 #左移動運算符：運算數的各二進位全部左移若干位，由 << 右邊的數字指定了移動的位數，高位丟棄，低位補0。
>>>print(bin(c))
0b100110100

>>>c = a >> 2 #右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位，>> 右邊的數字指定了移動的位數
>>>print(bin(c))
0b10011

2.5 邏輯運算符

• 對布爾值進行計算的符號
• 包括：and(與，可以看作乘法）、or(或，可以看作加法）、not（非）
• 比如: True and False = 1 * 0 = 0 = False

>>>a = True # 可以看做1
>>>b = False # 可以看做0

>>>c = a and b # 與，也可以看做乘法
>>>print(c)
False

>>>c = a or b # 或，也可以看做加法
>>>print(c)
True

>>>c = not a # 非
>>>print(c)
False

2.6 成員位運算符

用來檢測某一個變量是否是另一個變量的成員,包括:in（包含） 和 not in（不包含）

>>>a = [1,2,3,4,5] #列表
>>>b = 2
>>>c = 6

>>>d = b in a # 是否包含
>>>print(d)
True

>>>d = c not in a # 是否不包含
>>>print(d)
True

2.7 身份運算符

• 用來檢測兩個變量的值是否相等
• 包含:is 和 is not

>>>a = 1
>>>b = 1

>>>c = a is b # 判斷是同一個變量
>>>print(c)
True

>>>c = a is not b # 判斷不是同一個變量
>>>print(c)
False

2.8 運算符的優先級

標識	備注
( )	最高優先級
**	指數
~ + -	按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法減法
>> <<	右移，左移運算符
&	位 'AND'
^ |	位運算符
<= < > >=	比較運算符
<> == !=	等于運算符
= %= /= //= -= += *= **=	賦值運算符
is、is not	身份運算符
in、not in	成員運算符
not、or、and	邏輯運算符

3. 程序結構

Python程序包含三種結構: 順序、分支和循環

3.1 順序結構

順序結構是按照從上到下一行一行的順序執行，是Python最基本的程序結構。

3.2 分支結構

分支結構根據條件判斷選擇一路執行。

1）單向分支: if 語句

if <條件表達式>:  #如果條件表達式為True則執行后面語句，條件表達式后面一定要有冒號
   <語句> #這里一定要有縮進!

if age > 18:
   print('你已經是成年人了。') 

2）雙向分支：if ... else... 語句

if <條件表達式>:  #如果條件表達式為True則執行后面語句，條件表達式后面一定要有冒號
   <語句1> #這里一定要有縮進!
else: #如果條件表達式為False則執行else后面的語句
   <語句2> #這里一定要有縮進！

if age > 18:
   print('你已經是成年人了。') 
else:
   print('你還沒有成年。')

3.3）多路分支: if ...elif ... else 語句

if <條件表達式>:  #如果條件表達式為True則執行后面語句，條件表達式后面一定要有冒號
   <語句1> #這里一定要有縮進!
elif <條件表達式>: #如果條件表達式為True則執行后面語句，elif可以有多個
   <語句2>
else: #如果前面的條件表達式全部為False則執行else后面的語句
   <語句3> #這里一定要有縮進！

if age > 18:
   print('你是成年人了。') 
elif age >= 15:
   print('你已經超過15歲了。')
elif age >= 10:
   print('你已經超過10歲了。')
else:
   print('你還不到10歲。')

4. 循環結構

重復執行某些固定動作或者處理基本固定的事物,包括:

• for循環
• while循環

4.1 for循環

• for循環有明確的循環次數。
• range(start,stop,steps)函數表示一個范圍的整數,例：range(1,10,1)表示從1-9。
• steps表示步長。

for <變量> in <序列>:
    <語句>    #這里必須有縮進

>>>j = 0
>>>for i in range(0,5):
>>>  j += 1
>>>print(j)
4

>>>for i in range(0,50,10):
>>>  print(i)
0
10
20
30
40

>>>str = 'Hello'
>>>for s in str:
>>>  print(s)
'H'
'e'
'l'
'l'
'o'

>>>list = ['banana','apple','grape']
>>>for l in list:
>>>  print(l)
'banana'
'apple'
'grape'

>>>dict = {1:'雪納瑞',2:'貴賓',3:'柯基'}
>>>for k in dict:
>>>  print(k,dict.get(k))
1 '雪納瑞'
2 '貴賓'
3 '柯基'

>>>tp = ((1,2,3),(2,3,4),(5,6,7))
>>>for a,b,c in tp:
>>>  print(a,b,c)
1 2 3
2 3 4
5 6 7

4.2 for...else...語句

• for循環完成后會執行后面的else語句
• 如果循環被中斷，else就不會執行

>>>j = 0
>>>for i in range(0,5):
>>>  j += 1
>>>else:
>>>  print(j)
4

>>>j = 0
>>>for i in range(0,5):
>>>  j += 1
>>>  break # 中斷循環
>>>else: 
>>>  print(j) # 這里不會被執行

4.3 while 循環

• while循環沒有明確的循環次數，只要條件滿足就會一直循環

while <條件表示式>:
   <語句> #縮進

>>>i = 1
>>>while i < 5:
>>>  print(i)
>>>  i += 1
1
2
3
4

>>>while True: # 這是個死循環
>>>  print('Hello World!)

4.4 while...else...語句

同for...else...語句

>>>i = 1
>>>while i < 5:
>>>  i += 1
>>>else:
>>>  print(i)
5

4.5 break,continue和pass

1）break：跳出一層循環

>>>for i in range(0,10):
>>>   print('Hello World!')
>>>   if i == 2:
>>>      break # 這里i到2就跳出循環，不會執行之后的循環
'Hello World!'
'Hello World!'

# 如果要跳出多層循環，就需要多次break
>>>a = 0
>>>for i in range(0,10):
>>>    for j in range(0,10):
>>>         a += 1 
>>>         if j == 5:
>>>           break  # 這里跳出里面一層的循環，但是會繼續執行外面的循環
>>>    if i == 6:
>>>        break  # 這里跳出外面一層的循環
>>>print(a)
42

2）continue: 結束本次循環，并開始下一輪循環

>>>i = 0
>>>while i < 5:
>>>  if i == 3:
>>>    continue # 當i為3時跳過一次循環
>>>  print(i)
0
1
2
4

3）pass: 占位符

>>>for i in range(1,5):
>>>  pass   # 有占位符，即使循環內沒有語句也可以執行

>>>for i in range(1,2):
>>>  pass
>>>  print('Hello World!') # pass后面的內容會執行
'Hello World!'
'Hello World!'

5. 函數

• 函數是一種代碼的組織形式。
• 一個函數通常完成一項功能。
• 調用函數前需要先定義。
• 函數可以嵌套。
• 函數讓代碼可以重復使用，減少代碼量。
• 函數可以將編程工作分解，便于擴展和修改。
• 函數讓代碼變得更具一致性。

5.1 定義函數

• 定義函數并不會調用執行
• 調用函數使用def關鍵字
• 請再看一下前面的命名規則
• 可以定義參數
• 函數內代碼必須縮進

def <函數名>(<參數>): #參數可以為空
   <代碼>

>>>def printInput(): 
>>>  print('HelloWorld!')

5.2 調用函數

• 用<函數名>(<參數>)調用函數
• 調用函數后函數內的程序開始按執行。

>>>def printInput():
>>>  print('Hello World!')
>>>printInput() # 這里調用函數
'Hello World!'

5.3 參數傳遞

1）普通參數

• 用于傳遞必要的數據或信息給函數。
• 調用時需要按順序傳入參數。

>>>def printInput(s1,s2): #定義函數時包含參數s
>>>  print(s1,s2) #在代碼中調用參數
>>>printInput('Hello','World!') #調用時這里必須傳入參數，不然會報錯。
'Hello World!'

2）關鍵字參數

• 調用時需要指定參數名。
• 調用時可以忽略傳入順序。

>>>def printInput(s1,s2): #定義函數時包含參數s
>>>  print(s1,s2) #在代碼中調用參數
>>>printInput(s2='Hey!',s1='You!) # 調用時不需要按照順序傳入參數
'You! Hey!'

3）默認參數

• 給參數賦一個默認值。
• 如果不傳入參數，將用默認值代替參數。

>>>def printInput(s='Hey'): #定義函數時包含,定義了參數s的默認值
>>>  print(s) #在代碼中調用參數
>>>printInput() # 如果不傳入參數，將調用默認參數
>>>printInput('Hello World!') # 如果傳入參數，將替代默認參數
'Hey'
'Hello World!'

4）收集參數

• 參數前加*。
• 把沒有位置、不能和定義時的參數位置相對應的參數，放入一個特定的數據結構中。

>>>def printInput(*str): # 定義一個不定長參數。 
>>>  for s in str:  #這里調用的參數是一個tuple
>>>    print(s)
>>>printInput('Hello','Python','World!') # 這里傳入的是3個參數
'Hello'
'Python'
'World!'

5）關鍵字收集參數

• 參數前加**。
• 把關鍵字參數按字典格式存入收集參數。

>>def printInput(**str): # 定義一個不定長參數。 
>>  for s in str:  #這里調用的參數是一個dict
>>    print(str.get(s))
>>printInput(var1='Hello',var2='Python',var3='World!') # 這里傳入的是3個參數
'Hello'
'Python'
'World!'

6）匿名參數

• 為lambda表達式傳入參數
• lambda表達式可以以后再理解。

>>>str = lambda arg1,arg2: arg1+arg2 #這里定義了一個lambda表達式
>>>print(str(‘Hello’,'World!')) #將參數傳入了表達式
Hello World!

7）參數混合調用順序

• 收集參數，關鍵字參數，普通參數可以混合使用。
• 參數順序: 普通參數 > 關鍵字參數 > 收集參數 > 關鍵字收集參數

>>>def printInput(s1,*args,s2='None',**kargs):
>>>    print('參數s1:',s1)
>>>    print('參數s2:',s2)
>>>    print('參數*args包括:',[x for x in args])
>>>    print('參數**kargs包括:',{v : k for k,v in kargs.items() })
>>>printInput('Hello','Python','I','love','Python',s2='World!',s3='Java',s4='C++',s5='JS')
參數s1: Hello
參數s2: World!
參數*args包括: ['Python', 'I', 'love', 'Python']
參數**kargs包括: {'Java': 's3', 'C++': 's4', 'JS': 's5'}

5.4 返回值

• 為函數返回一個結果值
• 使用return關鍵字
• 如果沒有return,默認在函數結尾 return None
• 一旦執行return,則結束函數的執行

>>>def printInput():
>>>  return "Hello World!" # 這里為函數返回結果
>>>  x = 1  # 注意！這里不會被執行
>>>print(printInput()) # 這里直接調用了函數的返回值
"Hello World!"

5.5 局部變量和全局變量

變量由作用范圍限制，分為全局變量和局部變量。

1）全局變量

• 在函數外部定義
• 在全局范圍可以使用
• 在局部范圍可以使用

>>>a = 1 # 創建全局變量
>>>def func():
>>>    print(a) # 在函數內調用全局變量
>>>func() # 調用函數
>>>print(a)
1
1

2）局部變量

• 在函數內部定義
• 在全局范圍無法使用
• 在局部范圍可以使用

>>>def func():
>>>    a = 1 # 創建局部變量
>>>    print(a)
>>>func()
>>>print(a) # 在函數外調用局部變量會報錯
1
NameError: name 'q' is not defined

3）提升局部變量為全局變量

使用global

>>>def func():
>>>    global a # 在函數內創建全局變量
>>>    a = 1
>>>    print(a)
>>>func()
>>>print(a) # 在函數外調用局部變量會報錯
1
1

4）LEGB原則

名稱（由內到外）	內容
- L（Local）	局部作用域
- E（Enclosing function locale）	外部嵌套函數作用域
- G（Global module）	函數定義所在模塊作用域
- B（Buildin）：	python內置魔法函數

5）globals和locals函數

• 通過globals()顯示所有全局變量
• 通過locals()顯示所有局部變量

>>>i = 1
>>>str = 'Hello World!'
>>>print('局部變量={0}'.format(locals()))
>>>print('全局變量={0}'.format(globals())) #自己試試打印出來吧

5.6 函數嵌套

• 嵌套函數即在函數內部定義函數并使用
• 外部函數的變量可以被內部函數所使用，但不能被內部函數修改，若要修改需要添加關鍵字nonlocal

>>>def funcA():
>>>    def funcB(): # 在函數內創建函數
>>>        a = 1
>>>        print(a)
>>>    funcB() # 在函數內調用函數
>>>funcA()
1

>>>def funcA():
>>>    a = 1
>>>    def funcB():
>>>        nonlocal a # 改變外部函數需要用nonlocal關鍵字，不然會報錯
>>>        a += 1
>>>    funcB()
>>>    print(a)
>>>funcA()
2

6. 部分字符串處理及內建函數

6.1 創建字符串

1）創建單行字符串

>>>str = 'Hello World!'
>>>print(str)
'Hello World!'

2）創建跨行字符串:

>>>str = '''Hello
>>>World!'''
>>>print(str)
Hello 
World!

6.2 訪問字符串

• 可以用[序號]訪問字符串

>>>str = 'Hello World!'
>>>print(str[0]) # 訪問字符串的第一個字符
H

>>>>str = 'Hello World!'
>>>print(str[-2]) # 訪問字符串的倒數第二個字符
d

• 字符串切片,格式:str[start,end,steps]

>>>str1 = 'Hello World!'
>>>str1 = str[2:5] # 訪問字符串第3-5個字符
>>>print(str1)
llo

>>>str2 = 'Hello World!'
>>>str2 = str[:4] # 訪問字符串第0-4個字符
>>>print(str2)
Hell

>>>str3 = 'Hello World!'
>>>str3 = str[0:8:2] # 訪問字符串第0-6個字符,步長為2
>>>print(str2)
HloW

>>>str4 = 'Hello World!'
>>>str4 = str[-1:2:-2] # 從右向左切片
>>>print(str2)
!lo l

6.3 字符串連接

>>>str1 = 'Hello'
>>>str2 = ' World'
>>>str = str1 + str2 # 這里將兩個字符串拼接在一起
>>>print(str)
Hello World

6.4 轉義字符

• 用一個特殊的方法表示出一系列不方便寫出的內容，比如回車鍵，換行鍵，退格鍵
• 借助反斜杠“\”字符，一旦字符串中出現反斜杠，則反斜杠后面一個火幾個字符表示已經不是原來的意思了，進行了轉義。

1）例：用\r\n轉義 回車+換行

• 在win系統下用\n，linux下需要\r\n
• 這應該是唯一一個系統區分的轉義案例

>>>str = 'Hello \r\nWorld' # 這里在字符串中增加了回車
>>>print(str)
Hello
World

2）例：一些常見應用

>>>print('c:\\folder\\file') # 用\\轉義\
c:\folder\file

>>>print('I love \'Python!\'') # 用\'轉義'
i love 'Python!'

>>>print('Hello \
>>>World!') # 遇到過長的代碼，可以用\換行繼續編寫
Hello World!

3）轉義字符表

轉義字符	描述
\	(在行尾時)續行符
\\	反斜杠符號
\’	單引號
\”	雙引號
\a	響鈴
\b	退格(Backspace)
\e	轉義
\000	空
\n	換行
\v	縱向制表符
\t	橫向制表符
\r	回車
\f	換頁
\oyy	八進制數yy代表的字符，例如：\o12代表換行
\xyy	十進制數yy代表的字符，例如：\x0a代表換行
\other	其它的字符以普通格式輸出

6.5 字符串運算符

1) + 字符串連接

>>>str = 'Hello' + ' World'
>>>print(str)
Hello World

2) * 重復字符串

>>>str = 'Hello World' * 2
>>>print(str)
Hello WorldHello World

3) 通過索引獲得字符

>>>str = 'Hello World' 
>>>s = str[0]
>>>print(s)
H

4) 截取一部分字符串

>>>str = 'Hello World' 
>>>s = str[2:5]
>>>print(s)
llo

5) 成員運算符 in 和 not in

>>>str = 'Hello World'
>>>a = 'hello' in str # 這里返回True
>>>b = 'Wrold' not in str # 這里返回False
>>>print(a)
>>>print(b)
True
False

6) 原始字符串 r或R

>>>str = r'Hello /nWorld' # 這里會將/n當做字符串而不是轉義字符處理
>>>print(str)
'Hello /nWorld'

7) Unicode字符串 u

Python3默認Unicode

>>>str = u'Hello World' # 這里字符串存儲為16位unicode字符

6.6 字符串格式化的五種方式

1）老版占位符方式

占位符必須和替換的內容匹配

常見占位符	含義
%d	整數
%f	浮點數
%s	字符串
%x	十六進制整數

>>>type = '雪納瑞'
>>>str = '我的小狗是, %s!'%type # 利用%s占位符
>>>print(str)
我的小狗是, 雪納瑞!

2）format方式

>>>type = '雪納瑞'
>>>str = '我的小狗是, {}!'.format(type)
>>>print(str)
我的小狗是, 雪納瑞!

>>>type = 'pp'
>>>str = '我的小狗是,{name}!.format(name=type)'
>>>print(str)
我的小狗是, pp!

3）format+解包方式

利用**解包字典

>>>dict = {'name':'qq','age':1}
>>>str = '我的小狗是{name},它今年{age}歲了'.format(**dict)
>>>print(str)
我的小狗是qq,它今年1歲了

4）Template方式

需要導入string.Template模塊

>>>from string import Template
>>>type = '雪納瑞'
>>>t = Template('我的小狗是,$type!')
>>>t.substitute(type=type)
'我的小狗是,雪納瑞!'

6.7 全部string內建函數

• 可以用help(string)查看全部內建函數。
• 或者通過傳送門看中文介紹: 內建函數資料

7. list、set、tuple和dict處理

7.1 部分list處理及內建函數

1）定義列表

>>>li = list(('雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']))
>>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World']]

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World']]

2）統計列表長度

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>print(len(li))
6

3）獲取元素index

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li_index = li.index('雪納瑞') # 這里獲取了序號
>>>print(li_index)
0

4）修改列表內容

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li[4] = 25 # 將li的第5個元素替換為25
>>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 25, ['Hello', 'World']]

5）插入元素

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li.append('金毛')
>>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World'], '金毛']

6）刪除元素

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li.remove('雪納瑞')
>>>print(li)
['貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World']]

7）列表pop和clear

• pop()將列表的最后一個元素從列表中刪除。
• clear()將列表清除。

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>a = li.pop() # 將列表的最后一個元素 li[-1] 從列表中剔除，并賦值到變量a
>>>print(a)
>>>print(li)
['Hello', 'World']
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19]

>>>li.clear() # 清空整個列表
>>>print(li)
[]

8）列表便利

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>for i in li:
>>>  print(i)
雪納瑞
貴賓犬
柯基
阿拉斯加
19
['Hello', 'World']

>>>print([i for i in li]) # 表達式的方法
雪納瑞
貴賓犬
柯基
阿拉斯加
19
['Hello', 'World']

9）更多列表操作符

• 列表重復

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li = li*2 # 將內容重復兩次
>>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World'], '雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World']]

• 列表連接

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>li1 = [1,2,3]
>>>li = li + li1 # 兩個列表組合
>>print(li)
['雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World'], 1, 2, 3]

• 判斷元素是否在列表中

>>>li = ['雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World']]
>>>print('雪納瑞' in li)
True

10）全部list內建函數

• 可以用help(list)查看全部內建函數。
• 或者通過傳送門看中文介紹: 內建函數資料

7.2 部分set集合處理及內建函數

• 集合set是一個無序的不重復元素序列, set中不會存在相同的元素

1）創建set

>>>a = {'雪納瑞','貴賓犬','柯基','阿拉斯加',19}
>>>b = set(('雪納瑞','貴賓犬','柯基','阿拉斯加',19)) # 第二種方式
>>>print(a)
{'阿拉斯加', '柯基', '雪納瑞', '貴賓犬', 19}

2）集合運算

運算符	備注
a - b	集合a中包含而集合b中不包含的元素
a | b	集合a和b中包含的所有元素，重復的元素只留一個
a & b	集合a和b中同時包含的元素
a ^ b	不同時包含于a和b的元素

>>>a = {'a','b','c'}
>>>b = {'c','d','e'}

>>>print(a-b) #集合a中包含而集合b中不包含的元素
{'a', 'b'}

>>>print(a|b) #集合a和b中包含的所有元素，重復的元素只留一個
{'a', 'b', 'c', 'd', 'e'}

>>>print(a&b) #集合a和b中同時包含的元素
{'c'}

>>>print(a^b) #不同時包含于a和b的元素
{'a', 'b', 'd', 'e'}

3）添加元素

>>>a = {'雪納瑞','貴賓','柯基'}
>>>a.add('金毛')
>>>print(a)
{'柯基', '金毛', '雪納瑞', '貴賓'}

>>>a.update('秋田犬','8歲') # 添加多個元素
>>>print(set)
{'8', '歲', '金毛', '秋', '田', '雪納瑞', '犬', '貴賓', '柯基'}

4）移除元素

>>>a = {'雪納瑞','貴賓','柯基','貴賓犬'}
>>>a.remove('貴賓犬')
>>>print(a)
{'柯基', '雪納瑞', '貴賓'}

>>>a.pop() #隨機刪除一個元素
>>>print(a) #這里的結果是隨機的
{'雪納瑞', '貴賓'}

5）巧妙利用set為list去重

>>a = ['雪納瑞','雪納瑞','貴賓','柯基','貴賓犬','柯基']
>>a = list(set(a)) #先轉成set,再轉回list
>>print(a) #完成去重，但是位置也被隨機改變了
['柯基', '雪納瑞', '貴賓犬', '貴賓']

6）全部set內建函數

• 可以用help(set)查看全部內建函數。
• 或者通過傳送門看中文介紹: set內建函數

7.3 部分tuple元組處理及內建函數

• Python的元組與列表類似，不同之處在于元組的元素不能修改。

1）創建元組

注意：如果元祖只包含一個值，需要在值后面加,

>>>tup1 = ('雪納瑞',) # 如果只有一個元素，需要在元素后加,
>>>print(tup1)
('雪納瑞',)

>>>tup2 = ('雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World'])
>>>print(tup2)
('雪納瑞', '貴賓犬', '柯基', '阿拉斯加', 19, ['Hello', 'World'])

2）訪問元組

>>>tup1 = ('雪納瑞','貴賓犬','柯基','阿拉斯加',19,['Hello','World'])
>>>print(tup1[0]) # 和list一樣，訪問第1個元素
雪納瑞

>>>print(tup1[3:5])
('阿拉斯加', 19)

3） 拼接元組

元組的內容不可以修改，但是可以拼接

>>>tup1 = ('雪納瑞',)
>>>tup2 = ('柯基','金毛','拉不拉多')
>>>tup = tup1 + tup2
>>>print(tup)
('雪納瑞', '柯基', '金毛', '拉不拉多')

4） 刪除元組

將對象刪除

>>>tup = ('柯基','金毛','拉不拉多')
>>>del tup
NameError: name 'tup' is not defined

5）全部tuple內建函數

• 可以用help(tuple)查看全部內建函數。
• 或者通過傳送門看中文介紹:tuple內建函數

7.4 部分dict字典處理及內建函數

• 由于dict采用的是hash算法，所以查找效率會比list快很多

1）創建字典

• key只能是int或者string,且不能改變
• value可以是任何值
• 可以用setdefault創建一個默認值，如果key沒有對應value，則用默認值替代。

>>>d1 = {'姓名':'pp','年齡':12,'性別':'男','品種':'雪納瑞'}
>>>print(d1)
{'姓名': 'pp', '年齡': 12, '性別': '男', '品種': '雪納瑞'}

>>>d1.setdefault(‘愛吃','餅干') # 設定了一個默認值，如果字典中未定義該key或者value則用默認值代替
>>>print(d1['愛吃'])
餅干

2）訪問字典

>>>d1 = {'姓名':'pp','年齡':12,'性別':'男','品種':'雪納瑞'}
>>>print(d1['年齡'])
12

>>>print(d1.get('性別'))
男

3）修改字典元素

>>>d1 = {'姓名':'pp','年齡':12,'性別':'男','品種':'雪納瑞'}
>>>d1['姓名'] = 'qq' # 如果key不存在則添加元素
>>>print(d1)
{'姓名': 'qq', '年齡': 12, '性別': '男', '品種': '雪納瑞'}

4）刪除字典元素

>>>d1 = {'姓名':'pp','年齡':12,'性別':'男','品種':'雪納瑞'}
>>>del d1['品種'] # 刪除指定的key和value
>>>print(d1)
{'姓名': 'pp', '年齡': 12, '性別': '男'}

>>>d1.clear() # 清空字典
>>>print(d1)
{}

>>>del d1 # 刪除字典
NameError: name 'd1' is not defined

5）全部dict內建函數

• 可以用help(dict)查看全部內建函數。
• 或者通過傳送門看中文介紹:dict內建函數

8 遞歸函數

• 在函數內直接或間接調用其自身，叫做遞歸函數。
• 遞歸函數必須要有一個終止遞歸的條件，否則會棧溢出。
• 遞歸函數的運算速度相對較慢

>>># 下面案例通過遞歸函數實現了階乘
>>>def func(n):
>>>   print(n)
>>>   if n == 1: # 這里必須有一個終止遞歸的條件，否則會棧溢出
>>>    return 1
>>>   return n * func(n-1)
>>>print(func(5))
5
4
3
2
1
1
120

參考資料

• https://www.runoob.com 菜鳥教程
• http://www.tulingxueyuan.com/ 北京圖靈學院
• http://www.imooc.com/article/19184?block_id=tuijian_wz#child_5_1 兩點水
• https://blog.csdn.net/weixin_44213550/article/details/91346411 python老菜鳥
• https://realpython.com/python-string-formatting/ Dan Bader
• https://www.liaoxuefeng.com/ 廖雪峰
• https://blog.csdn.net/Gnewocean/article/details/85319590 新海說
• 《Python學習手冊》Mark Lutz
• 《Python編程 從入門到實踐》Eric Matthes

本文作者：大師兄(superkmi)

夢幻微武俠