廖雪峯Python教程學習筆記（1）

1. Python 簡介

Python 是著名的“龜叔”Guido van Rossum（尼德蘭人）在1989年聖誕節期間，爲了打發無聊的聖誕節而編寫的一個編程語言。
Python 有着完善的基礎代碼庫，以及大量的第三方庫。使用 Python 可以寫出優雅，明確，簡單的代碼。
但是，Python 運行速度慢，因爲它是解釋型語言；Python 的代碼不能加密。

2. 安裝 Python

Python 是跨平臺的，有Windows、Mac和各種Linux/Unix系統平臺的安裝程序。
在 Windows 上安裝 Python，記得勾選 “Add Python 3.x to PATH”。
安裝完成後，打開命令提示窗口，敲入 python 後，出現下列信息表示安裝成功：

Microsoft Windows [版本 6.1.7601]
版權所有 (c) 2009 Microsoft Corporation。保留所有權利。

C:\Users\wangzhichao>python
Python 3.8.0 (tags/v3.8.0:fa919fd, Oct 14 2019, 19:37:50) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

解釋一下：
>>>：表示我們目前是在 Python 交互式環境中。
如何退出 Python 交互式環境呢？：輸入 exit() 並回車。

進入 Python 交互式環境的方式：
打開命令行提示窗口，輸入 python 並回車；
通過開始菜單選擇 Python 3.x （64-bit）菜單項，直接進入 Python 交互式環境。

第一種方式，在輸入 exit() 回車後，會回到命令行提示窗口；而第二種方式，在輸入 exit() 回車後，不會回到命令行提示窗口。

需要補充說明的是：
在 Windows 上運行 Python 時，請先啓動命令行，然後運行 python。
在 Mac 和 Linux 上運行 Python 時，請打開終端，然後運行 python3。

在 Python 交互式模式下，輸入 import this ，可以輸出 The Zen of Python：

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

2.1 Python 解釋器

Python 的解釋器有很多，包括 CPython，IPython，PyPy，Jython，IronPython。但使用最廣泛的還是 CPython。當我們從Python官方網站下載並安裝好Python 3.x後，我們就直接獲得了一個官方版本的解釋器，這就是 CPython。

3. 第一個 Python 程序

>>> print('hello, world')
hello, world
>>>

print() 是打印函數；
用單引號或者雙引號括起來的文本是字符串。

命令行模式和 Python 交互式模式的區別：

在命令行模式下，可以執行 python 進入 Python 交互式模式，還可以執行 python hello.py 運行一個.py 文件。需要注意的是，執行 .py文件只能在命令行模式下。

在命令行模式運行 .py 文件和在 Python 交互式模式直接運行 Python 代碼是有區別的：在 Python 交互式模式下會把每一行 Python 代碼的結果都打印出來，但是在命令行模式運行 .py 文件不會。也就是說，Python 交互式模式的代碼是輸入一行，執行一行，而命令行模式是一次性執行 .py 文件內的所有代碼。在實際開發中，Python 交互式模式主要是爲了調試 Python 代碼用的，並不是正式運行 Python 代碼的環境。

** ：表示指數運算。

>>> 2**10
1024

3.1 使用文本編譯器

這裏使用的微軟的 Visual Studio Code。

3.2 Python 代碼運行助手

運行 learning.py 後，就可以在通過廖雪峯老師的網站運行 Python 代碼了。真是神奇啊。

3.3 輸入和輸出

print() 函數可以接收多個字符串，用逗號“,”隔開，就可以連成一串輸出：

>>> print('The quick brown fox','jumps over','the lazy dog')
The quick brown fox jumps over the lazy dog
>>>

從打印結果可以看出，print() 會依次打印每個字符串，遇到逗號“,”會輸出一個空格。
print() 還可以打印整數，還可以計算結果。
再看一個例子：

>>> print('100 + 200 = ', 100 +200)
100 + 200 =  300

input() 函數讓用戶輸入字符串，並存放到一個變量裏面。

>>> name = input()
wangzhichao
>>> name
'wangzhichao'
>>>

解釋一下上面的代碼：
name = input()表示讓用戶輸入，並存放到一個變量裏面，回車後會看到下面一行出現閃動的光標。
在閃動的光標處輸入 wangzhichao，並回車後，界面上會另起一行變爲 >>>。
這時再輸入 name 並回車，可以看到變量內容。
一段帶提示信息的代碼：

