2. 程式人生 > >Python學習筆記：高階特性

Python學習筆記：高階特性

阿新 • • 發佈：2019-01-07

前言

最近在學習深度學習，已經跑出了幾個模型，但Pyhton的基礎不夠紮實，因此，開始補習Python了，大家都推薦廖雪峰的課程，因此，開始了學習，但光學有沒有用，還要和大家討論一下，因此，寫下這些帖子，廖雪峰的課程連線在這裡：廖雪峰
Python的相關介紹，以及它的歷史故事和執行機制，可以參見這篇：python介紹
Python的安裝可以參見這篇：Python安裝
Python的執行模式以及輸入輸出可以參見這篇：Python IO
Python的基礎概念介紹，可以參見這篇：Python 基礎
Python字串和編碼的介紹，可以參見這篇：Python字串與編碼
Python基本資料結構：list和tuple介紹，可以參見這篇：

Python list和tuple
Python控制語句介紹：ifelse，可以參見這篇：Python 條件判斷
Python控制語句介紹：迴圈實現，可以參見這篇：Python迴圈語句
Python資料結構：dict和set介紹Python資料結構dict和set
Python函式相關：Python函式
目錄：

高階特性

掌握了Python的資料結構、控制語句和基本函式，基本上就可以編寫出很多有用的程式了。
比如構造一個1, 3, 5, 7, …, 99的列表，可以通過迴圈實現：
L = []
n = 1
while n <= 99:
L.append(n)
n = n + 2
取list的前一半的元素，也可以通過迴圈實現。
但是在Python中，程式碼不是越多越好，而是越少越好。程式碼不是越複雜越好，而是越簡單越好。
基於這一思想，我們來介紹Python中非常有用的高階特性，1行程式碼能實現的功能，決不寫5行程式碼。
請始終牢記，程式碼越少，開發效率越高

。

切片

取一個list或tuple的部分元素是非常常見的操作。比如，一個list如下：

>>> L = ['Mike', 'Sarah', 'Tracy', 'Bob', 'Jack']

取前3個元素，應該怎麼做？
笨辦法：

>>> [L[0], L[1], L[2]]
['Mike', 'Sarah', 'Tracy']

之所以是笨辦法是因為擴充套件一下，取前N個元素就沒轍了。
取前N個元素，也就是索引為0-(N-1)的元素，可以用迴圈：

>>> r = []
>>> n = 3
>>> for
 
 i in range(n):
...     r.append(L[i])
... 
>>> r
['Mike', 'Sarah', 'Tracy']

對這種經常取指定索引範圍的操作，用迴圈十分繁瑣，因此，Python提供了切片（Slice）操作符，能大大簡化這種操作。
對應上面的問題，取前3個元素，用一行程式碼就可以完成切片：

>>> L[0:3]
['Michael', 'Sarah', 'Tracy']

L[0:3]表示，從索引0開始取，直到索引3為止，但不包括索引3。即索引0，1，2，正好是3個元素。
如果第一個索引是0，還可以省略：

>>> L[:3]
['Mike', 'Sarah', 'Tracy']

也可以從索引1開始，取出2個元素出來：

>>> L[1:3]
['Sarah', 'Tracy']

類似的，既然Python支援L[-1]取倒數第一個元素，那麼它同樣支援倒數切片，試試：

>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

記住倒數第一個元素的索引是-1。
切片操作十分有用。我們先建立一個0-99的數列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

可以通過切片輕鬆取出某一段數列。比如前10個數：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

後10個數：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20個數：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10個數，每兩個取一個：

>>> L[:10:2]
[0, 2, 4, 6, 8]

所有數，每5個取一個：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什麼都不寫，只寫[:]就可以原樣複製一個list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一種list，唯一區別是tuple不可變。因此，tuple也可以用切片操作，只是操作的結果仍是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字串’xxx’也可以看成是一種list，每個元素就是一個字元。因此，字串也可以用切片操作，只是操作結果仍是字串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在很多程式語言中，針對字串提供了很多各種擷取函式（例如，substring），其實目的就是對字串切片。Python沒有針對字串的擷取函式，只需要切片一個操作就可以完成，非常簡單。

