Python 3基礎(chǔ)四

Python3 函數(shù)

函數(shù)是組織好的，可重復(fù)使用的，用來(lái)實(shí)現(xiàn)單一羽历，或相關(guān)聯(lián)功能的代碼段。
函數(shù)能提高應(yīng)用的模塊性芒粹，和代碼的重復(fù)利用率。你已經(jīng)知道Python提供了許多內(nèi)建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)骡和，這被叫做用戶自定義函數(shù)。
個(gè)人理解相寇，函數(shù)或者方法就是定義好的，直接拿來(lái)用就可以钮科，不用關(guān)注實(shí)現(xiàn)方式唤衫，拿到想要的結(jié)果就ok，跟對(duì)外訪問(wèn)接口類似绵脯。
當(dāng)然佳励，如果可以頻繁的用到某些代碼，就把代碼封裝起來(lái)蛆挫，一次書(shū)寫(xiě)赃承，多次調(diào)用。
定義一個(gè)函數(shù)
你可以定義一個(gè)由自己想要功能的函數(shù)悴侵，以下是簡(jiǎn)單的規(guī)則：
函數(shù)代碼塊以 def 關(guān)鍵詞開(kāi)頭瞧剖，后接函數(shù)標(biāo)識(shí)符名稱和圓括號(hào) ()。
任何傳入?yún)?shù)和自變量必須放在圓括號(hào)中間可免，圓括號(hào)之間可以用于定義參數(shù)抓于。
函數(shù)的第一行語(yǔ)句可以選擇性地使用文檔字符串—用于存放函數(shù)說(shuō)明。
函數(shù)內(nèi)容以冒號(hào) : 起始浇借，并且縮進(jìn)捉撮。
return [表達(dá)式] 結(jié)束函數(shù)，選擇性地返回一個(gè)值給調(diào)用方妇垢，不帶表達(dá)式的 return 相當(dāng)于返回 None巾遭。
Python 定義函數(shù)使用 def 關(guān)鍵字肉康，一般格式如下：

# Python 定義函數(shù)使用 def 關(guān)鍵字，一般格式如下：
def 函數(shù)名（參數(shù)列表）:
    函數(shù)體
# JAVA 
public static void  函數(shù)名（參數(shù)列表）{
       函數(shù)體
}

#!/usr/bin/python3

def hello() :
    print("Hello World!")

hello()

public static void  hello（）{
       System.out.println("Hello World!")
}

# java 入口函數(shù)
public static void main(){
 hello（）
}

image.png

#!/usr/bin/python3
 
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

# 計(jì)算面積函數(shù)
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

5
Welcome Runoob
width = 4  height = 5  area = 20

函數(shù)調(diào)用

定義一個(gè)函數(shù)：給了函數(shù)一個(gè)名稱灼舍，指定了函數(shù)里包含的參數(shù)吼和，和代碼塊結(jié)構(gòu)。
這個(gè)函數(shù)的基本結(jié)構(gòu)完成以后片仿，你可以通過(guò)另一個(gè)函數(shù)調(diào)用執(zhí)行纹安，也可以直接從 Python 命令提示符執(zhí)行。
如下實(shí)例調(diào)用了 printme() 函數(shù)：

#!/usr/bin/python3
 
# 定義函數(shù)
def printme( str ):
   # 打印任何傳入的字符串
   print (str)
   return
 
# 調(diào)用函數(shù)
printme("我要調(diào)用用戶自定義函數(shù)!")
printme("再次調(diào)用同一函數(shù)")

我要調(diào)用用戶自定義函數(shù)!
再次調(diào)用同一函數(shù)

參數(shù)傳遞

在 python 中砂豌，類型屬于對(duì)象厢岂，對(duì)象有不同類型的區(qū)分，變量是沒(méi)有類型的：

a=[1,2,3]

a="Runoob"

以上代碼中阳距，[1,2,3] 是 List 類型塔粒，"Runoob" 是 String 類型，而變量 a 是沒(méi)有類型筐摘，她僅僅是一個(gè)對(duì)象的引用（一個(gè)指針）卒茬，可以是指向 List 類型對(duì)象，也可以是指向 String 類型對(duì)象咖熟。

可更改(mutable)與不可更改(immutable)對(duì)象