>>> name = input('please enter your name:')
please enter your name:wangzhichao
>>> print('hello,', name)
hello, wangzhichao

4. Python 基礎

Python 的語法採用縮進方式來組織代碼。這要求我們遵守約定俗成的習慣，堅持使用 4 個空格的縮進。
以 #開頭的行是註釋。不以 # 開頭的每一行都是一個語句，當語句以冒號 :結尾時，縮進的語句視爲代碼塊。
Python 是大小寫敏感的。

4.1 數據類型和變量

數據類型

• 整數：1,100，-1000 等，16進制格式 0xff00，注意：Python 中的整數沒有大小限制；
• 浮點數：1.23，3.14，1.23e9，3.14e-5 等，注意：Python 中的浮點數沒有大小限制，但是超出一定範圍就直接表示爲 inf（無限大）。
• 字符串：以單引號 ’ 或雙引號 " 括起來的任意文本，如 ‘abc’，“xyz”，“I’m OK” ，‘I’m “OK”’
  看一下字符串的打印代碼：

  >>> print("I'm OK")
  I'm OK
  >>> print('I\'m \"OK\"')
  I'm "OK"
  >>> print('I\'m learning\nPython')
  I'm learning
  Python
  >>> print('\\\n\\')
  \
  \
  >>> print('\\\t\\')
  \       \
  >>> print(r'\\\t\\')
  \\\t\\
  >>> print('''line1)
  ... line2
  ... line3''')
  line1)
  line2
  line3
  >>>
  

  補充說明一下：
  Python 允許用r''表示''內部的字符串默認不轉義。注意，這時r''外邊沒有了單引號或 者雙引號。
  Python允許用'''...'''的格式表示多行內容。
• 布爾值：要麼是 True，要麼是 False。注意首字母是大寫的。
  布爾值可以用 and，or 和 not 運算。
• 空值：是 Python 裏一個特殊的值，用 None 表示。None 是一個特殊的空值，但 None不能理解爲 0，因爲 0 是有意義的。

變量

變量在程序中使用一個變量名來表示。在 Python 中，等號 = 是賦值語句，可以把任意數據類型賦值給變量，同一個變量可以反覆賦值，而且可以是不同類型的變量。

a = 123 # 整數
print(a)
a = 'ABC' # a 變爲了字符串
print(a)

補充說明：動態語言與靜態語言

動態語言是變量類型本身不固定的語言，靜態語言是變量類型本身固定的語言。靜態語言在定義變量時必須指定變量類型，這樣在進行賦值時，若類型不匹配，就會報錯。Python 是動態語言，Java 是靜態語言。

常量

常量就是不能變的變量。在 Python 中，通常用全部大寫的變量名錶示常量。

Python 中的除法

