机器学习05

import threading
import time
import multiprocessing
# 子类继承父类


class Person(object):
    def __init__(self, name, age):

        self.name = name
        self.age = age

    def sleep(self):
        print(self.name + '正在睡觉')

# 继承父类


class Student(Person):
    def __init__(self, name, age, school):
        # 第一种写法
        # 使用super调用父类方法
        super(Student, self).__init__(name, age)
        # self.name = name
        # self.age = age
        # 子类在父类之上添加新的功能
        # 第二种写法
        # Person.__init__(self, name, age)
        self.school = school

    # 子类重写父类中sleep方法
    # 父类Person
    # 子类Student
    def sleep(self):
        print(self.name + '课间睡觉')

    def study(self):
        print(self.name + '学习')


s = Student('gll', 24, 'xx')

s.sleep()
print(Student.__mro__)
s.study()

'''
多态
基于继承
通过子类重写父类，达到不同子类对象调用相同的父类方法，得到不同的结果
'''


class Police(object):
    @staticmethod
    def work(self):
        print(self.name + '执行police.work_with()')


class Example(object):
    def __init__(self, name, dog):
        self.name = name
        self.dog = dog

    def work_with(self):

        self.dog.work(self)


P = Police()
police = Example('g', P)
police.work_with()

'''
多线程
'''


# def dance():
#     for i in range(50):
#         time.sleep(2)
#         print('跳舞')
#
#
# def singe():
#     for i in range(50):
#         time.sleep(1.3)
#         print('唱歌')
#
# # dance()
# # singe()


# t1 = threading.Thread(target=dance)
# t2 = threading.Thread(target=singe)
# t1.start()
# t2.start()

# 线程共享全局变量
# num = 20
#
# lock = threading.Lock()
#
#
# def sell1():
#
#     global num
#     while True:
#         lock.acquire()
#         # 加上同步锁
#         num -= 1
#         time.sleep(1)
#         lock.release()
#         # 释放锁
#         if num > 0:
#             print('1--***{}\n'.format(num))
#
#         else:
#             break
#
#
# def sell2():
#
#     global num
#     while True:
#         lock.acquire()
#         # 加上同步锁
#         num -= 1
#         time.sleep(1)
#         lock.release()
#         # 释放锁
#         if num > 0:
#
#             print('2--***{}\n'.format(num))
#         else:
#             print('end---->')
#
#             break
#
#
# t11 = threading.Thread(target=sell1)
# t21 = threading.Thread(target=sell2)
# t11.start()
# t21.start()
# 上面error
# 线程锁
# 加锁变慢、效率变低
# 进程使用m
def dance(m):
    for i in range(m):
        time.sleep(2)
        print('跳舞')


def singe():
    for i in range(5):
        time.sleep(1.3)
        print('唱歌')

# 进程与线程区别
# 进程是系统资源分配,调度的一个独立单位
# 线程是进程的一个实体,是CPU调度和分派的基本单位
# 进程在执行过程中有独立内存单元,线程共享内存
# 线程不能独立运行,必须依存进程


if __name__ == '__main__':
    #

    p1 = multiprocessing.Process(target=dance, args=(10,))
    # args 类型是元组
    p2 = multiprocessing.Process(target=singe)
    p1.start()
    p2.start()