python 面向对象、多线程、多进程等

#MyDict

class MyDict(dict):
    def __getattr__(self, item): #魔法方法 #是这个对象在没有某个属性的话，会调用它
        value = self.get(item)
        if type(value) == dict:
            value = MyDict(value)
        if isinstance(value,list) or isinstance(value,tuple):
            #isinstance 判断数据类型
            value = list(value)
            for index,v in enumerate(value):
                if isinstance(v,dict):
                    value[index] = MyDict(v)
        return value

    def __setattr__(self, key, value): #实例化重新赋值时会调用该方法
        # value = self.get(key)
        # if type(value) ==MyDict:
        self[key] = value
        print("setattr",key,value)


    #魔法方法
d1 = {"name":"wkf","addr":"北京","info":{"city":"深圳","cars":{"name":"bmw"}},
      "phones":({"name":"huawei","price":50000},{"name":"xiaomi","price":11})
      }

d = MyDict(d1)
print(d.phones[0].name)
print(d.phones[0].price)

d.name = "ljq"
print(d.name) #修改成功

d.info.city = "中国"
print(d.info.city) #没有修改成功

 

重写requests类:

import requests
import traceback
from loguru import logger

# class MyDict(dict):
#     def __getattr__(self, item):
#         value = self.get(item)
#         if type(value) == dict:
#             value = MyDict(value)
#         if isinstance(value,list) or isinstance(value,tuple):
#             value = list(value)
#             for index,v in enumerate(value):
#                 if isinstance(v,dict):
#                     value[index] = MyDict(v)
#         return value
# class MyRequest:
#     def __init__(self,url,params=None,data=None,headers=None,files=None,json=None):
#         self.url = url
#         self.params = params
#         self.data = data
#         self.headers = headers
#         self.files = files
#         self.json = json
#
#     def get(self):
#         logger.debug("url:{},params:{},headers:{}",self.url,self.params,self.headers)
#         try:
#             self.resonpse = requests.get(self.url,params=self.params,headers=self.headers,verify=False)
#         except:
#             logger.error("接口不通，请求出错,错误信息是:{}",traceback.format_exc())
#             return MyDict()
#         try:
#             ret = self.resonpse.json()
#         except:
#             logger.warning("接口返回的不是json！无法转成字典！response：{}",self.resonpse.content)
#             return MyDict()
#         logger.debug("接口返回数据:{}",ret)
#         return MyDict(ret)
#
#     def post(self):
#         logger.debug("url:{},params:{},data:{},json:{},files:{},headers:{}",self.url,self.params,self.data,self.json,self.files,self.headers)
#         try:
#             self.resonpse = requests.post(self.url,params=self.params,
#                                           json=self.json,data=self.data,files=self.files,headers=self.headers,verify=False)
#         except:
#             logger.error("接口不通，请求出错,错误信息是:{}",traceback.format_exc())
#             return MyDict()
#         try:
#             ret = self.resonpse.json()
#         except:
#             logger.warning("接口返回的不是json！无法转成字典！response：{}",self.resonpse.content)
#             return MyDict()
#         logger.debug("接口返回数据:{}",ret)
#         return MyDict(ret)




class MyDict(dict):
    def __getattr__(self, item):
        value = self.get(item)
        if type(value) == dict:
            value = MyDict(value)
        if isinstance(value,list) or isinstance(value,tuple):
            value = list(value)
            for index,v in enumerate(value):
                if isinstance(v,dict):
                    value[index] = MyDict(v)
        return value


class MyRequest:
    def __init__(self,url,params=None,data=None,headers=None,files=None,json=None,timeout=5):
        self.url = url
        self.params = params
        self.data = data
        self.headers = headers
        self.files = files
        self.json = json
        self.timeout = timeout
    def __get_response(self):
        try:
            ret = self.response.json()
        except:
            logger.warning("接口返回的不是json！无法转成字典！response：{}", self.response.content)
            return MyDict()
        logger.debug("接口返回数据:{}", ret)
        return MyDict(ret)

    def __request(self,method):
        logger.debug("url:{},params:{},data:{},json:{},files:{},headers:{}",self.url,self.params,self.data,self.json,self.files,self.headers)
        try:
            self.response = requests.request(method,url=self.url,params=self.params,data=self.data,
                             json=self.json,headers=self.headers,files=self.files,verify=False,timeout=self.timeout)
        except:
            logger.error("接口不通，请求出错,错误信息是:{}",traceback.format_exc())
            return MyDict()

        return self.__get_response()

    def get(self):
        return self.__request("get")
    def post(self):
        return self.__request("post")
    def put(self):
        return self.__request("put")
    def delete(self):
        return self.__request("delete")
