Python面向对象

写在前面

---

---

　　　　时间的高效利用；

---

---

前言：

　　补充 is 和 == 的区别，整理如下：Python中变量的属性以及判断方法

一、面向过程和面向对象

　　- 1.面向过程

　　　　核心是过程，过程就是解决问题的步骤；流水线、机械式；
　　　　优点：复杂的问题简单化，分成多个功能单元；
　　　　缺点：可扩展性差
　　　　应用：Linux内核、httpd、git

　　- 2.面向对象

　　　　核心是对象；
　　　　要理解对象，应该把自己当做上帝，在上帝眼里一切存在的事物都是对象，不存在的也可以创建出来；
　　　　对象是 特征（变量）和技能（函数）的结合体；
　　　　优点：可扩展性强
　　　　缺点：无法像面向过程一样知道什么阶段发生什么事情、会有什么结果
　　　　应用场景：与用户层交互较多的、游戏领域、互联网软件

 

二、类和对象

　　- 对象

　　　　- 对象是特征（变量）和技能（函数）的结合体；

　　- 类

　　　　- 类是一系列对象共有的特征与技能的结合体；

现实生活中：先有对象，再总结归纳出类；而程序中：先定义类，再实例化对象；

在python中，用变量表示特征，用函数表示技能；

因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体；

Python中，一切皆对象；

Python3中，统一了类和类型的概念；

　　- 类和对象的定义

　　　　- 类的语法结构

class 类名():
    '''
    类的注释
    '''
    类体

class People():                        # 定义了一个类 People
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

p1 = People('standby')                 # 实例化了一个对象 p1 
p1.talk()                              # 对象p1 调用了People类的talk()函数，称之为向 p1 对象发送了一个消息，让p1去执行 talk()这个函数；

---
standby comes from China

　　- 类的属性

　　　　- 类有两种属性：数据属性和函数属性；

　　　　　　- 类的数据属性是共享给所有对象的；

　　　　　　- 类的函数属性是绑定到所有对象的；

C:\Users\Administrator>python
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AM
D64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> class People():
...     country = 'China'
...     def __init__(self,name):
...         self.name = name
...     def talk(self):
...         print('%s comes from %s' % (self.name,self.country))
...
>>>
>>> p1 = People('standby')          # 实例化一个对象 p1
>>> p2 = People('kunkun')           # 实例化第二个对象 p2
>>>
>>> print(id(People.country))       # 类的数据属性是共享给所有对象的
11690984
>>> print(id(p1.country))           # p1.country 的id he p2.country 是同一个
11690984
>>> print(id(p2.country))
11690984
>>>
>>> print(People.talk)              # 类的函数属性
<function People.talk at 0x0000000000B1F510>
>>> print(p1.talk)                  # 类的函数属性是绑定（bond）到类对象的
<bound method People.talk of <__main__.People object at 0x0000000000B26550>>    # 注意：p1对象的talk()方法的内存地址 和p2对象的talk()方法地址不是一个；
>>> print(p2.talk)
<bound method People.talk of <__main__.People object at 0x0000000000B265F8>>
>>>
>>> print(id(People.talk))
11662608
>>> print(id(p1.talk))              # 虽然内存地址不是一个，但是用id()查看的时候有的时候是一样的，有的时候不一样；这是有id()做了一些内部的设置；
3590536
>>> print(id(p2.talk))
3590536
>>>
>>> id(People.talk)
11662608
>>> id(p1.talk)
3590536
>>> id(p2.talk)
3590536
>>>

　　　　- 关于 id() 的补充：

def id(*args, **kwargs): # real signature unknown
    """
    Return the identity of an object.
    
    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object's memory address.)
    """
    pass

　　　　- 数据属性

　　　　　　上例中的 country 就是类People的数据属性；

　　　　- 函数属性

　　　　　　talk 和 __init__ 就是类People的函数属性；

class People():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

print(type(People.country))
print(People.talk)
print(People.__init__)

---
<class 'str'>
<function People.talk at 0x000000000071C488>
<function People.__init__ at 0x000000000071C400>

　　　　- 类属性的补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

　　- 类和对象的名称空间

　　　　- 关于名称空间的补充

名称空间是名称(标识符)到对象的映射； 
 
向名称空间添加名称的操作过程涉及到绑定标识符到指定对象的操作(以及给该对象的引用计数加 1 )；

改变一个名字的绑定叫做重新绑定；

删除一个名字叫做解除绑定；

类和对象，要查看自己的命名空间，用 类名.__dict__ 和 对象名.__dict__

 　　　  - 创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性；

　　　　- 创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性；

class Chinese:
    country = 'China'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        print('Say chinese...')

p1 = Chinese('egon',18)
print(Chinese.__dict__)    # 类的名称空间包含 talk 和 __init__ （函数属性）、包含 country（数据属性）；
print(p1.__dict__)         # 对象的名称空间只包含 name 和 age （只有数据属性）

---
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'talk': <function Chinese.talk at 0x0000000000A1C488>, '__init__': <function Chinese.__init__ at 0x0000000000A1C400>, 'country': 'China', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
{'name': 'egon', 'age': 18}

　　- 类的两种用法

　　　　- 实例化

　　　　　　类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征；

class People():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

p1 = People('standby')   # 这一步实质上就是在执行： People.__init__(p1,'standby')；然后执行People类里的__init__函数里的赋值语句： p1.name = name (即：standby)
p1.talk()

---
standby comes from China

　　　　- 属性引用

class People():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

print(People.country)         # 引用类的数据属性，该属性与所有对象共享；
print(People.talk)            # 引用类的函数属性；
 
---
China
<function People.talk at 0x0000000000A6C488>

　　　　- 示例扩展

class People():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

print(People.country)         
print(People.__dict__)               # 查看类的属性字典，或者说是名称空间
print(People.__dict__['country'])