在 python 中圃酵，strings, tuples, 和 numbers 是不可更改的對(duì)象，而 list,dict 等則是可以修改的對(duì)象馍管。
不可變類型：變量賦值 a=5 后再賦值 a=10郭赐，這里實(shí)際是新生成一個(gè) int 值對(duì)象 10，再讓 a 指向它确沸，而 5 被丟棄捌锭，不是改變 a 的值，相當(dāng)于新生成了 a罗捎。
可變類型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 則是將 list la 的第三個(gè)元素值更改观谦，本身la沒(méi)有動(dòng)，只是其內(nèi)部的一部分值被修改了桨菜。
python 函數(shù)的參數(shù)傳遞：
不可變類型：類似 C++ 的值傳遞豁状，如整數(shù)、字符串雷激、元組替蔬。如 fun(a)，傳遞的只是 a 的值屎暇，沒(méi)有影響 a 對(duì)象本身承桥。如果在 fun(a) 內(nèi)部修改 a 的值，則是新生成一個(gè) a 的對(duì)象根悼。
可變類型：類似 C++ 的引用傳遞凶异，如 列表蜀撑，字典。如 fun(la)剩彬，則是將 la 真正的傳過(guò)去酷麦，修改后 fun 外部的 la 也會(huì)受影響
python 中一切都是對(duì)象，嚴(yán)格意義我們不能說(shuō)值傳遞還是引用傳遞喉恋，我們應(yīng)該說(shuō)傳不可變對(duì)象和傳可變對(duì)象沃饶。
python 傳不可變對(duì)象實(shí)例
通過(guò) id() 函數(shù)來(lái)查看內(nèi)存地址變化：

def change(a):
    print(id(a))   # 指向的是同一個(gè)對(duì)象
    a=10
    print(id(a))   # 一個(gè)新對(duì)象
 
a=1
print(id(a))
change(a)

4379369136
4379369136
4379369424

可以看見(jiàn)在調(diào)用函數(shù)前后，形參和實(shí)參指向的是同一個(gè)對(duì)象（對(duì)象 id 相同）轻黑，在函數(shù)內(nèi)部修改形參后糊肤，形參指向的是不同的 id。
傳可變對(duì)象實(shí)例
可變對(duì)象在函數(shù)里修改了參數(shù)氓鄙，那么在調(diào)用這個(gè)函數(shù)的函數(shù)里馆揉，原始的參數(shù)也被改變了。例如：

#!/usr/bin/python3
 
# 可寫(xiě)函數(shù)說(shuō)明
def changeme( mylist ):
   "修改傳入的列表"
   mylist.append([1,2,3,4])
   print ("函數(shù)內(nèi)取值: ", mylist)
   return
 
# 調(diào)用changeme函數(shù)
mylist = [10,20,30]
changeme( mylist )
print ("函數(shù)外取值: ", mylist)

函數(shù)內(nèi)取值:  [10, 20, 30, [1, 2, 3, 4]]
函數(shù)外取值:  [10, 20, 30, [1, 2, 3, 4]]

參數(shù)

以下是調(diào)用函數(shù)時(shí)可使用的正式參數(shù)類型：
必需參數(shù)
關(guān)鍵字參數(shù)
默認(rèn)參數(shù)
不定長(zhǎng)參數(shù)
必需參數(shù)

必需參數(shù)須以正確的順序傳入函數(shù)抖拦。調(diào)用時(shí)的數(shù)量必須和聲明時(shí)的一樣升酣。

調(diào)用 printme() 函數(shù)，你必須傳入一個(gè)參數(shù)态罪，不然會(huì)出現(xiàn)語(yǔ)法錯(cuò)誤：

#!/usr/bin/python3
 
#可寫(xiě)函數(shù)說(shuō)明
def printme( str ):
   "打印任何傳入的字符串"
   print (str)
   return
 
# 調(diào)用 printme 函數(shù)噩茄，不加參數(shù)會(huì)報(bào)錯(cuò)
printme()

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

關(guān)鍵字參數(shù)

關(guān)鍵字參數(shù)和函數(shù)調(diào)用關(guān)系緊密，函數(shù)調(diào)用使用關(guān)鍵字參數(shù)來(lái)確定傳入的參數(shù)值复颈。
使用關(guān)鍵字參數(shù)允許函數(shù)調(diào)用時(shí)參數(shù)的順序與聲明時(shí)不一致巢墅，因?yàn)?Python 解釋器能夠用參數(shù)名匹配參數(shù)值。
以下實(shí)例在函數(shù) printme() 調(diào)用時(shí)使用參數(shù)名：

#!/usr/bin/python3
 
#可寫(xiě)函數(shù)說(shuō)明
def printme( str ):
   "打印任何傳入的字符串"
   print (str)
   return
 
#調(diào)用printme函數(shù)
printme( str = "hello python")

hello python

函數(shù)參數(shù)的使用不需要使用指定順序：
與java不同券膀，java順序不對(duì)的話，如果類型不一致會(huì)報(bào)錯(cuò)的驯遇，即使類型一致結(jié)果也是不對(duì)的

#!/usr/bin/python3
 
#可寫(xiě)函數(shù)說(shuō)明
def printinfo( name, age ):
   "打印任何傳入的字符串"
   print ("名字: ", name)
   print ("年齡: ", age)
   return
 
#調(diào)用printinfo函數(shù)
printinfo( age=50, name="runoob" )

