函数定义

• 格式

# 格式
# def 函数名(num):
#     pass
# 调用函数:
# 函数名(num)

• 函数定义实例：

def caculateNum(num):
    """
    计算1~num质检的累加和
    :param num:累加和的末尾
    :return: 返回累加和
    """
    res = 0
    for i in range(1,num+1):
        res += i
    return res

res = caculateNum(100)
print(res)

5050

三种传参方式

• 按位置顺序传参

def get_fullname(first_name,last_name='凌宇'):
    full_name = first_name+last_name
    return full_name
full_name = get_fullname('李','诗才')
print(full_name)

李诗才

• 按关键字传参,参数顺序可以任意

def get_fullname(first_name,last_name='凌宇'):
    full_name = first_name+last_name
    return full_name
full_name = get_fullname(last_name='诗才',first_name='李')
print(full_name)

李诗才

• 默认传参
  当参数缺省时，默认参数会生效，默认参数需要在函数声明时指定其值，如果传参时省略了默认参数，则该参数的值为默认值。如下函数中的last_name

def get_fullname(first_name,last_name='凌宇'):
    full_name = first_name+last_name
    return full_name
full_name = get_fullname(first_name='李')
print(full_name)

李凌宇

“*”操作符

将参数放置到一个元组中

def self_print(name,*a):
    print(name)
    print(type(name))
    print(a)
    print(type(a))
self_print(1,2,3,4,5,6)

1
<class 'int'>
(2, 3, 4, 5, 6)
<class 'tuple'>

1被赋值给了name，后面的2，3，4，5，6放置到元组中

注意：*操作符也可以拆开元组或列表
效果如下：

# * 有拆开元组、列表的作用
t = (1,2,3,4,5)
print(*t)

1 2 3 4 5

所以以上代码可以改成如下:

def self_print(name,*a):
    print(name)
    print(type(name))
    print(a)
    print(type(a))
self_print(*(1,2,3,4,5,6))

1
<class 'int'>
(2, 3, 4, 5, 6)
<class 'tuple'>

“**”操作符

把参数都放入到字典中

def d_self_print(**kwars):
    print(kwars)
d_self_print(first_name="li",last_name="shicai")

{'first_name': 'li', 'last_name': 'shicai'}

注意：“**”操作符如果作用于字典，可以将一个字典拆开所以上面代码可以和下面这种写法等效

# ** 有拆开字典的作用
def d_self_print(**kwars):
    print(kwars)
d_self_print(**{'first_name': 'li', 'last_name': 'shicai'})

{'first_name': 'li', 'last_name': 'shicai'}

return

用于返回值，可以用“，”分割，代表一个元组

def sum_and_avg(*numbers):
    total = sum(numbers)
    avg_number = total/len(numbers)
    return total,avg_number
sum,avg = sum_and_avg(1,2,3,4,5,6,7,8,9,10)
print("总和是%f"%(sum))
print('平均值是%f'%(avg))

总和是55.000000
平均值是5.500000

函数的传参问题

参数分为引用类型，普通类型，python中的基本数据类型都是普通类型。包括数、布尔、字符串型，除了这些之外的都是引用类型。普通类型赋值的时候传的是值；引用类型赋值的时候，传的是址

l1 = [1,2,3,4,5,]
l2 = l1
l2[1] = 5
print(l1)

a = 5
b = a
b = 10
print(a)

[1, 5, 3, 4, 5]
5

上面列表传的是列表的地址，是引用，而b=a的操作是传的值

传参的本质就是赋值操作，如果传递的引用数据类型，则需要注意是否在函数中对其做出了修改
为了防止在函数中修改了值，通常会创建一个数据副本

def power(numbers):
    # 列表推导式可以创建一个副本，不改变原本的值，
    # 函数中的numbers与外部的number不是同一个number，只是值相同，但地址不同
    # numbers = [x**2 for x in numbers]

    # 也可以赋值创建副本,不改变原本的值
    # numbers = numbers[:]
    # numbers = list(numbers)
    numbers[3] = 10
    return numbers
nums = [1,2,3,4,5,6,7,8,9,10]
print(power(nums))
print(nums)

函数的本质

函数的本质其实是地址

def fun():
    print("hello world!")

