Python函数

#Python函数
#定义函数: 以def开头 + 函数名称 + 圆括号()
#参数置于()内, 函数内容以冒号起始, 并且缩进
#return结束函数, 可以返回一个值, 或者不写返回None
def hello():
    print("Hello World!")


hello()

def area(width, height):
    return width * height

w, h = 4, 5
print("width=", w, " height:", h, " area:", area(w, h))


#参数传递, 对于Python, 数据可以分为不可改变对象, 和可变对象
#如果在向函数传递了不可变对象, 那么, 在函数内部对这个参数的更新, 不会改变原本的对象
#相反, 如果是可变对象, 在函数内部对这个参数做了改变, 会改变原来的对象
def changeInt(a):
    a = 10
    return

b = 2
changeInt(b) #因为int不是可变对象, 所以b不会改变
print(b) #2

def changeMe(myList):
    myList.append([1, 2, 3, 4])
    return

myList = [0]
changeMe(myList) #因为list是可变对象, 所以myList会被改变
print("结果:", myList) #[0, [1, 2, 3, 4]]

#函数的参数, 参数必须要写, 如果写参数名,则顺序不需要保持一直, 否则顺序需保持一直
def printInfo(name, age):
    print("名字:", name)
    print("年龄:", age)
    return

printInfo('leviathan', 20)
printInfo(age=30, name='francis')

#参数的默认值, 创建函数的时候, 可以设置参数的默认值, 那么如果没有传入该参数, 就可以使用默认值了
def printInfo(name, age = 35):
    print("名字:", name)
    print("年龄:", age)
    return
printInfo(name='james')

#不定长参数, 第一个参数必须指定,
# 不定长参数以*开头, 将会以元组的形式导入
# 不定长参数以**开头, 将会以字典形式导入
def printInfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print("arg1:", arg1, "  vartuple:", vartuple)

printInfo(70, 60,90) #arg1: 70   vartuple: (60, 90)


def printinfo(arg1, **vardict):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1) #1
    print(vardict) #{'a': 2, 'b': 3}

printinfo(1, a=2, b=3)

#lambda表达式, 简化了函数的定义方式, 同时返回函数对象, 可以当做参数进行传递
sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 20))

#变量的作用域
#变量的搜寻顺序是 局部作用域-> 闭包函数外的函数中-> 全局作用域-> 内建作用域
#if/elif/else/try/except/for/while不改变作用域, 也就是说这些语句内定义的变量, 外部也是可以访问的

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

if True:
    msg = 'i am from mars'
print(msg) #i am from mars

#函数修改全局变量(可变对象, 才会可能在函数内部修改, 不可变对象, 无法在函数内部修改)
#这一点和java是不同的
#如果需要修改外部作用域的不可变对象, 那么需要用global 和 nonlocal关键字

total = 0
li = []
def sum(arg1, arg2):
    total = arg1 + arg2
    li.append(arg1)
    print("内部total:", total) #30
    print("内部li:", li) #[10]
    return
sum(10, 20)
print("外部total:", total) #0
print("外部li:", li) #[10]

#   修改全局不可变对象
num = 1
def fun1():
    global num
    num = 123
    print(num) #123
fun1()
print(num) #123

#   修改外层嵌套作用域不可变对象
def outer():
    num = 10
    def inner():
        nonlocal num
        num = 100
        print(num) #100
    inner()
    print(num) #100
outer()