python系列十：python3函数

#!/usr/bin/python
#-*-coding:gbk-*-

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

length, width = 3, 4
print("length=", length, "width=", width, "area=", area(length, width))#函数调用

'''
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
    不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
    可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
    不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。
        比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
    可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
'''
#不可变类型传参
def changeNum(b):
    b = 10
    return b
a = 5
print("before a = ", a)
print("return a = ", changeNum(a))
print("after a = ", a)

#可变类型传参
def chageList(list2):
    list2.append(["i", "love", "my", "home", {"name":"hejing"}])
    return list2
list1 = [1,2,3,4,5]
print("before list1 = ", list1)
print("return list1 = ", chageList(list1))
print("after list1 = ", list1)

'''
调用函数时可使用的正式参数类型：
    必需参数
    关键字参数
    默认参数
    不定长参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
'''
def printme1(str1):
    "打印任何传入的字符串"
    print(str1)
    return

printme1("i am needed var")
'''
printme1()
TypeError: printme() missing 1 required positional argument: 'str1'
'''

'''
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
'''
def printme2(name, str1):
    print(str1)
    print(name)
    return
printme2(str1 = "i am a key var", name = 'zhangsan')

'''
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。
'''
def printme3(name = "zhangsan", age = 50):
    print(name, end = ",")
    print(age)
    return
printme3(name = "hejing", age = 18)
printme3(name = "lisi")

'''
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
'''
def printme4(var1, *vartuples):
    "打印任何传入的参数"
    print(var1)
    for var in vartuples:
        print(var, end = " ")
    return
printme4(1)
printme4(1,2,3,4,5,6)

'''
匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数
    lambda 只是一个表达式，函数体比 def 简单很多。
    lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
    虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
'''
divid = lambda var1, var2: var1 / var2
var1, var2 = 10, 5
print(var1, "/", var2, "=", divid(var1, var2))

'''
变量作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的.
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
    L （Local） 局部作用域
    E （Enclosing） 闭包函数外的函数中
    G （Global） 全局作用域
    B （Built-in） 内建作用
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
'''
'''
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入
新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）
是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问
'''
#当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字
a = 1
def out():
    global a   # 需要使用 global 关键字声明
    print("a = ", a)
    a = 2
    print("a = ", a)
    b = 2
    print("b = ", b)
    #如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字
    def inner():
        nonlocal b   # nonlocal关键字声明
        b = 3
        print("b = ", b)
    inner()
out()

#如果没有使用global关键字，UnboundLocalError: local variable 'a' referenced before assignment
#错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。

#默认参数必须放在最后面，否则会报错或者结果错误
def printme1(age = 18, sex = 'man'):
    print("age", age, "sex", sex)
    return
printme1(23, 'woman')
printme1(23)
printme1('woman')

#def(*kwargs) 把N个关键字参数转化为字典:
def fun(country, provience, *section):
    print(country, provience, end = " ")
    for var in section:
        print(var)
fun("china", "sichuan", {"city":"chengdu", "section":"tianfuruanjianyuan"})

#lambda 匿名函数也是可以使用"关键字参数"进行参数传递
#如果只打算给其中一部分参数设定默认值，那么应当将其放在靠后的位置（和定义函数时一样，避免歧义），否则会报错。
fun2 = lambda x, y: x ** 2 + y ** 2
print(fun2(2, 3))
print(fun2(y = 3, x = 2))

'''
简单的说就是，不可更改类型传到函数里重新赋值后，两次输出值不一样，
而可更改类型传到函数里对对象的"属性" 重新赋值后输出值一样
'''

'''
对于变量作用域，变量的访问以 L（Local） –> E（Enclosing） –> G（Global） –>B（Built-in）
的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
'''

'''
内置作用域是通过一个名为builtin的标准模块来实现的，但是这个变量名自身并没有
放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:
'''
import builtins
print(dir(builtins))

#函数内可以访问全局变量，但不能更新(修改)其值！
#加上 global 引用后才可以更新变量值 。