Python task06-2函数的扩展应用

目录

1.模拟sorted函数，写出过程和原理

2.模拟“矩阵”运算，给出使用自定义函数循环和使用map函数两种方案，并计算下面的“乘法”运算t1=[[1,2,3]， [4,5,6]] t2=[[11,22,33],[10,20,30]]

3.比较使用range函数和使用enumerate函数的时间效率for i in range(len(seasons)) :#使用range函数控制索引print(i, seasons[i])for i, e in enumerate(seasons) :#使用enumerate生成器对象print(i, e)

4. 比较使用itemgetter函数和使用列表推导式的时间效率

5.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]执行a_new=sorted(a)的排序过程

6.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]按第二个元素进行排序的代码

7.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]按三个元素的平均值大小进行排序的代码

8.模拟函数装饰器，对现有自定义函数加入“X时X分X秒，启动XX函数”的提示¶

---

1.模拟sorted函数，写出过程和原理

import math
def fun(ids,my_reverse=False):
    temp=ids.copy()
    for i in range(len(temp)-1):
        for j in range(i,len(temp)):
            if temp[i]>temp[j]:
                temp[i],temp[j]=temp[j],temp[i]
            if my_reverse==True and temp[j]>temp[i]:
                temp[j],temp[i]=temp[i],temp[j]
                
    return temp
    

y=[2,6,2,1,5,7,2,5,3,2,77,13,5,3,23]
x=["gs","cs","av"]
xi=fun(x,my_reverse=False)
yi=fun(y,my_reverse=True)
print(xi)
print(yi)

就sorted的原码来看是要传一个*元组和**字典，但是emmm，我不会，就这样写了一个，ids传一个列表，然后由后面的my_reverse来决定输出方式，就是代码中的那两个if，copy就是复制一份放到temp当中去

2.模拟“矩阵”运算，给出使用自定义函数循环和使用map函数两种方案，并计算下面的“乘法”运算
t1=[[1,2,3]， [4,5,6]] t2=[[11,22,33],[10,20,30]]

#自定义函数
def fun1(t1,t2):
    t3=[[1,1,1],[2,2,2]]
    for i in range(0,2):
        for j in range(0,3):
            t3[i][j]=t1[i][j]*t2[i][j]
    return t3
t1=[[1,2,3],[4,5,6]]
t2=[[11,22,33],[10,20,30]]
print(fun1(t1,t2))

t3不碍事，就是创建了一个这个样子的列表，然后将t1和t2的里面的元素的乘积赋给t3

#map函数
t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[11, 22, 33], [10, 20, 30]]

def fun2(t1,t2):
    return list(map(lambda x, y:list(map(lambda i, j: i*j, x, y)), t1,t2))
print(fun2(t1, t2))

首先要注意的就是lambda,lambda就相当于简化的def 构造函数，map就是前面接收方法，后面接收序列嘛，eg:i和j就从x和y中来，然后i*j（方法），x和y就从t1和t2中来

3.比较使用range函数和使用enumerate函数的时间效率
for i in range(len(seasons)) :#使用range函数控制索引
print(i, seasons[i])
for i, e in enumerate(seasons) :#使用enumerate生成器对象
print(i, e)

import time
 
seasons = range(100)
time1=time.time()
for i in range(len(seasons)) :#使用range函数控制索引
      print(i, seasons[i])
time2=time.time()
print(time2-time1)
time3=time.time()
for i, e in enumerate(seasons) :#使用enumerate生成器对象
      print(i, e)
time4=time.time()
print(time4-time3)

time1和time3都是开始的时间,当这个函数执行结束,就是time2和time4，开始和结束时间之间作差，就可以做到对比的效果

4. 比较使用itemgetter函数和使用列表推导式的时间效率

from operator import itemgetter
import time
def fun1():
    t1=time.time()
    for i in range(100000):
        itemgetter(0,1,3,6)(b)
    t2=time.time()
    print(t2-t1)
        
        
def fun2():
    t3=time.time()
    for i in range(100000):
        [b[x]for x in range(len(b)) if x in [0,1,3,6]]
    t4=time.time()
    print(t4-t3)
    
b=[0,10,20,30,40,50,60,70,80]
fun1()
fun2()

仿写itemgetter这个方法一定一定要注意一个问题，看下面：

def myitemgetter(*items):
    if len(items)==1:
        item=items[0]
        def getitem(obj):
            return obj[item]
    else:
        def getitem(obj):
            return tuple(obj[n] for n in items)
    return getitem
    
obj=[0,40,30,10,20,70,80,90]#这里面的顺序不能乱
s=myitemgetter(2,4)(obj)
print(s)

就是输入这个函数里面的列表，首先会帮你转成元组，这没问题，当元组的长度为1时，就直接输出这个元组本身吗，如果，你输入的列表是obj=[10],然后myitemgetter(1)(obj),输出是10，是不是感觉没毛病，但是obj=[20]，则输出20，是不是不含1却输出了20，这说明你输入的myitemgetter里面的数字不是要找的数字，而是下标，一旦obj乱了，它也会输出不含那个数字的数，我说的是仿写这个，仿写~

5.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]执行a_new=sorted(a)的排序过程

a=[[20,1,3], [40,6,2], [10,5,0]]
a_new=sorted(a)
print(a_new)

6.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]按第二个元素进行排序的代码

a=[[20,1,3], [40,6,2], [10,5,0]]
a_new=sorted(a,key=lambda x:x[1])
print(a_new)

7.使用sorted函数排序，写出对a=[[20,1,3], [40,6,2], [10,5,0]]按三个元素的平均值大小进行排序的代码

a=[[20,1,3], [40,6,2], [10,5,0]]
a_new=sorted(a, key=lambda x:int((x[0]+x[1]+x[2])/3))
print(a_new)

第五六七题没啥好说的，就直接做就可以了

8.模拟函数装饰器，对现有自定义函数加入“X时X分X秒，启动XX函数”的提示¶

import datetime

def fun1(fun):
    def fun2():
        time=datetime.datetime.now()
        print(time,",启动fun函数")
        fun()
    return fun2
@fun1
def fun():
    print("我是Superman")
fun()

我对修饰器的理解是让修改代码变得更简单，遵循着“开闭原则”，@fun1就是个注释，这下面这个函数fun的地址被上面fun1接收，fun1里面再建立一个fun2，有点像嵌套在里面，fun2则是对fun的一个“补充”