# 函数名的本质是函数的地址
f = fun
print('f即函数的地址:', f)
f() # 效果等同于fun()

f即函数的地址: <function fun at 0x000001B512E5C1E0>
hello world!

函数的闭包

即函数的嵌套在函数内部还可以定义一个函数，例子包含在下面变量的讲解中。

函数变量的作用域

python中，变量的作用域是以函数为单位的，内层函数可以访问外层函数的变量，但是不能修改

def outter():
    a = 10
    def inner():
        a = 20
        print('内层',a)
    print('外层未改变',a)
    return inner
outter()()

外层未改变 10
内层 20

• global:加了global表示调用的时全局变量，即最外层变量，而不是当前函数或者外层函数所创建的

a = 5
def outter():
    a = 10
    def inner():
        global a # 用了global后，与全局a是同一个，并非副本
        print('内层赋值前',a)
        a = 20
        print('内层赋值后',a)
    inner()
    print('外层函数的变量不变',a)
outter()
print('最外层全局变量因内层赋值后而改变',a)

内层赋值前 5
内层赋值后 20
外层函数的变量不变 10
最外层全局变量因内层赋值后而改变 20

• nolocal
  nolocal修饰变量时，说明使用的嵌套层函数的变量，内层函数访问变量时会先从自己查找，如果找不到，就会层层向上查找

a = 5
def outter():
    a = 10
    def inner():
        nonlocal a # 用了global后，与全局a是同一个，并非副本
        print('内层赋值前',a)
        a = 20
        print('内层赋值后',a)
    inner()
    print('外层函数的变量改变',a)
outter()
print('最外层全局变量不变',a)

内层赋值前 10
内层赋值后 20
外层函数的变量改变 20
最外层全局变量不变 5

总结：变量通常只作用于当前函数体内，若内层函数有同名变量，其实只是外层函数变量的副本，改变内层函数变量的值，并不改变外层函数变量的值；但加了global或nolocal关键字修饰后的变量则不同，内层函数变量不再是副本，用global修饰的内层函数变量就是全局变量，nolocal修饰的变量层层向上查找，改变内层函数变量的值即改变的外层的值。类似于传址。

函数的递归

所谓递归，就是自己调用自己，编写递归函数时，一定要注意出口的设置，否则函数会无线调用下去；并且可以用递归解决的问题一定可以用循环解决。不多说，直接上个阶乘的例子

def factorial(n):
    mm = 1
    for num in range(1,n+1):
        mm *=num
    return mm

print(factorial(5))
def factorial1(n):
    if n== 1:
        return 1
    return n * factorial(n-1)
print(factorial1(5))

120
120

高阶函数

函数的参数或返回值是函数的函数，一般函数的参数是另一个函数的地址，看下面代码很好理解

def handle(func, *param):
    return func(*param)

def my_sum(*param):
    sum = 0
    for i in param:
        sum += i
    return  sum
print(my_sum(1,2,3,4,5,6))

# 函数的参数还是一个函数
print(handle(my_sum,1,2,3,4,5,6))

21
21

可能用到的高级函数

• map(func, iterator) 该函数会把可迭代对象中的数据一次传递给func函数处理,最后把处理的结果返回

def power(x):
    return x*x
result = map(power,[1,2,3,4,5,6])
print(result)
print(list(result))

[1, 4, 9, 16, 25, 36]

• reduce(func,iterator)
  reduce函数累积操作。func函数必须接收两个参数。reduce会把func的运行结果做一个参数，然后从iterator中导入另一个参数,注意，第一次会func会直接从iterator中导入两个参数作为其参数

from functools import reduce
li = [1,2,3,4,5]
result = reduce(lambda x,y:x * y,li)
print(result)

120

filter(func,inteable)

根据func来过滤interable。将interable中的数据传入函数func中如果函数返回True，就保留；否则过滤掉

li = [1,2,4,5,6,9,10,15]
result = list(filter(lambda x: x % 2 == 1,li))
print(result)

[1, 5, 9, 15]

• .doc
  可以查看函数的文档随便举两个例子就知道他的用法了

from functools import reduce
print(reduce.__doc__)
print(map.__doc__)

reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
map(func, *iterables) --> map object
Make an iterator that computes the function using arguments from
each of the iterables. Stops when the shortest iterable is exhausted.