国产精品成人网站,亚洲欧美精品在线,色一情一乱一伦,又大又紧又粉嫩18P少妇

摘要：局部變量只能在其被聲明的函數(shù)內(nèi)部訪問，而全局變量可以在整個(gè)程序范圍內(nèi)訪問。調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱都將被加入到作用域中。

函數(shù)

（一）定義函數(shù)

你可以定義一個(gè)由自己想要功能的函數(shù)，以下是簡單的規(guī)則：

（1）函數(shù)代碼塊以def關(guān)鍵詞開頭，后接函數(shù)標(biāo)識(shí)符名稱和圓括號(hào)()。

（2）任何傳入?yún)?shù)和自變量必須放在圓括號(hào)中間。圓括號(hào)之間可以用于定義參數(shù)。

（3）函數(shù)的行語句可以選擇性地使用文檔字符串—用于存放函數(shù)說明。

（4）函數(shù)內(nèi)容以冒號(hào)起始，并且縮進(jìn)。

（5）return結(jié)束函數(shù)，選擇性地返回一個(gè)值給調(diào)用方。不帶表達(dá)式的return相當(dāng)于返回 None。

 語法：   def functionname( parameters ):       "函數(shù)_文檔字符串"       function_suite       return [expression]

默認(rèn)情況下，參數(shù)值和參數(shù)名稱是按函數(shù)聲明中定義的的順序匹配起來的。

練習(xí)1：沒有返回return的函數(shù)，返回none

      >>> def sum(a,b):      ...     print a+b      >>> print sum(5,4)      

練習(xí)2：返回列表及元組

 >>> def bar():  ...     return "abc",[42,"python"],"guido" >>> def foo():  ...     return ["hello",1000,-98.6]

注：bar()函數(shù)返回一個(gè)元組,foo()函數(shù)返回一個(gè)列表python defaultdict函數(shù)，由于元組語法上不一定帶上圓括號(hào)，所以讓人覺得返回了多個(gè)值。所以可以適當(dāng)加上括號(hào)。

從返回值的角度看可以通過以下三種方式進(jìn)行數(shù)據(jù)的存儲(chǔ)：

（在對(duì)x,y,z 和a,b,c的賦值中每個(gè)變量會(huì)接收對(duì)應(yīng)的返回值，而tuple1會(huì)隱式地返回整個(gè)元組）

 >>>tuple1=bar() >>> x,y,z=bar() >>> (a,b,c)=bar()

（二）調(diào)用函數(shù)

定義一個(gè)函數(shù)只給了函數(shù)一個(gè)名稱，了函數(shù)里包含的參數(shù)python defaultdict函數(shù)，和代碼塊結(jié)構(gòu)。這個(gè)函數(shù)的基本結(jié)構(gòu)完成以后，你可以通過另一個(gè)函數(shù)調(diào)用執(zhí)行，也可以直接從Python提示符執(zhí)行。

>>> def printme(str):...     print str;...     Return>>> printme("調(diào)用自定義的函數(shù)")   

練習(xí)3：求列表中第二大的數(shù)

方法一：

>>> a=[10,50,-1,3,2,10]>>> def secNum(lista):...     lista.sort()...     return lista[-2]...>>> print secNum(a)
10

方法二：

>>> def secNum(lista):...     max_number=max(lista)...     lista.remove(max_number)...     return max(lista)

方法三：

算法：

1 比較列表中前2個(gè)數(shù)，大的作為為列表中暫時(shí)的數(shù)，小的

作為次大數(shù)，分別存在2個(gè)變量里

2 遍歷列表從第三個(gè)數(shù)開始以后后的值，去和值去比較，存在2種可能

3 如果大于，當(dāng)前值作為列表中暫時(shí)的數(shù)，以前的變?yōu)?/p>

次大的。

4 如果小于，和次大的比較，大于它就是次大值，小于繼續(xù)遍歷

后續(xù)值。

#coding=utf-8a=[10,10,10,0,10,10,0]def secondBiggestNumber(lista):

