0. OOP-Python 面向对象

• Python 面向对象

• 面向对象编程

  • 根底
  • 私有公有
  • 继承
  • 组合，Mixin

• 魔法函数

  - 魔法函数概述
  - 结构类魔法函数
  - 运算类魔法函数
  

  1. 面向对象概述（ObjectOriented, OO）

  • OOP 思维

    • 接触到任意一个工作，首先想到的是工作这个世界的形成，是由模型形成的

  • 几个名词

    • OO：面向对象
    • OOA：面向对象的剖析
    • OOD：面向对象的设计
    • OOI：面向对象的实现
    • OOP：面向对象的编程
    • OOA->OOD->OOI：面向对象的实现过程

• 类和对象的概念

  • 类：抽象名词，代表一个汇合，共性的事物
  • 对象：具象的货色，单个个体

  • 类跟对象的关系

    - 一个具象，代表一类事物的某一个个体
    - 一个是形象，代表的是一大类事物

• 类中的内容，应该具备两个内容

  • 表明事物的特色。叫做属性（变量）
  • 表明事物性能或动作，称为成员办法（函数）

2. 类的根本实现

• 类的名字

  • 恪守变量命名的标准
  • 大驼峰（有一个或者多个单词形成，每个单词首字母大写，单词跟单词间接相连）
  • 尽量避开跟零碎命名类似的命名

• 如何申明一个类

  • 必须用 class 关键字
  • 类由属性和办法形成，其余不容许应用
  • 成员属性定义能够间接应用变量赋值，如果没有值，容许应用 None
  • 案例 01.py

• 实例化类

  变量 = 类名()   # 实例化了一个对象

• 拜访对象成员

  • 应用点操作符

    obj. 成员属性名称
    obj. 成员办法

• 能够通过默认内置变量查看类和对象的所有成员

  • 对象所有成员查看

    dict 前后各有两个下划线

    obj.__dict__

  • 类所有的成员

    dict 前后各有两个下划线

    class_name.__dect__

3. anaconda 根本应用

• anaconda 次要是一个虚拟环境管理器
• 还是一个安装包管理器
• conda list：显示 anaconda 装置的包
• conda env list：显示 anaconda 的虚拟环境列表
• conda create -n xxx python=3.6：创立 python 版本为 3.6 的虚拟环境，名称为 xxx

4. 类和对象的成员剖析

• 类和对象都能够存储成员，成员能够归类所有，也能够归对象所有
• 类存储成员时应用的是与类关联的一个对象
• 对象存储成员是存储在以后对象中
• 对象拜访一个成员时，如果对象中没有该成员，尝试拜访类中的同名成员
  如果对象中有此成员，肯定应用对象中的成员
• 创建对象的时候，类中的成员不会放入对象当中，而是失去一个空对象，没有成员
• 通过对象对类中成员从新赋值或者通过对象增加成员时，对应成员会保留在对象中，
  而不会批改类成员

5. 对于 self

• self 在对象的办法中示意以后对象自身，如果通过对象调用一个办法，

那么该对象会主动传入到以后办法的第一个参数中

• self 并不是关键字，只是一个用于接管对象的一般参数，实践上能够用任何一个

一般变量名代替

• 办法中有 self 形参的办法成为非绑定类的办法，能够通过对象拜访，没有 self 的

是绑定类的办法，只能通过类拜访

• 应用类拜访绑定类的办法时，如果类办法中须要拜访以后类的成员，能够通过

__class__成员名来拜访

6. 面向对象的三大个性

• 封装
• 继承
• 多态

6.1 封装

• 封装就是对对象的成员进行拜访限度

• 封装的三个级别

  • 公开：public
  • 受爱护的：protected
  • 公有的：private
  • public，private，protected 不是关键字

• 判断对象的地位

  • 对象外部
  • 对象内部
  • 子类中
• python 中下划线的应用

• 公有

  • 公有成员是最高级别的封装，只能在以后类或对象中拜访

  • 在成员后面增加两个下划线即可

    class Person():

    # name 是共有的成员
    name = "ruochen"
    # __age 就是公有成员
    __age = 18

  • Python 的公有不是真公有，是一种成为 name mangling 的改名策略

  能够应用对象._classname_attributename 拜访

