day9 函数 匿名函数 高阶函数

day9
	函数
		#值传递：实参是不可变数据类型，如number，tuble，str，bool，如果形参发生改变，实参不受影响

#引用传递：实参是可变的数据类型，如list，dict，set，如果形参发生改变内容，则实参随着改变

		#2.关键字参数
def show1(name,age):
 print("姓名：%s,年龄：%d" % (name,age))
show1("aaa",19)

#注意1：关键字来自于形参列表中的变量名
#注意2：使用了关键字参数，则传参的时候顺序可以不一致
		#3.可变参数【不定长参数】:传参的时候可以处理比声明时候更多的数据
#a.*   *xxx,xxx相当于是一个元组,xxx是元组的变量名
#注意：实参可以传递任意个数，任意类型的数据

#b.**,**xxx，xxx相当于字典，所以传参的时候必须以key=value的形式传参

#注意2：此处的传参和 关键字参数的传参区别

#注意3：不定长参数使用较多的格式为 def xxx(*args,**kwargs)

#注意4：在形参列表中，同种不定长参数只能使用一个

#注意5:在形参列表中出现不定长参数，要么尽量出现在后面 ，要么可以使用关键字参数消除歧义 
	匿名函数
		概念：不再使用def这种标准形式定义函数，而是使用lambda表达式来创建函数，该函数没有函数名，被称为匿名函数

语法：lambda  形参列表:函数体 

说明：

​	a.lambda只是一个表达式，用一行代码实现一个简单的逻辑，可以达到对函数的简化【优点】

​	b.lambda主体是一个表达式，而不是一个代码块，只能封装有限的逻辑【缺点】

​	c.lambda拥有自己的命名空间，不能访问自有列表之外或者全局命名空间里的参数
	高阶函数
		#一、map(),映射
"""
map(fn，seq)
 fn:函数
 seq：序列

功能：将fn函数作用域seq序列中每一个元素，并将新的结果返回
"""
			#1.[1,2,3,4,5]---->[1,4,9,16,25]
list1 = [1,2,3,4,5]
#方式一
newlist = [num ** 2 for num in list1]
print(newlist)

#方式二
def square(x):
 return x ** 2
#注意：函数作为参数使用，只需要传递函数名
r1 = map(square,list1)
print(r1)
newlist2 = list(r1)
print(newlist2)

#方式三
r2 = map(lambda x:x ** 2,list1)
print(list(r2))

#2.[1,2,3,4]----->["1","2","3","4"]
newlist3 = list(map(str,list1))
print(newlist3)


#3.注意：map中的函数，参数的个数和序列的个数保持一致
newlist4 = list(map(lambda x,y:x + y,[1,2,3,4],[6,7,8]))
print(newlist4)
		#二、reduce(),减少
"""
reduce(fn，seq)
 fn:函数
 seq：序列

功能：用fn的功能将序列中的每个元素进行累计

reduce(f,[a,b,c,d])
 r1 = f(a,b)
 r2 = f(r1,c)
 r3 = f(r2,d)
"""

"""
工作原理
add(1,2)--->3
add(3,3)--->6
add(6,4)--->10
"""
			#1.求一个列表中元素的和
list1 = [1,2,3,4]
#方式一
result = 0
for num in list1:
 result += num
print(result)

#方式二
def add(x,y):
 return x + y

result1 = functools.reduce(add,list1)
print(result1)
"""
工作原理
add(1,2)--->3
add(3,3)--->6
add(6,4)--->10
"""

#方式三
result2 = functools.reduce(lambda a,b:a + b,list1)
print(result2)

#2.将序列[1,3,5,7]---->1357
"""
[1,3]--->13---->1 * 10 + 3
[1,3,5]--->135--->13 * 10 + 5 
"""
def test(num1,num2):
 return num1 * 10 + num2

r1 = functools.reduce(test,[1,3,5,7])
print(r1,type(r1))

r2 = functools.reduce(lambda a,b:a * 10 + b,[1,3,5,7])
print(r2)
		#三、filter(),过滤，进行数据的筛选
"""
filter(fn，seq)
 fn:函数，提供过滤数据的条件
 seq：序列

功能：通过一定的条件过滤序列中的元素，如果fn返回True则表示数据保留，返回False则数据过滤

"""

			#将列表中的奇数剔除
list1 = [1,2,3,4,5,6,7,8,9]

def func(num):
 if num % 2 == 0:
     return True
 else:
     return False

result = filter(func,list1)    #__str__
print(result)
print(list(result))
		#四：sorted()
"""
不同点：
 列表.sort()，在原列表内部直接排序
 sorted(列表)，生成了新的列表
相同点：
 默认升序
 如果要降序，reverse=True
 如果要自定义排序规则，key=函数
"""

			#1.升序
list1 = [3,7,10,2]
list2 = sorted(list1)
print(list1)
print(list2)

#2.降序
list1 = [3,7,10,2]
list2 = sorted(list1,reverse=True)
print(list2)

#3.自定义排序规则
list1 = [3,-7,10,-2]
list2 = sorted(list1,key=abs,reverse=True)
print(list2)

list1 = ["455fsgg","ahjghakjghakjghkjag","aaa","hello"]
list2 = sorted(list1,key=len,reverse=True)
print(list2)

list1 = [{'学号': '02', '姓名': '李四', '分数': '90'}, {'学号': '03', '姓名': '王五', '分数': '70'}, {'学号': '01', '姓名': '张三', '分数': '60'}]
list1.sort(key=lambda x:int(x["分数"]),reverse=True)
print(list1)

