python面向对象

#定义类；
class Person: #定义经典类
class Person(object): #定义新式类
    def __init__(self,name,sex):
        self.name = name #属性
        self.sex = sex
def cry(self):   #方法
        print(‘%s cry....‘%self.name)   
def eat(self):
        print(‘color‘,self.sex)

ccx = Person(‘常彩霞‘,‘女‘,‘黑色‘)  #创建对象，即类的实例化
ccx.eat()  #访问对象的方法

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(abc):
    print("Hello my name is " + self.name)

p1 = Person("Bill", 63)

class Foo:

    def __init__(self):
        print(‘构造方法被调用‘)   #初始化方法，创建完对象后会自动被调用

    def __del__(self):
        print(‘脚本运行结束, 释放内存‘)  #析构方法，当对象被删除时，会自动被调用,然后释放内存

class straff:
    nation = ‘china‘  #类变量
    def __init__(self,name,position,salary):  #实例方法，必须带self
        self.name = name           #实例变量、成员变量
        self.position = position
        self.salary = salary

    @classmethod  #装饰器、可以视为一个函数
    def help(cls):  #类方法、cls就是类straff，一些公共的方法，就用类方法，类方法里面不能调用实例方法，不能调用实例变量
        print(cls.nation)
        cls.show()

    def myself(self):  #实例方法
        self.help()    #实例方法可以调用类方法
        print(self.nation)   #实例方法可以调用类变量
        print(self.name)
        self.show()

    # 静态方法，可以看成一个单纯的函数，和类本身没有关系，不能使用类或实例的任何属性和方法；类对象或实例对象都可以调用它
    @staticmethod
    def show():    #静态方法可以不带参数
        print(‘静态方法‘)

class Car:
    __key = ‘value‘ #私有的变量和方法不能被继承
    def __init__(self,wheel,direction):
        self.wheel = wheel
        self.direction = direction

    def run(self):
        print(‘向着 %s 前进 %s‘ %(self.direction,self.wheel))

class Bmw(Car):  #继承
    pass

bmw = Bmw(4,‘north‘) #实例化
bmw.run()  #调用父类的方法
print(bmw.wheel) #调用父类的属性

class Car:
    def __init__(self,wheel,direction):
        self.wheel = wheel
        self.direction = direction

    def run(self):
        print(‘向着 %s 前进 %s‘ %(self.direction,self.wheel))

class Bmw(Car):  
     def run(self):    #覆盖重写父类的方法，父类的方法不会被调用
         print(‘重写父类的方法‘)

    def run(self):
        super().run()  #在父类的方法基础上修改
        print(‘重写父类的方法‘)

class Car:
    def __init__(self,wheel,direction):
        self.wheel = wheel
        self.direction = direction

    def run(self):
        print(‘向着 %s 前进 %s‘ %(self.direction,self.wheel))

class Bmw(Car):  #继承
    def __init__(self,name,color):   #重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__
        self.name = name
        self.clor = color
    
    def __init__(self,name,color):  
        super(Bmw,self).__init__(name,color) #重写__init__，同时保留父类的构造方法
        self.name = name
        self.color = color
    def run(self):
        super().run()   
        print(‘向着 %s 前进 %s‘ %(self.name,self.color))

import threading
import time

def insert_db():   #定义一个线程函数
    time.sleep(3)
    print(‘insert_over‘)

threads = []
start_time = time.time()
for i in range(3):
    t = threading.Thread(target=insert_db)  # 创建3个线程，target指定线程执行的函数名   ## t = threading.Thread(target=run,args=(‘t1‘,)) args是函数对应的参数，以元组的形式存在
    t.start()  #启动线程
    threads.append(t)

#1线程执行完后自动结束，判断线程是否全部结束
for t in threads:
    t.join() # 告诉主线程，等子线程完成之后再执行

#2也可以判断线程数
while threading.activeCount() != 1:
    pass

end_time = time.time()
print(‘多线程执行的时间‘,end_time - start_time)
print(‘全部结束‘)

import threading

count = 0
lock = threading.Lock()
def func():
    global count
    print(‘test-lock‘)
    lock.acquire()   #加锁
    count += 1
    lock.release()   #释放锁

for i in range(3):
    t = threading.Thread(target=func)
    t.start()

import threading
import time
def talk(name):
    print(‘正在和%s聊天‘%name)
    time.sleep(200)
def shipin(name):
    print(‘正在和%s视频‘%name)
    time.sleep(300)

print("qq主窗口")
t1 = threading.Thread(target=talk,args=[‘刘小燕‘])
t1.setDaemon(True) #设置线程为守护线程
t1.start()

t2 = threading.Thread(target=shipin,args=[‘蔡明昌‘])
t2.setDaemon(True) #设置线程为守护线程
t2.start()

time.sleep(5)

print(‘结束。。。‘)