day016类的成员（变量、方法、属性）、私有

本节主要内容

1.类的成员
2.类的成员----变量（java叫属性）
3.类的成员----方法
4.类的成员----属性（等同于变量）
5.私有

一、类的成员

类里面写的内容，就是成员

二、类的成员—-变量

1、类中的变量分为两大类：

1.实例变量（字段，java叫属性）
2.类变量（静态变量）

2、实例变量

每个实例都拥有的变量，给对象用的，单独属于这个对象的，类似于实参，你写才有的

3、类变量（静态）

·这类事物统一拥有的变量，共享的，所有创建出来的对象都有的，例如：国籍都是中国
·最好用类名来访问，这样才规范

fe1: 实例和类变量的体现

class Person:
    # 类变量，所有的对象都有这个变量
    country = "中国"

    def __init__(self, name, card_no, height, weight, address, laopo):
        # 实例变量. 给对象赋值
        self.name = name
        self.card_no = card_no
        self.height = height
        self.weight = weight
        self.address = address
        self.laopo = laopo

p1 = Person("马化", "123456789123456781", 1.60, 180, "深圳市南山区南山法院", "不知道")
p1.company = "腾讯" # 添加实例变量-> 字段 -> 属性(java)

p2 = Person("刘东", "789456132456789123", 1.65, 190, "宿迁", "奶茶妹妹")

fe2:一个小坑，类变量只能通过类名方位来改变

class Person:
    country = "中国"
    def __init__(self,name, age):
        self.name = name
        self.age = age

# Person.country = "大清"
print(Person.country) # 直接使用类名进行访问
p1 = Person("alex", 185)
p1.country = "大清" # 添加了一个实例变量,而不是改变了类变量
print(p1.name)
print(p1.country)

p2 = Person("wusir", 145)
print(p2.name)
print(p2.country)

# 类变量的修改只能通过类名来完成

引用同一类变量

新建了一个实例变量

二、类的成员—-方法

1、方法有三种

1.成员方法（实例方法）
2.静态方法
3.类方法

2、成员方法（实例）

所有对象直接访问的方法，就是成员方法

fe1: 对象调用实例方法

class Car:
    def run(self):
        print("会跑的车")

    def cul(self, a, b):
        return a + b

    def jump(self):
        print("you jump i jump")

c = Car()
c.run() # 调用实例方法
print(c.cul(1 , 3))
c.jump()

3、静态方法

·不需要我们给方法传递self，也就是一个方法不需要使用到成员（实例）变量时，选择这个方法
·在类中定义一个普通函数
·静态方法需要我们在方法上面添加一个 @staticmethod
·通过类名直接访问和调用，才规范

fe1: 静态方法的示例

class Person:

    @staticmethod
    def shui():  # 在类中定义的一个普通函数
        print("和你睡不等于睡你 -- 姜文")

    @staticmethod  # 添加一个
    def 上天(height):  # 在类中定义的一个普通函数
        print("上天%s" % height)

Person.shui() # 必须用类名去访问，才显得规范
Person.上天(500)

4、类方法

·类方法需要在参数列表(形参位置）的第一个位置预留一个位置，通常我们给第一个参数起名字叫：cls
·类方法在被调用时，也不需要传递实例对象，但是，系统会自动把类传递给第一个参数
·编写时，需要在类方法上面添加: @classmethod

fe2：类方法的示例

class Person:

    def chi(self): # 实例方法
        print("人在吃饭")

    # 类方法
    @classmethod # 类方法
    def he(cls): # cls 类
        print(cls)
        print("我是喝")

    @classmethod
    def cul(cls, a, b):
        return a + b

p = Person() # 必须用类名去访问
p.he() #  错误的示范， 不管用对象还是用类去访问类方法. 默认传递进去的是类

Person.he() # 正确的访问类方法

print(Person.cul(1, 3) # 调用访问类方法

面试题：类方法静态方法和实例方法的区别？

类方法静态方法：不需要传递变量给self，系统会默认自动传进去类，去访问的方法
实例方法：所有对象直接访问的方法，直白说，就是对象直接访问到的方法

三、类成员—-属性

·属性：其实是把方法变成变量的一种写法
·在方法上添加一个： @property
·应用场景：需要通过计算来获得一个数值，这样的属性，例如：年龄

1、实际应用

保存数据的时候，我们一般不会保存一个人的年龄，因为随之时间的推移，每个人的年龄都在改变。
如何完美保存，很简单，保存出生年月日，然后用程序来计算当前年龄，这里要进行相应的运算
但计算属于一个功能，当然是写在方法里，
而年龄这个属性，他是个数值，不是动作，我们也只要年龄这个数值

fe:

class User:
    def __init__(self, name, birthday, qq, email):
        self.name = name
        self.birthday = birthday
        self.qq = qq
        self.email = email

    # 方法
    @property # 可以把一个方法变成一个属性
    def age(self):
        return 2018 - self.birthday
    '''
        @property
        1. 函数只能有一个self参数.
        2. 需要有返回值
        3. 不能赋值
        4. 调⽤的时候, 我们不需要写括号. 直接当成属性变量来⽤就可以了

    '''
u = User("王明", 1994, 1024663304, "wangming@126.com")
print(u.age)  # 属性变量不需要括号
u.qq = 10010
# u.age = 18 # 报错, 不能赋值

2、注意

@property
    1. 函数只能有一个self参数.
    2. 需要有返回值
    3. 不能赋值
    4. 调⽤的时候, 我们不需要写括号. 直接当成属性变量来⽤就可以了

四、私有

·一般不提倡设置和使用私有信息
·__作为方法或变量的前缀，就可以变成私有的
·在类里面就可以随意的调用私有的
·父类私有的，子类无法继承

fe1: 私有变量、方法，及其调用

class Person:
    def __init__(self, name): # 构造, 创建对象的时候自动调用
        self.__name = name # 私有的 变量
        print("这里是构造方法")

    def __chi(self): # 私有的 方法
        print("我要吃. 疯狂的吃")

    def he(self):
        self.__chi() # 内部调用
        print("我是喝", self.__name)


p = Person("孙艺珍")
p.he()  # he里面有类里面的内部调用，所以可以访问到私有的
# # p.__init__() # 不会这样调用，很蠢

# print(p.__name)  # 报错

# print(p.__chi()) # 报错

fe2: 私有的内容，子类无法继承

class Fu:
    __qingfeng = "清风"

class Zi(Fu):
    pass

print(Zi.__qingfeng)    # 报错