python -- 面向对象-成员

1、成员

 

    在类中，你能写的所有内容都是类的成员

 

2、变量

 

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

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)

2、类变量：变量属于类，但是对象也可以访问

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)

 

3、方法

 

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

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

class Computer:
 
    #实例方法（成员方法）
    def play(self):
        print('电脑可以玩游戏')
 
    # 在定义实例方法的时候，必须给出一个参数self
    # 形参的第一个参数，自动的把对象给传递进来
 
    def work(self):  # self是当前类的对象
        print(self)
        print('电脑可以用来工作')
 
c = Computer()
c.work() # 调用的时候不需要手动的给出self
print(c)

 

    2、类方法（@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() # 类方法

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

           静态方法一般跟类方法差不多，使用类名去访问。

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

class Quit:
 
    @staticmethod
    def meet():
        print('会议保持安静')
 
# 静态方法可以使用对象访问，也可以使用类名访问，但是一般推荐使用类名访问
c = Quit()
c.meet()
 
# 推荐使用类名访问
Quit.meet()

4、类的成员 - 属性

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

        在方法上添加一个@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是一个方法，不是一个变量

注意：

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

    2、方法上方要写@property

    3、调用的时候，不需要写括号，直接当成属性变量来使用就可以了

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

 

 

5、私有

 

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

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

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

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