1. Object-Facing programming
1.1 Basic concepts
Instance method: The function defined in the class is an instance method with a self variable inside the function
Class method:
- cannot be instantiated, called directly with the class name
- Class methods can use class variables, cls.xxx
- Instances can use class methods through SELF.XX
Instance methods and instance variables cannot be used inside a class method
static method:
- Common functions defined in a class
- Cannot use instance methods, instance variables, class methods, class variables
Does not need to be instantiated and is called directly with the class name
? Property Method:
- is an instance method
- Cannot have an entry parameter
- When using it, direct m.func, use it as a variable, and do not need parentheses in the back.
It is the return value of the Get function
destructor: Executed when the instance is reclaimed, and the instance is recycled at the end of the program
Constructor: the "init" class is automatically executed when instantiated
Private function: "del" begins with two underscores, declares that the method is private, can only be called inside a class, and cannot be called outside of a class
class My: def __init__(self):#构造函数,类在实例化的时候,会自动执行 print(‘执行构造函数‘) def __del__(self): #析构函数,在实例被销毁的时候会自动执行 print(‘执行析构函数‘) def say(self): #入参里面有self的是实例方法,只有通过实例化才可以调用 print(‘我是牛奶‘) self.__cry() def __cry(self): #私有函数,只能在类里面调用 print(‘哇哇哇‘) @classmethod #类方法,可以实例化调用,通过类名直接调用 def eat(cls): print("吃饭") @staticmethod #静态方法,不需要实例化,直接用类名调用 def run(): pass @property #属性方法,是实例方法,使用的时候直接当做变量来用 def red_pag(self): return 100
1.2 adorners: They are functions that modify the functionality of other functions
Small examples of adorners
import time,requestsdef timer(func): def war(*args,**kwargs): start = time.time() res = func(*args,**kwargs) end_time = time.time() print(‘运行的时间是%s‘%(end_time-start)) return res return war@timerdef down_img(name): res=requests.get(‘http://www.nnzhp.cn/wp-content/uploads/2018/07/60f2add20f0659e27d26435f28b8472e.png‘) open(‘a.png‘,‘wb‘).write(res.content) return name+‘hhh‘@timerdef eat(): time.sleep(5)res = down_img(‘xxx‘)print(res)eat()
1.3 Inheritance
class Ln: #父类 money=2000 def make_money(self): print(‘挣钱‘)class Me(Ln) #子类继承父类 def make_money(self): print(‘挣更多的钱’)
2. Build a test environment
First time Building
- Install dependent software MYSQL,REDIS,TOMCAT,NGINX,JDK, database, middleware, etc.
- Get the code from the Svn,git
- Compiling (java,c,c#)
- Import the underlying data
- Modifying a configuration file
- Start Project
Daily deployment
- Get the latest code
- Compile
- Execute SQL file (if database structure is changed)
- Modifying a configuration file
- Restart Project
3. Multi-threading and multi-process
Process: A process is a program.
Thread: A thread is the smallest execution unit within a process. There is at least one thread in a process that can have multiple threads, each of which is independent of each other.
Because of the Gil (Global interpreter lock) mechanism inside Python, it ensures that only one Python thread executes at any time, so the multi-threaded inside of Python, not using multicore CPUs, can only take advantage of a core CPU. In CPU-intensive processes, multithreading does not lead to an increase in efficiency, but may result in a decrease in efficiency due to frequent thread switching, and in the case of IO-intensive processes, the multithreaded process can take advantage of the idle time of IO blocking wait to execute other threads and improve efficiency.
Multithreading for IO-intensive tasks, multi-process for CPU-intensive tasks
import threading,timeall_res=[]def run(): time.sleep(5) print(‘%s 哈哈哈‘%name) all_res.append(name)threads=[] #存放所有的子线程for i in range(10) #开10个子线程 t = threading.Thread(target=run,args=(i,)) threads.append(t) t.start() #方法一:统计当前线程数量判断所有子线程是否运行完成while threading.active_count()!=1: pass #当while=1,说明子线程已经完成,结束循环,程序向下执行#方法二:主线程循环等待所有的子线程结束后再结束for t in threads: t.join()#等待子进程运行完以后再运行print(all_res)
Daemon Thread: When the main thread ends, the daemon will also end
import threading,timedef run(): time.sleep(8) print(‘run。。‘)for i in range(10): t=threading.Thread(target=run) t.setDaemon(True) #设置子线程为一个守护进程 t.start() print(‘over‘)#主线程结束后,子线程就结束了,run函数不会执行
Lock
import threadingfrom threading import Locknum = 0Lock = Lock()def run(): global num lock.acquire() #加锁 num+=1 lock.release() #解锁 with lock: #自动加解锁 num+=1for i in range(100): t=threading.Thread(target=run) t.start()while threading.active_count()!=1: passprint(num)
Thread pool
You can control how many threads are allowed to be at the same time, and the part that exceeds is automatically waited. Fixed the uneven distribution of threads running, such as a thread still working hard, and another thread has completed, but not to help the previous thread sharing situation.
import threadpool,pymongo,requestsclient = pymongo.MongoClient(host=‘118.24.3.40‘,port=27017)table=client[‘liken‘][‘qq_group_likun‘]all_table=[i.get(‘qq‘) for i in table.find()]url = ‘http://q4.qlogo.cn/g?b=qq&nk=%s&s=140‘def down_img(qq_num): res=requests.get(url%qq_num).content with open(‘%s.jpg‘%qq_num,‘wb‘) as fw: fw.write(res)pool = threadpool.ThreadPool(200) #定义线程池的大小all_requests=threadpool.makeRequests(down_img,all_qq) #分配数据for i in all_requests: pool,putRequest(r) #发请求#[pool.putReques(r) for r in all_requests]pool.wait() #等待所有线程运行完成print(‘done!下载完成。‘)
Python interface Automation Nine--face object programming two, build test environment, multi-threading and multi-process