名字:  runoob
年齡:  50

默認(rèn)參數(shù)

調(diào)用函數(shù)時(shí)芹彬，如果沒(méi)有傳遞參數(shù)，則會(huì)使用默認(rèn)參數(shù)叉庐。以下實(shí)例中如果沒(méi)有傳入 age 參數(shù)舒帮，則使用默認(rèn)值：

#!/usr/bin/python3
 
#可寫(xiě)函數(shù)說(shuō)明
def printinfo( name, age = 35 ):
   "打印任何傳入的字符串"
   print ("名字: ", name)
   print ("年齡: ", age)
   return
 
#調(diào)用printinfo函數(shù)
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

名字:  runoob
年齡:  50
------------------------
名字:  runoob
年齡:  35

不定長(zhǎng)參數(shù)

你可能需要一個(gè)函數(shù)能處理比當(dāng)初聲明時(shí)更多的參數(shù)。這些參數(shù)叫做不定長(zhǎng)參數(shù)陡叠，和上述 2 種參數(shù)不同玩郊，聲明時(shí)不會(huì)命名⊥髡螅基本語(yǔ)法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函數(shù)_文檔字符串"
   function_suite
   return [expression]

加了星號(hào) * 的參數(shù)會(huì)以元組(tuple)的形式導(dǎo)入译红，存放所有未命名的變量參數(shù)。

#!/usr/bin/python3
  
# 可寫(xiě)函數(shù)說(shuō)明
def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數(shù)"
   print ("輸出: ")
   print (arg1)
   print (vartuple)
 
# 調(diào)用printinfo 函數(shù)
printinfo( 70, 60, 50 )

輸出: 
70
(60, 50)

如果在函數(shù)調(diào)用時(shí)沒(méi)有指定參數(shù)兴溜，它就是一個(gè)空元組侦厚。我們也可以不向函數(shù)傳遞未命名的變量耻陕。如下實(shí)例：

#!/usr/bin/python3
 
# 可寫(xiě)函數(shù)說(shuō)明
def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數(shù)"
   print ("輸出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 調(diào)用printinfo 函數(shù)
printinfo( 10 )
printinfo( 70, 60, 50 )

輸出:
10
輸出:
70
60
50

還有一種就是參數(shù)帶兩個(gè)星號(hào) **基本語(yǔ)法如下：

def functionname([formal_args,] **var_args_dict ):
   "函數(shù)_文檔字符串"
   function_suite
   return [expression]

#!/usr/bin/python3
  
# 可寫(xiě)函數(shù)說(shuō)明
def printinfo( arg1, **vardict ):
   "打印任何傳入的參數(shù)"
   print ("輸出: ")
   print (arg1)
   print (vardict)
 
# 調(diào)用printinfo 函數(shù)
printinfo(1, a=2,b=3)

輸出: 
1
{'a': 2, 'b': 3}

聲明函數(shù)時(shí)，參數(shù)中星號(hào) * 可以單獨(dú)出現(xiàn)刨沦，例如:

def f(a,b,*,c):
    return a+b+c

如果單獨(dú)出現(xiàn)星號(hào) *诗宣，則星號(hào) * 后的參數(shù)必須用關(guān)鍵字傳入：

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 報(bào)錯(cuò)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

匿名函數(shù)

Python 使用 lambda 來(lái)創(chuàng)建匿名函數(shù)。
所謂匿名想诅，意即不再使用 def 語(yǔ)句這樣標(biāo)準(zhǔn)的形式定義一個(gè)函數(shù)召庞。
lambda 只是一個(gè)表達(dá)式，函數(shù)體比 def 簡(jiǎn)單很多来破。
lambda 的主體是一個(gè)表達(dá)式篮灼，而不是一個(gè)代碼塊。僅僅能在 lambda 表達(dá)式中封裝有限的邏輯進(jìn)去讳癌。
lambda 函數(shù)擁有自己的命名空間穿稳，且不能訪問(wèn)自己參數(shù)列表之外或全局命名空間里的參數(shù)。
雖然 lambda 函數(shù)看起來(lái)只能寫(xiě)一行晌坤，卻不等同于 C 或 C++ 的內(nèi)聯(lián)函數(shù)逢艘，后者的目的是調(diào)用小函數(shù)時(shí)不占用棧內(nèi)存從而增加運(yùn)行效率。
語(yǔ)法
lambda 函數(shù)的語(yǔ)法只包含一個(gè)語(yǔ)句骤菠，如下：

lambda [arg1 [,arg2,.....argn]]:expression

設(shè)置參數(shù) a 加上 10:

x = lambda a : a + 10
print(x(5))

15

以下實(shí)例匿名函數(shù)設(shè)置兩個(gè)參數(shù)：

#!/usr/bin/python3
 
# 可寫(xiě)函數(shù)說(shuō)明
sum = lambda arg1, arg2: arg1 + arg2
 
# 調(diào)用sum函數(shù)
print ("相加后的值為 : ", sum( 10, 20 ))
print ("相加后的值為 : ", sum( 20, 20 ))

相加后的值為 :  30
相加后的值為 :  40

我們可以將匿名函數(shù)封裝在一個(gè)函數(shù)內(nèi)它改，這樣可以使用同樣的代碼來(lái)創(chuàng)建多個(gè)匿名函數(shù)。
以下實(shí)例將匿名函數(shù)封裝在 myfunc 函數(shù)中商乎，通過(guò)傳入不同的參數(shù)來(lái)創(chuàng)建不同的匿名函數(shù)：

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

22
33

return 語(yǔ)句

return [表達(dá)式] 語(yǔ)句用于退出函數(shù)央拖，選擇性地向調(diào)用方返回一個(gè)表達(dá)式。不帶參數(shù)值的 return 語(yǔ)句返回 None鹉戚。之前的例子都沒(méi)有示范如何返回?cái)?shù)值鲜戒，以下實(shí)例演示了 return 語(yǔ)句的用法：