練習

利用切片操作，實現一個trim()函式，去除字串首尾的空格，注意不要呼叫str的strip()方法：

def trim(s):
    num=len(s)
    timer1=0
    timer2=-1
    for i in range(0,num):
        if s[timer1]==' ':
            timer1=timer1+1
        if s[timer2]==' ':
            timer2=timer2-1
    s3=s[timer1:timer2+num+1]
    return s3

迭代

如果給定一個list或tuple，我們可以通過for迴圈來遍歷這個list或tuple，這種遍歷我們稱為迭代（Iteration）。
在Python中，迭代是通過for … in來完成的，而很多語言比如C語言，迭代list是通過下標完成的，比如Java程式碼：

for (i=0; i<list.length; i++) {
    n = list[i];
}

可以看出，Python的for迴圈抽象程度要高於C的for迴圈，因為Python的for迴圈不僅可以用在list或tuple上，還可以作用在其他可迭代物件上。

list這種資料型別雖然有下標，但很多其他資料型別是沒有下標的，但是，只要是可迭代物件，無論有無下標，都可以迭代，比如dict就可以迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

因為dict的儲存不是按照list的方式順序排列，所以，迭代出的結果順序很可能和初始化的結果不一樣。

預設情況下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同時迭代key和value，可以用for k, v in d.items()。
由於字串也是可迭代物件，因此，也可以作用於for迴圈：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

所以，當我們使用for迴圈時，只要作用於一個可迭代物件，for迴圈就可以正常執行，而我們不太關心該物件究竟是list還是其他資料型別。
那麼，如何判斷一個物件是可迭代物件呢？方法是通過collections模組的Iterable型別判斷：

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

最後一個小問題，如果要對list實現類似Java那樣的下標迴圈怎麼辦？Python內建的enumerate函式可以把一個list變成索引-元素對，這樣就可以在for迴圈中同時迭代索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for迴圈裡，同時引用了兩個變數，在Python裡是很常見的，比如下面的程式碼：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

練習

請使用迭代查詢一個list中最小和最大值，並返回一個tuple：

def finde(x):
    minn=x[0]
    maxn=x[0]
    for value in x:
        if minn>value:
            minn=value
        if maxn<value:
            maxn=value
    return(minn,maxn)

列表生成式

列表生成式即List Comprehensions，是Python內建的非常簡單卻強大的可以用來建立list的生成式。
舉個例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, …, 10x10]怎麼做？方法一是迴圈：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

但是迴圈太繁瑣，而列表生成式則可以用一行語句代替迴圈生成上面的list：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

寫列表生成式時，把要生成的元素x * x放到前面，後面跟for迴圈，就可以把list創建出來，十分有用，多寫幾次，很快就可以熟悉這種語法。
for迴圈後面還可以加上if判斷，這樣我們就可以篩選出僅偶數的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

還可以使用兩層迴圈，可以生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

三層和三層以上的迴圈就很少用到了。
運用列表生成式，可以寫出非常簡潔的程式碼。例如，列出當前目錄下的所有檔案和目錄名，可以通過一行程式碼實現：

>>> import os # 匯入os模組，模組的概念後面講到
>>> [d for d in os.listdir('.')] # os.listdir可以列出檔案和目錄
['check_exampe.py', 'example_.py', 'example_download.py', 'example_download2.py', 'example_fact.py', 'example_find.py', 'example_function.py', 'example_Hanno.py', 'example_month_2.py', 'example_Multifunc.py', 'example_one.py', 'example_power.py', 'example_power1.py', 'example_print.py', 'example_print2.py', 'example_strip.py', 'example_variable.py', 'QR.png', '__pycache__']

for迴圈其實可以同時使用兩個甚至多個變數，比如dict的items()可以同時迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

因此，列表生成式也可以使用兩個變數來生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

最後把一個list中所有的字串變成小寫：

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

練習

如果list中既包含字串，又包含整數，由於非字串型別沒有lower()方法，所以列表生成式會報錯：

>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
AttributeError: 'int' object has no attribute 'lower'

使用內建的isinstance函式可以判斷一個變數是不是字串：

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

答案

