函数

1.函数
    函数是对动作和功能的封装,是这段代码可以重复的利用
    语法:
    def 函数名():
        函数体
    调用:
    函数名()
2.返回值
    1.如果函数什么都不写,不写return,没有返回值,得到的是none
    2,在函数的中间或者末尾写return,返回的还是none
    3,在函数中写return值,返回一个值
    4,在函数中可以有多个返回值,return,值1,值2,值3,...接收的是元组
3,参数
    1.函数执行的时候给函数传递的信息
    2,形参:函数声明的位置变量
    3,实参:函数调用时候给你的具体值
    4,传参:把形参交给实参的过程
            实参:
                1.位置参数,按照形参的位置,给形参传值
                2,关键字参数,按照形参的名字给形参传值
                3,混合参数,即用位置参数同时又使用关键字参数

             形参:
                1.位置参数
                2.默认值参数,先位置后默认
                3.动态参数

函数定义和函数的调用

形参和实参

局部变量:
当你在一个函数的定义中声明变量时，它们不会以任何方式与身处函数之外但具有相同名称
的变量产生关系，也就是说，这些变量名只存在于函数这一局部（Local）。这被称为变量的
作用域（Scope）。所有变量的作用域是它们被定义的块，从定义它们的名字的定义点开始。
案例（保存为 function_local.py ）：
x = 50
def func(x):
print('x is', x)
x = 2
print('Changed local x to', x)
func(x)
print('x is still', x)

输出：
$ python function_local.py
x is 50
Changed local x to 2
x is still 50

它是如何工作的
当我们第一次打印出存在于函数块的第一行的名为 x 的值时，Python 使用的是在函数声明
之上的主代码块中声明的这一参数的值。
接着，我们将值 2 赋值给 x 。 x 是我们这一函数的局部变量。因此，当我们改变函数中
x 的值的时候，主代码块中的 x 则不会受到影响。
随着最后一句 print 语句，我们展示出主代码块中定义的 x 的值，由此确认它实际上不受
先前调用的函数中的局部变量的影响。

全局变量:

global 语句
如果你想给一个在程序顶层的变量赋值（也就是说它不存在于任何作用域中，无论是函数还
是类），那么你必须告诉 Python 这一变量并非局部的，而是全局（Global）的。我们需要通
过 global 语句来完成这件事。因为在不使用 global 语句的情况下，不可能为一个定义于
函数之外的变量赋值。

你可以使用定义于函数之外的变量的值（假设函数中没有具有相同名字的变量）。然而，这
种方式不会受到鼓励而且应该避免，因为它对于程序的读者来说是含糊不清的，无法弄清楚
变量的定义究竟在哪。而通过使用 global 语句便可清楚看出这一变量是在最外边的代码块
中定义的。
案例（保存为 function_global.py ）：
x = 50
def func():
global x
print('x is', x)
x = 2
print('Changed global x to', x)
func()
print('Value of x is', x)

输出：
$ python function_global.py
x is 50
Changed global x to 2
Value of x is 2

它是如何工作的
global 语句用以声明 x 是一个全局变量——因此，当我们在函数中为 x 进行赋值时，这
一改动将影响到我们在主代码块中使用的 x 的值。
你可以在同一句 global 语句中指定不止一个的全局变量，例如 global x, y, z 。

默认参数值
对于一些函数来说，你可能为希望使一些参数可选并使用默认的值，以避免用户不想为他们
提供值的情况。默认参数值可以有效帮助解决这一情况。你可以通过在函数定义时附加一个
赋值运算符（ = ）来为参数指定默认参数值。
要注意到，默认参数值应该是常数。更确切地说，默认参数值应该是不可变的——这将在后
面的章节中予以更详细的解释。就目前来说，只要记住就行了。
案例（保存为 function_default.py ）：

def say(message, times=1):
print(message * times)
say('Hello')
say('World', 5)
输出：
$ python function_default.py
Hello
WorldWorldWorldWorldWorld
它是如何工作的
名为 say 的函数用以按照给定的次数打印一串字符串。如果我们没有提供一个数值，则将按
照默认设置，只打印一次字符串。我们通过为参数 times 指定默认参数值 1 来实现这一
点。
在第一次使用 say 时，我们只提供字符串因而函数只会将这个字符串打印一次。在第二次使
用 say 时，我们既提供了字符串，同时也提供了一个参数 5 ，声明我们希望说（Say）这
个字符串五次。
注意
只有那些位于参数列表末尾的参数才能被赋予默认参数值，意即在函数的参数列表中拥
有默认参数值的参数不能位于没有默认参数值的参数之前。
这是因为值是按参数所处的位置依次分配的。举例来说， def func(a, b=5) 是有效的，
但 def func(a=5, b) 是无效的。
关键字参数
如果你有一些具有许多参数的函数，而你又希望只对其中的一些进行指定，那么你可以通过
命名它们来给这些参数赋值——这就是关键字参数（Keyword Arguments）——我们使用命
名（关键字）而非位置（一直以来我们所使用的方式）来指定函数中的参数。
这样做有两大优点——其一，我们不再需要考虑参数的顺序，函数的使用将更加容易。其
二，我们可以只对那些我们希望赋予的参数以赋值，只要其它的参数都具有默认参数值。
案例（保存为 function_keyword.py ）：