#判斷是否是列表或元組

ifnotisinstance(lista,(list,tuple)):

returnNone

#判斷是否有2個(gè)以上元素

iflen(lista)lista[1]:

biggest_number=lista[0]

second_biggest_number=lista[1]

else:

biggest_number=lista[1]

second_biggest_number=lista[0]

#遍歷列表從第三個(gè)數(shù)開始以后后的值，去和值去比較

foriinlista[2:]:

#如果大于，當(dāng)前值作為列表中暫時(shí)的數(shù)，以前的變?yōu)?/p>

#次大的。

ifi>biggest_number:

second_biggest_number=biggest_number

biggest_number=i

#如果小于，和次大的比較，大于它就是次大值，小于繼續(xù)遍歷

#后續(xù)值。

elifi==biggest_number:

continue

else:

ifbiggest_number==second_biggest_number:

second_biggest_number=i

ifi>second_biggest_number:

second_biggest_number=i

returnsecond_biggest_number

    print secondBiggestNumber(a)

練習(xí)4：計(jì)算10000次浮點(diǎn)數(shù)運(yùn)算的耗時(shí)

import timeimport random>>> def compute_float_time_consume():...     start_time=time.time()...     for i in range(10000):...         random.random()**2...     end_time=time.time()...     return end_time-start_time

(三）參數(shù)傳遞

在Python中，類型屬于對(duì)象，變量是沒有類型的：

  a=[1,2,3]  a="Runoob"

以上代碼中，[1,2,3]是 List 類型，"Runoob"是 String 類型，而變量 a 是沒有類型，她僅僅是一個(gè)對(duì)象的引用（一個(gè)指針），可以是 List 類型對(duì)象，也可以指向 String 類型對(duì)象。

(1)可更改(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沒有動(dòng)，只是其內(nèi)部的一部分值被修改了。

(2)python 函數(shù)的參數(shù)傳遞：

不可變類型：類似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對(duì)象本身。比如在 fun（a）內(nèi)部修改 a 的值，只是修改另一個(gè)復(fù)制的對(duì)象，不會(huì)影響a本身。

可變類型：類似 c++ 的引用傳遞，如列表，字典。如 fun（a），則是將 a 真正的傳過去，修改后fun外部的a也會(huì)受影響

python 中一切都是對(duì)象，嚴(yán)格意義我們不能說值傳遞還是引用傳遞，我們應(yīng)該說傳不可變對(duì)象和傳可變對(duì)象。

練習(xí)3：傳不可變對(duì)象

>>> def ChangeInt(a):...     a=10>>> b=2>>> ChangeInt(b)>>> print b    #結(jié)果是2

練習(xí)4：傳可變對(duì)象

>>> def changeme(mylist):...     mylist.append([1,2,3,4])...     print mylist...     return>>> mylist=[10,20,30]>>> changeme(mylist)      #[10, 20, 30, [1, 2, 3, 4]]>>> print mylist           #[10, 20, 30, [1, 2, 3, 4]]

注：實(shí)例中傳入函數(shù)的和在末尾添加新內(nèi)容的對(duì)象用的是同一個(gè)引用

（2）參數(shù)類型

python中函數(shù)傳遞參數(shù)有四種形式：

fun1(a,b,c)

fun1(a,b,c)是直接將實(shí)參賦予行參，根據(jù)位置做匹配，即嚴(yán)格要求實(shí)參的數(shù)量與行參的數(shù)量位置相等，比較一般，大多數(shù)語言常用這種方式。

>>> def a(x,y):print x,y>>> a(4,5)      #4 5

fun2(a=1,b=2,c=3)

fun2(a=1,b=2,c=3)根據(jù)鍵值對(duì)的形式做實(shí)參與行參的匹配，通過這種式就可以忽略了參數(shù)的位置關(guān)系，直接根據(jù)關(guān)鍵字來進(jìn)行賦值，同時(shí)該種傳參方式還有個(gè)好處就是可以在調(diào)用函數(shù)的時(shí)候作為個(gè)別選填項(xiàng)，不要求數(shù)量上的相等，即可以fun5(3,4)來調(diào)用fun2函數(shù)，這里關(guān)鍵就是前面的3,4覆蓋了原來a、b兩個(gè)行參的值，但c還是不變采用原來的默認(rèn)值3，這種模式相較種更加靈活，不僅可以通過fun6(c=5,a=2,b=7)來打亂行參的位置，而且可以在但沒有對(duì)應(yīng)行參傳遞的時(shí)候常用定義函數(shù)時(shí)的默認(rèn)值。

>>> def a(x,y=3):print x,y>>> a(4)           #4 3

注：Python傳可變對(duì)象-傳默認(rèn)參數(shù)會(huì)記住值-這是坑須知道

#coding=utf-8def add_end(L=[]):                     #或者Ｌ＝[1, 2, 3]    L.append("END")    return Lprint add_end([1, 2, 3])print add_end(["x", "y", "z"])print add_end()print add_end()print add_end()

只有在默認(rèn)參數(shù)時(shí)候，L才會(huì)記住每次append的值

如果你每次都傳入值，L就會(huì)每次顯示你傳入的數(shù)據(jù)而不會(huì)記住你上一次傳入的值

改成如下：

def add_end(L=None):    if L is None:        L=[]        L.append("END")    return L

解析：

Python傳默認(rèn)參數(shù)需注意：

默認(rèn)參數(shù)是[]，但是函數(shù)似乎每次都"記住了"上次添加了’END’后的list；

Python函數(shù)在定義的時(shí)候，默認(rèn)參數(shù)的值就被計(jì)算出來了即[]；

因?yàn)槟J(rèn)參數(shù)L也是一個(gè)變量，它指向?qū)ο骩]，每次調(diào)用該函數(shù)，如果改變了L的內(nèi)容，則下次調(diào)用時(shí)，默認(rèn)參數(shù)的內(nèi)容就變了，不在是函數(shù)定義時(shí)的[]了；

