python基础知识点

一.property将方法变为属性

class Student(object):

    def get_score(self):
        return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
S1=Student()
S1.set_score(59)
print(S1.get_score())


class Student(object):
    @property  #把方法变为属性
    def get_score(self):
        return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value


S1 = Student()
S1.set_score(59)
print(S1.get_score)

二.sys.argv

第一个元素sys.argv[0] 是程序本身，随后是外部给的参数

test.py代码

三.命令行解析args

import argparse
parser = argparse.ArgumentParser()
parser.parse_args()

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print（args.echo）

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', help="display a square of a given number")
args=parser.parse_args()
print(args.square**2)

发生类型错误 

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', help="display a square of a given number",type=int)
args=parser.parse_args()
print(args.square**2)

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--square', help="display a square of a given number",type=int)
args=parser.parse_args()
print(args.square**2)

四.python常见的* 与　**

1.* 可起解压迭代对象的特性

a, *b, c = range(1, 11)
print('a,b,c===', a, b, c)

a, *b, c = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]#range(1, 11)
print('a,b,c===', a, b, c)

接受不定长参数*args

# 接收不定长参数*args 
def fun_var_args(farg, *args):  
    print("arg:", farg)
    for value in args:  
        print("another arg:", value)

fun_var_args(1, 2, 3) # *args可以当作可容纳多个变量组成的list  

*args可以当作可容纳多个变量组成的list  