---
China
{'talk': <function People.talk at 0x0000000000B4C488>, 'country': 'China', '__init__': <function People.__init__ at 0x0000000000B4C400>, '__doc__': None, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__module__': '__main__'}
China

　　- 对象的用法

　　　　- 只有属性引用

　　　　- 对象/实例本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法；

　　　　- 绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样；

class People():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s comes from %s' % (self.name,self.country))

p1 = People('standby')
print(p1.__dict__)               # 查看对象的属性字典，或者说是名称空间
print(p1.name)
print(p1.__dict__['name'])

---
{'name': 'standby'}
standby
standby

　　　　- 补充

定义在类内部的变量，是所有对象共有的，id全一样

定义在类内部的函数，是绑定到所有对象的，是给对象来用，obj.func() 会把obj本身当做第一个参数出入

绑定方法：绑定到谁身上，就是给谁用的，谁来调用就会自动把自己当做第一个参数传入

print(p1.x) #先从p1.__dict__，找不到再找People.__dict__，然后是父类，再找不到就会报错；

　　　　- 练习1：

# 统计一共实例化了多少个对象
class Chinese:
    count = 0
    def __init__(self,name):
        Chinese.count += 1
    def talk(self):
        print('--->> %d' % Chinese.count)

p1 = Chinese('alex')
p2 = Chinese('egon')
print(Chinese.count)
print(p1.count)
print(p2.count)

---
2
2
2

　　　　- 练习2

# 定义学生类
class Student:
    tag = 666
    def __init__(self,ID,name,age,gender):
        self.id = ID
        self.name = name
        self.age = age
        self.gender = gender
    def wailking(self):
        print('{} is walking...'.format(self.name))

s1 = Student(1,'egon',18,'male')
s2 = Student(2,'alex',19,'female')
print(s1.id)
print(s1.name)
print(s1.age)
print(s1.gender)
print(s1.tag)
s1.wailking()
s2.wailking()

---
1
egon
18
male
666
egon is walking...
alex is walking...

　　- 对象之间的交互

#对象之间的交互
class Egon:
    camp='London'
    def __init__(self,nickname,life_value=200,aggressivity=100):
        self.nickname=nickname
        self.life_value=life_value
        self.aggressivity=aggressivity
    def attack(self,enemy):
        enemy.life_value-=self.aggressivity

class Alex:
    camp = 'Florence'
    def __init__(self, nickname, life_value=100, aggressivity=200):
        self.nickname = nickname
        self.life_value = life_value
        self.aggressivity = aggressivity
    def attack(self, enemy):
        enemy.life_value -= self.aggressivity

e1 = Egon('egon1')
a1 = Alex('alex1')
print(a1.life_value)
e1.attack(a1)  #发送了一条消息，称为向g发送了attack指令
print(a1.life_value)

---
100
0

 

三、继承与派生

　　- 继承的概念

　　　　- 一种创建新的类的方式；在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类；

　　　　- 通过继承可以在一个一般的类的基础上建立新的类，被继承的类称为基类，在基类的基础上建立的新类成为派生类；

　　　　- 继承可以减少冗余代码；

　　　　- 子类继承父类，则继承了父类的数据属性和函数属性，可以通过 子类名.属性名 的方式来调用；

class ParentClass1:
    pass
class ParentClass2:
    pass
class SubClass1(ParentClass1):
    pass
class SubClass2(ParentClass1,ParentClass2):
    pass

print(SubClass1.__bases__)      # 单继承
print(SubClass2.__bases__)      # Python中允许继承多个类，即多继承

---
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

　　　　- 如果没有指定父类/基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现；

print(ParentClass1.__bases__)
print(ParentClass2.__bases__)

---
(<class 'object'>,)
(<class 'object'>,)

　　- 新式类和经典类

　　　　- Python2 分两种

　　　　　　- 新式类

class Foo(object):
    pass

　　　　　　- 经典类

class Bar:
    pass

　　　　- Python3 只有新式类

class Foo:
    pass

print(Foo.__bases__)     # 类名称.__bases__ 可以查看这个类的父类是什么； Python3 里面，默认就给经典类加上了 object父类/基类

---
(<class 'object'>,)

　　- 先抽象再继承

　　　　- 抽象

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次： 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类； 

    2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类；

  

　　　　- 继承：

　　　　　　是基于抽象的结果，通过编程语言去实现它；

　　　　　　肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构；

　　- 派生

 　　　  - 子类继承了父类，在子类定义新的属性，覆盖掉父类的属性,称为派生；

　　　　- 练习1：

class Animal:                                       # 定义父类/基类
    def __init__(self,name,age,sex):                # 父类初始/实例化函数
        self.name = name                            # 初始化父类的三个数据属性
        self.age = age
        self.sex = sex

    def talk(self):                                 # 定义父类的函数属性
        print("%s 发出奇怪的声音..." % self.name)
    def eat(self):
        print("%s eatting..." % self.name)

class People(Animal):                               # 定义第一个子类，继承Animal父类
    def __init__(self,name,age,sex,education):      # 定义子类的初始化函数（重写了子类的初始化函数），覆盖了父类/基类的初始化函数
        Animal.__init__(self,name,age,sex)          # 先调用父类的初始化函数初始化 name age sex 这三个共有的属性
        self.education = education                  # 再初始化子类私有的数据属性：education
    def talk(self):                                 # 定义子类的 talk() 函数，覆盖了父类的 talk() 函数
        print("%s say hello" % self.name)

class Pig(Animal):                                  # 定义第二个子类：Pig
    pass
class Dog(Animal):                                  # 定义第三个子类：Dog
    pass

people1 = People('standby',23,'male','Bachelor')    # 初始化 People的实例；等价于：People.__init__(people1,'standby',23,'male','Bachelor')；   派生
pig1 = Pig('alex',99,'female')                      # 初始化 Pig实例；等价于：Pig.__init__(pig1,'alex',99,'female')
dog1 = Dog('egon',18,'male')                        # 初始化 Dog实例
people1.talk()                                      # People类对象people1调用talk()方法；注意：这个talk是子类的talk，而非父类的talk；
pig1.talk()                                         # Pig类对象pig1调用talk()方法；Pig类没有重写 talk()函数，所以这个talk就是父类的talk;
dog1.talk()

---
standby say hello
alex 发出奇怪的声音...
egon 发出奇怪的声音...

# obj.name 的搜索顺序：
# 
# 1.先找 obj.__dict__
#
# 2.再找obj所归属的类的属性字典，即：类名.__dict__
#
# 3.然后再找父类的属性字典，即：父类名.__dict__
#
# 父类也找不到的话就报错：AttributeError

　　　　- 练习2：

class Parent:
    def foo(self):
        print('Parent.foo')
        self.bar() #s.bar()
    def bar(self):
        print('Parent.bar')

class Sub(Parent):
    def bar(self):
        print('Sub.bar')

sub1 = Sub()
sub1.foo()              # 等价于 foo(sub1) ，所以会去执行Sub类的 bar() 函数，也是一种派生；
print(sub1.__dict__)
print(Sub.__dict__)
print(Parent.__dict__)

---
Parent.foo
Sub.bar
{}
{'__module__': '__main__', 'bar': <function Sub.bar at 0x000000000110C598>, '__doc__': None}
{'__module__': '__main__', 'foo': <function Parent.foo at 0x000000000110C488>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Parent' objects>, '__dict__': <attribute '__dict__' of 'Parent' objects>, 'bar': <function Parent.bar at 0x000000000110C510>}

　　- 继承与重用

 　　　　- 所谓重用，就是代码的复用，避免大量重复的代码

　　　　　　- 示例1，没有通过继承重用的代码：

class Cat():
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s eatting..." % self.name)
    def run(self):
        print("%s running..." % self.name)
    def talk(self):
        print('Cat 喵喵喵...')

class Dog():
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("%s eatting..." % self.name)
    def run(self):
        print("%s running..." % self.name)
    def talk(self):
        print('Dog 汪汪汪...')

cat = Cat('cat1')
dog = Dog('dog1')
cat.eat()
cat.run()
cat.talk()
dog.eat()
dog.run()
dog.talk()

---
cat1 eatting...
cat1 running...
Cat 喵喵喵...
dog1 eatting...
dog1 running...
Dog 汪汪汪...

　　　　- 由于cat类和dog类都有相同的eat()函数和run()函数，所以可以尝试抽象出一个Animal类，通过继承Animal，就可以减少冗余代码：

class Animal():
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s eatting..." % self.name)
    def run(self):
        print("%s running..." % self.name)

class Cat(Animal):
    def talk(self):
        print('Cat 喵喵喵...')
class Dog(Animal):
    def talk(self):
        print('Dog 汪汪汪...')

cat = Cat('cat1')
dog = Dog('dog1')
cat.eat()
cat.run()
cat.talk()
dog.eat()
dog.run()
dog.talk()

---
cat1 eatting...
cat1 running...
Cat 喵喵喵...
dog1 eatting...
dog1 running...
Dog 汪汪汪...

　　　　- 继承反映的是一种什么是什么的关系；本例中cat是动物，dog也是动物；

　　- 组合与重用

　　　　- 组合也可以解决代码冗余问题，但是组合反映是一种什么有什么的关系；

　　　　- 类的组合：在一个类中以另外一个类的对象作为数据属性；

　　　　- 示例1：

class People():
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell(self):
        print('%s-%s-%s' %(self.year,self.mon,self.day))

class Teacher(People):
    def __init__(self,name,age,sex,salary,year,mon,day):
        # self.name=name                            # 第一种方式
        # self.age=age
        # self.sex=sex
        # People(name,age,sex)                      # 第二种方式
        People.__init__(self,name,age,sex)          # 第三种方式
        self.salary=salary
        self.birth=Date(year,mon,day)               # Date类的对象作为 Teacher类的数据属性，成为类的组合；反映的是有的关系，即老师有生日；
                                                    # 如果再有学生类、家长类等，都可以通过组合的方式实现  有 的关系，减少代码的冗余；
t=Teacher('egon',18,'male',3000,1995,12,31)
t.birth.tell()

---
1995-12-31

　　- 接口与归一化设计

　　　　- 接口，可以理解为接口继承；（Java 语言中的接口很好的实现了接口的含义）

　　　　- 接口类包含一组功能的集合，但是只定义函数，并没有函数体（即没有去实现）；

　　　　- 这些接口函数由子类继承并实现具体的功能；

继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）；

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能；

　　　　- 示例1：模拟Java中的接口

class File:                       # 定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self):               # 定接口函数read
        raise TypeError('类型错误')
    def write(self):              # 定义接口函数write
        raise TypeError('类型错误')

class Txt(File):                  #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的写入方法')
class Sata(File):                 #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')
    def write(self):
        print('硬盘数据的写入方法')
class Process(File):              # 进程，具体实现read和write
    def read(self):
        print('进程数据的读取方法')
    def write(self):
        print('进程数据的写入方法')
p=Process()
t=Txt()
d=Sata()

print(isinstance(t,File))         # 判断 t/p/d 这些对象是否是 File类的实例化对象；
print(isinstance(p,File))
print(isinstance(d,File))

t.read()
p.read()
d.read()

---
True
True
True
文本数据的读取方法
进程数据的读取方法
硬盘数据的读取方法

　　　　- 补充，可以通过 raise + error 的方式进一步模拟 【只定义函数，没有函数体的形式】

class File:
    def read(self): 
        raise TypeError('类型错误')
    def write(self):
        raise TypeError('类型错误')

　　　　- 归一化

接口继承实质上是要求 “做出一个良好的抽象，这个抽象规定了一个兼容接口，
使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”
                                     ——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合；
就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕
当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定；

　　- 抽象类

　　　　- 抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化；

　　　　- 为什么要有抽象类？

　　　　　　- 如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

从实现角度来看，抽象类与普通类的不同之处在于：
    抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，
    且子类必须实现抽象方法。  

　　　　- 继续接口的归一化问题，但是如果子类并没有去实现父类的read和write，或者是定义其他的函数名字，这样不就又不统一了吗？

class File:
    def read(self):
        raise TypeError('类型错误')
    def write(self):
        raise TypeError('类型错误')

class Process(File):               # 类似于这样，Process子类继承了File父类，但是也可以不去实现File父类里的read和write方法；
    def du(self):                  # 这样在示例话Process对象的时候也是可以的，并不报错；
        print('进程数据的读取方法')
    def xie(self):
        print('进程数据的写入方法')

p=Process()

　　　　- 如何避免这种情况呢？换句话说，如何强制子类必须去实例化 父类里的定义的接口函数呢？　

# 抽象类；   使用abc模块强制子类必须实现父类里定义的接口函数；
import abc
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod                # 定义抽象方法，无需实现功能；
    def read(self):                    # 子类必须要实现这个抽象方法；
        pass
    @abc.abstractmethod                # 定义抽象方法，无需实现功能
    def write(self):                   # 子类必须要实现这个抽象方法
        pass

class Process(File):
    def xie(self):     # 如果子类没有实现父类定义的接口函数，就报出异常；
        pass
    def du(self):
        pass
p=Process()

---
Traceback (most recent call last):
  File "D:/soft/work/Python_17/day07/blog.py", line 185, in <module>
    p=Process()
TypeError: Can't instantiate abstract class Process with abstract methods read, write

　　　　- 这样大家就都归一化了；即让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度；

　　- 继承实现的原理（继承的顺序）

 

　　　　- 例如有如下几个类：

　　　　- 示例代码：

class A:
    def test(self):
        print('from A')
    pass
class B(A):
    def test(self):
        print('from B')
    pass
class C(A):
    def test(self):
        print('from C')
    pass
class D(B):
    def test(self):
        print('from D')
    pass
class E(C):
    def test(self):
        print('from E')
    pass
class H(A):
    def test(self):
        print('from H')
    pass
class F(D,E,H):
    def test(self):
        print('from F')
    pass
f=F()
f.test()
print(F.mro())    # 可以通过 子类.mro() 的形式查看继承的顺序
 
---
from F
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.H'>, <class '__main__.A'>, <class 'object'>]

# 经典类：深度优先，F->D->B->A->E->C->H
# 新式类：广度优先，F->D->B->E->C->H->A   （Python3 都是新式类）

　　- 子类调用父类的方法

 　　　　- 第一种方法：

class Foo1:
    def test(self):
        print('from foo1.test')
    pass
class Foo2:
    def test(self):
        print('from foo2.test')
class Bar(Foo1,Foo2):
    def test(self):
        Foo1.test(self)    # 在子类中，使用 父类名.父类函数名 的方法调用父类；这种跟父类的耦合性太强，如果父类名字改了，就不能调用了；
        Foo2.test(self)
        print('bar')
print(Bar.mro())
b=Bar()
b.test()

---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo1.test
from foo2.test
bar

　　　　- 第二种方法：

class Foo1:
    def test(self):
        print('from foo1.test')
    pass
class Foo2:
    def test(self):
        print('from foo2.test')
class Bar(Foo1,Foo2):
    def test(self):
        super().test()       # 通过super()替代父类的名字；
        print('bar')
print(Bar.mro())
b=Bar()
b.test()

---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo1.test
bar

class Foo1:
    pass
class Foo2:
    def test(self):
        print('from foo2.test')
class Bar(Foo1,Foo2):
    def test(self):
        # Foo1.test(self)
        # Foo2.test(self)
        super().test()             # 继承了2个父类，如果第一个父类没有要调用的名字，就会去找第二个父类；
        print('bar')
print(Bar.mro())                   # Bar.mro()  等价于  Bar.__mro__
b=Bar()
b.test()

---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo2.test
bar

 

四、多态与多态性

　　- 多态

　　　　- 多态是同一种事物的多种形态;

　　　　- 一个抽象类有多个子类，因而多态的概念依赖于继承;

　　　　- 示例：

import abc
class Animal(metaclass=abc.ABCMeta):     # 同一类事物：动物
    @abc.abstractmethod
    def talk(self):
        pass

class Cat(Animal):                       # 动物形态之一：猫
    def talk(self):
        print('喵喵喵')
class Dog(Animal):                       # 动物形态之二：狗
    def talk(self):
        print('汪汪汪')
class Pig(Animal):                       # 动物形态之三：诸
    def talk(self):
        print('哼哼哼')

　　- 多态性

　　　　- 指具有不同功能的函数，可以具有相同的函数名；

　　　　- obj.func() --> 是调用了obj的方法func，又称为向obj发送了一条消息func;

　　　　- 多态性指的是具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数；

在面向对象方法中一般是这样表述多态性：
    向不同的对象发送同一条消息（obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func）
    不同的对象在接收时会产生不同的行为（即方法）。

也就是说，每个对象可以用自己的方式去响应共同的消息。

所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

　　　　- 示例：

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass

class Cat(Animal):
    def talk(self):
        print('喵喵喵')
class Dog(Animal):
    def talk(self):
        print('汪汪汪')
class Pig(Animal):
    def talk(self):
        print('哼哼哼')

cat1 = Cat()
dog1 = Dog()
pig1 = Pig()

def func(x):
    x.talk()

func(cat1)
func(dog1)
func(pig1)

---
喵喵喵
汪汪汪
哼哼哼

　　- 为何要用多态性？

1.增加了程序的灵活性
以不变应万变，不论对象如何变化，使用者都用同一种方式去调用，如func(animal)

2.增加了程序的可扩展性

 

五、封装

　　- 要封装什么？

　　　　- 数据的封装

　　　　- 函数/方法的封装

　　- 为什么要封装？

　　　　- 封装数据：保护隐私

　　　　- 封装函数/方法：隔离复杂度；（只需要提供一个最简单的操作方法给用户，把内部的实现隐藏起来）

　　- 封装的两个层面

封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口；

接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口；

并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问；

　　　　- 第一种封装：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装；

class demo():
    x = 10
    def test(self):
        print('from demo -> test')
d = demo()
print(demo.x)
print(d.x)

---
10
10

　　　　　　- 对于这一层面的封装（隐藏），类名. 和 实例名. 就是访问隐藏属性的接口；

　　　　- 第二中封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问；

在python中用双下划线开头的方式实现隐藏属性（设置成私有的）；

类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式；

类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果；

这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的；

在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的；

对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了；

　　　　　　- 属性没有隐藏的例子

class demo():
    x = 10
    def test(self):
        print('from demo -> test')

print(demo.x)
print(demo.__dict__)
print(demo.__dict__['x'])

---
10
{'__dict__': <attribute '__dict__' of 'demo' objects>, '__weakref__': <attribute '__weakref__' of 'demo' objects>, 'test': <function demo.test at 0x00000000007CC400>, '__module__': '__main__', '__doc__': None, 'x': 10}
10

　　　　　　- 属性隐藏的例子： __x  在类的属性字典里变成了  _demo__x

class demo():
    __x = 10
    def test(self):
        print('from demo -> test')

# print(demo.__x)        # 报错：AttributeError: type object 'demo' has no attribute '__x'
print(demo.__dict__)
print(demo.__dict__['_demo__x'])

---
{'test': <function demo.test at 0x000000000109C400>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'demo' objects>, '_demo__x': 10, '__weakref__': <attribute '__weakref__' of 'demo' objects>, '__doc__': None}
10

　　　　　　- 函数/方法的没有隐藏的例子：

class Parent():
    def foo(self):
        print('from Parent.foo')
        self.bar()                     # 调用的是子类的方法
    def bar(self):
        print('from Parent.bar')

class Son(Parent):
    def bar(self):
        print('from Son.bar')

s = Son()
s.foo()

---
from Parent.foo
from Son.bar

　　　　　　- 函数/方法的隐藏的例子：

class Parent():
    def foo(self):
        print('from Parent.foo')
        self.__bar()                   # 只有在类内部才可以通过 .__bar() 访问到；因为这行在定义的阶段就会变形成： self._Parent__bar()
    def __bar(self):                   # 调用的是父类的方法 ;   定义阶段就会变形成：def _Parent__bar()
        print('from Parent.bar')

class Son(Parent):
    def __bar(self):
        print('from Son.bar')

s = Son()
s.foo()

---
from Parent.foo
from Parent.bar

　　　　- 注意

这种机制也并没有真正意义上限制我们从外部直接访问属性；
知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N；

变形的过程只在类的定义时发生一次；在定义后的赋值操作，不会变形；

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的；

　　　　- 示例补充：

class Parent():
    def foo(self):
        print('from Parent.foo')
        self.__bar()                  # 在定义的时候就会变形成：  self._Parent__bar()
    def __bar(self):                  # def _Parent__bar()
        print('from Parent.bar')

class Son(Parent):
    def __bar(self):                  # 在定义的时候就会变形：def _Son__bar()
        print('from Son.bar')

s = Son()
print(s.__dict__)
print(Son.__dict__)
print(Parent.__dict__)
s._Son__bar()
Son.__dict__['_Son__bar'](s)
s._Parent__bar()
Parent.__dict__['_Parent__bar'](s)

---
{}
{'_Son__bar': <function Son.__bar at 0x000000000110C510>, '__module__': '__main__', '__doc__': None}
{'__weakref__': <attribute '__weakref__' of 'Parent' objects>, '__dict__': <attribute '__dict__' of 'Parent' objects>, '_Parent__bar': <function Parent.__bar at 0x000000000110C488>, '__module__': '__main__', 'foo': <function Parent.foo at 0x000000000110C400>, '__doc__': None}
from Son.bar
from Son.bar
from Parent.bar
from Parent.bar

　　　　- 示例：在父类中定义接口函数，供外部调用，从而访问父类的私有属性

# 私有属性的查看和更改 + raise使用
class People():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def get_info(self):
        print('Name is %s, age is %s' % (self.__name,self.__age))

    def set_info(self,name,age):
        if not isinstance(name,str):              # Python没有类型检查一说，所以需要自己提供类型检查；
            raise TypeError('名字必须是字符串')     # 如果用户输入的名字不是 str 类型就抛出类型错误；
        if not isinstance(age,int):
            raise TypeError('年龄必须是整数')       # 如果用户输入的年龄不是 int 类型就抛出类型错误；
        self.__name = name
        self.__age = age

p1 = People('Alex',18)
p1.get_info()
p1.set_info('egon',20)
p1.get_info()
p1.set_info('standby',21)
p1.get_info()

---
Name is Alex, age is 18
Name is egon, age is 20
Name is standby, age is 21

　　- 特性，property

装饰器本身可以是任意可调用对象（包括函数、类...）

　　　　- property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值；

　　　　　　- 正常的样子：

class Foo():
    def test(self):
        print('from Foo.test')
    # test = property(test)

f = Foo()
f.test()

---
from Foo.test

　　　　　　- 使用property的样子：

　　　　　　　　- 示例1：

class Foo():
    def test(self):
        print('from Foo.test')
    test = property(test)           # property是一个类

f = Foo()
f.test                              # 不用加 () 执行

---
from Foo.test

　　　　　　　　- 示例2：装饰器形式

class Foo():
    @property                       # 属性装饰器
    def test(self):
        print('from Foo.test')

f = Foo()
f.test                              # 不用加 () 执行

---
from Foo.test

　　　　　　- 练习：计算圆的周长和面积

import math
class Circle():
    def __init__(self,radius):
        self.radius = radius
    @property
    def perimeter(self):
        return math.pi * self.radius * 2
    @property
    def area(self):
        return math.pi * self.radius ** 2

c = Circle(5)
print(c.perimeter)       # 可以向访问数据属性一样去访问perimeter，会触发一个函数的执行，动态计算出一个值；
print(c.area)            # 同上

---
31.41592653589793
78.53981633974483

　　　　　　- property扩展用法：封装+提供接口

class People():
    def __init__(self,name,permmission=False):
        self.__name = name
        self.permmission = permmission

    @property
    def name(self):                                   # 属性装饰器，让对象可以像访问数据属性一样去访问name，实际上访问的是 _Peopel__name 
        return self.__name                            # 可以理解为 _People__name 的get方法
    @name.setter
    def name(self,name):                              # 设置针对 _People__name 的set方法
        if not isinstance(name,str):
            raise TypeError('名字必须是字符串类型')
        self.__name = name
    @name.deleter
    def name(self):                                   # 设置 _People__name 的del方法
        if not self.permmission:
            raise PermissionError('不允许的操作！')
        del self.__name

p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
del p1.name

---
standby
alex
Traceback (most recent call last):
  File "D:/soft/work/Python_17/day07/blog.py", line 326, in <module>
    del p1.name
  File "D:/soft/work/Python_17/day07/blog.py", line 319, in name
    raise PermissionError('不允许的操作！')
PermissionError: 不允许的操作！

class People():
    def __init__(self,name,permmission=False):
        self.__name = name
        self.permmission = permmission

    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,name):
        if not isinstance(name,str):
            raise TypeError('名字必须是字符串类型')
        self.__name = name
    @name.deleter
    def name(self):
        if not self.permmission:
            raise PermissionError('不允许的操作！')
        del self.__name

p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
p1.permmission = True                        # 设置删除权限为 True
del p1.name                                  # 删除操作
print(p1.name)

---
standby
alex
Traceback (most recent call last):
  File "D:/soft/work/Python_17/day07/blog.py", line 328, in <module>
    print(p1.name)
  File "D:/soft/work/Python_17/day07/blog.py", line 310, in name
    return self.__name
AttributeError: 'People' object has no attribute '_People__name'

　　　　　　- 另一种写法：

class People():
    def __init__(self,name,permmission=False):
        self.__name = name
        self.permmission = permmission

    def get_name(self):
        return self.__name
    def set_name(self,name):
        if not isinstance(name,str):
            raise TypeError('名字必须是字符串类型')
        self.__name = name
    def del_name(self):
        if not self.permmission:
            raise PermissionError('不允许的操作！')
        del self.__name
    name = property(get_name,set_name,del_name)             # 按照顺序；   与上面的例子是同样的效果；

p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
p1.permmission = True
del p1.name
print(p1.name)

　　- 封装与扩展性

于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；

而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。

这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。 

 

六、绑定方法与非绑定方法

　　- 1.绑定方法

　　　　- 绑定到对象的方法

　　　　　　- 在类中定义的，没有被任何装饰器装饰的函数都是绑定到对象的方法；

　　　　　　- 对象的自动传值（把自己当做第一个参数传进去）;

　　　　　　- 示例1：

class Foo():
    def test1(self):
        print('test1, ',self)

f = Foo()
print(Foo.test1)    # test1 对于类 Foo来说就是一个函数
print(f.test1)      # 对于对象f来说就是一个 绑定方法（bound method）
f.test1()           # test1函数绑定到对象 f上，f 在调用的时候就会自动把自己当做第一个参数传进去；

---
<function Foo.test1 at 0x00000000010CC400>
<bound method Foo.test1 of <__main__.Foo object at 0x00000000010CA908>>
test1,  <__main__.Foo object at 0x00000000010CA908>

　　　　　　- 示例2：

class Foo():
    def test1():           # 类Foo中定义的函数没有参数
        print('test1, ')

f = Foo()
f.test1()                  # 根据绑定方法的定义，对象 f 在调用的时候就会把自己当做第一个参数传进去；所以会报错；

---
Traceback (most recent call last):
  File "D:/soft/work/Python_17/day07/blog.py", line 396, in <module>
    f.test1()
TypeError: test1() takes 0 positional arguments but 1 was given

　　　　- 绑定到类的方法

　　　　　　- 在类中定义的，被 @classmethod 修饰的函数就是绑定到类的方法；

　　　　　　- 类的自动传值（把自己当做第一个参数传进去）;

class Foo:
    @classmethod           # 定义绑定到类的方法 
    def test(cls):
        print(cls)

print(Foo)
Foo.test()                 # 绑定到类的方法，类在调用的时候就会把自己当做第一个参数传进去；

---
<class '__main__.Foo'>
<class '__main__.Foo'>

　　- 2.非绑定方法

　　　　- 在类中定义的，既不绑定到对象，也不绑定到类的函数；被 @staticmethod 修饰的函数；

　　　　- 不管谁来调用都没有自动传值一说；

　　　　- 就是类内部定义的一个 "普通工具"；

class Foo:
    @staticmethod
    def test():
        print('test...')

f = Foo()
print(Foo)
print(f)
Foo.test()
f.test()
print(Foo.test)           
print(f.test)
print(Foo.__dict__)

---
<class '__main__.Foo'>
<__main__.Foo object at 0x00000000010F2390>
test...
test...
<function Foo.test at 0x00000000010EC400>           
<function Foo.test at 0x00000000010EC400>
{'test': <staticmethod object at 0x00000000010EA860>, '__doc__': None, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>}

　　　　- 扩展示例：

class Foo:
    def test1(self):
        pass
    @classmethod
    def test2(cls):
        print(cls)
    @staticmethod
    def test3():
        pass

f=Foo()
print(f.test1)               # 绑定到对象的方法
print(Foo.test2)             # 绑定到类的方法
print(Foo.test3)             # 谁也不绑定的方法，只是类的函数属性
print(f.test3)               # 谁也不绑定的方法，只是类的函数属性

---
<bound method Foo.test1 of <__main__.Foo object at 0x0000000000A32470>>
<bound method Foo.test2 of <class '__main__.Foo'>>
<function Foo.test3 at 0x0000000000A2C510>
<function Foo.test3 at 0x0000000000A2C510>

　　- 3.应用

　　　　- 示例1：绑定到对象

class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
        print('conneting...')
    def select(self): #绑定到对象的方法
        print(self)
        print('select function')

conn=MySQL('192.168.1.3',3306)
conn.select()

---
conneting...
<__main__.MySQL object at 0x0000000000B2A860>
select function

　　　　- 示例2：绑定到类

# settings.py
HOST='127.0.0.1'
PORT=3306

# 执行文件
import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
        print('conneting...')
    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT) # 等价于 MySQL('127.0.0.1',3306)，即间接调用类的 __init__()函数
    def select(self): #绑定到对象的方法
        print(self)
        print('select function')

