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()

子类无法继承私有方法