成员 - 亿夏网

主要内容:

1. 类的成员
2. 类的成员-变量
3. 类的成员-方法
4. 类的成员-属性
5. 私有

1.类的成员

首先, 什么是类的成员, 很简单. 你能在类中写什什么? 写的内容就是成员,到目前为止,我们已经学过了一些成员(类中定义的变量和方法)

class Movie:
    def __init__(self,genre,language,name,time):
        self.genre=genre
        self.language=language
        self.name=name
        self.time=time
    def show(self):
        print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")

在上面代码中__init__和show都属于类的成员方法又称为实例方法. 这样的东西需要用对象来访问.

而self.属性1 = 参数1 这个代码的含义是给对象设置属性信息,在实例化后将实例化对象的内存地址传给self此时,并对对象的属性进行初始化,即xxx属性是xxxx. 这种东西又被称之为成员变量或者实例变量, 再或者被称之为字段.

2. 类的成员-变量

(1) 实例变量(字段)
(2) 类变量(静态变量)

每个实例都应该拥有的变量. 比如.在上述事例中电影的的名字,电影的类型, 电影的语言,电影的时长.,都是实例变量

而类变量就是这一类事物统一拥有的变量 ,比如上述事例中可以说这些个电影都可以是3D(规定下):

class Movie:
    film_format="3D"
    def __init__(self,genre,language,name,time):
        self.genre=genre
        self.language=language
        self.name=name
        self.time=time
    def show(self):
        print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")
print(M1.film_format)                             #3D

class Movie:
    film_format="3D"
    def __init__(self,genre,language,name,time):
        self.genre=genre
        self.language=language
        self.name=name
        self.time=time
    def show(self):
        print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")
Movie.film_format="2D"                    #把类变量中的值改了,都跟着变了. 
print(M1.film_format)                     #2D
print(M2.film_format)                     #2D

class Movie:
    film_format="3D"
    def __init__(self,genre,language,name,time):
        self.genre=genre
        self.language=language
        self.name=name
        self.time=time
    def show(self):
        print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")
M1.film_format="2D"
print(M1.film_format)                   #2D
print(M2.film_format)                   #3D

后面的代码结果不一致,因为在执行M1.film_format="2D"时,并没有去改变类中的film_format,而是给对象添加了⼀个实例变量. 并且这个实例变量,只有当前的M1是存在的. 在M2中是不存在的.
通过这里. 我们应该能发现,类变量最好是用类名来访问,当然, 我们通过对象名也可以访问. 但只能看, 不能改变它,想要改变它, 需要用类名来改变它.

3. 类的成员-方法

(1) 成员方法(实例方法)
(2)静态方法
(3)类方法

(1) 成员方法: 就是对象直接访问的方法叫成员方法.

class Computer:       
     # 实例方法(成员方法)    
    def play(self):        
        print("我的电脑可以玩⼉儿") 
c = Computer() 
c.play()    # 对象直接去调用实例方法

(2)静态方法: 即不需要给方法传递self. 也就是说. 当出现⼀个方法不需要用到成员变量时,就可以选择使用静态方法.

需要我们在方法上面添加一个@staticmethod

class Person:
    def __init__(self):
        pass
    # 实例方法需要传递类的对象 self
    def think(self):
        print("人能思考")
    # 静态方法不需要传递对象或者类
    @staticmethod # 静态方法
    def calculate(a, b):
        print("我来过这里")
        return a + b
c = Person.calculate(1, 2) #  类名可以访问
print(c)
p = Person()
d = p.calculate(3, 5) # 用对象也可以访问, 但最好不要这么干,以便于区分静态方法和实例方法
print(d)

(3)类方法:当方法需要传递类名的时候. 需要类方法.

类方法在编写的时候, 需要在类方法上面添加@classmetho

class Person:
    def __init__(self):
        pass
    # 实例方法需要传递类的对象 self
    def think(self):
        print("人能思考")
    # 类方法: 第一个参数传递的是类名
    @classmethod
    def clsMethod(cls): # cls表示的类
        p = cls() # 可以动态的创建对象.
        print("我是一个类方法", p) #我是一个类方法 <__main__.Person object at 0x00000188873E7940>