conn = MySQL.from_conf()                        # 等价于把 MySQL当做第一个参数传给类的方法 from_conf()
conn.select()

---
conneting...
<__main__.MySQL object at 0x00000000010E2470>
select function

　　　　- 示例3：谁也不绑定的普通函数

def time(): # real signature unknown; restored from __doc__
    """
    time() -> floating point number
    
    Return the current time in seconds since the Epoch.
    Fractions of a second may be present if the system clock provides them.
    """
    return 0.0

def clock(): # real signature unknown; restored from __doc__
    """
    clock() -> floating point number
    
    Return the CPU time or real time since the start of the process or since
    the first call to clock().  This has as much precision as the system
    records.
    """
    return 0.0

# 生成一个唯一的id
import time, hashlib

def create_id():
    m = hashlib.md5(str(time.time()).encode('utf-8'))
    return m.hexdigest()
print(create_id())
print(create_id())
print(create_id())

---
23e5f91da003f794b3e0b35681f0e91e
23e5f91da003f794b3e0b35681f0e91e
23e5f91da003f794b3e0b35681f0e91e

import time, hashlib

def create_id():
    m = hashlib.md5(str(time.clock()).encode('utf-8'))
    return m.hexdigest()
print(create_id())
print(create_id())
print(create_id())

---
362dc18e003ee03d1c64f35aef957966
0069e3d295dd493495db0adfd8008df1
31dded025da89a196a05a40db3d50e5f

