几个内置方法

‘‘‘子类不能继承父类的私有方法‘‘‘
‘‘‘
class Son(object):
    A=123
    __AB=234
    # print(__AB) # 只能在内部查看,内部会自动翻译成 ‘_Son__AB‘: 234, 也就是_类名__AB
# print(Son.__AB)  # 报错 私有属性不能在外部查看

# print(Son.__dict__) # 查看所有静态属性


class Foo(Son):
    def func(self):
        print(Foo.A) # 子类没有找父类 所以打印结果为 123
        # print(Son.__AB)   当前类(就是你在谁那就会变成谁的)会自动帮你翻译成_Foo__AB会自动加上类名,这样的东西在父类中是没有的,所以他会报错.

print(Foo().func())

# __这个变量出现在哪个类中,就会在变形的时候 加上这个类的类名
# 所以在子类中使用私有的名字,会加上子类的名字
# 这样就不可能调用加上了父类名字的静态变量了‘‘‘

# class Foo(object):
#     def __init__(self):
#         self.__func() # 此时翻译为_Foo__func
#     def __func(self):
#         print(‘你好‘)  # 所以打印的是这个
#     def func(self):
#         print(‘你不好‘)
# class Son(Foo):
#     def __func(self):
#         print(‘不好‘)
#     def func(self):
#         print(‘好‘)
# Son()
# print(Foo.__dict__)
‘‘‘
调用私有的方法或者属性
    不需要考虑self是谁的对象
    只要是私有的方法或者属性,就一定是在调用的当前类中执行方法
当某个方法或者属性,不希望被子类继承的时候,也可以把这个方法\属性定义为私有成员
   ‘‘‘
# 二   类中的几个装饰器函数

# class A:
#     __count=0
#     def __init__(self,name):
#         self.name=name
#         self.__add_count()
#     # def __add_count(self): # 常规写法,但是写完之后你会发现,这个作用根本就用不到self,也就没有对象什么事(不需要这个self参数)
#     #     A.__count+=1
#     @classmethod  # 类方法
#     def __add_count(cls): # 顺便说 定义一个私有方法,目的是让这个方法在类的内部使用
#         cls.__count+=1    # 相当于类名点方法了
#     @classmethod
#     def show_count(cls):
#         return cls.__count # 让用户从外部查看__count的值
#
# print(A(33).show_count()) #对象操作方法
# print(A.show_count()) # 类名直接操作方法
‘‘‘
# 在类中会有一种情况,就是这个方法并不需要使用某一个对象的属性
# 因此这个方法中的self完全是一个没用的参数
# show_count是一个查看类中属性的方法,这样的方法和某一个对象并没有直接联系
# 本质上,一个方法不使用对象属性,但使用静态属性---就是类方法@classmothd
# 调用这个方法,可以使用对象调用,也可以是用类调用
# 但是这个方法的默认参数永远是当前类的名称空间,而不是对象的
‘‘‘

# (2)
# 如果一个类中的方法不用对象属性也不用静态属性__就是静态方法@staticmethod
# 那实际上这个方法就是一个普通的函数

# 那综上所述大体总结:
‘‘‘                             普通方法                类方法                 静态方法
默认参数                        self                    cls                     无
操作的变量                       操作对象的属性         操作静态属性              既不操作对象属性,也不操作类属性
所属的命名空间                    类                    类                       类
调用方式                          对象调用              类或对象                    类/对象
对应的装饰器                      无                      @ classmethod            @staticmethod
‘‘‘

# 三   反射(hasattr,getattr,setattr,delattr)
# 什么意思呢 :你希望能够通过这个字符串-->程序中的变量名(类名\函数\变量名\方法名\对象名)
# 例如:

# class Person:
#     role = ‘人类‘
#     Country = ‘中国‘
#
# attr = input(‘>>>‘)  # role 人类
#                    # Country 中国
# print(getattr(Person,‘role‘))
# print(getattr(Person,‘Country‘))
# if hasattr(Person,attr):
#     print(getattr(Person,attr)) # 把你所获取到的字符串变成代码

  # 所有 的a点b都可以被反射成getattr(a,"b")
# 反射中的方法
class Person():
    role=‘人类‘
    @staticmethod
    def show_courses():
        print(‘所偶有课成‘)
# Person.role==getattr(Person,‘role‘) # 这句仅仅是判断他是不是等于他

# print(Person.role)
print(getattr(Person,‘role‘))
# Person.show_courses() == getattr(Person,‘show_courses‘)()
ret = getattr(Person,‘show_courses‘)
ret() # 如果是方法就返回方法 调用的时候加括号

lass Foo:
    f = ‘类的静态变量‘
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print(‘hi,%s‘%self.name)

obj=Foo(‘egon‘,73)
print(obj.__dict__)
setattr(obj,‘sex‘,‘男‘)
obj.habby=‘run‘
print(obj.__dict__)
delattr(obj,‘name‘)
print(obj.__dict__)
setattr(Foo,‘f‘,‘李四‘)
print(Foo.__dict__)
print(obj.age,Foo.f)