Day 4

1.函数关键字

关键字
　　python中一共含有32个关键字：‘false’, ‘none’, ‘true’, ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’

–关键字-是Python内置的、具有特殊意义的表示符
　　--使用时关键字后面不需要括号
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

2.函数的定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。可以自己定义一个函数。

–函数-封装了独立功能，可以直接调用

–函数名(参数)
以下是简单的定义规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法：

def functionname( parameters ):
  "函数_文档字符串"
   function_suite
    return [expression]

3.函数参数与作用域

Python中的作用域分4种情况
1）L：local，局部作用域，即函数中定义的变量

2）E：enclosing,嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但是不是全局的

3）G：global，全局变量，就是模块级别定义的变量

4）B：built-in，系统固定模块里面的变量，比如：int，bytearray等，搜索变量的优先级顺序依次是：
作用域局部 > 外出作用域 > 当前模块中的全局变量 > python内置作用域。
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，如下代码：

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>>

实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

>>> def test():
...     msg_inner = 'I am from Runoob'
... 
>>> msg_inner
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>

从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)

以上实例输出结果：
函数内是局部变量 : 30
函数外是全局变量 : 0
global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量 num：

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()

以上实例输出结果：

1
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

以上实例输出结果：

100
100

另外有一种特殊情况，假设下面这段代码被运行：

a = 10
def test():
    a = a + 1
    print(a)
test()

以上程序执行，报错信息如下：

Traceback (most recent call last):
  File "test.py", line 7, in <module>
    test()
  File "test.py", line 5, in test
    a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。

4.函数返回值

函数需要先定义后调用，函数体中 return 语句的结果就是返回值。如果一个函数没有 reutrn 语句，其实它有一个隐含的 return 语句，返回值是 None，类型也是 ‘NoneType’。
return 语句的作用：结束函数调用、返回值
指定 return 返回值函数举例：

def showplus(x):
    print(x)
    return x + 1
     
num = showplus(6)
add = num + 2
print(add)

输出结果：

6
9

隐含 return None 举例：

def showplus(x):
    print(x)
 
num = showplus(6)
print(num)
print(type(num))

输出结果：

6
None
<class 'NoneType'>

return 语句位置与多条 return 语句
python 函数使用 return 语句返回 “返回值”，可以将其赋给其它变量作其它的用处

所有函数都有返回值，如果没有 return 语句，会隐式地调用 return None 作为返回值

一个函数可以存在多条 return 语句，但只有一条可以被执行，如果没有一条 reutrn 语句被执行，同样会隐式调用 return None 作为返回值

如果有必要，可以显式调用 return None 明确返回一个None(空值对象)作为返回值，可以简写为 return，不过 python 中懒惰即美德，所以一般能不写就不写

如果函数执行了 return 语句，函数会立刻返回，结束调用，return 之后的其它语句都不会被执行了

  def showplus(x):
      print(x)
      return x + 1
      print(x + 1)  #该语句会执行么
 
  print(showplus(6))

输出结果：

6
7

  def showplus(x):
      print(x)       # 5
      return x + 1   # 6
      return x + 2   # 该语句也不会被执行
  
  print(showplus(5))

输出结果：

5
6

for … else … 语句 （意外终止情况）
表示如果 for 语句段的内容正常循环结果才会执行 else 段的语句，如果 for 在循环过程中时被 break 或者 return 语句意外终止循环，就不会执行 else 段中的语句。

def fn(x):
    for i in range(x):
        if i > 4:
            return i
    else:
        print("{} is not greater than 4".format(x))

print(fn(3))
print(fn(6))

返回结果：

3 is not greater than 4
None
5

返回值类型
无论定义的是返回什么类型，return 只能返回单值，但值可以存在多个元素。

return [1,3,5] 是指返回一个列表，是一个列表对象，1,3,5 分别是这个列表的元素

return 1,3,5 看似返回多个值，隐式地被Python封装成了一个元祖返回

def fn():
    return 3   #单值时，返回的是什么类型
    
print(fn())
print(type(fn()))

输出结果：

3
<class 'int'>    #int 整数类型

def showlist():
    return [1,3,5]   #多元素，返回的是什么类型

print(type(showlist()))
print(showlist())

输出结果

<class 'list'>
[1, 3, 5]    #列表类型

函数嵌套
函数有可见范围(内外可见关系)，这就是作用域的概念。

内部函数不能被外部直接调用，会抛异常 NameError。

def outer():
    def inner():  #可以理解为内部函数
        print("inner")  
    print("outer")
outer()

输出结果：

outer

此时如果调用 outer()，只会执行 print(“outer”)，因为 inner 虽然在 outer 函数内，但它也是一个函数，函数如果要调用，就必须用 ‘函数名()’ 方式。

def outer():
    def inner():
        print("inner")
    print("outer")
    inner()

outer()

输出结果：

outer
inner