python的基本使用

---

print 功能

print 字串

• python 中 print 字串 要加’ ‘(單引號)或者” “(雙引號)。
• 要顯示引號：加反斜槓\ 或者外層用雙引號

>>> print('hello world')
hello world
>>> print("hello world 2")
hello world 2
print('I\'m')
I'm
print("I'm")
I'm

print 字串疊加

可以使用 + 將兩個字串連結起來。

>>> print('Hello world' + ' Hello Gong Kong')
Hello world Hello Gong Kong

字串不能直接+數字,可以包在’ '裡面或者通過str()轉化成string

>>>print('apple'+4)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: must be str, not int
>>>print('apple'+'4')
apple4
>>>print('apple'+str(4))
apple4

int()可以把整數的string轉化為int，而小數形式的string需要通過float()轉化

>>>print(int('2.2')+2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '2.2'
>>>print(int('2')+2)
4
>>>print(float('2.2')+2)
4.2

簡單運算

可以直接print 加法+,減法-,乘法*,除法/.
注意：字串不可以直接和數字相加，否則出現錯誤。

>>> print(1 + 1)
2
>>> print(3 - 1)
2
>>> print(3 * 4)
12
>>> print(12 / 4)
3.0
>>> print('iphone' + 4)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
print('iphone' + 4)
TypeError: must be str, not int

int()和 float()；當int()一個浮點型數時，int會保留整數部分,比如 int(1.9),會輸出1,而不是四捨五入。

>>> print(int('2') + 3) # int為定義整數型 
5
>>> print(int(1.9)) # 當定義為一個浮點型數時，int會保留整數部分
1
>>>print(int(2.6)+2)
4
>>> print(float('1.2') + 3) # float是浮點型，可以把字串轉換為小數
4.2

基礎數學運算

基本的加減乘除

python可以直接運算數字，也可以加print 進行運算。

>>> 1 + 1
2
>>> 2 - 1
1
>>> 2 * 3
6
>>> 4 / 3
1.3333333333333333

^ 與 *

python當中 ^ 符號，區別於其他語言，在python中，^用兩個*表示，如3的平方為3**2 , **3表示立方，**4表示4次方，依次類推。

>>> 3 ** 2  # **2表示3的二次方
9
>>> 3 ** 3  # **3表示3的三次方
27

取餘數 %

取餘數符號為“%”。

>>> 8 % 3
2

取整//

>>>9//4
2

Python比較運算子

以下假設變數a為10，變數b為20：

運算子	描述	例項
==	等於 - 比較物件是否相等	(a == b) 返回 False。
!=	不等於 - 比較兩個物件是否不相等	(a != b) 返回 true.
<>	不等於 - 比較兩個物件是否不相等	(a <> b) 返回 true。這個運算子類似 != 。
>	大於 - 返回x是否大於y	(a > b) 返回 False。
<	小於 - 返回x是否小於y。所有比較運算子返回1表示真，返回0表示假。這分別與特殊的變數True和False等價。	(a < b) 返回 true。
>=	大於等於 - 返回x是否大於等於y。	(a >= b) 返回 False。
<=	小於等於 - 返回x是否小於等於y。	(a <= b) 返回 true。

Python賦值運算子

以下假設變數a為10，變數b為20：

運算子	描述	例項
=	簡單的賦值運算子	c = a + b 將 a + b 的運算結果賦值為 c
+=	加法賦值運算子	c += a 等效於 c = c + a
-=	減法賦值運算子	c -= a 等效於 c = c - a
*=	乘法賦值運算子	c *= a 等效於 c = c * a
/=	除法賦值運算子	c /= a 等效於 c = c / a
%=	取模賦值運算子	c %= a 等效於 c = c % a
**=	冪賦值運算子	c **= a 等效於 c = c ** a
//=	取整除賦值運算子	c //= a 等效於 c = c // a

Python邏輯運算子

Python語言支援邏輯運算子，以下假設變數 a 為 10, b為 20:

運算子	邏輯表示式	描述	例項
and	x and y	布林"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。	(a and b) 返回 20。
or	x or y	布林"或" - 如果 x 是非 0，它返回 x 的值，否則它返回 y 的計算值。	(a or b) 返回 10。
not	not x	布林"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。	not(a and b) 返回 False

注意： 不能用 & 或者 | 代替 and ,or,python 中 & | 代表位運算子

Python成員運算子

除了以上的一些運算子之外，Python還支援成員運算子，測試例項中包含了一系列的成員，包括字串，列表或元組。

運算子	描述	例項
in	如果在指定的序列中找到值返回 True，否則返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中沒有找到值返回 True，否則返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Python身份運算子

身份運算子用於比較兩個物件的儲存單元

運算子	描述	例項
is	is 是判斷兩個識別符號是不是引用自一個物件	x is y, 類似 id(x) == id(y) , 如果引用的是同一個物件則返回 True，否則返回 False
is not	is not 是判斷兩個識別符號是不是引用自不同物件	x is not y ， 類似 id(a) != id(b)。如果引用的不是同一個物件則返回結果 True，否則返回 False。

變數 variable

自變數命名規則

可以將一個數值，或者字串串附值給自變數，如apple=1中，apple為自變數的名稱，1為自變數的值。 也可以將字串賦值給自變數

>>>apple='iphone'
>>>pear=10
>>>print(apple)
iphone
>>>print(pear)
10

自變數名稱區分大小寫；如果需要用多個單詞來表示自變數，需要加下劃線，如

>>>apple_2016 = 'iphone7 plus and new macbook'
>>>print(apple_2016)  # 輸出值為iphone7 plus and new macbook
iphone7 plus and new macbook

可在自變數後面進行運算,運算結果儲存在自變數裡

>>>c=1+2+3
>>>c
6

python允許一次定義多個自變數，如

>>>a, b, c = 11, 12, 13
>>>print(a, b, c) # 輸出值為11, 12, 13
11 12 13

while和for迴圈

---

while迴圈

基本使用

主要結構如下：

while condition:
    expressions

其中 condition為判斷條件，在 Python 中就是True 和False 其中的一個，如果為 True， 那麼將執行 expressions語句,否則將跳過該 while 語句塊接著往下執行。

例項

比如要列印出 0 - 9 的所有資料：

condition = 0
while condition < 10:
    print(condition)
    condition = condition + 1

輸出的結果將是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 第一行設定condition的 初始值為 0，在進行 while 判斷的時候0 < 10為 True，將會執行 while 內部 的程式碼，首先先列印出該值，然後將 condition 值加 1，至此將完成一次迴圈；再 condition的值與 10進行比較，仍然為True，重複如上過程，至到condiiton等於 10 後，不滿足condition < 10的條件（False），將不執行 while 內部的內容，所以10不會被列印。

注意點

在使用 while 句法的時候一定要注意在迴圈內部一定要修改判斷條件的值，否則程式的while部分將永遠執行下去。
如果按以下程式執行，程式將一直列印出 I’m True，要停止程式，使用ctrl + c終止程式。

while True:
    print("I'm True")

高階主題

在 Python 中除了常規比較操作

• 小於（<)
• 大於 (>)
• 不大於 (<=)
• 不小於 (>=)
• 等於 (==)
• 不等於 (!=)

