day19-20markdown总结

1.多线程

import threading
import datetime
import time

def download(file):
    print('开始下载：'+file, datetime.datetime.now())
    time.sleep(10)
    print(file+'下载结束', datetime.datetime.now())

if __name__ == '__main__':
    print('主线程中的代码')
    print(threading.currentThread())
    # download('终结者2')
    # download('沉默的羔羊')
    print('==============')
    #2.在两个子线程中去下载两个电影
    """
    Thread(target,args)
    target:需要在子线程中调用的函数的函数名
    args：函数的实参
    返回值：创建好的线程对象
    download以外的代码全在主线程执行
    """
    t1 = threading.Thread(target=download, args=('终结者2', ))
    # 开始执行t1对应的线程中的任务
    t1.start()
    t2 = threading.Thread(target=download, args=('沉默的羔羊',))
    t2.start()
    # 想要在子线程中执行任务，必须通过线程对象调用start方法才行
    print('=======')

2.面向对象的多线程技术

from threading import Thread
import datetime
import time
from random import randint
面向对象实现多线程技术
1.声明一个类继承自Thread类
2.将需要在子线程中执行的任务放在run方法中
3.在需要子线程的位置去创建这个类的对象，然后用对象调用start方法去执行run中的任务
class DownloadThread(Thread):
    def __init__(self, file):
        super().__init__()
        self.file = file
    def run(self):
        print(self.file+'开始下载：', datetime.datetime.now())
        time.sleep(randint(5, 10))
        print(self.file+'下载结束:', datetime.datetime.now())
if __name__ == '__main__':
    print('=======')
    t1 = DownloadThread('苍老师')
    t1.start()

3.join方法使用

from threading import Thread
from datetime import datetime
import time
from random import randint
# 在两个子线程中下载两个电影，去主线程中去统计两个电影下载的总时间
# 如果希望某个线程结束后才执行某个操作，就用那个线程调用join方法
class DownloadThread(Thread):
    def __init__(self, file):
        super().__init__()
        self.file = file
    def run(self):
        print(self.file+'开始下载',datetime.now())
        time.sleep(randint(5, 15))
        print(self.file+'下载结束',datetime.now())

if __name__ == '__main__':
    start = time.time
    t1 = DownloadThread('美丽人生')
    t2 = DownloadThread('肖恩克的救赎')
    tim1 = t1.start()
    tim2 = t2.start()
    # 系统t1和t2中的代码都结束才执行下面的代码
    t1.join()   # 这句代码后面的代码在t1对应的线程结束后才执行
    t2.join()
    end = time.time()

4.线程间的数据共享

from threading import Thread,Lock
import time
class Account:
    """账号类"""
    def __init__(self, balance):
        """余额"""
        self.balance = balance
        # 创建锁对象
        self.lock = Lock()

    def save_money(self, amount):
        # 存钱过程：读出原来余额，确定钱的操作
        self.lock.acquire() # 加锁
        old_amount = self.balance   # 获取原来的余额
        time.sleep(5)
        # 存钱
        self.balance = old_amount + amount
        print('当前余额为：', self.balance)
        self.lock.release() # 减锁
    def get_money(self, amount):    #取钱
        old_amount = self.balance
        if old_amount < amount:
            print('余额不足!')
            return
        time.sleep(5)
        self.balance = old_amount - amount
        print('当前余额为：', self.balance)
    def show_balance(self):
        print('当前余额为：', self.balance)


if __name__ == '__main__':
    account = Account(1000)
    # account.save_money(200)
    # account.get_money(100)
    # 当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱的问题

    t1 = Thread(target=account.save_money, args=(200,))
    t2 = Thread(target=account.save_money, args=(300,))
    t1.start()
    t2.start()
str4 = 'good good study,day day up'
print(str4[3::-1])
print(str4[::-1])

5.内存管理机制

掌握：1.数字，字符串（简单的字符串），布尔值的缓存
      2.垃圾回收中的引用计数机制
python中所有的数据都是对象，所有的变量都是对象的引用

python对数字、字符串和布尔对象进行了缓存。让不同的变量赋同样值的
这些对象的时候，给的地址是缓存的对象的地址。
总结：1.给一个变量赋值的时候，赋的是数字、字符串、布尔的时候，会先看缓存区是否有这个值
        如果有直接将值对应地址赋给变量。没有就在缓存中开辟空间存储数据，然后返回地址、
      2.给一个变量赋值的时候，赋的是除了数字、字符串、布尔以外的值，就直接在内存中开辟空间存储数据，然后返回地址
一个变量存了一个对象的地址，那么这个变量就是这个对象的引用
2.python中的内存管理：
c的内存管理机制：手动
java\oc\python等：拥有一套属于自己的内存管理机制
a.python通过垃圾回收机制来对内存进行管理的。不定时对程序中的对象进行检测，查看是否需要回收
将对应的内存释放。看是否需要回收就看对象引用计数是否为0。
b.引用计数：
python中的每个对象在创建的时候就会有一个属性叫引用计数，其对应的值是0
当对象被引用一次，其引用计数就会加1.当对象的引用减少一个，其引用计数就会减1

3.垃圾回收机制
垃圾回收机制并不是一旦产生引用计数为0的对象就马上回收。而是不定时的对整个程序中
所有的对象进行检测，检测的时候引用计数为0才回收。
当当前程序所有的对象引用计数变化的次数达到它的阈值的时候，才会
对对象尽心检测。
4.循环引用（python中的垃圾回收能够自动解决因为循环引用二导致的内存泄漏问题）
检测的时候如果对象（object_i）的引用计数不是0，就备份引用计数值(count_i)，去找到引用这个当前对象的对象，然后将
object_j的引用计数count_j-1,如果count_j-1后的值是0，那么count_i的值就-1.如果减完后count_j的值是0，那么count_i的值就见1.
"""
from sys import getrefcount

if __name__ == '__main__':
    object1 = [1, 2]
    # 注意：getrefcount函数本身会对查看的对象进行一次引用
    print(getrefcount(object1))