　　　　　　- 在示例2的基础上，给每次实例化连接都附加一个id属性

# settings.py
HOST='127.0.0.1'
PORT=3306

# 执行文件
import hashlib
import time
import settings
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
        print('conneting...')

    @staticmethod
    def create_id(): #非绑定方法，就是类中的普通工具包
        m=hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()
    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT) #MySQL('127.0.0.1',3306)
    def select(self): #绑定到对象的方法
        print('%s --> select function' % self.id)

conn1=MySQL.from_conf()
conn2=MySQL.from_conf()
conn3=MySQL.from_conf()
conn4=MySQL.from_conf()
conn1.select()
conn2.select()
conn3.select()
conn4.select()

---
conneting...
conneting...
conneting...
conneting...
362dc18e003ee03d1c64f35aef957966 --> select function
7067177e6221914604cc0711d39524b2 --> select function
daef6092a8bfdbed7c6ebae5d8991c50 --> select function
e035b6f811ff8e7604f25d2f637fa08d --> select function

　　　　- 示例4：classmethod 和 staticmethod 的区别，以及 __str__() 的使用

class Foo():
    def __init__(self):
        print('Foo.__init__ function...')
    def __str__(self):                         # 重写 __str__ 函数
        return 'Foo.__str__ function...'

f = Foo()  # 等价于：Foo.__init__(f)
print(f)
print(f.__str__())
print(Foo.__str__)

