搭建测试环境、面向对象

class Car: #Car是类,用class来定义一个类，类名首字母最好大写。类是一个种类、一个模型，将相似功能封装到一个类中，里边用不同函数实现不同功能
    wheel = 4 #wheel是类变量，即直接在类下面定义的变量，没有加self的，每个实例都可以用.节省内存
    def __init__(self,color,p):  #构造函数。类在实例化的时候会自动执行的一个函数
        self.color = color #实例变量，加了self的变量，必须得实例化且调用方法之后才可以使用。也可以定义为一个实例（对象）
        self.p = p

    def help(self): #实例方法，需要传self的方法，必须实例化之后才可以使用，实例方法里面可以随便通过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): #类方法
           # 1、不需要实例化就可以调用，如Car.check_wheel(cls)
           # 2、它可以使用类变量
           # 3、调用其他的类方法。
           # 4、它不可以使用实例方法、实例变量
           # 如果类里面的这个方法，它并没有使用到其他的实例变量、或者其他实例方法，那么就给他定义成类方法
        print(‘cls的内存地址‘,id(cls))
        print(cls.wheel)
        cls.haha()

    @classmethod
    def haha(cls):
        print(‘哈哈哈‘)
        cls.help2()

    @staticmethod #静态方法，如果不需要传参，不需要调用变量，单纯输出值，可以使用静态方法
            # 1、不需要实例化就可以调用的
            # 2、它就是一个定义在类里面的普通函数，不能使用实例变量、实例方法、不能使用类变量、类方法。
    def help2():  #调用时，用对象.help2
        print(‘这个类的作用是造汽车，它里面有xxx方法‘)

    @property  #属性方法，调用有些特殊。如print(mcb.yesterday),而不能用print(mcb.yesterday（）)
    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)
    
    def __del__(self): #实例在销毁的时候自动执行的函数

        pass


Car.help2() #调用静态方法
mcb = Car(‘赤橙黄绿青蓝紫‘,‘马春波‘) #实例化，mcb的id和self的id一样。
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()

class Person:
    def __init__(self,name):
        print(‘开始造人了‘,name)
        self.name = name  # 实例变量
        self.age = 18

    def cry(self,size):
        print(‘%s在%s哭。年龄是%s‘%(size,self.name,self.age))
        self.size = ‘大哭‘
        self.date = ‘20190106‘
        
    def say(self):
        print(‘我叫%s，我住在%s.‘%(self.name,self.addr))
        print(self.size)
        print(‘Jin天的日期‘,self.date)
        self.help()

    def help(self):
        print(self.date)


mcb = Person(‘马春波‘)
cq = Person(‘陈琦‘)
mcb.grilfriend = cq #加一个变量，变量可以为对象
print(‘马春波的女朋友‘,mcb.grilfriend.name)
mcb.grilfriend.cry(‘大‘)

mcb = Person(‘马春波‘)
mcb.addr = ‘北京‘  #原类中没有addr变量，这儿加了一个，可以供下边调用的函数使用。
mcb.cry(‘大‘)  #cry(mcb,大)
mcb.say()

#该功能与上边的加grilfriend变量一样
def car(self,car_name): #
    self.car_name = car_name
    #函数里面给mcb加了一个变量
car(mcb,‘奔驰‘)#把mcb这个实例传给了self，self指的就是mcb这个实例
print(mcb.car_name)

class Lm:
    money = 1000000
    house = 5
    def driver(self):
        print(‘会开车‘)

class Mcb(Lm): #这里继承了类Lm, 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()