---恢复内容开始---
函数:在其他的语言中,我们也经常听到函数的概念,那么什么是函数呢?在Java中叫做method;
定义:函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可;
作用:函数能提高应用的模块性,和代码的重复利用率。
特性:1、代码一致性,2、代码复用性,3、代码可扩展性;
二:
2.1函数的创建:
在Python中,创建函数要用:def
def 函数名(参数列表):
函数体
def hello():
print('hello')
hello()#调用hello函数
2.2 函数名的命名规则:
1、函数名必须是下滑线,字母开头,包含任意字母,下划线,数字,但是不能使用任何的标点符号;
2、函数名是区分大小写的;
3、函数名字不能是保留字;
2.3形式参数,和实参:
形式参数:是不存在的,虚拟的参数,他存在的目的是为了,在函数调用的时候接收实际的参数,形参的个数数据类型应该与实参一一对应;
实际参数:调用函数的传给函数的参数,可以是常量,变量,表达式,函数 传给形参
区别:形式参数是虚拟的不占用内存空间,只有在调用的时候才会分配给内存空间,实参,是具体的,分配内存空间,只有实参传给形参,形参不能传给实参;实参的传递是单向传输的;
2.4:函数的参数:
必备参数;
不定长参数;
默认参数;
关键字参数;
1、必备参数:必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样;
def person(name,age):
print('i am %s 年龄 %d'%(name,age))
person('wing',12)
2、默认参数:默认参数是在开始的时候参数就有了默认值;
如下sex,在开始就有默认值:‘女’,如果后边的代码没有传入sex的参数,会默认给出参数值‘女’
def info(name,age,sex='女'): print('Name:%s'%name)
print('age:%s'%age)
print('Sex:%s'%sex)
return info('wing',18)
info('mimi',40,'男') 执行结果:
Name:wing
age:18
Sex:女
Name:mimi
age:40
Sex:男
3、不定长参数:不定长参数没有明确的参数的个数,这样的函数能够处理比声明的时候更多的参数,这种参数就是不定长参数;
且:加了星号(*)的变量名会存放所有未命名的变量参数。而加(**)的变量名会存放命名的变量参数
def add(*args):
sum=0
for i in args:
sum+=i
return sum
print(add(1,2,3,4,5))
print(add(1,2,9,0))
#**参数:
def information(**kwargs):
print(kwargs)
for i in kwargs:
print('%s:%s'%(i,kwargs[i]))
return
information(name='hhhhh',age=12,sex='nv',notion='china')
4.不定长参数,*args **kwargs和必须参数的位置是有要求的;
def function(必须参数,*args,**kwargs)不然位置出现错乱,是会报错的;
def info(name,*args,**kwargs):#def info(name,**kwargs,*args):报错 print('Name:%s'%name) print('args:',args)
print('kwargs:',kwargs) return info('lele',18,sex='nv',intion='chin',muqin='xuxu')
执行结果:
Name:lele
args: (18,)
kwargs: {'sex': 'nv', 'intion': 'chin', 'muqin': 'xuxu'}
5.高阶函数:
条件:1.满足一个或者多个函数作为输入,
2.输出一个函数;
def add(x,y,f):
return f(x) + f(y)
re=add(3,-1,abs)
print(re)
三:函数的返回值:
要获取函数的执行结果,必须使用return返回;
1.函数遇到return就会返回,结束运行,遇到return就代表函数的结束,然后返回值;
2.如果函数中没有return,则默认会给出return,返回值为None;
3.return多个对象,解释器会把这多个对象组装成一个元组作为一个一个整体结果输出;
四:作用域:
Python中作用域分为4种:
1.L,local,局部作用域,即函数中定义的变量;
2.E,enclosing,嵌套的父级函数的局部作用域,即包含此函数的上级函数的局部作用域,但不是全局的;
3.G,globa,全局变量,就是模块级别定义的变量;
4.B, built-in,系统固定模块里面的变量,比如int, bytearray等。 搜索变量的优先级顺序依次是:作用域局部>外层作用域>当前模块中的全局>python内置作用域,也就是LEGB。
x=int(2.6) #int built-in
g_count =0 #global
def f():
o=1 #enclosing
def inner():
i=2 #local
print(o)
#print(i) 找不到
inner()
f()
#print(o)找不到
注意:在Python中,只有类,模块,函数,才会有,新的作用域的概念,其他的代码块是不会有新的作用域的概念的;
if 2>1:
x = 1
print(x) # 1 #if并没有引入一个新的作用域,x仍处在当前作用域中,后面代码可以使用
def xue():
x = 2
print(x) # NameError: name 'x' is not defined
s=1
def f():
print(s)
s=5
f() # 错误的原因在于print(s)时,解释器会在局部作用域找,会找到s=5(函数已经加载到内存),但s使用在声明前了,所以报错:
# local variable 's' referenced before assignment.如何证明找到了s=5呢?简单:注释掉s=5,s=1
# 报错为:name 's' is not defined
#同理
x=2
def f2():
x+=2 #local variable 'x' referenced before assignment.
f2()
4.2当一个函数的作用域想要修改外部作用域的时候,这时候就要用到gobal了,和nonlocal,当修改的变量是全局作用域的时候,就要用到gobal了;
count = 1 def outer():
global count
print(count)
count = 0
print(count)
outer()
#1
#0
4.3:global关键字声明的变量必须在全局作用域上,不能嵌套作用域上,当要修改嵌套作用域(enclosing作用域,外层非全局作用域)中的变量怎么办呢,这时就需要nonlocal关键字了;
def outer():
count = 10
def inner():
nonlocal count
count = 20
print(count)
inner()
print(count)
outer()
#
#
(1)变量查找顺序:LEGB,作用域局部>外层作用域>当前模块中的全局>python内置作用域;
(2)只有模块、类、及函数才能引入新作用域;
(3)对于一个变量,内部作用域先声明就会覆盖外部变量,不声明直接使用,就会使用外部作用域的变量;
(4)内部作用域要修改外部作用域变量的值时,全局变量要使用global关键字,嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字,有了这个 关键字,就能完美的实现闭包了。
4.4递归:
函数的内部可以调用其他的函数,如果函数自己调用自己,这种就是递归;
def fun(n):
res=n
for i in range(1,n) :
res*=i
return res
print(fun(4)) #****************递归
def f(n):
if n==1:
return 1
return n*f(n-1)
print(f(3))
4.4.2斐波那契数列:
#**************递归*********************
def fibo(n):#n可以为零,数列有[0] if n <= 1:
return n
return(fibo(n-1) + fibo(n-2)) print(fibo(3))
递归:
必须有一个明确的结束的条件;
每次进入深层次的递归的时候,问题都会比上一次的递归应用有所减少;
递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返 回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。)
五:函数式编程
函数式编程中的函数这个术语不是指计算机中的函数,而是指数学中的函数,即自变量的映射。也就是说一个函数的值仅决定于函数参数的值,不依赖其他状态。比如y=x*x函数计算x的平方根,只要x的平方,不论什么时候调用,调用几次,值都是不变的。
1、函数式编程简单易懂;
其余的不在赘述;