第十六天-面向对象02-成员

# 类的成员：类中写的内容就是成员

# class 类名:
#     方法
#     def __init__(self, 参数1, 参数2....):
#     属性变量
#     self.属性1 = 参数1
#     self.属性2 = 参数2
#     ....
#     方法
#     def method(self):
#     pass
'''
上面代码中__init__和method都属于类的成员方法.又称为实例方法.需用对象来访问.而上⽅的self.属性1 = 参数1
这个代码含义是给对象设置属性信息.这个对象的xxx属性是xxxx.被称为成员变量或实例变量或者字段,类中还存在其他成员
'''

# 类的成员——变量：
# 实例变量  每个实例都应该拥有的变量. 如实例人.⼈的名字,⼈的爱好,每个⼈的个⼈信息.
# 类变量  一类事物统一拥有的变量 如.各位都是中国⼈.那大家都拥有同一个国家

class Person:
    country = "中国"  # 类变量，表示所有的该类对象都共享这个变量
    def __init__(self,name,age):
        # 实例变量/成员变量/字段  表示你创建的每一个人都有这两个变量
        self.name = name
        self.age = age

p1 = Person("麻花藤",45)
print(p1.name)
print(p1.country) # 中国

p2 = Person("流动墙",46)
print(p2.name)
print(p2.country) # 中国

# 如上对象p1 p2的name都是对象自己的，但是country是公用的类的

# Person.country = "大明" # 通过类名修改类变量  后面都跟着改变
p1.country ="越国" # 通过对象名修改实例变量 只对这个对象有效
print(p1.name)
print(p1.country)
print(p2.name)
print(p2.country)
#  类变量,最好是用类名来访问.当然,通过对象名也可以访问.但只能看,不能改变.想要改它,需要用类名

# 总结：
# 实例变量，给对象用的
# 类变量，多个对象共享的，最好是用类名来访问，更规范

# 类的成员-方法

# 实例方法(成员方法)
# 作用于对象 用的最多

class Car:
    def run(self): # 实例方法
        print("音速走你")

    def fly(self): # 实例方法
        print("起飞走你")

c = Car()
c.run() # 对象直接调用实例方法
c.fly()

# 类方法：
# 使用类方法需要在类方法前面添加一个 @classmethod

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

    @classmethod # 类方法
    def he(cls):  # cls 类
        # print(cls)  # <class '__main__.Person'>
        print("我是喝")

    @classmethod
    def shui(cls,a,b):  # 类方法在被调用时也不需要传递实例对象.但系统会自动的把类传递给第一个参数
        return a+b

# print(Person)  # <class '__main__.Person'>
Person.he()
print(Person.shui(1,2))  # 此时会自动把类名传递给第一个参数
p = Person()
p.he()  # 类也可以访问 但不推荐 不管是类还是对象访问类方法 默认传递(cls)的都是类

# 静态方法： 作用于类
# 不需要给方法传递self
# 使用静态方法需要在前面添加一个 @staticmethod

class Person:
    @staticmethod  # 静态方法 可理解成类里面的函数
    def shui():
        print("我是睡")

    @classmethod # 类方法
    def he(cls):  # cls 类
        # print(cls)  # <class '__main__.Person'>
        print("我是喝")

Person.shui() # 类名可直接访问
p = Person()
p.shui() # 也能调用 但很少这样用 以便区分静态方法和实例方法

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

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

    @property  # 可以把一个方法变成属性
    def age(self):
        return 2018 - self.birthday
    @property
    def email(self):
        return "123@163.com"

u = User("张三",1994,123485)
re = u.birthday # 调用属性不需要括号
print(re)
print(User.email)

# 注意:
# 1. 方法参数只能有一个self
# 2. 方法上方要写@property
# 3. 调用时,不需要写括号.直接当成属性变量来用
# 4. 这种套路只能取值.不能设置值

# 私有: (一般不用)
# 应用于某些不能公开、公共的对象，如...你老婆
# python中使用__作为方法或者变量的前缀 那么这个方法或者变量就是私有的