# 传收不定长参数*args
def fun_var_args_call(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

args = [2, 3] #list

fun_var_args_call(1, *args)

2.**  起传收不定长参数的作用　**kwargs

# 接收不定长参数**kwargs
def fun_var_kwargs(arg1, **kwargs):
    print("arg1:", arg1)
    for key in kwargs:
        print("%s: %s" % (key, kwargs[key]))


fun_var_kwargs(arg1=1, arg2=2, arg3=3) # **kwargs可以当作容纳多个key和value的dict

**kwargs可以当作容纳多个key和value的dict 

# 传收不定长参数**kwargs
def fun_var_args_call(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

kwargs = {"arg3": 3, "arg2": 2} # dictionary

fun_var_args_call(1, **kwargs)

# 接收不定长参数**kwargs
def fun_var_kwargs(arg1, **kwargs):
    print("arg1:", arg1)
    print('kwargs=',kwargs)
    for key in kwargs:
        print("%s: %s" % (key, kwargs[key]))

kwargs = {"arg3": 3, "arg2": 2} # dictionary
fun_var_kwargs(arg1=1, **kwargs) # **kwargs可以当作容纳多个key和value的dict

3. **用于字典更新

a = {1:'aaa'}
b = {2:'bb'}
res = {**a, **b}
print('==res:', res)

总结：

list变量前面加星号,字典变量前面加两个星号:

列表前面加星号作用是将列表解开成两个独立的参数，传入函数，

字典前面加两个星号，是将字典解开成独立的元素作为形参。

    def add(a, b):
        return a + b
    
    data = [4, 3]
    print(add(*data))
    data = {'a': 4, 'b': 3}
    print(add(**data))

五.sys.modules[self.__class__.__module__].__file__

#coding:utf-8
import sys
import os
class Vgg16:
    def __init__(self, vgg16_npy_path=None):
        if vgg16_npy_path is None:
            path = sys.modules[self.__class__.__module__].__file__
            print(path)
            # print path
            #上级目录
            print(os.pardir)
            path = os.path.abspath(os.path.join(path, os.pardir))
            print path
vgg=Vgg16()

sys.modules[self.__class__.__module__].__file__打印当前，.py文件的绝对路径

os.pardir打印两个..h号

两个一join就返回到上层目录

os.path.basename(__file__) 打印出当前的.py文件

六.zip

1.zip两个列表

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
print(list(zipped))
print(list(zip(*(a, b))))
print(*(a, b))

2.矩阵转置

a =[[1, 2, 3],
    [4, 5, 6]]
print(*a)

a=[1,2,3]
b=[4,5,6]
zipped=list(zip(a,b))
#压缩
print(zipped)
#解压
print(list(zip(*zipped)))

可用列表与相应的索引匹配。

line=[[6, 3], [1, 3], [2, 5]]
line=sorted(line)
print(line)
line=sorted(line,key=lambda x:x[1])
print(line)

sorted默认，第一个排序，加上x[1]才是第二个，对于zip后的列表同样适用。

classes=('back','bus')
num_classes=len(classes)
print(list(range(num_classes)))
print(list(zip(classes,list(range(num_classes)))))
a=dict(list(zip(classes, list(range(num_classes)))))
print(a)

可看出，假设img是1,4是label，则两个就形成了一一对应。

dic={'a':0,'b':3,'c':1}
res=max(dic.items(), key=lambda x: x[1])[0]
print(res)

res = sorted(dic.items(), key=lambda x: x[1])
print(res)

dict key和value互转

dict_label = {'平和': 0, '气虚': 1, '气郁': 2, '湿热': 3, '特禀': 4,
                  '痰湿': 5, '血瘀': 6, '阳虚': 7, '阴虚': 8}
print(dict_label.values(), dict_label.keys())
print(list(zip(dict_label.values(), dict_label.keys())))
dict_label_tran = dict(zip(dict_label.values(), dict_label.keys()))
print(dict_label_tran)

七.python字典in　字典无序性

1.用于判断key是否在字典中

a={}
a['b']=1

print(a)
print('b' in a)

2.update更新字典 

a={'a':1}
b={'b':2}
a.update(b)
print(a)

#合并字典
x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
print({**x, **y})

#更新字典
y.update(x)
print(y)

setdefault更新字典

a = {}
    # a.setdefault('1.xml', '/xxx/xxx/1.xml')
    # print('a:', a)
    a['1.xml'] = '/xxx/xxx/1.xml'
    a.setdefault('2.xml', '/xxx/xxx/2.xml')
    print('a:', a)

#
z = {'b': 2, 'c': 4, 'a': 1}
for key, value in z.items():
    print(key, value)
print('============or========')
for key in z:
    print(key, z[key])

#字典推导式
fruits = ['apple', 'mango', 'banana','cherry']
a={f:len(f) for f in fruits}
print(a)

3.字典排序

字典本质上是个无序的容器对象（其实Python3.6开始支持有序，不过这个有序是指按照key的添加顺序），如果我们要对字典的 key 或者 value 排序，一般是将其转换为list，再按照key或者value排序。

import operator
d = {"c": 3, "a": 1, "f":6, "b": 0}
# 按照value排序
print(sorted(d.items(), key=lambda x:x[1]))
print(sorted(d.items(), key=operator.itemgetter(1)))
print('=========================================')
# 按照key排序
print(sorted(d.items(), key=lambda x:x[0]))
print(sorted(d.items(), key=operator.itemgetter(0)))

对字典的value值排序,利用lambda找出dict的value最大值，并对value排序后，获取相应的字典

    dic = {'1666.jpg': 0.4404807686805725, '10885.jpg': 0.4567480981349945}
    print(max(dic.items(), key=lambda x: x[1]))
    print(max(dic.items(), key=lambda x: x[1])[0])
    dic=sorted(dic.items(),key=lambda x:x[1],reverse=True)
    print(dic)
    print(dict(dic))

对列表的字典排序

lis = [{"name": "Taobao", "age": 100},
       {"name": "Runoob", "age": 7},
       {"name": "Google", "age": 100},
       {"name": "Wiki", "age": 200}]

# 通过 age 升序排序
print("列表通过 age 升序排序: ")
print(sorted(lis, key=lambda i: i['age']))
print("列表通过 先age后 name 升序排序: ")
print(sorted(lis, key=lambda i: (i['age'], i['name'])))

get方法

task = [1, 1, 1, 0, 0]

task_dict = {}
for i in task:
    task_dict[i] = task_dict.get(i, 0)+1
print('task_dict:', task_dict)

4.统计列表中每个字母出现的次数

chars=['a','b','a','c','c','d']
a={}
for i in chars:
    if i in a:
        a[i]+=1
    else:
        a[i]=0
print(a)

import operator
d=sorted(a.items(), key=operator.itemgetter(1))
print(d)
print(d[-1])

八.可用于判断正符号

def choice(x):
    res=[-1,1][x>0]
    return res
res=choice(3)
print(res)
res=choice(-3)
print(res)

九.lambda 匿名函数

[:-2]指丢掉后两位

nums=[1,2,3,4,5]
print(nums[0:-2])


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

list1 = [3,5,-4,-1,0,-2,-6]
#按照绝对值大小排序
list1.sort(key=lambda x: abs(x))
print(list1)

十.random choice, 从列表或元组里随机产生一个数

import random
print("choice([1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9]))
print("choice('A String') : ", random.choice('A String'))

random.sample，从a中随机产生2个独立的元素

import random
a=np.array([[1,2],[3,4],[5,6]])
a=a.tolist()
print('a=',a)
b=random.sample(a,2)
print('b=',b)

十一.filter过滤器（函数表达式）

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
print(list(newlist))

对于python2返回的是list，而对于python3返回的是可迭代类型，这时候需要转换成list

 mask rcnn model.py里的一句话，用来冻结层

if exclude:
    layers = filter(lambda l: l.name not in exclude, layers)

十二.map映射（函数表达式）

map作用的是每个元素

def square(x):
    return x**2
res=map(square,[1,2,3,4,5])
print(res)
print(list(res))

对于python2返回的是list，python3返回的是可迭代类型，需要转换成list

答题的时候

M, N = list(map(int, input().split(',')))
print(M,N)

print(list(map(int,'10')))
print(list(map(int,'10,11'.split(','))))
print(type(input()))

l1=[1,3,5,20,9]
l2=[2,4,6,8,10]
mins=map(min,l1,l2)
print(list(mins))

map＋lambda

x = [1, 2, 3]
    y = list(map(lambda x: x + 1, x))
    print('y:',y)

十三.reduce （函数表达式）

1.列表数字和

reduce累计运算，适合做大数据的运算,reduce只能接受2个参数,作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用（累积计算).

def add(x, y):  # 两数相加
    return x + y
from functools import reduce
a=reduce(add, [1, 2, 3, 4, 5])  # 计算列表和：1+2+3+4+5
print(a)
b=reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
print(b)

2.列表合并

from functools import reduce

l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
res = reduce(lambda x, y: x+y, l)
print('==res:', res)

十四.join，用来连接列表或元组里的元素

a=['a','b','cd','d']
b=('a','b','cd','d')
str='.'
print(str.join(a))
print(''.join(b))

 一行话，将int型连起来

a=[1,2,3,4]
result=int(''.join([str(i) for i in a]))
print(result)
print(type(result))

a=int(''.join(map(str,a)))

十五.tqdm使用

from tqdm import tqdm
for i in tqdm(range(1000)):
    # do something
    pass

十六.if语句一句话

[对(x)的操作 for x in 集合 if 条件]

[对(x,y)的操作 for x in 集合1 for y in 集合2 if 条件]

#让两个list中的偶数分别相加，应该结果是2+6,4+6,2+8,4+8
x=[1,2,3,4]
y=[5,6,7,8]
res=[i+j for i in x for j in y if i%2==0 and j%2==0]
print(res)

1.常规

if a>b:
    c = a
else:
    c = b

2.表达式

c=a if a>b else b

3.二维列表

c=[b,a][a>b]

４．加上列表的if else

print([i if i == 0 else 100 for i in range(10)])

十七.装饰器

统计函数的运行时间

1，#最简单做法

import time
def func():
    print("hello")
    time.sleep(1)
    print("world")

def func_1():
    startTime = time.time()

    func()
    endTime = time.time()

    msecs = (endTime - startTime)*1000
    print("time is %d ms" %msecs)
print(func_1())

2,#模拟装饰器的写法

def deco(func):
    startTime = time.time()
    func()
    endTime = time.time()
    msecs = (endTime - startTime)*1000
    print("time is %d ms" %msecs)

def func():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':
    f = func
    deco(f)#只有把func()或者f()作为参数执行，新加入功能才会生效
    print("f.name is",f.__name__)#f的name就是func()

3,#最简陋的装饰器,先执行装饰器，在执行函数本身

def deco(func):
    def wrapper():
        startTime = time.time()
        func()
        endTime = time.time()
        msecs = (endTime - startTime)*1000
        print("time is %d ms" %msecs)
    return wrapper

@deco
def func():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':
    f = func #这里f被赋值为func，执行f()就是执行func()
    f()

4,#加参数的装饰器

def deco(func):
    def wrapper(a,b):
        startTime = time.time()
        func(a,b)
        endTime = time.time()
        msecs = (endTime - startTime)*1000
        print("time is %d ms" %msecs)
    return wrapper

@deco
def func(a,b):
    print("hello")
    time.sleep(1)
    print("world")
    print('a+b=',a+b)

if __name__ == '__main__':
    f = func #这里f被赋值为func，执行f()就是执行func()
    f(1,2)

5,#带不定参数的装饰器

def deco(func):
    def wrapper(*args,**kwargs):
        startTime = time.time()
        func(*args,**kwargs)
        endTime = time.time()
        msecs = (endTime - startTime)*1000
        print("time is %d ms" %msecs)
    return wrapper

@deco
def func(a,b):
    print("hello")
    time.sleep(1)
    print("world")
    print('a+b=',a+b)
@deco
def func2(a,b,c):
    print("hello")
    time.sleep(1)
    print("world")
    print('a+b+c=',a+b+c)

if __name__ == '__main__':
    f = func #这里f被赋值为func，执行f()就是执行func()
    f(1,2)
    func2(1,2,3)

6.使用

def compute_time_deco(function):
    def warpper(*args, **kwargs):
        st = time.time()
        res = function(*args, **kwargs)
        print('{}:spend time:{}'.format(function.__name__, time.time() - st))
        return res
    return warpper

7.统计超时装饰器

注意：使用 @functools.wraps 的目的是因为被装饰的 func 函数元信息会被替换为 wrapper 函数的元信息，而 @functools.wraps(func) 将 wrapper 函数的元信息替换为 func 函数的元信息。最终虽然返回的是 wrapper 函数，元信息却依然是原有的 func 函数.注释了也没影响。

import functools
from concurrent.futures import ThreadPoolExecutor

executor = ThreadPoolExecutor(1)
def timeout(seconds):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            future = executor.submit(func, *args, **kw)
            # print('===future.result:', future.result)
            return future.result(timeout=seconds)
        return wrapper
    return decorator

import time
@timeout(1)
def task(a, b):
    time.sleep(0.8)
    return a+b

res = task(2, 3)
print('==res:', res)

8.统计超时　类装饰器

#类装饰器
import functools
from concurrent.futures import ThreadPoolExecutor

class TimeOut:
    __executor = ThreadPoolExecutor(1)

    def __init__(self, seconds):
        self.seconds = seconds

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            future = TimeOut.__executor.submit(func, *args, **kw)
            return future.result(timeout=self.seconds)
        return wrapper

import time
@TimeOut(1)
def task(a, b):
    time.sleep(1.2)
    return a+b

res = task(2, 3)
print('==res:', res)

9.统计函数用时

import time
import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print('函数{}耗时{}s'.format(func.__name__, end - start))
        return res
    return wrapper


@log
def now():
    print('2021-7-1')
now()

10.约束某个函数的可执行次数

import functools
class allow_count:
    def __init__(self, count):
        self.count = count
        self.i = 0

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            if self.i >= self.count:
                return
            self.i += 1
            return func(*args, **kw)
        return wrapper

@allow_count(3)
def job(x):
    x += 1
    return x

for i in range(5):
    print('===job(i):', job(i))

十八.np.array,np.asarray

array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会,故改变源数据时，通过array的副本不会变化，而asarray的副本会变化。

# example 1:
data1 = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
arr2 = np.array(data1)
arr3 = np.asarray(data1)
data1[1][1] = 2
print('data1:\n', data1)
print('arr2:\n', arr2)
print('arr3:\n', arr3)

数据源为ndarray

# example 1:
data1 = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
arr2 = np.array(data1)
arr3 = np.asarray(data1)
data1[1][1] = 2
print('data1:\n', data1)
print('arr2:\n', arr2)
print('arr3:\n', arr3)

十九. 深拷贝，浅拷贝

1.对于不可变类型（数值，字符串，布尔值），无论怎么改变变量名，id值（数据的内存地址）都不会变

str1 = 'haha'
print('==str1:', id(str1))
str2 = 'haha'
print('==str2:', id(str2))

import copy
str3 = copy.copy('haha')
print('==str3:', id(str3))
str4 = copy.deepcopy('haha')
print('==str4:', id(str4))

2.对于可变类型(list dict set),虽然相同数据，但是内存仍然会开辟新的内存地址来存放相同的数据。

import copy
list1 = [1, 2, 3]
print('==id(list1):', id(list1))
list2 = [1, 2, 3]
print('==id(list2):', id(list2))

3.深浅拷贝

3.1如果只针对不可变数据类型，深浅拷贝的对象和原数据对象都是相同的内存地址

str1 = 'haha'
print('==str1:', id(str1))
str2 = str1
print('==str2:', id(str2))

import copy
str3 = copy.copy(str1)
print('==str3:', id(str3))
str4 = copy.deepcopy(str1)
print('==str4:', id(str4))

3.2对于可变类型（list dict set）深浅拷贝

3.2.1 浅拷贝

列表本身的浅拷贝对象的地址和原对象的地址是不同的，因为列表是可变数据类型。列表中的元素（第1个元素为例）和浅拷贝对象中的第一个元素的地址是相同的，因为元素本身是数值型，是不可变的。

import copy
list1 = [1, 2, 3]
print('==id(list1):', id(list1))
list2 = copy.copy(list1)
print('==id(list2):', id(list2))

print('==id(list1[0]):', id(list1[0]))
print('==id(list2[0]):', id(list2[0]))

如果列表存在嵌套，浅拷贝只拷贝最外层数据，导致最外层内存地址发生变化，而里面的内存地址不会变.

import copy
list1 = [1, 2, [3, 4, 5]]
print('==id(list1):', id(list1))
list2 = copy.copy(list1)
print('==id(list2):', id(list2))

print('==id(list1[0]):', id(list1[0]))
print('==id(list2[0]):', id(list2[0]))


print('==id(list1[-1]):', id(list1[-1]))
print('==id(list2[-1]):', id(list2[-1]))

3.2.1 深拷贝

如果列表存在嵌套，深拷贝对最外层数据是只拷贝数据，会开辟新的内存地址来存放数据。深拷贝对里面的不可变数据类型直接复制数据和地址，和可变类型的浅拷贝是相同的效果。

import copy

list1 = [1, 2, [3, 4, 5]]

list2 = copy.copy(list1)
list3 = copy.deepcopy(list1)
print('==id(list1):', id(list1))
print('==id(list2):', id(list2))
print('==id(list3):', id(list3))

print('==id(list1[0]):', id(list1[0]))
print('==id(list2[0]):', id(list2[0]))
print('==id(list3[0]):', id(list3[0]))

print('==id(list1[-1]):', id(list1[-1]))
print('==id(list2[-1]):', id(list2[-1]))
print('==id(list3[-1]):', id(list3[-1]))


list1[-1][0] = 100
print('==list1:', list1)
print('==list2:', list2)
print('==list3:', list3)
print('==id(list1[-1]):', id(list1[-1]))
print('==id(list2[-1]):', id(list2[-1]))
print('==id(list3[-1]):', id(list3[-1]))

总结：

#浅拷贝和深拷贝
#浅拷贝只拷贝父类 不拷贝子类
a={1:[1,2,3]}
print('=======原始值地址========')
print('id(a)=',id(a))
print('id(a[1])=',id(a[1]))
b=a
#复制全都一样
print('====普通赋值=====')
print('id(b)=',id(b))
print('id(b[1])=',id(b[1]))

c=a.copy()
#父类的地址不一样 因为拷贝了
print('====浅拷贝=====')
print('id(c)=',id(c))
print('id(c[1])=',id(c[1]))
d=copy.deepcopy(a)
#地址都不一样
print('====深拷贝=====')
print('id(d)=',id(d))
print('id(d[1])=',id(d[1]))

二十. getattr() 函数用于返回一个对象属性值

class A(object):
    bar=1
    def __init__(self):
        print('init')
    def train(self):
        print('call train')
if __name__ == '__main__':
    a=A()
    print(getattr(a,'bar'))
    print(getattr(a,'train')())

二十一.python特殊函数，__len()__，__getitem__()，__iter()__

len()将类变现得像list，需要重写__len__方法

class Students(object):
    def __init__(self, *args):
        self.names = args

    def __len__(self):
        return len(self.names)
student=Students('a','b','c')
print(len(student))

class Animal:
    def __init__(self, animal_list):
        self.animals_name = animal_list
    # def __getitem__(self, item):
    #     return self.animals_name[item]

animals = Animal(["dog", "cat", "fish"])
for animal in animals:
    print(animal)

报错，Python的解释器就会去寻找__getitem__ 来迭代对象。

class Animal:
    def __init__(self, animal_list):
        self.animals_name = animal_list
    def __getitem__(self, item):
        return self.animals_name[item]

animals = Animal(["dog", "cat", "fish"])
for animal in animals:
    print(animal)

for … in… 这个语句其实做了两件事。第一件事是获得一个可迭代器，即调用了__iter__()函数。 
第二件事是循环的过程，循环调用next函数。对于test这个类来说，它定义了__iter__和next函数，所以是一个可迭代的类，也可以说是一个可迭代的对象（Python中一切皆对象）。

class test():
    def __init__(self, data=1):
        self.data = data

    def __iter__(self):
        return self

    def next(self):
        if self.data > 5:
            raise StopIteration
        else:
            self.data += 1
            return self.data

for item in test(3):
    print(item)

具体实例：可用于数据加载中

数据路径：

.py文件

#coding:utf-8
import torch as t
from torch.utils import data
import os
from PIL import Image
import numpy as np

class DogCat(data.Dataset):
    def __init__(self, path):
        imgs = os.listdir(path)
        # 所有图片的绝对路径
        # 这里不实际加载图片，只是指定路径，当调用__getitem__时才会真正读图片
        self.imgs_list_path = [os.path.join(path, i) for i in imgs]

    def __getitem__(self, index):
        img_path = self.imgs_list_path[index]
        # dog->1， cat->0
        label = 1 if 'dog' in img_path.split('/')[-1] else 0
        pil_img = Image.open(img_path)
        array = np.asarray(pil_img)
        img = t.from_numpy(array)
        return img_path,img, label

    def __len__(self):
        return len(self.imgs_list_path)
if __name__ == '__main__':
    dataset = DogCat('./data/dogcat/')
    # img, label = dataset[0]  # 相当于调用dataset.__getitem__(0)
    print('len(dataset)=',len(dataset))
    for img_path,img, label in dataset:
        print(img_path,img.size(), img.float().mean(), label)

结果： 

二十二：Collections的一些功能, collections 是容器数据类型，即列表，集合，元组，字典

1.Collections counter统计列表元素出现的次数

a=[1,2,3,4,5,6,3,'a','a','a']
from collections import Counter
cnt=Counter(a)
print(cnt)
print(cnt.most_common(3))

列表中频率最高的元素

a=[1,2,3,1,2,3,2,2,4,5,1]
print(max(set(a),key=a.count))

2.检查两个字符串是不是由相同字母不同顺序组成

from collections import Counter
str1='1234abc'
str2='3421bca'
print(Counter(str1)==Counter(str2))

3.deque用于队列  基于list优化了列表两端的增删数据操作

from collections import deque

d = deque([3, 2, 4, 0])

value = d.popleft() # 左侧移除元素，O(1)时间复杂度
print('==value:', value)

value = d.pop()# 末侧移除元素，O(1)时间复杂度
print('==value:', value)

d.appendleft(3)# 左侧添加元素，O(1)时间复杂度
print('=d:', d)

d.append(5)# 末侧添加元素，O(1)时间复杂度
print('=d:', d)

4.heapq:基于list优化的一个数据结构：堆队列，也称为优先队列。堆队列特点在于最小的元素总是在根结点：heap[0] 基本用法：

import heapq
a = [3, 1, 4, 5, 2, 1]

heapq.heapify(a) #对a建堆，建堆后完成对a的就地排序
print('a[0]:', a[0])

value = heapq.nlargest(4, a) #a的前3个最大元素
print('value:', value)

value = heapq.nsmallest(4, a) #a的前3个最小元素
print('value:', value)

5. defaultdict defaultdict是一种带有默认对象工厂的dict

words = ['book', 'nice', 'great']
d = {}
for i, word in enumerate(words):
    if word in d:
        d[word].append(i)
    else:
        d[word] = [i]# 显示的创建一个list
print('==d:', d)

from collections import defaultdict
d = defaultdict(list)# 创建字典值默认为list的字典
for i, word in enumerate(words):
    d[word] = i
print('==d:', d)
print(d['book'])

省去一层if逻辑判断，代码更加清晰。上面defaultdict(list)这行代码默认创建值为list的字典，还可以构造defaultdict(set), defaultdict(dict)等等，这种模式就是对象工厂，工厂里能制造各种对象：list,set,dict...

6.ChainMap 多个dict想要合并为一个大dict,比update省内存

from collections import ChainMap

d1 = {'a':1,'c':3,'b':2}

d2 = {'d':1,' e':5}

dm = ChainMap(d1, d2)

print(dm)
print(dm['c'])
print(dm['d'])

dm['c'] = 10
print(dm)

二十三.super() 函数是用于调用父类(超类)的一个方法。

def test_super():
    class A:
         def add(self, x):
             y = x+1
             print(y)
    class B(A):
        def add(self, x):
            super().add(x)
    b = B()
    b.add(2)  #3

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')

    def bar(self,message):
        print ("%s from Parent" % message)

class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()
        print ('Child')

    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)

if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

二十四：itertools是一个包含很多面向可迭代对象的工具函数集

from itertools import product

a=[1,2,3]
b=[2,3,4]
c=[3,4,5]
def function(a,b,c):
    for i,j,k in product(a,b,c):
        print(i,j,k)
function(a,b,c) 

相当于

def function(a,b,c):
    for i in a:
        for j in b:
            for k in c:
                print(i,j,k)

二十五:读取h5

当print(data.keys())出现 KeysView(<HDF5 file "data.h5" (mode r)>)时,用遍历key的方式进行.

注意取数据时要这样Training_label[:]

import h5py
path='./fer2013/data/data.h5'
data=h5py.File(path,'r')
print(data.keys())
for i in data.keys():
    print(i)
Training_label=data['Training_label']
print(Training_label.shape)
print(Training_label[:])

二十六. 身份运算符：is，not is

is 是判断两个标识符是不是引用自一个对象

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

a = 20
b = 20
c = 30

if (a is b):
    print(" a和 b有相同的标识")
if (a is not c):
    print(" a和 c没有相同的标识")

【例子】比较的两个变量均指向不可变类型。
```python
a = "hello"
b = "hello"
print(a is b, a == b)  # True True
print(a is not b, a != b)  # False False
```

【例子】比较的两个变量均指向可变类型。
```python
a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False
```

注意：
- is, is not 对比的是两个变量的内存地址
- ==, != 对比的是两个变量的值
- 比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
- 对比的两个变量，指向的是地址可变的类型（list，dict等），则两者是有区别的。

二十七.函数的作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内置作用域（内置函数所在模块的范围）

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

if True:
    msg = 'I am from Runoob'

print(msg)

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

total = 0  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是局部变量 : ", total)
    return total
# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

以下实例修改全局变量 num

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)
    num = 123
    print(num)
