day 0150面向对象-成员

一类的成员

在类中定义的变量和方法都被称为成员

class Person:
            def __init__(self, name, num, gender, birthday):
                # 成员变量(实例变量)
                self.name = name
                self.num = num
                self.gender = gender
                self.birthday = birthday

            # 对象来访问（成员方法）（实例方法）
            def marray(self, duifang):
                print("人会结婚%s" % duifang)

也就是说在类中, 是存在着实例变量和实例方法的.

(2) 变量

在类中变量分为两大类:

1 实例变量(成员变量)

2类变量(静态变量)

先看什么是实例变量.

就是每个实例都应该拥有的变量比如. 人的名字, 人的爱好,
每个⼈的个人信息. 都属于实例变量. 那什么是类变量. 就是这一类事物统一拥有的变量. 比
如. 在座的各位都是中国⼈. 那大家都拥有同⼀一个国家.例如::

class Person:
# 类变量量, 表示所有的该类的对象都共享这个变量量. 它不属于对象,但对象可以访问,不可以修改,
country = "中国"
def __init__(self, name, num, birthday):
# 实例例变量量(字段) 表示你创建的每⼀一个⼈人都有这三个变量量
　　　　self.name = name
　　　　self.num = num
　　　　self.birthday = birthday
p1 = Person("alex", 18, "1840年年06⽉月01⽇日")
print(p1.name) # alex
print(p1.country) #中国

p2 = Person("wusir", 28, "1894年年07⽉月25⽇日")
print(p2.name) # wusir
print(p2.country) # 中国

(我们发现对象p1和p2的name都是对象自己的,但是country是类的大家公用一个变量)验证下:

Person.country = "⼤清" # 在这⾥. 我把国家改成了大清
p1 = Person("alex", 18, "1840年年06⽉月01⽇日")
print(p1.name)
print(p1.country) # alex是大清的
p2 = Person("wusir", 28, "1894年年07⽉月25⽇日")
print(p2.name)
print(p2.country) # wusir也是大清的

总结:
    实例变量,给对象用的
    类变量,多个对象共享的,最好用用类名去操作.规范

(3) 方法

1成员方法(实例方法)

2静态方法

3类方法

先说成员方法:

,用的最多(就是对象直接访问的方法叫成员方法)

例子:

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

静态方法: ( 静态方法不需要我们给方法传递self,也就是说,当出现一个方法不需要使用到成员变量的时候,就可以使用静态方法,静态方法需要我们子方法上添加一个@staticmethed

static;静态 method;方法

@staticmethod
def fare():
print("我的电脑⾮非常⽜牛B, 可以煎鸡蛋")

类方法: (类方法和静态方法差不多,只不过类方法需要子啊参数列表中的第一个位置预留一个位置,通常我们给第一个参数起名字叫cls.类方法在被调用的时候也不需要传递实例对象,但是系统会自动把类传递给第一个参数,类方法在写的时候,需要在类方法上添加 @classmethod

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)

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

class Person:
def __init__(self):
pass
@property
def age(self):
return 1
p = Person()
age = p.age
print(age)

例子2

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. 这种套路路只能取值. 不能设置值

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

class Tiger:

    def __init__(self, name, waibiao, qingzhenglianjiedezuofeng, qingfu, money, fangchan):
        self.name = name
        self.waibiao = waibiao
        self.qingzhenglianjiedezuofeng = qingzhenglianjiedezuofeng
        self.__qingfu = qingfu
        self.__money = money
        self.__fangchan = fangchan

    def buy(self):
        print("我有%s" % self.__money)
        self.__sel()

    def __sel(self):
        print("我要卖掉%s" % self.__fangchan)


lh = Tiger("alex", "正直", "非常刚正不阿, 666", "小潘潘", 10000000000, 5)
print(lh.qingzhenglianjiedezuofeng)
print(lh.name)
print(lh.waibiao)
lh.buy()
# lh.__sel()
# print(lh.__money)

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

不单单实力变量有私有的.类变量(静态变量)一样有这样的属性:

例子

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:
def __init__(self):
pass
def __yue(self):
print("我要约会")
def job(self):
print("我要⼯工作")
p = Person()
# p.__yue() # 报错  __yue是一个私有的方法,只能在类中调用,类外面不能访问
p.job()   # job 是一个成员方法,并且是一个开放的方法,在类外界可以被访问到

同样的. 类中的私有方法也是相对⽽言的. 我们可以通过其他方法来访问到这样的方法.

class Person:
def __init__(self):
pass
def __yue(self):
print("我要约会")
def job(self):
print("我要⼯工作")
self.__yue() # 在⾃自⼰己类中访问⾃自⼰己的其他⽅方法. 哪怕是私有的. 也是⾃自⼰己在⽤用
p = Person()
p.job()