L = ['Hello', 'World', 18, 'Apple', None]
l2=[s.lower() for s in L if isinstance(s,str)]
print(l2)

生成器

通過列表生成式，我們可以直接建立一個列表。但是，受到記憶體限制，列表容量肯定是有限的。而且，建立一個包含100萬個元素的列表，不僅佔用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。
所以，如果列表元素可以按照某種演算法推算出來，那我們是否可以在迴圈的過程中不斷推算出後續的元素呢？這樣就不必建立完整的list，從而節省大量的空間。在Python中，這種一邊迴圈一邊計算的機制，稱為生成器：generator。
要建立一個generator，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[]改成()，就建立了一個generator：

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

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。
我們可以直接打印出list的每一個元素，但我們怎麼打印出generator的每一個元素呢？
如果要一個一個打印出來，可以通過next()函式獲得generator的下一個返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

我們講過，generator儲存的是演算法，每次呼叫next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，丟擲StopIteration的錯誤。
當然，上面這種不斷呼叫next(g)實在是太變態了，正確的方法是使用for迴圈，因為generator也是可迭代物件：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

所以，我們建立了一個generator後，基本上永遠不會呼叫next()，而是通過for迴圈來迭代它，並且不需要關心StopIteration的錯誤。
generator非常強大。如果推算的演算法比較複雜，用類似列表生成式的for迴圈無法實現的時候，還可以用函式來實現。

比如，著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契數列用列表生成式寫不出來，但是，用函式把它打印出來卻很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，賦值語句：

a, b = b, a + b

相當於：

t = (b, a + b) # t是一個tuple
a = t[0]
b = t[1]

但不必顯式寫出臨時變數t就可以賦值。
上面的函式可以輸出斐波那契數列的前N個數：

>>> fib(6)
1
1
2
3
5
8
'done'

仔細觀察，可以看出，fib函式實際上是定義了斐波拉契數列的推算規則，可以從第一個元素開始，推算出後續任意的元素，這種邏輯其實非常類似generator。
也就是說，上面的函式和generator僅一步之遙。要把fib函式變成generator，只需要把print(b)改為yield b就可以了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

這就是定義generator的另一種方法。如果一個函式定義中包含yield關鍵字，那麼這個函式就不再是一個普通函式，而是一個generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

這裡，最難理解的就是generator和函式的執行流程不一樣。函式是順序執行，遇到return語句或者最後一行函式語句就返回。而變成generator的函式，在每次呼叫next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
舉個簡單的例子，定義一個generator，依次返回數字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

呼叫該generator時，首先要生成一個generator物件，然後用next()函式不斷獲得下一個返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

可以看到，odd不是普通函式，而是generator，在執行過程中，遇到yield就中斷，下次又繼續執行。執行3次yield後，已經沒有yield可以執行了，所以，第4次呼叫next(o)就報錯。

回到fib的例子，我們在迴圈過程中不斷呼叫yield，就會不斷中斷。當然要給迴圈設定一個條件來退出迴圈，不然就會產生一個無限數列出來。

同樣的，把函式改成generator後，我們基本上從來不會用next()來獲取下一個返回值，而是直接使用for迴圈來迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for迴圈呼叫generator時，發現拿不到generator的return語句的返回值。如果想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
     try:
         x = next(g)
         print('g:', x)
     except StopIteration as e:
         print('Generator return value:', e.value)
         break

g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

關於如何捕獲錯誤，後面的錯誤處理還會詳細講解。

練習生成楊輝三角

def triangles(num):

    if num==1:
        b=[1]
    elif num==2:
        b=[1,1]
    else:
        b=[1,1]
        i=3
        while i  <num:
            yield b
            c=i*[None]
            c[0]=1
            c[i-1]=1
            for j in range(1,i-1):
                c[j]=b[j-1]+b[j]

            b=c
            i=i+1   
    return b

小結

generator是非常強大的工具，在Python中，可以簡單地把列表生成式改成generator，也可以通過函式實現複雜邏輯的generator。
要理解generator的工作原理，它是在for迴圈的過程中不斷計算出下一個元素，並在適當的條件結束for迴圈。對於函式改成的generator來說，遇到return語句或者執行到函式體最後一行語句，就是結束generator的指令，for迴圈隨之結束。
請注意區分普通函式和generator函式，普通函式呼叫直接返回結果：