fun1()
print(num)

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

二十八.os.walk

for roots,dirs,files in os.walk(rootdir):
    print('roots:',roots)
    print('files:',files)

rootdir为文件夹总目录，roots是整个文件夹的目录，files是文件夹下的图片目录

二十九.python处理txt

1.写txt

列表形式:

    with open(output_label_path, 'w', encoding='utf-8') as file:
        [file.write(val + '\n') for val in value_list]

2.读txt

    with open(train_label_path, 'r', encoding='utf-8') as file:
        for i,read_info in enumerate(file.readlines()):
            # if i<3:
                image_name=read_info.split(' ')[0]
                if image_name in os.listdir(train_path):
                    print('read_info:',read_info)

3.将gbk的txt转换成utf-8

import os
txt_name='./算法json-20190906+-+3(4)(1).txt'
output_path='./out'
if not os.path.exists(output_path):
    os.mkdir(output_path)

decode_res=[]
with open(txt_name, 'rb') as file:
    for read_info in file.readlines():
        # print(read_info.decode('gbk'))
        decode_res.append(read_info.decode('gbk'))

with open(output_path + '/' + txt_name.split('/')[-1], 'w', encoding='utf-8') as file:
    [file.write(val + '\n') for val in decode_res]

                               

三十.列表找交集，并集，差集