---
Foo.__init__ function...
Foo.__str__ function...
Foo.__str__ function...
<function Foo.__str__ at 0x00000000006EC488>

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        # print('run __str__')
        return 'name:%s age:%s' %(self.name,self.age)

p1=People('egon1',18)
p2=People('egon2',28)
print(p1)
print(p2)

---
name:egon1 age:18
name:egon2 age:28

　　　　　　- staticmethod

import settings
class MySql():
    def __init__(self,host,port):
        self.host = host
        self.port = port
        print('Connecting...')
    @staticmethod
    def from_conf():
        return MySql(settings.HOST, settings.PORT)
    def __str__(self):                                # 重写 __str__ 函数
        print('from MySql.__str__()')
        return ('MySql...')
class Mariadb(MySql):
    def __str__(self):
        print('from Mariadb.__str__()')
        return 'Host: %s, Port: %s' % (self.host, self.port)

conn = Mariadb.from_conf()               # 子类没有 from_conf() 函数，所以去父类找，父类的from_conf是一个staticmethod，并且返回了一个 MySQL对象
print(conn)                              # 所以conn实际上是父类的对象，即执行父类里的 __str__函数

---
Connecting...
from MySql.__str__()
MySql...

　　　　　　- classmethod

import settings
class MySql():
    def __init__(self,host,port):
        self.host = host
        self.port = port
        print('Connecting...')
    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT)
    def __str__(self):                            # 重写 __str__ 函数
        print('from MySql.__str__()')
        return ('MySql...')
class Mariadb(MySql):
    def __str__(self):
        print('from Mariadb.__str__()')
        return 'Host: %s, Port: %s' % (self.host, self.port)

conn = Mariadb.from_conf()                        # 继承父类的from_conf函数，但父类的from_conf是一个绑定到类的方法，是子类在调用，所以传进去的参数是子类；
print(conn)                                       # 所以conn是子类的对象，故执行的是子类的 __str__函数；

---
Connecting...
from Mariadb.__str__()
Host: 127.0.0.1, Port: 3306

　　　　- 练习5：

练习2（学生自己写）：定义MySQL类

　　1.对象有id、host、port三个属性

　　2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一

　　3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化

　　4.为对象定制方法，save和get，save能自动将对象序列化到文件中，文件名为id号，文件路径为配置文件中DB_PATH;get方法用来从文件中反序列化出对象

　　　　- 代码实现：

# settings
HOST = '127.0.0.1'
PORT = 3306
DB_PATH = r"D:\soft\work\Python_17\day07\MySql\account"

# MySql.py
import settings
import pickle
import os,time,hashlib

class MySql():
    def __init__(self,host,port):
        self.id = self.create_id()
        self.host = host
        self.port = port
        print('Connecting...')
    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT)
    @staticmethod
    def create_id():
        m = hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()
    def save(self):
        file_path = r"%s%s%s" % (settings.DB_PATH, os.sep, self.id)
        pickle.dump(self,open(file_path,'wb'))
    def get(self):
        file_path = r"%s%s%s" % (settings.DB_PATH, os.sep, self.id)
        return pickle.load(open(file_path,'rb'))

conn1 = MySql('10.0.0.2','22')
conn2 = MySql.from_conf()
print(conn1,conn1.id,conn1.host,conn1.port)
print(conn2,conn2.id,conn2.host,conn2.port)
conn1.save()
conn2.save()
res1 = conn1.get()
res2 = conn2.get()
print(res1,res1.id,res1.host,res1.port)
print(res2,res2.id,res2.host,res2.port)

---
Connecting...
Connecting...
<__main__.MySql object at 0x00000000011B8CC0> 437656776fa5cd96c6a670bef33e81e4 10.0.0.2 22
<__main__.MySql object at 0x00000000011AC208> 5b18e65260ecafe8aa8d34881721f166 127.0.0.1 3306
<__main__.MySql object at 0x00000000011AC668> 437656776fa5cd96c6a670bef33e81e4 10.0.0.2 22
<__main__.MySql object at 0x00000000011AC3C8> 5b18e65260ecafe8aa8d34881721f166 127.0.0.1 3306

 

 

七、类的内置函数

　　

1.__init__      # 初始化，不能有返回值
2.__str__       # 必须有返回值，且必须是 str类型

 __doc__

__bases__

 

八、反射/自省

　　- python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）；

　　　　- 通过类名获得类的实例对象；

　　　　- 通过方法名得到方法，实现调用；

　　　　- 示例1：通过字符串的方式去寻找一些属性

class Chinese:
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age

print(Chinese.country)    # Chinese.__dict__['country']

p=Chinese('egon',18)
print(p.name)             # p.__dict__['name']

---
China
egon

　　　　- 示例2：反射模块

import sys
class Chinese:
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age

m = sys.modules[__name__]           # 获取并打印当前模块
print(m)
if hasattr(m,'Chinese'):            # 判断当前模块是否包含 'Chinese' 名字
    res = getattr(m,'Chinese')      # 有的话就获取该属性；
    print(res)
    obj = res('standby','23')       # 获取的是一个类，所以就可以实例化一个对象
    print(obj.name,obj.age)         # 打印该对象的名字和年纪

---
<module '__main__' from 'D:/soft/work/Python_17/day07/blog.py'>
<class '__main__.Chinese'>
standby 23

　　　　- 应用：模拟ftp长传下载小程序

class FtpCLient:
    def __init__(self,host):
        self.host=host
        print('Connecting...')
    def run(self):
        while True:
            inp=input('>>>: ').strip()
            inp_l=inp.split()
            if 'Q' == inp_l[0].upper():
                print('Bye...')
                break
            if hasattr(self,inp_l[0]):
                func=getattr(self,inp_l[0])
                func(inp_l)
    def get(self,arg):
        print('download file',arg[1])
    def put(self,arg):
        print('Upload file: %s' % arg[1])

f=FtpCLient('10.0.0.9')
f.run()

 

 

p.name                  # 本质就是 p.__dict__['name']

getattr(p,'name')    # 本质就是 p.__dict__['name']

　　

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。

如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。

如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。

还有那些特殊属性,像__dict__,__name__及__doc__

hasattr(object,name)：用于判断一个对象里中是否存在name这一特性．

setattr(object, name, value):该函数给对象中的属性赋值，该属性若不存在，则会在对象里创建新的属性

getattr(object, name[, default]),object为对象名，name为对象属性（必须是字符串），
	default为name属性不存在时指定的返回内容（可以是字符串，也可以是部分指令），
	若对象中存在该属性，则函数返回object.name，
	否则返回default中的内容，若省略default,则返回 AttributeError．

delattr(object, name):删除指定对象的属性，可以配合hasattr使用

字符串和属性之间的对应关系

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.
    
    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.
    
    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value
    
    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

class Foo(object):
    def __init__(self):
        self.name = 'abc'

    def func(self):
        return 'ok'
obj = Foo()
ret = getattr(obj, 'func')  # 获取的是个对象
print(type(ret),ret)
res = ret()
print(res)
ret = hasattr(obj, 'func')  # 因为有func方法所以返回True
print(ret)
print(obj.name)
ret = setattr(obj, 'name', 'standby')
print(obj.name)
delattr(obj, 'name')        # 删除指定属性
# print(obj.name)  # 报错：AttributeError: 'Foo' object has no attribute 'name'

---
<class 'method'> <bound method Foo.func of <__main__.Foo object at 0x00000000010D34E0>>
ok
True
abc
standby

 

#!/usr/bin/python
# -*- coding:utf-8 -*-


# class Foo:
#     pass
#
# class Bar(Foo):
#     pass
#
# print(issubclass(Bar,Foo))


#反射
class Chinese:
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age

# print(Chinese.county) #Chinese.__dict__['country']

p=Chinese('egon',18)
# print(p.name) #p.__dict__['name']
#
# print(hasattr(p,'name'))                     # 判断对象p是否有name属性
# print(hasattr(Chinese,'country'))            # 判断类Chinese是否有country属性


# p.x=1
# print(p.__dict__)
# print(p.x)
# setattr(p,'x',1231231231231)                 # 设置对象p的x属性的值为 1231231231231
# print(p.__dict__)
# print(p.x)


# print(getattr(p,'x','not exist'))
# print(getattr(p,'name','not exist'))         # 获取对象p的name属性，如果不存在则返回 'not exist'

# setattr(p,'x',123123123123123)
# if hasattr(p,'x'):
#     res=getattr(p,'x')
#     print(res)

