python -- 面向对象-成员

一、成员

 

    在类中，你能写的全部内容都是类的成员

 

二、变量

 

       一、实例变量：由对象去访问的变量，通常使用是  对象 . 属性

class Person:
    def __init__(self,name,gender,hobby):
        self.name = name    # 实例变量   对象里的变量
        self.gender = gender
        self.hobby = hobby

s = Person('张三','男','打篮球')

print(s.hobby)

s.hobby = '踢足球'

print(s.hobby)

二、类变量：变量属于类，可是对象也能够访问 

class Person:
    country = '中国'

    def __init__(self,name,gender):
        self.name = name
        self.gender = gender

c = Person('Ann','女')
b = Person('Bob','男')

print(Person.country)
c.country = '大清'  # 大坑，没有修改类变量

print(c.country)  # 类变量能够给对象使用
print(b.country)

 

三、方法

 

    一、实例方法：对象直接访问的方法叫实例方法（成员方法）   使用   对象.方法（）

        特色：再申明的时候，须要给self，self必须放在第一个位置，在调用的时候，自动的会把对象传给形参的self

class Computer:

    #实例方法（成员方法）
    def play(self):
        print('电脑能够玩游戏')

    # 在定义实例方法的时候，必须给出一个参数self
    # 形参的第一个参数，自动的把对象给传递进来

    def work(self):  # self是当前类的对象
        print(self)
        print('电脑能够用来工做')

c = Computer()
c.work() # 调用的时候不须要手动的给出self
print(c)

View Code

 

    二、类方法（@classmathod）：类方法是属于类的

        特色：在申明的时候须要给出一个可以接受类名的参数，cls，也必须放在参数的第一个，在调用的时候，自动得把xx对象的类传递给cls

 

        类方法和静态方法差很少，只不过类方法须要在参数列表中的第一个位置预留一个参数位置cls， 类方法在被调用的时候也不须要传递实例参数，系统会自动的把类传递给第一个参数。

class Person:
    # 实例方法
    def eat(self):
        print('吃遍山珍海味')

    @classmethod  # 装饰器，此时这个方法是一个类方法
    def talk(cls):  # 此时接收到的cls是类名
        print('自言自语')

# # 用对象访问
# s = Person()
# s.talk()  # 在调用类方法的时候，默认的把类名传递给类方法
# print(Person)

# 类方法通常用类名访问
Person.talk() # 类方法

View Code

三、静态方法（@staticmethod）：静态方法也是属于类的，静态方法就比如，咱们在类中定义了一个函数

           静态方法通常跟类方法差很少，使用类名去访问。

           静态方法不须要咱们给方法传递self，也就是说，当出现一个方法不须要使用到成员变量的时候，就能够选择使用静态方法。

class Quit:

    @staticmethod
    def meet():
        print('会议保持安静')

# 静态方法可使用对象访问，也可使用类名访问，可是通常推荐使用类名访问
c = Quit()
c.meet()

# 推荐使用类名访问
Quit.meet()

View Code

四、类的成员 - 属性

 

class Person:

    __qie = 'beauty'

    def __init(self,name,secret):
        self.name = name
        self.__secret = secret  # 私有内容  实例变量

    def tell(self):
        print(f"你的秘密是{self.__secret}")
        print(Person.__qie) # 私有的类变量只能在类中调用
        return self.__secret

    def __dream(self): # 私有的实例方法
        print('个人梦想是..')

    @staticmethod
    def __think():
        print('当心思')

    @classmethod
    def  __work(cls):
        print('我的工做')


p =Person('zhangmeng','过去的生活')
# print(p.__secret)  # 私有的内容只能在类中调用
#
# p.tell()
# print(Person.__qie)

# p.__dream()
# Person.__work()

View Code

 

        在方法上添加一个@property，能够把一个方法变成一个属性，可是这个属性不能够被赋值

        当咱们某一个属性必须通过计算才能获得结果的时候。

class Person:
    def __init__(self,name,hobby,birth):
        self.name = name
        self.hobby = hobby
        self.birth = birth
    # 年龄应该是算出来的，而不是直接存储

    @property # 把一个方法更改为一个属性，每次拿属性的时候都会自动的去执行这个方法
            # 方法的返回值就是属性值
    def age(self): # 实例方法
        print('个人年龄')
        return 2018 - self.birth

c = Person('zhangmeng','dance',1999)
# c.age
print(c.age)  # 看着像一个变量同样使用，实际上这里是调用的一个方法

# c.age = 26  # 不能够，由于age是一个方法，不是一个变量

View Code

注意：

    一、方法参数只能有一个self

    二、方法上方要写@property

    三、调用的时候，不须要写括号，直接当成属性变量来使用就能够了

    四、这种套路只能取值，不能设置值

 

 

五、私有

 

        全部以双下划线开头的方法，变量都是私有内容，

        私有的内容不能直接访问，可是若是对方开辟了外界访问的通道，那能够经过这个公共的方法来获取到私有的内容，这样作的好处是，外界只能看，可是不能更改。

        对于私有的内容而言，子类是没法继承的。

class Person:

    __qie = 'beauty'

    def __init(self,name,secret):
        self.name = name
        self.__secret = secret  # 私有内容  实例变量

    def tell(self):
        print(f"你的秘密是{self.__secret}")
        print(Person.__qie) # 私有的类变量只能在类中调用
        return self.__secret

    def __dream(self): # 私有的实例方法
        print('个人梦想是..')

    @staticmethod
    def __think():
        print('当心思')

    @classmethod
    def  __work(cls):
        print('我的工做')


p =Person('zhangmeng','过去的生活')
# print(p.__secret)  # 私有的内容只能在类中调用
#
# p.tell()
# print(Person.__qie)

# p.__dream()
# Person.__work()

View Code