python3.6入门到高阶(全栈) day016 类的成员

今日主要内容
    成员
        变量
            1. 实例变量. 对象.xxx = xxx 实例变量 -> 字段 -> 属性.  给对象用的
               什么是实例变量：如个人的爱好，喜欢的事物，喜欢的运动，喜欢的姑娘等等

            2. 类变量. 直接写在类中的变量就是类变量. 类变量一般用类名来访问. 对象中共性的属性提取出来.
               什么时候类变量：比如我们都属于这个世界，都是一个国家的人等等


            例    class Person:
                  # 类变量, 表示所有的该类的对象都共享这个变量.
                  country = "中国"

                  def __init__(self, name, num, birthday):
                   # 实例变量(字段) 表示你创建的每⼀个⼈都有这三个变量
                     self.name = name
                     self.num = num
                     self.birthday = birthday
                p1 = Person("周杰伦", 18, "1840年06⽉01⽇")
                print(p1.name) # 周杰伦
                print(p1.country) # 中国
                p2 = Person("刘德华", 28, "1894年07⽉25⽇")
                print(p2.name) # 刘德华
                print(p2.country) # 中国
            # 发现对象p1和p2的name都是对象⾃⼰的. 但是country是类的. ⼤家公⽤同⼀个变量
                Person.country = "⼤清" # 在这⾥. 我把国家改成了⼤清
                p1 = Person("周杰伦", 18, "1840年06⽉01⽇")
                print(p1.name)
                print(p1.country) # 周杰伦是⼤清的
                p2 = Person("刘德华", 28, "1894年07⽉25⽇")
                print(p2.name)
                print(p2.country) # 刘德华 也是⼤清的
            # 把类变量中的值改了. ⼤家看到的都跟着变了
                p1 = Person("周杰伦", 18, "1840年06⽉01⽇")
                p1.country = "⼤清"
                print(p1.name)
                print(p1.country) # ⼤清
                p2 = Person("刘德华", 28, "1894年07⽉25⽇")
                print(p2.name)
                print(p2.country) # 中国
            # 在执⾏p1.country = "⼤清"的时候. 其实并没有去改变类中的country,
              ⽽是给对象添加了⼀个实例变量. 并且这个实例变量,只有当前
              的p1是存在的. 在p2中是不存在的


           个简单的总结:
             实例变量, 给对象⽤的.
             类变量, 多个对象共享的. 最好是⽤类名来访问. 这样更加规范.


       方法
            1. 实例方法.  对象.方法()
            2. 类方法.    类名.方法()
            3. 静态方法.  类名.方法()
          例 class Person:

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

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

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

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

            # print(Person)
            # Person.he()

            # p = Person()
            # p.he()  # 不管用对象还是用类去访问类方法. 默认传递进去的是类

            Person.shui()  #静态⽅法和静态变量⼀样. ⼀般都是使⽤类名直接访问和调⽤的
            Person.上天(500)
            #
            # p = Person()
            # p.shui()



       属性@property
            把方法转化成属性.
            对象.属性
          例 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

私有
    __作为前缀
    在自己类中可以随意访问. 但是出了类任何人都不可以访问这个私有内容

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

            def init(self):
                print("实例方法")

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

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

        p = Person("孙艺珍")
        p.he()
        # # p.__init__() # 这种方法很蠢
        # p.init()
        # print(p.__name)