【Python简要笔记6】函数

函数可返回任何类型的值，包括列表和字典等复杂的数据结构。

定义函数

"""xx"""三个引号文档字符串注释

def greet_user():
	"""这是什么"""
	print("Hello!")
greet_user()
---ans---
Hello!

参数

带参数的函数

def greet_user(name):
	"""这是什么"""
	print("Hello!" + name)
greet_user("bob")
---ans---
Hello!bob

实参和形参

def greet_user(name):
	"""这是什么"""
	print("Hello!" + name)
name1 = "bob"
greet_user(name1)
---ans---
Hello!bob

name是形参
name1是实参

关键字实参

def greet_user(name):
	"""这是什么"""
	print("Hello!" + name)
greet_user(name="bob2")
---ans---
Hello!bob2

函数形参默认值

def greet_user(name, age="20"):
	"""这是什么"""
	print("Hello!" + name + " is " + age)
name1 = "bob"
greet_user(name1)
---ans---
Hello!bob is 20

列表作为形参

列表作为形参的定义

def greet_user(names):
	for name in names:
		print("Hello! " + name)
names1 = ["bob","lily"]
greet_user(names1)
---ans---
Hello! bob
Hello! lily

列表传递给函数后, 函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的。
修改实验

def greet_user(names):
	i = 0
	for name in names:
		print("Hello! " + name)
		names[i] = name + str(i)
		i += 1
names1 = ["bob","lily"]
greet_user(names1)
print(names1)
---ans---
Hello! bob
Hello! lily
['bob0', 'lily1']

使用切片表示法禁止修改列表

def greet_user(names):
	i = 0
	for name in names:
	print("Hello! " + name)
	names[i] = name + str(i)
	i += 1
names1 = ["bob","lily"]
names2 = names1[:]
greet_user(names2)
print(names1)
print(names2)
---ans---
Hello! bob
Hello! lily
['bob', 'lily']
['bob0', 'lily1']

切片表示法[:]创建列表的副本，对原列表进行备份，对生成的新列表进行修改不会影响到原列表。

虽然向函数传递列表的副本可保留原始列表的内容, 但除非有充分的理由需要传递副本, 否则还是应该将原始列表传递给函数, 因为让函数使用现成列表可避免花时间和内存创建副本, 从而提高效率,在处理大型列表时尤其如此。

传递任意数量的实参

Python允许函数从调用语句中收集任意数量的实参
定义

def greet_user(*names):
	print(names)
names1 = ("bob","lily")
names2 = ("bob","lily","georg","tomas")
print(names1)
print(names2)
greet_user(names1)
greet_user(names2)
---ans---
('bob', 'lily')
('bob', 'lily', 'georg', 'tomas')
(('bob', 'lily'),)
(('bob', 'lily', 'georg', 'tomas'),)

形参名*names中的星号让Python创建一个名为names的空元组, 并将收到的所有值都封装到这个元组中。
*星号作用：创建一个空元组

使用位置实参和任意数量实参
在函数定义中，将任意数量参数放在最后。先匹配位置实参和关键字实参，最后是任意参数实参。形参的位置一一对应。

def greet_user(school, *names):
	print(school + " : ")
	print(names)
names1 = ("bob","lily")
names2 = ("bob","lily","georg","tomas")
greet_user("shiyan",names1)
greet_user("diyizhongxue",names2)
---ans---
shiyan : 
(('bob', 'lily'),)
diyizhongxue : 
(('bob', 'lily', 'georg', 'tomas'),)

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

def greet_user(school1, school2,**infos):
	profile = {}
	profile['bob'] = school1
	profile['anni'] = school2
	for key, value in infos.items():
	profile[key] = value
	return profile
profiles = greet_user("shiyan", "zhognxue", lily = "shiyan")
print(profiles)
---ans---
{'bob': 'shiyan', 'anni': 'zhognxue', 'lily': 'shiyan'}

在这种情况下，函数可以接受任意数量的键-值对，可以满足任意数量的实参。
形参**infos中的两个星号，让Python创建一个名为infos的空字典，并将收到的所有键-值对都封装到这个字典中。

返回值

返回变量

def greet_user(name):
	people = "I'm " + name + " is good! "
	return people
name1 = "bob"
people = greet_user(name1)
print(people)
---ans---
I'm bob is good!

返回字典

def build(first_name, last_name):
	person = {"first": first_name, "last": last_name}
	return person
people = build("Zsss", "Asasa")
print(people)
---ans---
{'first': 'Zsss', 'last': 'Asasa'}

将函数存储在模块中

将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。
import语句允许在当前运行的程序文件中使用模块中的代码。

导入整个模块

模块是拓展名为.py的文件，包含要导入到程序中的代码。
greet.py文件

def greet_user(names):
	i = 0
	for name in names:
		print("Hello! " + name)
		names[i] = name + str(i)
		i += 1

同一目录下的文件

import greet

names = ["bob","lily","rio"]
greet.greet_user(names)
---ans---
Hello! bob
Hello! lily
Hello! rio

Python在读取导入的这个文件时，代码行import greet_user让Python打开文件greet_user.py，并将其中的所有函数都复制到这个程序中。在程序运行时，Python在幕后复制这些代码。

使用.，句点来调用导入的模块中的函数。

导入特定的函数

直接导入模块中的特定函数，如：

from module_name import function_name

首先from A import a1 是从A模块导入a1（a1可以是某个函数，全局变量以及类），import A是导入整个A模块的全部内容（包括全部的函数，全局变量以及类）。

使用逗号分隔函数名，导入任意数量的函数，如：

from module_name import function_0, function_1, function_2

实验

from greet import greet_user
names = ["bob","lily","rio"]
greet_user(names)
---ans---
Hello! bob
Hello! lily
Hello! rio

from import 不用使用句点，直接使用import的函数。

❗️❗️❗️：from β import α会在内存中创建并加载该模块工具的副本，当有另外一个程序导入时，会在内存中创建另一个副本进行加载，并不会使用同一个副本。所以程序对导入的工具（函数、类等）进行的修改并不会影响到导入的原模块，而且不同程序之间的操作也不会相互影响。

使用as给函数指定别名

给导入的函数名，指定名称。

from greet import greet_user as gu

names = ["bob","lily","rio"]
gu(names)
---ans---
Hello! bob
Hello! lily
Hello! rio

使用as给模块制定别名

import greet as gu

names = ["bob","lily","rio"]
gu.greet_user(names)
---ans---
Hello! bob
Hello! lily
Hello! rio

导入模块中的所有函数

使用星号(*)运算符可让Python导入模块中的所有函数
greet.py文件

def greet_user(names):
	i = 0
	for name in names:
		print("Hello! " + name)
		names[i] = name + str(i)
		i += 1

def hello_word():
	print("hello_word!!!!")

同一目录下的文件

from greet import *

names = ["bob","lily","rio"]
greet.greet_user(names)
hello_word()
---ans---
Hello! bob
Hello! lily
Hello! rio
hello_word!!!!

星号让Python模块中的所有函数都复制到这个程序文件中，可以直接通过名称来调用模块中的函数，不需要使用句点表示法。

❗️❗️❗️：在引入模块中注意，遇到多个相同名称的函数或者变量，会发生函数覆盖，结果不一致的情况，注意同名函数。
最好只导入需要使用的函数，或者使用句点表示法精准使用函数。