函数

1.函数参数列表可以没有
  return value 没有的话就是None
2.返回多个结果
def damage(skill1,skill2):
    damage1 = skill1 * 3
    damage2 = skill2 * 2
    return damage1,damage2
damages = damage(1,2)
print(type(damages)) #tuple
skill1_damage,skill2_damage = damage(1,2)
print(skill1_damage,skill2_damage) #序列解包


3.链式赋值、序列解包
 ①三个变量接受三个数值：a,b,c = 1,2,3
 ②一个变量接受三个数值：d = 1,2,3
d是tuple类型
  序列解包： a,b,c = d，注意个数要匹配，否则报错too many value
  a=b=c=1
4.必须参数与关键字参数
 定义的时候：形式参数，调用到时候：实际参数
def add(x,y):
return x+y
add(1,2)
add(y=2,x=1)
5.默认参数
 默认参数是必须在非默认参数之前
6.可变参数
def demo(*param):
    print(param)
    print(type(param))
def demo(*param):
    print(param)
    print(type(param))
#二维元祖   
a = (1,2,3)
demo(a)
#一维元祖
demo(*a)
demo(1,2,3)
7.关键字可变参数
任意个数的关键字参数
两种传入方式：一个个的键值对；一个字典


def city_temp(**param):
    print(param)
    print(type(param))
    for city in param:
        print(city)
    for key,value in param.items():
        print(key,":",value)
city_temp(bj = "32C",sh = "40")
a = {"bj" : "32C","sh" : "40"}
city_temp(**a)


8.变量作用域
场景一：函数内部的变量只能作用域函数内部，不会改变函数外部定义变量的值
m = 100
def fuc1(x,y):
    m = x + y
    print(m)
fuc1(1,2)
print(m)   
场景二：函数外部定义的变量，是可以在函数内调用的，反过来是不行的
n = 101
def fuc2(): 
    print(n)
fuc2()
函数外部定义的变量称为全局变量
函数内部定义的变量称为是局部变量（相对概念），局部变量被赋值，不会改变全局变量
def fun3():
    c = 50
    for i in range(0,9):
        c +=1
    print(c)
fun3()      
场景三：
for循环外部是可以引用for循环内部变量的，因为python中for没有块级作用域，函数是可以形成块级作用域的
def fun4():
    c = 50
    for i in range(0,9):
        a= "a"
        c +=1
    print(c)
    print(a)
总结：全局变量：模块级别的变量，不属于任何一个函数，但是可以被多个函数引用
 局部变量：函数里面定义的变量称为局部变量，for while if else是跟函数同一个级别的，没有块级别作用域
9.作用域链
 优先找局部变量，再找全局变量
 Python中函数就是一个作用域，局部变量放置在作用域中，
 代码定义完成后，作用域已经生成，作用域链向上查找。
age = 18
def fun1():
    age = 73 
    def func2():
        print(age)
    return func2
val = fun1()
val()
out：73
10.global关键字
函数内部的变量编程全局变量
def fun5():
   global e #定义全局变量
   e = 50
fun5()
print(e)
11.其他变量
函数内部不能修改全局的字符串、数字类型、字典、列表、元祖、对象等整体变量，除非通过global关键字申明
函数内部可以修改全局的列表、元祖、对象、字典等整体变量内部的元素
因为整个列表包起来是一个内存地址，里面的每个元素又有内存地址，整体的内存地址是不能修改的，只能引用。
场景一：列表数据修改，整体赋值是无法修改的，内存地址是不一样的，跟8的字符串变量是一样的
names =["zzq1","zzq2","zzq3"]
def changenames():
    names = ["zzq1","zzq2"]
    print(id(names))
    print(names)
changenames()
print(id(names))
print(names)    
out:
39316744
['zzq1', 'zzq2']
39316616
['zzq1', 'zzq2', 'zzq3']
场景二：修改list里面的数据
#coding=utf-8
names =["zzq1","zzq2","zzq3"]
def changenames():
    del names[2]
    print("changenames函数：names的内存地址是：",id(names))
    print("changenames函数：names[0]的内存地址是：",id(names[0]))
    print("changenames函数：names[1]的内存地址是：",id(names[1]))
    print(id(names))
    print(names)
changenames()
print("模块：names的内存地址是：",id(names))
print(names)    
out：
changenames函数：names的内存地址是： 39382152
changenames函数：names[0]的内存地址是： 35557480
changenames函数：names[1]的内存地址是： 35557928
39382152
['zzq1', 'zzq2']
模块：names的内存地址是： 39382152
['zzq1', 'zzq2']
场景三：通过global申明，在函数内部改变变量，一般不建议，因为可能其他人也会使用这个全局变量，不知道在哪里被其他函数改变
names2 =["zzq1","zzq2","zzq3"]
def changenames2():
    global names2
    names2 = ["1","2"]
    print(names2)
changenames2()
print(names2)    


12.内置函数
#coding=utf-8
l = []
for i in range(0,10):
    l.append(i)
print(l)    
l[8]= 99
print(l)
#sorted函数 对list排序
print(sorted(l))


#sorted函数 对dict排序（字典本身是无须），想排序，需要先变成列表
d = {}
for i in range(20):
    d[i] = i -50
print(d)    
print(d.items())#未排序


print(sorted(d.items()))#排序了
print(sorted(d.items(),key = lambda x:x[1]))#按照value排序
d[0] = 399
print(sorted(d.items(),key = lambda x:x[1]))#按照value排序
print(sorted(d.items(),key = lambda x:x[1],reverse = True))#按照value排序