　　　list_a = [3,4,5,8]
	list_b = [3,4,5,6,7]
	set_c = set(list_a) & set(list_b)
	list_c = list(set_c)
	print('list_c:',list_c)
　　
    #求并集
    retC = list(set(listA).union(set(listB)))
    print "retC1 is: ",retC

    #求差集，在B中但不在A中
    retD = list(set(listB).difference(set(listA)))

三十一.使用title方法,将每个单词首字母大写

s = "programming is awesome"

print(s.title())

三十二.按照指定大小切割列表

from math import ceil

def chunk(lst, size):
    return list(
        map(lambda x: lst[x * size:x * size + size],
            list(range(0, ceil(len(lst) / size)))))
res=chunk([1,2,3,4,5],2)
print('res:',res)

三十三.合并两个字典

def merge_two_dicts(a, b):
    c = a.copy()   # make a copy of a
    c.update(b)    # modify keys and values of a with the ones from b
    return c

a = { 'x': 1, 'y': 2}
b = { 'y': 3, 'z': 4}
print(merge_two_dicts(a, b))

三十四.将列表转换成字典

def to_dictionary(keys, values):
    return dict(zip(keys, values))


keys = ["a", "b", "c"]
values = [2, 3, 4]
print(to_dictionary(keys, values))

三十五.try/except +else 子句

