一篇文章让你让你对python函数的掌握由基础到高级

python中函数由低级到高级

一 函数基础

1.1 函数简介 function

input print 内置函数——》可以直接使用

可复用性非常差

函数就是存代码的

总结函数的优点：
1.遇到重复功能的时候，直接调用即可，减少代码量
2.提升代码的结构性，分工明确，提高代码的可读性
3.遇到扩展功能的时候，修改比较方便

函数的本质就是一段有特定功能、可重复使用的代码，这段代码已经被提前编写好了，并且为其起了一个“好听”的名字，在后续编写程序中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码

def my_len(s):
    leng = 0
    for i in s:
        leng+=1
    return leng

lengt = my_len('sahdjbaodbnao')
print(lengt)  # 13
lengt1 = my_len('xiaochuan')
print(lengt1) # 9

1.2 函数定义

定义函数：

def 函数名(形参1,形参2....形参n):
    代码块(函数体)

def fn():
    print('这是我的第一个函数')
# 函数中保存的代码不会立刻执行，需要我们用户自己调用函数，代码才会执行

1.3 函数调用

必须遵循先定义再调用

def fn():
    print('这是我的第一个函数')
print(fn) # fn是函数地址函数对象<function fn at 0x000002980AEB7430>
print(type(fn)) # <class 'function'>

调用函数语法：
函数名()

def fn():
    print('这是我的第一个函数')
fn()
fn()
fn()
fn()
fn()

这是我的第一个函数
这是我的第一个函数
这是我的第一个函数
这是我的第一个函数
这是我的第一个函数

def fn():
    print('吃了吗')
    print('睡了吗')
    print('你好')
    print('再见')
fn()
fn()
吃了吗
睡了吗
你好
再见
吃了吗
睡了吗
你好
再见

区分：
fn    函数名
fn()  函数调用

1.4 函数参数

1.4.1 形参和实参

def 函数名(): # 括号里面没东西就叫做无参函数
def 函数名(参数1,参数2...参数n): # 括号里面有东西，这个东西就叫做参数，可以有很多个

函数的参数：在定义函数时，可以在函数名后()中定义数量不等的形参，注意可以有，也可以没有，可以有一个也可以有多个，多个形参之间使用逗号隔开

形参(形式参数)：定义形参就相当于在函数内部声明了变量，但是并不赋值，这个变量只是先形式的在函数里使用，但是它没有值

实参(实际参数)：在函数定义的时候指定了形参，在调用的时候也必须传递实参，我们的实参会赋值给对应的形参，简单来讲就是有几个形参，我们必须传递几个实参
def fn(a,b):
    print('a=',a)
    print('b=',b)
fn(10,20) # 10,20就叫做实参

a= 10
b= 20

# 定义一个函数，可以用来求任意两个数的和
def sum1(a,b):
    print(a+b)
sum1(22,33)
sum1(1,1)
sum1(111,333)

总结：
在定义函数时那个参数叫形参
调用的时候叫实参
定义了多少个形参就要传递多少个实参

1.4.2 参数的传递方式

形参的传递方式

1.4.2.1 默认值参数

def fn(a,b,c=10):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,3)
a= 1
b= 2
c= 3


def fn(a,b,c=10):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2)

a= 1
b= 2
c= 10

有些参数太常用或者说基本不会去改变它，我们就可以使用默认值参数

实参的传递方式

1.4.2.2 位置参数和关键字参数

