面向对象（五）

#Python中的私有在属性或方法前加双下即可
class Person:
    __country=‘China‘#私有静态属性

    def __init__(self,name,age):
        self.name=name
        self.__age=age#对象的私有属性

    def __func(self):#私有方法
        print(‘in __func ‘)

    def func1(self):
        print(Person.__country)
        Person.__func(self)

class A(Person):
    def func(self):
        Person.__country
        Person.__func(self)
        print(self.__age)

# 私有静态属性：
    # 类的外部:不可以
    # print(Person.__country)

    #类的内部：可以
    # Person.func1(1)

    #对象可以查看私有静态属性？ 不可以
    # obj=Person()
    # print(obj.__country)

# 私有方法：
    # 类的外部：不可以
    # Person.__func(1)

    # 类的内部：可以

    # 对象掉用私有方法可以吗？不可以
    # obj=Person()
    # obj.__func()

# 对象的私有属性
    # 类的外部：不可以
    # obj=Person()
    # print(obj.__age)
    
    # 类的内部：可以
    
    # 子类调用？也不可以

# 这些私有的属性，方法的本质是名字前面加了_类名，变相的私有
# 总结：私有的属性，方法只能内部使用

class A:
    def __init__(self):#双下方法，特殊方法
        pass
    
    def func(self):#实例化方法，给对象用的方法，会默认把对象传递给第一个参数self
        pass

    @classmethod
    def class_method(cls):#类方法，给类使用的方法，它会默认把本类传递给第一个参数cls
        pass

    @staticmethod
    def static_method():#不依赖于类和对象，只是一个函数
        pass

    @property
    def price(self):#属性，有一些方法名，听起来像属性的
        pass

# 实例化一个对象，最后得到对象的总数
class Student:
    __count=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
        Student.sum_num()

    @classmethod
    def sum_num(cls):
        cls.__count+=1

    @classmethod
    def get_count(cls):
        return cls.__count

alex=Student(‘alex‘,10)
alex1=Student(‘alex1‘,10)
alex2=Student(‘alex2‘,10)
# print(alex2.get_count())
ret=Student.get_count()
print(ret)

# 总结：
# 类方法一般是用来操作静态属性的，与对象无关的时候需要调用类方法
# 对象也可以调用类方法，不推荐

#静态方法是一个独立的，单纯的函数
#譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数
import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)
#总结：对象和类都可以掉静态方法

class Goods:
    def __init__(self,name,origi_price,discount,):
        self.name=name
        self.origi_price=origi_price
        self.discount=discount

    @property
    def price(self):
        return self.origi_price*self.discount

apple=Goods(‘苹果‘,5,0.8)
print(apple.price)
# 总结：属性装饰的是一些函数名听起来很像属性的方法。
#         只要对象调用，就行其中的代码

# 属性的全解
class A:

    @property
    def price(self):
        print(‘对象调用我‘)

    @price.setter
    def price(self,new):
        print(‘对象修改我‘)

    @price.deleter
    def price(self):
        print(‘对象删除我‘)

a=A()
a.price#对象调用我
a.price=1#对象修改我
del a.price#对象删除我
# 总结：
# 这些调用的本质是在触发，一旦触发就执行其中的代码
# 不推荐，在对象的属性与property伪装的属性（方法）同名，有坑

class A:
    pass

class B(A):
    pass

obj=B()

print(isinstance(obj,B))
print(isinstance(obj,A))
# isinstance(o,a)是判断o是不是这个类（这个类的派生类)的对象

print(issubclass(B,A))
#判断B是不是A的子类

# 反射：通过字符串对对象进行操作
# 可以操作的对象有：
#     实例化的对象，类，本模块，其他模块（可以.的都可以反射）
# hasattr()
# getattr()
# setattr()
# delattr()

# 实例化的对象
class A:
    country=‘China‘
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def func(self):
        print(‘in func‘)

obj=A(‘alex‘,18)
if hasattr(obj,‘name‘):
    print(getattr(obj,‘name‘))
增
setattr(obj,‘sex‘,‘man‘)
print(obj.__dict__)
删delattr(obj,‘sex‘)
print(obj.__dict__)



# 具体应用
class User:
    def login(self):
        print(‘登陆‘)
    def register(self):
        print(‘注册‘)
obj=User()
while 1:
    msg=input(‘>>>‘).strip()
    if hasattr(obj,msg):
        getattr(obj,msg)()