#!/usr/bin/python3
 
# 可寫(xiě)函數(shù)說(shuō)明
def sum( arg1, arg2 ):
   # 返回2個(gè)參數(shù)的和."
   total = arg1 + arg2
   print ("函數(shù)內(nèi) : ", total)
   return total
 
# 調(diào)用sum函數(shù)
total = sum( 10, 20 )
print ("函數(shù)外 : ", total)

函數(shù)內(nèi) :  30
函數(shù)外 :  30

強(qiáng)制位置參數(shù)

Python3.8 新增了一個(gè)函數(shù)形參語(yǔ)法 / 用來(lái)指明函數(shù)形參必須使用指定位置參數(shù)，不能使用關(guān)鍵字參數(shù)的形式抹凳。
在以下的例子中遏餐，形參 a 和 b 必須使用指定位置參數(shù)，c 或 d 可以是位置形參或關(guān)鍵字形參赢底，而 e 和 f 要求為關(guān)鍵字形參:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

以下使用方法是正確的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法會(huì)發(fā)生錯(cuò)誤:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用關(guān)鍵字參數(shù)的形式
f(10, 20, 30, 40, 50, f=60)           # e 必須使用關(guān)鍵字參數(shù)的形式

Python3 數(shù)據(jù)結(jié)構(gòu)

列表
Python中列表是可變的失都，這是它區(qū)別于字符串和元組的最重要的特點(diǎn)，一句話概括即：列表可以修改幸冻，而字符串和元組不能粹庞。

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

將列表當(dāng)做堆棧使用

列表方法使得列表可以很方便的作為一個(gè)堆棧來(lái)使用，堆棧作為特定的數(shù)據(jù)結(jié)構(gòu)洽损，最先進(jìn)入的元素最后一個(gè)被釋放（后進(jìn)先出）庞溜。用 append() 方法可以把一個(gè)元素添加到堆棧頂。用不指定索引的 pop() 方法可以把一個(gè)元素從堆棧頂釋放出來(lái)碑定。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

將列表當(dāng)作隊(duì)列使用

也可以把列表當(dāng)做隊(duì)列用强缘，只是在隊(duì)列里第一加入的元素督惰，第一個(gè)取出來(lái)；但是拿列表用作這樣的目的效率不高旅掂。在列表的最后添加或者彈出元素速度快赏胚，然而在列表里插入或者從頭部彈出速度卻不快（因?yàn)樗衅渌脑囟嫉靡粋€(gè)一個(gè)地移動(dòng)）。

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

元組和序列

元組由若干逗號(hào)分隔的值組成商虐，例如：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

集合

集合是一個(gè)無(wú)序不重復(fù)元素的集觉阅。基本功能包括關(guān)系測(cè)試和消除重復(fù)元素秘车。
可以用大括號(hào)({})創(chuàng)建集合典勇。注意：如果要?jiǎng)?chuàng)建一個(gè)空集合，你必須用 set() 而不是 {} 叮趴；后者創(chuàng)建一個(gè)空的字典割笙，下一節(jié)我們會(huì)介紹這個(gè)數(shù)據(jù)結(jié)構(gòu)。
以下是一個(gè)簡(jiǎn)單的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 刪除重復(fù)的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 檢測(cè)成員
True
>>> 'crabgrass' in basket
False

>>> # 以下演示了兩個(gè)集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母眯亦，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母伤溉，但不同時(shí)在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

字典