# print(Chinese.country)
# delattr(Chinese,'country')                   # 删除类的country属性
# print(Chinese.country)
# print(p.country)
# p1=Chinese('aaaaa',18)
# print(p1.country)

# import sys
# m=sys.modules[__name__]
# # print(m)
#
# if hasattr(m,'Chinese'):
#     res=getattr(m,'Chinese')
#     # print(res)
#     obj=res('egon',18)
#     print(obj.name)



p.name #p.__dict__['name']
getattr(p,'name') #p.__dict__['name']

　　

　　- 参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html#_label2

 

九、面向对象的常用术语和常见误区

　　- 1.常用术语

 

　　- 2.常见误区

 

十、扩展

　　- 1.导入模块的多种方式

　　　　- 正常导入

import sys

　　　　- 以字符串方式导入

以字符串的形式导入对应模块：
m = __import__('sys')
print(m)

import importlib
importlib.import_module('sys')

 

os.sep

os.listdir

os.walk

os.getcwd

os.cpu_count()

os.path.abspath()
os.path.abspath(__file__)

os.path.basename()

os.path.dirname()

os.path.join()

os.path.normpath()

sys.models

　　

　　　　- os.walk() 示例

# !/usr/bin/python3.4
# -*- coding: utf-8 -*-

import os

# 字节bytes转化kb\m\g
def formatSize(bytes):
    try:
        bytes = float(bytes)
        kb = bytes / 1024
    except:
        print("传入的字节格式不对")
        return "Error"
    if kb >= 1024:
        M = kb / 1024
        if M >= 1024:
            G = M / 1024
            return "%fG" % (G)
        else:
            return "%fM" % (M)
    else:
        return "%fkb" % (kb)

# 获取文件大小
def getDocSize(path):
    try:
        size = os.path.getsize(path)
        return formatSize(size)
    except Exception as err:
        print(err)
# 获取文件夹大小
def getFileSize(path):
    sumsize = 0
    try:
        filename = os.walk(path)          # 注意os.walk()的返回值
        for root, dirs, files in filename:
            for fle in files:
                size = os.path.getsize(path + fle)
                sumsize += size
        return formatSize(sumsize)
    except Exception as err:
        print(err)

if __name__ == "__main__":
    print(getDocSize("../detailhtml/20161103112313.html"))
    # 1006.142578kb
    print(getFileSize("../data/"))
    # 111.856756M

　　　　- os.getcwd() 和 os.listdir() 示例：

import os

print(os.getcwd())                # 获取当前路径
res = os.listdir(os.getcwd())     # 获取当前路径下所有的文件
print(res)

---
D:\soft\work\Python_17\day07
['blog.py', 'exercise.py', 'homework', 'id.txt', 'MySql', 's1.py', 'settings.py', '__pycache__', '上节课回顾', '本节内容']

 

十一、练习

要求：

代码结构：

'''
关联：一对多、多对多
school   course      一对多
course   classes     一对多
classes  student     一对多

course   teacher     多对多     

可以用 中间类 的形式实现多对多

学校
课程 -> 学校
班级 -> 学校 -> 课程

学生 <-> 班级
老师 <-> 课程 （关联）
'''

CourseSys
│  __init__.py
│
├─bin
│      run.py
│      __init__.py
│
├─conf
│     settings.py
│     __init__.py
│
├─core
│  │  models.py
│  │  __init__.py
│  │
│  ├─services
│         admin.py
│         readme.py
│         student.py
│         teacher.py
│    
│
└─db
    │  __init__.py
    │
    ├─admin
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │
    ├─class
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │      337cf34c9a89818f8ea03e466cc3e94e
    │      a8171b981278f2d61daf201c48aeb01f
    │      aaaa78e1efedc57b06ed703a2fe19d6e
    │      bcb2558740d2342494d464e5a0b80957
    │
    ├─course
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │      210a534cb0390e7afcb70754a2eaa75b
    │      41a0d51531f5f79f56a339876f98fb7b
    │      ecdfaf71ed7739b8b1bfa4e20b9ebe9a
    │
    ├─course_to_teacher
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │      1cd39abc387d6f4a847a6b70fba6f149
    │      2efc7ebdc320320145afccf6d9cfac2d
    │      337cf34c9a89818f8ea03e466cc3e94e
    │
    ├─school
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │      337cf34c9a89818f8ea03e466cc3e94e
    │      405aea10bcb2b6085ae3879d0fa57be1
    │
    ├─student
    │      08d24c9757db5cc358afea448b4a5621
    │      0b04526a08bca7f8eaa65c8bc2d8d937
    │      337cf34c9a89818f8ea03e466cc3e94e
    │      4e5ce2d4f7bc39765a0d0b1ed63b37ea
    │      5b4d24e0776b07b4a722ac8d3d5059b9
    │      eff6335db3e812f18e5698a83c050b9d
    │
    └─teacher
            0b04526a08bca7f8eaa65c8bc2d8d937
            592b6f828668e66d0dee4246aca50d3e

具体代码：

　　- run.py

#!/usr/bin/python
# -*- coding:utf-8 -*-
import os,sys
parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)
from core.models import *
from core.services import admin,student,teacher
from conf.settings import *

if __name__ == '__main__':
    print('+++++++++++++++++++++++++++++++')
    print('+Welcome to CourseSelected SYS+')
    print('+++++++++++++++++++++++++++++++')
    role_selected = {
        '0':admin.initializate,
        '1':student.login,
        '2':teacher.login,
        '3':admin.login,
        '4':exit
    }
    while True:
        print(WELCOME_INFO)
        option = input('Select your role and begin >>>\t').strip()
        if option not in role_selected:
            continue
        role_selected[option]()

　　- models.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

'''
关联：一对多、多对多

school   course      一对多
course   classes     一对多
classes  student     一对多

course   teacher     多对多     

可以用 中间类 的形式实现多对多

学校
课程 -> 学校
班级 -> 学校 -> 课程

学生 <-> 班级
老师 <-> 课程 （关联）
'''

import os,sys,time,hashlib,pickle
parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)
from conf import settings

class BaseModel():
    def save(self):
        file_path = r"%s%s%s" % (self.db_path,os.sep,self.uid.uid)
        pickle.dump(self,open(file_path,'wb'))
    @classmethod
    def get_all_obj_list(cls):
        # base_path = settings.PATH_DICT[cls.__name__]
        base_path = cls.db_path
        ret = []
        for file_name in os.listdir(base_path):
            path = r'%s%s%s' % (base_path,os.sep,file_name)
            obj = pickle.load(open(path,'rb'))
            ret.append(obj)
        return ret

class UUID():
    def __init__(self,db_path):
        self.uid = UUID.create_id()
        self.db_path = db_path
    def get_obj_by_uid(self):
        # path = r'%s%s%s' % (self.db_path,os.sep,self.uid)
        file_path = os.path.join(self.db_path,self.uid)
        return pickle.load(open(file_path,'rb'))
    @staticmethod
    def create_id():
        m = hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()

class Admin(BaseModel):
    db_path = settings.ADMIN_DB
    def __init__(self,name,password):
        self.uid = UUID(self.db_path)
        self.name = name
        self.password = password
        self.create_time = time.strftime('%Y-%m-%d %X')

class School(BaseModel):
    db_path = settings.SCHOOL_DB
    def __init__(self,name,addr):
        self.uid = UUID(self.db_path) # 返回的是一个UUID类的对象
        self.name = name
        self.addr = addr
        self.__income = 0   # 学校的收入，应该是隐私的
        self.create_time = time.strftime('%Y-%m-%d %X')
    def __str__(self):
        return self.name

class Course(BaseModel):
    db_path = settings.COURSE_DB
    def __init__(self,name,price,period,school_uid):
        self.uid = UUID(self.db_path)
        self.name = name
        self.price = price
        self.period = period
        self.school_uid = school_uid
        self.create_time = time.strftime('%Y-%m-%d %X')
    def __str__(self):
        return self.name

class Classes(BaseModel):
    db_path = settings.CLASSES_DB
    def __init__(self,name,sch_uid,cour_uid):
        self.uid = UUID(self.db_path)
        self.name = name
        self.sch_uid = sch_uid
        self.cour_uid = cour_uid
        self.create_time = time.strftime('%Y-%m-%d %X')
    def __str__(self):
        return self.name

class Teacher(BaseModel):
    db_path = settings.TEACHER_DB
    def __init__(self,name,password):
        self.uid = UUID(self.db_path)
        self.name = name
        self.password = password
        self.__account = 0  # 老师的账户信息，应该是隐私的
        self.create_time = time.strftime('%Y-%m-%d %X')
    def __str__(self):
        return self.name

# 老师 和 课程 是多对多的关系
class Course_to_teacher(BaseModel):
    db_path = settings.COURSE_TO_TEACHER_DB
    def __init__(self,course_uid,teacher_uid):
        self.uid = UUID(self.db_path)
        self.course_uid = course_uid
        self.teacher_uid = teacher_uid

class Student(BaseModel):
    db_path = settings.STUDENT_DB
    def __init__(self,name,password,class_uid,qq):
        self.uid = UUID(self.db_path)
        self.name = name
        self.password = password
        self.class_uid = class_uid
        self.qq = qq
        self.create_time = time.strftime('%Y-%m-%d %X')
    def __str__(self):
        return self.name

　　- /core/__init__.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

__all__ = ['School','Corese','Teacher','Student']

