python入门精讲笔记-10-函数

10 函数 Function

目录

• 10 函数 Function
  • 2 函数的调用
  • 3 函数的返回值
  • 4 函数的作用域
    • 4.1 函数内的变量的作用域
    • 4.2 在函数的内部使用global关键字的变量
    • 4.3 python3中的封装enclosure
      • 4.3.1 函数中嵌套函数的作用域
      • 4.3.2 Built-in
  • 5 函数的参数传递
    • 5.1 传递实参是不可变类型
    • 5.2传递实参是可变类型
    • 5.3传递可变和不可变实参的原理
  • 6 函数的参数的匹配
    • 6.1传递安装顺序传递，位置匹配
    • 6.2传递参数，按照变量的值匹配
    • 6.3默认值传递值
    • 6.4函数接收多个不确定个数的参数*arg
      • 6.4.1python在定义函数的时候，在形参的前面加上*来表明可以接收可变个数的参数：
      • 6.4.2 声明了接收可变参数，但传递的是一个元组，需解包
      • 6.4.3 函数实参为字典表

##1 函数的定义 使用关键字`def = define`来进行定义 定义函数的目的： 1.最大化代码重用，dry原则(don't repeat yourself) 2.最小化代码冗余 3.过程分解 函数的定义：`def 函数名称(形参):`

2 函数的调用

函数名称(实参)

def learning(name, course, start, end):
    print('{} is learning {}'.format(name, course))
    print('{} to {}'.format(start, end))

learning('Jerry', 'python入门经典', '2018/7', '2018/9')

3 函数的返回值

使用return来返回函数的值,python具有多态的特性，而可以实现不同类型的计算，然后返回。

def add_num(x, y): return (x + y)
print(add_num(3, 5))

例子，找出两个序列中的重复部分：
这个例子可以实现多态的特性，实参只要是序列就可以了，可以是list也可以str类型

def intersect(seq1, seq2):
    res = []

    for x in seq1:
        if x in seq2:
            res.append(x)

    return res


seqA = [1, 5, 65, 8, 4, 5, 4]
seqB = [1., 2, 45, 1, 65, 4]

print(intersect(seqA, seqB))
结果：[1, 65, 4, 4]

同样也可以通过集合set来实现得出两个不同的元素

seqA = [1, 5, 65, 8, 4, 5, 4]
seqB = [1, 2, 45, 1, 65, 4]

s1 = set(seqA) & set(seqB)
print(s1)
结果：{65, 4, 1}

4 函数的作用域

4.1 函数内的变量的作用域

1.函数里面定义的变量成为local,作用域为函数内部。
2.函数外部定义的是global全局的变量
3.另外的是built-in内置的类型，其作用域最高

# 函数内的变量的值和外部变量重复了
# 函数内的变量的作用域的问题

x = 50

def fun():
    x = 99
    return x

print('函数运行后的x的值是{}'.format(fun()))
print('全局的x的值是{}'.format(x))
结果:
函数运行后的x的值是99
全局的x的值是50

4.2 在函数的内部使用global关键字的变量

可以在函数中使用global关键字来声明该变量为全局的变量

# 函数内的变量的值和外部变量重复了
# 函数内的变量的作用域的问题

x = 50

def fun():
    global x
    x = 99
    return x

print('函数运行后的x的值是{}'.format(fun()))
print('全局的x的值是{}'.format(x))
结果：
函数运行后的x的值是99
全局的x的值是99

4.3 python3中的封装enclosure

使用场景为函数中又嵌套了函数，嵌套的函数变量和上一层的函数的变量名称相同，可以使用nonlocal关键字。
优先级的顺序：LEGB

4.3.1 函数中嵌套函数的作用域

从下面的例子可以看出函数变量的作用域，其中enclosure的优先级是最低的，其次是local,然后是global,最后是built-in

x = 10
def f1():
    x = 99
    
    def f2():
        x = 100
        print(x)
        
    print(x)  # 打印的是f1 local的x
    f2()  # 打印的是f2 local的x
    print(x)  # 打印的是f1 local的x
    
f1()
print(x)
结果：
99  # 打印的是f1的
100 # 打印的是f2的
99  # 打印的是f1的
10  # 打印的是global的

如果要在嵌套的函数中使用全局的，就使用global的关键字，如果只是想使用外侧的，就使用nonlocal的关键字来实现。

x = 10
def f1():
    x = 99
    
    def f2():
        nonlocal x
        x = 100
        print(x)
        
    print(x)  # 打印的是f1 local的x
    f2()  # 打印的是f2 local的x
    print(x)  # 打印的是f1 local的x
    
f1()
print(x)

结果：
99
100
100
10

4.3.2 Built-in

如果定义了一个方法，将built-in覆盖了，就会使用定义的函数，编写的时候特别注意，不要覆盖了built-in的函数。

5 函数的参数传递

变量类型，大致可以分为2种，一种是可变类型，另外一种是不可变类型。

5.1 传递实参是不可变类型

不可改变的类型，如int类型，作为参数传递到函数，此时是作为副本传递，实参的值是不会改变的。
例子1，传递的是一个int类型