另一個(gè)非常有用的 Python 內(nèi)建數(shù)據(jù)類型是字典。
序列是以連續(xù)的整數(shù)為索引妻率，與此不同的是乱顾，字典以關(guān)鍵字為索引，關(guān)鍵字可以是任意不可變類型宫静，通常用字符串或數(shù)值走净。
理解字典的最佳方式是把它看做無(wú)序的鍵=>值對(duì)集合。在同一個(gè)字典之內(nèi)孤里，關(guān)鍵字必須是互不相同伏伯。
一對(duì)大括號(hào)創(chuàng)建一個(gè)空的字典：{}。
這是一個(gè)字典運(yùn)用的簡(jiǎn)單例子：

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

構(gòu)造函數(shù) dict() 直接從鍵值對(duì)元組列表中構(gòu)建字典捌袜。如果有固定的模式舵鳞，列表推導(dǎo)式指定特定的鍵值對(duì)：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

遍歷技巧

在字典中遍歷時(shí)，關(guān)鍵字和對(duì)應(yīng)的值可以使用 items() 方法同時(shí)解讀出來(lái)：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中遍歷時(shí)琢蛤，索引位置和對(duì)應(yīng)值可以使用 enumerate() 函數(shù)同時(shí)得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同時(shí)遍歷兩個(gè)或更多的序列，可以使用 zip() 組合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

要反向遍歷一個(gè)序列抛虏，首先指定這個(gè)序列博其，然后調(diào)用 reversed() 函數(shù)：

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

要按順序遍歷一個(gè)序列，使用 sorted() 函數(shù)返回一個(gè)已排序的序列迂猴，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

Python3 模塊

如果你從 Python 解釋器退出再進(jìn)入慕淡，那么你定義的所有的方法和變量就都消失了。
為此 Python 提供了一個(gè)辦法沸毁，把這些定義存放在文件中峰髓，為一些腳本或者交互式的解釋器實(shí)例使用傻寂，這個(gè)文件被稱為模塊。
模塊是一個(gè)包含所有你定義的函數(shù)和變量的文件携兵，其后綴名是.py疾掰。模塊可以被別的程序引入，以使用該模塊中的函數(shù)等功能徐紧。這也是使用 python 標(biāo)準(zhǔn)庫(kù)的方法静檬。
下面是一個(gè)使用 python 標(biāo)準(zhǔn)庫(kù)中模塊的例子。

#!/usr/bin/python3
# 文件名: using_sys.py
 
import sys
 
print('命令行參數(shù)如下:')
for i in sys.argv:
   print(i)
 
print('\n\nPython 路徑為：', sys.path, '\n')

$ python using_sys.py 參數(shù)1 參數(shù)2
命令行參數(shù)如下:
using_sys.py
參數(shù)1
參數(shù)2


Python 路徑為： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] 

1并级、import sys 引入 python 標(biāo)準(zhǔn)庫(kù)中的 sys.py 模塊拂檩；這是引入某一模塊的方法。
2嘲碧、sys.argv 是一個(gè)包含命令行參數(shù)的列表稻励。
3、sys.path 包含了一個(gè) Python 解釋器自動(dòng)查找所需模塊的路徑的列表愈涩。

import 語(yǔ)句

想使用 Python 源文件望抽，只需在另一個(gè)源文件里執(zhí)行 import 語(yǔ)句，語(yǔ)法如下：

