环境小硕的转行之路-27-面向对象的成员

今日内容

1.面向对象的成员
2.组合(类似于建立模型->多个类之间的相互嵌套)

成员

　成员:类的成员

class Foo:
    country = 'CN'#为类创建了一个变量又称'静态字段',可以在obj1和obj2里面找到
    def __init__(self,name):#对象变量(变量)/实例变量(本质上是个函数)
        self.name = name
    def func():#方法(函数)
        pass
obj1 = Foo('negu')
obj2 = Foo('negi')
'''
obj1和obj2实例化的时候不止创建了name还创建了类对象指针,obj1和obj2都指向Foo,调用方法的时候都去Foo里面寻找.
而实例变量是放在各自的对象里面各自持有这样是为了节省内存.
obj->Foo类的对象
obj->Foo类的实例
   '''

　　

成员共分为三类:
第一类：
变量:
　-实例变量(字段)
　　 -公有实例变量
　　-私有实例变量
　 -类变量(静态字段)
　　-公有类变量
　　-私有类变量#几乎不用,但要知道.

字段

class Foo:
    country = 'CN'  # 为类创建了一个变量又称'静态字段',可以在obj1和obj2里面找到

    def __init__(self, name):  # 对象变量(变量)/字段/实例变量(本质上是个函数)
        self.name = name

    def func():  # 方法(函数)
        pass


obj1 = Foo('negu')
obj2 = Foo('negi')

print(obj1.country)#CN obj1.country = 'US'会改自己内部的country,obj2.country还是CN.也可以在外部往类里面创建新变量.
print(obj2.country)#CN

#通过对象没法改类里面的值.
#准则:实例变量(字段),使用对象访问,即obj1.name
#     类变量(静态字段)访问时,使用类方法来进行访问,即Foo.country,实在不方便才使用对象.
#什么时候用类变量:当不同对象中有相同的值的时候才用类变量(要改都改,要删都删的时候).将实例变量提取到类变量中.

#易错点
'''
obj1.name = 'tom'
obj1.country = 'US'
print(obj1.name)#tom 
print(obj1.country)#US
'''

############## 私有实例变量(私有字段) ##############
class Foo:
    def __init__(self,name):
        self.__name = name#加两个下划线变成私有变量,在外部不可获取.在类里面定义的函数可以调用.称为私有的实例变量或者私有字段.
        self.age = '22'#在内部定义而在外部可以获取的叫公有变量.
    def print_func(self):
        print(self.__name)
    obj = Foo('negu')
    obj.print_func()
    print(obj.age)


############## 私有类变量(私有静态字段) ##############

class Foc:
    __country = 'cn'
    def __init__(self):
        pass
    def print_func(self):#内部调用
        print(self.__country)
        print(Foc.__country)
objFoc = Foc()
objFoc.print_func()#打印cn
#print(Foc.__country)#报错

############## 私有字段在父类和子类之间的调用############
class Base(object):#python里面定义类的时候自动继承object(用于开辟类的内存等等之类的操作)
    __secret = '受贿'
    def secret_paper(self):
        print(self.__secret)
class Son(Base):
    def print_function(self):
        print(self.__secret)#报错.无法执行
obj = Son()
# print(obj.__secret)#报错
# obj.print_function()#报错
obj.secret_paper()#不报错

　　

第二类：
　 方法:
　　-方法/实例方法
　　 -静态方法
　　-类方法

class Foo(object):
    def func(self): #func下面有波浪线,表示没必要,因为没有用到self
        print('实例方法')
obj = Foo()
obj.func()#实例方法
class Foo1:
    def __init__(self,name):
        self.name = 'gegege'
    def func(self):#里面用到self才有必要
        print(self.name)
obj1 = Foo1('negu')
obj1.func()#实例方法

############ 静态方法 ############
class Static:
    def __init__(self,name):
        self.name = name
    #实例方法
    def func(self):
        print(self.name)
    @staticmethod#固定搭配
    #静态方法,可以直接通过类调用,如果方法中无需使用对象中封装的值,就用静态方法.相当于在类中写函数
    def display():#可以传参也可以不传,和函数一样
        print('666')
