Python 全國等級考試二級（基礎）

•內置對象可以直接使用，而標準庫和擴展庫需要導入後才能使用其中的對象。

【導入整個模塊庫】

使用這種方式導入後，在使用時需要在對象之前加上模塊名作為前綴，以“模塊名. 對象名”的方式進行訪問。如果模塊名字很長，那麼為方便記憶和代碼編寫，可以為導入的模塊設置一個別名，即可用“別名. 對象名”的方式來使用其中的對象了。

>>> import math # 導入標準庫 math

>>> math.pi # 查看圓周率的值

3.141592653589793

>>> math.sin(0.5) # 求 0.5（ 單位是弧度） 的正弦

0.479425538604203

>>> import random # 導入標準庫 random

>>> n = random.random() # 獲得 [0,1) 內的隨機小數

>>> n = random.randrange(1, 100) # 返回 [1, 100) 內的隨機整數

>>> import os.path as path # 導入標準庫os.path，設置別名 path

>>> path.isfile(r'C:\\windows\\notepad.exe')

True

>>> import numpy as np # 導入擴展庫numpy， 設置別名np

>>> a = np.array((1,2,3,4)) # 創建數組

【明確導入模塊中的特定對象】

使用這種方式僅導入明確指定的對象，並且可以為導入的對象起一個別名。這種導入方式可以減少查詢次數，提高訪問速度，減小打包後可執行文件的體積，同時也減少程序員需要輸入的代碼量，且不需要使用模塊名作為前綴。

>>> from math importsin # 只導入模塊中的指定對象

>>> sin(3)

0.1411200080598672

>>> from math import sinas f # 給導入的對象起別名

>>> f(3) # 等價於 sin(3)

0.1411200080598672

>>> from random importsample

>>> sample((1, 2, 3, 4, 5,6, 7), 3) # 從 7 個元素中任選 3 個不重複元素

[6,5, 1]

【一次導入特定模塊中的所有對象】

>>> from math import* # 導入標準庫 math 中所有對象

>>> gcd(36, 18) # 最大公約數

18

>>> pi # 圓周率常數 π

3.141592653589793

>>> e # 常數 e

2.718281828459045

>>> log2(8) # 計算以 2 為底的對數函數值

3.0

>>> log10(100) # 計算以 10 為底的對數函數值

2.0

>>> radians(180) # 把角度轉換為弧度

3.141592653589793

Python編程基礎

常用內置對象(Built-in Object )

對象類型

類型名稱

示例

簡要說明

數字

int

float

complex

123456789

3.1415926

1e-63+4j

基本類型，不可變，大小沒有限制

字符串

str

'swfu'

"I'm a student"

'''Python '''

容器類型，不可變，可以使用單引號、雙引號、三引號作為定界符

列表

list

[1, 2, 3]

['a', 'b', ['c', 2]]

容器類型，可變，所有元素放在一對方括號中，元素之間使用逗號分隔，其中的元素可以是任意類型

元組

tuple

(2, -5, 6)(3,)

容器類型，不可變，所有元素放在一對圓括號中，元素之間使用逗號分隔，如果元組中只有一個元素，後面必須多寫一個逗號

集合

set

{'a', 'b', 'c'}

容器類型，可變，所有元素放在一對大括號中，元素之間使用逗號分隔，元素必須為不可變類型的數據，並且不允許重複

字典

dict

{1:'food',2:'taste', 3:'import'}

容器類型，可變，所有元素放在一對大括號中，元素之間使用逗號分隔，元素形式為“鍵:值”，其中“鍵”不允許重複且必須不可變

對象類型

類型名稱

示例

簡要說明

布爾型

bool

TrueFalse

邏輯值，關係運算符、成員測試運算符、同一性測試運算符組成的表達式的值一般為True或False

空類型

NoneType

None

空值

其他可迭代對象

生成器對象、range對象、zip對象、enumerate對象、map對象、filter對象等等

具有惰性求值的特點，除range對象之外，其他幾個對象中的元素只能使用一次

編程單元

函數（使用def定義）類（使用class定義）模塊（類型為module）

類和函數都屬於可調用對象，模塊用來集中存放函數、類、常量或其他對象

