01.Python基础-5.函数

1 函数的介绍

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

1. 内置函数
2. 自定义函数

2 函数的定义和调用

2.1 函数的定义和调用

1. 定义

def  函数名([参数]):
    代码块
    [return 表达式]

1. 调用/执行

函数名([参数])

2.2 函数的文档说明

'''
文档说明
'''

3 函数的4种类型

3.1 函数的4种类型

根据是否有参数和是否有返回值，函数分为4种类型

1. 无参，无返

'''
没有参数
没有返回值 == return None
'''

# 定义
def f1():
    print('我学Python')

# 调用
f1()

1. 无参，有返

'''
没有参数
有返回值，这个方法调用执行后，得到一个值
'''

# 定义
def f1():
    print('我学Python')
    return '函数'

# 调用
f1()        # 我学Python
ret = f1()  # 我学Python
print(ret)  # 函数

1. 有参，无返

'''
有参数
没有返回值
参数：
    1· 形参 变量名 num1
    2. 实参 值     33
'''

# 定义
def f1(num1):
    print(num1)

# 调用
f1(33)        # 33

1. 有参，有返

'''
有参数
有返回值
'''

# 定义
def f1(num1):
    return num1

# 调用
ret = f1(33)
print(ret)  # 33

1. return强调

'''
return的功能
    函数中到return结束
    如果 函数需要返回值，return写到最后
    如果像结束方法，return
'''

def f1():
    print('begin...')
    i = 1
    while i<100:
        print('i=%s' % i)
        if i == 10:
            return #到这里，函数结束
            # break 如果是break，只是退出if判断
        i+=1
    print('over...')

# 调用
f1()

3.2 函数的嵌套

def f2():
    print('f2 begin...')
    f1()
    print('f2 begin...')

def f1():
    print('f1 ...')

f2()

4 函数的参数

4.1 参数的介绍

1. 可变和不可变参数
   1. 可变类型
      • 类似 c++ 的引用传递，如 列表(list)，字典(dict)，集合(set)。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
   2. 不可变类型
      • 类似 c++ 的值传递，如 整数(int)、浮点数(float)、布尔型(bool)、None、字符串(str)、元组(tuple)。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身
2. 必选参数

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

1. 默认参数

• 调用函数时，缺省参数的值如果没有传入，则被认为是默认值, e.g.def f1(num1, num2, oper='+')

1. 可变参数
   1. 元组，列表
      • 在Python函数中，还可以定义可变参数。
      • 顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。参数组装成一个tutple
   2. 字典
      • 变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
      • 而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

'''
    可变-元组
    1. 如果传递的是列表或者元组，传递的时候要加*
    2. 也可以直接传递一个一个的参数值，数量不限
'''

def f1(*args):
    print(type(args))
    print(sum(args))

nums = (110, 119, 120)
f1(*nums) # typr->tuple sum->3

num1 = 120
num2 = 119
f1(num1, num2) # typr->tuple sum->2

'''
    可变-字典
    1. 如果传递的是字典，传递的时候要加上**
    2. 也可以直接传递一个一个的参数键值对，数量不限
'''

def f1(**kwargs):
    print(type(kwargs))

f1(sid=1,sage=10,sname='老王')
f1(**{'sid':1, 'sage':10, 'sname':'老王'})

1. 关键字参数

• 对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
• 如果要限制关键字参数的名字，就可以用命名关键字参数

def f1(a,b):
    print(a, b)

f1(1,2)
f1(a=1,b=2)
f1(b=2,a=1)

4.2 参数组合的顺序

• 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
• 但是请注意，参数定义的顺序必须是：
  
  必选参数、默认参数、可变参数。e.g.def f(a,b=1,*c,**d):

5 变量作用域

5.1 变量作用域介绍

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

1. 全局变量
2. 局部变量

5.2 局部变量

1. 局部变量，就是在函数内部定义的变量
2. 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
3. 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

局部变量
    定义的位置
        1. 定义在函数的变量
        2. 定义成函数的参数
    作用域
        只有在函数里有效，函数运行完毕，垃圾回收机制会将局部变量回收

5.3 全局变量

1. 如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
2. 如果要再函数中修改全局变量，使用global声明

全局变量
    定义的位置
        1. 函数的外部
        2. 定义在函数内部，使用global声明
    作用域
        只要前面定义过了，以后任何地方都能用
    注意
        在函数体不能直接修改全局变量
        如果想在内部修改全局变量，加global

5.4 全局和局部变量重名

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量

5.5 小结

1. 在函数外边定义的变量叫做全局变量
2. 全局变量能够在所以的函数中进行访问
3. 如果在函数中修改全局变量，那么就需要使用global进行声明
4. 如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧 强龙不压地头蛇

6 递归函数

1. 如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

2. 满足递归的条件：

   1. 有循环的内容
   2. 有跳出的条件

3. 和循环的比较

• 一般递归可以改成循环for，while
• 递归效率比较低，因为函数会反复调用占内存

# 1 1 2 3 5 8 13 21 ...
# 斐波那契数列
def rec(num):
    if num==1 or num==2:
        return 1
    return rec(num-1) + rec(num-2)

ret = rec(30)

# 5! = 5*4*3*2*1
# 求阶乘
i = 1
num = 1
while i<11:
    num*=i
    i+=1

def rec(num):
    if num==1:
        return 1
    return num*rec(num-1)
ret = rec(10)

7 匿名函数

1. 用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
2. lambda函数的语法只包含一个语句，如下：
   
   lambda [arg1 [,arg2,.....argn]]:expression
   
   注意：
   1. lambda函数能接收任何数量的参数但只能返回一个表达式的值
   2. 匿名函数不能直接调用print，因为lambda需要一个表达式

def f1(a,b):
    return a+b
f1(1,2)

add = lambda a,b:a+b
add(1,2)