python 进阶 面向对象（二）

# s1模块
 class Foo:
     
      country = "China" # 静态字段，存在类中

      def __init__(self, name):
           self.name = name # 普通字段，对象中
  
      # 普通方法，类中
      def show(self):
          print("show")

      # 静态方法，类中
      @staticmethod
      def xo(arg1, arg2):
          print("XO")

obj = Foo("xinmin")
# 反射：以字符串的形式去对象（模块）中操作其成员
# 反射：类，只能找类里的成员
r = hasattr(Foo, ''show")
print(r) # True
# 反射：对象， 既可以找对象，也可以找类的成员
r1 = hasattr(obj, 'name')
print(r1) # True
r2 = hasattr(obj, 'show')
print(r2) # True

# 导入模块
m = __import__('s1', fromlist=True)
# 去模块中寻找类
class_name = getattr(m, "Foo")
# 创建对象
obj = class_name("xinmin")
# 去对象中找name 对应的值
val = getattr(obj, 'name')
print(val)

在python中都可通过：类，对象 ====》静态字段，静态方法，普通方法、类的方法

通过类访问的有：静态字段，静态方法，类方法（特殊的静态方法）

通过对象访问的有：普通字段，类的方法

class Provice:
     # 静态字段
     country = "中国"
     # 构造方法
     def __init__(self, name):
         # 普通字段，对象中
         self.name = name
     # 类方法
     @classmethod
     def xxoo(cls): # cls就是当前类名
         print("xxoo")
     # 静态方法
     @staticmethod
     def xo(arg1, arg2):
         print("xo")
     # 普通方法，类中
     def show(self):
         print("show")
     # 普通方法
     def start(self):
         temp = "%s xxx" %self.name 
         return temp
     # python特性：将方法伪装成字段，访问时不需要加括号，但带参数则报错
     @property
     def end(self):
         temp = "%s xxx" %self.name 
         return temp   
     @end.setter
     def end(self, value):
         print(value)
         self.name = value
         
obj = Provice("xinmin")
# print(obj.name) # xinmin
ret1 = obj.start() 
print(ret1) # xinmin xxx
# 获取特性
ret2 = obj.end
print(ret2) # xinmin xxx
# 设置特性
obj.end = "xxoo" # xxoo
print(obj.end) # xxoo xxx

• 成员：
  • 字段 ： 静态字段（每个对象都有一份）、普通字段（每个对象都是不同的数据）
  • 方法 ： 静态方法（无需使用对象封装的内容）、普通方法（使用对象中的数据）、类方法
  • 特性： 普通特性（将方法伪装成字段）
    快速判断，类执行，还是对象执行
  • self：对象调用
  • 无self：类调用