day2-1面向对象

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

面向过程

所谓过程就是我们解决问题的步骤，一步步的按照流程走，有先后之分。

整个设计就好比流水线，思维上比较机械化。

优缺点:

• 优点
  • 复杂化的问题流程化，将问题分解简化。
• 缺点
  • 拓展性不好

面向对象

核心是对象

正式的来说

• 对象是一个数据以及相关行为的集合
• 面向对象是功能上指向建模对象

通过数据和行为方式来描述交互对象的集合

过程面向对象的优缺点

面向对象的优缺点

• 优点
  • 解决程序的拓展性
• 缺点
  • 复杂度远高于面向过程
  • 交互式解决问题，无法准确预测结果

object1:
Tom
特征：
school=zucc
name=Tom
age=22
sex：male
技能：
eat
sleep

object2:
Jack
特征：
school=zucc
name=Tom
age=21
sex：male
技能：
eat
sleep

类就是类别、种类

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

类则是这一系列的特征和技能的结合

对于现实世界，先有个体（即对象），才有类别；但对于程序，必须先有类，然后才有对象

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• **数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。
• **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• **实例化：**创建一个类的实例，类的具体对象。
• **方法：**类中定义的函数。
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

面向对象的编程

OOP（object oriented programing）

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

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

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

Demo：

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

• 面向过程的方式

stu1={‘name’:‘Tom’,‘age’:13}

stu1={‘name’:‘Tom’,'age’33}

• 利用函数来

创建一个类

class MyFirstClass:
    pass

类的作用是一个模板。我们可以在创建实例的时候吧一些我们认为必须要要绑定的值写进去

数据封装

class Student:

    def __init__(self,name,score):
        self.name=name
        self.score=score

    def find_score(self):
        print(self.name,':',self.score)
stu1=Student('Tom',99)
stu1.find_score()

类名.__name__#类的名字
类名.__doc__#类的文档字符串
类名.__bases__#类的所有父类构成的元组
类名.__dict__#类的属性
类名.__module__#类定义所在的模块
类名.__class__#实例对应的类

总结：

class ClassName:
    def __init__(self,para1,para2,...):
        self.对象属性1=para1
        self.对象属性2=para2
    def 方法名1(self):
        pass
    def 方法名2(self):
        pass
obj=ClassName(para1,para2)
#对象的实例化，代表具体的东西
#ClassName();调用__init__
#括号内传参，无需传入self，参数一一对应
#结果是返回对象obj

obj.对象属性1#查看对象的属性
obj.方法名1#调用类的方法

对象之间的交互

class Person:
    def __init__(self,name,agg,life_value):
        self.name=name
        self.agg=agg
        self.life_value=life_value
    def attack(self,dog):
        dog.life_value-=self.agg
class Dog:
    def __init__(self,name,breed,agg,life_value):
        self.name=name
        self.breed=breed
        self.agg=agg
        self.life_value=life_value
    def bite(self,people):
        people.life_value-=self.agg
per=Person('jack',10,1000)
dog=Dog('Jeorry',"Husky",8,1000)
print(dog.life_value)
per.attack(dog)
print(dog.life_value)

类名空间与对象、实例的空间

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

类的属性有两种：

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

类的三大特点

• 继承
• 多态
• 封装

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

比如，

class Animal(object): #定义父类
    def run(self):
        print('Aniaml is running.')
class Dog(Animal): #单继承
    pass
class Cat(Animal): #单继承
    pass
class Husky(Animal,Dog):#多继承，用逗号分隔开
    pass
dog=Dog()
cat=Cat()
print(dog.run())
print(cat.run())

继承的查看

ClassName.__bases__

多态

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

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

class Animal(object): #定义父类
    def run(self):
        print('Aniaml is running.')
class Dog(Animal): #单继承
    def run(self):
        print('Dog is running.')
class Cat(Animal): #单继承
    def run(self):
        print('Cat is running.')
class Husky(Animal,Dog):#多继承，用逗号分隔开
    pass
dog=Dog()
cat=Cat()
dog.run()
cat.run()

理解多态，首先要对数据类型在进行说明。定义一个类的时候实际上就是定义了一种数据类型。我们自定义的数据类型和Python自带的数据类型，比如str，list，dict，没什么区别

用isinstance() 来判断某个变量是否是某个类型

对于一个变量，我们只要知道他的父类型，无需确切知道子类型，就可以放心调用相关的方法。运行时具体的方法是作用在子类型上还是父类型上，由我们运行的对象决定。

也就是说，调用时只管调用，不管细节。

当我们新增一个子类时，只要保证相关的方法编写正确，就不用管原来的代码是如何调用的。

—>‘开闭’原则

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

总结：

继承可以一级一级的继承下来，类比人类，就好比，爷爷奶奶到父母，父母到子女，都可以追溯到object。

私有属性

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

比如Student类：

class Student:

    def __init__(self,name,score):
        self.name=name
        self.score=score

    def find_score(self):
        print(self.name,':',self.score)
stu1=Student('Tom',99)
stu2=Student('Jack',59)
print(stu1.score)
stu1.score=88
print(stu1.score)
#99
#88

从这可以看出，外部代码可以自由修改一个实例的属性（name，score）

如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线。

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

封装

隐藏对象的属性和实现细节，仅仅对外提供公共访问的方式。

这样做的优点在于：

1.可以将变化隔离；

2.便于使用；

3.提高安全性

4.提供复用性

封装的原则是：

• 将不需要对外提供的内容隐藏起来；
• 隐藏属性，提供公共方法对其进行访问。

—>私有方法，私有变量—>私有属性

用双下划线开头的方式将属性隐藏，设置为私有的

class A:
    def login(self):
        pass
    def register(self):
        pass
class B:
    def login(self):
        pass
    def register(self):
        pass
# A,B两个类,没有任何关系,独立两个,但是里面的功能相似,所以python一般会将类似于A,B两个类
# 里面的相似的功能让其命名相同.

鸭子类型不要求有严格的继承关系，一个对象，只要“看起来像鸭子，走起来还是像鸭子”

也就是说，如果要编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的，但与起无任何关系的全新对象。

比方说，利用标准库中定义的各种“与文件类似的”的对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法。