定義默認(rèn)參數(shù)必須牢記一點(diǎn)：默認(rèn)參數(shù)必須指向不變對(duì)象！

所以：函數(shù)的默認(rèn)參數(shù)別用可變對(duì)象，否則存在累加操作結(jié)果

的情況

fun3(*args)--元組參數(shù)

fun3(*args)，這傳參方式是可以傳入任意個(gè)參數(shù)，這些若干參數(shù)都被放到了tuple元組中賦值給行參args，之后要在函數(shù)中使用這些行參，直接操作args這個(gè)tuple元組就可以了，這樣的好處是在參數(shù)的數(shù)量上沒有了限制，但是因?yàn)槭莟uple，其本身還是有次序的，這就仍然存在一定的束縛，在對(duì)參數(shù)操作上也會(huì)有一些不便。

>>> def a(*x):print x>>> a(1,2,3)(1, 2, 3)>>> a(x=1,y=2,z=3)Traceback (most recent call last):File "", line 1, in TypeError: a() got an unexpected keyword argument "x"

注：不管有多少個(gè)，在函數(shù)內(nèi)部都被存放在以形參名為標(biāo)識(shí)符的元組中。

練習(xí)5：累計(jì)乘法

>>> def mul(*arg):...     result=1...     for i in arg:...         if not isinstance(i,(int,float,long)):...             return None
...         else:...             result*=i...     return result...>>> mul(1,2,3,4)24 

fun4(**kargs)--參數(shù)是字典

fun4(*kargs)靈活，形參名前加兩個(gè)表示，參數(shù)在函數(shù)內(nèi)部將被存放在以形式名為標(biāo)識(shí)符的dictionary中，這時(shí)調(diào)用函數(shù)的方法則需要采用arg1=value1,arg2=value2這樣的形式。

>>> def a(**x):print x>>> a(x=1,y=2,z=3){"y": 2, "x": 1, "z": 3}>>> a(1,2,3)Traceback (most recent call last):  File "", line 1, in TypeError: a() takes exactly 0 arguments (3 given)

