python学习——面向对象练习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)