objStatic = Static('negu')
Static.display()#通过类调用
objStatic.display()#通过对象调用

'''
总结:
    1.编写时:方法上方有个@staticmethod
        方法参数可有可无
    2.调用时:
        -类.方法名()
        -对象.方法名()
    3.什么时候写静态方法?
        -无需调用对象中封装的值

'''
#类方法,相当于静态方法的补充
class ClassMethod:
    @classmethod
    def show(cls,x1,x2):#cls这个参数在python的内部会帮你自动传递
        print(cls,x1,x2)
#获取当前类的时候才用类方法.获取当前对象则用实例方法,什么都不用用静态方法.
ClassMethod.show(1,8)
'''
总结:
    1.定义时
        -方法上写@classmethod
        -()至少有一个cls参数
    2.执行时:
        -类名.方法() 默认会将当前类传到参数中
    3.什么时候使用
        -如果在函数中使用当前类就使用类方法.

'''
'''

面试题:静态方法和实例方法的区别和作用?
        1.定义的时候:@@
        2.执行的时候:实例方法要先实例化,静态和类可以直接类名.方法调用
        3.应用场景:不会用到对象相关数据时用静态方法和类方法,如果代码用到当前类则用类方法,其它情况用静态方法.
'''
################ 私有的实例方法 ###############
class Foo:
    def __init__(self):
        pass
    def __display(self,arg):
        print('私有方法',arg)
    def real_display(self):
        self.__display('fuck')
obj = Foo()
# obj.__display()#报错
obj.real_display()#成功调用
############### 私有的静态方法 ############
class Foo1:
    def __init__(self):
        pass
    @staticmethod
    def __display():
        print('私有方法')
    def real_display(self):
        self.__display()
# Foo1.display #访问不到,通过实例方法或再写一个正常静态方法调用.

　　

嵌套

'''
创建三个学校,学校的大部分内容和设施都是一致.

'''
    class Company:
        def __init__(self,name,address):
            self.name = name
            self.address =address
        def speech(self):
            pass
    Company1 = Company('滴滴公司','北京')
    Company2 = Company('腾讯公司','深圳')
    Company3 = Company('华为公司','深圳')
    class Teacher:
        def __init__(self,name,gender,address,salary):
            self.name = name
            self.gender = gender
            self.__salary = salary
            self.address =address
            self.company = None
    t1 = Teacher('negu','male','Fuzhou','188888')
    t2 = Teacher('negu older 10 years','male','ShenZheng','500000')
    t3 = Teacher('negu older 20 years','male','ShenZheng','750000')

    t1.company = Company1#在t1对象里面做了一个嵌套
    print(t1.company.address)#北京,对象和对象之间的嵌套关系
    准则:不仅字段,方法也要归类,为嵌套做准备.

　　

练习题

要求：

data_list = []
#数据太多,进行分页展示
for i in range(1,901)
    data_list.append('negu-%s'%i)
page = int(input('请输入要查看的页码:'))
#900条数据进行分页展示，默认每页十条，且用面向对象的方法编写。

　　

————

    class PageDivision:
        def __init__(self,page,num_per_page=10):
            '''
            初始化一些参数
            :param page:当前页码
            :param num_per_page:每页显示的数据数
            '''
            self.page = int(page)
            self.num_per_page = int(num_per_page)
        @property#Python内置的@property装饰器就是负责把一个方法变成属性调用的
        def start_score(self):
            return (self.page-1)*self.num_per_page
        @property
        def end_score(self):
            return self.page * self.num_per_page
    data_list = []
    for i in range(1,301):
        data_list.append('negu-%s'%i)
    page = input('请输入要查看的页码')
    obj = PageDivision(page)
    page_data = data_list[obj.start_score:obj.end_score]
    for item in page_data:
        print(item)