會返回True 和 False值，其他操作也會返回 True 和 False。

1.數字

整數和浮點數也能進行 Boolean資料操作，如果該值等於0或者0.0將會返回False，其餘的返回True。

condition = 10
while condition:
    print(condition)
    condition=-1

輸出的結果將會是 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 在這裡condition在while語句中，如果該值大於0，那麼將會返回為True，執行迴圈內部語句，直至 condition等於0，返回 False。

2.None 型別

如果 while 後面接著的語句資料型別None, 將會返回 False。

3.集合型別

在Python中集合型別有list、tuple、dict和set等，如果該集合物件作為while判斷語句， 如果集合中的元素數量為 0，那麼將會返回False，否則返回True。
下列程式將會返回 9, 8, 7, 6, 5, 4, 3, 2, 1, 0，程式首先判斷列表是否空，如果不為空，則列印出最後一個內容，然後使用切片操作去掉最後一個元素，並更新列表；如此重複，直至列表為空。

a = range(10)
while a:
    print(a[-1])
    a = a[:len(a)-1]

for迴圈

基本使用

在Python中的基本使用方法如下：

for item in sequence:
    expressions

sequence為可迭代的物件，item為序列中的每個物件。

例項

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)

以下程式輸出的結果為1,2,3,4,5,6,7,12,543,876,12,3,2,5, 內容依次為 example_list中的每一個元素。注意 Python 是使用縮排表示程式的結構，如果程式如下編寫

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)
    print("inner of for")
