python foo函数_python——函数

python——函数

函数是什么

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

在python中函数它相当于一个独立的代码块，可以被重复使用，如果需要增加一个功能或者修改一个功能，只需要，增加或者修改函数即可。

函数分类

内置函数

python解释器已经为我们定义好的参数，比如:len(),sum(),max()等

函数的定义

列子：定义函数使用def关键字，后面是函数名，函数名不能重复

def fun():#定义一个函数，后面是函数名

print("Hello World")#函数体

我们看一下实列

def函数名(参数1，参数2，参数3,....):'''注释名'''函数体return 返回的值

一旦执行到return，整个函数就结束了。如果没有return，会默认返回None。return可以返回多个参数，这多个参数用元组封装。

函数的参数

1.形参和实参

函数在调用的时候，可以传入参数，有形参和实参，简单点说，形参就是函数接收的参数，而实参就是你实际传入的参数。

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。

实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

形参，实参如下：

#1、位置参数：按照从左到右的顺序定义的参数

位置形参：必选参数

位置实参：按照位置给形参传值#2、关键字参数：按照key=value的形式定义的实参

无需按照位置为形参传值

注意的问题：1. 关键字实参必须在位置实参右面2. 对同一个形参不能重复传值#3、默认参数：形参在定义时就已经为其赋值

可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数(形参)

注意的问题：1. 只在定义时赋值一次2. 默认参数的定义应该在位置形参右面3. 默认参数通常应该定义成不可变类型#4、可变长参数：

可变长指的是实参值的个数不固定

而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs===========*args===========

def foo(x, y, *args):print(x, y) #1 2

print(args) #(3, 4, 5)

foo(1, 2, 3, 4, 5)-----------------------------------------------

def foo(x, y, *args):print(x, y) #1 2

print(args) #(3, 4, 5)

foo(1, 2, *[3, 4, 5])-----------------------------------------------

deffoo(x, y, z):print(x, y, z) #1 2 3

foo(*[1, 2, 3])-----------------------------------------------

def foo(*args, x, y):print(x, y)print(args)

foo(1, 2, *[3, 4, 5]) #报错

===========**kwargs===========

def foo(x, y, **kwargs):print(x, y) #1 2

print(kwargs) #{'c': 3, 'a': 1, 'b': 2}

foo(1, y=2, a=1, b=2, c=3)----------------------------------------------

def foo(x, y, **kwargs):print(x, y) #1 2

print(kwargs) #{'c': 3, 'a': 1, 'b': 2}

foo(1, y=2, **{'a': 1, 'b': 2, 'c': 3})-----------------------------------------------

deffoo(x, y, z):print(x, y, z) #2 3 1

foo(**{'z': 1, 'x': 2, 'y': 3})===========*args+**kwargs===========

def foo(x, y, *args, **kwargs):print(x, y) #1 2

print(args) #(3, 4, 5)

print(kwargs) #{'c': 4, 'b': 3, 'd': 5}

foo(1, 2, 3, 4, 5, b=3, c=4, d=5)----------------------------------------------

*后定义的参数，必须被传值(有默认值的除外)，且必须按照关键字实参的形式传递def foo(x, y, *args, a=1, b, **kwargs):print(x, y) #1 2

print(args) #(3, 4, 5)

print(a) #1

print(b) #3

print(kwargs) #{'c': 4, 'd': 5}

foo(1, 2, 3, 4, 5, b=3, c=4, d=5)View Code

2.默认参数

默认参数就是在定义形参的时候，给函数默认赋一个值，比如说数据库的端口这样的，默认给它一个值，这样就算你在调用的时候没传入这个参数，它也是有值的

#port=3306为默认值参数

def connect(ip,port=3306):print(ip,port)#如果给一个port值，则传新给的值

connect('118.1.1.1',3307)#如果不填，则使用默认参数

connect('118.1.1.1')View Code

使用函数

使用的原则

函数使用的时候，要保证先定义，后调用

例子如下：

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名#测试一

deffoo():print('from foo')

bar()

foo()#报错

#测试二

defbar():print('from bar')deffoo():print('from foo')

bar()

foo()#正常

#测试三

deffoo():print('from foo')

bar()defbar():print('from bar')

foo()#会报错吗?

#结论:函数的使用,必须遵循原则:先定义,后调用#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段

deffoo():print('from foo')

bar()defbar():print('from bar')#调用阶段

foo()View Code

调用函数方式1 语句形式：foo()

2 表达式形式：3*len('hello')

3 当中另外一个函数的参数：range(len('hello'))

嵌套函数

嵌套函数说直接点就是在函数还有另一个函数

函数嵌套还分为调用和定义

我们先看一下调用：

defmax(x,y):return x if x > y elseydefmax4(a,b,c,d):

res1=max(a,b)

res2=max(res1,c)

res3=max(res2,d)returnres3print(max4(1,2,3,4))View Code

接下来我们看一下嵌套函数的定义：

deff1():print('from f3')

f1()View Code

函数的特性

函数是第一类对象，即函数可以当作数据传递

比如：#1 可以被引用

#2 可以当作参数传递

#3 返回值可以是函数

#3 可以当作容器类型的元素

列1：

defdemo():print("demo1")

a=demo

b=a

b()View Code