请看如下代码:
print (" _ooOoo_ ")
print (" o8888888o ")
print (" 88 . 88 ")
print (" (| -_- |) ")
print (" O\\ = /O ")
print (" ____/`---'\\____ ")
print (" . ' \\| |// `. ")
print (" / \\||| : |||// \\ ")
print (" / _||||| -:- |||||- \\ ")
print (" | | \\\\\\ - /// | | ")
print (" | \\_| ''\\---/'' | | ")
print (" \\ .-\\__ `-` ___/-. / ")
print (" ___`. .' /--.--\\ `. . __ ")
print (" ."" '< `.___\\_<|>_/___.' >'"". ")
print (" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
print (" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
print (" ======`-.____`-.___\\_____/___.-`____.-'====== ")
print (" `=---=' ")
print (" ")
print (" ............................................. ")
print (" 佛祖镇楼 BUG辟易 ")
print (" 佛曰: ")
print (" 写字楼里写字间,写字间里程序员;")
print (" 程序人员写程序,又拿程序换酒钱。")
print (" 酒醒只在网上坐,酒醉还来网下眠;")
print (" 酒醉酒醒日复日,网上网下年复年。")
print (" 但愿老死电脑间,不愿鞠躬老板前;")
print (" 奔驰宝马贵者趣,公交自行程序员。")
print (" 别人笑我忒疯癫,我笑自己命太贱;")
print (" 不见满街漂亮妹,哪个归得程序员?")
运行后的现象:
想一想: 如果一个程序在不同的地方需要输出“佛祖镇楼”,程序应该怎样设计?
if 条件1:
输出‘佛祖镇楼’
...(省略)...
if 条件2:
输出‘佛祖镇楼’
...(省略)...
如果需要输出多次,是否意味着要编写这块代码多次呢?
抽象
抽象
抽象是数学中非常常见的概念。举个例子:
计算数列的和,比如:1 + 2 + 3 + ... + 100
,写起来十分不方便,于是数学家发明了求和符号∑,可以把1 + 2 + 3 + ... + 100
记作:
这种抽象记法非常强大,因为我们看到 ∑ 就可以理解成求和,而不是还原成低级的加法运算。 而且,这种抽象记法是可扩展的,比如:
还原成加法运算就变成了: (1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1) 可见,借助抽象,我们才能不关心底层的具体计算过程,而直接在更高的层次上思考问题。 写计算机程序也是一样,函数就是最基本的一种代码抽象的方式。
定义函数的格式如下:
def 函数名():
代码
demo:
# 定义一个函数,能够完成打印信息的功能
def printInfo():
print ('------------------------------------')
print (' 人生苦短,我用Python')
print ('------------------------------------')
定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它
调用函数很简单的,通过 函数名()
即可完成调用
demo:
# 定义完函数后,函数是不会自动执行的,需要调用它才可以
printInfo()
注意:Python调用函数要放在定义函数后面,部分编程语言可放在前面
要求:定义一个函数,能够输出自己的姓名和年龄,并且调用这个函数让它执行
答案:点击阅读原文查看
def test(a,b):
"用来完成对2个数求和"
print("%d"%(a+b))
如果执行,以下代码
help(test)
能够看到test函数的相关说明
Help on function test in module __main__:
test(a, b)
用来完成对2个数求和
(END)
思考一个问题,如下:
现在需要定义一个函数,这个函数能够完成2个数的加法运算,并且把结果打印出来,该怎样设计?下面的代码可以吗?有什么缺陷吗?
def add2num():
a = 11
b = 22
c = a+b
print(c)
为了让一个函数更通用,即想让它计算哪两个数的和,就让它计算哪两个数的和,在定义函数的时候可以让函数接收数据,就解决了这个问题,这就是 函数的参数
示例如下:
def add2num(a, b):
c = a+b
print(c)
以调用上面的add2num(a, b)函数为例:
def add2num(a, b):
c = a+b
print(c)
add2num(11, 22) #调用带有参数的函数时,需要在小括号中,传递数据
调用带有参数函数的运行过程:
要求:定义一个函数,完成前2个数完成加法运算,然后对第3个数,进行减法;然后调用这个函数
答案:点击阅读原文
>>> def test(a,b):
... print(a,b)
...
>>> test(1,2)
1 2
>>> test(b=1,a=2)
2 1
>>>
>>> test(b=1,2)
File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>>
>>>
现实生活中的场景:
我给儿子10块钱,让他给我买包烟。这个例子中,10块钱是我给儿子的,就相当于调用函数时传递到参数,让儿子买烟这个事情最终的目标是,让他把烟给你带回来然后给你对么,此时烟就是返回值。
开发中的场景:
定义了一个函数,完成了获取室内温度,想一想是不是应该把这个结果给调用者,只有调用者拥有了这个返回值,才能够根据当前的温度做适当的调整。
综上所述:
想要在函数中把结果返回给调用者,需要在函数中使用return
。
如下示例:
def add2num(a, b):
c = a+b
return c
或者
def add2num(a, b):
return a+b
在本小节刚开始的时候,说过的“买烟”的例子中,最后儿子给你烟时,你一定是从儿子手中接过来 对么,程序也是如此,如果一个函数返回了一个数据,那么想要用这个数据,那么就需要保存。 保存函数的返回值示例如下:
#定义函数
def add2num(a, b):
return a+b
#调用函数,顺便保存函数的返回值
result = add2num(100,98)
#因为result已经保存了add2num的返回值,所以接下来就可以使用了
print(result)
函数根据有没有参数,有没有返回值,可以相互组合,一共有4种:
此类函数,不能接收参数,也没有返回值,一般情况下,打印提示灯类似的功能,使用这类的函数。
def printMenu():
print('--------------------------')
print(' xx涮涮锅 点菜系统')
print('')
print(' 1. 羊肉涮涮锅')
print(' 2. 牛肉涮涮锅')
print(' 3. 猪肉涮涮锅')
print('--------------------------')
结果:
此类函数,不能接收参数,但是可以返回某个数据,一般情况下,像采集数据,用此类函数。
# 获取温度
def getTemperature():
#这里是获取温度的一些处理过程
#为了简单起见,先模拟返回一个数据
return 24
temperature = getTemperature()
print('当前的温度为:%d'%temperature)
此类函数,能接收参数,但不可以返回数据,一般情况下,对某些变量设置数据而不需结果时,用此类函数。
此类函数,不仅能接收参数,还可以返回某个数据,一般情况下,像数据处理并需要结果的应用,用此类函数。
# 计算1~num的累积和
def calculateNum(num):
result = 0
i = 1
while i<=num:
result = result + i
i+=1
return result
result = calculateNum(100)
print('1~100的累积和为:%d'%result)
def testB():
print('---- testB start----')
print('这里是testB函数执行的代码...(省略)...')
print('---- testB end----')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
结果:
---- testA start---- ---- testB start---- 这里是testB函数执行的代码...(省略)... ---- testB end---- ---- testA end----
小总结:
如下图所示:
如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量 demo如下:
a = 100
def test1():
print(a)
def test2():
print(a)
# 调用函数
test1()
test2()
运行结果:
100 100
看如下代码:
既然全局变量,就是能够在所以的函数中进行使用,那么可否进行修改呢? 代码如下:
全局变量
global
进行声明,否则出错>>> a = 1
>>> def f():
... a += 1
... print(a)
...
>>> f()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in f
UnboundLocalError: local variable 'a' referenced before assignment
>>>
>>>
>>> li = [1,]
>>> def f2():
... li.append(1)
... print(li)
...
>>> f2()
[1, 1]
>>> li
[1, 1]
global
声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向,即不能将全局变量指向新的数据。global
时无法修改全局变量。global
时也可修改全局变量。在python中我们可不可以返回多个值?
>>> def divid(a, b):
... shang = a//b
... yushu = a%b
... return shang, yushu
...
>>> sh, yu = divid(5, 2)
>>> lb = divid(5, 2)
>>> sh
2
>>> yu
1
>>> lb
(2,1)
调用函数时,缺省参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:
def printinfo( name, age = 35 ):
# 打印任何传入的字符串
print("Name: ", name)
print("Age ", age)
# 调用printinfo函数
printinfo(name="9527" )
printinfo( age=9,name="9527" )
以上实例输出结果:
Name: 9527 Age 35 Name: 9527 Age 9
注意:带有默认值的参数一定要位于参数列表的最后面(可设置多个带默认值的参数)。
>>> def printinfo(name, age=35, sex):
... print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,声明时不会命名。 基本语法如下:
def functionname([formal_args,] *args, **kwargs):
"函数_文档字符串"
function_suite
return [expression]
加了星号(*)的变量args会存放所有未命名的变量参数,args为元组;而加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典。
>>> def fun(a, b, *args, **kwargs):
... """可变参数演示示例"""
... print("a =", a)
... print("b =", b)
... print("args =", args)
... print("kwargs: ")
... for key, value in kwargs.items():
... print(key, "=", value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d) # 注意元组与字典的传参方式
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args = ((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>
>>> def selfAdd(a):
... """自增"""
... a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]
Python中函数参数是引用传递(注意不是值传递)。对于不可变类型,因变量不能修改,所以运算不会影响到变量自身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量。
想一想为什么
>>> def selfAdd(a):
... """自增"""
... a = a + a # 我们更改了函数体的这句话
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2] # 想一想为什么没有变呢?
在python中,值是靠引用来传递来的。
我们可以用id()
来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b) # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a) # 注意a的id值已经变了
13033792
>>> id(b) # b的id值依旧
13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b) # 注意a与b始终指向同一个地址
139935018544808
>>> b
[1, 2, 3]
可变类型与不可变类型 可变类型,值可以改变:
不可变类型,值不可以改变:
通过前面的学习知道一个函数可以调用其他函数。 如果一个函数在内部不调用其它的函数,而是自己本身的话,这个函数就是递归函数。
举个例子,我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
解决办法1:
看阶乘的规律
1! = 1 2! = 2 × 1 = 2 × 1! 3! = 3 × 2 × 1 = 3 × 2! 4! = 4 × 3 × 2 × 1 = 4 × 3! ... n! = n × (n-1)!
解决办法2:
原理
解决办法3:
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。可以试试fact(1000
:
>>> fact(1000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in fact
...
File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison
解决递归调用栈溢出的方法是通过尾递归优化,事实上尾递归和循环的效果是一样的,所以,把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。这样,编译器或者解释器就可以把尾递归做优化,使递归本身无论调用多少次,都只占用一个栈帧,不会出现栈溢出的情况。
上面的fact(n)
函数由于return n * fact(n - 1)
引入了乘法表达式,所以就不是尾递归了。要改成尾递归方式,需要多一点代码,主要是要把每一步的乘积传入到递归函数中:
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
可以看到,return fact_iter(num - 1, num * product)
仅返回递归函数本身,num - 1
和num * product
在函数调用前就会被计算,不影响函数调用。
fact(5)
对应的fact_iter(5, 1)
的调用如下:
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120
尾递归调用时,如果做了优化,栈不会增长,因此,无论多少次调用也不会导致栈溢出。
遗憾的是,大多数编程语言没有针对尾递归做优化,Python解释器也没有做优化,所以,即使把上面的fact(n)
函数改成尾递归方式,也会导致栈溢出。
用lambda
关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print("Value of total : ", sum( 10, 20 ))
print("Value of total : ", sum( 20, 20 ))
以上实例输出结果:
Value of total : 30 Value of total : 40
Lambda函数能接收任何数量的参数但只能返回一个表达式的值 匿名函数不能直接调用print,因为lambda需要一个表达式
函数作为参数传递函数作为参数传递 ①自己定义函数
>>> def fun(a, b, opt):
... print("a =", a)
... print("b =", b)
... print("result =", opt(a, b))
...
>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3
②作为内置函数的参数
想一想,下面的数据如何指定按age或name排序?
stus = [
{"name":"zhangsan", "age":18},
{"name":"lisi", "age":19},
{"name":"wangwu", "age":17}
]
按name排序:
>>> stus.sort(key = lambda x:x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]
按age排序:
>>> stus.sort(key = lambda x:x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]