python中的函数

函数的定义

使用关键字def定义函数

python中允许嵌套定义函数，即一个函数定义的内部再定义一个函数
但是，内部定义函数，不仅要有定义，也要有调用（否则就白定义了～～）

# 如何定义一个函数
def hello():
    print('python')
    print('hello')

# 通过函数名来调用函数
hello()
hello()

def westos():
    print('it is westos')
    def python():
        print('is python')
    python()    #若没有在westos函数的定义中调用python的话，则不会输出python函数
westos()

# 定义函数的时候使用的变量叫形参(名字任意)
# 形参实际就是一个占位符，等待实参传入具体的值
def welcome(a):
    print('welcome',a)
# 真实的数据信息,调用函数的时候传递进入函数内部值的变量(参数)叫函数的实参
welcome('tom')
welcome('lily')
# welcome()

函数的形参

函数参数: 实参 形参
形参:位置参数 默认参数 可变参数 关键字参数

实际参数若没有对应的形式参数来接收（对应），会报错

# 位置参数:形参和实参必须保持一致
# 实参 向形参传递值，依靠参数位置来传递/依靠参数名称指明相应的形参传递值
def getinfo(name,age):
    print('姓名:',name,'年龄:',age)
# getinfo('westos',11)
# getinfo(11,'westos')
getinfo(age=11,name='westos')

# 默认参数
默认参数，对于原始的默认函数，进行二次封装
使得自己新定义的函数，即便少输入参数也可以正常执行。
默认参数：
当该形参未接收到数据时，以默认值执行函数。
当该参数接收到值时，以所接收到的实参的值来执行函数
def mypow(x,y=2):
    print(x ** y)
mypow(2,3)
mypow(2)

# 可变参数
输入*num 解包
def mysum(*a):      #*a 该形参接收一串整型或浮点型的值
    print(*a)
    print(a)
    sum  = 0
    for item in a:
        sum += item
    print(sum)

# mysum(1,2,3,4,5)     传入一串整型序列，可以成功调用函数
# mysum([1,2,3,4,5])   直接传入一列表，调用函数失败
nums = [1,2,3,4]
nums2 = (1,2,3,4)
nums3 = {1,2,3,4}
# 参数解包:在参数名前加*
# 却不能直接用列表,元组,集合作为实参,需要先解包(使用*符号)
mysum(*nums) # *nums:1 2 3 4
mysum(*nums2)
mysum(*nums3)

# 关键字参数
def getinfo(name,age,**k):
    print(name)
    print(age)
    print(k)
d = dict(a=1,b=2)
print(*d)
# getinfo('westos',12,**d)

函数的返回值

想让变量引用函数的结果，必须让函数将其结果作为返回值返回。
否则，函数执行完毕后，其内存地址被释放，其结果值无法被变量引用

与c不同的是，python可以有多个返回值同时返回。因为python帮我们将其封装成了一个元组类型

返回值：函数运算的结果，还需要进一步操作，就给函数的执行结果一个返回值，将其值传出函数
return用来返回函数执行的结果，如果函数没有返回值，默认返回None
一旦遇到return 函数执行结束，后面的代码不会执行
多个返回值的时候，python会帮我们封装成一个元组类型

def mypow(x,y=2):
    #print(x ** y)
    # pass
    return x**y,x+y
a = mypow(2,4)
print(a)
print(mypow(5,2))

函数的作用域

可以参考c语言中变量的生命域/作用域

a = 1
print('outside:',id(a))

def fun():
    global a #声明a为全局变量   可以再将关键字global去掉
    a = 5
    print('inside:',id(a))

fun()
print(a)
print(id(a))

#  id() 查看变量所引用的内存地址空间