Python笔记④ 10.24

一、函数

1.无参函数
（1）定义函数

def 函数名（）：
	代码

'''函数的调用'''
def printinfo():
    print('-'*10)
    print('人生苦短，我用python')
    print('-'*13)
printinfo()

2.有参函数

def add2num(a,b):
    c = a + b
    print(c)
add2num(13,6)

3、传参顺序

def xiu(a,b,c):#此处abc是形参
    he = a + b - c
    print(he)
xiu(33,12,5)#位置传参。此处是实参


def xiu(a,b,c):
    he = a + b - c
    print(he)
xiu(a = 33,b = 12,c = 5)#关键字传参。关键字传参不能写在位置传参前面
# xiu(a=33,12,5)会报错

'''举个例子'''
def xiu(a,b,c=5):
    print(a+b-c)
xiu(33,12)
xiu(33,12,1)#1覆盖5

def test(a, b):
    return a+b,a-b
c, d= test(2,33)
print(c, d)

4.函数的返回值

'''把两个数的和返回'''
def test(a, b):
    return a + b
c = test(1, 2)
print(c)

5.函数的嵌套

'''函数的嵌套'''
def testb():
    print('----testb start----')
    print('这里是testb执行的。。。')
    print('----testb end----')

def testa():
    print('----testa start----')
    testb()
    print('----testa end----')
testa()

二、局部变量和全局变量

c = 5
d = 233#c和d是全局变量
def two_sum(a, b):
   c = 10#局部变量，只作用于函数内部
    print(a+b-c)
two_sum(2,3)

三、修改变量

用global

c = 5
d = 233#全局变量
def two_sum(a, b):
    global c,d#局域变量更改全局变量
    # global c
    # global d

四、函数的返回值（一）

1.函数间的数据共享
全局变量在局部使用并且更改数据保存，在另一个函数里面直接使用。

a = 0
def test1():
    global a
    a = 100
def test2():
    global a
    #注意，这里没有重新定义a的值！
    print(a)
test1()
test2()

2.函数的嵌套使用

3.默认返回类型为元组，也可以返回为其他类型

def li():
    return [1,2]
a = li()
print(a)
print(type(a))

函数的返回值（二）

1.return除了能将数据返回之外，还有一个隐藏功能：结束函数

2.一个函数返回多个值

def fun(a,b):
    shang = a//b
    yushu = a%b
    return shang,yushu#默认是元组
result = fun(5,2)
print(result)#输出（2,1）

五、函数的参数

1.不定长参数
有时可能需要一个函数能处理比当初声明更多的参数，这些参数叫做不定长参数，声明时不会命名
➢*args 存放所有未命名的变量参数，args为元组
➢ **kwargs 存放命名参数，即形如key=value的参数，kwargs为字典

def fun(a,b,*args,**kwargs):
    print('a=%d'%a)
    print('b=%d'%b)
    print('args:')
    print(args)
    print('kwargs:%s'%kwargs)
fun(1,2,3,4,5,m=6,n=7,p=8)

def fun(a,b,*args,**kwargs):
    print('a=%d'%a)
    print('b=%d'%b)
    print('args:')
    print(args)
    print('kwargs:%s'%kwargs)
# fun(1,2,3,4,5,m=6,n=7,p=8)

c = (3,4,5)
d = {'m':6,'n':7,'p':8}
fun(1,2,*c,**d)
fun(1,2,c,d)

2.顺序
缺省参数、*args、关键字参数、**kwargs

六、拆包，交换变量的值

➢ 拆包时要注意，需要拆包的数据个数要与变量的个数相同，否则程序就是异常 ➢ 除了对原子拆包之外，还可以对列表，字典等拆包
注意 ：字典取出来的是key而不是键值对

'''➢ 定义一个函数接收多个参数,默认值b=1，函数的参数未知个数，把接收的所有参数加起来 
def fun(*args,b=1,**kwargs):
    he = 0
    for i in args:
        he += i
    he += b
    for k in kwargs.values():
        he += k
    print(he)
fun(1,2,3)#输出值是7'''

tu = ('小张','小刘')
a,b = tu
print(a)
print(b)#元组的拆包

a = 1
b = 2
a,b=b,a
print(a,b)#ab值互换

a, b = {'m':11,'n':22}
print(a)
print(b)#字典的拆包取key值

七、匿名函数

➢ 用lambda关键词能创建小型匿名函数

sum = lambda arg1,arg2:arg1+arg2
print('value of total:%d'%sum(10,20))
print('value of total:%d'%sum(22,3))

应用场景
1、函数作为参数传递

def fun(a,b,opt):
    print('a=%s'%a)
    print('b =%s'%b)
    print('result =%s'%opt(a,b))
fun(1,2,lambda x,y:x+y)

2、作为内置函数的参数（排序的内置函数sort）

3、按name排序

4、按age排序

stus = [{'name':'mianyi','age':18},{'name':'levi','age':23},{'name':'lihua','age':20}]
func = lambda x:x['name']
stus.sort(key=func)#sort  #name排序
print(stus)
stus.sort(key= lambda x:x['age'])#age排序
print(stus)

八、三元表达式

1、定义
➢ 三元表达式实现的效果就是，条件成立的情况下返回一个值，不成立的情况下返回另外一个值

def max2(x,y):
    # if x > y:
    #     return x
    # else:
    #     return y
    return x if x > y else y

➢res = 条件成立的情况下返回的值 if 条件 else 条件不成立的情况下返回的值三 元表达式

name = input('名字：').strip()
res = 'RUA' if name=='mianyi' else 'hangua'
print(res)

九、列表和字典生成式

1、列表生成式

names = ['lxx','zxx','wxx']
l = []
for name in names:
    res = name +'_DSB'
    l.append(res)
print(l)
#以上代码换成一行
l=[name + '_DSB' for name in names]
print(l)

2、字典生成式

dic = {}
li =['姓名','年龄','性别','QQ']
li2 = ['mianyi',18,'woman',386149176]
for i,k in zip(li,li2):
    dic[i] = k
print(dic)
print(len(dic))#len是内置函数，查看元素个数

items = [('name','egon'),('age',18)]
dic = dict(items)
print(dic)

keys = ['name','age','sex']
vals = ['jane',18,'female']
dic = {}

for i,k in enumerate(keys):#enumerate里的i是索引
    dic[k] = vals[i]
print(dic)

for i, k in zip(keys,vals):
    dic[i] = k
print(dic)

dic = {k:vals[i] for i,k in enumerate(keys)}#enumerate里的i是索引
print(dic)

dic = {i:k for i,k in zip(keys,vals)}
print(dic)