【python学习日记】函数

2018-07-07 本文已影响0人 lony荼靡

1 *2 * 3 * ... * 10，写起来十分不方便，我们为了简便可以写成10！这就是抽象，借助抽象我们不用关心底层的具体计算过程，而直接在更高的层次上思考问题。函数就是最基本的一种代码抽象的方式。python内置了很多有用的函数，也可以灵活地自己定义函数。

1.定义

def 函数名(参数1，参数2，....):

函数体

return 返回值

函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。函数可以返回多个值，返回值为单个元组。最好写函数说明

2.调用

要调用一个函数，需要知道函数的名称和参数；调用函数式我们传入的参数数量或者类型不正确会抛出 TypeError 错误

3.参数

参数类型：必需参数、关键字参数、默认参数、不定长参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo( name, age ):

print ("名字: ", name)

print ("年龄: ", age)

return

printinfo( age=50, name="runoob" )

定义函数时我们可以给参数传递默认值，当调用函数时没有传递该参数值时使用默认参数值。带默认值的参数称为默认参数，而无默认值的参数为必需参数，调用函数时必需参数必填，默认参数选填。默认参数只能定义在必需参数的后面

def per_info(name, sex='男', age=30):

print(name, sex, age)

tuple = ('Peter', '男', 22)

per_info(*tuple)

要将列表或元组中值当参数传入函数，我们可在前面加上*，注意参数的顺序和个数

不定长参数：函数能处理比当初声明时更多的参数，加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。（如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。）

def printinfo( arg1, *vartuple ):

print ("输出: ")

print (arg1)

for var in vartuple:

print (var)

return

printinfo( 10 )

printinfo( 70, 60, 50 )

加了两个星号 ** 的参数会以字典的形式导入。

def printinfo(arg1, **vardict):

print("输出: ")

print(arg1)

print(vardict)

printinfo(1,a=2,b=3)

补充：

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型： 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型： 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，传参数即为传不可变对象和传可变对象。

4.变量作用域

Python的作用域：Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域

L （Local）局部作用域

E （Enclosing）闭包函数外的函数中

G （Global）全局作用域

B （Built-in）内建作用域

变量的查找以 L –> E –> G –>B 的规则查找，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。即可以在if外面访问if中定义的变量，不可以在函数外访问函数中定义的变量

全局变量和局部变量：在函数内部的变量拥有一个局部作用域，在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

global 和 nonlocal关键字

num = 123

def fun1():

global num # 使用 global 关键字声明，使num成为全局变量值可在函数内修改

print(num) # 输出123

num = 456 # 修改全局变量值

fun1()

print(num) # 输出 456,全局变量值被修改

def out():

num = 10 # out函数的内部变量

def inner():

nonlocal num # nonlocal关键字声明，修改嵌套作用域（外层非全局作用域）中的变量

print(num) # 输出10

num = 100 # 修改out内部变量

inner()

print(num) # 输出100

out()

5.匿名函数 lambda

lambda [参数1[,参数2,.....参数n]]:表达式

函数体只能有一个表达式，而不是一个代码块，返回结果为表达式的值

g = lambda x:x*x+1

print(g(3)) # 结果为10

lambda 匿名函数的 if...else..

lambda [arg1 [,arg2,.....argn]]:expression1 if condition else expression2 释义：如果condition 为True，条件表达式的结果为expression1，否则为expression2

funmax = lambda x, y: x if x > y else y # 求两个数最大值 print(funmax(5,2))

func = lambda n: 1 if n == 0 else n * func(n - 1)# 递归求n！ print(func(5))

filter(function,sequence)过滤筛选类，他能过滤筛选序列中的数据，返回可迭代对象。

list1 = [1, 18, 9, 7, 17, 12, 6]

f = filter(lambda x: x % 2 == 0, list1) # 筛选list1中能被2整除的数据，返回值可迭代对象

print(list(f)) # 转换为list 打印出结果，输出[18, 12, 6]

map(function,sequence)将function调用映射到每个序列的对应元素上，返回可迭代对象。

m = map(lambda x: x * 2 + 10, list1) # 对list中的每个值进行操作，返回可迭代对象

print(list(m)) #输出[12, 46, 28, 24, 44, 34, 22]

reduce(function,sequence,[initial])累积函数，function有两个参数，如无initial值，取sequence第一个元素与第二个为function参数，有则initial值作为第一个参数，sequence的第一个参数作为第二个参数。function返回值作为下次调用的第一个参数，取sequence中没选取的后一个参数作为函数第二个参数，依次类推将结果积累返回。

from functools import reduce

r = reduce(lambda x, y: x + y, list1) # 对list中元素进行累积((((((1+18)+9)+7)+17)+12)+6)

print(r) #输出70

r = reduce(lambda x, y: x + y, list1, 1) # 对list中元素进行累积,初始值为1,相当于 1+((((((1+18)+9)+7)+17)+12)+6)

print(r) #输出71

6.可变参数(*args, **kwargs)

*args 序列可变参数

def 函数名([参数,] *args):

函数体

return [返回值]

*args会存放所有未命名的不带键的参数，将这些参数转换为一个元组存储在args中。*args传入参数可以是元组、列表，也可以指不带关键字的任意多个参数。

def variablefun(name, *args):

print(name, end=':')

for arg in args:

print(arg, end=',')

print('')

variablefun('Bobo') # 可变参数可以不传入值

variablefun('woodman', 80, 90, 'man') # 可变参数可以传入任意值

tuple1 = ('女', 20) # 元组或列表前无*可变参数将元组当成一个变量

variablefun('Helen', tuple1) # 传入的是整个元组，函数会认为是一个元组参数 ('女', 20)

variablefun('Baby', *tuple1) # 加了星号，程序会将元组数据拆开，按照顺序传入数据，*tuple1 传入的是两个参数‘女’ 20

**kwargs 键对值可变型参数

def 函数名([参数,] **kwargs ):

函数体

return [返回值]

**kwargs 会存放所有未命名的带有键对值的变量参数，将这些参数转换为一个字典存储在kwargs 中。键对值可变参数中的kwargs 传入参数可以是字典，也可以是任意带关键字的参数

def fun(name, **kwargs):

print('name:', name)

for key, value in kwargs.items():

print(key, ':', value)

print('----------')

fun('woodman') # 可变参数可以不传入值

fun('Bob', sex='男') # 不在参数列表中的参数必须指定键值对

tuple1 = {'sex': '男', 'class': 2016012}

fun('Alan', **tuple1) # 可以传入字典

tuple2 = {'name': 'Heln', 'sex': '女', 'score': 89}

fun(**tuple2) #将参数name也放入了字典tuple2中，通过**tuple2传入函数