print("outer of for')

那麼每次迴圈都會輸出 inner of for，在迴圈結束後，輸出outer of for一次。
IDLE中的縮排快捷鍵 ctrl+[

進階

range使用

在 Python 內建了工廠函式，range 函式將會返回一個序列，總共有三種使用方法

1.range(start, stop)

其中start 將會是序列的起始值，stop為結束值，但是不包括該值，類似數學中的表達 [start, stop),左邊為閉區間，右邊為開區間。

for i in range(1, 10):
    print(i)  # 上述表達將會返回1-9所有整數，但不包括10

2.range(stop)

如果省略了 start 那麼將從 0開始，相當於range(0, stop)。

3.range(start, stop, step)

step 代表的為步長，即相隔的兩個值的差值。從 start 開始，依次增加 step 的值，直至等於或者大於 stop。

for i in range(0, 13, 5):
    print(i)  # 將會輸出0,5,10

高階主題

4.1內建集合

Python共內建了list、tuple 、dict和set四種基本集合，每個集合物件都能夠迭代。
tuple 型別

tup = ('python', 2.7, 64)
for i in tup:
    print(i)  # 程式將以此按行輸出‘python’, 2.7, 64

dictionary 型別
字典在迭代的過程 中將key作為可迭代的物件返回。
（注意字典中 key是亂序的，也就是說和插入的順序是不一致的。
如果想要使用順序一致的字典，請使用collections 模組中的 OrderedDict物件。）——似乎是舊版問題
下列程式輸出的結果為：lan python,version 2.7,platform 64,a b,c 1,1 2,1 v
。

dic = {'lan': 'python', 'version': 2.7, 'platform': 64}
for key in dic:
    print(key, dic[key])

dic={}
dic['a']='b'
dic['c']=1
dic[1]=2
dic['1']='v'
for key in dic:
    print(key, dic[key])

set 型別

set 集合將會去除重複項。輸出的 結果也不是按照輸入的順序。
下列程式將會輸出 python, python3, python2。

s = set(['python', 'python2', 'python3', 'python'])   
for item in s:
    print(item)

迭代器

Python 中的 for句法實際上實現了設計模式中的迭代器模式 ，所以我們自己也可以按照迭代器的要求自己生成迭代器物件，以便在 for 語句中使用。只要類中實現了iter 和next函式，那麼物件就可以在for 語句中使用。現在建立 Fibonacci 迭代器物件，以下程式將會輸出前 5 個 Fibonacci 資料 1，1，2，3，5。

# define a Fib class
class Fib(object):
    def __init__(self, max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise StopIteration()

# using Fib object
for i in Fib(5):
    print(i)

4.3 生成器

除了使用迭代器以外，Python 使用yield 關鍵字也能實現類似迭代的效果。yield 語句每次執行時，立即返回結果給上層呼叫者，而當前的狀態仍然保留，以便迭代器下一次迴圈呼叫。這樣做的好處是在於節約硬體資源，在需要的時候才會執行，並且每次只執行一次。

def fib(max):
    a, b = 0, 1
    while max:
        r = b
        a, b = b, a + b
        max -= 1
        yield r

# using generator
for i in fib(5):
    print(i)

將會輸出前 5 個 Fibonacci 資料1,1, 2, 3, 5

if 判斷

---

if 判斷

基本使用

與其他程式語言中的 if 語句一樣，使用方法如下

if condition:
    expressions

如果 condition 的值為 True,將會執行 expressions 語句的內容，否則將跳過該語句往下執行。

例項

x = 1
y = 2
z = 3
if x < y:
    print('x is less than y')

上述程式碼中，if 語句的條件為 x < y 為 True, 那麼將執行條件內部語句，程式將輸出 x is less than y。 當我們將程式碼修改為一下

if x < y < z:
    print('x is less than y, and y is less than z')

在這裡的條件變成了 x < y < z, 其相當於 x < y and y < z, 如果 and 兩邊的條件都為 True 那麼才會返回 True。 注意這個用法是 python 語言特有，不鼓勵 大家寫出這樣的程式碼，以便其他語言的程式設計師能夠看懂你的程式碼。

注意點

在 python 語言中等號的判斷使用 == 而不是 =, 因為後一種是賦值語句。

x = 1
y = 2
z = 3
if x = y:
    print('x is equal to y')

如果這樣寫的話，是有句法錯誤的，程式將無法執行。當然如果是從 C/C++ 語言轉過來的同學，剛才那一句是非常熟悉的，也是我們經常錯誤的來源。

修改如下

x = 2
y = 2
z = 0
if x == y:
    print('x is equal to y')

因為 x 和 y 都等於2, 所以將會輸出 x is equal to y。

if else 判斷

基本使用

if condition:
    true_expressions
else:
    false_expressions

當 if 判斷條件為 True,執行 true_expressions 語句; 如果為 False，將執行 else 的內部的 false_expressions。

例項

x = 1
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal to y')

在這個例子中，因為 x > y 將會返回 False, 那麼將執行 else 的分支內容。輸出 x is less or equal to y

x = 4
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal y')

在這裡，因為 condition 條件為 True, 那麼將會輸出 x is greater than y。

高階主題

對於從其他程式語言轉過來的同學一定非常想知道 python 語言中的三目操作符怎麼使用，很遺憾的是 python 中並沒有類似 condition ? value1 : value2 三目操作符。然後現實中很多情況下我們只需要簡單的判斷 來確定返回值，但是冗長的 if-else 語句似乎與簡單的 python 哲學不一致。別擔心，python 可以通過 if-else 的行內表示式完成類似的功能。

var = var1 if condition else var2

可以這麼理解上面這段語句，如果 condition 的值為 True, 那麼將 var1 的值賦給 var;如果為 False 則將 var2 的值賦給 var。

worked = True
result = 'done' if worked else 'not yet'
print(result)

首先判斷如果 work 為 True,那麼將 done 字串賦給 result，否則將 not yet 賦給 result。 結果將輸出 done。

if elif else 判斷

基本使用

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

如果有多個判斷條件，那可以通過 elif 語句新增多個判斷條件，一旦某個條件為 True，那麼將執行對應的 expression。 並在之程式碼執行完畢後跳出該 if-elif-else 語句塊，往下執行。

例項

x = 4
y = 2
z = 3
if x > 1:
    print ('x > 1')
elif x < 1:
    print('x < 1')
else:
    print('x = 1')
print('finish')

因為 x = 4 那麼滿足 if 的條件，則將輸出 x > 1 並且跳出整個 if-elif-else 語句塊，那麼緊接著輸出 finish。 如果將 x = -2 那麼將滿足 elif x < 1 這個條件，將輸出 x <1, finish。

定義功能

---

def 函式

如果我們用程式碼實現了一個小功能，但想要在程式程式碼中重複使用，不能在程式碼中到處貼上這些程式碼，因為這樣做違反 了軟體工程中 DRY原則。 Python 提供了 函式功能，可以將我們這部分功能抽象成一個函式以方便程式呼叫，或者提供給其他模組使用。

基本使用

def function_name(parameters):
    expressions

Python 使用 def 開始函式定義，緊接著是函式名，括號內部為函式的引數，內部為函式的 具體功能實現程式碼，如果想要函式有返回值, 在 expressions 中的邏輯程式碼中用 return 返回。

例項

def function():
    print('This is a function')
    a = 1+2
    print(a)

上面我們定義了一個名字為 function的函式，函式沒有接收引數，所以括號內部為空，緊接著就是 函式的功能程式碼。如果執行該指令碼，發現並沒有輸出任何輸出，因為我們只定義了函式，而並沒有執行函式。 這時我們在 Python 命令提示符中輸入函式呼叫 function(), 注意這裡呼叫函式的括號不能省略。那麼 函式內部的功能程式碼將會執行，輸出結果：

This is a function
3

如果我們想要在指令碼中呼叫的指令碼，只需要在指令碼中最後新增函式呼叫語句

function()

那麼在執行指令碼的時候，將會執行函式。

函式引數

我們在使用的呼叫函式的時候，想要指定一些變數的值在函式中使用，那麼這些變數就是函式的引數，函式呼叫的時候， 傳入即可。

基本使用

def function_name(parameters):
    expressions

parameters 的位置就是函式的引數，在呼叫的時候傳入即可。

例項

def func(a, b):
    c = a+b
    print('the c is ', c)

在這裡定義的一個函式，其引數就是兩個數值，函式的功能就是把兩個引數加起來。執行指令碼後，在 Python 提示符內呼叫函式 func, 如果不指定引數 func(), 那麼將會出錯; 輸出 func(1, 2)，將 a=1, b=2 傳入函式，輸出 the c is 3 。所以在呼叫函式時候，引數個數和位置一定要按照函式定義。如果我們忘記了函式的引數的位置，只知道各個引數的名字，可以在 函式呼叫的過程中給指明特定的引數 func(a=1, b=2), 這樣的話，引數的位置將不受影響，所以 func(b=2,a=1)是同樣的 的效果。

函式預設引數

我們在定義函式時有時候有些引數在大部分情況下是相同的，只不過為了提高函式的適用性，提供了一些備選的引數， 為了方便函式呼叫，我們可以將這些引數設定為預設引數，那麼該引數在函式呼叫過程中可以不需要明確給出。

基本使用

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
    expressions

函式宣告只需要在需要預設引數的地方用 = 號給定即可, 但是要注意所有的預設引數都不能出現在非預設引數的前面。

例項

def sale_car(price, color='red', brand='carmy', is_second_hand=True):
    print('price', price,
          'color', color,
          'brand', brand,
          'is_second_hand', is_second_hand,)

在這裡定義了一個 sale_car 函式，引數為車的屬性，但除了 price 之外，像 color, brand 和 is_second_hand 都是有預設值的，如果我們呼叫函式 sale_car(1000), 那麼與 sale_car(1000, ‘red’, ‘carmy’, True) 是一樣的效果。當然也可以在函式呼叫過程中傳入特定的引數用來修改預設引數。通過預設引數可以減輕我們函式呼叫的複雜度。

進階

3.1 自呼叫

如果想要在執行指令碼的時候執行一些程式碼，比如單元測試，可以在指令碼最後加上單元測試 程式碼，但是該指令碼作為一個模組對外提供功能的時候單元測試程式碼也會執行，這些往往我們不想要的，我們可以把這些程式碼放入指令碼最後：

if __name__ == '__main__':
    #code_here

如果執行該指令碼的時候，該 if 判斷語句將會是 True,那麼內部的程式碼將會執行。 如果外部呼叫該指令碼，if 判斷語句則為 False,內部程式碼將不會執行。

3.2 可變引數

顧名思義，函式的可變引數是傳入的引數可以變化的，1個，2個到任意個。當然可以將這些 引數封裝成一個 list 或者 tuple 傳入，但不夠 pythonic。使用可變引數可以很好解決該問題，注意可變引數在函式定義不能出現在特定引數和預設引數前面，因為可變引數會吞噬掉這些引數。

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    print(name, 'total grade is ', total_grade)

定義了一個函式，傳入一個引數為 name, 後面的引數 *grades 使用了 * 修飾，表明該引數是一個可變引數，這是一個可迭代的物件。該函式輸入姓名和各科的成績，輸出姓名和總共成績。所以可以這樣呼叫函式 report(‘Mike’, 8, 9)，輸出的結果為 Mike total grade is 17, 也可以這樣呼叫 report(‘Mike’, 8, 9, 10)，輸出的結果為 Mike total grade is 27

3.3 關鍵字引數

關鍵字引數可以傳入0個或者任意個含引數名的引數，這些引數名在函式定義中並沒有出現，這些引數在函式內部自動封裝成一個字典(dict).

def portrait(name, **kw):
    print('name is', name)
    for k,v in kw.items():
        print(k, v)

定義了一個函式，傳入一個引數 name, 和關鍵字引數 kw，使用了 ** 修飾。表明該引數是關鍵字引數，通常來講關鍵字引數是放在函式引數列表的最後。如果呼叫引數 portrait(‘Mike’, age=24, country=‘China’, education=‘bachelor’) 輸出:

name is Mike
age 24
country China
education bachelor

通過可變引數和關鍵字引數，任何函式都可以用 universal_func(*args, **kw) 表達。

變數形式

---

區域性變數

在 def 中, 我們可以定義一個區域性變數, 這個變數a只能在這個功能 fun中有效, 出了這個功能, a這個變數就不是那個區域性的a.

def fun():
    a = 10
    print(a)
    return a+100

print(fun())

"""
10
110
"""

下面這個例子就驗證瞭如果在 fun 外面呼叫 a, 會報錯, 這表明外面的這個 print(a)不能找到那個區域性的 a, 只有全域性變數再能在外面被呼叫, 比如 APPLE.全域性變數一般大寫

APPLY = 100 # 全域性變數
def fun():
    a = 10  # 區域性變數
    return a+100

print(APPLE)    # 100
print(a)    # 報錯, 不能拿到一個區域性變數的值

全域性變數

那如何在外部也能呼叫一個在區域性裡修改了的全域性變數呢. 首先我們在外部定義一個全域性變數 a=None, 然後再fun()中宣告 這個a是來自外部的 a. 宣告方式就是 global a. 然後對這個外部的 a修改後, 修改的效果會被施加到外部的 a 上. 所以我們將能看到執行完 fun(), a 的值從 None 變成了 20.

APPLE = 100 # 全域性變數
a = None
def fun():
    global a    # 使用之前在全域性裡定義的 a
    a = 20      # 現在的 a 是全域性變數了
    return a+100

print(APPLE)    # 100
print('a past:', a)  # None
print(fun()) #120
print('a now:', a)   # 20

模組安裝

---

安裝外部的模組有很多種方式, 不同的系統安裝形式也不同. 比如在 Windows 上安裝 Python 的一些包, 可能還會要了你的老命. 哈哈.

什麼是外部模組

外部模組就是在你 import 什麼東西去python 指令碼的時候會用到的.

import numpy as np
import matplotlib.pyplot as plt

這裡的 Numpy 和 matplotlib 都是外部模組, 需要安裝以後才會有的. 他不屬於 python 自帶的模組.

安裝 Numpy

這裡我們舉例說明, 對於一些科學運算的模組, 比如 numpy, 他的安裝方式就有很多。 在 Windows 上, 最簡單的方式就安裝 Anaconda 這種平臺, 他會自帶很多必要的外部模組. 安裝一個, 省去安裝其它的煩惱。
不過我這裡要講的是下載安裝包的方式在 Windows 安裝. 比如 在 Numpy 安裝包的網站中, 你能找到 numpy 的各種版本的安裝包。
在 NumPy 1.10.2 這個版本中, 我們能找到適合 Windows 的安裝包, 新版中目前還沒新增 Windows 的安裝包. 然後根據你的系統和 python 版本選擇合適的 “exe” 安裝包.。下載安裝。
如果你是 MacOS 或者 Linux, 這種外部模組, 安裝起來就方便多了。在你的電腦 Terminal 上輸入一句話, 就能輕鬆安裝.。Windows 好像要經過特殊設定才能實現一樣的功能, 具體忘記了… 你可能要查一下. 在我電腦中, Terminal 長這樣。

然後只要你在裡面輸入這種形式就可以安裝了.

$ pip install 你要的模組名

比如

$ pip install numpy   # 這是 python2+ 版本的用法
$ pip3 install numpy   # 這是 python3+ 版本的用法

更新外部模組

使用 pip 更新外部模組會十分簡單. 主需要在 Terminal 中輸入下面的指令就行. 這裡的 -U 就是 update 意思.

$ pip install -U numpy   # 這是 python2+ 版本的用法
$ pip3 install -U numpy   # 這是 python3+ 版本的用法

pycharm 模組安裝與更新

File->Settings->Project Interpreter

檔案讀取

---

\n 換行命令

定義 text為字串, 並檢視使用 \n和不適用\n的區別:

text='This is my first test. This is the second line. This the third '
print(text)  # 無換行命令

"""
This is my first test. This is the second line. This the third
"""

text='This is my first test.\nThis is the second line.\nThis the third line'
print(text)   # 輸入換行命令\n，要注意斜杆的方向。注意換行的格式和c++一樣

"""
This is my first test.
This is the second line.
This the third line
"""

open 讀檔案方式

使用open 能夠開啟一個檔案,open 的第一個引數為檔名和路徑 ‘my file.txt’, 第二個引數為將要以什麼方式開啟它, 比如 w為可寫方式. 如果計算機沒有找到 ‘my file.txt’ 這個檔案, w方式能夠建立一個新的檔案, 並命名為 my file.txt
完整的語法格式為：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

引數說明:
file: 必需，檔案路徑（相對或者絕對路徑）。
mode: 可選，檔案開啟模式
buffering: 設定緩衝
encoding: 一般使用utf8
errors: 報錯級別
newline: 區分換行符
closefd: 傳入的file引數型別
opener:

file

my_file=open('my file.txt','w')   #用法: open('檔名','形式'), 其中形式有'w':write;'r':read.
my_file.write(text)               #該語句會寫入先前定義好的 text
my_file.close()                   #關閉檔案

open一個同py檔案同一個目錄的檔案的時候，用以下：

txt = open('filtered_words.txt','rb')

也可利用絕對路徑

txt = open('E:\\python_project\\test\github\\filtered_words.txt','rb')

用反斜槓

txt = open('E:/python_project/test/github/filtered_words.txt','rb')

mode

t 文字模式 (預設)。
x 寫模式，新建一個檔案，如果該檔案已存在則會報錯。
b 二進位制模式。
+ 開啟一個檔案進行更新(可讀可寫)。
U 通用換行模式（不推薦）。
r 以只讀方式開啟檔案（帶r的檔案必須先存在）。檔案的指標將會放在檔案的開頭。這是預設模式。
r+ 可讀可寫,不會建立不存在的檔案。如果直接寫檔案，則從頂部開始寫，覆蓋之前此位置的內容，如果先讀後寫，則會在檔案最後追加內容。

(每當你open一個檔案的時候，都會產生一個檔案"指標",這個指標會隨你的讀寫操作而向後移動。初始這個指標是指向檔案內容的起始位置，當你執行指令f.read（）時，它會讀取檔案的所有內容，並將指標從檔案起始位置一直移到檔案末尾。當你執行指令f.write(“你好”)前，這個指標是指向當前檔案末尾，所以會將“你好”新增在檔案末尾，此時指標又移動到“你好”的後面，此時你又輸入“世界”，則在指標指向的檔案當前位置寫入“世界”，此時指標又移動到“世界”的後面。此時，你又執行f.read(),由於此時指標指向的是當前檔案的末尾，即指向“世界”的後面，而“世界”後面當然什麼內容都沒了，故你什麼都讀取不了，空白)

w+ 可讀可寫 如果檔案存在 則覆蓋整個檔案不存在則建立 //要close 之後才算完成寫入
w 只能寫 覆蓋整個檔案 不存在則建立
a 只能寫 從檔案底部新增內容 不存在則建立
a+ 可讀可寫 從檔案頂部讀取內容 從檔案底部新增內容 不存在則建立

encoding 編碼方式

1.win系統預設是gbk編碼的，所以桌面生成的TXT之類的都是gbk編碼的。
2.出現亂碼正常都是原檔案的編碼方式和開啟指定的編碼不一致所致

\t tab 對齊

使用 \t 能夠新增一個tab間隔：

text='\tThis is my first test.\nThis is the \tsecond line.\n\t\tThis is the third line'
print(text) 
"""
	This is my first test.
This is the 	second line.
		This is the third line

"""

給檔案增加內容

我們先儲存一個已經有3行文字的 “my file.txt” 檔案, 檔案的內容如下:

This is my first test. 
This is the second line.
This the third

然後使用新增文字的方式給這個檔案新增一行 “This is appended file.”, 並將這行文字儲存在 append_file 裡，注意\n的適用性:

append_text='\nThis is appended file.'  # 為這行文字提前空行 "\n"
my_file=open('my file.txt','a')   # 'a'=append 以增加內容的形式開啟
my_file.write(append_text)
my_file.close()
""""
This is my first test.
This is the second line.
This the third line.
This is appended file.
""""
#執行後再去開啟檔案，會發現會增加一行程式碼中定義的字串

總結

掌握 append 的用法 ：open(‘my file.txt’,‘a’) 開啟型別為 a ，a 即表示 append

讀取檔案內容 file.read()

使用 file.read() 能夠讀取到文字的所有內容.

file= open('my file.txt','r') 
content=file.read()  
print(content)

""""
This is my first test.
This is the second line.
This the third line.
This is appended file.    
""""

按行讀取 file.readline()

如果想在文字中一行行的讀取文字,帶換行符, 可以使用 file.readline(), file.readline() 讀取的內容和你使用的次數有關, 使用第二次的時候, 讀取到的是文字的第二行, 並可以以此類推:

file= open('my file.txt','r') 
content=file.readline()  # 讀取第一行
print(content)
""""
This is my first test.
""""
second_read_time=file.readline()  # 讀取第二行
print(second_read_time)
"""
This is the second line.
"""

讀取所有行 file.readlines()

如果想要讀取所有行, 並可以使用像 for 一樣的迭代器迭代這些行結果, 我們可以使用 file.readlines(), 將每一行的結果儲存在 list 中, 方便以後迭代，注意換行符是包含在字串的內容中。

file= open('my file.txt','r') 
content=file.readlines() # python_list 形式
print(content)
""""
['This is my first test.\n', 'This is the second line.\n', 'This the third line.\n', 'This is appended file.']
""""
# 之後如果使用 for 來迭代輸出:
for item in content:
    print(item)   
"""
This is my first test.
This is the second line.
This the third line.
This is appended file.
"""

去除換行符\n

使用strip()函式去掉每行結束的\n

for line in file.readlines():
    line=line.strip('\n')

strip()函式原型

宣告：s為字串，rm為要刪除的字元序列

s.strip(rm) 刪除s字串中開頭、結尾處，位於 rm刪除序列的字元

s.lstrip(rm) 刪除s字串中開頭處，位於 rm刪除序列的字元

s.rstrip(rm) 刪除s字串中結尾處，位於 rm刪除序列的字元

注意：當rm為空時，預設刪除空白符（包括’\n’, ‘\r’, ‘\t’, ’ ')

class 類

---

class 類

class 定義一個類

class 定義一個類,類似於定義一個函式, 後面的類別首字母推薦以大寫的形式定義，比如Calculator. class可以先定義自己的屬性，比如該屬性的名稱可以寫為 name=‘Good Calculator’. class後面還可以跟def, 定義一個函式. 比如def add(self,x,y): 加法, 輸出print(x+y). 其他的函式定義方法一樣，注意這裡的self 是預設值.

class Calculator:       #首字母要大寫，冒號不能缺
    name='Good Calculator'  #該行為class的屬性
    price=18
    def add(self,x,y):
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

""""
>>> cal=Calculator()  #注意這裡執行class的時候要加"()",否則呼叫下面函式的時候會出現錯誤,導致無法呼叫.
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
>>>
""""

總結

注意定義自變數cal等於Calculator要加括號“()” ,cal=Calculator()否則執行下面函式的時候會出現錯誤,導致無法呼叫.

class 類 init 功能

init

__init__可以理解成初始化class的變數，取自英文中initial 最初的意思.可以在執行時，給初始值附值，

執行c=Calculator('bad calculator',18,17,16,15),然後調出每個初始值的值。看如下程式碼。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height,width,weight):   # 注意，這裡的下劃線是雙下劃線
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight
""""
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
""""

如何設定屬性的預設值, 直接在def裡輸入即可，如下:

def __init__(self,name,price,height=10,width=14,weight=16):檢視執行結果， 三個有預設值的屬性，可以直接輸出預設值，這些預設值可以在code中更改, 比如c.wi=17再輸出c.wi就會把wi屬性值更改為17.同理可推其他屬性的更改方法。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height=10,width=14,weight=16): #後面三個屬性設定預設值,檢視執行
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight

 """"
>>> c=Calculator('bad calculator',18)
>>> c.h
10
>>> c.wi
14
>>> c.we
16
>>> c.we=17
>>> c.we
17
""""

總結

def __init__(self,name,price,height,width,weight):注意，這裡的下劃線是雙下劃線

input 輸入

---

input

variable=input()表示執行後，可以在螢幕中輸入一個數字，該數字會賦值給自變數。看程式碼：

a_input=input('please input a number:')
print('this number is:',a_input)
''''
please input a number:12 #12 是我在硬碟中輸入的數字
this number is: 12
''''

input()應用在if語句中.
在下面程式碼中，需要將input() 定義成整型，因為在if語句中自變數 a_input對應的是1 and 2 整數型。輸入的內容和判斷句中對應的內容格式應該一致。
也可以將if語句中的1and2定義成字串，其中區別請讀者自定寫入程式碼檢視。

a_input=int(input('please input a number:'))#注意這裡要定義一個整數型
if a_input==1:
    print('This is a good one')
elif a_input==2:
    print('See you next time')
else:
    print('Good luck')
""""
please input a number:1   #input 1
This is a good one
please input a number:2   #input 2
See you next time
please input a number:3   #input 3 or other number
Good luck
""""

input擴充套件

用input()來判斷成績

score=int(input('Please input your score: \n'))
if score>=90:
   print('Congradulation, you get an A')
elif score >=80:
    print('You get a B')
elif score >=70:
    print('You get a C')
elif score >=60:
    print('You get a D')
else:
    print('Sorry, You are failed ')

""""
Please input your score:
100   #手動輸入
Congradulation, you get an A
""""

元組、列表、字典

---

元組 列表

Tuple

叫做tuple，用小括號、或者無括號來表述，是一連串有順序的數字。

a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6

List

而list是以中括號來命名的:

a_list = [12, 3, 67, 7, 82]

兩者對比

他們的元素可以一個一個地被迭代、輸出、運用、定位取值:

for content in a_list:
    print(content)
"""
12
3
67
7
82
"""

for content_tuple in a_tuple:
    print(content_tuple)
"""
12
3
5
15
6
"""

下一個例子，依次輸出a_tuple和a_list中的各個元素：

for index in range(len(a_list)):
    print("index = ", index, ", number in list = ", a_list[index])
"""
index =  0 , number in list =  12
index =  1 , number in list =  3
index =  2 , number in list =  67
index =  3 , number in list =  7
index =  4 , number in list =  82
"""

for index in range(len(a_tuple)):
    print("index = ", index, ", number in tuple = ", a_tuple[index])
"""
index =  0 , number in tuple =  12
index =  1 , number in tuple =  3
index =  2 , number in tuple =  5
index =  3 , number in tuple =  15
index =  4 , number in tuple =  6
"""

list 列表

List 新增

列表是一系列有序的數列，有一系列自帶的功能， 例如：

a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最後面追加一個0
print(a)
# [1, 2, 3, 4, 1, 1, -1, 0]

在指定的地方新增項：

a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1處新增0
print(a)
# [1, 0, 2, 3, 4, 1, 1, -1]

List 移除

刪除項：

a = [1,2,3,4,1,1,-1]
a.remove(2) # 刪除列表中第一個出現的值為2的項
print(a)
# [1, 3, 4, 1, 1, -1]

List 索引

顯示特定位：

a = [1,2,3,4,1,1,-1]
print(a[0])  # 顯示列表a的第0位的值
# 1

print(a[-1]) # 顯示列表a的最末位的值
# -1

print(a[0:3]) # 顯示列表a的從第0位 到 第2位(第3位之前) 的所有項的值
# [1, 2, 3]

print(a[5:])  # 顯示列表a的第5位及以後的所有項的值
# [1, -1]

print(a[-3:]) # 顯示列表a的倒數第3位及以後的所有項的值
# [1, 1, -1]

列印列表中的某個值的索引(index):

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 顯示列表a中第一次出現的值為2的項的索引
# 1

統計列表中某值出現的次數：

a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
# 1

List 排序

對列表的項排序：

a = [4,1,2,3,4,1,1,-1]
a.sort() # 預設從小到大排序
print(a)
# [-1, 1, 1, 1, 2, 3, 4, 4]

a.sort(reverse=True) # 從大到小排序
print(a)
# [4, 4, 3, 2, 1, 1, 1, -1]

元組的基本操作與列表相同，但元組本身是不可變的，不能隨意插入刪除元素，但可利用切片的方式對元組進行拷貝，從而間接實現新增刪除元素

多維列表

建立二維列表

一個一維的List是線性的List，多維List是一個平面的List：

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
			   [2,3,4],
			   [3,4,5]] # 三行三列

