Python ❀ 函数

文章目录

• ​​1、函数定义​​

• ​​1.1 向函数传递参数​​
• ​​1.2 实参与形参​​

• ​​2、传递实参​​

• ​​2.1 位置实参​​
• ​​2.2 关键字实参​​
• ​​2.3 默认参数​​
• ​​2.4 实参错误​​

• ​​3、返回值​​

• ​​3.1 返回一个简单的值​​
• ​​3.2 实参可选​​
• ​​3.3 返回字典​​
• ​​3.4 结合while循环使用函数​​

• ​​4、传递列表​​

• ​​4.1 在函数中修改列表​​
• ​​4.2 禁止函数修改列表​​

• ​​5、传递任意数量的实参​​

• ​​5.1 结合使用位置实参和任意数量实参​​
• ​​5.2 使用任意数量的关键字实参​​

• ​​6、函数存储在模块内​​

• ​​6.1 导入整个代码模块​​
• ​​6.2 导入特定的函数​​
• ​​6.3 使用as给函数指定别名​​
• ​​6.4 使用as给模块指定别名​​
• ​​6.5 导入模块内的所有函数​​

1、函数定义

---

具有名称且能够完成某一特定功能的代码的集合被称为函数；
代码格式：

def function_name([args...]):
# 函数体
[return 返回值]
function_name()

1.1 向函数传递参数

以函数有没有参数，函数的参数要根据实际来决定是否需要参数；

• 无参函数；
• 有参函数；

# 无参函数
def no_values():
print("无参函数案例")

#有参函数
aaa = 1
def one_values(aaa):
print("有参函数案例")

#函数入口
if __name__ == '__main__':
no_values()
one_values(aaa)

1.2 实参与形参

Python环境安装完成后默认有很多函数可供直接使用，不同的函数内赋予了更多参数，以形式区分为：形参、实参两种；

• 形参：函数中定义的参数名称；
• 实参：赋予参数的值；

实参与形参的数量必须保持完全一致；

def values(aaa):
# aaa为形参
print(aaa)

if __name__ == '__main__':
# 1为实参
aaa = 1
values(aaa)

2、传递实参

---

鉴于函数定义包含多个形参，因此函数调用中也可以同时包含多个实参，向函数传递实参的方式有很多种，可以使用位置实参、关键字实参、列表、字典等方式传递参数；

2.1 位置实参

在调用函数时，Python必须将函数调用中的每个实参都关联到函数定义定义中的一个形参，最简单的关联方式就是参数的顺序，这种关联方式称之为位置实参；

def hello(aaa,bbb,ccc):
print("Hello" + aaa + bbb + ccc)

if __name__ == '__main__':
hello("_World","_is","_nice")

输出结果：

Hello_World_is_nice

上述案例中可以看出字符串World为参数aaa的值，字符串is为参数bbb的值，字符串nice为参数ccc的值，准从函数中形参的顺序，当改变其实参顺序时，结果也会发生改变；

def hello(aaa,bbb,ccc):
print("Hello" + aaa + bbb + ccc)

if __name__ == '__main__':
hello("_World","_is","_nice")
hello("_World","_nice","_is")

输出结果：

Hello_World_isnice
Hello_World_nice_is

2.2 关键字实参

在实参中将名称与值进行关联的传参方法被称为关键字实参，关键字实参不需要考虑传参的顺序，只需要准确的输入参数的名称与值即可；（在使用关键字传参时，需要准确输入传入的形参名称）

def hello(aaa,bbb,ccc):
print("Hello" + aaa + bbb + ccc)

if __name__ == '__main__':
hello(aaa="_World",ccc="_is",bbb="_nice")

输出结果：

Hello_World_nice_is

2.3 默认参数

编写函数时，可以给某些函数定义默认参数，在调用函数时若是指定值，则使用指定的值，否则使用默认值；

def hello(aaa,bbb,ccc="_test"):
print("Hello" + aaa + bbb + ccc)

if __name__ == '__main__':
hello(aaa="_World",ccc="_is",bbb="_nice")
hello(aaa="_World", bbb="_nice")

输出结果：

Hello_World_nice_is
Hello_World_nice_test