綜合練習(xí)3：mul(1,2,3,4,5,a=6,b=7)實(shí)現(xiàn)連乘函數(shù)，需要用到arg，*kw,且函數(shù)有固定2個(gè)參數(shù)：a,b

def mul(a, b, *arg, **kw):    result=1    if not isinstance(a, (int, float, long)) and not isinstance(b, (int,             float, long)):        return None    else:        result=a*b    for i in arg:        if not isinstance(i, (int, float, long)):            return None        else:            result *= i    for j in kw.values():        if  not isinstance(j, (int, float, long)):            return None        else:            result *= j    return result

調(diào)用函數(shù)的方式：

（1）mul(10,20,20,34,c=40,d=50)

（2）mul(10,20,(20,34),*{"c":40,"d":50})

（3）mul(10,20,30,40,f=20,(20,34),*{"c":40,"d":50})

等價(jià)于 tup=(20,34) dic={"c":40,"d":50}

mul(10,20,30,40,f=40,tup,*dic)

注意我們的元組和字典參數(shù)僅僅是被調(diào)函數(shù)中最終接收的元組和字典的子集

（四）匿名函數(shù)

python使用lambda來創(chuàng)建匿名函數(shù)。

（1）lambda只是一個(gè)表達(dá)式，函數(shù)體比def簡單很多。

（2）lambda的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊。僅僅能在lambda表達(dá)式中封裝有限的邏輯進(jìn)去。

（3）lambda函數(shù)擁有自己的命名空間，且不能訪問自有參數(shù)列表之外或全局命名空間里的參數(shù)。

（4）雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用函數(shù)時(shí)不占用棧內(nèi)存從而增加運(yùn)行效率。

（5）lambda函數(shù)返回一個(gè)函數(shù)對(duì)象，如果沒有變量接受這個(gè)返回值，它很快就被丟棄，也正是由于lambda是一個(gè)表達(dá)式，所以它可以直接作為List,dict的成員

def與lambda區(qū)別：

注：在def中，用return可以返回的可以放在lambda后面，不能用return返回的不能定義在lambda后.因此,像if或for或print這種語句就不能用于lambda中，lambda一般只用來定義簡單的函數(shù)。

語法：

lambda函數(shù)的語法只包含一個(gè)語句：

lambda[arga,arg2……]:expression

幾個(gè)規(guī)則：

1.一般也就一行表達(dá)式，必須有返回值

不能有return

可以沒有參數(shù)，可以有一個(gè)或多個(gè)參數(shù)

練習(xí)6：x的y次方

 >>> sum=lambda x,y:x**y >>> print sum(10,20)

練習(xí)7：

def make_repeater(n):    return lambda s: s*ntwice = make_repeater(2)     #等價(jià)lambda s: s*2print twice("word")          ##等價(jià)lambda s: "word"*2print twice(5)              ###等價(jià)lambda s: 5*2

（五）全局變量和局部變量

定義在函數(shù)內(nèi)部的變量擁有一個(gè)局部作用域，定義在函數(shù)外的擁有全局作用域。

局部變量只能在其被聲明的函數(shù)內(nèi)部訪問，而全局變量可以在整個(gè)程序范圍內(nèi)訪問。調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱都將被加入到作用域中。

>>> total=0>>> def sum(a,b):...     total=a+b...     print total...     return total>>> sum(10,20)            #結(jié)果 30 30>>> print total             #結(jié)果 0>>> total=0>>> def sum(a,b):...     global total...     total=a+b...     print total...     return total>>> sum(10,20)        #結(jié)果 30 30>>> print total       #結(jié)果 30

總結(jié)：

1 函數(shù)中使用全局變量，聲明為global

2 否則當(dāng)局部變量使用，且局部變量都要在函數(shù)開始的地方做賦值

3 如果函數(shù)中的變量沒有聲明為global，且在外部有同名的變量

則可以直接使用，如果進(jìn)行了賦值操作，則此變量變?yōu)榫植孔兞?/p>

且在使用前必須初始化賦值。