day23作业详解

1.题目

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中没有特殊性
面向对象的变量：类变量，实例变量

类变量（静态字段）

公有类变量（静态字段）

私有类变量（私有静态字段（

实例变量（字段）

公有实例变量（字段）

私有实例变量（私有字段）
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)
面向对象的方法

实例方法：使用对象封装__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()
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.面向对象中公有成员和私有成员有什么不同？

公有成员：可以在外部直接调用

私有成员：定义时加"__"，只能在内部调用
1  12
999  11  11  AttributeError
666 1 error error 1 error
666 1 18 99 1 1000 1098
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()
Foo类
Foo类
Foo类

Foo类
foo.f2

base.f1

Foo类
class Foo(object):

@staticmethod

def __func1():

print('func1')
def func2(self):
    print('func2')
    self.__func1()

obj = Foo()
obj.__func1   外部不可调用
obj.func2()     #通过内部方法间接调用
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)