索引

在上面定義的List中進行搜尋：

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

用行數和列數來定位list中的值。這裡用的是二維的列表，但可以有更多的維度。

dictionary 字典

建立字典

如果說List是有順序地輸出輸入的話，那麼字典的存檔形式則是無需順序的， 我們來看一個例子：
在字典中，有key和 value兩種元素，每一個key對應一個value, key是名字, value是內容。數字和字串都可以當做key或者value， 在同一個字典中, 並不需要所有的key或value有相同的形式。 這樣說, List可以說是一種key為有序數列的字典。

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'pear': 2, 'apple': 1}

字典儲存型別

以上的例子可以對列表中的元素進行增減。在列印出整個列表時，可以發現各個元素並沒有按規律列印出來，進一步驗證了字典是一個無序的容器。

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])    # a

字典還可以以更多樣的形式出現，例如字典的元素可以是一個List，或者再是一個列表，再或者是一個function。索引需要的專案時，只需要正確指定對應的key就可以了。

模組

---

import 模組

import 的各種方法

import time 指 import time 模組，這個模組可以python自帶，也可以是自己安裝的，比如以後會用到numpy這些模組,需要自己安裝。

import time
print(time.localtime())  #這樣就可以print 當地時間了
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法二：import time as ____下劃線縮寫部分可以自己定義，在程式碼中把time定義成t.設定別名呼叫更簡潔