import module1[, module2[,... moduleN]

#!/usr/bin/python3
# Filename: support.py
 
def print_func( par ):
    print ("Hello : ", par)
    return

#!/usr/bin/python3
# Filename: test.py
 
# 導(dǎo)入模塊
import support
 
# 現(xiàn)在可以調(diào)用模塊里包含的函數(shù)了
support.print_func("Runoob")

$ python3 test.py 
Hello :  Runoob

一個(gè)模塊只會(huì)被導(dǎo)入一次钠署，不管你執(zhí)行了多少次 import糠聪。這樣可以防止導(dǎo)入模塊被一遍又一遍地執(zhí)行。
當(dāng)我們使用 import 語(yǔ)句的時(shí)候谐鼎，Python 解釋器是怎樣找到對(duì)應(yīng)的文件的呢舰蟆？
這就涉及到 Python 的搜索路徑，搜索路徑是由一系列目錄名組成的狸棍，Python 解釋器就依次從這些目錄中去尋找所引入的模塊身害。
這看起來(lái)很像環(huán)境變量，事實(shí)上草戈，也可以通過(guò)定義環(huán)境變量的方式來(lái)確定搜索路徑塌鸯。
搜索路徑是在 Python 編譯或安裝的時(shí)候確定的，安裝新的庫(kù)應(yīng)該也會(huì)修改唐片。搜索路徑被存儲(chǔ)在 sys 模塊中的 path 變量丙猬，做一個(gè)簡(jiǎn)單的實(shí)驗(yàn)，在交互式解釋器中费韭，輸入以下代碼：

>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
>>> 

from … import 語(yǔ)句

Python 的 from 語(yǔ)句讓你從模塊中導(dǎo)入一個(gè)指定的部分到當(dāng)前命名空間中茧球，語(yǔ)法如下：

from modname import name1[, name2[, ... nameN]]

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

這個(gè)聲明不會(huì)把整個(gè)fibo模塊導(dǎo)入到當(dāng)前的命名空間中，它只會(huì)將fibo里的fib函數(shù)引入進(jìn)來(lái)星持。

from … import * 語(yǔ)句

把一個(gè)模塊的所有內(nèi)容全都導(dǎo)入到當(dāng)前的命名空間也是可行的抢埋，只需使用如下聲明：

from modname import *

這提供了一個(gè)簡(jiǎn)單的方法來(lái)導(dǎo)入一個(gè)模塊中的所有項(xiàng)目。然而這種聲明不該被過(guò)多地使用。

深入模塊

模塊除了方法定義揪垄，還可以包括可執(zhí)行的代碼穷吮。這些代碼一般用來(lái)初始化這個(gè)模塊。這些代碼只有在第一次被導(dǎo)入時(shí)才會(huì)被執(zhí)行饥努。
每個(gè)模塊有各自獨(dú)立的符號(hào)表捡鱼，在模塊內(nèi)部為所有的函數(shù)當(dāng)作全局符號(hào)表來(lái)使用。
所以肪凛，模塊的作者可以放心大膽的在模塊內(nèi)部使用這些全局變量堰汉，而不用擔(dān)心把其他用戶的全局變量搞混。
從另一個(gè)方面伟墙，當(dāng)你確實(shí)知道你在做什么的話翘鸭，你也可以通過(guò) modname.itemname 這樣的表示法來(lái)訪問(wèn)模塊內(nèi)的函數(shù)。
模塊是可以導(dǎo)入其他模塊的戳葵。在一個(gè)模塊（或者腳本就乓，或者其他地方）的最前面使用 import 來(lái)導(dǎo)入一個(gè)模塊，當(dāng)然這只是一個(gè)慣例拱烁，而不是強(qiáng)制的生蚁。被導(dǎo)入的模塊的名稱將被放入當(dāng)前操作的模塊的符號(hào)表中。

還有一種導(dǎo)入的方法戏自，可以使用 import 直接把模塊內(nèi)（函數(shù)邦投，變量的）名稱導(dǎo)入到當(dāng)前操作模塊。比如:

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

這種導(dǎo)入的方法不會(huì)把被導(dǎo)入的模塊的名稱放在當(dāng)前的字符表中（所以在這個(gè)例子里面擅笔，fibo 這個(gè)名稱是沒(méi)有定義的）志衣。
這還有一種方法，可以一次性的把模塊中的所有（函數(shù)猛们，變量）名稱都導(dǎo)入到當(dāng)前模塊的字符表:

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

這將把所有的名字都導(dǎo)入進(jìn)來(lái)念脯，但是那些由單一下劃線（_）開(kāi)頭的名字不在此例。大多數(shù)情況弯淘， Python程序員不使用這種方法绿店，因?yàn)橐氲钠渌鼇?lái)源的命名，很可能覆蓋了已有的定義庐橙。

name屬性

一個(gè)模塊被另一個(gè)程序第一次引入時(shí)假勿，其主程序?qū)⑦\(yùn)行。如果我們想在模塊被引入時(shí)态鳖，模塊中的某一程序塊不執(zhí)行转培，我們可以用name屬性來(lái)使該程序塊僅在該模塊自身運(yùn)行時(shí)執(zhí)行。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在運(yùn)行')
else:
   print('我來(lái)自另一模塊')

$ python using_name.py
程序自身在運(yùn)行

$ python
>>> import using_name
我來(lái)自另一模塊
>>>

說(shuō)明： 每個(gè)模塊都有一個(gè)name屬性郁惜，當(dāng)其值是'main'時(shí)，表明該模塊自身在運(yùn)行，否則是被引入兆蕉。
說(shuō)明：name 與 main 底下是雙下劃線羽戒， _ _ 是這樣去掉中間的那個(gè)空格。

dir() 函數(shù)

內(nèi)置的函數(shù) dir() 可以找到模塊內(nèi)定義的所有名稱虎韵。以一個(gè)字符串列表的形式返回:

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

如果沒(méi)有給定參數(shù)易稠，那么 dir() 函數(shù)會(huì)羅列出當(dāng)前定義的所有名稱:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一個(gè)當(dāng)前模塊中定義的屬性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一個(gè)新的變量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 刪除變量名a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>

標(biāo)準(zhǔn)模塊

