面向对象：
类：一个种类，一个模型
实例，对象：根据模型制造出来的东西
实例化：就是制造的过程
实例变量：self.xx=xx，加了self的变量才是实例变量，必须得实例化之后才可以使用
实例方法：需要传self 的方法，都是实例方法，必须得实例化之后才可以使用
实例方法里面可以随便通过self来调用实例方法，类方法，静态方法，类变量
方法：类里面的函数
属性：类里面的变量
构造函数：类在实例化的时候自动执行的一个函数def __init__(self)
析构函数：实例在销毁时自动执行的函数def __del__(self)
self：代表本类的对象
类变量：直接在类下面定义的变量，没有加self,每个实例都可以使用
类方法：不需要实例化就可以调用，它可以使用类变量，调用其他的类方法，不可以使用实例方法和实例变量
如果类里面的这个方法没有使用到其他的实例变量，实例方法，就定义为类方法
在方法前面加上@classmethod
静态方法：不需要实例化就可以调用，在方法前面加上@staticmethod
他就是一个定义在类里面的普通函数，不能使用实例变量，实例方法，类变量，类方法
属性方法：看起来像变量的一个方法，方法前面加@property
私有：变量，函数前面加两个下划线就代表是一个私有的，只能在类里面用，比如self.__password
定义一个类：
class Stu:#一般类名的首字母大写，经典类
pass
class Stu1(object):#新式类
pass
class Stu2():#新式类
pass
类的实例:
class Person:#定义类
def __init__(self.name):
self.name=name #实例变量
self.age=18
self.data='哈哈'
self.addr='北京'
def cry(self):实例方法
print(“%s在大哭”%self.name)
wl=Person("王丽")#实例化，wl是实例或对象
wl.cry()#调用方法，实际上self就是实例化出来的对象wl，两个内存地址是一致的
#方法的实例
class Car:
wheel = 4 #类变量
def __init__(self,color,p):#构造函数
self.color = color #实例变量
self.p = p
def help(self): #实例方法
print('汽车有%s个轮子'%self.wheel)#可以使用类变量
print('汽车的颜色是%s'%self.color)
print('牌子%s'%self.p)
print('='*10)
self.haha()
self.check_wheel()
#类方法，不需要实例化就可以调用，只能在类内部调用
@classmethod
def check_wheel(cls):
print('cls的内存地址',id(cls))
print(cls.wheel)
cls.haha()
@classmethod
def haha(cls):
print('哈哈哈')
cls.help2()
#静态方法，普通的一个函数，不需要实例化就可以被调用
@staticmethod
def help2():
print('这个类的作用是造汽车，它里面有xxx方法')
#属性方法
@property
def yesterday(self):
import datetime
res = datetime.date.today() + datetime.timedelta(-1)
return str(res)
def tom(self):
import datetime
res = datetime.date.today() + datetime.timedelta(1)
return str(res)
Car.help2()
#静态方法，普通的一个函数，不需要实例化就可以被调用
mcb = Car('赤橙黄绿青蓝紫','马春波')
print(mcb.yesterday)#调用属性方法
print(mcb.tom())
# mcb.wheel = 28
# mcb.haha()
# mcb.help()
# mcb.help2()
#
# print('Car的内存地址',id(Car))
# Car.check_wheel()
# Car.wheel= 19
# print(Car.wheel)
#
# benc = Car('黑色','奔驰')
# benc.help()
#
# bmw = Car('白色','宝马')
# bmw.help()
继承：如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法，在调用父类的方法时，需要加上父类的类名前缀，且需要带上self参数变量
class Lm:#父类
money = 1000000
house = 5
def driver(self):
print('会开车')
class Mcb(Lm):#子类继承父类
def about_me(self):
print('我有 %s 钱 ,%s 房子'%(self.money,self.house))
self.driver()
def driver(self):#重写父类方法
print('会开28个轮子的汽车')
m = Mcb()
m.driver()
m.about_me()
私有：不能在类的外部被使用或直接访问
class My:
def test(self):
self.__password = 123456#私有变量
def say(self):
print('password',self.__password)
def __set_password(self):
self.__password = 7890
def update(self):
self.__set_password()
m = My()
m.test()
m.say()
m.update()
m.say()
继承：
class Car:
def run(self,):
print('running...')
return 'abc'
class NewCar(Car):
def run(self):
res = super().run()# super()的意思就是找到父类
print('fly...',res)
bmw = NewCar()
bmw.run()
输出结果：
running...
fly... abc