if __name__ == '__main__':
    # r = MyRequest("https://api.apiopen.top/getWangYiNews?count=1")
    # result = r.get()
    # ret1 = r.post()
    data = {"file": open("myDict.py", 'rb')}
    r = MyRequest("http://118.24.3.41/api/file/file_uploa", files=data)
    # result = r.get()
    ret1 = r.post()

 

找出2个字符串之间的字符：

from collections import defaultdict

def find_str(string:str):
    #abcsdgsf1s23f
    str_index_map = defaultdict(list) #{s:[3,6],f:[9,12,13]}
    [str_index_map[s].append(index) for index,s in enumerate(string) if string.count(s) > 1 ]
    #{s:[3,6],f:[9,12,13]}
    count = 1
    for index_list in str_index_map.values(): #2 range(0,1)
        for index in range(len(index_list) - 1): #处理重复次数大于2的
            start_index = index_list[index] #开始的下标
            end_index = index_list[index+1] #结束的下标
            target_str = string[start_index:end_index+1]  #通过开始和结束的下标取值
            target_str_len = len(target_str) - 2
            print("%s.    %s    %s" % (count,target_str,target_str_len))
            count+=1


    # for index,s in enumerate(string):
    #     if string.count(s)>1:
    #         str_index[s].append(index)


if __name__ == '__main__':
    s  = "abcsdgdsf1s23f"
    #
    find_str(s)

 

面向对象各种方法：

import time
class Car:
    country = "China" #类变量，公共的，随着类定义

    @staticmethod #定义静态方法，和普通方法没有区别，只是定义在类里，它无法使用类方法，实例方法，类变量
    def say():
        # Car.country #只能通过类调用
        print("heiehi")

    @classmethod #声明类方法，不用实例化也能调用,但不能调用类里的实例方法和实例变量
    def help(cls):                          #实例方法可以调用类方法和类变量
        # cls.help2()  #类方法可以调用类方法和类变量
        # cls.country
        print("请拨打客服热线：1395999999")

    @classmethod #声明类方法,节省内存
    def help2(cls):
        print("help2")

    def __init__(self,name):
        self.__name = name #实例变量
        self.creter_time = int(time.time()) -60*60*24*365*5

    #实例方法
    def run(self):
        print("%s,run" % self.__name)

    @property #声明属性方法,方法里不能传参数，必须有返回值
    def age(self):
        car_are = (int(time.time()) - self.creter_time) / (60*60*24*365)
        # print("车龄:",car_are)
        return car_are

qq = Car("qq")
# qq.age()
print(qq.age) #打印属性方法的返回值
Car.help() #调用类方法，通过类名调用
qq.help() #类方法,通过实例也能调用

 

面向对象_数据：

import faker
f = faker.Faker(locale="zh-CN")
class Student:
    def __init__(self,name,age,_class,addr,email,country = "china"):
        self.name = name
        self.age = age
        self._class = _class
        self.addr = addr
        self.email = email
        self.country = country

# student_list = []
# for i in range(5):
#     ljq = Student(f.name(),18,"飞马","北京","260303838@qq.com")
#     student_list.append(ljq)
#     print(ljq)
# print(student_list)

ljq = Student(f.name(),18,"飞马","北京","260303838@qq.com")
print(ljq.__dict__) #转字典
# print(ljq.addr)
# ljq.addr = "上海"
# print(ljq.addr)

 

面向对象_继承：

class Lw: #父类，公共的定义在父类里
    countrt = "日本"
    money = 5000

    def __fly(self): #私有的方法不能继承
        print("fly")

    def make_money(self):
        print("挣钱，500块")
        return 500

    def eat(self):
        print("老王吃饭")

class Ll: #父类，公共的定义在父类里
    countrt = "韩国"
    def paocai(self):
        print("泡菜")

    def eat(self):
        print("老李吃饭")



class Xw(Lw,Ll): #继承父类Lw,Ll,不限制继承个数

    def make_money(self): #第一种重写父类方法
        print("挣钱，1000块")

    def huaqian(self):
        print("花钱")

class Xxx(Lw): #继承父类Lw
    def dubo(self):
        self.eat() #调用父类方法
        print("赌博")

    def make_money(self): #第一种重写父类方法
        f_money = super().make_money() #super()方法，自动找到父类，调用父类方法
        cur_money = f_money + 1000
        print("挣钱，每天挣%s" % cur_money)

print(Xw.mro())#mro，广度优先，调用多个父类有相同方法，查看调用父类方法的顺序
xw = Xw()
xw.eat()


# xx = Xxx()
# xx.dubo()
# xx.make_money()


# xw = Xw()
# xw.make_money()
# xw.eat()
# print(Xw.money)
# print(Xw.countrt)

 

面向对象_多继承：

class A:
    def eat(self):
        print("a eat")
    pass

class B(A):
    def eat(self):
        print("b eat")
    pass


class C(A):
    def eat(self):
        print("c eat")
    pass


class D(B,C):
    pass

d = D()
d.eat()

 