• 受爱护的封装 protected

  • 受爱护的封装是将对象成员进行肯定级别的封装，而后，在类中或者子类

  中都能够拜访，然而在内部不能够

  • 封装办法：在成员名称前增加一个下划线即可

• 公开的，公共的 public

  • 公共的封装理论对成员没有任何操作，任何中央都能够拜访

class Student():
    name = "aaa"
    age = 18
    
Student.__dict__

# 实例化
a = Student()
a.__dict__ 
print(a.name)

aaa

class A():
    name = "dana"
    age = 18
    
    # 留神 say 的写法，参数有一个 self
    def say(self):
        self.name = "aaa"
        self.age = 200

# 此案例阐明
# 类实例的属性和其对象的实例的属性在不对对象的实例属性赋值的前提下，# 指向同一变量

# 此时，A 称为类实例
print(A.name)
print(A.age)

print("*" * 20)

# id 能够甄别出一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))

print("*" * 20)
a = A()

print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

dana
18
********************
2245155422024
140717429003616
********************
dana
18
2245155422024
140717429003616

# 此时，A 称为类实例
print(A.name)
print(A.age)

print("*" * 20)

# id 能够甄别出一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))

print("*" * 20)
a = A()
# 查看 A 内所有属性
print(A.__dict__)
print(a.__dict__)

a.name = "yaona"
a.age = 16
print(a.__dict__)

print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

dana
18
********************
2245155422024
140717429003616
********************
{'__module__': '__main__', 'name': 'dana', 'age': 18, 'say': <function A.say at 0x0000020ABDBC7E18>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
{}
{'name': 'yaona', 'age': 16}
yaona
16
2245155597256
140717429003552

class Student():
    name = "dana"
    age = 18
    
    # 留神 say 的写法，参数有一个 self
    def say(self):
        self.name = "aaa"
        self.age = 200
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))
        
    def sayAgain(s):
        print("My name is {0}".format(s.name))
        print("My age is {0}".format(s.age))
        
yueyue = Student()
yueyue.say()
yueyue.sayAgain()

My name is aaa
My age is 200
My name is aaa
My age is 200

class Teacher():
    name = "dana"
    age = 19
    
    def say(self):
        self.name = "yaona"
        self.age = 17
        print("My name is {0}".format(self.name))
        # 调用类的成员变量须要用__class__
        print("My age is {0}".format(__class__.age))
        
    def sayAgain():
        print(__class__.name)
        print(__class__.age)
        print("Hello, nice to see you again")
        
t = Teacher()
t.say()
# 调用绑定类函数应用类名
Teacher.sayAgain()

My name is yaona
My age is 19
dana
19
Hello, nice to see you again

# 对于 self 的案例

class A():
    name = "ruochen"
    age = 18
    
    def __init__(self):
        self.name = "aaaa"
        self.age = 200
        
    def say(self):
        print(self.name)
        print(self.age)
        
class B():
    name = "bbb"
    age = 99
    
a = A()
# 此时，零碎会默认把 a 作为第一个参数传入函数
a.say()

# 此时，self 被 a 替换
A.say(a)
# 同样能够把 A 作为参数传入
A.say(A)

# 此时，传入的是类实例 B，因为 B 具备 name 和 age 属性，所有不会报错
A.say(B)

# 以上代码，利用鸭子模型

aaaa
200
aaaa
200
ruochen
18
bbb
99

# 公有变量案例
class Person():
    # name 是共有的成员
    name = "ruochen"
    # __age 就是公有成员
    __age = 18
                
p = Person()
# name 是私有变量
print(p.name)
# __age 是公有变量
# 留神报错信息 
print(p.__age)

ruochen



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-41-e118b6505697> in <module>
     11 # __age 是公有变量
     12 # 留神报错信息
---> 13 print(p.__age)


AttributeError: 'Person' object has no attribute '__age'

# name.mangling 技术
print(Person.__dict__)

p._Person__age = 19
print(p._Person__age)

{'__module__': '__main__', 'name': 'ruochen', '_Person__age': 18, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
19