Python面向对象

面向对象基础：实例/对象、实例化

举例，有个买车处，可以包含买车、买保险、交税、上牌

#面向过程
def buyCar():
    print(‘买车‘)
def baoxian():
    print(‘保险‘)
def jiaoshui():
    print(‘交税‘)
def shangpai():
    print(‘上牌‘)
buyCar()
baoxian()
jiaoshui()
shangpai()


# 面向对象，把方法写在类中
class BuyCar:
    def buyCar(self,):
        print(‘买车‘)

    def baoxian(self,):
        print(‘保险‘)

    def jiaoshui(self,):
        print(‘交税‘)
    def shangpai(self):
        print(‘上牌‘)

xw = BuyCar()#实例化，xw是实例，也可以叫对象
xw.buyCar()# 调用方法
xw.baoxian()
xw.jiaoshui()
xw.shangpai()

面向对象：封装

构造函数、私有方法

# 数据库类
import pymysql
class Db:

    # 构造函数，类在实例化的时候会自动执行构造函数，会把参数传入
    def __init__(self, host, user, password, db, port=3306, charset=‘utf8‘):
        self.db_info = {‘user‘: user, ‘password‘: password, "db": db, "port": port, ‘charset‘: charset,
                        ‘autocommit‘: True, ‘host‘: host}
        self.__connect()

    # 私有方法：加两个下划线，只能在类里面调用，出了类就不行了
    def __connect(self):  # 连接数据库
        try:
            self.conn = pymysql.connect(**self.db_info)  # 建立连接
        except Exception as e:
            # print("连接不上数据库")
            raise Exception("连接不上数据库,请检查数据库连接信息")  # raise主动抛出一个异常
        else:
            self.cur = self.conn.cursor(pymysql.cursors.DictCursor)

    def execute_one(self, sql):  # 执行sql
        self.cur.execute(sql)
        return self.cur.fetchone()

    def __close(self):  # 关闭
        self.conn.close()
        self.cur.close()


mysql = Db(‘118.24.3.40‘, ‘jxz‘, ‘123456‘, ‘jxz‘)  # 实例化，并传入参数
result = mysql.execute_one(‘select * from app_myuser;‘)

类、类变量、实例变量、私有变量构造方法、析构方法、静态方法、类方法、实例方法、属性方法

class Person:  # 经典类
    country = ‘China‘ # 类变量
    base_price = 8000# 价格
    discount = 0.1#折扣

    # 构造方法，类在实例化的时候会自动执行构造函数，会把参数传入
    def __init__(self, uid, name):
        print(‘self的内存地址:‘, id(self))
        self.id = uid  # 实例变量
        self.name = name  # pep8
        self.__base_price = 8000#私有变量：加两个下划线，只能在类里面用,出了类就不行了

    # 析构方法：实例被销毁的时候自动调用的方法，不再占用内存
    def __del__(self):
        print("析构方法")

    # 静态方法：只是写在类里面的一个方法，不能使用类变量,调用不了其他的类方法。
    @staticmethod
    def help():
        print("静态方法")

    # 类方法，不需要实例化，需要加上装饰器 @classmethod
    @classmethod
    def sayCountry(cls):
        cls.getClassname()
        print(cls.country)


    # 实例方法：带有self的方法，必须要实例化之后才能使用的函数
    def housework(self):
        print(‘%s正在做家务‘ % self.name)
        print(‘国籍是%s‘ % self.country)

    #属性方法：看起来像变量的一个方法，无参数。
    @property
    def price(self,):
        return self.base_price - self.base_price * self.discount#计算价格


Person.country = ‘USA‘
Person.sayCountry()
xh = Person(1, ‘小黑‘) 
xh.housework() 
xh.sayCountry()
xh.help()
print(xh.country)

面向对象：继承

继承、重写、私有方法无法继承、mro算法

#父类
class Lw:
    money = 500000
    def make_money(self):
        print(‘挣钱 50000‘)
    def __driver(self): #私有方法无法被继承
        print(‘开车‘)
#父类2
class Ll:
    def cook(self):
        print(‘做饭‘)
    def make_money(self):
        print(‘挣钱一万‘)

#子类
#python中子类可以继承多个父类，java只能一个
class Xw(Lw,Ll):
    def make_money(self): #重写，和父类的方法名一样，先调用自己的方法
        print(‘挣钱‘)


xw = Xw()
print(Xw.mro())#mro算法，告诉我们调用子类按什么顺序查找方法
# [<class ‘__main__.Xw‘>, <class ‘__main__.Lw‘>, <class ‘__main__.Ll‘>, <class ‘object‘>]
xw.make_money()# 子类调用重写的方法
xw.cook()#调用父类的方法