def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
func(25, c=24)
func(c=50, a=100)
输出：
$ python function_keyword.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
它是如何工作的
名为 func 的函数有一个没有默认参数值的参数，后跟两个各自带有默认参数值的参数。
在第一次调用函数时， func(3, 7) ，参数 a 获得了值 3 ，参数 b 获得了值 7 ，而 c
获得了默认参数值 10 。
在第二次调用函数时， func(25, c=24) ，由于其所处的位置，变量 a 首先获得了值 25。然
后，由于命名——即关键字参数——指定，变量 c 获得了值 24 。变量 b 获得默认参数值
5 。
在第三次调用函数时， func(c=50, a=100) ，我们全部使用关键字参数来指定值。在这里要注
意到，尽管 a 在 c 之前定义，但我们还是我们在变量 a 之前指定了变量 c 。
可变参数
有时你可能想定义的函数里面能够有任意数量的变量，也就是参数数量是可变的，这可以通
过使用星号来实现（将下方案例保存为 function_varargs.py ）：
def total(a=5, *numbers, **phonebook):
print('a', a)
#遍历元组中的所有项目
for single_item in numbers:
print('single_item', single_item)
#遍历字典中的所有项目
for first_part, second_part in phonebook.items():
print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))
函数
输出：
$ python function_varargs.py
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None

举例
它是如何工作的
当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数
（Positional Arguments）都将被收集并汇集成一个称为“param”的元组（Tuple）。
类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字
参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。
我们将在后面的章节探索有关元组与字典的更多内容。
return 语句
return 语句用于从函数中返回，也就是中断函数。我们也可以选择在中断函数时从函数中返
回一个值。
案例（保存为 function_return.py ）：
def maximum(x, y):
if x > y:
return x
elif x == y:
return 'The numbers are equal'
else:
return y
print(maximum(2, 3))
输出：
$ python function_return.py
它是如何工作的
maximum 函数将会返回参数中的最大值，在本例中是提供给函数的数值。它使用一套简单的
if...else 语句来找到较大的那个值并将其返回。
要注意到如果 return 语句没有搭配任何一个值则代表着 返回 None 。 None 在 Python 中一
个特殊的类型，代表着虚无。举个例子， 它用于指示一个变量没有值，如果有值则它的值便
是 None（虚无） 。
每一个函数都在其末尾隐含了一句 return None ，除非你写了你自己的 return 语句。你可
以运行 print(some_function()) ，其中 some_function 函数不使用 return 语句，就像这
样：
def some_function():
pass
Python 中的 pass 语句用于指示一个没有内容的语句块。
提示：有一个名为 max 的内置函数已经实现了“找到最大数”这一功能，所以尽可能地使
用这一内置函数。
DocStrings
Python 有一个甚是优美的功能称作文档字符串（Documentation Strings），在称呼它时通常
会使用另一个短一些的名字docstrings。DocStrings 是一款你应当使用的重要工具，它能够帮
助你更好地记录程序并让其更加易于理解。令人惊叹的是，当程序实际运行时，我们甚至可
以通过一个函数来获取文档！
案例（保存为 function_docstring.py ）：
def print_max(x, y):
'''Prints the maximum of two numbers.打印两个数值中的最大数。
The two values must be integers.这两个数都应该是整数'''
# 如果可能，将其转换至整数类型
x = int(x)
y = int(y)
if x > y:
print(x, 'is maximum')
else:
print(y, 'is maximum')
print_max(3, 5)
print(print_max.__doc__)
输出：
$ python function_docstring.py
5 is maximum
Prints the maximum of two numbers.
The two values must be integers.
它是如何工作的
函数的第一行逻辑行中的字符串是该函数的 文档字符串（DocString）。这里要注意文档字符
串也适用于后面相关章节将提到的模块（Modules）与类（Class） 。
该文档字符串所约定的是一串多行字符串，其中第一行以某一大写字母开始，以句号结束。
第二行为空行，后跟的第三行开始是任何详细的解释说明。在此强烈建议你在你所有重要功
能的所有文档字符串中都遵循这一约定。
我们可以通过使用函数的 __doc__ （注意其中的双下划綫）属性（属于函数的名称）来获取
函数 print_max 的文档字符串属性。只消记住 Python 将所有东西都视为一个对象，这其中
自然包括函数。我们将在后面的类（Class）章节讨论有关对象的更多细节。
如果你曾使用过 Python 的 help() 函数，那么你应该已经了解了文档字符串的用途了。它所
做的便是获取函数的 __doc__ 属性并以一种整洁的方式将其呈现给你。你可以在上方的函数
中尝试一下——只需在程序中包含 help(print_max) 就行了。要记住你可以通过按下 q 键
来退出 help 。
自动化工具可以以这种方式检索你的程序中的文档。因此，我强烈推荐你为你编写的所有重
要的函数配以文档字符串。你的 Python 发行版中附带的 pydoc 命令与 help() 使用文档字

内容回顾:

函数:是对功能或动作的封装
语法:
    def 函数名(形参):
        函数体(代码块,return)
     函数名(实参列表)
形参:在函数声明的位置是形参(变量)
    1.位置参数
    2,默认参数 (location = 北京)
    3.动态传参
        *args:位置参数的动态传参
        **kwargs:关键字参数的动态传参
        顺序:位置.*args,默认值,**kwargs
实参:在函数调用时给函数传递的信息(值)
    1.位置参数,记住位置
    2.关键字参数
    3,混合参数(先位置后关键字)
传参:把实参交给形参的过程
返回值:
    return可以终止一个函数的运行

动态传参:

动态传参举例: