python笔记(5.函数)

第五部分函数

函数简介（function）

- 函数也是一个对象
- 对象是内存中专门用来存储数据的一块区域
- 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用
- 创建函数：
    def 函数名([形参1,形参2,...形参n]) :
        代码块
    - 函数名必须要符号标识符的规范
        （可以包含字母、数字、下划线、但是不能以数字开头）    
- 函数中保存的代码不会立即执行，需要调用函数代码才会执行
- 调用函数：
    函数对象()
- 定义函数一般都是要实现某种功能的

定义函数

# 比如有如下三行代码，这三行代码是一个完整的功能
# print('Hello')
# print('你好')
# print('再见')

# 定义一个函数
def fn() :
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')

# 打印fn
# print(fn) <function fn at 0x03D2B618>
# print(type(fn)) <class 'function'>

# fn是函数对象  fn()调用函数
# print是函数对象 print()调用函数
# fn()  
# 调用fn函数

# 定义一个函数，可以用来求任意两个数的和
 def sum() :
     a = 123
     b = 456
     print(a + b)

# 定义函数时指定形参
def fn2(a , b) :
    # print('a =',a)
    # print('b =',b)
    print(a,"+",b,"=",a + b)

# 调用函数时，来传递实参
fn2(10,20)
fn2(123,456)

函数的参数

- 在定义函数时，可以在函数名后的()中定义数量不等的形参，
    多个形参之间使用,隔开
- 形参（形式参数），定义形参就相当于在函数内部声明了变量，但是并不赋值
- 实参（实际参数）
    - 如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，
        实参将会赋值给对应的形参，简单来说，有几个形参就得传几个实参

练习1:定义一个函数，可以用来求任意三个数的乘积

1
2
3

# 求任意三个数的乘积
def mul(a,b,c):
    print(a*b*c)

练习1:定义一个函数，可以根据不同的用户名显示不同的欢迎信息

# 根据不同的用户名显示不同的欢迎信息   
def welcome(username):
    print('欢迎',username,'光临')

# mul(1,2,3)   
# welcome('孙悟空')

参数传递实例：

# 定义一个函数
# 定义形参时，可以为形参指定默认值
# 指定了默认值以后，如果用户传递了参数则默认值没有任何作用
#   如果用户没有传递，则默认值就会生效
def fn(a = 5 , b = 10 , c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)

# fn(1 , 2 , 3)
# fn(1 , 2)
# fn()

# 实参的传递方式
# 位置参数
# 位置参数就是将对应位置的实参复制给对应位置的形参
# 第一个实参赋值给第一个形参，第二个实参赋值给第二个形参 。。。
# fn(1 , 2 , 3)

# 关键字参数
# 关键字参数，可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
# fn(b=1 , c=2 , a=3)
# print('hello' , end='')
# 位置参数和关键字参数可以混合使用
# 混合使用关键字和位置参数时，必须将位置参数写到前面
# fn(1,c=30)

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

# 函数在调用时，解析器不会检查实参的类型
# 实参可以传递任意类型的对象（和C有所区别）
b = 123
b = True
b = 'hello'
b = None
b = [1,2,3]

# fn2(b)    
fn2(fn)

# 参数类型任意方便，但也会产生一些问题
def fn3(a , b):
    print(a+b)
# fn3(123,"456")

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    # a = 20
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时（该对象）
    #   会影响到所有指向该对象的变量（类似于传地址调用）
    a[0] = 30
    print('a =',a,id(a))

c = 10   
c = [1,2,3] 
fn4(c)

# 想要传值调用，不改变实参本身，可以这样
# fn4(c.copy())
# fn4(c[:])

不定长的参数：

# 不定长的参数
# 定义一个函数，可以求任意个数字的和
# 在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参
def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    print(result)


# sum(123,456,789,10,20,30,40) 想要参数数量随便变化
# 在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参
# 它将会将所有的实参保存到一个元组中
# a,b,*c = (1,2,3,4,5,6)

# *a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
def fn(*a):
    print("a =",a,type(a))

# fn(1,2,3,4,5)
# 带星号的形参只能有一个
# 带星号的参数，可以和其他参数配合使用
# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
# def fn2(a,b,*c):
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)

# 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递(c就必须使用关键字参数的形式传递)
# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数
# def fn2(a,*b,c):
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)