print(10 / 3) # 精確的除法
print(10 // 3) # 地板除
print(10 % 3) # 取餘

'''
打印結果:
3.3333333333333335
3
1
'''

4.2 字符串和編碼

字符編碼

• ASCII 編碼是美國信息交換標準代碼，包含 128 個字符，即大小寫英文字母，數字和一些符號，它需要一個字節。
• Unicode 編碼是統一碼，萬國碼，單一碼，是爲了解決傳統的字符編碼方案的侷限而產生的，它爲每種語言中的每個字符設定了統一併且唯一的二進制編碼，以滿足跨語言、跨平臺進行文本轉換、處理的要求。它通常是 2 個字節。
• UTF-8 編碼是針對 Unicode 的一種可變長度字符編碼。UTF-8 使用 1~4 字節爲每個字符編碼。

計算機系統通用的字符編碼方式：在計算機內存中，統一使用 Unicode 編碼，當需要保存到硬盤或者需要傳輸的時候，就轉換爲 UTF-8 編碼。

Python 的字符串

在 Python 3 版本中，字符串是以 Unicode 編碼的。
對於單個字符的編碼，ord()函數獲取字符的整數表示，chr() 函數把編碼轉換成對應的字符

print('包含中文的str')

# ord() 函數獲取字符的整數表示
print(ord('A')) # 打印：65
print(ord('王')) # 打印：29579

# chr() 函數把編碼轉換成對應的字符
print(chr(66)) # 打印：B
print(chr(36229)) # 打印：超

以 Unicode 表示的str編碼爲指定的bytes，需要用到 encode() 函數；
從網絡上或者磁盤上獲取字節流，對應的數據是bytes，這時要把bytes轉換成str，需要用到 decode() 函數。
len() 函數計算 str 時，表示包含多少個字符；計算bytes時，表示包含多少個字節。

在操作字符串時，我們經常遇到str和bytes的互相轉換。爲了避免亂碼問題，應當始終堅持使用 UTF-8 編碼對str和bytes進行轉換。

.py 文件開頭：

• #!/usr/bin/env python3 是爲了告訴 Linux/OS X 系統，這是一個 Python 可執行程序，Windows系統會忽略這個註釋；
• # -*- coding: utf-8 -*- 是爲了告訴 Python 解釋器，按照 UTF-8 編碼讀取源代碼，否則，你在源代碼中寫的中文輸出可能會有亂碼。

格式化

在 Python 中，採用的格式化方式和 C 語言是一致的，用 % 實現。

print('Hello, %s' % 'world') # Hello, world
print('Hi %s, your score is %d' %('Bart', 59)) # Hi Bart, your score is 59
print('親愛的%s你好！你%d月的話費是%.2f元，餘額是%.2f元。' %('王志超', 1, 30.22, 6.18))
print('%2d-%02d' %(3, 1)) # 3-01

4.3 使用 list 和 tuple

list

list，即列表，是 Python 內置的一種數據類型。list 是一種有序的集合，可以隨時添加和刪除其中的元素。
下面是代碼演示：

classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)

# len() 函數獲取 list 中元素的個數
print(len(classmates))

# 訪問集合中的元素
print(classmates[0])
print(classmates[1])
print(classmates[2])
# print(classmates[3]) # 此行報錯：IndexError

# 倒着取
print(classmates[-1]) # Tracy
print(classmates[-2]) # Bob
print(classmates[-3]) # Michael
# print(classmates[-4]) # 此行報錯：IndexError

# 追加元素
classmates.append('Adam')
print(classmates)

# 在指定位置插入元素
classmates.insert(1, 'Jack')
print(classmates)

# 刪除集合末尾的元素
classmates.pop()
print(classmates)

# 刪除指定位置的元素
classmates.pop(1)
print(classmates)

# 替換某個位置的元素
classmates[1] = 'Sarah'
print(classmates)

# list 裏面的元素數據類型可以不同
L = ['Apple', 123, True]
print(L)

# list 裏面的元素也可以是另一個 list
s = ['python', 'java', ['asp', 'php'], 'scheme']
print(s) # ['python', 'java', ['asp', 'php'], 'scheme']
print(len(s)) # 4

# 空 list
L = []
print(L) # []

比較特殊的地方是，list 裏面的元素數據類型可以不同，並且 list 裏面的元素也可以是另一個 list。

tuple

tuple，即元組，也是一種有序列表，和 list 非常類似，但是 tuple 一旦初始化就不能修改。
下面是演示代碼：

classmates = ('Michael', 'Bob', 'Tracy')

# 獲取 tuple 中的元素
print(classmates[0])
print(classmates[1])
print(classmates[2])

# 倒着取
print(classmates[-1])
print(classmates[-2])
print(classmates[-3])

# 獲取元素個數
print(len(classmates)) # 3

# 沒有追加，插入，刪除，替換的方法

# 定義一個空的 tuple
t = ()
print(t) # ()

# 定義一個一個元素的 tuple
# 不正確的寫法
t = (1)
print(t) # 1, 從打印結果看，這並不是一個 tuple，而是數值 1。
# 正確的寫法
t = (1,) # 只有1個元素的tuple定義時必須加一個逗號,，來消除歧義
print(t) # (1,)

# "可變"的 tuple
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t) # ('a', 'b', ['X', 'Y'])

4.4 條件判斷

if語句
if ... else 語句
if ... elif ... else語句： elif 是 else if的縮寫，可以有多個elif。

if 判斷條件可以簡寫，如

if x:
	print(True)

上面的代碼中，只要x是非零數值、非空字符串、非空list等，就判斷爲True，否則爲False。

int() 函數：把 str 轉換成整數，如果不合法，就拋出異常。

4.5 循環

for