>>> r = abs(6)
>>> r
6

generator函式的“呼叫”實際返回一個generator物件：

>>> g = fib(6)
>>> g
<generator object fib at 0x1022ef948>

迭代器

我們已經知道，可以直接作用於for迴圈的資料型別有以下幾種：
一類是集合資料型別，如list、tuple、dict、set、str等；
一類是generator，包括生成器和帶yield的generator function。
這些可以直接作用於for迴圈的物件統稱為可迭代物件：Iterable。
可以使用isinstance()判斷一個物件是否是Iterable物件：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用於for迴圈，還可以被next()函式不斷呼叫並返回下一個值，直到最後丟擲StopIteration錯誤表示無法繼續返回下一個值了。

可以被next()函式呼叫並不斷返回下一個值的物件稱為迭代器：Iterator。

可以使用isinstance()判斷一個物件是否是Iterator物件：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator物件，但list、dict、str雖然是Iterable，卻不是Iterator。

把list、dict、str等Iterable變成Iterator可以使用iter()函式：

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

你可能會問，為什麼list、dict、str等資料型別不是Iterator？

這是因為Python的Iterator物件表示的是一個數據流，Iterator物件可以被next()函式呼叫並不斷返回下一個資料，直到沒有資料時丟擲StopIteration錯誤。可以把這個資料流看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷通過next()函式實現按需計算下一個資料，所以Iterator的計算是惰性的，只有在需要返回下一個資料時它才會計算。

Iterator甚至可以表示一個無限大的資料流，例如全體自然數。而使用list是永遠不可能儲存全體自然數的。

小結

凡是可作用於for迴圈的物件都是Iterable型別；
凡是可作用於next()函式的物件都是Iterator型別，它們表示一個惰性計算的序列；
集合資料型別如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函式獲得一個Iterator物件。
Python的for迴圈本質上就是通過不斷呼叫next()函式實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

實際上完全等價於：

# 首先獲得Iterator物件:
it = iter([1, 2, 3, 4, 5])
# 迴圈:
while True:
    try:
        # 獲得下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出迴圈
        break

相關推薦

Python學習筆記：高階特性

前言 最近在學習深度學習，已經跑出了幾個模型，但Pyhton的基礎不夠紮實，因此，開始補習Python了，大家都推薦廖雪峰的課程，因此，開始了學習，但光學有沒有用，還要和大家討論一下，因此，寫下這些帖子，廖雪峰的課程連線在這裡：廖雪峰 Python的相關介紹

Python 學習筆記（高階特性）

【關於切片】 #例如一個列表如下： L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] print('L=', L) #在沒有使用切片之前，取列表前三項的方法可能會是： _list = [] for i in range(3): _list.

Python學習07：高階特性

本文學習Python的筆記，僅供參考 本文介紹一下Python的高階特性：切片，迭代，列表生成器，生成器 切片 對於List和tuple資料結構，會經常取其中的部分進行操作，如L = [1，2，3，4，5，6] ，取前三個元素，這樣的話需要L[0],L[1],L[2] 這

Python學習筆記二(高階特性)

     1. 切片 #取一個list或tuple的部分元素是非常常見的操作,即輸出第0,1,2三個元素 L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] # 方法一： print([L[0], L[1], L[2]])

Python學習筆記(一) —— 高階特性

寫學習筆記之前對python的基礎語法已經有了基本的瞭解，在此不冗餘的敘述。直接從其高階特性開始。python的學習材料或網站:高階特性切片切片是對list和tuple的常見操作。以list來舉例，先建立一個0-99的數列：L = list(range(100))前十個數:L

Python學習筆記：Python高階特性

Python學習筆記：Python高階特性 學自廖雪峰巨佬的Python3教程：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317568446245b3e1c883

Python之學習筆記（高階特性）

[TOC] 切片，迭代，列表表示式，生成器 高階特性 # -*- coding: utf-8 -*- from collections import Iterable L = [] n =

python學習筆記：字符串

