Python3简单教程（五）函数

相关文件及后续更新会上传至：https://github.com/bloodymandoo/Python3_lesson

#Python3函数

#函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
#函数能提高应用的模块性，和代码的重复利用率。

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

#实例：
def hello():
    print("hello world!")
hello()         #return   hello world!

def area(width,height):
    return width*height
print(area(4,5))        #return  20


#可更改(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中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

#Python传不可变对象实例：
def changeInt(a):
    a = 10

b = 2
changeInt(b)
print(b)            #return  结果是2

#实例中有int对象2，指向它的变量是b，在传递给changeInt函数时，按传值得方式复制了变量b，a和b都指向了同一个int对象，
#在a=10时，则新生成一个int值对象10，并让a指向它。


#传可变对象实例
#可变对象在函数里修改了参数，那么调用这个参数的函数里，原始的参数也被改变了。例如：

def changeList(list):
    "修改传入的列表"
    list.append([1,2,3,4,5])
    print("函数内取值：",list)
    return

list = [10,20,30]
changeList(list)
print("函数外取值：",list)

#return
# 函数内取值： [10, 20, 30, [1, 2, 3, 4, 5]]
# 函数外取值： [10, 20, 30, [1, 2, 3, 4, 5]]


#调用函数时可使用的正式参数类型：
#必须参数
#关键字参数
#默认参数
#不定长度参数

#必须参数：
def printme(str):
    pass
#printme()    #return  TypeError: printme() missing 1 required positional argument: 'str'

#关键字参数
#关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
def printInfo(name,age):
    pass

printInfo(age='50',name='shayu')

#默认参数
#调用函数时，如果没有传递参数，则会使用默认参数。
def printInfo(name,age=35):
    print("名字：",name,end=" ")
    print("年龄：",age)
    return
printInfo(age=50,name='shayu')          #return 名字： shayu 年龄： 50
printInfo(name='shayu')                 #return 名字： shayu 年龄： 35


#不定长参数
#你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2中参数不同，声明时不会命名。
#基本语法如下：
# def functionname([formal_args,] *var_args_tuple):
#     function_suite
#     return [expression]
#加了星号(*)的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。
#我们也可以不向函数传递未命名的变量。如下：
def printInfo(arg1,*vartuple):
    print(arg1,end=",")
    for var in vartuple:
        print(var,end=",")
    return
printInfo(10)               #return 10,
printInfo(70,80,90)         #return 70,80,90,



#匿名函数
#Python使用Lambda来创建匿名函数。
#所谓匿名，意即不再使用def语句这样标准的形式定义一个函数。

#lambda只是一个表达式，函数体比def简单很多。
#lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
#lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
#虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈
#内存从而增加运行效率。

#语法
#lambda函数的语法只包含一个语句，如下：
# lambda[arg1[,arg2...]]:expression
#实例：
sum = lambda arg1,arg2:arg1 + arg2
print(sum(10,20))                       #return 30



#变量作用域
#Python中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
#变量的作用域决定了在哪一部分程序了可以访问哪个特别的变量名称。Python的作用域一共有4种，分别是：
#L(Local)局部作用域
#E(Enclosing)闭包函数外的函数中
#G(Global)全局作用域
#B(Built-in)内建作用域

#以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等)是不会引入新的作用域的，也就是说这些语句内定义的变量，
#外部也可以访问。



#global 和 nonlocal 关键字
#当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
#以下实例修改全局变量 num：
num = 1
def fun1():
    global num      #需要使用global关键字声明
    print(num)
    num = 123
    print(num)
fun1()
print(num)
#return
# 1
# 123
# 123

#如果要修改嵌套作用域(enclosing作用域，外层非全局作用域)中的变量则需要nonlocal关键字了，如下实例：
def outer():
    num = 10
    def inner():
        nonlocal num
        num = 100
        print(num)
    inner()
    print(num)
outer()
#return
# 100
# 100