# 遍歷 list
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

# 求從 1 到 10 的和
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum += x
print(sum)

# 求從 1 到 100 的和, 使用了 range(n) 函數：生成一個從 0 開始小於 n 的整數序列
sum = 0
for x in range(101):
    sum += x
print(sum)

while

# 計算 100 以內的所有奇數之和
sum = 0
n = 99
while n > 0:
    sum += n
    n = n - 2
print(sum)

break 跳出所在的循環

continue 跳過本次循環

4.6 使用 dict 和 set

dict

Python 內置了字典：dict 的支持，dict 全稱 dictionary，在其他語言中也稱爲 map，使用鍵值對（key-value）存儲，具有極快的查找速度。

d = {'Michael' : 95, 'Bob' : 75, 'Tracy' : 85}

# 根據 key，獲取 value
print(d['Michael'])

# 通過 key，存放 value
d['Adam'] = 67
print(d['Adam'])

# 一個 key 只對應一個 value，後面的 value 會覆蓋前面的 value
d['Jack'] = 66
d['Jack'] = 77
print(d['Jack'])

# 如果 key不存在，dict 就會報錯
# d['Thomas']
'''
錯誤信息：
Traceback (most recent call last):
  File "do_dict.py", line 16, in <module>
    d['Thomas']
KeyError: 'Thomas'
'''

# 判斷 dict 是否包含某個 key
if 'Thomas' in d:
    print(d['Thomas'])
else:
    print('d doesn\'t contain \'Thomas\'')

# dict 的 get() 方法
print(d.get('Thomas')) # 如果不存在 key，就返回 None。
print(d.get('Thomas', -1)) # 如果不存在 key，就返回指定的值。

# dict 的刪除方法 pop(key)，如果 key 存在，則該方法返回對應的 value。
print(d.pop('Bob')) # 打印：75
# print(d.pop('Thomas')) # 報錯
'''
Traceback (most recent call last):
  File "do_dict.py", line 37, in <module>
    print(d.pop('Thomas'))
KeyError: 'Thomas'
'''

dict 和 list 的比較：

• dict 的特點：
  • 查找和插入的速度極快，不會隨着 key 的增加而變慢；
  • 需要佔用大量的內存，內存浪費多。
• list的特點：
  • 查找和插入的時間隨着元素的增加而增加；
  • 佔用空間少，浪費內存少。

需要牢記的是 dict 的 key 必須是不可變對象。這是因爲 dict 根據 key 來計算 value 的存儲位置，如果每次計算相同的 key 得出的結果不同，那 dict 內部就完全混亂了。這個通過 key 計算位置的算法稱爲哈希算法（Hash）。
要保證 hash 的正確性，作爲 key 的對象就不能變。在 Python 中，字符串、整數等都是不可變的，因此，可以放心地作爲 key。而 list 是可變的，就不能作爲 key。

set

set 和 dict 類似，也是一組 key 的集合，但不存儲 value。由於 key 不能重複，所以，在 set 中，沒有重複的元素。

# 創建 set
s = {1, 2, 3}

# 創建 set，也提供一個 list 作爲輸入集合
s = set([1, 2, 3])
print(s) # {1, 2, 3}

# 如果提供的集合裏包含重複元素，在 set 中會被自動過濾
s = set([1, 1, 2, 2, 3, 3])
print(s) # {1, 2, 3}

# 添加元素方法：add()
print(s.add(4)) # None
print(s.add(4)) # None

# 刪除元素方法：remove()
print(s.remove(4)) # None
# print(s.remove(5)) # 報錯
'''
報錯信息：
Traceback (most recent call last):
  File "do_set.py", line 15, in <module>
    print(s.remove(5))
KeyError: 5
'''

# set 可以做數學意義上的交集，並集等操作
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # {2, 3}
print(s1 | s2) # {1, 2, 3, 4}

set 和 dict 的唯一區別僅在於沒有存儲對應的 value。set 的原理和 dict 是一樣的。set 同樣不能放入可變對象。

不可變對象再談

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

# list 是可變對象
a = ['c', 'b', 'a']
a.sort()
print(a) # ['a', 'b', 'c']
# 可以看到 a 的內容是可以變化的


# str 是不可變對象
a = 'abc'
b = a.replace('a', 'A')
print(b) # Abc
print(a) # abc