函数2

变量的作用区域（全局和局部）

def testA():
	a=100#a是局部变量
	print(a)
testA()

a=100#a是全局变量，，在函数体外面里面都可以用
def testA():
	print(a)

#在函数里面的是局部变量，但是你也可以通过修改在函数体内部修改成为全局
a=100
def  testB():
	global a
	a=200
	print(a)
print(a)#现在a就变成了全局

glo_num=0
def test1():
	global glo_num
	glo_num=100
def test2():
	print(glo_num)
test1()#声明全局变量
test2()#直接打印全局变量
print(glo_num)#全局变量的数据变为100，如果不调用就位0

#返回值作为参数传递
def test1():
	return 50
def test2(num):
	print(num)
reult=test1()
test2(result)

#一个函数多个返回值的写法
def return_num():
	return 1,2#这样写是可以的，可以返回一个元组
	#写多个return是错的
	#return(10,20,)返回元组
	#return[10,20]返回列表
	#字典元组列表都是可以的
	

位置参数：

def user_info(name,age,gender):
	print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('tom',12,'男')#传递的次数和个数必须要一致

关键字参数

def user_info(name,age,gender):
	print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('tom',age=12,gender='男')
user_info('tom',gender='男'，age=12)#关键字参数都可以，不存在顺序之分

缺省参数（默认）

def user_info(name,age,gender='男'):
	print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('tom',age=12)
user_info(name='tom',gender='女'，age=12)#修改默认值

不定长参数（可变参数）
包裹位置传递

def user_info(*args):  #*可以表示不定长参数
	print(args)#返回一个元祖

包裹关键字传递 （组包过程）

def user_info(**kwargs):  
	print(kwargs)
user_info(name='tom',gender='女'，age=12)
#打印出字典

元组拆包

def return_num():
	return 100,200#返回的是一个元组
num1,num2=return_num()
print(num1)
print(num2)

字典拆包

dict1={'name':'tom','age':18}
a,b=dict1#赋值键值对，取出来的是key
print(a)#name
print(b)#age
print(dict1[a])#tom
print(dict1[b])#18

交换变量之间的值

#复杂方法中间变量
c=0
c=a
a=b
b=c
print(a)
print(b)

#化简版
a,b=1,2
a,b=b,a#先定义一个元祖，然后进行元组拆包

引用

#可以依靠引用传递值(不可变类型）
a=1
b=a
print(b)
print(id(a))
print(id(b))#id地址，返回在内存当中的地址，是10进制的，相同的内存空间
□→      a→ b
内存地址
a=2#int类型是不可变的
print(id(a))#此时a的地址就改变了，因为不可变类型但是b的地址还是不变的

#可变类型
aa=[100,200]#     □→  a→ b
bb=aa
print(id(aa))
print(id(bb))#返回的数据类型是一样的，都是相同的地址
aa.append(30)
print(id(bb))
print(id(aa))#返回的地址依然相等因为列表是可变的类型，内存地址依然保持不变

引用当做实参去传递

def test1(a):
	print(a)
	print(id(a))
	a+=a
	print(a)
	print(id(a))
b=100
test1(b)#传进了引用
m=[11,22]
test1(m)
#地址还是不变的

可变类型：列表 字典 集合
不可变：整型 浮点型 字符串 元组