import time as t
print(t.localtime()) # 需要加t.字首來引出功能
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法三：from time import time,localtime,只import自己想要的功能.

from time import time, localtime
print(localtime())
print(time())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)

1482475298.709855
""""

方法四：from time import * 輸入模組的所有功能

from time import *
print(localtime())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

自建一個模組

這裡和視訊有點差別，我自己寫了另外一個模組，是計算五年複利本息的模組,程式碼如下：模組寫好後儲存在預設資料夾：balance.py

d=float(input('Please enter what is your initial balance: \n'))
p=float(input('Please input what is the interest rate (as a number): \n'))
d=float(d+d*(p/100))
year=1
while year<=5:
    d=float(d+d*p/100)
    print('Your new balance after year:',year,'is',d)
    year=year+1
print('your final year is',d)

呼叫自己的模組
新開一個指令碼，import balance

import balance

""""
Please enter what is your initial balance:
50000  # 手動輸入我的本金
Please input what is the interest rate (as a number):
2.3  #手動輸入我的銀行利息
Your new balance after year: 1 is 52326.45
Your new balance after year: 2 is 53529.95834999999
Your new balance after year: 3 is 54761.14739204999
Your new balance after year: 4 is 56020.653782067144
Your new balance after year: 5 is 57309.12881905469
your final year is 57309.12881905469
""""

模組儲存路徑說明

在Mac系統中，下載的python模組會被儲存到外部路徑site-packages，同樣，我們自己建的模組也可以放到這個路徑，最後不會影響到自建模組的呼叫。

class類、模組、包關係

• 類： 它將資料和操作進行封裝，以便將來的複用。幾乎是最小的封裝單元了，方便更高的複用
• 模組：在Python可理解為對應於一個檔案。在建立了一個指令碼檔案後，定義了某些函式和變數。你在其他需要這些功能的檔案中，匯入這模組，就可重用這些函式和變數。
• 包：在建立許許多多模組後，我們可能希望將某些功能相近的檔案組織在同一資料夾下，這裡就需要運用包的概念了。包對應於資料夾，使用包的方式跟模組也類似，唯一需要注意的是，當資料夾當作包使用時，資料夾需要包含__init__.py檔案，主要是為了避免將資料夾名當作普通的字串。init.py的內容可以為空，一般用來進行包的某些初始化工作或者設定__all__值，__all__是在from package-name import *這語句使用的，全部匯出定義過的模組。通常包總是一個目錄， 可以是對模組的聚集，包裹在同一個資料夾內。可以使用import匯入包，或者from + import來匯入包中的部分模組。包目錄下為首的一個檔案便是 init.py。然後是一些模組檔案和子目錄，假如子目錄中也有 init.py 那麼它就是這個包的子包了。

其他

---

continue & break

True and False 跳出迴圈

當輸入1時，a=False時，會執行接下來的語句後再跳出這個迴圈。

a=True
while a:
    b= input('type somesthing')
    if b=='1':
        a= False
        print('still in a while')
    else:
        pass #什麼都不做跳過
print ('finish run')

''''
type somesthing 2
type somesthing3
type somesthing1
still in a while #會執行下面的語句再跳出
finish run
''''

break

break用法，在迴圈語句中，使用break, 當符合跳出條件時，會直接結束迴圈，這是 break和 True False的區別。

while True:
    b= input('type somesthing:')
    if b=='1':
        break
    else:
        pass
    print('still in while')
print ('finish run')

"""
type somesthing:4
still in while
type somesthing:5
still in while
type somesthing:1
finish run
"""

continue

在程式碼中，滿足b=1的條件時，因為使用了continue , python 不會執行 else 後面的程式碼，而會直接進入下一次迴圈。

while True:
    b=input('input somesthing:')
    if b=='1':
       continue
    else:
        pass
    print('still in while' )

print ('finish run')
"""
input somesthing:3
still in while
input somesthing:1  # 沒有"still in while"。直接進入下一次迴圈
input somesthing:4
still in while
input somesthing:
"""

總結

break直接跳出迴圈；
continue跳過後面的，從頭開始下一個迴圈’
flag(True->False)執行完當前一輪迴圈再退出

try 錯誤處理

錯誤處理

輸出錯誤：try:, except … as …: 看如下程式碼

try:
    file=open('eeee.txt','r')  #會報錯的程式碼
except Exception as e:  # 將報錯儲存在 e 中
    print(e)
"""
[Errno 2] No such file or directory: 'eeee.txt'
"""

處理錯誤：會使用到迴圈語句。首先報錯：沒有這樣的檔案No such file or directory. 然後決定是否輸入y, 輸入y以後，系統就會新建一個檔案（要用寫入的型別），再次執行後，檔案中就會寫入ssss

try:
    file=open('eeee.txt','r+')
except Exception as e:
    print(e)
    response = input('do you want to create a new file:')
    if response=='y':
        file=open('eeee.txt','w')
    else:
        pass
else:
    file.write('ssss')
    file.close()
"""
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:y

