day23作业详解

亦凉 2021-11-02 05:10 307阅读 0赞

## 1.题目 ##

![1259820-20190527095818054-1378527557.png][]

![1259820-20190527100016402-74606095.png][]

![1259820-20190527100021786-1381096012.jpg][]

![1259820-20190527100047558-105899148.jpg][]

![1259820-20190527100051877-1225793174.jpg][]

## 2.题目详解 ##

点击查看详细内容

1.
    1-1 封装
    把功能封装到类中
    class Message(object):
        def email(self):pass
        def msg(self):pass
        def wechat(self):pass
    
    初始化方法，把封装数据给其他方法使用
    class Dog(object):
        def __init__(self,name):
            self.name = name
    
        def bulk(self):
            print("%s:wang wang wang" %self.name)
    
    
    1-2 继承
    class Father(object):
        def func1(self):
            print('in func1')
    
    class Son(Father):
        def func2(self):
            print('in func2')
    
    obj = Son()
    obj.func1()
    
    
    1-3 多态
    Python原生支持多态，所在多态在python中没有特殊性
    
    
    
    2.
    面向对象的变量：类变量，实例变量
        类变量（静态字段）
            公有类变量（静态字段）
            私有类变量（私有静态字段（
        实例变量（字段）
            公有实例变量（字段）
            私有实例变量（私有字段）
    
    
    class Foo:
        country = '中国'  # 类变量
    
        def __init__(self,name):
            self.name = name    # 实例变量
    
    obj1 = Foo('王小明')
    obj2 = Foo('小樱')
    
    Foo.country = '法国'
    print(obj1.country)
    print(obj2.country)
    
    obj1.name = '大头'
    print(obj1.name)
    
    
    
    3.
    面向对象的方法
        实例方法：使用对象封装__init__方法的值是，用实例方法
        静态方法：方法中使用对象中封装的值是，使用静态方法
        类方法：在方法中需要用到当前类时，用类方法
    
    
    3-1.实例方法：
    class Foo(object):
    
        def __init__(self,name):
            self.name = name
    
        def func(self):
            print(self.name)
    
    obj = Foo('爱丽丝')
    obj.func()
    
    3-2.静态方法和类方法：
    class Foo(object):
    
        @staticmethod
        def static():
            print('666')
    
        @classmethod
        def show(cls):
            print(cls)
    
    Foo.static()
    obj = Foo()
    obj.static()
    Foo.show()
    
    
    
    4.
    class Foo(object):
    
        @property
        def func1(self):
            return 1
    
        @property
        def func2(self):
            return 9
    
    obj = Foo()
    print(obj.func1)
    print(obj.func2)
    
    
    
    5.静态方法和类方法的区别？
        1.编写时：
            静态方法：@staticmethod,参数可有可无
            类方法：@classmethod,至少有一个参数
            实例方法：普通的方法，调用对象封装的值
    
        2.调用时：
            静态方法和类方法：类名.方法名()
            实例方法：对象名.方法名()
    
        3.应用场景：
            如果在方法内部不会用到对象相关的数据时，就可以用静态方法或类方法。需要用到对象相关的数据时，才用实例方法。
            如果在方法中需要用当前类时，类方法默认传参是当前类，可以用类方法。
    
    
    6.定义时不需要写参数：静态方法
    
    
    7.面向对象中公有成员和私有成员有什么不同？
        公有成员：可以在外部直接调用
        私有成员：定义时加"__"，只能在内部调用
    
    
    8.  1  12
    
    
    9.  999  11  11  AttributeError
    
    
    10. 666 1 error error 1 error
    
    
    11. 666 1 18 99 1 1000 1098
    
    
    12.
    class Foo(object):
        hobby = "大保健"
    
        def __init__(self,num):
            self.num = num
            self.__salary = 1000
    
        def f1(self):
            print(Foo.hobby)
    
        @staticmethod
        def f2():
            print(Foo.hobby)
    
        @classmethod
        def f3(cls):
            print(cls.hobby)
    
    obj = Foo(1)
    obj.f1()
    obj.f2()
    obj.f3()
    
    
    13.
    Foo类
    
    
    14.
    Foo类
    
    
    15.
    Foo类
    Foo类
    
    
    16.
    foo.f2
    base.f1
    Foo类
    
    
    17.
    class Foo(object):
        @staticmethod
        def __func1():
            print('func1')
    
        def func2(self):
            print('func2')
            self.__func1()
    
    obj = Foo()
    # obj.__func1   外部不可调用
    obj.func2()     #通过内部方法间接调用
    
    
    18.
    class Page(object):
        def __init__(self,lst,page_num=0,dis_page=10):
            self.lst = lst
            self.page_num = page_num
            self.dis_page = dis_page
    
        @property
        def start(self):
            return (self.page_num -1) * self.dis_page
    
        @property
        def end(self):
            return self.page_num * self.dis_page
    
        def show(self):
            self.page_num = int(input('请输入查看的页码：'))
            for i in self.lst[self.start:self.end]:
                print(i)
    
    lst = ['alex-%s' %i for i in range(1,101)]
    
    while 1:
        obj = Page(lst)
        obj.show()
    
    
    #19. 三个类之间的嵌套
    class School(object):
        def __init__(self,address):
            self.address = address
    
    
    class Course(object):
        def __init__(self,name,period,price,school=None):
            self.name = name
            self.period = period
            self.price = price
            self.school = school
    
    
    class Grade(object):
        def __init__(self,name,people,introduce,course=None):
            self.name = name
            self.people = people
            self.introduce = introduce
            self.course = course
    
    #1.学校
    bj = School('北京')
    sh = School('上海')
    sz = School('深圳')
    
    #2.课程
    py1 = Course('Python全栈',110,19999,bj)
    py2 = Course('Python全栈',110,19999,sh)
    py3 = Course('Python全栈',110,19999,sz)
    
    l1 = Course('Linux运维',110,19999,sh)
    g1 = Course('Go开发',119,19999,bj)
    
    #3.课程开班
    gra1 = Grade('全栈21期：',55,'北京GO全栈开发21期',g1)
    gra2 = Grade('Linux运维1期：',45,'上海Linux运维1期',l1)
    
    gra3 = Grade('全栈1期：',45,'深圳全栈开发1期',py3)

转载于:https://www.cnblogs.com/byho/p/10929215.html

[1259820-20190527095818054-1378527557.png]: /images/20211102/073389b5a46d4812949d86c1d9865e00.png
[1259820-20190527100016402-74606095.png]: /images/20211102/ddf3e105b080413ba037c5c950fdded2.png
[1259820-20190527100021786-1381096012.jpg]: /images/20211102/3860a16110644feeb955893f70bd7ef3.png
[1259820-20190527100047558-105899148.jpg]: /images/20211102/237d16a65acf46fe8f930a2e30c75147.png
[1259820-20190527100051877-1225793174.jpg]: /images/20211102/a28e6d31e405418b8285630b9aa9897b.png