1.位置参数
就是将对应位置的实参赋值给对应位置的形参
2.关键字参数
可以不按照形参定义的顺序来传递，而是直接根据参数名来传递参数
def fn(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(b=1,c=3,a=2)
注意：混合使用关键字和位置参数的时候，位置参数必须写在关键字参数的前面
def fn(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,c=20)

a= 1
b= 2
c= 20

实参可以传递任意类型

def fn2(a):
    print('a=',a)
# fn2(123)
a = 123
fn2(a)

1.4.3 可变参数

也叫作不定长参数

1.4.3.1 *args

*args可以获得我们所有的实参，将所有的实参都保存到一个元组中，实参传递几个值元组就会有几个元素，它会接收所有的参数

我们把散开的数据，装到一个元组或者是字典里面里面这就可以叫做是装包

好处就是你想传几个就传几个，不传都行

def fn(*a):
    print(a)  # ()
    print(type(a)) # <class 'tuple'>
fn()

def fn(*a):
    print(a)  # (1, 2, 3, 4, 5)
fn(1,2,3,4,5)

# 定义一个函数，求任意个数的和
def sum1(*args):
    result = 0
    for i in args:
        result+=i
    print(result)
sum1(1)  # 1
sum1(1,2)  # 3
sum1(1,2,3)  # 6
sum1(1,2,3,4,52,3,4,5,6) # 80

注意：
1.带*号的形参只能有一个，因为写多了没办法分
2.带*号的参数可以和其他参数配合使用，但是得写在最后面
def fn(a,b,*c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,3,4,5,6,7,8,9)

a= 1
b= 2
c= (3, 4, 5, 6, 7, 8, 9)

def fn(*a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,3,4,5,6,7,8,9,1,1,1,1,1,1,1,1,1,1)  # 报错，*a是无限长的，b和c读取不到值

# 使用下面的写法可以解决可变参数写在前面的情况
def fn(*a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,3,4,5,6,7,8,9,b=44,c=55)

a= (1, 2, 3, 4, 5, 6, 7, 8, 9)
b= 44
c= 55

1.4.3.2 **kwargs

*形参有一个弊端就是只能接收位置参数

**形参可以接收任意关键字参数，会将这些参数统一保存到字典里面，字典的键就是参数的名字，字典的值就是参数的值

def fn(**args):
    print('args=',args)
    print(type(args))
fn(a=1,b=2,c=3)

args= {'a': 1, 'b': 2, 'c': 3}
<class 'dict'>

注意：**形参也是只能有一个，并且必须写在所有参数最后，它必须是最后一个

*args和**kwargs是可以同时使用的
要注意的是，同时使用*args和**kwargs的时候，*args必须写在**kwargs之前
def fn(a,b,*args,**kwargs):
    print('a=',a)
    print('b=',b)
    print('args=',args)
    print('kwargs=',kwargs)
fn(1,2,3,4,5,6,7,8,9,1,5,k=1,w=2,aa=3,rr=4)

1.4.3.3 参数解包

传递实参时，也可以在序列类型参数前面添加星号，这样他会自动将序列中的元素依次作为参数传递

注意：序列中的元素必须和我们函数形参的个数一致

def fn(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
# t = (1,2,3)
# fn(*t)
fn(*[2,3,4])
# fn(*[2,3,4,5])  # 报错，元素个数必须和形参个数一致

a= 2
b= 3
c= 4

# 注意：字典的解包必须要满足字典的key和参数的名字对上
def fn(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
d = {'a':10,'b':20,'c':30}
fn(**d)

a= 10
b= 20
c= 30

总结

1.*args适用于接收多余的未命名的位置参数
**kwargs用于接收关键字参数
其中args是一个元组类型
kwargs是一个字典类型
2.*args是把元组中的数据进行解包，也就是把元组中的数据拆成单个的数据
**kwargs是把字典中的数据进行解包，也就是把字典中的数据拆成单个的键值对

二 函数返回值 return

函数执行以后返回的结果

获取返回值：把函数调用当做一个值来输出

return后面是什么，函数的返回结果就是什么

return后面可以是任意的值

返回值可以是任意类型包括函数

def fn():
    def fn2():
        print('hello')
    return fn2
r = fn()  # fn2
print(r) # <function fn.<locals>.fn2 at 0x00000287B1216670>
r() # hello

# 如果我们不给一个函数return，那么这个函数的返回值就是空的，就是None
def fn2():
    pass
print(fn2()) # None

# NoneType只有一个值就是None
print(type(None)) # <class 'NoneType'>

# 如果给一个函数写return但是return后面没有值那么这个函数的返回值也是None
def fn():
    return 
print(fn())  # None

在函数中，return代表函数执行结束，后面的代码不会再执行

总结

return 语句的作用：结束函数调用、返回值、指定返回值
print 和 return的区别是什么：
print仅仅是打印在控制台，把结果打印出来，而return则是将return后面部分作为返回值：作为函数的输出，可以赋值给变量，继续用返回值做其他操作

注意：return语句在同一个函数中可以出现多次，但是只要有一个得到执行，就会直接结束函数的执行

三 作用域与命名空间

3.1 作用域

3.1.1 简介

作用域直白来说就是变量产生作用的区域

程序中就是：指的是变量生效的区域

def fn():
    x = 1  # x定义在函数fn的内部 所以x的作用域就是在函数内部，在函数外部无法访问

print(x) # 无法访问函数内部x


y = 2
def fn():
    x = 1  # x定义在函数fn的内部 所以x的作用域就是在函数内部，在函数外部无法访问
    print('函数内部y=',y)
fn()
print('函数外部y=',y)

函数内部y= 2
函数外部y= 2

3.1.2 全局作用域

全局作用域就是在全局都有效

全局作用域的生命周期：全局作用域在程序执行时创建，在程序执行结束时销毁

哪些位置属于全局作用域？所有函数以外的都是全局作用域
只要代码不是在函数里面都是全局作用域
在全局作用域中定义的变量，都属于是全局变量，全局变量可以在程序的任意位置被访问
# y就是全局变量
y = 2
def fn():
    x = 1  # x定义在函数fn的内部 所以x的作用域就是在函数内部，在函数外部无法访问
    print('函数内部y=',y)
fn()
print('函数外部y=',y)

函数内部y= 2
函数外部y= 2

3.1.3 局部(函数)作用域

函数作用域的生命周期：就是在函数调用时创建，在调用结束时销毁
函数每次调用的时候都会产生一个新的函数作用域
在函数作用域中定义的变量只能在函数内部访问，或者说在函数作用域中定义的变量都可以叫做局部变量
def fn():
    a = 10
    print('a=',a)
fn()
print('a=',a) # 报错，访问不到

可以从小的往大的看，但是不能从大的往小的看

def fn1():
    a = 30
    def fn2():
        print(a)  # 30 可以从里面往外面看
    fn2()
fn1()

def fn1():
    def fn2():
        a = 10
    print(a)  # 报错 不能从外面往里面看
fn1()

def fn1():
    a = 20
    def fn2():
        a = 10
        print(a) # 10
    fn2()
fn1()
使用变量的时候，会优先在当前作用域中寻找该变量，如果有就是用，没有就继续往上级作用域中寻找

global 关键字——》如果希望在函数内部修改全局变量，可以使用global关键字来声明变量

a = 1
def fn():
    a = 2
    print('内部a=',a) # 内部a= 2
fn()
print('外部a=',a) # 外部a= 1

a = 1
def fn():
    global a  # 把变量a声明为全局变量
    a = 2
    print('内部a=',a) # 内部a= 2
fn()
print('外部a=',a)  # 外部a= 2

总结：
1.基本就是 里面能看到外面，但是外面看不到里面
2.如果局部修改全局变量可以加上一个global关键字

3.2 命名空间

就是变量存储的位置

每一个作用域都会有一个对应的命名空间

全局作用域有全局的命名空间

局部作用域有局部的命名空间

命名空间实际上就是一个字典，是一个专门存储变量的字典

locals()：获取当前作用域的命名空间，返回一个字典

a = 1
def fn():
    b = 1
    print(locals())  # 函数作用域中的命名空间{'b': 1}
fn()

a = 1
def fn():
    global b  # 把变量b声明给全局了
    b = 1
    print(locals())  # {}
fn()

global  全局 把函数体内部变量声明给全局
a = 1
def fn():
    a = 2
    print('内部a=',a) # 内部a= 2
fn()
print('外部a=',a) # 外部a= 1

a = 1
def fn():
    global a  # 把变量a声明为全局变量
    a = 2
    print('内部a=',a) # 内部a= 2
fn()
print('外部a=',a)  # 外部a= 2

nonlocal  局部 只能在嵌套函数中使用
用来在函数或者其他作用域中使用外层(非全局)变量
def f1():
    a = 1
    def f2():
        a =2
        print('f2中的a=',a) # f2中的a= 2
    f2()
    print('f1中的a=',a)  # f1中的a= 1
f1()

def f1():
    a = 1
    def f2():
        nonlocal a
        a =2
        print('f2中的a=',a)  # f2中的a= 2
    f2()
    print('f1中的a=',a) # f1中的a= 2
f1()

全局 = 大方的人——》我的东西你们都可以用
局部 = 小气的人——》我的东西只有我能用

四 函数进阶

4.1 高级用法

只是让大家知道可以这么去使用，但是不常用

1.函数可以被引用(可以赋值)

def fn():
    print('我是fn')
f = fn
print(f,fn) #<function fn at 0x000001ACA2557430> <function fn at 0x000001ACA2557430>
fn() # 我是fn
f() # 我是fn

2.函数可以作为参数传入另一个函数

def fn():
    print('我是fn')
def fn2(x):
    print(x) # <function fn at 0x000001CB97FF7430>
    x()  # 我是fn
fn2(fn)  

3.可以将函数作为返回值

def fn():
    print('我是fn')
def fn2(x):
    # print(x)
    return x
x = fn2(fn)   # fn2(fn)  ——》fn
x()  # 我是fn

4.函数可以作为容器的元素

def fn():
    print('我是fn')
li1 = [1,2,3,fn]
f = li1[3]
f()  # fn()

4.2 匿名函数 lambda

语法：
lambda 参数列表:运算表达式
def fn(x):
    return x*x


# print(fn(5))  # 25
f = lambda x:x*x
print(f(5))  # 25

总结注意事项：
1.lambda并不会带来程序运行效率的提高，只会使代码更简洁
2.如果使用lambda，lambda内不要有循环，因为可读性不好，有的话请使用标准函数完成，目的是为了代码有可重用性和可读性
3.lambda只是为了减少单行函数的定义而存在，如果一个函数，只有一个返回值，只有一句代码，就可以使用lambda

4.3 高阶函数

4.3.1 高阶内置函数简介

所谓的高阶函数就是把函数作为参数传入，就是把一个函数作为另一个函数的参数传入
abs() ——》求绝对值
print(abs(-1))  # 1
sum() ——》求和
print(sum([1, 1, 2, 3, 4])) # 11
round() ——》求四舍五入
print(round(4.3)) # 4

任意两个数字，对2个数字求绝对值后进行求和
def ab_sum(a,b,f):
    return f(a)+f(b)
res = ab_sum(-1,4,abs)
print(res)

求相反数的和
def xfs(x):
    return -x
def ab_sum(a,b,f):
    return f(a)+f(b)
res = ab_sum(1,-4,xfs)
print(res)

4.3.2 map()

map(func,seq)第一个参数是给一个函数，第二个参数是给一个序列类型(要改变的序列)
map的作用就是改变序列中所有的元素，改变规则由我们传入的函数决定
li1 = [-1,2,-3,4,-5]
print(list(map(abs,li1))) # [1, 2, 3, 4, 5]

将列表中序列的各个元素加一
li1 = [1,2,3,4,5]
# 普通做法
li2 = []
for i in li1:
    li2.append(i+1)
print(li2) # [2, 3, 4, 5, 6]
# map()做法
def add1(x): # x就是列表中的每个元素
    return x+1
print(list(map(add1,li1)))
# lambda做法
print(list(map(lambda x:x+1,li1)))

4.3.3 filter()

filter(func,seq)第一个参数是给一个函数，第二个参数是给一个序列类型(要改变的序列)
filter用于过滤序列，过滤掉不符合条件的元素

需求：保留一个序列中所有的偶数
li1 = [1,2,3,4,5,6,7,8,9,10]
# 普通做法
li1 = [1,2,3,4,5,6,7,8,9,10]
for i in li1:
    if i %2 !=0: # i是奇数
        li1.remove(i)
print(li1) # 所有的偶数
# filter用法
li1 = [1,2,3,4,5,6,7,8,9,10]
def os1(x):
    return x%2==0
print(list(filter(os1,li1)))
# lambda用法
print(list(filter(lambda x:x%2==0,li1)))

4.3.4 sorted()

语法：sorted(seq,key=函数) # 第一个是给一个序列类型，第二个是参数key=函数  函数是自己所定义的规则排序
返回一个排序后的序列
li1 = [2,1,4,3,5,6,9,7]
print(sorted(li1))  # 升序
print(sorted(li1,reverse=True)) # 降序

需求：
li1 = ["小零:69","小违:79","小力:89","小荣:100","小川:59"]
def f(x):
    arr = x.split(":")
    return int(arr[1])
print(sorted(li1,key=f)) # ['小川:59', '小零:69', '小违:79', '小力:89', '小荣:100']

# x——》x是列表中每一个元素，每一个字符串"小零:69"
# x.split(":") #["小零","69"],["小违","79"]
# arr[1] 根据下标获取第二个值也就是每个元素的分数 69,79,89，但是他们都还是字符串类型
# int(arr[1])将字符串类型转成int才可以进行排序计算

max(seq,key=函数)：根据函数可以获取序列类型的最大值
min(seq,key=函数)：根据函数可以获取序列类型的最小值
def f(x):
    return int(x.split(":")[1])
print(max(li1,key=f)) # 小荣:100
print(min(li1,key=f)) # 小川:59

4.4 递归函数

如果一个函数的内部调用了自己，那么这个函数就叫做递归函数
1.如果定义递归函数，不想让它报错的话，必须要有出口
2.设计一个出口，不断的向出口接近
# 打印1-500
def func(x):
    if x == 501:
        return 
    print(x)
    return func(x+1)
func(1)