# 所有的位置参数都给a，b和c必须使用关键字参数
# def fn2(*a,b,c):
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)

# 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递
def fn2(*,a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
# fn2(a=3,b=4,c=5)

# *形参只能接收位置参数，而不能接收关键字参数
# def fn3(*a) :
#     print('a =',a)

# **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
#   字典的key就是参数的名字，字典的value就是参数的值
# **形参只能有一个，并且必须写在所有参数的最后
def fn3(b,c,**a) :
    print('a =',a,type(a))
    print('b =',b)
    print('c =',c)

# fn3(b=1,d=2,c=3,e=10,f=20)

# 参数的解包（拆包）
def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

# 创建一个元组
t = (10,20,30)

# 传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
# 这里要求序列中元素的个数必须和形参的个数的一致
# fn4(*t)    

# 创建一个字典
d = {'a':100,'b':200,'c':300}
# 通过 **来对一个字典进行解包操作
fn4(**d)

函数的返回值：

返回值，返回值就是函数执行以后返回的结果
可以通过 return 来指定函数的返回值
可以之间使用函数的返回值，也可以通过一个变量来接收函数的返回值

这是一个没有返回值的函数：

def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    print(result)

# sum(123,456,789)

return 后边跟什么值，函数就会返回什么值
return 后边可以跟任意的对象(字符串，列表，字典)，返回值甚至可以是一个函数

这是一个有返回值的函数：

def fn():
    # return 'Hello'
    # return [1,2,3]
    # return {'k':'v'}
    def fn2() :
        print('hello')#嵌套函数
    return fn2 # 返回值也可以是一个函数

r = fn() # 这个函数的执行结果就是它的返回值

如果仅仅写一个return 或者不写return，则相当于return None
在函数中，return后的代码都不会执行，return 一旦执行函数自动结束

return continue break三者的区别：

def fn4() :
    for i in range(5):
        if i == 3 :
            # break 用来退出当前循环
            # continue 用来跳过当次循环
            return # return 用来结束函数
        print(i)
    print('循环执行完毕！')

fn5 和 fn5()的区别

def fn5():
    return 10

print(fn5) 
# fn5是函数对象，打印fn5实际是在打印函数对象 <function fn5 at 0x05771BB8>
print(fn5()) 
# fn5()是在调用函数，打印fn5()实际上是在打印fn5()函数的返回值 10

文档字符串(函数的描述)

help 函数

help()是Python中的内置函数
通过help()函数可以查询python中的函数的用法
语法：help(函数对象)

help(print) # 获取print()函数的使用说明
结果：
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

利用函数字符串编写函数说明

# 文档字符串（doc str）
# 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
#   当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
#   文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
def fn(a:int,b:bool,c:str='hello') -> int:#这里等于号后面是对参数类型的描述，后面的箭头表示其返回值的类型
    '''
    这是一个文档字符串的示例（尽量使用英文编写）

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。
        b，作用，类型，默认值。。。。
        c，作用，类型，默认值。。。。
    '''
    return 10

help(fn)

函数的作用域和命名空间

作用域

作用域（scope）
作用域指的是变量生效的区域

b = 20 # 全局变量

def fn():
    a = 10 # a定义在了函数内部，所以他的作用域就是函数内部，函数外部无法访问
    print('函数内部：','a =',a)
    print('函数内部：','b =',b)

fn()    
print('函数外部：','a =',a)#无法调用
print('函数外部：','b =',b)

在Python中一共有两种作用域
全局作用域

全局作用域在程序执行时创建，在程序执行结束时销毁
所有函数以外的区域都是全局作用域
在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问

函数作用域

函数作用域在函数调用时创建，在调用结束时销毁
函数每调用一次就会产生一个新的函数作用域
在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

变量的查找

当我们使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，如果没有则继续去上一级作用域中寻找，如果有则使用，
如果依然没有则继续去上一级作用域中寻找，以此类推。直到找到全局作用域，依然没有找到，则会抛出异常：
NameError: name ‘a’ is not defined

变量修改：

a = 20

def fn3():
    # a = 10 # 在函数中为变量赋值时，默认都是为局部变量赋值
    # 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
    global a # 声明在函数内部的使用a是全局变量，此时再去修改a时，就是在修改全局的a
    a = 10 # 修改全局变量
    print('函数内部：','a =',a)

命名空间

命名空间（namespace）
命名空间指的是变量存储的位置，每一个变量都需要存储到指定的命名空间当中
每一个作用域都会有一个它对应的命名空间
全局命名空间，用来保存全局变量。函数命名空间用来保存函数中的变量
命名空间实际上就是一个字典，是一个专门用来存储变量的字典

locals()用来获取当前作用域的命名空间
如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间
返回的是一个字典

scope = locals() # 当前命名空间
print(type(scope))
# print(a)
# print(scope['a'])
# 向scope中添加一个key-value
scope['c'] = 1000 # 向字典中添加key-value就相当于在全局中创建了一个变量（一般不建议这么做）
# print(c)

def fn4():
    a = 10
    # scope = locals() # 在函数内部调用locals()会获取到函数的命名空间
    # scope['b'] = 20 # 可以通过scope来操作函数的命名空间，但是也是不建议这么做

    # globals() 函数可以用来在任意位置获取全局命名空间
    global_scope = globals()
    # print(global_scope['a'])
    global_scope['a'] = 30
    # print(scope)

fn4()

递归

求10的阶乘

基础：

# 尝试求10的阶乘（10!）
# 1! = 1
# 2! = 1*2 = 2
# 3! = 1*2*3 = 6
# 4! = 1*2*3*4 = 24

# print(1*2*3*4*5*6*7*8*9*10)

函数：

# 创建一个变量保存结果
# n = 10
# for i in range(1,10):
#     n *= i
# print(n)
# 创建一个函数，可以用来求任意数的阶乘
def factorial(n):
    '''
        该函数用来求任意数的阶乘
        参数：
            n 要求阶乘的数字
    '''
    # 创建一个变量，来保存结果
    result = n    
    for i in range(1,n):
        result *= i
    return result    
# 求10的阶乘    
# print(factorial(20))

递归式的函数：
从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么故事呢？
从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么故事呢？….
递归简单理解就是自己去引用自己！
递归式函数，在函数中自己调用自己！

# 无穷递归，如果这个函数被调用，程序的内存会溢出，效果类似于死循环
 def fn():
     fn()
 fn()

递归是解决问题的一种方式，它和循环很像

它的整体思想是，将一个大问题分解为一个个的小问题，直到问题无法分解时，再去解决问题
递归式函数的两个要件
1.基线条件

问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了

2.递归条件

将问题继续分解的条件

递归和循环类似，基本是可以互相代替的，循环编写起来比较容易，阅读起来稍难,递归编写起来难，但是方便阅读

利用递归求阶乘：

def factorial(n):
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''
    # 基线条件 判断n是否为1，如果为1则此时不能再继续递归
    if n == 1 :
        # 1的阶乘就是1，直接返回1
        return 1

    # 递归条件    
    return n * factorial(n-1)

# print(factorial(10))

递归练习

创建一个函数 power 来为任意数字做幂运算 n ** i

def power(n , i):
    '''
        power()用来为任意的数字做幂运算

        参数：
            n 要做幂运算的数字
            i 做幂运算的次数
    '''
    # 基线条件
    if i == 1:
        # 求1次幂
        return n
    # 递归条件
    return n * power(n , i-1)

# print(power(8,6))

创建一个函数，用来检查一个任意的字符串是否是回文字符串

先检查第一个字符和最后一个字符是否一致，如果不一致则不是回文字符串
如果一致，则看剩余的部分是否是回文字符串

#   abcdefgfedcba
#   先检查第一个字符和最后一个字符是否一致，如果不一致则不是回文字符串
#       如果一致，则看剩余的部分是否是回文字符串
#   检查 abcdefgfedcba 是不是回文
#   检查 bcdefgfedcb 是不是回文
#   检查 cdefgfedc 是不是回文
#   检查 defgfed 是不是回文
#   检查 efgfe 是不是回文
#   检查 fgf 是不是回文
#   检查 g 是不是回文(基线条件)
def hui_wen(s):
    '''
        该函数用来检查指定的字符串是否回文字符串，如果是返回True，否则返回False

        参数：
            s：就是要检查的字符串
    '''
    # 基线条件
    if len(s) < 2 :
        # 字符串的长度小于2，则字符串一定是回文
        return True
    elif s[0] != s[-1]:
        # 第一个字符和最后一个字符不相等，不是回文字符串
        return False    
    # 递归条件    
    return hui_wen(s[1:-1])
print(hui_wen('abcdefgfedcba'))

高阶函数

函数式编程

在Python中，函数是一等对象

一等对象一般都会具有如下特点：
① 对象是在运行时创建的
② 能赋值给变量或作为数据结构中的元素
③ 能作为参数传递
④ 能作为返回值返回

高阶函数

高阶函数至少要符合以下两个特点中的一个
① 接收一个或多个函数作为参数
② 将函数作为返回值返回

一个普通的函数：

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

# 定义一个函数
#   可以将指定列表中的所有的偶数，保存到一个新的列表中返回
def fn(lst) :

    '''
        fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回

        参数：
            lst：要进行筛选的列表
    '''
    # 创建一个新列表
    new_list = []

    # 对列表进行筛选
    for n in lst :
        # 判断n的奇偶
        if i % 2 == 0 ::
            new_list.append(n)
    # 返回新列表
    return new_list

函数化编程：

检查一个任意的数字是否是偶数

# 定义一个函数，用来检查一个任意的数字是否是偶数
def fn2(i) :
    if i % 2 == 0 :
        return True
    
    return False

这个函数用来检查指定的数字是否大于5

# 这个函数用来检查指定的数字是否大于5
def fn3(i):
    if i > 5 :
        return True    
    return False

主函数：

def fn(func , lst) :
    '''
        fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回

        参数：
            lst：要进行筛选的列表
    '''
    # 创建一个新列表
    new_list = []
    # 对列表进行筛选
    for n in lst :
        # 判断n的奇偶
        if func(n) :
            new_list.append(n)
        # if n > 5 :
        #     new_list.append(n)
    # 返回新列表
    return new_list

调用时，主函数可以直接选择调用任意函数，和参数 (规则和参数都作为输入)
当我们使用一个函数作为参数时，实际上是将指定的代码传递进了目标函数

1 2	`print(fn(fn2 , l)) #实现的功能也是将指定列表中的所有的偶数，保存到一个新的列表中返回`

filter()过滤器

filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中
参数：
 1.函数，根据该函数来过滤序列（可迭代的结构）
 2.需要过滤的序列（可迭代的结构）
返回值：
  过滤后的新序列（可迭代的结构）

示例：

r=filter(fn4 ,l)#这里fn4作为参数，所以不加（）
print(list(r))
# fn4是作为参数传递进filter()函数中
#   而fn4实际上只有一个作用，就是作为filter()的参数
#   filter()调用完毕以后，fn4就已经没用

匿名函数：

匿名函数 lambda 函数表达式 （语法糖）
  lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式
  语法：lambda 参数列表 : 返回值
  匿名函数一般都是作为参数使用，其他地方一般不会使用

示例：

#普通写法：
def fn5(a , b):
    return a + b
#匿名写法：
lambda a,b : a + b

调用：整体加括号，参数也放进括号里
(lambda a,b : a + b)(10,20)#一般不这么用

# 也可以将匿名函数赋值给一个变量，一般不会这么做
fn6 = lambda a,b : a + b
# print(fn6(10,30))

对本节第一个程序的改造：

def fn4(i):
    return i % 3 == 0
#fn4可以有如上的简写
#在利用filter()和匿名函数调用就是下面这样：
r = filter(lambda i : i > 5 , l)
print(list(r))
#这两行就起到了本节第一个普通函数fn的效果

map()函数

# map()
# map()函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
l = [1,2,3,4,5,6,7,8,9,10]

r = map(lambda i : i ** 2 , l)#求列表每一个元素的2次方

# print(list(r))

sort()方法

# sort()
# 该方法用来对列表中的元素进行排序
# sort()方法默认是直接比较列表中的元素的大小
# 在sort()可以接收一个关键字参数 ， key
#   key需要一个函数作为参数，当设置了函数作为参数
#   每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小
l = ['bb','aaaa','c','ddddddddd','fff']
# l.sort(key=len)

l = [2,5,'1',3,'6','4']
l.sort(key=int)
# print(l)

sorted()函数

# sorted()
# 这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
#   并且使用sorted()排序不会影响原来的对象，而是返回一个新对象

l = [2,5,'1',3,'6','4']
# l = "123765816742634781"

print('排序前:',l)
print(sorted(l,key=int))
	print('排序后:',l)

闭包

将函数作为返回值返回，也是一种高阶函数
这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
可以将一些私有的数据藏到的闭包中

语法示例：

def fn():
    a = 10
    # 函数内部再定义一个函数
    def inner():
        print('我是fn2' , a)
    # 将内部函数 inner作为返回值返回   
    return inner

# r是一个函数，是调用fn()后返回的函数
# 这个函数实在fn()内部定义，并不是全局函数
# 所以这个函数总是能访问到fn()函数内的变量,其他函数访问不了
r = fn()    
r()

示例：求多个数的平均值:

正常写法：

# 求多个数的平均值
 nums = [50,30,20,10,77]
# sum()用来求一个列表中所有元素的和
 print(sum(nums)/len(nums))

闭包：

# 形成闭包的要件
#   ① 函数嵌套
#   ② 将内部函数作为返回值返回
#   ③ 内部函数必须要使用到外部函数的变量
def make_averager():
    # 创建一个列表，用来保存数值
    nums = []

    # 创建一个函数，用来计算平均值
    def averager(n) :
        # 将n添加到列表中
        nums.append(n)
        # 求平均值
        return sum(nums)/len(nums)

    return averager

averager = make_averager()
print(averager(10))
print(averager(20))
print(averager(30))
print(averager(40))

装饰器

现在有以下程序：

def add(a , b):
    '''
        求任意两个数的和
    '''
    r = a + b
    return r


def mul(a , b):
    '''
        求任意两个数的积
    '''
    r = a * b
    return r    

r = add(123,456)
print(r)

当前需求：希望函数可以在计算前，打印开始计算，计算结束后打印计算完毕

我们可以直接通过修改函数中的代码来完成这个需求，但是会产生以下一些问题
① 如果要修改的函数过多，修改起来会比较麻烦
② 并且不方便后期的维护
③ 并且这样做会违反开闭原则（OCP）

程序的设计，要求开发对程序的扩展，要关闭对程序的修改
我们希望在不修改原函数的情况下，来对函数进行扩展:

只需要根据现有的函数，来创建一个新的函数:

def fn2():
    print('函数开始执行~~~')
    fn()
    print('函数执行结束~~~')

对add函数进行修改(记得传递参数)

def new_add(a,b):
    print('计算开始~~~')
    r = add(a,b)
    print('计算结束~~~')
    return r

# r = new_add(111,222)    
# print(r)

上边的方式，已经可以在不修改源代码的情况下对函数进行扩展了
但是，这种方式要求我们每扩展一个函数就要手动创建一个新的函数，实在是太麻烦了
为了解决这个问题，我们创建一个函数，让这个函数可以自动的帮助我们生产函数

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function

f = begin_end(fn)
f2 = begin_end(add)
f3 = begin_end(mul)
# r = f()
# r = f2(123,456)
# r = f3(123,456)
# print(r)

向begin_end()这种函数我们就称它为装饰器
通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
在开发中，我们都是通过装饰器来扩展函数的功能的
在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
可以同时为一个函数指定多个装饰器，这样函数将会安装从内向外的顺序被装饰

@begin_end
def say_hello():
    print('大家好~~~')

say_hello()

这个就相当于：

1	`f = begin_end(say_hello)`

计算机及嵌入式软件 > 编程语言 > python

#编程语言 #python #函数

python笔记(5.函数)

https://www.duruofu.xyz/posts/56416/

作者

DuRuofu

发布于

2022年3月17日

更新于

2025年1月10日

许可协议

python笔记(3.流程控制语句) 上一篇

python笔记(6.对象) 下一篇

python笔记(5.函数)

第五部分 函数

函数简介（function）

定义函数

函数的参数

练习1:定义一个函数，可以用来求任意三个数的乘积

练习1:定义一个函数，可以根据不同的用户名显示不同的欢迎信息

参数传递实例：

不定长的参数：

函数的返回值：

文档字符串(函数的描述)

help 函数

利用函数字符串编写函数说明

函数的作用域和命名空间

作用域

命名空间

递归

递归练习

创建一个函数 power 来为任意数字做幂运算 n ** i

创建一个函数，用来检查一个任意的字符串是否是回文字符串

高阶函数

函数式编程

filter()过滤器

匿名函数：

map()函数

sort()方法

sorted()函数

闭包

装饰器

第五部分函数