　　- settings.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SCHOOL_DB = os.path.join(BASE_DIR,'db','school')
COURSE_DB = os.path.join(BASE_DIR,'db','course')
TEACHER_DB = os.path.join(BASE_DIR,'db','teacher')
ADMIN_DB = os.path.join(BASE_DIR,'db','admin')
CLASSES_DB = os.path.join(BASE_DIR,'db','class')
STUDENT_DB = os.path.join(BASE_DIR,'db','student')
COURSE_TO_TEACHER_DB = os.path.join(BASE_DIR,'db','course_to_teacher')

WELCOME_INFO = '''
0.initializate
1.student
2.teacher
3.admin
4.exit
'''
ADMIN_INFO = '''
0.查看可操作选项
1.创建学校
2.查看已有学校
3.创建课程
4.查看已有课程
5.创建班级
6.查看已有班级
7.创建老师
8.查看已有老师
9.关联老师与课程
10.查看老师与课程的关联关系
11.创建学生
12.查看已有学生
13.退出
'''
STUDENT_INFO = '''
0.更改密码
1.查看所属课程及班级信息
2.查看任课教师
3.退出
'''
TEACHER_INFO = '''
0.更改密码
1.查看教授的课程
2.查看指定班级的学生名单
3.退出
'''

　　- db

db
│  __init__.py
│
├─admin
│      0b04526a08bca7f8eaa65c8bc2d8d937
│
├─class
│      0b04526a08bca7f8eaa65c8bc2d8d937
│      337cf34c9a89818f8ea03e466cc3e94e
│      a8171b981278f2d61daf201c48aeb01f
│      aaaa78e1efedc57b06ed703a2fe19d6e
│      bcb2558740d2342494d464e5a0b80957
│
├─course
│      0b04526a08bca7f8eaa65c8bc2d8d937
│      210a534cb0390e7afcb70754a2eaa75b
│      41a0d51531f5f79f56a339876f98fb7b
│      ecdfaf71ed7739b8b1bfa4e20b9ebe9a
│
├─course_to_teacher
│      0b04526a08bca7f8eaa65c8bc2d8d937
│      1cd39abc387d6f4a847a6b70fba6f149
│      2efc7ebdc320320145afccf6d9cfac2d
│      337cf34c9a89818f8ea03e466cc3e94e
│
├─school
│      0b04526a08bca7f8eaa65c8bc2d8d937
│      337cf34c9a89818f8ea03e466cc3e94e
│      405aea10bcb2b6085ae3879d0fa57be1
│
├─student
│      08d24c9757db5cc358afea448b4a5621
│      0b04526a08bca7f8eaa65c8bc2d8d937
│      337cf34c9a89818f8ea03e466cc3e94e
│      4e5ce2d4f7bc39765a0d0b1ed63b37ea
│      5b4d24e0776b07b4a722ac8d3d5059b9
│      eff6335db3e812f18e5698a83c050b9d
│
└─teacher
        0b04526a08bca7f8eaa65c8bc2d8d937
        592b6f828668e66d0dee4246aca50d3e

　　- services

/core/services
│  admin.py
│  readme.py
│  student.py
│  teacher.py

'''
path = r'D:\soft\work\Python_17\day07\homework\Course\core\services'
选课系统有三个角色：
    1.学生
    2.老师
    3.管理员

这个services目录就是存放这三个角色的主要业务逻辑
'''

　　- admin.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

from conf.settings import ADMIN_DB,ADMIN_INFO
from core.models import *


def initializate():
    print('Start to create admin account...')
    name = input('Input name>>>\t').strip()
    password = input('Input password>>>\t').strip()
    if not isinstance(name,str):
        print('Admin name must be a str obj.')
        return
    admin_obj_list = Admin.get_all_obj_list()
    admin_obj_name_list = []
    for obj in admin_obj_list:
        if obj.name not in admin_obj_name_list:
            admin_obj_name_list.append(obj.name)
    if name in admin_obj_name_list:
        print('Admin name: %s already exist.' % name)
        return
    admin_obj = Admin(name,password)
    admin_obj.save()
    print('\033[46m初始化管理员成功！\033[0m')

def login():
    name = input('姓名>>>\t').strip()
    password = input('密码>>>\t').strip()
    user_obj_list = Admin.get_all_obj_list()
    for user_obj in user_obj_list:
        if name == user_obj.name:
            if password == user_obj.password:
                print('管理员：%s 登录成功！' % name)
                break
            else:
                print('用户名或密码错误！')
                return
    # do_something...
    admin_func()

def show_notice():
    print(ADMIN_INFO)

def create_school():
    name = input('请输入学校名>>>\t').strip()
    addr = input('请输入学校地址>>>\t').strip()
    school_obj_list = School.get_all_obj_list()
    for school_obj in school_obj_list:
        if name == school_obj.name and addr == school_obj.addr:
            print('\033[41m%s-%s已经存在，不能重复创建！\033[0m' % (name,addr))
            return
    school_obj = School(name,addr)
    school_obj.save()
    print('\033[46m学校创建成功！\033[0m')
def show_school_list():
    school_obj_list = School.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for school in school_obj_list:
        out_str = '学校名字：%s'.ljust(10,' ') % school.name + '地址：%s'.ljust(10,' ') % school.addr + '成立时间：%s' % school.create_time
        print(out_str)
    print('+++++++++++++++++++++++++++')
def create_course():
    school_obj_list = School.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for index, sch in enumerate(school_obj_list, 1):
        print('%s\t%s - %s' % (index, sch.name, sch.addr))
    print('+++++++++++++++++++++++++++')
    school_index = input('请输入课程所属的学校id>>>\t').strip()
    for index, sch in enumerate(school_obj_list, 1):
        if index == int(school_index):
            school_uid = sch.uid
    course_name = input('请输入课程名字>>>\t').strip()
    course_price = input('请输入课程价格>>>\t').strip()
    course_period = input('请输入课程周期>>>\t').strip()
    course_obj_list = Course.get_all_obj_list()
    for course_obj in course_obj_list:
        if course_name == course_obj.name:
            print('\033[41m课程：%s 已经存在，不能重复创建！\033[0m' % course_name)
            return
    course_obj = Course(course_name,course_price,course_period,school_uid)
    course_obj.save()
    print('\033[46m课程创建成功！\033[0m')
def show_course_list():
    course_obj_list = Course.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for course in course_obj_list:
        out_str = '课程名字：%s, 价格：%s, 周期：%s, 归属：%s - %s, 创建时间：%s' % \
                  (course.name,course.price,course.period,course.school_uid.get_obj_by_uid().name,course.school_uid.get_obj_by_uid().addr,course.create_time)
        print(out_str)
    print('+++++++++++++++++++++++++++')
def create_teacher():
    name = input('请输入老师姓名>>>\t').strip()
    password = input('设置老师登录默认密码>>>\t').strip()
    teacher_obj_list = Teacher.get_all_obj_list()
    for teacher_obj in teacher_obj_list:
        if name == teacher_obj.name:
            print('\033[41m老师：%s 已经存在，不能重复创建！\033[0m' % name)
            return
    teacher_obj = Teacher(name,password)
    teacher_obj.save()
    print('\033[46m老师创建成功！\033[0m')

def show_teacher_list():
    teacher_obj_list = Teacher.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for teacher in teacher_obj_list:
        print('教师名字：%s\t创建时间：%s' % (teacher.name,teacher.create_time))
    print('+++++++++++++++++++++++++++')
def course_to_teacher():
    course_obj_list = Course.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for index, course in enumerate(course_obj_list, 1):
        print('%s\t%s' % (index, course.name))
    print('+++++++++++++++++++++++++++')
    course_index = input('请输入要进行关联的课程id>>>\t').strip()
    for index, course in enumerate(course_obj_list, 1):
        if index == int(course_index):
            course_uid = course.uid
    teacher_obj_list = Teacher.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for index, teacher in enumerate(teacher_obj_list, 1):
        print('%s\t%s' % (index, teacher.name))
    print('+++++++++++++++++++++++++++')
    teacher_index = input('请输入要进行关联的老师id>>>\t').strip()
    for index, teacher in enumerate(teacher_obj_list, 1):
        if index == int(teacher_index):
            teacher_uid = teacher.uid
    course_to_teacher = Course_to_teacher(course_uid,teacher_uid)
    course_to_teacher.save()
    print('\033[46m课程：%s 关联老师：%s 成功！\033[0m' % (course_uid.get_obj_by_uid().name,teacher_uid.get_obj_by_uid().name))

def show_course_to_teacher():
    relation_list = Course_to_teacher.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for relation in relation_list:
        print('课程：%s\t教师：%s' % (relation.course_uid.get_obj_by_uid().name,\
                                relation.teacher_uid.get_obj_by_uid().name))
    print('+++++++++++++++++++++++++++')

