类 反射

# 对象 = 类名()
# 过程：
    # 类名() 首先 会创造出一个对象，创建了一个self变量
    # 调用init方法，类名括号里的参数会被这里接收
    # 执行init方法
    # 返回self
# 对象能做的事：
    # 查看属性
    # 调用方法
    # __dict__ 对于对象的增删改查操作都可以通过字典的语法进行
# 类名能做的事：
    # 实例化
    # 调用方法 : 只不过要自己传递self参数
    # 调用类中的属性,也就是调用静态属性
    # __dict__ 对于类中的名字只能看 不能操作
    
# @property     # 不加括号就能调用方法，像调用属性一样        # 是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值    
# @classmethod     # 类名.方法名()就可调用，像调用def定义的函数一样，不依赖类，# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法
# @staticmethod # 类名.方法名()如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

#     @property            # 变属性
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price
    @price.setter        # 设置属性
    def price(self, value):
        self.original_price = value
    @price.deleter        # 删除属性
    def price(self):
        del self.original_price
# obj.price         # 获取商品价格
# obj.price = 200   # 修改商品原价
# del obj.price     # 删除商品原价
# 
# 组合 ：一个对象的属性值是另外一个类的对象
# print(AB_son.__bases__)    # 查看继承的父类
# 
# 调用对象的所有的属性或方法，如果没有就到父类中找
# 
# # class Person(Animal):
#         # __key = 123  # 私有静态属性
#     def __init__(self,name,aggr,hp,sex):
#         Animal.__init__(self,name,aggr,hp)    #  方式1
        # super().__init__(name,aggr,hp)        # 方式二 只在新式类中有，python3中所有类都是新式类
# # super(类名,实例名).eat()    # 类外调用父类的方法
# super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

# 父类中没有的属性 在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
    # 如果还想用父类的，单独调用父类的:
    #       父类名.方法名 需要自己传self参数
    #       super().方法名 不需要自己传self
# 正常的代码中 单继承 === 减少了代码的重复
# 继承表达的是一种 子类是父类的关系
# 
# # 新式类中的继承顺序 ： 广度优先            # 多继承找父类，先检测，如果后一个父类不能到达的地方就使用深度继承，一条路走到底，
　　　　　　　　　　　　　　　　　　　　　　　　　　# 如果后一个也能到达就在此打住走另一条路，找到为止。
# print(类名.__mro__)    # mro方法只在新式类中存在
# 
# 在属性和方法前加__ ,所有的私有的 都不能在类的外部使用
# 
# class Goods:
#     __discount = 0.8
#     def __init__(self,name,price):
#         self.name = name
#         self.__price = price
#     @property
#     def price(self):
#         return self.__price * Goods.__discount
#     @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
#     def change_discount(cls,new_discount):  # 修改折扣
#         cls.__discount = new_discount
# apple = Goods('苹果',5)
# print(apple.price)
# Goods.change_discount(0.5)   # Goods.change_discount(Goods)
# print(apple.price)
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法
# 
# # 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法
# # 静态方法 没有默认的参数 就象函数一样
# 



# isinstance(obj,cls)检查是否obj是否是类 cls 的对象
# issubclass(sub, super)检查sub类是否是 super 类的派生类 
# 反射对象中的属性和方法   # hasattr getattr setattr delattr

# print(hasattr(obj,'name'))                # 检测是否含有某属性
# getattr(object, name, default=None):        # n=getattr(obj,'name')    #获取属性    # 返回地址加括号调用
# # Get a named attribute from an object ，getattr(x, 'y') is equivalent to x.y.
# setattr(x, y, v):                         # setattr(obj,'sb',True)    # 设置属性
# # setattr(x, 'y', v) is equivalent to "x.y = v"
# delattr(x, y):                            # delattr(obj,'show_name111')    # 删除属性#不存在,则报错
# Deletes the named attribute from the given object.delattr(x, 'y') is equivalent to ``del x.y''

# class Foo(object):    # 类也是对象
    staticField = "old boy"
    def __init__(self):
        self.name = 'wupeiqi'
    def func(self):
        return 'func'
    @staticmethod
    def bar():
        return 'bar'
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')
# 
# 改变对象的字符串显示__str__,__repr__
# 自定制格式化字符串__format__
# 析构方法，当对象在内存中被释放时，自动触发执行。__del__
# __new__
# 对象后面加括号，触发执行。__call__    # 对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
# __len__
# __hash__
# __eq__
# __getitem__,__setitem__,__delitem__

 

如果在实例化对象的过程中，可以通过 __new__ 方法来决定是否要实例化类对象

# def __new__(cls, config, *args, **kwargs):
    if config == '':
        # 如果不符合，就不实例化对象
        return
    else:
        # 符合，调用父类来实例化当前类对象
        return super().__new__(cls)

class useDatabase:
    '''self.cmd 数据库交互   self.upload 上传数据 '''
    def __new__(cls, conn_info, *args, **kwargs):
        cls.host = str(conn_info['host']).strip()
        cls.user = str(conn_info['user']).strip()
        cls.password = str(conn_info['password']).strip()
        cls.database = str(conn_info['database']).strip()
        if cls.host == '':
            print('地址不能为空')
            return
        if cls.user == '':
            print('用户名不能为空')
            return
        if cls.password == '':
            print('没有密码，可能登陆失败，即使登陆成功也存在安全隐患！')
            if input('是(y)否尝试登陆？').strip().lower() != 'y': return
        return super().__new__(cls)

    def __init__(self,conn_info):
        # conn_info = {'host':"localhost", 'user':'root', 'password':'','database':''}
        # print(self.__dict__)  # {}
        self.conn = pymysql.connect(host=self.host,user=self.user,password=self.password,database=self.database)
        self.cursor = self.conn.cursor()
        # print(self.__dict__)  # {'cursor': <pymysql.cursors.Cursor object at 0x000000ADFDD54CC0>,
　　　　　　　　　　　　　　　　　　　　#　 'conn': <pymysql.connections.Connection object at 0x000000ADFDD54AC8>}

没有返回cls是不会执行__init__ 方法的 　　实例化类的返回值就是new中的return值