2.4 实参错误

在使用函数时，难免会触发实参不匹配的情况，因此实参错误的返回信息就比较容易判断到错误的位置；

def hello(aaa,bbb,ccc="test"):
print("Hello" + aaa + bbb + ccc)

if __name__ == '__main__':
hello()

输出结果：

Traceback (most recent call last):
File "D:\Python\Test\Source\venv\05_study_test.py", line 5, in <module>
hello()
TypeError: hello() missing 2 required positional arguments: 'aaa' and 'bbb'

类型错误：hello函数缺少2个必需的位置参数:‘aaa’和’bbb’；

3、返回值

---

函数并非总是直接显示输出，相反函数将处理的数据以一个值或一组值进行保存到某个对象中进行返回，被称为返回值，使用return语句将值返回到调用函数的代码行中；

3.1 返回一个简单的值

是否有返回值，在函数中，当遇到return关键字的时函数会立刻返回；

• 无返回值；
• 有返回值；

#有返回值函数
a = 1
def one_values(a):
print("有返回值函数案例")
b = a
return b

# 无返回值函数
def no_values(b):
print("无返回值函数案例")

if __name__ == '__main__':
b = one_values(a)
no_values(b)

3.2 实参可选

在某些函数中需要将实参变成可选择项，就需要使用默认参数进行限制；

def get_name(first,last,mid=""):
if mid:
name = first+mid+last
else:
name = first+last
print(name)
return name

if __name__ == '__main__':
get_name("z","c","x")
get_name("z","c")

输出结果：

zxc
zc

3.3 返回字典

函数可以返回任何类型的值，包含列表、字典等复杂结构的数据；

def dc(aaa,bbb,ccc):
d1 = {"1":aaa,"2":bbb,"3":ccc}
return d1

if __name__ == '__main__':
d1 = dc("z","c","x")
print(d1)

输出结果：

{'1': 'z', '2': 'c', '3': 'x'}

3.4 结合while循环使用函数

将函数与while循环结合使用，可以快速的多次调用某个函数；

def dc(aaa,bbb,ccc):
d1 = {"1":aaa,"2":bbb,"3":ccc}
return d1

if __name__ == '__main__':
while True:
aaa = input("输入:")
bbb = input("输入:")
ccc = input("输入:")
d1 = dc(aaa,bbb,ccc)
print(d1)

输出结果：

输入:1
输入:2
输入:3
{'1': '1', '2': '2', '3': '3'}
输入:4
输入:5
输入:6
{'1': '4', '2': '5', '3': '6'}

4、传递列表

---

向函数中传递列表非常有用，函数就可以直接访问列表的内容而进行其他相关操作；

def ls(name):
for name in names:
l1 = name
print(l1)

if __name__ == '__main__':
names = [1,2,3,4]
ls(names)

输出结果：

1
2
3
4

4.1 在函数中修改列表

将列表传递给函数，函数就可以对其进行修改，在函数中对于列表的修改是永久性的，因此可以通过函数进行大量的数据修改；
下面以一个例子进行展示，创建两个列表，使用循环将其中一个列表的元素写入到另一个列表内；

aaa = [1,2,3,4,5]
bbb = []

while aaa:
a = aaa.pop()
bbb.append(a)

print(bbb)

输出结果：

[5, 4, 3, 2, 1]

使用函数对操作进行划分，一个函数写入数据，另一个函数展示数据，最终调用两个函数，并赋予其列表即可；

def tihuan(aaa,bbb):
while aaa:
a = aaa.pop()
bbb.append(a)

def dayin(bbb):
print(bbb)

if __name__ == '__main__':
aaa = [1,2,3,4,5]
bbb = []
tihuan(aaa,bbb)
dayin(bbb)

输出结果：

[5, 4, 3, 2, 1]

4.2 禁止函数修改列表

某些时候需要禁止函数修改列表数据，因此向函数传递列表时，使用列表的副本，而并非列表本身，因此函数的修改只影响了副本，并非影响列表自身；切片法[:]创建列表的副本

aaa = [1,2,3,4,5]
bbb = aaa[:]

print(aaa,bbb)

输出结果：

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

5、传递任意数量的实参