Person.clsMethod() # 类方法默认第一个参数接收的是类名

4. 类的成员-属性

属性其实就是通过方法改造过来的一种变量的写法, 在方法上添加一个@property就可以了

class Person:
    def __init__(self, name, num, gender, birthday):
        self.name = name
        self.num = num
        self.gender = gender
        self.birthday = birthday
    @property # 表示当前方法是一个属性. 方法的返回值就是这个属性的值
    def age(self): # 方法只能有一个参数, self
        return 10 #   可以是个计算结果 必须有返回值
p = Person("alex", "10086", "不详", "1989年12月1日")
print(p.age) # 可以直接访问属性, 实际*问的是age()方法. 返回值就是属性值

应用场景:

我们⼀般保存数据的时候, 不会保存⼀个⼈的年龄. 因为随着时间的推移. 每个人的年年龄都时刻在改变着. 那如何保存更更加完美呢? 很简单. 保存出生年年月日. 然后用程序来计算,你当前的年龄实时的那这个时候就需要进行行相应的计算了了. 而计算属于⼀个功能. 当然要写方法里了. 但是对于年年龄这个属性而言. 他应该是一个数值. 而不是动作. 所以python 就提供了这样⼀种机制. 通过方法来描述⼀个属性.

注意:

1.方法参数只能有⼀个self
2. 方法上方要写@property
3. 调用的时候, 我们不需要写括号. 直接当成属性变量量来用就可
4. 这种套路只能取值. 不能设置值

5. 私有

在python中使用__作为方法或者变量的前缀,那么这个方法或者变量就是一个私有的.

(1)私有变量

class Tiger:
    def __init__(self,name,figure,style,qingfu,money,fangchan):
        self.name = name
        self.figure = figure
        self.style = style
        self.__qingfu = qingfu
        self.__money = money
        self.__fangchan=fangchan
    def buy(self):
        print("我有%s这么多钱" % self.__money)
T1=Tiger("呵呵","正直","廉洁","潘潘","10亿","10套")
print(T1._money)

程序报错,私有的内容是访问不到的,但是,这个访问不到是有⼀定的局限性的比如:

class Tiger:
    def __init__(self,name,figure,style,qingfu,money,fangchan):
        self.name = name
        self.figure = figure
        self.style = style
        self.__qingfu = qingfu
        self.__money = money
        self.__fangchan=fangchan
    def buy(self):                        #通过一个非私有的方法得到访问
        print("我有%s这么多钱" % self.__money)
T1=Tiger("呵呵","正直","廉洁","潘潘","10亿","10套")
T1.buy()                  #我有10亿这么多钱

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

(2)私有方法:

私有方法, 顾名思义, 只能自己访问的方法,别人都不能随便便调用的.

class Tiger:
    def __init__(self,name,figure,style,qingfu,money,fangchan):
        self.name = name
        self.figure = figure
        self.style = style
        self.__qingfu = qingfu
        self.__money = money
        self.__fangchan=fangchan
    def buy(self):
        print("我有%s这么多钱" % self.__money)
    def __sel(self):
        print("我要卖掉%s" % self.__fangchan)
T1=Tiger("呵呵","正直","廉洁","潘潘","10亿","10套")
T1._sel()

此时同样会报错,但是通过先访问公共的东西,再去访问私有就可以.

class Tiger:
    def __init__(self,name,figure,style,qingfu,money,fangchan):
        self.name = name
        self.figure = figure
        self.style = style
        self.__qingfu = qingfu
        self.__money = money
        self.__fangchan=fangchan
    def buy(self):
        print("我有%s这么多钱" % self.__money)                  #我有10亿这么多钱
        self.__sel()
    def __sel(self):
        print("我要卖掉%s套房" % self.__fangchan) 
T1=Tiger("呵呵","正直","廉洁","潘潘","10亿","10")
T1.buy()                      #我要卖掉10套房

成员

相关推荐