常量與變量(Constant and Variable )

在Python 中，不僅變量的值是可變的，而且變量的類型也是可以隨時發生改變的，這正是動態語言的特點。•另外，在Python 程序中不需要事先聲明變量名及其類型，直接賦值即可創建任意類型的變量。

>>>x = 3 #憑空出現一個整型變量x

創建了整型變量x，並賦值為3，再例如語句

>>>x = 'Hello world.' #新的字符串變量，再也不是原來的x了

創建了字符串變量x，並賦值為'Helloworld.'。

在Python 中定義變量名、函數名或類名時，需要注意以下問題。

• 必須以漢字、字母或下畫線開頭。
• 不能包含空格或標點符號。
• 不能使用關鍵字。如if、else、for、while、return等不能作為變量名，也不能作為函數和類的名字。
• 對英文字母的大小寫敏感，如score 和 Score 不是同一個變量。
• 不建議使用系統內置的模塊名、類型名或函數名和已導入的模塊名及其成員名，這會改變其類型和含義，甚至會導致其他代碼無法正常執行。

數字類型(Numeric Type)

在Python 中，內置的數字類型有整數、實數和複數。•整數又分為二進制整數（以0b 開頭，每位上的數字為0 或 1）、八進制整數（以0o 開頭，每位上的數字在0～ 7 之間）、十進制整數（默認，每位上的數字在0～ 9之間）和十六進制整數（以 0x 開頭，每位上的數字在0 ～ 9 之間或a ～ f之間）。

•在使用時，不必擔心數值的大小問題，因為Python 支持任意大的數值。

>>>9999 ** 99 # 這裡**是冪乘運算符， 表示9999的 99次方

990148353526723487602263124753282625570559528895791057324326529121794837894053513464422176826916433932586924386677766244032001623756821400432975051208820204980098735552703841362304669970510691243800218202840374329378800694920309791954185117798434329591212159106298699938669908067573374724331208942425544893910910073205049031656789220889560732962926226305865706593594917896276756396848514900989999

儘量避免在實數之間直接進行相等性測試，而是應該以二者之差的絕對值是否足夠小作為兩個實數是否相等的依據，或者使用標準庫math中的isclose()進行測試。

>>>0.4 - 0.1 # 實數運算的結果可能會有一定的誤差

0.30000000000000004

>>>0.4 - 0.1 == 0.3 # 避免直接比較兩個實數是否相等

False

>>>abs(0.4-0.1 - 0.3) < 1e-6 # 這裡 1e-6 表示 10 的 -6 次方

True

>>>math.isclose(0.4-0.1, 0.3)

True

Python 支持複數及其運算

>>> x = 3 + 4j # 使用 j 或 J 表示複數虛部

>>> y = 5 + 6j

>>> x + y # 複數之間的加、 減、 乘、 除運算

(8+10j)

>>> x - y

(-2-2j)

>>> x * y

(-9+38j)

>>> x / y

(0.6393442622950819+0.03278688524590165j)

>>> abs(x) # 內置函數 abs() 可以計算複數的模

5.0

>>> x.imag # 虛部

4.0

>>> x.real # 實部

3.0

>>> x.conjugate() # 共軛複數

(3-4j)

字符串(String)

在Python中，使用一對單引號、雙引號、三單引號、三雙引號作為定界符來表示字符串，並且不同的定界符之間可以互相嵌套。使用雙引號限定的字符串中可以包含單引號，而使用單引號限定的字符串中可以包含雙引號。

Python支持使用加法運算符連接字符串，支持乘法運算符對字符串進行復制。除此之外，Python 字符串自身還提供了大量的方法支持查找、替換、排版等操作，很多內置函數和標準庫對象也支持對字符串的操作。

>>> x = 'Helloworld.' # 使用單引號作為定界符

>>> x = "Python is agreat language." # 使用雙引號作為定界符

>>> x = '''Tom said,"Let's go."''' # 最外層是三個單引號

# 在內層雙引號中還嵌套了一個單引號

>>> print(x)

Tom said, "Let's go."

>>> 'good ' +'morning' # 連接字符串

'goodmorning'

>>> 'good ' * 3 # 字符串複製