Python 本身帶著一些標(biāo)準(zhǔn)的模塊庫(kù)，在 Python 庫(kù)參考文檔中將會(huì)介紹到（就是后面的"庫(kù)參考文檔"）包蓝。
有些模塊直接被構(gòu)建在解析器里驶社，這些雖然不是一些語(yǔ)言內(nèi)置的功能，但是他卻能很高效的使用测萎，甚至是系統(tǒng)級(jí)調(diào)用也沒(méi)問(wèn)題亡电。
這些組件會(huì)根據(jù)不同的操作系統(tǒng)進(jìn)行不同形式的配置，比如 winreg 這個(gè)模塊就只會(huì)提供給 Windows 系統(tǒng)硅瞧。
應(yīng)該注意到這有一個(gè)特別的模塊 sys 份乒，它內(nèi)置在每一個(gè) Python 解析器中。變量 sys.ps1 和 sys.ps2 定義了主提示符和副提示符所對(duì)應(yīng)的字符串:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Runoob!')
Runoob!
C> 

包

包是一種管理 Python 模塊命名空間的形式腕唧，采用"點(diǎn)模塊名稱"或辖。
比如一個(gè)模塊的名稱是 A.B， 那么他表示一個(gè)包 A中的子模塊 B 枣接。
就好像使用模塊的時(shí)候颂暇，你不用擔(dān)心不同模塊之間的全局變量相互影響一樣，采用點(diǎn)模塊名稱這種形式也不用擔(dān)心不同庫(kù)之間的模塊重名的情況但惶。
這樣不同的作者都可以提供 NumPy 模塊耳鸯，或者是 Python 圖形庫(kù)。
不妨假設(shè)你想設(shè)計(jì)一套統(tǒng)一處理聲音文件和數(shù)據(jù)的模塊（或者稱之為一個(gè)"包"）榆骚。
現(xiàn)存很多種不同的音頻文件格式（基本上都是通過(guò)后綴名區(qū)分的片拍，例如： .wav，:file:.aiff妓肢，:file:.au捌省，），所以你需要有一組不斷增加的模塊碉钠，用來(lái)在不同的格式之間轉(zhuǎn)換纲缓。
并且針對(duì)這些音頻數(shù)據(jù)，還有很多不同的操作（比如混音喊废，添加回聲祝高，增加均衡器功能，創(chuàng)建人造立體聲效果）污筷，所以你還需要一組怎么也寫(xiě)不完的模塊來(lái)處理這些操作工闺。
這里給出了一種可能的包結(jié)構(gòu)（在分層的文件系統(tǒng)中）:

sound/                          頂層包
      __init__.py               初始化 sound 包
      formats/                  文件格式轉(zhuǎn)換子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  聲音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

在導(dǎo)入一個(gè)包的時(shí)候，Python 會(huì)根據(jù) sys.path 中的目錄來(lái)尋找這個(gè)包中包含的子目錄。
目錄只有包含一個(gè)叫做 init.py 的文件才會(huì)被認(rèn)作是一個(gè)包陆蟆，主要是為了避免一些濫俗的名字（比如叫做 string）不小心的影響搜索路徑中的有效模塊雷厂。
最簡(jiǎn)單的情況，放一個(gè)空的 :file:init.py就可以了叠殷。當(dāng)然這個(gè)文件中也可以包含一些初始化代碼或者為（將在后面介紹的） all變量賦值改鲫。
用戶可以每次只導(dǎo)入一個(gè)包里面的特定模塊，比如:

import sound.effects.echo

這將會(huì)導(dǎo)入子模塊:sound.effects.echo林束。 他必須使用全名去訪問(wèn):

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

還有一種導(dǎo)入子模塊的方法是:

from sound.effects import echo

這同樣會(huì)導(dǎo)入子模塊: echo像棘，并且他不需要那些冗長(zhǎng)的前綴，所以他可以這樣使用:

echo.echofilter(input, output, delay=0.7, atten=4)

還有一種變化就是直接導(dǎo)入一個(gè)函數(shù)或者變量:

from sound.effects.echo import echofilter

同樣的壶冒，這種方法會(huì)導(dǎo)入子模塊: echo缕题，并且可以直接使用他的 echofilter() 函數(shù):

echofilter(input, output, delay=0.7, atten=4)

注意當(dāng)使用 from package import item 這種形式的時(shí)候，對(duì)應(yīng)的 item 既可以是包里面的子模塊（子包）依痊，或者包里面定義的其他名稱避除，比如函數(shù)，類或者變量胸嘁。
import 語(yǔ)法會(huì)首先把 item 當(dāng)作一個(gè)包定義的名稱瓶摆，如果沒(méi)找到，再試圖按照一個(gè)模塊去導(dǎo)入性宏。如果還沒(méi)找到群井，拋出一個(gè) :exc:ImportError 異常。
反之毫胜，如果使用形如 import item.subitem.subsubitem 這種導(dǎo)入形式书斜，除了最后一項(xiàng)，都必須是包酵使，而最后一項(xiàng)則可以是模塊或者是包荐吉，但是不可以是類，函數(shù)或者變量的名字口渔。