list1 = [{'学号': '02', '姓名': '李四', '分数': '90'}, {'学号': '03', '姓名': '王五', '分数': '70'}, {'学号': '01', '姓名': '张三', '分数': '60'}]
list2 = sorted(list1,key=lambda x:int(x["分数"]))
print(list2)
		#注意：函数作为参数使用，只需要传递函数名

1.封装一个函数，函数的功能是生成指定长度的验证码

要求：由数字和大小写英文字母构成的随机字符串

def code(num=0):
    import random
    co=""
    for i in range(1,num+1):
        co+=random.choice("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789")
    return co

print(code(0))

2.封装一个函数，函数的功能是对密码加密，默认密码中只有小写字母和空格

加密规则是 a变d, b变e, c变f, …, u变x, v变y, w变z, x变a, y变b, z变c. 空格保持不变

例如: ab d ---> de g        

def password(num):
    str1="abcdefghijklmnopqrstuvwsyz"
    str2="defghijklmnopqrstuvwsyzabc"
    t=str.maketrans(str1,str2)
    num=num.translate(t)
    return num
print(password("ab d"))
#或者
def enc(code):
    #声明一个字符串用于接收加密后的结果
    result=""
    #遍历code，加密前 和  加密后 差3
    #chr()  ord()
    for ch in code:
        value = ord(ch)
        if 97<=value <=119:
            result+=chr(value+3)
        elif 120<=value<=122:
            result +=chr(value-23)
        else:
            result +=chr(value)
    return result
print(enc("sdhfjhg46846*"))

3.封装一个函数，去除指定列表中与指定数据一样的所有元素

例如: [19, 27, 32, 19, 28, 45, 19] 除去19   ----> [27, 32, 28, 45]

def dislodge(list=None,ele=None):
    for i in list[:]:
        if i==ele:
            list.remove(i)
    return list
print(dislodge([19, 27, 32, 19, 28, 45, 19],19))
#或者
def remov(list1,num):
    newlist=[]
    for i in list1:
        if i !=num:
            newlist.append(i)
    return newlist
print(remov([1,1,26,5468,8,3,1,11,35],1))

4.封装一个函数， 将指定字典中的键值交换

例如: {"a":97, "b":98} ----> {97:"a", 98:"b"}

def change(dict):
    newDict={v:k for k,v in dict.items()}
    return  newDict
print(change(dict1))

5.编写一个函数，求多个数中的最大值 要求：不能使用max系统函数

例如：17， 28， 32， 45， 67， 57 -----> 67

list1=[17, 28, 32, 45, 67, 57]

def make_max(list):
    max1=list[0]
    for i in list:
        if i>max1:
            max1=i
    return max1
print(make_max(list1))
#或者
def make_max(list):
    for i in range(len(list)-1):
        for j in range(len(list)-1-i):
            if list[j]>list[j+1]:
                list[j],list[j+1]=list[j+1],list[j]
    return list[-1]
print(make_max(list1))
#或者
def get_max(*nums):
    # nums作为元组存在
    max_value = nums[0] # 假设第一个元素是最大的
    for ele in nums:
        if ele > max_value:
            max_value = ele 
    return max_value
max_num = get_max(17, 18, 29, 32, 47, 25)
print(max_num)

6.写一个函数，默认求10的阶乘，也可以求其他数字的阶乘

def factorial(num=10):
    result = 1
    for i in range(1,num+1):
        result*=i
    return result
print(factorial(3))

7.写一个函数，将指定字符串的首字母变成大写 要求：不能使用字符串自带的方法capitalize

例如： abc ---> Abc     123abc ---> 123abc

def cap(str):
    if str[0] in "qwertyuiopasdfghjklzxcvbnm":
        str=str.replace(str[0],str[0].upper())
    return str
print(cap("abc"))

def trans(str1):
    return str1[0].upper()+str1[1:].lower()
print(trans("a454dfg"))
#或者
def trans(str1):
    result = ""
    if "a" <= str1[0] <= "z":
        result += chr(ord(str1[0])-32)+str1[1:].lower()
    else:
        result+=str1
    return result
print(trans("a454dfg"))

8.写一个函数，判断一个字符串是否已指定的字符串结束 不能使用字符串自带的方法endswith

例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
     字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
     
def judgeend_str(str1="",str2=""):
    if str1=="" or str2=="":
        return None
    if str2==str1[-len(str2):]:
        return True
    else:
        return False
print(judgeend_str('abc231ab','ab'))

9.封装一个函数，验证传入的正整数是几位数

例如：1 ---> 1          18 -----> 2       139 -----> 3

def judge(num):
    count=1
    while num//10!=0:
        num//=10
        count+=1
    return count
print(judge(1123456))

10.写一个函数，获取在指定列表中与指定数据相同的所有索引

例如：[27, 32, 51, 28, 27]  27 ------> [0,4]

list1=[27, 32, 51, 28, 27]
def get_index1(lst=None, item=''):
    tmp = []
    tag = 0
    for i in lst:
        if i == item:
            tmp.append(tag)
        tag += 1
    return tmp
print(get_index1(list1,27))
#或者
list1=[27, 32, 51, 28, 27]
def get_index1(lst=None, item=''):
    tmp = []
    for i in range(len(lst)):
        if lst[i] == item:
            tmp.append(i)
    return tmp
print(get_index1(list1,32))