def create_class():
    school_obj_list = School.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for index, sch in enumerate(school_obj_list, 1):
        print('%s\t%s - %s' % (index, sch.name, sch.addr))
    print('+++++++++++++++++++++++++++')
    school_index = input('请输入班级所属的学校id>>>\t').strip()
    for index, sch in enumerate(school_obj_list, 1):
        if index == int(school_index):
            school_uid = sch.uid
    course_obj_list = Course.get_all_obj_list()
    optional_corese_list = []
    for course_obj in course_obj_list:
        if course_obj.school_uid.uid == school_uid.uid:
            optional_corese_list.append(course_obj)
    print('+++++++++++++++++++++++++++')
    for index, course in enumerate(optional_corese_list, 1):
        out_str = '%s\t课程名字：%s, 价格：%s, 周期：%s, 归属学校：%s - %s' % \
                  (index,course.name, course.price, course.period, course.school_uid.get_obj_by_uid().name,
                   course.school_uid.get_obj_by_uid().addr)
        print(out_str)
    print('+++++++++++++++++++++++++++')
    course_index = input('请输入班级所属的课程序号>>>\t').strip()
    for index, course in enumerate(optional_corese_list, 1):
        if index == int(course_index):
            course_uid = course.uid
    class_name = input('请输入班级名称>>>\t').strip()
    classes_obj_list = Classes.get_all_obj_list()
    for classes_obj in classes_obj_list:
        if class_name == classes_obj.name:
            print('\033[41m班级：%s 已经存在，不能重复创建！\033[0m' % class_name)
            return
    class_obj = Classes(class_name,school_uid,course_uid)
    class_obj.save()
    print('\033[46m班级创建成功！\033[0m')

def show_class_list():
    class_obj_list = Classes.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for classes in class_obj_list:
        out_str = '班级名称：%s, 归属课程：%s, 归属学校：%s - %s, 创建时间：%s' % \
                  (classes.name, classes.cour_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().addr,classes.create_time)
        print(out_str)
    print('+++++++++++++++++++++++++++')
def create_student():
    class_obj_list = Classes.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for index, classes in enumerate(class_obj_list, 1):
        out_str = '%s\t学校：%s - %s, 课程：%s, 班级名称：%s' % \
                  (index,classes.sch_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().addr,\
                   classes.cour_uid.get_obj_by_uid().name,classes.name)
        print(out_str)
    print('+++++++++++++++++++++++++++')
    class_index = input('请输入新学员所关联的班级序号>>>\t').strip()
    for index, classes in enumerate(class_obj_list, 1):
        if index == int(class_index):
            class_uid = classes.uid
    name = input('请输入学生名字>>>\t').strip()
    password = input('请输入学生默认密码>>>\t').strip()
    qq = input('请输入学生的QQ号码>>>\t').strip()
    student_obj_list = Student.get_all_obj_list()
    for student_obj in student_obj_list:
        if qq == student_obj.qq:
            print('\033[41m学生账户：%s QQ：%s 已经存在，不能重复创建！\033[0m' % (student_obj.name,student_obj.qq))
            return
    student_obj = Student(name,password,class_uid,qq)
    student_obj.save()
    print('\033[46m学生创建成功！\033[0m')
def show_student_list():
    student_obj_list = Student.get_all_obj_list()
    print('+++++++++++++++++++++++++++')
    for student in student_obj_list:
        print('学生名字：%s, QQ：%s, 报名班级：%s, 创建时间：%s' % (student.name,student.qq,\
                                                    student.class_uid.get_obj_by_uid().name,student.create_time))
    print('+++++++++++++++++++++++++++')

def admin_func():
    option_selected = {
        '0':show_notice,
        '1':create_school,
        '2':show_school_list,
        '3':create_course,
        '4':show_course_list,
        '5':create_class,
        '6':show_class_list,
        '7':create_teacher,
        '8':show_teacher_list,
        '9':course_to_teacher,
        '10':show_course_to_teacher,
        '11':create_student,
        '12':show_student_list,
        '13':exit
    }
    while True:
        print(ADMIN_INFO)
        option = input('Select your option and begin >>>\t').strip()
        if option not in option_selected:
            continue
        option_selected[option]()

　　- student.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

from conf.settings import STUDENT_DB,STUDENT_INFO
from core.models import Student,Course_to_teacher

def login():
    qq = input('QQ>>>\t').strip()
    password = input('密码>>>\t').strip()
    user_obj_list = Student.get_all_obj_list()
    for user_obj in user_obj_list:
        if qq == user_obj.qq:
            if password == user_obj.password:
                print('学生：%s, QQ：%s  登录成功！' % (user_obj.name,user_obj.qq))
                student_func(user_obj)
                break
            else:
                print('用户名或密码错误！')
                return
def show_class(student_obj):
    class_name = student_obj.class_uid.get_obj_by_uid().name
    school_name = student_obj.class_uid.get_obj_by_uid().sch_uid.get_obj_by_uid().name
    school_addr = student_obj.class_uid.get_obj_by_uid().sch_uid.get_obj_by_uid().addr
    course_price = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().price
    course_name = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().name
    course_period = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().period
    class_start_time = student_obj.class_uid.get_obj_by_uid().create_time
    out_str = '已报名班级：%s\n归属学校：%s-%s\n课程：%s（价格：%s, 周期：%s）\n开课时间：%s' % \
              (class_name,school_name,school_addr,course_name,course_price,course_period,class_start_time)
    print(out_str)
def show_teacher(student_obj):
    class_name = student_obj.class_uid.get_obj_by_uid().name
    course_name = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().name
    course_obj = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid()
    relation_list = Course_to_teacher.get_all_obj_list()
    for relation in relation_list:
        if course_obj.uid.uid == relation.course_uid.uid:
            teacher_name = relation.teacher_uid.get_obj_by_uid().name
            break
    print('班级名称：%s\n课程名称：%s\n任课教师：%s' % (class_name,course_name,teacher_name))


def change_password(student_obj):
    old_pass = input('请输入当前密码>>>\t').strip()
    if old_pass == student_obj.password:
        new_pass = input('请输入新密码>>>\t').strip()
        option = input('确定要更改密码？(y/Y)').strip()
        if 'Y' == option.upper():
            student_obj.password = new_pass
            student_obj.save()
            print('\033[46m更改密码成功！\033[0m')
    else:
        print('密码错误！')

def bye(student_obj):
    print('See you %s' % student_obj.name)
    exit(0)

def student_func(student_obj):
    option_selected = {
        '0':change_password,
        '1':show_class,
        '2':show_teacher,
        '3':bye,
    }
    while True:
        print(STUDENT_INFO)
        option = input('Select your option and begin >>>\t').strip()
        if option not in option_selected:
            continue
        option_selected[option](student_obj)

　　- teacher.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

from conf.settings import TEACHER_DB,TEACHER_INFO
from core.models import Teacher,Course_to_teacher,Classes,Student

def login():
    name = input('姓名>>>\t').strip()
    password = input('密码>>>\t').strip()
    user_obj_list = Teacher.get_all_obj_list()
    for user_obj in user_obj_list:
        if name == user_obj.name:
            if password == user_obj.password:
                print('教师：%s 登录成功！' % user_obj.name)
                teacher_func(user_obj)
                break
            else:
                print('用户名或密码错误！')
                return

def change_password(teacher_obj):
    old_pass = input('请输入当前密码>>>\t').strip()
    if old_pass == teacher_obj.password:
        new_pass = input('请输入新密码>>>\t').strip()
        option = input('确定要更改密码？(y/Y)').strip()
        if 'Y' == option.upper():
            teacher_obj.password = new_pass
            teacher_obj.save()
            print('\033[46m更改密码成功！\033[0m')
    else:
        print('密码错误！')

def show_course_list(teacher_obj):
    course_obj_list = []
    relation_list = Course_to_teacher.get_all_obj_list()
    for relation in relation_list:
        if teacher_obj.uid.uid == relation.teacher_uid.uid:
            course_obj_list.append(relation.course_uid.get_obj_by_uid())
    for course_obj in course_obj_list:
        print('课程名称：%s\t课程周期：%s\t价格：%s\t归属学校：%s-%s' % \
              (course_obj.name,course_obj.period,course_obj.price,\
               course_obj.school_uid.get_obj_by_uid().name,course_obj.school_uid.get_obj_by_uid().addr))

def show_students_by_class(teacher_obj):
    course_obj_list = []
    relation_list = Course_to_teacher.get_all_obj_list()
    for relation in relation_list:
        if teacher_obj.uid.uid == relation.teacher_uid.uid:
            course_obj_list.append(relation.course_uid.get_obj_by_uid())
    class_list = Classes.get_all_obj_list()
    class_obj_list = []
    for course in course_obj_list:
        for classes in class_list:
            if course.uid.uid == classes.cour_uid.uid:
                class_obj_list.append(classes)
    print('%s 教授的班级如下：' % teacher_obj.name)
    print('+++++++++++++++++++++++++++')
    for index, classes in enumerate(class_obj_list, 1):
        print('%s\t%s' % (index, classes.name))
    print('+++++++++++++++++++++++++++')
    classes_index = input('请输入要进行查找的班级序号>>>\t').strip()
    for index, classes in enumerate(class_obj_list, 1):
        if index == int(classes_index):
            classes_uid = classes.uid
    student_obj_list = Student.get_all_obj_list()
    for student_obj in student_obj_list:
        if student_obj.class_uid.uid == classes_uid.uid:
            print('学生名字：%s, QQ：%s, 报名班级：%s, 创建时间：%s' %\
                  (student_obj.name,student_obj.qq,student_obj.class_uid.get_obj_by_uid().name, student_obj.create_time))

def bye(teacher_obj):
    print('See you %s' % teacher_obj.name)
    exit(0)

def teacher_func(teacher_obj):
    option_selected = {
        '0':change_password,
        '1':show_course_list,
        '2':show_students_by_class,
        '3':bye,
    }
    while True:
        print(TEACHER_INFO)
        option = input('Select your option and begin >>>\t').strip()
        if option not in option_selected:
            continue
        option_selected[option](teacher_obj)