day0729

82年松花蛋

于 2019-07-29 17:29:50 发布

阅读量133

点赞数 1

本文链接：https://blog.csdn.net/DAVID11234/article/details/97658293

版权

对象

面向过程
函数式编程
面向对象

面向过程

所谓过程就是我们解决问题的步骤，一步一步按部就班。，整个设计就像流水线。

优缺点：

优点
- 复杂的问题流程化
缺点
- 扩展性不好，

面向对象

核心是对象。

数据及行为集合
功能上指向建模对象

Python中，一切皆对象

面向对象的优缺点

优点
- 解决程序扩展性
缺点
- 复杂度高于面向过程

蔡徐坤

特征：

爱好：唱，跳，rap

特征：基，腻，态，美 ```

类就是类别，种类

对象就是特征和技能的统一体

类就是它们的结合

人类世界，先有个体，再有类，程序中，先有类，再创建对象

面向对象编程

OOP(object oriented programming)

其实是一种程序思想，OOP把对象作为程序的一个基本单元，一个对象就包含了数据和操作数据的函数。

在python中，所有数据类型都可以视为对象，同时我们也可以自定义对象。

自定义的对象的数据类型就是面向对象中类的概念

Demo:

假如要处理我们的成绩，为了表示学生的成绩：

面向过程的方式

stu1={‘name’:‘TOM’,‘age’:12}

stu2={‘name’:‘TOMcat’,‘age’:22}

def student(stu):

print(student(stu1))
面向对象的方法

class Student:

def init(self,name,score):

self.name=name

self.score=score

def find_score(self)

print(self.name,":",self.socre)

stu1=Student(‘TOM’,99)

stu1.find_score()

常见的概念
面向对象设计的思想，先抽象出类，再根据类创建实例
`class ClassName(object):
    class_staement

创建一个类

class MyClass:
    pass
a=MyClass()
b=MyClass()
#地址不同，因为类是一个模板，引出的对象实例时不同的

类的命名

一般都是大驼峰式（各名词字母大写）

类的作用

属性引用
- 类名.属性直接引用
实例化
- 类名加上一个实例化，自动触发init函数的运行，进而为每个实例定制自己的特征。

相当于一个模板，再创建实例的时候可以把一些类中固定的属性绑定在对象身上，这是就通过’init_'方法，在创建实例的时候，绑定相关的属性，比如前面的name,score.

和普通函数相比，在类中定义方法时，第一个参数必须是self（代表了对自己的一个实例化，就是假装自己是个东西），除了第一个参数外，其他的和普通函数没什么区别。

self代表的是实例，而非类
```
'__ini__'方法
```
- 1.为对象初始化自己独有的特征
- 2.该方法中可以有任意的代码，但是一定不可以有返回值

数据封装

通过init()让stu1实力本身拥有了相关数据，访问这些数据，我们可以直接在student类的内部定义相关的函数来访问数据，以此来封装数据。

这些封装的函数和Student类本身是关联起来的，他们被称之为方法。

类属性的补充

1.dir(类名)

返回一个列表，查看其属性

2.类名._dict _
- 返回一个字典，key为属性名，value是属性名

特殊的类属性

类名 ._name_#返回对应的类的名字
类名._doc_#返回类的说明文档（str）
类名._base_#类的第一个父类
类名._bases_#类的所有父类构成的元组
类名._module_#类定义所在的模块
类名._class_#实例所对应的类

类命名空间与对象，实例的空间

创建一个类就会创建一个类的名称空间，用来存储我们定义的所有变量名，这些名字就是属性。

类的属性有两种：

静态属性
- 直接在类中定义的变量
动态属性
- 在类中定义的方法

静态属性是共享给所有对象的，它们创建的内存空间地址指向的是同一个地方。

class Player:
    def __init__(self,life,attack,name):
        self.life=int(life)
        self.attack=int(attack)
        self.name=name
    def attacking(self,someone):
        someone.life-=self.attack
class wildmaster:
    def __init__(self,life,attack,name):
        self.life=int(life)
        self.attack=int(attack)
        self.name=name
    def attacking(self,someone):
        someone.life-=self.attack
robot=Player(1000,200,'robot1')
redbuff=wildmaster(1000,200,'redbuff')
robot.attacking(redbuff)
print(redbuff.life)

类的三大特性

继承
多态
封装

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（SubClass）,而被继承的类则被称为基类，父类，超类（Base Class,Father Class,Super Class）

关于继承的问题，如果我定义了一个子类1类它继承了一个父类1，然后我再定义一个子类2去同时继承第一个子类1和父类1，就会报错，因为子类2既然继承了子类1，就已经继承了父类1。可以去再继承另一个父类2，或者再定义一个子类3去继承子类2.
如果不指定基类，所有的类默认继承于Object类，它是所有python基类的爸爸，它提供最基本的一些方法。

多态

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，在运行代码时，总会调用子类和父类永明的方法。

这样，就是继承的另一个好处，多态。

理解多态，首先就要理解数据类型，定义了一个类，相当于定义了一种数据类型，就像list,dict,set,一样。

dog=Dog()
cat=Cat()
print(dog.run())
li=list()
print(isinstance(li,list))
print(isinstance(dog,Animal))
print(isinstance(dog,Dog))

True
True
True

对于一个变量，我们只要知道它的父类，而不需要知道它的子类，调用时只管调用不需要管细节，当我新增一个子类只要编写正确，并不用理会原来的方法是如何编写调用的。

开闭原则

对扩展开放：允许新增子类
对修改封闭：不需要修改依赖父类类型的函数

继承可以一级一级的继承下来，任何类都可以追溯到object类。

私有属性

在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样隐藏内部的复杂逻辑。

如果我们不想内部的属性被外部访问或更改，我们可以在属性名称前加两个下划线。

在python中，实例的变量名如果以双下划线开头，就变成了一个私有变量，只有内部可以访问。

class Vector2D(object):
def init(self, x, y):
self.__x = float(x)
self.__y = float(y)
self.xx = x
self.yy = y
def get_x(self):
return self.__x # 内部访问
if name == “main”:
v = Vector2D(3, 4)
print v.dict
print v._Vector2D__x, v.get_x()# 但是可以通过v._Vector2D__x 在外部访问
v.__x # 外部访问12345678910111213

输出:

{‘yy’: 4, ‘xx’: 3, ‘_Vector2D__x’: 3.0, ‘_Vector2D__y’: 4.0}
3.0 3.0
Traceback (most recent call last):
…
v.__x
AttributeError: ‘Vector2D’ object has no attribute '__x’123456

从上面的例子可以看出:

__field被编译器重命名为_className__field
在class外部不能访问obj.__field, 但在class内部可以
但是, 这只能防止无意间的调用, 不能防止恶意调用, 用Fluent Python的话来讲, 这是一种safety device, not security device, 用国语来讲, 就是防君子不防xx, 因为可以通过obj._className__field在外部访问obj的私有__field.