析构函数、私有、类方法；继承；环境部署；多线程、多进程；锁

1.析构函数、私有、类方法、属性方法、静态方法
class My:
    def __init__(self):
        print('构造函数，类在实例化的时候会自动执行他')
    def __del__(self):   #析构函数，这个实例被销毁的时候自动执行的
        self.__client.close()
    def say(self): #实例方法
        print('我是牛奶')
　　　　　__cry() 在类外边调用say方法时，可以调用到私有函数__cry()
    def __cry(self):
        #函数名或者变量名前面加__，这个函数或者变量就是私有的，私有的只能在类里边用，私有比较安全，出了类，方法内的东西不能被修改
        print('哇哇哇')
m=My（）
如果在这行代码以后没有了代码，代表这个实例在内存里被删除了，会自动执行析构函数
如果在这行代码之后还有其他代码，没有手动销毁这个实例，那么等其他代码执行完以后，再自动执行析构函数
如果这行代码之后有del m，手动销毁实例，而且再往下还有其他代码，那么在执行析构函数之后，再往下执行其他代码

@classmethod #类方法，不用实例化，可以直接调用；装饰器，不改变原来的函数，给函数添加新功能
def eat(cls):
    print('吃饭')
@staticmethod #静态方法
def run():
    pass
@property  #属性方法
def red_pag(self):
    return 100

# 类方法：
# 1.不用实例化，直接用类名调用 例如：My.eat()

# 2.他可以使用类变量，cls.xxx，这里的cls代表My

# 3.实例化也可以直接通过self.xx来使用类方法
# 4.类方法里边它是不能用这些实例方法和实例变量 即self.xxxx

# 静态方法：
# 就是一个普通的函数，就是定义在类里边而已
# 用不了实例方法，用不了实例变量，也用不了类方法、类变量
# 也不需要实例化，直接类名调用即可

# 属性方法：
# 看起来像方法的一个函数
# 实例方法
# 他不能有入参
# 用它的时候，直接m.func，把他当做一个变量就ok了，不需要加括号调用
# 他是获取函数的返回值

2.继承

#目的是为了减少代码，减少重复代码

class Ln:  #父类
    money='2000'
    def make_money(self):
        print('挣钱')

class Me(Ln):  #子类
　　pass
print(Me.money)  #继承父类，结果为2000
nhy=Me()
nhy.make_money()
如果在子类中的方法进行了重构，以重构方法为准
如果在父类方法基础上修改父类的方法，可以在子类方法中调用父类的对应方法，即:父类.方法名（self,**,**）括号里传方法的所有参数，self一定要传

3.环境部署

　　怎么搭建测试环境
　　第一次搭建
　　1、安装依赖软件 mysql、redis、tomcat、nginx、jdk
　　数据库、中间件等等
　　2、获取代码 svn git
　　3、编译（java c c##）
　　4、导入基础数据
　　5、修改配置文件
　　6、启动项目

　　日常部署
　　1、获取最新代码
　　2、编译（java c c##）
　　3、执行sql（如果数据库有改变的话）
　　4、修改配置文件
　　5、重启项目

4.多线程、多进程

# 进程：一个进程就是一个程序
# 线程：线程就是进程里面最小的执行单元
#     线程在进行里边，干活的还是线程
#     一个进行里边最少有一个线程，可以有多个线程
#     每个线程之间都是互相独立的
# 没有真正意义的并发，电脑是几核的，那么最多只能同时运行几个任务

# python里面的多线程，是利用不了多核cpu的，只能利用一个核心的cpu
# 有些情况下，你用多线程的时候发现比单线程速度还慢
# GIL全局解释器锁
#     1.为什么python的多线程利用不了多核cpu，但还是比单线程还快
　　　　答案参考：http://www.mamicode.com/info-detail-2318634.html
# 什么时候用多线程，什么时候用多进程？
# 多线程适用于io密集型任务
#     磁盘io
#     网络io

# 多进程适用于cpu密集型任务
# 多进程，是可以使用多核cpu的

import threading,time
all_res=[]#这是用来存储函数的结果的

def run(name):
    print('子线程',threading.current_thread())打印线程状态和线程id
    time.sleep(5)
    print('[%s]哈哈哈'%name)
    all_res.append(name)  #启动多线程时，返回值获取不到

# for i in range(5): #串行
#     run()
start=time.time()
threads=[] 用来存放所有的子线程
for i in range(5): #先统一启动所有子线程
    t=threading.Thread(target=run,args=(i,)) 在target后边跟要运行的方法，在args后边加参数，可以有多个参数，存在元组当中
    threads.append(t) 将所有的子线程加到list
    t.start()

end=time.time()
print(end-start) 这里打印主线程运行的时间，主线程和子线程之间是相互独立的

    # t.join()#等待，主线程等待子线程执行完，再一起执行其他代码
# while threading.active_count()!=1:  #判断当前活动的线程是几个，如果是1的话，说明子线程都已经执行完成了
#     pass
for t in threads: #循环线程list，再统一的去等待子线程执行结束
    t.join()
print('主线程',threading.current_thread())

守护线程：

# 守护线程就是和秦始皇陪葬的人一样
# 主线程就是秦始皇
# 守护线程就是陪葬的人

import threading
import time
def run():
    time.sleep(9)
    print('run...')
for i in range(10):
    t=threading.Thread(target=run)
    t.setDaemon(True) #设置子线程称为一个守护线程
    t.start()
print('over...')

加锁：

import threading
from threading import Lock
num=0
lock=Lock() #实例化一把锁

def run():
    global num
    # lock.acquire()#加锁
    # num+=1 #多个线程操作一份数据时，最好要加上锁，防止数据出错
    # lock.release() #解锁
    with lock:  #自动加锁解锁
        num+=1
for i in range(100):
    t=threading.Thread(target=run)
    t.start()
while threading.active_count()!=1:
    pass
print(num)

线程池：

import threadpool,pymongo,requests
client = pymongo.MongoClient(host='***.**.*.**',port=27017)
table = client['db']['table']
all_qq = [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 r in all_requests:
   pool.putRequest(r)   #发请求
#[pool.putRequest(r) for r in all_requests] #
pool.wait()#等待所有线程运行完
print('done！下载完成。')

多进程：

from multiprocessing import Process,Pool,active_children
import pymongo,requests
import threading
client = pymongo.MongoClient(host='***.**.**.*',port=27017)
table = client['***']['*****']
all_qq = [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)

if __name__ == '__main__':
   # for qq in all_qq:
   #  p = Process(target=down_img,args=(qq,)) #启动多进程
   #  p.start()
   pool = Pool(5)#指定进程池的大小
   list(pool.map(down_img,all_qq)) #生成器强行转化为list自动运行 使用进程池