学习 Python 之 函数_fun函数python

python函数

1. 函数的作用和特性

1. 功能性
2. 隐藏细节
3. 避免编写重复代码
4. 组织代码

2. 函数的定义

def function_name(parameter_list):
    pass
1
2

parameter_list是参数列表, 可有可无

例子: 定义一个add()函数实现两个数的相加, 返回相加后的结果

def add(x, y):
    return x + y
1
2

3. 函数的定义时声明变量类型

定义函数时, 不给函数的参数类型和返回值类型, 这让其他人调用时会很疑惑

def add(参数名: 类型, ...) -> 返回值类型:
    return ...
1
2

例: 加法函数

def add(a: int, b: int) -> int:
    return a + b
1
2

注意, 变量声明类型只是方便调用者或者读者

def add(a: int, b: int) -> int:
    return a + b

print(add("1", "2"))
1
2
3
4

结果:

12
1

4. 函数返回值

使用return关键字让函数有返回值, 如果函数没有返回值, 返回值为None

(1). 返回多个值

def fun(x, y):
    return x, y
1
2

当返回值大于一个时, 返回结果是一个元组

def fun(x, y):
    return x, y
    
print(fun(1, 2))
1
2
3
4

结果为:

(1, 2)

(2). 接收返回值

第一种接收方法和使用方法(不推荐)

def fun(x, y):
    return x, y
    
result = fun(1, 2)
print(result[0], result[1])
1
2
3
4
5

第二种接收方法和使用方法(推荐)

def fun(x, y):
    return x, y
    
a, b = fun(1, 2)
print(a, b)
1
2
3
4
5

这种方法也成为序列解包

(3). 序列解包

将一个序列的值逐一把赋给其他变量

序列: 字符串、列表、元组、字典、集合

a, b, c = [1, True, 'a']
print(a, b, c) 
1
2

1, True, ‘a’

当函数有多个返回值是, 将返回一个元组, 元组是序列, 所以可以使用序列解包

a, b, c = 'abc'
print(a, b, c)
1
2

a b c

快速赋值

a, b, c = 1, 2, None
print(a, b, c)
1
2

1, 2, None

快速复制的原理也是序列解包

a = 1, 2, None
print(type(a))
1
2

<class ‘tuple’>

5. 函数参数

(1). 必须参数

函数中规定了几个参数, 调用该函数时就必须传递几个参数

def fun(x, y):
    return x, y
    
a, b = fun(1, 2)
print(a, b)
1
2
3
4
5

fun函数规定了两个参数, 调用时必须传递两个参数

(2). 关键字参数

默认情况下, 传入的参数是从左向右依次赋值的

def fun(x, y):
    return x, y
1
2

对于fun函数, 调用时fun(1, 2), 则x=1, y=2

关键字参数用来指定参数的值

def fun(x, y):
    return x, y
    
a, b = fun(y = 1, x = 2)
1
2
3
4

此时, x的值被指定为2, y的值被指定为1

(3). 默认参数

函数参数不传时有一个默认值

def fun(x, y = 2):
    return x, y
    
a, b = fun(1)
1
2
3
4

上述例子, y的值没有传入, 就为默认值

默认参数必须在必须参数的左边

下面这个例子是错误的

def fun(x, y = 2, z):
    return x, y, z
    
fun(1, 3)
1
2
3
4

正确写法

def fun(x, y, z = 2):
    return x, y, z
    
fun(1, 3)
1
2
3
4

(4). 可变参数

参数前面使用*表示该参数是可变参数, 可变参数表示, 调用该函数时, 传入的参数可以是不确定个数的

定义一个可变参数函数

def fun(*parament):
    print(parament)

fun(1, 2, 3, 4)
1
2
3
4

输出

(1, 2, 3, 4)

参数列表会转换成元组

如果传入参数为元组, 结果就会变成元组的元组

fun((1, 2, 3, 4))
1

((1, 2, 3, 4), )

如果我想传入元组, 进入函数不让它变成元组的元组, 怎么办呢?

使用*

def fun(*parament):
    print(parament)

fun((1, 2, 3, 4))
fun(*(1, 2, 3, 4))
1
2
3
4
5

结果为, 使用*后, 参数没有被转换成元组的元组

((1, 2, 3, 4),)

(1, 2, 3, 4)

(5). 关键字可变参数

如果要指定参数的名字和值, 仅使用可变参数是不行的

def fun(*para):
    print(para)

fun(a = 1, b = 2)
1
2
3
4

这样会出现错误

Traceback (most recent call last):
  File "C:\Users\Administrator\Desktop\python\demo.py", line 8, in <module>
    fun(a = 1, b = 2)
TypeError: fun() got an unexpected keyword argument 'a'
1
2
3
4

那么如何实现呢, 使用**

def fun(**para):
    print(para)

fun(a = 1, b = 2)
1
2
3
4

结果

{‘a’: 1, ‘b’: 2}

但是结果变成了字典, 所以可变关键字参数列表会被转换成字典

使用**

def fun(**para):
    for k, v in para.items():
        print(k, '-', v)

a = {
    '1': 'one',
    '2': 'two'
}

fun(**a)
1
2
3
4
5
6
7
8
9
10

1 - one

2 - two

6. 变量作用域

(1). 作用域

for循环外部可以引入for循环内部的变量, 因为python没有块级作用域

def funOne():
    c = 2
    print('one', id(c))
    def funTwo():
        c = 3
        print('two', id(c))
        print(c)
    funTwo()

funOne()
1
2
3
4
5
6
7
8
9
10

结果

one 2571382423824

two 2571382423856

3

(2). global关键字

用于将局部变量变成全局变量

def func():
    global c
    c = 2

func()
print(c)
1
2
3
4
5
6

2