如果没有触发错误的话，就会运行else句子。

try:
     1==0
except TypeError:
    print("An exception was raised")
else:
    print("Thank God, no exceptions were raised.")

三十六.最常出现的列表元素

def most_frequent(list):
    return max(set(list), key = list.count)

list = [1,2,1,2,3,2,1,4,2]
res=most_frequent(list)
print('res:',res)

三十七．判断是是文件夹还是文件

os.path.isdir()
os.path.isfile()

三十八.any or all

x = [True, True, False]
    if any(x):
        print("At least one True")
    if all(x):
        print("Not one False")
    if any(x) and not all(x):
        print("At least one True and one False")

三十九.time获取当前时间

import time
    print(time.localtime())
    month = time.strftime("%Y%m", time.localtime())
    print(month)
    day = time.strftime("%Y%m%d", time.localtime())
    print(day)

四十.itertools combinations得到组合

itertools模块是用于处理迭代器的工具的集合

import itertools
    friends = ['Team 1', 'Team 2', 'Team 3', 'Team 4']
    res2 = list(itertools.combinations(friends, r=2))
    print('res2:', res2)
    res3 = list(itertools.combinations(friends, r=3))
    print('res3:', res3)

四十一.得到.py的同级目录和父级目录

import os
current_path = os.path.abspath(__file__)
# print('current_path:', current_path)
# 获取当前文件的父目录
father_path = os.path.abspath(os.path.dirname(current_path) + os.path.sep + ".")

