前端入職學習筆記-第四周第一天（python學習）
學習地址：python學習-廖雪峰
在正式編寫第一個Python程式前，我們先複習一下什麼是命令列模式和Python互動模式。
命令列模式
在Windows開始選單選擇“命令提示符”，就進入到命令列模式，它的提示符類似C:\>：
┌────────────────────────────────────────────────────────┐ │Command Prompt - □ x │ ├────────────────────────────────────────────────────────┤ │Microsoft Windows [Version 10.0.0] │ │(c) 2015 Microsoft Corporation. All rights reserved. │ │ │ │C:\> _ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘
Python互動模式
在命令列模式下敲命令python，就看到類似如下的一堆文字輸出，然後就進入到Python互動模式，它的提示符是>>>。
┌────────────────────────────────────────────────────────┐ │Command Prompt - python - □ x │ ├────────────────────────────────────────────────────────┤ │Microsoft Windows [Version 10.0.0] │ │(c) 2015 Microsoft Corporation. All rights reserved. │ │ │ │C:\> python │ │Python 3.7 ... on win32 │ │Type "help", ... for more information. │ │>>> _ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘
在Python互動模式下輸入exit()並回車，就退出了Python互動模式，並回到命令列模式：
┌────────────────────────────────────────────────────────┐ │Command Prompt - □ x │ ├────────────────────────────────────────────────────────┤ │Microsoft Windows [Version 10.0.0] │ │(c) 2015 Microsoft Corporation. All rights reserved. │ │ │ │C:\> python │ │Python 3.7 ... on win32 │ │Type "help", ... for more information. │ │>>> exit() │ │ │ │C:\> _ │ │ │ │ │ └────────────────────────────────────────────────────────┘
也可以直接通過開始選單選擇Python (command line)選單項，直接進入Python互動模式，但是輸入exit()後窗口會直接關閉，不會回到命令列模式。
然後，選擇一個目錄，例如C:\work，把檔案儲存為hello.py，就可以開啟命令列視窗，把當前目錄切換到hello.py所在目錄，就可以執行這個程式了：
C:\work> python hello.py
hello, world
也可以儲存為別的名字，比如first.py，但是必須要以.py結尾，其他的都不行。此外，檔名只能是英文字母、數字和下劃線的組合。
輸入
現在，你已經可以用print()輸出你想要的結果了。但是，如果要讓使用者從電腦輸入一些字元怎麼辦？Python提供了一個input()，可以讓使用者輸入字串，並存放到一個變數裡。比如輸入使用者的名字：
name = input()
print('hello,', name)
執行上面的程式，第一行程式碼會讓使用者輸入任意字元作為自己的名字，然後存入name變數中；第二行程式碼會根據使用者的名字向用戶說hello，比如輸入Michael：
C:\Workspace> python hello.py
Michael
hello, Michael
附
name = input('please enter your name: ')
print('hello,', name)資料型別
整數
浮點數
整數和浮點數在計算機內部儲存的方式是不同的，整數運算永遠是精確的（除法難道也是精確的？是的！），而浮點數運算則可能會有四捨五入的誤差。
字串
字串是以單引號'或雙引號"括起來的任意文字，
如果字串內部既包含'又包含"怎麼辦？可以用轉義字元\來標識，比如：
'I\'m \"OK\"!'
如果字串裡面有很多字元都需要轉義，就需要加很多\，為了簡化，Python還允許用r''表示''內部的字串預設不轉義：
>>> print('\\\t\\')
\ \
>>> print(r'\\\t\\')
\\\t\\
如果字串內部有很多換行，用\n寫在一行裡不好閱讀，為了簡化，Python允許用'''...'''的格式表示多行內容：
>>> print('''line1
... line2
... line3''')
line1
line2
line3
布林值
布林值和布林代數的表示完全一致，一個布林值只有True、False兩種值，要麼是True，要麼是False，在Python中，可以直接用True、False表示布林值（請注意大小寫）
布林值可以用and、or和not運算。
空值
空值是Python裡一個特殊的值，用None表示。None不能理解為0，因為0是有意義的，而None是一個特殊的空值。
變數
變數的概念基本上和初中代數的方程變數是一致的，只是在計算機程式中，變數不僅可以是數字，還可以是任意資料型別。
Python的字串
對於單個字元的編碼，Python提供了ord()函式獲取字元的整數表示，chr()函式把編碼轉換為對應的字元：
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
由於Python原始碼也是一個文字檔案，所以，當你的原始碼中包含中文的時候，在儲存原始碼時，就需要務必指定儲存為UTF-8編碼。當Python直譯器讀取原始碼時，為了讓它按UTF-8編碼讀取，我們通常在檔案開頭寫上這兩行：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行註釋是為了告訴Linux/OS X系統，這是一個Python可執行程式，Windows系統會忽略這個註釋；
第二行註釋是為了告訴Python直譯器，按照UTF-8編碼讀取原始碼，否則，你在原始碼中寫的中文輸出可能會有亂碼。
佔位符
在Python中，採用的格式化方式和C語言是一致的，用%實現，舉例如下：
>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
你可能猜到了，%運算子就是用來格式化字串的。在字串內部，%s表示用字串替換，%d表示用整數替換，有幾個%?佔位符，後面就跟幾個變數或者值，順序要對應好。如果只有一個%?，括號可以省略。
常見的佔位符有：
| 佔位符 | 替換內容 |
|---|---|
| %d | 整數 |
| %f | 浮點數 |
| %s | 字串 |
| %x | 十六進位制整數 |
list
Python內建的一種資料型別是列表：list。list是一種有序的集合，可以隨時新增和刪除其中的元素。
比如，列出班裡所有同學的名字，就可以用一個list表示：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
變數classmates就是一個list。用len()函式可以獲得list元素的個數：
>>> len(classmates)
3
用索引來訪問list中每一個位置的元素，記得索引是從0開始的：
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
當索引超出了範圍時，Python會報一個IndexError錯誤，所以，要確保索引不要越界，記得最後一個元素的索引是len(classmates) - 1。
如果要取最後一個元素，除了計算索引位置外，還可以用-1做索引，直接獲取最後一個元素：
>>> classmates[-1]
'Tracy'
list是一個可變的有序表，所以，可以往list中追加元素到末尾：
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
也可以把元素插入到指定的位置，比如索引號為1的位置：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
要刪除list末尾的元素，用pop()方法：
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
要刪除指定位置的元素，用pop(i)方法，其中i是索引位置：
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
要把某個元素替換成別的元素，可以直接賦值給對應的索引位置：
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
list裡面的元素的資料型別也可以不同，比如：
>>> L = ['Apple', 123, True]
list元素也可以是另一個list，比如：
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
要注意s只有4個元素，其中s[2]又是一個list，如果拆開寫就更容易理解了：
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
要拿到'php'可以寫p[1]或者s[2][1]，因此s可以看成是一個二維陣列，類似的還有三維、四維……陣列，不過很少用到。
如果一個list中一個元素也沒有，就是一個空的list，它的長度為0：
>>> L = []
>>> len(L)
0
tuple
另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：
>>> classmates = ('Michael', 'Bob', 'Tracy')
現在，classmates這個tuple不能變了，它也沒有append()，insert()這樣的方法。其他獲取元素的方法和list是一樣的，你可以正常地使用classmates[0]，classmates[-1]，但不能賦值成另外的元素。
但是，要定義一個只有1個元素的tuple，如果你這麼定義：
>>> t = (1)
>>> t
1
定義的不是tuple，是1這個數！這是因為括號()既可以表示tuple，又可以表示數學公式中的小括號，這就產生了歧義，因此，Python規定，這種情況下，按小括號進行計算，計算結果自然是1。
所以，只有1個元素的tuple定義時必須加一個逗號,，來消除歧義：
>>> t = (1,)
>>> t
(1,)
Python在顯示只有1個元素的tuple時，也會加一個逗號,，以免你誤解成數學計算意義上的括號。
最後來看一個“可變的”tuple：
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
這個tuple定義的時候有3個元素，分別是'a'，'b'和一個list。
條件判斷
elif是else if的縮寫，完全可以有多個elif，所以if語句的完整形式就是：
if <條件判斷1>:
<執行1>
elif <條件判斷2>:
<執行2>
elif <條件判斷3>:
<執行3>
else:
<執行4>
input()返回的資料型別是str，str不能直接和整數比較，必須先把str轉換成整數。Python提供了int()函式來完成這件事情：
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00後')
迴圈
我們想計算1-10的整數之和，可以用一個sum變數做累加：
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)
range(101)就可以生成0-100的整數序列
第二種迴圈是while迴圈，只要條件滿足，就不斷迴圈，條件不滿足時退出迴圈。比如我們要計算100以內所有奇數之和，可以用while迴圈實現：
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
在迴圈內部變數n不斷自減，直到變為-1時，不再滿足while條件，迴圈退出。
range(101)就可以生成0-100的整數序列，計算如下：
break
如果要提前結束迴圈，可以用break語句：
n = 1
while n <= 100:
if n > 10: # 當n = 11時，條件滿足，執行break語句
break # break語句會結束當前迴圈
print(n)
n = n + 1
print('END')
執行上面的程式碼可以看到，打印出1~10後，緊接著列印END，程式結束。
continue
上面的程式可以打印出1～10。但是，如果我們想只打印奇數，可以用continue語句跳過某些迴圈：
n = 0
while n < 10:
n = n + 1
if n % 2 == 0: # 如果n是偶數，執行continue語句
continue # continue語句會直接繼續下一輪迴圈，後續的print()語句不會執行
print(n)
執行上面的程式碼可以看到，列印的不再是1～10，而是1，3，5，7，9。
可見continue的作用是提前結束本輪迴圈，並直接開始下一輪迴圈。
dict
如果用dict實現，只需要一個“名字”-“成績”的對照表，直接根據名字查詢成績，無論這個表有多大，查詢速度都不會變慢。用Python寫一個dict如下：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
要避免key不存在的錯誤，有兩種辦法，一是通過in判斷key是否存在：
>>> 'Thomas' in d
False
二是通過dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
set
set和dict類似，也是一組key的集合，但不儲存value。由於key不能重複，所以，在set中，沒有重複的key。
要建立一個set，需要提供一個list作為輸入集合：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意，傳入的引數[1, 2, 3]是一個list，而顯示的{1, 2, 3}只是告訴你這個set內部有1，2，3這3個元素，顯示的順序也不表示set是有序的。。
重複元素在set中自動被過濾：
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}通過add(key)方法可以新增元素到set中，可以重複新增，但不會有效果：
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
通過remove(key)方法可以刪除元素：
>>> s.remove(4)
>>> s
{1, 2, 3}
set可以看成數學意義上的無序和無重複元素的集合，因此，兩個set可以做數學意義上的交集、並集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set和dict的唯一區別僅在於沒有儲存對應的value，但是，set的原理和dict一樣，所以，同樣不可以放入可變物件，因為無法判斷兩個可變物件是否相等，也就無法保證set內部“不會有重複元素”。
函式
呼叫abs函式：
>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34
呼叫函式max()可以接收任意多個引數，並返回最大的那個：
>>> max(1, 2)
2
>>> max(2, 3, 1, -5)
3
數名其實就是指向一個函式物件的引用，完全可以把函式名賦給一個變數，相當於給這個函式起了一個“別名”：
>>> a = abs # 變數a指向abs函式
>>> a(-1) # 所以也可以通過a呼叫abs函式
1
在Python中，定義一個函式要使用def語句，依次寫出函式名、括號、括號中的引數和冒號:，然後，在縮排塊中編寫函式體，函式的返回值用return語句返回。
┌────────────────────────────────────────────────────────┐
│Command Prompt - python - □ x │
├────────────────────────────────────────────────────────┤
│>>> def my_abs(x): │
│... if x >= 0: │
│... return x │
│... else: │
│... return -x │
│... │
│>>> my_abs(-9) │
│9 │
│>>> _ │
│ │
│ │
└────────────────────────────────────────────────────────┘
空函式
如果想定義一個什麼事也不做的空函式，可以用pass語句：
def nop():
pass
pass語句什麼都不做，那有什麼用？實際上pass可以用來作為佔位符，比如現在還沒想好怎麼寫函式的程式碼，就可以先放一個pass，讓程式碼能執行起來。
pass還可以用在其他語句裡，比如：
if age >= 18:
pass
缺少了pass，程式碼執行就會有語法錯誤。
返回多個值
函式可以返回多個值嗎？答案是肯定的。
比如在遊戲中經常需要從一個點移動到另一個點，給出座標、位移和角度，就可以計算出新的座標：
import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
import math語句表示匯入math包，並允許後續程式碼引用math包裡的sin、cos等函式。
如果要繼續傳入年齡、城市等資訊怎麼辦？這樣會使得呼叫函式的複雜度大大增加。
我們可以把年齡和城市設為預設引數：
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
可變引數
在Python函式中，還可以定義可變引數。顧名思義，可變引數就是傳入的引數個數是可變的，可以是1個、2個到任意個，還可以是0個。
我們以數學題為例子，給定一組數字a，b，c……，請計算a2 + b2 + c2 + ……。
所以，我們把函式的引數改為可變引數：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
定義可變引數和定義一個list或tuple引數相比，僅僅在引數前面加了一個*號。在函式內部，引數numbers接收到的是一個tuple，因此，函式程式碼完全不變。但是，呼叫該函式時，可以傳入任意個引數，包括0個引數.