ssss  #eeee.txt中會寫入'ssss'

zip lambda map

zip

• zip()函式的定義
  從引數中的多個迭代器取元素組合成一個新的迭代器；
• 返回：返回一個zip物件，其內部元素為元組；可以轉化為列表或元組；
• 傳入引數：元組、列表、字典等迭代器。
• 注意：zip(a,b)要求a與b的維數相同，當兩者具有相同的行數與列數時，正常組合對應位置元素即可；
  當a與b的行數或列數不同時，取兩者結構中最小的行數和列數，依照最小的行數和列數將對應位置的元素進行組合；這時相當於呼叫itertools.zip_longest(*iterables)函式。

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)#當zip()函式有兩個引數時,zip()函式分別從a和b依次各取出一個元素組成元組，再將依次組成的元組組合成一個新的迭代器
aa=zip(a)#當zip()函式中只有一個引數時,從a中依次取一個元組，組成一個元組。
print(list(ab))
print(list(aa))  #需要加list來視覺化這個功能
m = [[1,2,3], [4,5,6], [7,8,9]]
n = [[2,2,2], [3,3,3], [4,4,4]]
p = [[2,2,2], [3,3,3]]
print(list(zip(m,n)))
print(list(zip(m,p)))
"""
[(1, 4), (2, 5), (3, 6)]
[(1,), (2,), (3,)]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3]), ([7, 8, 9], [4, 4, 4])]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3])]
"""

