Python Day6

一、面向对象入门    

概述

• 面向过程：根据业务逻辑从上到下写垒代码
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向对象初识

 创建类和对象

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

 

• class是关键字，表示类
• 创建对象，类名称后加括号即可

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

　　　面向对象的应用场景 ：

1. 1. 如果多个函数须传入多个共同的参数时
   2. 根据一个模板创建某些东西时
   3. 需要执行很多重复的操作时　　

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

1. 防止数据被随意修改；

2. 使外部程序不需要关注对象内部的构造，只需要通过此对象对外提供的接口

进行直接访问即可；

class Role(object):

    nationality = "China"  # 公有静态字段

    def __init__(self, name, sex, age):
        self.name = name  # 公有字段
        self.sex = sex
        self.age = age
        self.__life_value = 100  # 私有字段

    def eat(self, food):  # 普通方法
        print("%s is eating %s" % (self.name, food))

    def talk(self, msg):
        print("%s is talking:%s" % (self.name, msg))


r1 = Role("Profhua", "M", 25)
r2 = Role("Wolf", "M", 25)
r1.eat("包子")
r1.nationality = "JP"  # 相当于在对象r1中克隆了一个nationality
print(r1.nationality)
print(r2.nationality)
Role.nationality = "US"  # 改变了公有静态字段
print(r1.nationality)
print(r2.nationality)

类的组合：

class F1:
    def __init__(self, n):
        self.N = n
        print('F1')


class F2:
    def __init__(self, arg1):
        self.a = arg1
        print('F2')


class F3:
    def __init__(self, arg2):
        self.b = arg2
        print('F3')


o1 = F1('alex')

o2 = F2(o1)

o3 = F3(o2)

# ###### 输出Alex:o3.b.a.N #######

print(o3.b.a.N)

总结：对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容

二、继承

通过父类 ===》子类的方式以最小代码量的方式实现不同角色的共同点和不同点同时存在

class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print("Person [%s] is talking" % self.name)

    def eat(self):
        print("Person [%s] is eating" % self.name)


class BlackPerson(Person):

    def __init__(self, name, age, strength):
        Person.__init__(self, name, age)
        self.strength = strength

    def talk(self):
        print("BlackPerson [%s] is talking" % self.name)


b = BlackPerson("小黑", 25, "Strong")
b.talk()
print(b.strength)

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

多继承

class A:

    def __init__(self):
        self.n = "A"


class B(A):
    pass
    # def __init__(self):
    #     self.n = "B"


class C(A):
    def __init__(self):
        self.n = "C"


class D(B, C):
    pass
    # def __init__(self):
    #     self.n = "D"
d = D()
print(d.n)

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式在Pyhton3中是广度优先

注：在Python3中不管是新式类还是经典类在多继承时都是广度优先 ； 在Python2中经典类多继承是深度优先，新式类是广度优先

注： 继承自 object 是为了使属性(properties)正常工作, 并且这样可以保护你的代码, 使其不受 PEP-3000的一个特殊的潜在不兼容性影响.

这样做也定义了一些特殊的方法, 这些方法实现了对象的默认语义, 包括 __new__, __init__, __delattr__, __getattribute__, __setattr__, __hash__, __repr__, and __str__ .

 三、多态

Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态

Python多态示例

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")


class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


def func(obj):  # 一个接口，多种形态
    obj.talk()


c1 = Cat('小晴')
d1 = Dog('李磊')

func(c1)
func(d1)

总结

以上就是本节对于面向对象初级知识的介绍，总结如下：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用
• 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

二、作业    

选课系统：

角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程

7. 上面的操作产生的数据都通过pickle序列化保存到文件里