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))

dana18********************2245155422024140717429003616********************dana182245155422024140717429003616

# 此时，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 = 16print(a.__dict__)print(a.name)print(a.age)print(id(a.name))print(id(a.age))

dana18********************2245155422024140717429003616********************{'__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}yaona162245155597256140717429003552

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 aaaMy age is 200My name is aaaMy 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 yaonaMy age is 19dana19Hello, 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)# 以上代码，利用鸭子模型

aaaa200aaaa200ruochen18bbb99

# 公有变量案例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 = 19print(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

0. OOP-Python面向对象

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

2. 类的根本实现

dict前后各有两个下划线

dict前后各有两个下划线

3. anaconda根本应用

4. 类和对象的成员剖析

5.对于self

6. 面向对象的三大个性

6.1 封装