# 私有变量：  实例变量 类变量
class Person:
    def __init__(self,wife,secret):
        self.__wife = wife
        self.__secret = secret

wangnm = Person("王尼美","嘘...")
# print(wangnm.__wife) # 报错  'Person' object has no attribute '__wife'
# 程序报错 私有内容外部是不能直接访问到的

# 但如果开辟外界访问通道(公用方法) 那就可以通过这个公用的方法来获取到私有内容 但只能看不能改
class Person:
    __zisi = "有些方面，谁都是自私的"  # 类变量也可以用 私有属性
    def __init__(self,wife,secret):
        self.__wife = wife # 私有
        self.__secret = secret

    def tell(self):
        print("大喇叭开播啦~~")
        return self.__secret,self.__wife

wangnm1 = Person("王尼美","嘘...")
print(wangnm1.tell())  # 借助tell方法成功访问到秘密
# print(Person.__zisi)  # 类变量同样报错

# 私有方法
# 私有方法,顾名思义,只能自己访问的方法.别人都不能随便调用.如: 你和你女朋友约会.你希望别⼈来调用么?

class Person:
    def __init__(self):
        pass

    def __yue(self):
        print("我们在约会")

    def work(self):
        print("努力搬砖中")

p = Person()
# p.yue() # 报错 __yue是一个私有的方法.只能在类中自己调用.类外不能直接访问.
p.work()

# 同样，私有方法也是相对而言的.我们可以通过其他方法来访问到
class Person:
    def __init__(self):
        pass

    def __yue(self):
        print("我们在约会")

    def work(self):
        print("努力搬砖中")
        self.__yue()  # 在自己类中访问自己的其他方法.哪怕是私有的.也是自己在用

    # 类方法与静态方法也和实例方法一样
    @classmethod
    def __yue1(cls):
        print("ta们在约会")

    @staticmethod
    def __yue2():
        print("ta们在约会")

    @property
    def __yue3(self):
        return "ta们在约会"


p = Person()
p.work() # 努力搬砖中  我们在约会
# Person.__yue1()  # 报错
# Person.__yue2()
# Person.yue3  # 报错 找不到

# 不过需要注意的是，对于私有内容而言，子类是无法继承的！

class Fu:
    def __init__(self):
        pass
    def __qingfu(self):
        print("情妇_如花...")

class Zi(Fu):
    pass

re = Zi()
# print(re.__qingfu)  # 报错 'Zi' object has n

——————————————相关练习———————————————

# 现有500W条数据.请使用面向对象的思维来完成这500W条数据的分页工作

class Page:
    '''
    lst为数据总条数,pagesize为每页显示多少条数据
    '''
    def __init__(self,lst,pagesize):
        self.lst = lst  # 总数据
        self.pagesize = pagesize  # 每页显示的数据

    def start(self):
        '''
        返回首页
        :return:
        '''
        return self.lst[0:self.pagesize]

    def index(self):
        y = int(input("请输入你要现实的页码
"))
        return self.lst[(y-1)*self.pagesize:y*self.pagesize]

    @property
    def total_page(self):  # 求页码数
        if len(self.lst) % self.pagesize == 0:
            return len(self.lst) // self.pagesize
        else:
            return len(self.lst) // self.pagesize + 1

    def end(self):
        '''
        返回尾页
        :return:
        '''
        return self.lst[(self.total_page-1)*self.pagesize:self.total_page*self.pagesize]



lst = [1,2,3,4,5,6,7,8,9,10,11,12,13,14]
s1 = Page(lst,3)
print(s1.start())
print(s1.end())
print(s1.index())
'''
每页3条数据      第y页显示的数据：[(y-1)*3:3*y]
1       2       3      4     5
[0:3]  [3:6]  [6:9] [9:12] [12:]
每页4条数据      第y页显示的数据：[(y-1)*4:4*y]
1       2       3      4   
[0:4]  [4:8]  [8:12] [12:]
'''