四十二.利用requests下载文件

#将传递的pdf地址进行下载
def pdf_download():
    pdf_path = 'xxx/wKhmwl4CzhyAXW-1AHtjyiVfVwc920.pdf'
    response = requests.get(pdf_path)
    pdf = response.content
    with open('./test_pdf.pdf', 'wb') as f:
        f.write(pdf)

四十三．利用requests直接发送文件

#将pdf拆成img发送给后端
def pdf_img_send():
    img_path = './test_jiekou/test.png'
    with open(img_path, "rb") as f:
        files = {"file": f} #注意这个连接　后端没有写完到时候需要换
        r = requests.post('url', files=files)
        # r.raise_for_status()
    print('r.json():', r.json())
    return r.json()

四十四.利用base64发送文件以及解析base64成图片

import json
import os
import requests
import base64
def json_send(url,dataPModel):
    # header = {"Content-type": "application/json", "Accept": "text/plain", "charset": "UTF-8"}
    header = {'Content-Type': 'application/json', 'token': 'token1'}
    # header = {'Content-Type': 'application/json','token':'WrKEkskh'}
    response = requests.post(url=url,headers = header, data=json.dumps(dataPModel))#,
                             #data=json.dumps(dataPModel))
    # print('response:', response)
    return json.loads(response.text)

def convert(o):
    if isinstance(o, np.generic):return o.item()
    raise TypeError

def xunzhenhan_test_img():
    url = 'xxxxx'
    dataPModel = {}

    img_path = './test_jiekou_img/15637681196627742_0.jpg'
    with open(img_path, "rb") as f:  # 转为二进制格式
        data_base64 = base64.b64encode(f.read()).decode()  # 使用base64进行加密
    with open('img_data_base64.txt', 'w', encoding='utf-8') as file:
        file.write(data_base64)

    dataPModel['encode_data'] = data_base64
    dataPModel['extract'] = 1
    # print("dataPModel['mode']:", dataPModel['mode'])

    result = json_send(url, dataPModel)
    print('result:', result)
    with open('result_img.json', 'w+') as fp:
        json.dump(result, fp=fp, ensure_ascii=False, default=convert, indent=4, separators=(',', ': '))

data_base64 = request.json['encode_data']
img = Image.open(io.BytesIO(base64.b64decode(data_base64)))
img = img.convert("RGB")
img = np.array(img)[..., ::-1]

四十五.判断日期是否合格

import time
def is_valid_date(date_str):
  '''判断是否是一个有效的日期字符串'''
  try:
    time.strptime(date_str, "%Y-%m-%d")
    return date_str
  except:
    return time.strftime('%Y-%m-%d', time.localtime(time.time()))
res=is_valid_date('2019-10-32')
print('res:',res)

四十六.监控GPU

class Monitor(Thread):
    def __init__(self, delay):
        super(Monitor, self).__init__()
        self.stopped = False
        self.delay = delay  # Time between calls to GPUtil
        self.run()

    def run(self):
        while not self.stopped:
            GPUtil.showUtilization()
            time.sleep(self.delay)

    def stop(self):
        self.stopped = True


# Instantiate monitor with a 10-second delay between updates
monitor = Monitor(10)

四十七.shutil操作文件夹

存在文件夹就删除