'goodgoodgood '

序列(Sequence)

>>> x_list = [1, 2, 3] # 創建列表對象

>>> x_tuple = (1, 2, 3) # 創建元組對象

>>> x_dict = {'a':97, 'b':98, 'c':99} # 創建字典對象

>>> x_set = {1, 2, 3} # 創建集合對象

>>> print(x_list[1]) # 使用下標訪問列表中指定位置的元素

2

>>> print(x_tuple[1]) # 使用下標訪問元組中指定位置的元素

2

>>> print(x_dict['a']) # 通過 " 鍵 " 訪問字典中對應的 " 值 "

97

>>> 3 in x_set # 測試集合中是否包含某個元素

True

運算符與表達式( Expression )

•在Python 中很多運算符具有多種不同的含義，作用於不同類型的操作數時含義並不完全相同，使用非常靈活。

•例如，加號在作用於整數、實數或複數時表示算術加法，而在作用於列表、字符串、元組時表示連接；乘號在作用於整數、實數或複數時表示算術乘法，而在列表、字符串或元組與整數相乘時表示序列複製；減號在作用於整數、實數或複數時表示算術減法，而在作用於集合時表示差集，在單個數字前面又表示負號。

運算符

功能說明

+

算術加法，列表、元組、字符串合併與連接，正號

-

算術減法，集合差集，負號

*

算術乘法，列表、元組或字符串與整數相乘時表示序列重複

/

真除法，結果為實數

//

求整商，向下取整，如果操作數中有實數的話，結果為實數形式的整數

%

求餘數，結果的符號與除數相同

**

冪運算

、>=、==、!=

關係運算符

and

邏輯與

or

邏輯或

not

邏輯非

in

成員測試

is

同一性測試，測試兩個對象是否引用同一個對象

&、|、^

集合交集、並集、對稱差集

算術運算符

（1） +運算符除用於算術加法外，還可以用於列表、元組、字符串的連接。

>>> 3 + 5.0 # 實數相加

8.0

>>> (3 + 4j) + (5 +6j) # 複數相加

(8+10j)

>>> [1, 2, 3] + [4, 5,6] # 連接兩個列表， 得到新列表

[1,2, 3, 4, 5, 6]

>>> (1, 2, 3) + (4,) # 連接兩個元組， 得到新元組

(1,2, 3, 4)

>>> 'abcd' + '1234' # 連接兩個字符串， 得到新字符串

'abcd1234'

（2）* 運算符除了表示算術乘法，還可用於列表、元組、字符串與整數的乘法，表示序列元素的

>>>3 * 5.0 # 實數乘法

15.0

>>>5 * (3 + 4j) # 實數與複數的乘法

(15+20j)

>>>(3 + 4j) * (5 + 6j) # 複數乘法

(-9+38j)

>>>[1, 2, 3] * 3 # 列表元素複製， 得到新列表

[1,2, 3, 1, 2, 3, 1, 2, 3]

>>>(1, 2, 3) * 3 # 元組元素複製， 得到新元組

(1,2, 3, 1, 2, 3, 1, 2, 3)

>>>'abc' * 3 # 字符串元素複製， 得到新字符串

'abcabcabc'

（3）運算符/ 和 // 分別表示算術除法和求整商。

>>>3 / 2 # 數學意義上的除法，結果為實數

1.5

>>>15 // 4 # 如果兩個操作數都是整數，那麼結果為整數

3

>>>15.0 // 4 # 操作數中有實數，得到實數形式的整數值

3.0

>>>-13 // 10 # 向下取整， 返回小於等於商的最大整數

-2

（4） % 運算符可以用於數字求餘數運算。

>>> 789 % 23 # 求餘數

7

>>> 36 % 12 # 餘數為 0， 表示 36 能被 12 整除

0

（5）** 運算符表示冪乘。

>>>3 ** 2 # 3 的 2 次方

9

>>>9 ** 0.5 # 9 的 0.5 次方， 可以用來計算平方根

3.0

>>>(-9) ** 0.5 # 可以對負數計算平方根，得到複數

(1.8369701987210297e-16+3j)

>>>1.01 ** 365 # 每天多努力一點點，一年後的樣子

