17_python_成员

一、类成员

1、字段

 class Province:
     country ＝ '中国'     # 实例 (静态) 字段；类变量. 不属于对象, 对象可以访问

     def __init__(self, name):
         self.name = name   # 普通字段

 obj = Province('河北省')   # 直接访问普通字段
 print obj.name

 Province.country    # 直接访问静态字段
 obj.country = "澳大利亚" # 注意。 这里和类变量没由一毛钱关系, 给alex单独加一个属性叫country = ”澳大利亚“
 print(obj.country) # 澳大利亚 # 拿到的是自己的。成员实例变量 字段
 # 总结：类变量，用类名去操作. 规范.

 由上图可是：静态字段在内存中只保存一份；普通字段在每个对象中都要保存一份

 

    2、方法 -- 普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同

    

        普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；

        类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

        静态方法：由类调用；无默认参数；

 class Person:

     def __init__(self):
         pass
     # 实例方法需要传递类的对象 self
     def think(self):
         print("人能思考")

     # 静态方法不需要传递对象或者类
     @staticmethod # 静态方法
     def jisuan(a, b):
         print("我来过这里")
         return a + b

     # 类方法: 第一个参数传递的是类名
     @classmethod
     def clsMethod(cls): # cls表示的类
         p = cls() # 可以动态的创建对象.
         print("我是一个类方法", p)

 # p = Person()
 # p.think()
 #
 # Person.think(p)

 # 静态方法的调用：

 # c = Person.jisuan(1, 2) #  类名可以访问
 # print(c)
 #
 # p = Person()
 # d = p.jisuan(3, 5) # 用对象也可以访问
 # print(d)

 # 记住, 静态的内容用类名访问

 Person.clsMethod() # 类方法默认第一个参数接收的是类名

 相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
 不同点：方法调用者不同、调用方法时自动传入的参数不同。

3、属性

 

    (1) 属性的基本使用

 # ############### 定义 ###############
 class Foo:

     def func(self):
         pass

     # 定义属性
     @property
     def prop(self):
         pass
 # ############### 调用 ###############
 foo_obj = Foo()

 foo_obj.func()
 foo_obj.prop   #调用属性

 属性的定义和使用

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据 

 # ############### 定义 ###############
 class Pager:

     def __init__(self, current_page):
         # 用户当前请求的页码（第一页、第二页...）
         self.current_page = current_page
         # 每页默认显示10条数据
         self.per_items = 10

     @property
     def start(self):
         val = (self.current_page - 1) * self.per_items
         return val

     @property
     def end(self):
         val = self.current_page * self.per_items
         return val

 # ############### 调用 ###############

 p = Pager(1)
 p.start 就是起始值，即：m
 p.end   就是结束值，即：n

二、类成员的修饰符

 

    公有成员，在任何地方都能访问

    私有成员，只有在类的内部才能方法

 

    1、私有成员

 class Person:
     def __init__(self, laopo, mimi):
             self.__laopo = laopo    # 私有的
             self.__mimi = mimi

 alex = Person("wusir", "他俩搞基")
 print(alex.__mimi) # 私有的. 谁都不不能碰，会报错

    可以 通过这个公共的方法来获取到私有的内容. 这样做的好处是. 外界, 只能看, 但是改不了. 不单单实例变量有私有的. 类变量(静态变量量)一样拥有这样的属性:

 class Person:
     __zisi = "人都是自私的"      # 人都是自私的. 但是这个自私又不希望别人知道
     def __init__(self, laopo, mimi):
         self.__laopo = laopo    # 私有的
         self.__mimi = mimi
     def gaosuni(self):
             print("大喇喇叭开始广播了了")
             return self.__mimi
 alex = Person("wusir", "他俩搞基")
 mimi = alex.gaosuni()
 print(mimi)
 print(Person.__zisi)    # 报错

 class Person:
     __zisi = '人都是自私的'
     def __init__(self, laopo, mimi):
         self.__laopo = laopo
         self.__mimi = mimi
     def gaosuni(self):
         print('大喇叭开始广播了')
         return self.__mimi

 alex = Person('wusir', '他俩搞基')
 mimi = alex.gaosuni()
 print(mimi)
 print(Person.__zisi) #报错

 

    2、私有方法

 class Person:
     def __init__(self):
         pass
     def __yue(self):     # __yue是⼀一个私有的⽅方法. 只能在类中⾃自⼰己调⽤用. 类外⾯面不能访问.
         print('我要约会')
     def job(self):
         print('我要工作')

 p = Person()
 # p.__yue() 报错
 p.job()

子类无法继承私有方法