2020-11-7 — 2020-11-13 python的函数学习

这周学了一些python的知识点，关于函数的。

一、关于def和参数的传入

a. 参数的传递与相对位置无关，而与传递对象有关
举个栗子：

def test(a,b):
    print(a+' '+b)
test('1','2')
test(b = '1',a = '2') #参数的传递与相对位置无关，而与传递对象有关

运行结果出来分别是：

1 2
2 1

b.默认参数可以被直接使用，但默认参数要被放置于所有参数的后列
如下列代码，可知传入参数会覆盖默认参数

def add(a,b,c=3):
    print(str(a+b+c))
add(1,2,3)
add(1,2,4)
add(1,2)#默认参数可以被直接使用 但默认参数要被放置于所有参数的后列

运行结果为：

6
7
6

c. * 号 拆包操作
便于随时扩展同类型数据的处理容量，传入可增长操作，需要调用 * 进行拆包操作
比如：

def func(*num): #一个*是对元组或列表的拆包（有序序列拆包）
    for i in num:
        print(str(i))
func(1,4,6)#包裹（可增长参数）传递，以便于随时扩展同类型数据的处理容量
func(1,4,5,6)
a = [[1,4],6]
func(a)
func(*a)

运行结果如下

1
4
6
1
4
5
6
[[1, 4], 6]
[1, 4]
6

而两个 ** 符号是对字典的拆包（无序序列）
比如：

def make_car(**parameters):#两个*是对字典的拆包（对无序序列）
    for k,v in parameters.items():
        print(k + ' : '+ v)
make_car(color = 'yellow',chooss_form = 'GPS')
car_1 = {'color' : 'yellow','choose_form' : 'GPS'}	
make_car(**car_1)   #必须**进行拆包（解析字典)

运行结果如下：

color : yellow
chooss_form : GPS
color : yellow
choose_form : GPS

d.方法对传入参数的操作（是否修改传入参数的本体）
传入参数为变量是会被临时赋值给参数变量，如果传入参数是对象则会被引用。临时赋值不改变本体数据，而引用会改变本体数据。当然如果数据被gobal定义为全局数据，那它在任何地方的操作都会改变其所引用的数据。
栗子如下：

def test_2(p1,p2):
    p1 = 10
    p2.append('what')
a = 20
b = ['how']
test_2(a,b)
print(a)
for v in b:
    print(v)

运行结果如下：

20
how
what

可知临时赋值不会改变当前数值，所以a的输出结果还是20

二、zip()与zip(*）函数

可以理解为zip（）是打包为元组
而zip（*）相反可以理解为拆包或者解压

给出一个函数的应用例子：

a = [1,2,3]
b = [4,5,6]
c = [[4,5],[6,7],[8]]
zipped = list(zip(a,b))#打包
dezip = list(zip(*zipped))#解压
print(zipped)
print(dezip)
print(list(map(list,zip(*c))))
print(list(zip(*c)))

运行结果如下：

[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]
[[4, 6, 8]]
[(4, 6, 8)]

zip()函数不返回 list ，而是返回 iterable(可迭代对象)。这个可迭代对象只能进行一次迭代遍历，第二次遍历是[]（空）。

lambda 函数

语法：

lambda argument_list: expression

lambda函数是匿名的，且有输入输出，实现的功能都非常的简洁方便
看代码：

fp = lambda x,y:x+y
z = fp(1,2)
print(z)

pf = lambda x,y:(x,y)
z = pf(y=2,x=1) #关键字输入
print(z)

pp = lambda *args:sum(args)
z = pp(1,2,3,4)
print(z)

ff = lambda **args:sum([key for key in args.values()])
z = ff(a=1,b=2,c=3)
print(z)

运行结果：

3
(1, 2)	#关键字输入
10
6

定义好入口出口就好 args相当于def xx()括号里的；表达式是返回值

filter 函数

filter(fp,items) 其中fp为函数，items为序列

这个也是蛮实用的一个函数，filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

inputLst = [1,3,45,5,4]
def IsOdd(x):
    if x%2 !=0:
        return True
    else:
        return False
inputLst = list(filter(IsOdd,inputLst))
print(inputLst)

#   list(filter(lambda x:x%2!=0,inputLst)) 结合lambda函数

[1, 3, 45, 5] #筛选出奇数，形成新的序列

map函数

这个就更常用了emmm

map(function, iterable, …) 函数；一个或多个序列，返回迭代器

map() 函数会根据提供的函数对指定一个或多个序列做映射。

第一个参数 function 把参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
看代码：

inputLst = [10,63,70,85,90]
def ChToChr(x):
    if x<60:
        result = '不合格'
    elif x<70:
        result = '及格'
    elif x<80:
        result = '中等'
    elif x<90:
        result = '良好'
    else:
        result = '优秀'
    return result   #不写的话默认返回值None
inputLst = list(map(ChToChr,inputLst))
print(inputLst)

运行结果：

['不合格', '及格', '中等', '良好', '优秀']

就相当于映射 按照我的fn功能，对每个可迭代对象进行fn的这个操作

层级创建文件夹

一个简单的os模块的应用，挺好玩的

os.makedirs（）

import os
for i in range(2):
    for j in range(2):
        os.makedirs('F:/'+str(i)+'/'+str(j))