---

某些情况下，不知道函数需要传入多少个参数，Python允许函数在调用时传入任意数量的参数；

def test(*aaa):
print(aaa)
print(type(aaa))

if __name__ == '__main__':
test(1,2,3,4,5,6)

输出结果：

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

5.1 结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后，Python先匹配位置实参和关键字实参，再将余下的实参都收集到某一个形参中；形参*aaa中的单个星号让Python创建一个名称为aaa的空白元组，用于接收多余的实参；

def test(a,*aaa):
print(a)
print(aaa)

if __name__ == '__main__':
test(1,2,3,4,5,6)

输出结果：

1
(2, 3, 4, 5, 6)

Python将第一个值赋给变量a，其余值赋给元组aaa；

5.2 使用任意数量的关键字实参

某些情况下，需要接受任意数量的实参，但是预先并不知道传递给函数的是什么信息，在这种情况下，可以将函数编写成能够接受任意数量的键值对；形参**info中的双星号让Python创建一个名称为info的空白字典，用于接收多余的键值对实参；

def test(first,last,**info):
aaa = {}
aaa["first_name"]=first
aaa["last_name"]=last
print(type(info))
for key,value in info.items():
aaa[key] = value
return aaa

if __name__ == '__main__':
bbb = test("111","222",a="333",b="444")
print(bbb)

输出结果：

<class 'dict'>
{'first_name': '111', 'last_name': '222', 'a': '333', 'b': '444'}

6、函数存储在模块内

---

函数的优点之一就是可以将代码块与主程序进行分离，通过给函数指定描述性的名称，可以让主程序容易被别人理解，若将函数存储在被成为模块的独立文件中，再将模块导入到主程序汇总，import语句允许当前运行的程序文件中使用模块中的代码；

6.1 导入整个代码模块

若需要函数拥有可导入性，首先需要创建模块；模块是扩展名称为.py的文件，包含要导入到程序中的代码；
首先制作一个py文件，并命名为make.py（文件存放路径需要与当前python脚本路径保持一致）；

def make_pizza(size,*aaa):
print("test!")
for aa in aaa:
print("-" + aa)

将完成的代码文件导入后进行调用；

import make

make.make_pizza("a","b","c")

输出结果：

test!
-b
-c

当Python读取到这个文件时，代码import会将make.py的代码读取到，将其中的函数都复制到这个程序之中，Python并不会回显这些复制好的函数，当这些函数被调用时，Python会在后台复制这些代码进行运行并返回其执行结果；
若使用import语句导入了某个代码文件，就可以使用这个代码文件内的所有函数；

# 导入某个模块
import [module_name]
# 使用该模块内的某个函数
[module_name].[function_name]

6.2 导入特定的函数

导入方式有两种，一种是前面直接导入所有函数，另一种是导入特定的函数进行使用；

# 导入模块内的某个函数
from [module_name] import [function_name]
# 导入多个函数
from [module_name] import [function_0]，[function_1]，[function_2]

前面的案例就可以修改为下面的代码方式，若是使用次方式导入某些函数，在使用时无需使用句号进行调用；

from make import make_pizza

make_pizza("a","b","c")

输出结果：

test!
-b
-c

6.3 使用as给函数指定别名

如果需要导入的函数名称可能与程序中的现有名称存在冲突，或者名称太长，就可以通过as语句指定一个简短且不冲突的别名；

from make import make_pizza as mp

mp("a","b","c")

输出结果：

test!
-b
-c

指定别名的通用语法：

from [module_name] import [function_name] as [alias]

6.4 使用as给模块指定别名

别名不仅可以指定函数，也支持指定到某个模块；

import make as p

p.make_pizza("a","b","c")

输出结果：

test!
-b
-c

模块指定别名的通用语法：

import [module_name] as [alias]

6.5 导入模块内的所有函数

import语句中的星号为通配符（*代表所有），因此Python可以使用星号导入某个模块的所有函数到当前的代码块中进行调用，而不需要使用句号进行调用（与直接导入模块的区别）；由于此方法导入的函数较多，函数名称大概率存在冲突，因此不推荐使用；
导入模块内所有函数的通用语法：

from [module_name] import *