python编程设计大学ppt_Python程序设计-清华大学出版社-董付国第5章-函数的设计和使用PPT...
PPT內容
這是Python程序設計-清華大學出版社-董付國第5章-函數的設計和使用PPT下載，主要介紹了函數定義；斐波那契數列；形參與實參；參數類型；默認值參數；關鍵參數；可變長度參數；參數傳遞的序列解包；return語句；變量作用域；局部變量；全局變量；案例；lambda表達式；案例精選；高級話題，歡迎點擊下載哦。
第5章 函數的設計和使用
將可能需要反復執行的代碼封裝為函數，并在需要該段代碼功能的地方調用，不僅可以實現代碼的復用，更重要的是可以保證代碼的一致性，只需要修改該函數代碼則所有調用均受到影響。
5.1 函數定義
def 函數名([參數列表]):
'''注釋'''
函數體
5.1 函數定義
；
def fib(n):
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
fib(1000)
5.1 函數定義
在定義函數時，開頭部分的注釋并不是必需的，但是如果為函數的定義加上這段注釋的話，可以為用戶提供友好的提示和使用幫助。例如，把上面生成斐波那契數列的函數定義修改為下面的形式，加上一段注釋。
>>> def fib(n):
'''accept an integer n.
return the numbers less than n in Fibonacci sequence.'''
a, b = 1, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
5.1 函數定義
5.2 形參與實參
函數定義時括弧內為形參，一個函數可以沒有形參，但是括弧必須要有，表示該函數不接受參數。
函數調用時向其傳遞實參，將實參的值或引用傳遞給形參。
在函數內直接修改形參的值不影響實參。
5.2 形參與實參
例1：編寫函數，接受兩個整數，并輸出其中最大數。
def printMax(a, b):
if a>b:
pirnt(a, 'is the max')
else:
print(b, 'is the max')
這個程序并不是很好，如果輸入的參數不支持比較運算，會出錯。
5.2 形參與實參
對于絕大多數情況下，在函數內部直接修改形參的值不會影響實參。例如下面的示例：
>>> def addOne(a):
print(a)
a += 1
print(a)
>>> a = 3
>>> addOne(a)
3
4
>>> a
3
5.2 形參與實參
在有些情況下，可以通過特殊的方式在函數內部修改實參的值，例如下面的代碼。
>>> def modify(v): #修改列表元素值
v[0] = v[0]+1
>>> a = [2]
>>> modify(a)
>>> a
[3]
>>> def modify(v, item): #為列表增加元素
v.append(item)
>>> a = [2]
>>> modify(a,3)
>>> a
[2, 3]
>>> def modify(d): #修改字典元素值或為字典增加元素
d['age'] = 38
>>> a = {'name':'Dong', 'age':37, 'sex':'Male'}
>>> a
{'age': 37, 'name': 'Dong', 'sex': 'Male'}
>>> modify(a)
>>> a
{'age': 38, 'name': 'Dong', 'sex': 'Male'}
5.3 參數類型
在Python中，函數參數有很多種：可以為普通參數、默認值參數、關鍵參數、可變長度參數等等。
Python函數的定義非常靈活，在定義函數時不需要指定參數的類型，也不需要指定函數的類型，完全由調用者決定，類似于重載和泛型；
函數編寫如果有問題，只有在調用時才能被發現，傳遞某些參數時執行正確，而傳遞另一些類型的參數時則出現錯誤。
5.3.1 默認值參數
def 函數名(形參名=默認值，……)
函數體
默認值參數必須出現在函數參數列表的最右端，且任何一個默認值參數右邊不能有非默認值參數。
5.3.1 默認值參數
調用帶有默認值參數的函數時，可以不對默認值參數進行賦值，也可以賦值，具有較大的靈活性。
>>> def say( message, times =1 ):
print message * times
>>> say('hello')
hello
>>> say('hello',3)
hello hello hello
>>> say('hi',7)
hi hi hi hi hi hi hi
5.3.1 默認值參數
再例如，下面的函數使用指定分隔符將列表中所有字符串元素連接成一個字符串。
>>> def Join(List,sep=None):
return (sep or ' ').join(List)
>>> aList = ['a', 'b', 'c']
>>> Join(aList)
'a b c'
>>> Join(aList, ',')
'a,b,c'
5.3.1 默認值參數
默認值參數如果使用不當，會導致很難發現的邏輯錯誤，例如：
def demo(newitem,old_list=[]):
old_list.append(newitem)
return old_list
print demo('5',[1,2,3,4])? #right
print demo('aaa',['a','b'])? #right
print demo('a')?? #right
#print demo.func_defaults
print demo('b')
5.3.1 默認值參數
改成下面的樣子就不會有問題了：
def demo(newitem,old_list=None):
if old_list is None:
old_list=[]
old_list.append(newitem)
return old_list
print demo('5',[1,2,3,4])? #right
print demo('aaa',['a','b'])? #right
print demo('a')?? #right
#print demo.func_defaults
print demo('b')
5.3.1 默認值參數
默認參數只被解釋一次
可以使用函數名.func_defaults查看默認參數的當前值
5.3.2 關鍵參數
關鍵參數主要指實參，即調用函數時的參數傳遞方式。
通過關鍵參數傳遞，實參順序可以和形參順序不一致，但不影響傳遞結果，避免了用戶需要牢記位置參數順序的麻煩。
>>> def demo(a,b,c=5):
print a,b,c
>>> demo(3,7)
3 7 5
>>> demo(a=7,b=3,c=6)
7 3 6
>>> demo(c=8,a=9,b=0)
9 0 8
5.3.3 可變長度參數
可變長度參數主要有兩種形式：*parameter和**parameter，前者用來接受多個實參并將其放在一個元組中，后者接受字典形式的實參。
5.3.3 可變長度參數
>>> def demo(*p):
print p
>>> demo(1,2,3)
(1, 2, 3)
>>> demo(1,2)
(1, 2)
>>> demo(1,2,3,4,5,6,7)
(1, 2, 3, 4, 5, 6, 7)
5.3.3 可變長度參數
>>> def demo(**p):
for item in p.items():
print item
>>> demo(x=1,y=2,z=3)
('y', 2)
('x', 1)
('z', 3)
5.3.3 可變長度參數
幾種不同類型的參數可以混合使用，但是不建議這樣做
>>> def func_4(a,b,c=4,*aa,**bb):
print (a,b,c)
print aa
print bb
>>> func_4(1,2,3,4,5,6,7,8,9,xx='1',yy='2',zz=3)
(1, 2, 3)
(4, 5, 6, 7, 8, 9)
{'yy': '2', 'xx': '1', 'zz': 3}
>>> func_4(1,2,3,4,5,6,7,xx='1',yy='2',zz=3)
(1, 2, 3)
(4, 5, 6, 7)
{'yy': '2', 'xx': '1', 'zz': 3}
5.3.4 參數傳遞的序列解包
傳遞參數時，可以通過在實參序列前加星號將其解包，然后傳遞給多個單變量形參。
>>> def demo(a,b,c):
print a+b+c
>>> seq=[1,2,3]
>>> demo(*seq)
6
5.4 return語句
return語句用來從一個函數中返回，即跳出函數，也可用return語句從函數中返回一個值。
如果函數沒有return語句，Python將認為該函數以return None結束。
def maximum( x, y ):
if x>y:
return x
else:
return y
在調用內置數據類型的方法時，一定要注意該方法有沒有返回值。
5.5 變量作用域
變量起作用的范圍稱為變量的作用域。
一個變量在函數外部定義和在函數內部定義，其作用域是不同的。
局部變量的引用比全局變量速度快。
5.5.1 局部變量
在函數內定義的變量只在該函數內起作用，稱為局部變量。
函數結束時，其局部變量被自動刪除。
5.5.2 全局變量
如果想要在函數內部給一個定義在函數外的變量賦值，那么這個變量就不能是局部的，其作用域必須為全局的，能夠同時作用于函數內外，稱為全局變量，可以通過global來定義。
(1)一個變量已在函數外定義，如果在函數內需要為這個變量賦值，并要將這個賦值結果反映到函數外，可以在函數內用global聲明這個變量，將其定義為全局變量。
(2)在函數內部直接將一個變量聲明為全局變量，在函數外沒有聲明，在調用這個函數之后，將增加為新的全局變量。
5.5.3 案例
>>> def demo():
global x
x = 3
y =4
print x,y
>>> x = 5
>>> demo()
3? 4
>>> x
3
>>> y
出錯
NameError: name 'y' is not defined
>>> del x
>>> x
出錯
NameError: name 'x' is not defined
>>> demo()
3? 4
>>> x
3
>>> y
出錯
NameError: name 'y' is not defined
5.6 lambda表達式
lambda表達式可以用來聲明匿名函數，即沒有函數名字的臨時使用的小函數，只可以包含一個表達式，且該表達式的計算結果為函數的返回值，不允許包含其他復雜的語句，但在表達式中可以調用其他函數。
5.6 lambda表達式
>>> f=lambda x,y,z:x+y+z
>>> print f(1,2,3)
6
>>> g=lambda x,y=2,z=3:x+y+z
>>> print g(1)
6
>>> print g(2,z=4,y=5)
11
>>> L=[(lambda x:x**2),(lambda x:x**3),(lambda x:x**4)]
>>> print L[0](2),L[1](2),L[2](2)
4 8 16
>>> D={'f1':(lambda:2+3),'f2':(lambda:2*3),'f3':(lambda:2**3)}
>>> print D['f1'](),D['f2'](),D['f3']()
5 6 8
>>> L=[1,2,3,4,5]
>>> print map((lambda x:x+10),L)
[11, 12, 13, 14, 15]
>>> L
[1, 2, 3, 4, 5]
5.6 lambda表達式
>>> def demo(n):
return n*n
>>> demo(5)
25
>>> a_list=[1,2,3,4,5]
>>> map(lambda x:demo(x),a_list)
[1, 4, 9, 16, 25]
5.6 lambda表達式
>>> data=range(20)
>>> print data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> import random
>>> random.shuffle(data)
>>> data
[4, 3, 11, 13, 12, 15, 9, 2, 10, 6, 19, 18, 14, 8, 0, 7, 5, 17, 1, 16]
>>> data.sort(key=lambda x:x)
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> data.sort(key=lambda x:len(str(x)))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> data.sort(key=lambda x:len(str(x)),reverse=True)
>>> data
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5.7 案例精選
例1：編寫函數計算圓的面積。
from math import pi as PI
import types
def CircleArea(r):
if isinstance(r,int) or isinstance(r,float): #確保接收的參數為數值
return PI*r*r
else:
print('You must give me an integer or float as radius.')
print(CircleArea(3))
5.7 案例精選
例2：編寫函數，接收任意多個實數，返回一個元組，其中第一個元素為所有參數的平均值，其他元素為所有參數中大于平均值的實數。
def demo(*para):
avg = sum(para)/len(para) #注意Python 2.x與Python 3.x對除法運算符“/”的解釋不同
g = [i for i in para if i>avg]
return (avg,)+tuple(g)
print(demo(1,2,3,4))
5.7 案例精選
例3：編寫函數，接收字符串參數，返回一個元組，其中第一個元素為大寫字母個數，第二個元素為小寫字母個數。
def demo(s):
result = [0,0]
for ch in s:
if 'a'<=ch<='z':
result[1] += 1
elif 'A'<=ch<='Z':
result[0] += 1
return result
print(demo('aaaabbbbC'))
5.7 案例精選
例4：編寫函數，接收包含20個整數的列表lst和一個整數k作為參數，返回新列表。處理規則為：將列表lst中下標k之前的元素逆序，下標k之后的元素依序，然后將整個列表lst中的所有元素逆序。
def demo(lst,k):
x = lst[:k]
x.reverse()
y = lst[k:]
y.reverse()
r = x+y
r.reverse()
return r
lst = list(range(1,21))
print(lst)
print(demo(lst,5))
5.7 案例精選
例5：編寫函數，接收整數參數t，返回斐波那契數列中大于t的第一個數。
def demo(t):
a, b = 1, 1
while b
a, b = b, a+b
else:
return b
print(demo(50))
5.7 案例精選
例6：編寫函數，接收一個包含若干整數的列表參數lst，返回一個元組，其中第一個元素為列表lst中的最小值，其余元素為最小值在列表lst中的下標。
import random
def demo(lst):
m = min(lst)
result = (m,)
for index, value in enumerate(lst):
if value==m:
result = result+(index,)
return result
x = [random.randint(1,20) for i in range(50)]
print(x)
print(demo(x))
5.7 案例精選
例7：編寫函數，接收一個整數t為參數，打印楊輝三角前t行。
def demo(t):
print([1])
print([1,1])
line = [1,1]
for i in range(2,t):
r = []
for j in range(0,len(line)-1):
r.append(line[j]+line[j+1])
line = [1]+r+[1]
print(line)
demo(10)
5.7 案例精選
例8：編寫函數，接收一個正偶數為參數，輸出兩個素數，并且這兩個素數之和等于原來的正偶數。如果存在多組符合條件的素數，則全部輸出。
import math
def IsPrime(n):
m = int(math.sqrt(n))+1
for i in range(2, m):
if n%i==0:
return False
return True
def demo(n):
if isinstance(n,int) and n>0 and n%2==0:
for i in range(3, int(n/2)+1):
if IsPrime(i) and IsPrime(n-i):
print(i, '+', n-i, '=', n)
demo(60)
5.7 案例精選
例9：編寫函數，接收兩個正整數作為參數，返回一個數組，其中第一個元素為最大公約數，第二個元素為最小公倍數。
def demo(m,n):
if m>n:
m, n = n, m
p = m*n
while m!=0:
r = n%m
n = m
m = r
return (int(p/n),n)
print(demo(20,30))
5.8 高級話題
內置函數map可以將一個函數作用到一個序列或迭代器對象上。
>>> map(str,range(5))
['0', '1', '2', '3', '4']
>>> def add5(v):
return v+5
>>> map(add5,range(10))
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
5.8 高級話題
內置函數reduce可以將一個接受2個參數的函數以累積的方式從左到右依次作用到一個序列或迭代器對象的所有元素上。
>>> seq=[1,2,3,4,5,6,7,8,9]
>>> reduce(lambda x,y:x+y, seq)
45
>>> def add(x, y):
return x + y
>>> reduce(add,range(10))
45
>>> reduce(add,map(str,range(10)))
'0123456789'
在python 3中，使用reduce函數需要
from functools import reduce
5.8 高級話題
5.8 高級話題
內置函數filter將一個函數作用到一個序列上，返回該序列中使得該函數返回值為True的那些元素組成的列表、元組或字符串。
>>> seq=['foo','x41','?!','***']
>>> def func(x):
return x.isalnum()
>>> filter(func,seq)
['foo', 'x41']
>>> seq
['foo', 'x41', '?!', '***']
>>> [x for x in seq if x.isalnum()]
['foo', 'x41']
>>> filter(lambda x:x.isalnum(),seq)
['foo', 'x41']
5.8 高級話題
生成器：惰性求值，可迭代，適用于大數據處理
>>> def f():
a, b = 1, 1
while True:
yield a
a, b = b, a+b
>>> a = f()
>>> a.next()
1
>>> a.next()
1
>>> a.next()
2
>>> a.next()
3
>>> a.next()
5
>>> a.next()
8
>>> a.next()
13
>>> a.next()
21
5.8 高級話題
使用dis模塊可以查看函數的字節碼指令
>>> def add(n):
n+=1
return n
>>> import dis
>>> dis.dis(add)
2?????????? 0 LOAD_FAST??????????????? 0 (n)
3 LOAD_CONST?????????????? 1 (1)
6 INPLACE_ADD
7 STORE_FAST?????????????? 0 (n)
3????????? 10 LOAD_FAST??????????????? 0 (n)
13 RETURN_VALUE
5.8 高級話題
函數嵌套定義與可調用對象
在Python中，函數是可以嵌套定義的。另外，任何包含__call__()方法的類的對象都是可調用的。例如，下面的代碼演示了函數嵌套定義的情況，
def linear(a, b):
def result(x):
return a * x + b
return result
下面的代碼演示了可調用對象類的定義，
class linear:
def __init__(self, a, b):
self.a, self.b = a, b
def __call__(self, x):
return self.a * x + self.b
使用上面的兩種方式中任何一個，都可以通過以下的方式來定義一個可調用對象，
taxes = linear(0.3, 2)
然后通過下面的方式來調用該對象，
taxes(5)
相關PPT
第1部分-專題一-第三講-基本初等函數、函數與方程及函數的應用PPT：這是第1部分-專題一-第三講-基本初等函數、函數與方程及函數的應用PPT下載，主要介紹了考點；考情；真題感悟；要點歸納；指數與對數式的七個運算公式；指數函數與對數函數的圖像和性質；函數的零點與方程根的關系；熱點；規律總結；判斷函數零點個數的方法；模型歸納；變式訓練，歡迎點擊下載哦。
第3講--函數與方程及函數的應用問題PPT：這是第3講--函數與方程及函數的應用問題PPT下載，主要介紹了函數的零點與方程的根；函數的應用；函數零點的判定；函數與方程的綜合應用；函數的實際應用；變式訓練；規律方法總結；函數與方程；應用函數模型解決實際問題的一般程序；練習題，歡迎點擊下載哦。
函數的最值及應用PPT：這是函數的最值及應用PPT下載，主要介紹了極值是局部性的,而最值是全局性的；具體求法；在許多實際問題中，往往用到求函數最值的下述方法；利用最值證明不等式；經濟應用舉例；解答；例題；作業，歡迎點擊下載哦。
《Python程序設計-清華大學出版社-董付國第5章-函數的設計和使用PPT》是由用戶寰鸞于2018-02-07上傳，屬于數學課件PPT。
《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀總結
以上是生活随笔為你收集整理的python编程设计大学ppt_Python程序设计-清华大学出版社-董付国第5章-函数的设计和使用PPT...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python机器学习及实践_Python
- 下一篇： websocket python爬虫_p