# 若文件夹不存在，创建文件夹，若存在，删除重建
def mkr(path):
    import shutil
    if os.path.exists(path):
        shutil.rmtree(path)
        os.mkdir(path)
    else:
        os.mkdir(path)

四十八.python模块collections中namedtuple(),类似c语言中的struct

from collections import namedtuple
h_fc7, h_relu5_3, h_relu4_3, h_relu3_2, h_relu2_2 = 1, 2, 3, 4, 5
vgg_outputs = namedtuple("VggOutputs", ['fc7', 'relu5_3', 'relu4_3', 'relu3_2', 'relu2_2'])
out = vgg_outputs(h_fc7, h_relu5_3, h_relu4_3, h_relu3_2, h_relu2_2)
print('==out:', out)
print('=out.fc7:', out.fc7)
for out_ in out:
    print('==out_:', out_)

四十八.python脚本调用sh清理缓存

例如:清理缓存脚本 vim cleanCache.sh

#!/bin/bash
# 每一小时清除一次缓存
echo "开始清除缓存"
sync;sync;sync #写入硬盘，防止数据丢失
sleep 10 #延迟10秒
echo 3 > /proc/sys/vm/drop_caches

python脚本

import sys
import os
import time

while 1:
    os.system('./cleanCache.sh')
    time.sleep(30*60)

四十九.生成字符画

import cv2
str = 'mqpka89045321@#$%^&*()_=||||}'# 字符表
im = cv2.imread('111.png')    # 读取图像
grey = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)    # 灰度转换
grey = cv2.resize(grey, (50, 18))    # 缩小图像
img_h, img_w = grey.shape
str_img = ''    # 用于装字符画
for i in range(img_h):
    for j in range(img_w):
        index = int(grey[i, j] / 256 * len(str))  # 获取字符坐标
        str_img += str[index]  # 将字符添加到字符画中
    str_img += '\n'
print(str_img)

五十.python的一些类方法

1.实例方法

最常见的一种方法，参数名一般为self,通过它来传递实例的属性和方法，（也可以传类的属性和方法），调用时只能由实例对象调用。

2.call方法

类实例化时进行自动调用,类似函数调用

class Reader:
    def __init__(self, name, nationality):
        self.name = name
        self.nationality = nationality

    def __call__(self, age):
        print('姓名:{},国籍:{},年龄:{}' .format(self.name, self.nationality, age))

r = Reader('Annie','中国')
r('18')

3.类方法

使用装饰器@classmethod修饰，参数名一般cls,通过它来传递类属性和方法，不能传递实例的属性和方法，调用是类和实例对象都能调用

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls):
        cls.__num += 1

    @classmethod
    def getNum(cls):
        return cls.__num

    # 这里我用到魔术方法__new__，主要是为了在创建实例的时候调用累加方法。
    def __new__(self):
        ClassTest.addNum()
        return super(ClassTest, self).__new__(self)


class Student(ClassTest):
    def __init__(self):
        self.name = ''

a = Student()
b = Student()
print(ClassTest.getNum())

4.静态方法

使用装饰器@staticmethod修饰，静态方法是类中的函数。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。调用是类和实例对象都能调用

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


print('==TimeTest.showTime():', TimeTest.showTime())

time.sleep(2)
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print('==nowTime:', nowTime)

五十一.python的一些魔法方法

1.__doc__方法

class Solution:
    def answer(self, what):
        self.what = what

s = Solution()
print('==Solution.__doc__:', Solution.__doc__)       #表示类的描述信息
print('==s.__module__:', s.__module__) #表示当前操作的对象在那个模块
print('==s.__class__:', s.__class__)   #表示当前操作的对象的类是什么

2.__dict__方法

类或者对象的所有属性

class Solution:
    def __init__(self, what):
        self.what = what
    # def answer(self, what):
    #     self.what = what

s = Solution("hha")
print('===Solution.__dict__:', Solution.__dict__)
print('===s.__dict__:', s.__dict__)

3.__init__()与__new__()方法

__new__() 创建对象时调用，会返回当前对象的一个实例

__init__() 创建完对象后调用，对当前对象的一些实例进行初始化

class Solution:
    def __init__(self, what):
        print('__init__() called')
        print('==init what', what)
    def __new__(cls, *args, **kwargs):
        print('__new__() called')
        print('==cls:', cls)
        print('==args:', args)
        print('==kwargs:', kwargs)
        return super().__new__(cls)

s = Solution(what="hahah")

4.__call__方法

类实例化时进行自动调用,类似函数调用

class Reader:
    def __init__(self, name, nationality):
        self.name = name
        self.nationality = nationality

    def __call__(self, age):
        print('姓名:{},国籍:{},年龄:{}' .format(self.name, self.nationality, age))

r = Reader('Annie','中国')
r('18')

5.__str__方法

如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Solution:
    def __init__(self, what):
        self.what = what
    def __str__(self):
        return '===打印对象时，就打印这里的值'

s = Solution("hha")
print('==s:', s)

class Solution:
    def __init__(self, what):
        self.what = what
    # def __str__(self):
    #     return '===打印对象时，就打印这里的值'

s = Solution("hha")
print('==s:', s)

6.用于索引操作，如字典。

用于切片操作，如列表。

6.1用于字典

class MyDict:

    def __init__(self):
        self.my_dict = dict()

    def __getitem__(self, key):
        print('调用__getitem__():', key)
        print('==self.my_dict:', self.my_dict)
        return self.my_dict.get(key, None)

    def __setitem__(self, key, value):
        print('调用__setitem__():', key, value)
        self.my_dict[key] = value

    def __delitem__(self, key):
        print('调用__delitem__():', key)
        del self.my_dict[key]

mydict = MyDict()
print("===mydict['name']===", mydict['name'])  #调用__getitem__方法
mydict['name'] = 'Damin'  #调用__setitem__方法
mydict['age'] = '12' #调用__setitem__方法
print("===mydict['name']===", mydict['name'])  #调用__getitem__方法
print("===mydict['age']===", mydict['age'])  #调用__getitem__方法
del mydict['name']
print("===mydict['name']===", mydict['name'])  #调用__getitem__方法