37.78343433288728

>>>1.02 ** 365 # 每天再多努力一點點，一年後的樣子

1377.4082919660768

>>>0.99 ** 365 # 每天少努力一點點，一年後的樣子

0.025517964452291125

關係運算符

>>>1 < 3 < 5 # 等價於 1 < 3 and 3 < 5

True

>>>3 < 5 > 2

True

>>>1 > 6 < 8 # 注意， 這裡實際上並不會計算 6<8 的值

False

>>>'Hello' > 'world' # 比較字符串大小

False

>>>[1, 2, 3] < [1, 2, 4] # 比較列表大小

True

>>>'Hello' > 3 # 字符串和數字不能比較，拋出異常

TypeError: unorderable types:str() >int()

成員測試運算符

>>> 3 in [1, 2, 3] # 測試 3 是否為列表 [1, 2, 3] 的元素

True

>>> 'abc' in 'abcdefg' # 子字符串測試

True

邏輯運算符

>>> 3 and 5 # 最後一個計算的表達式的值作為整個表達式的值

5

>>> 3 or 5 # and 和 or 的結果不一定是 True 或 False

3

>>> 3 and 5>2 # 所有非 0 數值都等價於 True

True

>>> 3 not in [1, 2,3] # 邏輯非運算 not

False

>>> 3 is not 5 # not 的計算結果只能是 True 或 False 之一

True

集合運算符

>>>{1, 2, 3} & {3, 4, 5} # 交集

{3}

>>>{1, 2, 3} | {3, 4, 5} # 並集

{1,2, 3, 4, 5}

>>>{1, 2, 3} - {3, 4, 5} # 差集

{1,2}

>>>{1, 2, 3} ^ {3, 4, 5} # 對稱差集

{1,2, 4, 5}

>>>{1, 2, 3} < {1, 2, 3, 4} # 測試是否子集

True

>>>{1, 2, 3} == {3, 2, 1} # 測試兩個集合是否相等

True

>>>{1, 2, 4} > {1, 2, 3} # 集合之間的包含測試

False

>>>{1, 2, 4} < {1, 2, 3}

False

常用內置函數

函數

功能簡要說明

abs(x)

返回數字x的絕對值或複數x的模

bin(x)

返回整數x的二進制表示形式

complex(real, [imag])

返回指定實部和虛部的複數

chr(x)

返回Unicode編碼為x的字符

dir(obj)

返回指定對象或模塊obj的成員列表，不帶參數則返回包含當前作用域內所有標識符名字的列表

divmod(x, y)

返回包含整商和餘數的元組((x-x%y)/y, x%y)

enumerate(iterable[, start])

返回包含元素形式為(start, iterable[0]), (start+1, iterable[1]), (start+2, iterable[2]), ...的迭代器對象，start默認值為0，enumerate對象中的元素只能使用一次

eval(s[, globals[, locals]])

計算並返回字符串s中表達式的值

filter(func, seq)

返回filter對象，其中包含序列seq中使得單參數函數func返回值等價於True的那些元素，如果函數func為None則返回包含seq中等價於True的元素的filter對象，filter對象中的元素只能使用一次

float(x)

返回把整數或字符串x轉換成浮點數的結果

help(obj)

返回對象obj的幫助信息

hex(x)

返回整數x的十六進制表示形式

函數

功能簡要說明

input([提示信息])

顯示提示信息，接收鍵盤輸入的內容，以字符串形式返回

int(x[, d])

返回數字x的整數部分，或把字符串x看做d進制數，將其轉換為十進制返回，d默認為10

isinstance(, class-or-type-or-tuple)

測試對象obj是否屬於指定類型（如果有多個類型的話需要放到元組中），返回True或False

len(obj)

返回對象obj包含的元素個數，適用於列表、元組、集合、字典、字符串以及range對象，但不適用於zip、map、filter、enumerate或類似對象

list([x])、set([x])、tuple([x])、dict([x])

把可迭代對象x轉換為列表、集合、元組或字典並返回，不帶參數時用來生成空列表、空集合、空元組、空字典

map(func, *iterables)