修改 結束 () 添加 cnblogs hid src 處理 linu string類型由多個字符組成，可以把字符串看成一個整體，也可以取得字符串中的任何一個部分。 函數len() 返回字符串的長度 >>> address = ‘www.baidu.c

python學習筆記：函數

筆記 函數 技術 nbsp bubuko pytho img info 學習筆記 python學習筆記：函數

20180821 Python學習筆記：如何獲取當前程序路徑

con awl tab style onf getcwd nbsp 為知筆記 想要 20180821 Python學習筆記：如何獲取當前程序路徑啟動的腳本的路徑為：D:\WORK\gitbase\ShenzhenHouseInfoCrawler\main.py當前腳本的路徑

Python學習筆記：單例模式

turn 實例 提示 type類 metaclass let 所有 python3.6 ips 單例模式：一個類無論實例化多少次，返回的都是同一個實例，例如：a1=A(), a2=A(), a3=A()，a1、a2和a3其實都是同一個對象，即print(a1 is a2)和

python學習筆記：第7天 深淺拷貝

我們 spl 交集 再次 ipy section 結束 技術分享 dict 目錄 1. 基礎數據類型補充 2. set集合 3. 深淺拷貝 1. 基礎數據類型補充 （1）join方法 join方法是把一個列表中的數據進行拼接，拼接成字符串（與split方法相反，spli

python學習筆記：第8天 文件操作

只讀 查看 lse tex ati 使用場景 java 創建文件 存在 1. 文件操作介紹 說到操作文件我們肯定會想到流，文件的操作都是通過流來操作的。在python中文件的操作非常簡單，並不像Java等其他語言一樣有各種各樣的流操作，我們直接使用open函數即可打開一個文

Python學習筆記：一手漂亮的Python函數

可能 emp func 就是 外部 指南 pep 沒有 dem 使用類和函數定義模型 函數是抽象和封裝的基本方法之一 重構函數 -- 命名合理 -- 具有單一功能 -- 包含文檔註釋 -- 返回一個值 -- 代碼不超過 50 行 -- 冪等函數，盡可能是純函數

python學習筆記：第11天 閉包及迭代器

目錄 1. 函式名的使用 2. 閉包 3. 迭代器 1. 函式名的使用 其實函式名也是一個變數，但它是一個比較特殊的變數，與小括號配合可以執行函式的變數： 函式名其實和記憶體一樣，也可以使用print檢視它的記憶體地址： In[22]: def func1(): .

Python學習筆記：bisect模組實現二分搜尋

　　在Python中可以利用bisect模組來實現二分搜尋，該模組包含函式只有幾個： import bisect L = [1,3,4,5,5,5,8,10] x = 5 bisect.bisect_left(L,x) # 3 # 在L中查詢x，x存在時返回x最左側的位置，x不存在返回應該插入

python學習筆記：第12天 列表推導式和生成器

目錄 1. 迭代器 2. 推導式 1. 迭代器 什麼是生成器呢，其實生成器的本質就是迭代器；在python中有3中方式來獲取生成器（這裡主要介紹前面2種） 通過生成器函式獲取 通過各種推導式來實現生成器 生成器函式 我們來看一個普通的函式： In[2]: def fu

Python學習筆記：bisect模塊實現二分搜索

筆記 class tro -s clas range mar block 圖片 　　在Python中可以利用bisect模塊來實現二分搜索，該模塊包含函數只有幾個： import bisect L = [1,3,4,5,5,5,8,10] x = 5 bisect.

python學習筆記：第12天 列表推導式和生成器

clas traceback 括號 module recent else 接收 工作 last 目錄 1. 叠代器 2. 推導式 1. 叠代器 什麽是生成器呢，其實生成器的本質就是叠代器；在python中有3中方式來獲取生成器（這裏主要介紹前面2種） 通過生成器函數獲

Python學習筆記：import sys模組（argv、path、platform、exit）

　　sys模組是Python標準庫中自帶的一個模組。 　　sys模組包括了一組非常實用的服務，內含很多函式方法和變數，用來處理Python執行時配置以及資源，從而可以與當前程式之外的系統環境互動，如：Python直譯器。 　　一、匯入sys模組 import sys #匯入sys模組 dir(sy