多线程：

import threading #线程：线程和线程之间是独立的，py文件是主线程
import time,random

def create_data(url):
    t = random.randint(1,5)
    print("t...",t)
    time.sleep(t)
    print("url",url)

start_time = time.time()
# 第一种主线程等待子线程方式
# threads = []
# for i in range(5):
#     t = threading.Thread(target=create_data,args=(i,))
#     t.start()
#     threads.append(t)
# for t in threads:
#     t.join() #等待子线程


# 第二种 通过判断当前线程数的方式
for i in range(5):
    t = threading.Thread(target=create_data,args=(i,)) #args=(i,)传一个参数，后加逗号
    t.start()
while threading.activeCount() != 1:
    pass
end_time = time.time()
print("执行时间：",end_time-start_time)
print(threading.activeCount()) #当前线程数



# if __name__ == '__main__':
#     create_data()

 

多线程_锁：

import threading


count = 0
lock = threading.Lock() #锁，多个线程再操作同一批数据时用到锁，防止数据错乱
def add_data():
    print("当前线程：",threading.currentThread())
    global count
    # lock.acquire() #锁，不释放的话会变成死锁
    # count +=1
    # lock.release()#把锁释放
    with lock: #用with自动释放
        count +=1

for i in range(5):
    t = threading.Thread(target=add_data)
    t.start()

while threading.activeCount() != 1:
    pass

print(count)

 

多线程举例：

#pip install threadpool 线程池
import requests,threading
import os,time

image_url = "https://q4.qlogo.cn/g?b=qq&nk=%s&s=140"

qq_numbers = ["511402865","260303838","1099276647","1490768397","729226162",
      "1164019076","569380213","923296994","330547222","609924484","1054114694",
      "854795345"]

def down_load_pic(qq):
    url = image_url % qq
    req = requests.get(url)
    path = os.path.join("images",qq+'.jpg')
    with open(path,'wb') as fw:
        fw.write(req.content)
    # return 1 #取返回值定义一个全局变量，把结果加到全局变量里return下

start_time = time.time()
# for qq in qq_numbers:
#     down_load_pic(qq)


for qq in qq_numbers:
    t = threading.Thread(target=down_load_pic,args=(qq,))
    t.start()

while threading.activeCount() !=1:
    pass

print("总耗时：",time.time() - start_time)

print("所有头像下载完成！")

 

守护线程：

import threading
import time

def ganhuo():
    time.sleep(10)
    print("done!")

for i in range(10):
    t = threading.Thread(target=ganhuo)
    t.setDaemon(True)#把子线程设置成守护线程，执行完主线程，不管子线程有没有执行完
    t.start()

print("主线程活干完了")

 

类继承的方式启动线程：

import threading,time



class MyThread(threading.Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name


    def run(self):
        time.sleep(1)
        # print("%s创建数据"%self.name)
        print("创建数据")

for i in range(5):
    t = MyThread("name")
    t.start()

 

线程池：

import threadpool #线程池
import requests,threading
import os,time,random

image_url = "https://q4.qlogo.cn/g?b=qq&nk=%s&s=140"

qq_numbers = ["511402865","260303838","1099276647","1490768397","729226162",
      "1164019076","569380213","923296994","330547222","609924484","1054114694",
      "854795345"]

def down_load_pic(qq):
    url = image_url % qq
    req = requests.get(url)
    path = os.path.join("images",qq+'.jpg')
    with open(path,'wb') as fw:
        fw.write(req.content)

# def down_load_pic(arg_list):  # qq_numbers 是 list格式
#     qq = arg_list[0]
#     url = arg_list[1]
#     print(qq,url)

pool = threadpool.ThreadPool(10)#指定线程多少个
reqs = threadpool.makeRequests(down_load_pic,qq_numbers)#分配数据
for req in reqs:#把分配好的数据放进线程池
    pool.putRequest(req)

pool.wait()#开始运行

 

多进程：

import multiprocessing,threading,time

lock = threading.Lock() #锁

def create_data(num):
    print("data..",num)
    time.sleep(3)


if __name__ == '__main__': #只能放在if  name里执行
    for i in range(5):
        p = multiprocessing.Process(target=create_data,args=(1,)) #进程
        p.start()
    while len(multiprocessing.active_children()) !=1:
        pass
    print("运行完成")

 

进程池：

import multiprocessing,time,os

qq_numbers = ["511402865","260303838","1099276647","1490768397","729226162",
      "1164019076","569380213","923296994","330547222","609924484","1054114694",
      "854795345"]

def create_data(num):
    print("data..",num)
    time.sleep(3)
if __name__ == '__main__':
    print(os.cpu_count())#查看CPU

    p = multiprocessing.Pool()

    for qq in qq_numbers:
        p.apply_async(create_data,args=(qq,))
        p.close()
        p.join()#等待子线程完成