返回包含若干func函數值的map對象，函數func的參數分別來自於iterables指定的每個迭代對象，map對象中的元素只能使用一次

max(...)、 min(...)

返回多個值中或者包含有限個元素的可迭代對象中所有元素的最大值、最小值，要求所有元素之間可比較大小，允許使用key參數指定排序規則

next(iterator[, default])

返回迭代器對象x中的下一個元素，default參數表示迭代結束之後繼續迭代時返回的默認值

oct(x)

返回整數x的八進制表示形式

ord(x)

返回單個字符x的Unicode編碼

函數

功能簡要說明

pow(x, y, z=None)

返回x的y次方或該結果對z的餘數，等價於x ** y或(x ** y) % z

print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)

基本輸出函數，默認輸出到屏幕，多個數值之間使用空格分隔，以換行符結束所有數據的輸出

range([start,] end [, step] )

返回range對象，其中包含左閉右開區間[start,end)內以step為步長的整數

reduce(func, sequence[, initial])

將雙參數函數func以迭代的方式從左到右依次應用至序列seq中每個元素，每次的計算結果作為下一次計算的第一個操作數繼續參與運算，最終返回單個值作為結果。在Python 3.x中需要從標準庫functools中導入reduce()函數再使用

reversed(seq)

返回seq（可以是列表、元組、字符串、range等對象）中所有元素逆序後的迭代器對象，但不能作用於zip、filter、map、enumerate、reversed等對象，reversed對象中的元素只能使用一次

round(x [, 小數位數])

返回對x進行四捨五入的結果，若不指定小數位數，則返回整數

函數

功能簡要說明

sorted(, key=None, reverse=False)

返回按指定規則對iterable排序後的列表，其中iterable表示要排序的序列或迭代對象，key用來指定排序規則，reverse用來指定升序（False）或降序（True）。該函數不對iterable做任何修改

str(obj)

返回把對象obj直接轉換為字符串的結果

sum(x, start=0)

返回序列x中所有元素之和，允許指定起始值start（默認為0），返回start+sum(x)的結果

type(obj)

返回對象obj的類型

zip(seq1 [, seq2 [...]])

返回zip對象，其中元素為(seq1[i], seq2[i], ...)形式的元組，最終結果中包含的元素個數取決於所有參數序列或可迭代對象中最短的那個，zip對象中的元素只能使用一次

>>>x = input('Please input: ')

Pleaseinput: 345

>>>type(x) # 返回字符串

<class>

>>>int(x) # 轉換為整數

345

>>>x = input('Please input: ')

Pleaseinput: [1, 2, 3]

>>>type(x)

<class>

>>>eval(x) # 對字符串進行求值，還原為列表

[1,2, 3]

>>>x = input('Please input:') # 不論用戶輸入什麼， 都返回字符串

Please input:'helloworld'

>>>x # 如果本來就想輸入字符串，那麼不用再輸入引號

"'helloworld'"

>>>eval(x)

'helloworld'

基本輸入輸出函數

>>>x = input('Please input: ')

Please input: 345

>>>type(x) # 返回字符串

<class>

>>>int(x) # 轉換為整數

345

>>>x = input('Please input: ')

Please input: [1, 2, 3]

>>>type(x)

<class>

>>>eval(x) # 對字符串進行求值，還原為列表

[1,2, 3]

>>>x = input('Please input:') # 不論用戶輸入什麼， 都返回字符串

Please input:'helloworld'

>>>x # 如果本來就想輸入字符串，那麼不用再輸入引號

"'helloworld'"

>>>eval(x)

'helloworld'

>>> print(1, 3, 5, 7, sep='\\t') # 修改默認分隔符

1 35 7

>>> for i in range(10):

print(i, end=' ') # 修改默認行尾結束符， 不換行

0 1 2 3 4 5 6 7 8 9

數字有關的函數

（1）函數bin()、 oct()和 hex() 分別用來將整數轉換為二進制數、八進制數和十六進制數的數字字符串，要求參數必須為整數。

>>> bin(555) # 將十進制整數轉換為二進制數字字符串

'0b1000101011'

>>> oct(555) # 將十進制整數轉換為八進制數字字符串

'0o1053'