zip 中的運算

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))
for i,j in zip(a,b):
     print(i/2,j*2)
"""
0.5 8
1.0 10
1.5 12
"""

zip(*)函式

zip(*)函式是zip()函式的逆過程，將zip物件變成原先組合前的資料。

a = [1,2,3]
b = [4,5,6]
zipped =list(zip(a,b))   # 打包為元組的列表
print(zipped)
aa=zip(*zipped)
print(list(aa)) # 與 zip 相反，*zipped 可理解為解壓，返回二維矩陣式
"""
[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]
"""

lambda

• lambda表示式，通常是在需要一個函式，但是又不想費神去命名一個函式的場合下使用，也就是指匿名函式。
• lambda所表示的匿名函式的內容應該是很簡單的，如果複雜的話，乾脆就重新定義一個函式了，使用lambda就有點過於執拗了。
• lambda就是用來定義一個匿名函式的，如果還要給他繫結一個名字的話，就會顯得有點畫蛇添足，通常是直接使用lambda函式。如下所示：

lambda x,y : x+y, 冒號前的x,y為自變數，冒號後x+y為具體運算。

add = lambda x, y : x+y
print(add(1,2))  # 結果為3

1. 應用在函數語言程式設計中
   Python提供了很多函數語言程式設計的特性，如：map、reduce、filter、sorted等這些函式都支援函式作為引數，lambda函式就可以應用在函數語言程式設計中。如下：
   ** 需求：將列表中的元素按照絕對值大小進行升序排列 **

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))

當然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):
    return abs(x)
sorted(list1,key=get_abs)