6.2用于列表

class MyList(object):

    def __init__(self):
        self.mlist = list()

    def __getitem__(self, index):
        print('__getitem__() called:')
        if isinstance(index, slice):
            return self.mlist[index]

    def __setitem__(self, index, value):
        print('__getitem__() called:')
        print(index, value)
        if isinstance(index, slice):
            self.mlist[index] = value

    def __delitem__(self, index):
        print('__delitem__()called:')
        if isinstance(index, slice):
            del self.mlist[index]

mlist =  MyList()

mlist[:] = [1, 2, 3]
print('==mlist[:2]:', mlist[:2])

五十一.datetime使用

today = datetime.date.today()
pre_day = today - datetime.timedelta(days=12)#往前推12天
print('==today:', today)
print('==pre_day:', pre_day)
dir_time = datetime.date(2020, 7, 3)
print('==dir_time:', dir_time)

if dir_time > pre_day and dir_time < today:
    print('在这12天中!!!!')

五十二.eval函数

def hah(a, b):
    print(a+b)

loss_name = 'hah'
kwargs = {'a': 3, 'b': 4}
eval(loss_name)(**kwargs)

五十三.find方法

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

五十四.types.MethodType函数的用法分析

MethodType函数可以将外部函数绑到一个类和实例中。

1.绑定到实例中

from types import MethodType

class Student(object):
    pass


def set_score(self, score):
    self.score = score


s1 = Student()
s2 = Student()

s1.set_score = MethodType(set_score, s1) #把外部函数绑到实例s1中
s1.set_score(99)
print('==s1.score:', s1.score)
print('==s2.score', s2.score)

可看出只绑定了s1,故s2调用会报错

2.绑定到类中

from types import MethodType

class Student(object):
    pass


def set_score(self, score):
    self.score = score
s1 = Student()
s2 = Student()

Student.set_score = MethodType(set_score, Student)
Student.set_score(99)
print('==Student.score:', Student.score)
print('==s1.score:', s1.score)
print('=s2.score:', s2.score)

s1.set_score(88)
print('==Student.score:', Student.score)
print('==s1.score:', s1.score)
print('=s2.score:', s2.score)

s2.set_score(77)
print('==Student.score:', Student.score)
print('==s1.score:', s1.score)
print('=s2.score:', s2.score)

可看出等效成为了类方法，实例化的对象都能取到值。

五十五.post请求二进制

    pid = 'yf6yuy6y6dgy'
    img_path = './test_jiekou/test.png'
    import time
    start_time = time.time()
    with open(img_path, "rb") as f:
        files = {"file": f}#注意这块url到时候和后端联调需要换掉
        r = requests.post('http://ip:port/file/upload?pId={}'.format(pid), files=files)

五十六.下载二进制

    pdf_path = 'http://ip:port/group1/M00/00/00/wKhmwl4CzhyAXW-1AHtjyiVfVwc920.pdf'
    response = requests.get(pdf_path)
    pdf = response.content
    with open('./test_pdf.pdf', 'wb') as f:
        f.write(pdf)

五十七.partial

from functools import partial

def multi_apply(func, *args, **kwargs):
    """Apply function to a list of arguments.

    Note:
        This function applies the ``func`` to multiple inputs and
        map the multiple outputs of the ``func`` into different
        list. Each list contains the same type of outputs corresponding
        to different inputs.

    Args:
        func (Function): A function that will be applied to a list of
            arguments

    Returns:
        tuple(list): A tuple containing multiple list, each list contains \
            a kind of returned results by the function
    """
    # print('=*args:', *args) #[1, 2, 3] [2, 3, 4]
    # print('=kwargs:', kwargs) #{'z': 10}
    # 注册入默认参数z = 10
    pfunc = partial(func, **kwargs) if kwargs else func
    map_results = map(pfunc, *args)
    #*map_results  (20, 30) (60, 50) (120, 70) 解压可迭代对象
    #list(zip(*map_results)) [(20, 60, 120), (30, 50, 70)]
    return tuple(map(list, zip(*map_results)))#([20, 60, 120], [30, 50, 70])

def multiply(x, y, z):
    return x * y * z, x + y + z

a = [1, 2, 3]
b = [2, 3, 4]

res = multi_apply(multiply, a, b, z=10)
print('=res:', res)

五十八:快速搭建ftp服务器

共享ftp

# python2
python -m SimpleHTTPServer 8888
# python3
python3 -m http.server 8888

五十九.python -i 出问题即可调试

from functools import lru_cache
@lru_cache(None)
def add(x, y):
    print("calculating: %s + %s" % (x, y))
    return x / y
print(add(1, 2))
print(add(1, 2))
print(add(2, 3))
print(add(2, 0))

输入 import pdb;pdb.pm() 即可开始调试,就不需要出问题了,在输入import pdb;pdb.set_trace()在重新执行程序. 

六十.pretty-errors 出错显示彩色信息

pip install pretty-errors

python  -m pretty_errors
 

六十一.python 调用shell命令

import os
def main():
    path = './cache/result_videos_track_multiframe_keypoint_box_euro_11_17_frame5'
    videos_list_path = [os.path.join(path, i) for i in os.listdir(path)]
    for i, video_list_path in enumerate(videos_list_path):
        print(video_list_path)
        name = path.split('/')[-1].split('_')[-1]
        output_path = video_list_path+name+'ffmpeg.mp4'
        cmd = """ffmpeg -i {} -crf 27 -filter:v "setpts=0.5*PTS" -vcodec h264 {}""".format(video_list_path, output_path)
        # print('==cmd:', cmd)
        rst = os.popen(cmd).read()
        # """ffmpeg -i $1 -crf 27 -filter:v "setpts=0.25*PTS" -vcodec h264 $2"""
if __name__ == '__main__':
    main()