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
搞代码网（gaodaima.com）提供的所有资源部分来自互联网，如果有侵犯您的版权或其他权益，请说明详细缘由并提供版权或权益证明然后发送到邮箱[email protected]，我们会在看到邮件的第一时间内为您处理，或直接联系QQ：872152909。本网站采用BY-NC-SA协议进行授权
转载请注明原文链接：关于python:Python-OOP1
转载请注明原文链接：关于python:Python-OOP1