>>> hex(555) # 將十進制整數轉換為十六進制數字字符串

'0x22b'

>>> bin(0x888) # 將十六進制整數直接轉換為二進制數字字符

'0b100010001000'

（2）函數int()用來將其他形式的數字轉換為整數

，參數可以為整數、實數、分數或合法的數字字符串，語法格式有int([x])和 int(x,base=10)兩種。

>>>int(-3.2) # 將實數轉換為整數

-3

>>>int('0x22b', 16) # 將十六進制數轉換為十進制數

555

>>>int('22b', 16) # 與上一行代碼等價

555

>>>int(bin(54321), 2) # 二進制數與十進制數之間的轉換

54321

>>>int('0b111') # 非十進制數字字符串， 必須指定第二個參數

ValueError:invalid literal for int() withbase 10: '0b111'

>>>int('0b111', 0) # 第二個參數 0 表示使用字符串隱含的進制

7

>>>int('0b111', 6) # 第二個參數必須與隱含的進制一致

ValueError:invalid literal for int() withbase 6: '0b111'

>>>int('111', 6) # 字符串沒有隱含進制

# 這時第二個參數可以為 2 ～ 36 之間的整數

（3）函數float() 用來將其他類型數據轉換為實數，函數complex()用來生成複數。

>>>float(3) # 把整數轉換為實數

3.0

>>>float('5.5') # 把數字字符串轉換為實數

5.5

>>>float('inf') # 無窮大， 其中inf不區分大小寫

inf

>>>complex(3) # 只指定實部， 虛部默認為 0

(3+0j)

>>>

complex(4, 5) # 同時指定實部和虛部

(4+5j)

（4）函數abs() 用來計算實數的絕對值或者複數的模，函數divmod()用來同時計算兩個數的商和餘數，函數pow() 用來計算冪乘，函數round()用來對數字進行四捨五入。

>>>abs(-3) # 絕對值

3

>>>abs(-3 + 4j) # 複數的模

5.0

>>>divmod(60, 8) # 返回商和餘數組成的元組

(7,4)

>>>pow(2, 3) # 冪運算， 2 的3 次方，相當於 2**3

8

>>>pow(2, 3, 5) # 相當於 (2**3) % 5

3

>>>round(10/3, 2) # 四捨五入， 保留 2 位小數

3.33

序列有關的函數

（1）函數list()、 tuple()、 dict()、 set() 和 str()

>>>list(range(5)) # 把 range 對象轉換為列表

[0,1, 2, 3, 4]

>>>tuple(_) # 一個下畫線表示上一次正確輸出結果

(0,1, 2, 3, 4)

>>>dict( zip('1234', 'abcde')) # 創建字典

{'4':'d', '2': 'b', '3': 'c', '1': 'a'}

>>>set('1112234') # 創建集合

{'4','2', '3', '1'}

>>>str(1234) # 直接轉換為字符串

'1234'

>>>str([1, 2, 3, 4]) # 直接轉換為字符串

'[1,2, 3, 4]'

>>>list(str([1, 2, 3, 4])) # 注意這裡的轉換結果

['[','1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']

（2）函數max()、 min()、 sum()

>>> from random import randint

>>> scores = [randint(1,100) for i in range(10)]

# 包含 10 個 [1,100] 之間隨機數的列表

>>> scores

[15,100, 59, 88, 74, 58, 56, 48, 74, 86]

>>> print(max(scores),min(scores), sum(scores))

# 最大值、 最小值、 所有元素之和

10015 658

>>> sum(scores) / len(scores) # 平均值

65.8

（3）函數sorted()

>>>x = list(range(11))

>>>import random

>>>random.shuffle(x) # 隨機打亂順序

>>>x

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

>>>sorted(x) # 以默認規則排序

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

>>>sorted(x, key=lambda item:len(str(item)), reverse=True)

# 按轉換成字符串以後的長度降序排列

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

>>>sorted(x, key=str) # 按轉換為字符串以後的大小排序

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

>>>x # 不影響原來列表的元素順序

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

>>>list(reversed(x)) # 逆序， 翻轉

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

（4）函數enumerate()

>>> list(enumerate('abcd')) # 枚舉字符串中的元素

