函数参数/局部变量与全局变量/前向引用(函数即变量)

'''
函数参数
1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能
再使用该形参变量。
2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，
输入等办法使参数获得确定值。
3.位置参数和关键字(标准调用：实参与形参位置一一对应；关键字调用：位置无需固定)
4.默认参数
5.参数组
'''

 


def calc(x, y):
　　"""这是函数描述"""
　　res = x ** y
　　return res

msg = calc(2, 3)
print(msg)


def test(a, b, c):
　　"""这是函数描述"""
　　print(a)
　　print(b)
　　print(c)

test(1, 3, 2) #位置参数，必须一一对应，缺或多参数都不行
test(c=4, a=8, b=6) #关键字参数，无须一一对应，缺或多参数都不行
test(10, c=11, b=12) #位置参数和关键字参数混搭，位置参数必须在关键字参数左边

 

def handle(x, typle='mysql'):
　　"""这是函数描述"""
　　print(x)
　　print(typle)

# handle('hello')
handle('hello', 'Nosql')

 

#参数组：**字典，*元组
def test01(x, *args): #可处理多余的位置参数
　　print(x)
　　print(args)
　　print(args[4])

# test01(1, 2, 3, '4', 5, [6, '7'])
# test01(1, 2, 3, '4', 5, *[6, '7']) #列表元组前加*号，可把列表元组里的元素逐一添加
# test01(1, 2, 3, '4', 5, *(6, '7'))

 

def test02(y, **kwargs): #可处理多于的关键字参数
　　print(y)
　　print(kwargs)

# test02(2, q=1, w='2', e=[3, '4', (5, '6')])
# test02('3', **{'name':'alex', 'age':18, 'qq':'123321'}) #字典前加**号，可直接把key及对应value值逐一添加
# tesst02(4, z=3, z=4) #会报错：一个参数不能传两个值

 

def test03(z, *args, **kwargs): #两个参数组位置固定，因为涉及到传入实参的顺序问题，位置参数必须在关键字参数前面
　　print(z)
　　print(args)
　　print(kwargs)

test03(1, 2, 3, *['4', 5], name='alex', age=18, **{'name1':'mike', 'age1':19})

 


'''
局部变量与全局变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
全局变量变量名大写，局部变量变量名小写；
'''

 

name = 'lhf'

def change_name():
　　"""全局变量的引用"""
　　print('我的名字%s!' % name)

change_name()

 

def change_name1():
　　"""当全局变量与局部变量同名时"""
　　name = '帅哥'
　　print('我的名字%s!' % name)

change_name1()
print(name)

 

def change_name2():
　　"""global关键字定义全局变量，并作更改"""
　　global name
　　name = 'alex'
　　print('我的名字%s!' % name)

change_name2()
print(name)

 

# 解释器从上到下执行，遇到函数，默认内部不执行，只进行编译
NAME = '海风'

def huangwei():
　　name = 'huang'
　　print(name)

　　def liuyang():

　　　　'''nonlocal关键字定义上一级局部变量，并作更改'''
　　　　nonlocal name
　　　　name = 'liu'
　　　　print(name)
　　def nulige():
　　　　print(NAME)
　　nulige()
　　liuyang()
　　print(name)

huangwei()

 


'''前向引用'''

# def foo():
# 　　 print('from foo')
# 　　 bar()

# foo() #name 'bar' is nor defined

# def bar():
# 　　 print('from bar')
# 在定义foo（）函数之后bar（）函数定义之前会报错，因为调用foo（）函数的时候bar还未定义

# def foo():
# 　　 print('from foo')
#　　 bar()

# def bar():
#　　 print('from bar')

# foo()
# 在定义foo（）和bar（）之后调用foo（），虽然foo（）定义在bar（）之前，且调用了bar（），但是在python中，若不执行函数，函数并不会执行，且在调用之前已经定义了bar（），所以不会报错，这就是前向引用