從一個(gè)包中導(dǎo)入*

如果我們使用 from sound.effects import * 會(huì)發(fā)生什么呢样屠？
Python 會(huì)進(jìn)入文件系統(tǒng)，找到這個(gè)包里面所有的子模塊缺脉，然后一個(gè)一個(gè)的把它們都導(dǎo)入進(jìn)來(lái)痪欲。
但這個(gè)方法在 Windows 平臺(tái)上工作的就不是非常好，因?yàn)?Windows 是一個(gè)不區(qū)分大小寫(xiě)的系統(tǒng)攻礼。
在 Windows 平臺(tái)上业踢，我們無(wú)法確定一個(gè)叫做 ECHO.py 的文件導(dǎo)入為模塊是 echo 還是 Echo，或者是 ECHO礁扮。
為了解決這個(gè)問(wèn)題知举，我們只需要提供一個(gè)精確包的索引瞬沦。
導(dǎo)入語(yǔ)句遵循如下規(guī)則：如果包定義文件 init.py 存在一個(gè)叫做 all 的列表變量，那么在使用 from package import * 的時(shí)候就把這個(gè)列表中的所有名字作為包內(nèi)容導(dǎo)入雇锡。
作為包的作者蛙埂，可別忘了在更新包之后保證 all 也更新了啊。
以下實(shí)例在 file:sounds/effects/init.py 中包含如下代碼:

__all__ = ["echo", "surround", "reverse"]

這表示當(dāng)你使用from sound.effects import *這種用法時(shí)遮糖，你只會(huì)導(dǎo)入包里面這三個(gè)子模塊。

如果 all 真的沒(méi)有定義叠赐，那么使用from sound.effects import *這種語(yǔ)法的時(shí)候欲账，就不會(huì)導(dǎo)入包 sound.effects 里的任何子模塊。他只是把包sound.effects和它里面定義的所有內(nèi)容導(dǎo)入進(jìn)來(lái)（可能運(yùn)行init.py里定義的初始化代碼）芭概。

這會(huì)把 init.py 里面定義的所有名字導(dǎo)入進(jìn)來(lái)赛不。并且他不會(huì)破壞掉我們?cè)谶@句話之前導(dǎo)入的所有明確指定的模塊“罩蓿看下這部分代碼:

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

這個(gè)例子中踢故，在執(zhí)行 from...import 前，包 sound.effects 中的 echo 和 surround 模塊都被導(dǎo)入到當(dāng)前的命名空間中了惹苗。（當(dāng)然如果定義了 all 就更沒(méi)問(wèn)題了）
通常我們并不主張使用 * 這種方法來(lái)導(dǎo)入模塊殿较，因?yàn)檫@種方法經(jīng)常會(huì)導(dǎo)致代碼的可讀性降低。不過(guò)這樣倒的確是可以省去不少敲鍵的功夫桩蓉，而且一些模塊都設(shè)計(jì)成了只能通過(guò)特定的方法導(dǎo)入淋纲。
記住，使用 from Package import specific_submodule 這種方法永遠(yuǎn)不會(huì)有錯(cuò)院究。事實(shí)上洽瞬，這也是推薦的方法。除非是你要導(dǎo)入的子模塊有可能和其他包的子模塊重名业汰。
如果在結(jié)構(gòu)中包是一個(gè)子包（比如這個(gè)例子中對(duì)于包sound來(lái)說(shuō)）伙窃，而你又想導(dǎo)入兄弟包（同級(jí)別的包）你就得使用導(dǎo)入絕對(duì)的路徑來(lái)導(dǎo)入。比如样漆，如果模塊sound.filters.vocoder 要使用包 sound.effects 中的模塊 echo为障，你就要寫(xiě)成 from sound.effects import echo。

from . import echo
from .. import formats
from ..filters import equalizer

無(wú)論是隱式的還是顯式的相對(duì)導(dǎo)入都是從當(dāng)前模塊開(kāi)始的氛濒。主模塊的名字永遠(yuǎn)是"main"产场，一個(gè)Python應(yīng)用程序的主模塊，應(yīng)當(dāng)總是使用絕對(duì)路徑引用舞竿。
包還提供一個(gè)額外的屬性path京景。這是一個(gè)目錄列表，里面每一個(gè)包含的目錄都有為這個(gè)包服務(wù)的init.py骗奖，你得在其他init.py被執(zhí)行前定義哦确徙⌒汛可以修改這個(gè)變量，用來(lái)影響包含在包里面的模塊和子包鄙皇。
這個(gè)功能并不常用芜赌，一般用來(lái)擴(kuò)展包里面的模塊。

個(gè)人理解就是相當(dāng)于java中的導(dǎo)包伴逸，如果你需要其他類的方法就需要導(dǎo)入類去調(diào)用相應(yīng)的方法缠沈。比如：工具類中的一些方法。