只不過這種方式的程式碼看起來不夠Pythonic

2. 應用在閉包中

def get_y(a,b):
     return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 結果為2

當然，也可以用常規函式實現閉包，如下：

def get_y(a,b):
    def func(x):
        return ax+b
    return func
y1 = get_y(1,1)
y1(1) # 結果為2

只不過這種方式顯得有點囉嗦。

map

map接收一個函式 f 和一個 list，並通過把函式 f 依次作用在 list 的每個元素上，得到一個新的 list 並返回。

def fun(x,y):
	return (x+y)
print(list(map(fun,[1],[2])))
print(list(map(fun,[1,2],[3,4])))
print(list(map(fun,[1,2],[3])))
"""
[3]
[4, 6]
[4]
"""

copy & deepcopy 淺複製 & 深複製

Python中，物件的賦值，拷貝（深/淺拷貝）之間是有差異的，如果使用的時候不注意，就可能產生意外的結果。

id

什麼是id？一個物件的id值在CPython直譯器裡就代表它在記憶體中的`地址

>>> import copy
>>> a=[1,2,3]
>>> b=a
>>> id(a)
"""
4382960392
"""
>>> id(b)
"""
4382960392
"""
>>> id(a)==id(b)    #附值後，兩者的id相同，為true。
True
>>> b[0]=222222  #此時，改變b的第一個值，也會導致a值改變。
>>> print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同時改變

淺拷貝

當使用淺拷貝時，python只是拷貝了最外圍的物件本身，內部的元素都只是拷貝了一個引用而已。copy只複製父物件，而子物件是共用的，deepcopy完全複製所有的父物件與子物件

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷貝了a的外圍物件本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改變 為false
False
>>> c[1]=22222   #此時，我去改變c的第二個值時，a不會被改變。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不變,c的第二個值變了，這就是copy和‘==’的不同

深拷貝

deepcopy對外圍和內部元素都進行了拷貝物件本身，而不是物件的引用。

#copy.copy()
>>> a=[1,2,[3,4]]  #第三個值為列表[3,4],即內部元素
>>> d=copy.copy(a) #淺拷貝a中的[3，4]內部元素的引用，非內部元素物件的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改變a中內部原屬列表中的第一個值
>>> d             #這時d中的列表元素也會被改變
[1, 2, [3333, 4]]
#copy.deepcopy()
>>> e=copy.deepcopy(a) #e為深拷貝了a
>>> a[2][0]=333 #改變a中內部元素列表第一個的值
>>> e
[1, 2, [3333, 4]] #因為時深拷貝，這時e中內部元素[]列表的值不會因為a中的值改變而改變

threading 什麼是多執行緒

多執行緒

多執行緒 Threading 是一種讓程式擁有分身效果. 能同時處理多件事情. 一般的程式只能從上到下一行行執行程式碼, 不過 多執行緒 (Threading) 就能打破這種限制. 讓你的程式鮮活起來.

multiprocessing 什麼是多程式

多程式

我們在多執行緒 (Threading) 裡提到過, 它是有劣勢的, GIL 讓它沒能更有效率的處理一些分攤的任務. 而現在的電腦大部分配備了多核處理器, 多程式 Multiprocessing 能讓電腦更有效率的分配任務給每一個處理器, 這種做法解決了多執行緒的弊端. 也能很好的提升效率.

什麼是 tkinter 視窗

視窗視窗

Tkinter 是使用 python 進行視窗視窗設計的模組. 簡單的構造, 多平臺, 多系統的相容性, 能讓它成為讓你快速入門定製視窗檔案的好助手. 它在 python 視窗視窗模組中是一款簡單型的. 所以用來入門, 熟悉 視窗視窗的使用, 非常有必要.

pickle 儲存資料

pickle 儲存

pickle 是一個 python 中, 壓縮/儲存/提取 檔案的模組. 最一般的使用方式非常簡單. 比如下面就是壓縮並儲存一個字典的方式. 字典和列表都是能被儲存的.

import pickle
a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}
# pickle a variable to a file
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

wb 是以寫的形式開啟 ‘pickle_example.pickle’ 這個檔案, 然後 pickle.dump 你要儲存的東西去這個開啟的 file. 最後關閉 file 你就會發現你的檔案目錄裡多了一個 ‘pickle_example.pickle’ 檔案, 這就是那個字典了.

pickle 提取

提取的時候相對簡單點, 同樣我們以讀的形式開啟那個檔案, 然後 load 進一個 python 的變數.

# reload a file to a variable 
#使用with避免忘記關file
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)
print(a_dict1)

set 找不同

set 基本

Set 最主要的功能就是尋找一個句子或者一個 list 當中不同的元素.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
sentence = 'Welcome Back to This Tutorial'
print(set(char_list))
# {'b', 'd', 'a', 'c'}
print(set(sentence))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}
print(set(char_list+ list(sentence)))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}

新增元素

定義好一個 set 之後我們還可以對其新增需要的元素, 使用 add 就能新增某個元素. 但是不是每一個東西都能新增, 比如一個列表.原本存在的元素不會被新增。

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
print(type(unique_char))
unique_char.add('x')
#unique_char.add(['y', 'z']) this is wrong
print(type(unique_char))
print(char_list)
print(unique_char)
char_list.append('x')#list用append，set用add
print(char_list)
"""
<class 'set'>
<class 'set'>
['a', 'b', 'c', 'c', 'd', 'd', 'd']
{'x', 'b', 'a', 'd', 'c'}
['a', 'b', 'c', 'c', 'd', 'd', 'd', 'x']
"""

清除元素或 set

清除一個元素可以用 remove或者 discard, 而清除全部可以用 clear.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
# unique_char.remove('x') 移除不存在的值會報錯
print(unique_char.remove('a')) #直接列印返回的都是none，需要重新print這個set才能看到剩餘值
print(unique_char)

unique_char.discard('x')#不報錯，返回原有資料
print(unique_char)
unique_char.discard('d')
print(unique_char)
print(unique_char.discard('c'))#直接列印同樣返回none

unique_char.clear()#清除所有
print(unique_char)
"""
None
{'c', 'b', 'd'}
{'c', 'b', 'd'}
{'c', 'b'}
None
set()
"""

篩選操作 /對比 （交集&差集）

我們還能進行一些篩選操作, 比如對比另一個東西, 看看原來的 set 裡有沒有和他不同的 (difference). 或者對比另一個東西, 看看 set 裡有沒有相同的 (intersection).

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
A= set(char_list)
print(A)
B={'a', 'e', 'i'}
print(B)
print(A.difference(B))#A-B
print(A.intersection(B))#A∩B
"""
{'b', 'c', 'd', 'a'}
{'e', 'i', 'a'}
{'b', 'c', 'd'}
{'a'}
"""