def change_num(x):
    x += 10
x = 5
change_num(x)
print(x)
结果：
5

例子2，传递的是一个str类型

def change_num(x):
    x += 'abc'
x = 'Hellokitty'
change_num(x)
print(x)
结果：Hellokitty

5.2传递实参是可变类型

可改变类型作为实参，传递给函数，函数进行的操作，会改变可变类型的本身的值，如下的list的类型。

def change_num(x):
    x[0] = '99'
x = [1,2,3]
change_num(x)
print(x)
结果：['99', 2, 3]

如果我想传递一个list但是又不想改变，可以手动传递副本，而不是直接传递值，这里本质上浅拷贝，如果有列表嵌套也不会奏效。

def change_num(x):
    x[0] = '99'
x = [1, 2, 3]
change_num(x[:])
print(x)

5.3传递可变和不可变实参的原理

传递可变类型，实际是传递的一个值，而不可变的类型传递的是一个引用。

6 函数的参数的匹配

6.1传递安装顺序传递，位置匹配

默认情况下是安装位置的顺序进行匹配的

def func(a, b, c):
    print(a, b, c)

func(1, 2, 3)
func('a', 'b', 'c')

6.2传递参数，按照变量的值匹配

也可以通过指定参数的值来进行参数的传递

def func(a, b, c):
    print(a, b, c)
func(1, 2, 3)
func('a', 'b', 'c')
func(c=15, a=16, b=55)

6.3默认值传递值

在定义函数的时候，就可以将参数赋予默认值，在传递实参的时候可以传递部分值给形参。
但是要注意一点：定义函数的默认值只能放在最后面

def func(a, b=1, c=1):
    print(a, b, c)

func(18)
func(1,15)
结果：
18 1 1
1 15 1

6.4函数接收多个不确定个数的参数*arg

python是一个动态类型，可以传递事先不确定个数的任意参数。
没有函数的重载，但是python设计可以在声明函数时，表明可以接收任意个数的参数,其中会将多余的参数以tuple的形式传递给arg

6.4.1python在定义函数的时候，在形参的前面加上*来表明可以接收可变个数的参数：

def avg(*score):
    return sum(score) / len(score)


print(avg(99, 100, 87, 75, 62))
print(avg(87, 99, 85, 68))

6.4.2 声明了接收可变参数，但传递的是一个元组，需解包

如果函数定义可以接收可变参数，但是将参数已经全部保存在一个tuple里面了，此时如果要传递这个tuple，需要先进行解包的操作。

# 如下会报错
def avg(*score):
    return sum(score) / len(score)

t = (87., 94, 98, 78)

avg(t)
结果：
Traceback (most recent call last):
  File "D:/str_2_unicode/str_2_unicode.py", line 7, in <module>
    avg(t)
  File "D:/str_2_unicode/str_2_unicode.py", line 2, in avg
    return sum(score) / len(score)
TypeError: unsupported operand type(s) for +: 'int' and 'tuple'

正确的操作如下,需要先进行解包的操作

def avg(*score):
    return sum(score) / len(score)


t = (87., 94, 98, 78)

print(avg(*t))
结果：89.25

如下例子,将他直接进行传递，可以看到t作为一个参数被传递了，而并未被解开

def func(*args):
    print(args)

t =(1,2,3)
func(t)
func(*t)
结果：
((1, 2, 3),)
(1, 2, 3)

6.4.3 函数实参为字典表

可以在定义函数的时候使用**，将多余的参数以dict的方式来呈现。
例如，如果要处理一个员工的信息，包括 name，age，job，salary，当然可以使用4个形式参数，然后传递4个实际的参数到函数进行处理，如下：

def staff_info(name, age, job, salary):
    print(name, age, job, salary)

staff_info('Jerry',20,'dev',9000.00)
结果：Jerry 20 dev 9000.0

但是有的时候，也不太确定要传递参数的个数，并且这些参数明显是具有相关性的，可以通过传递字典表来解决这个问题。

def func(**arg)，使用**来表示将传递的多余部分以字典表方式处理
扩展阅读
https://www.cnblogs.com/xuyuanyuan123/p/6674645.html
要注意的是，传递的是一个键值对，其中键的值并不需要加上引号。

def staff_info(**kwargs):
    print(kwargs)
staff_info(name='Lucy', age=20, job='dev', salary=11000)
结果：{'salary': 11000, 'age': 20, 'job': 'dev', 'name': 'Lucy'}

如果要传递的参数本身就已经是一个dict类型，需要进行解包操作。

def staff_info(**kwargs):
    print(kwargs)
lucy_info = dict(name='Lucy', age=20, job='dev', salary=11000)
staff_info(**lucy_info)

如果不进行解包操作，则会报错：

def staff_info(**kwargs):
    print(kwargs)
lucy_info = dict(name='Lucy', age=20, job='dev', salary=11000)
staff_info(lucy_info)

Traceback (most recent call last):
  File "D:/str_2_unicode/str_2_unicode.py", line 7, in <module>
    staff_info(lucy_info)
TypeError: staff_info() takes 0 positional arguments but 1 was given