Day9 面向对象

一、面向对象

1、类、一个种类或者一个模型，类里边可以定义函数、变量（比如操作数据库，单条或多条，他们是同一个种类）
2、模型是不能直接用的，得根据模型制作出东西。

self：代表的本类对象，加了self后函数质检能互相用

 class My3():
#     pass
class Person:
    def __init__(self,name): #构造函数,自动会执行
        print('开始造人了',name)
        self.name = name #self：实例变量 指的就是伦伦 ，加self 是为了函数之间能互相用，
        self.age = 19
        self.data = '哈哈哈'
        # print('self的内存地址。。',id(self)) #获取内存地址
        self.addr = '北京'

    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('今天的日期是',self.date)


lyl = Person('伦伦')   #通过person 实例化了一个对象
cq = Person('陈琦')
lyl.friend = cq
print('lyl的朋友',lyl.friend.name)

# lyl.addr = '北京'
# lyl.cry('啦啦')   # = cry(lyl)
# lyl.say()


# print('lyl.....name',lyl.name)
# print('lyl.....age',lyl.age)

　　解释原理：

#解释原理
def car(self,car_name):
    self.car_name= car_name

car(lyl,'奔驰')  #把lyl这个实例传给了self，self指的就是lyl这个实例
print(lyl.car_name)

3、类变量

类变量：
实例变量
类方法：1、不需要实例化就可以调用的方法；2、不可以使用实例方法、实例变量； 3、他可以使用类变量；4、有其他类方法，可以调用其他的类方法
静态方法：1、不需要实例化就能调用的 2、他就是
属性方法：看起来像变量的一个方法

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)

　　

类方法：1、不需要实例化就可以调用的方法；2、不可以使用实例方法、实例变量； 3、他可以使用类变量；4、有其他类方法，可以调用其他的类方法
    @classmethod   #类方法
    def check_wheel(cls):
        print('cls的内存地址',id(cls))
        print(cls.wheel)

　　

 @staticmethod   #静态方法#打印一个帮助文档可以定义一个静态方法， （这个目前有问题）
    def help2():
        print('这个类的作用是造汽车，它里边有xx方法')

    @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)

　　

实例：就是根据模型制作出来的东西
实例化：就是做东西的过程
方法：类里面的函数
属性：类里边的变量
构造函数：类在实例化的时候自动执行的一个函数
析构函数：实例在销毁的时候自动执行的一个函数

import pymysql
class MyDb:
    def __init__(self,host,user,password,db,port=3306,charset='utf8'):#构造函数，
        print('连接数据库')
        self.conn = pymysql.connect(host=host,user=user,password=password,
                        db=db,port=port,charset=charset)
        self.cur = self.conn.cursor()

    def execute_one(self,sql):
        print('返回单条数据')
        self.cur.execute(sql)
        res = self.cur.fetchone()
        return res

    def execute_many(self,sql):
        print('返回多条数据的')
        self.cur.execute(sql)
        res = self.cur.fetchall()
        return res

    def __del__(self):#析构函数
        print('关闭数据库连接')
        self.cur.close()
        self.conn.close()

my = MyDb('118.24.3.40','jxz','123456','jxz') #实例化

　　二、私有

私有：在变量、函数前面加下划线，代表私有，只能在类里边用

class My:
    def test(self):
        self.__password = 123456   #一旦这个方法加了下划线， 代表私有，只能在类里边用
    def say(self):
        print('password',self.__password)

m = My()
m.test()
# print(m.__password)
m.say()

　　三、继承

class Lm :
    money = 1000
    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()