类

类的定义

#面向对象

class Player():#定义一个类 类名最好大写 相同的内容归纳总结
    def __init__(self,name,hp,**occu**):#所有类和方法中第一个参数一定要带self
        self.name=name #self表示Player进行实例化后的实例化本身user
        self.hp=hp #变量(name)被称作为属性，函数(print_role)称作为方法
        **self.occu=occu**
    def print_role(self):#定义一个方法  类有什么功能
        print('%s:%s ***%s***'%(self.name,self.hp,**self.occu**))
    def updatername(self,newname):#重命名
        self.name=newname
class Monster():
    '定义怪物类'
    pass
#先定义但不编写时
user1=Player('tom',100,'war')      #类的实例化  把用户与类关联起来 用户拥有类的特征  类到具体用户的过程叫类的实例化
user2=Player('jerry',100,'master')
user1.print_role()#调用这个方法
user2.print_role()
**user1.updatername('marry')
user1.print_role()**

加粗体为如何增加属性和方法

当类的属性不想被访问时在属性前加__ 例self.__name，变量将不会被实例访问：类的封装

类的继承

猫科动物（父类）-->猫（子类） 猫继承猫科动物的方法

继承:class 子类名称（父类名称）:

class Monster():     #父类
    '定义怪物类'
    def __init__(self,hp=100):#hp 初始值100
        self.hp=hp

    def run(self):       #定义怪物的方法 就是能干啥
        print('移动到某个位置')


class Animals(Monster):      #子类继承父类 子类（父类名称）
  #  '普通怪物'
   def __init__(self,hp=10):
      # self.hp=hp
       super().__init__(hp)  # super在父类中初始化了某些属性在子类中便不需要再次初始化

#怪物
a1=Monster(100)
print(a1.hp)
print(a1.run())

a2=Animals(1)
print(a1.hp)
print(a2.run())

多态

当父类和子类都定义同一个同名的方法时 子类的调用会覆盖父类

class Monster():#父类
    '定义怪物类'
    def __init__(self,hp=100):#hp 初始值100
        self.hp=hp

    def run(self):#定义怪物的方法 就是能干啥
        print('移动到某个位置')
    def whoami(self):
        print('我是父类')
class Boss(Monster):#子类
    def __init__(self, hp=10):
        super().__init__(hp)  # super在父类中初始化了某些属性在子类中便不需要再次初始化
  #  '大怪物'
    def whoami(self):
        print('我是子类')
 a3=Boss(10)
 a3.whoami()

所示结果:我是子类

tisp:

①利用type区分类

print('a1的类型是%s'%type(a1))
print('a2的类型是%s'%type(a2))
print('a3的类型是%s'%type(a3))

所示结果：

a1的类型是<class 'main.Monster'>

a2的类型是<class 'main.Animals'>

a3的类型是<class 'main.Boss'>

②利用isinstance区分父类子类

print(isinstance(a2,Monster))

所示结果：True (不是则显示False)

③当在父类初始化后的属性不需要在子类再次定义可以用 super

super().init(属性名)

④Python中所有的列表，元组，字符串...都归于类，其父类为object

⑤类无法直接引用需要进行实例化

自定义with语句的使用

with 语句

with open() as f:

自定义with语句

class Testwith():
    def __enter__(self):
        print('run')
    def __exit__(self, exc_type, exc_val, exc_tb):
        # enter&exit 指在对类进行初始化和类结束时被调用
        print('exit')
        if exc_tb is None: #利用exc_tb判断是否有异常
            print('正常结束')
        else:
            print("有异常 %s" %exc_tb)
with Testwith():  #Testwith在enter时输出 run 在exit时输出exit
    print('Test is running')

    raise  NameError('testNameError') #手动抛出异常

多线程

定义

我的理解 多个并发的渠道解决问题 比如多个打饭窗口

循环
def myThread(arg1, arg2):
    print('%s %s' % (arg1, arg2))

for i in range(1, 6, 1):  # 循环五次 递增1
    t1 = myThread(i, i + 1)
    
    
线程

import threading #导入函数库
import time
from threading import current_thread #显示当前线程运行状态
def myThread(arg1, arg2):
    print(current_thread().getName(),'start') #getName 获取线程名称
    print('%s %s' % (arg1, arg2))
    time.sleep(2)
    print(current_thread().getName(),'stop')

for i in range(1, 6, 1):  # 循环五次 递增1
    t1= threading.Thread(target=myThread,args=(i,i+1))#Thread 方法 target参数：用来传递函数名 args：对函数进行传递参数
    t1.start() #start方法使多线程运行
print(current_thread().getName(),'end')

多线程之间的同步

面向对象

import threading
from threading import current_thread

class Mythread(threading.Thread):#利用类继承 threading.Thread() 利用多态形式将run方法重写
    def run(self):
        print(current_thread().getName(),'start')
        print('run')
        print(current_thread().getName(),'stop')

a1=Mythread()#实例化
a1.start()#线程启动
a1.join()

print(current_thread().getName(),'end')

所示结果：

Thread-1 start

run

Thread-1 stop

MainThread end

生产者和消费者问题

队列

import queue
q=queue.Queue() #产生队列
q.put(1) #在队列中增加数
q.put(2)
q.get() #从属队列中取得数  按顺序读取

#生产者和消费者问题
from threading import Thread,current_thread  #实现多个生产者和多个消费者并行生产和消费
import time
import random  #生产随机数据
from queue import Queue #队列

queue=Queue(5) #定义队列长度  队列长度决定数据多少

class ProducerThread(Thread):
    def run(self):
        name=current_thread().getName() #获取线程名字
        nums=range(100)
        global queue
        while True:
            num=random.choice(nums) #随机选择数字
            queue.put(num)#随机数字放入队列中 生产者可通过随机的休眠时间往队列中添加数字
            print('生产者%s生成了数据%s'%(name,num))
            t=random.randint(1,3)
            time.sleep(t)
            print('生产者%s休眠了%s秒'%(name,t))

class ConsumerThread(Thread):
    def run(self):
        name=current_thread().getName()
        global queue
        while True:
            num=queue.get() #消费者可通过随机的休眠时间往队列中提取数字
            queue.task_done() #task_done() 线程等待的方法
            print('消费者%s 消耗了数据%s'%(name,num))
            t=random.randint(1,5)
            time.sleep(t)
            print('消费者%s休眠了%s秒'%(name,t))

p1=ProducerThread(name='p1')
p1.start()
c1=ConsumerThread(name='c1')
c1.start()
c2=ConsumerThread(name='c2')
c2.start()