[(0,'a'), (1, 'b'), (2, 'c'), (3, 'd')]

>>>list(enumerate(['Python', 'Greate'])) # 枚舉列表中的元素

[(0,'Python'), (1, 'Greate')]

>>> for index, value inenumerate(range(10, 15)):

print((index, value), end=' ')

(0,10) (1, 11) (2, 12) (3, 13) (4, 14)

（5）函數zip()

>>>list(zip('abcd', [1, 2, 3])) # 壓縮字符串和列表

[('a',1), ('b', 2), ('c', 3)]

>>>list(zip('abcd')) # 對一個序列也可以壓縮

[('a',),('b',), ('c',), ('d',)]

>>>list(zip('123', 'abc', ',.!')) # 壓縮三個序列

[('1','a', ','), ('2', 'b', '.'), ('3', 'c', '!')]

>>>for item in zip('abcd', range(3)): # zip 對象是可迭代的

print(item)

('a',0)

('b',1)

('c',2)

>>>x = zip('abcd', '1234')

>>>list(x)

[('a','1'), ('b', '2'), ('c', '3'), ('d', '4')]

>>>list(x) #zip 對象中的元素只能使用一次

[]

函數map()、 reduce()、 filter()

（1）函數map()

>>>list(map(str, range(5))) # 把列表中元素轉換為字符串

['0','1', '2', '3', '4']

>>>def add5(v): # 單參數函數， 把參數加 5 後返回

return v+5

>>>list(map(add5, range(10))) # 把單參數函數映射到序列的所有元素上

[5,6, 7, 8, 9, 10, 11, 12, 13, 14]

>>>def add(x, y): # 返回兩個參數之和的函數

return x+y

>>>list(map(add, range(5), range(5,10))) # 把雙參數函數映射到兩個序列上

[5,7, 9, 11, 13]

>>>import random

>>>x = random.randint(1, 1e30) # 生成指定範圍內的隨機整數

>>>x

839746558215897242220046223150

>>>list(map(int, str(x))) # 提取大整數每位上的數字

[8,3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2, 2, 3,1, 5, 0]

>>>sum(map(int, str(x))) # 大整數各位數字之和

122

（2）標準庫functools中的函數reduce()

>>> from functools import reduce

>>> seq = list(range(1, 10)) # range(1,10) 包含從 1 到 9 的整數

>>> reduce(add, seq) # add 是上一段代碼中定義的函數

45

（3）函數filter()

>>>seq = ['foo', 'x41', '?!', '***']

>>>deffunc(x):

return x.isalnum() # 測試是否為字母或數字

>>>filter(func, seq) # 返回可迭代的 filter 對象

<filterobject>

>>>list(filter(func, seq)) # 把 filter 對象轉換為列表

['foo','x41']

>>>seq #filter() 不對原列表做任何修改

['foo','x41', '?!', '***']

>>>list(filter(None, [1, 2, 3, 0, 0, 4, 0, 5])) # 指定函數為 None

[1,2, 3, 4, 5]

函數range()

函數 range() 是 Python 中非常有用的一個函數，其語法格式為range([start, ]stop[, step] )，有range(stop)、 range(start, stop) 和 range(start,stop, step) 三種用法，參數 start 默認為 0， step 默認為 1。該函數返回具有惰性求值特點的 range 對象，其中包含左閉右開區間 [start, end) 內以step為步長的整數。

>>>range(5) # start 默認為 0， step 默認為 1

range(0,5)

>>>list(range(1, 10, 2)) # 指定步長， 並轉換為列表查看其中的內容

[1,3, 5, 7, 9]

>>>list(range(9, 0, -2)) # 步長可以為負數

[9,7, 5, 3, 1]

精彩例題分析與解答

1、編寫程序，輸入一個包含若干自然數的列表，輸出一個新列表，要求新列表中只包含原來列表中各位數字之和等於9 的自然數。

x = eval(input(' 請輸入包含若干自然數的列表：'))

result = list(filter(lambda num:sum(map(int, str(num)))==9, x))

print(result)

---

分享到:

---

閱讀更多 城市板塊分析 的文章

關鍵字: Eclipse 泛函編程 Microsoft

---