Python 面向对象

面向对象

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

面向对象技术简介

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

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

面向过程

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

设计好比流水线，思维上比较机械化

优缺点：

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

面向对象

核心是对象

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

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

在python中，一切皆为对象

面向对象的优缺点

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

现实中

object1:   #对象1
  Tom
  
     特征：
    school=zucc
    name=Tom
    age=20
    sex=male
    
    技能：
    eat
    study
    sleep
    
object2:
  Jack
    特征：
    school=zucc
    name=Jack
    age=21
    sex=male
    
    技能：
    eat
    study
    sleep
    sing
     

类就是类别、种类

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

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

现实中，现有个体（即对象），才有类别，但对于程序，现有类，才有对象

面向对象编程

OOP(object oriented programming)

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

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

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

Demo:

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

• 面向过程的方式

stu1 = {'name':'Tom','score':'99'}
stu2 = {'name':'Jack','score':'90'}

利用函数来实现

def find_score(stu):
  print(stu['name'],':',stu['score'])

  

利用类来实现

class Student:
    def __init__(self,school,name,age,sex):
        self.school = school
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(self.name,'is eating.')

    def study(self):
        print(self.name,'is studying')

    def sleep(self):
        print(self.name,'is sleeping')

stu1 = Student('ZUCC','tom',22,'男')
stu1.eat()



Tom : 99
tom is eating.

面向对象设计思想，先抽象出类，再根据类创建实例

class Classname(object):
  """docstring"""
  class_statement

创建一个类,大驼峰式（就是变量名称的单词首字母大写）

class Myfirstclass:
  pass

类的作用是一个模版，我们可以在创建实例的时候，把一些 必须要绑定的属性填写进去，这时就通过特殊的__init__方法，在创建实例的时候，绑定相关的属性，比如前面的name,score.

class Student:
    school = 'ZUCC'

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


stu1 = Student('Tom', 99) #实例化
print((stu1.name, stu1.score, stu1.school))


('Tom', 99, 'ZUCC')

和普通函数相比，在类中定义方法时，第一个参数必须是self，除第一个参数外，其他和普通参数没有什么区别

Self 代表的是实例，而非类

__init__方法

• 为对象初始化自己独有的特征
• 该方法中可以有任意的代码，但一定不可以是返回值

数据封装

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


Tom : 99

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

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

class point:
    pass


p1 = point()
p2 = point()

p1.x = 5
p1.y = 4
p2.x = 3
p2.y = 6
print(p1.x, p1.y)
print(p2.x, p2.y)


# 通过点记法给一个实例化的对应赋予任何属性
# 没有任何行为

class point:
    def reset(self):
        self.x = 0
        self.y = 0


p = point()
p.reset()
print(p.x, p.y)

# 传参

class point:
    def reset(self, x, y):
        self.x = x
        self.y = y


p = point()
p.reset(4,5)
print(p.x, p.y)



5 4
3 6
0 0
4 5

import math


class Point:
    def __init__(self, x, y):
        # self.x = x
        # self.y = y
        self.move(x,y) #初始化

    def move(self, x, y):
        self.x = x
        self.y = y

    def reset(self):
        self.move(0, 0)

    def cal_distance(self, other_point):
        return math.sqrt(
            (self.x - other_point.x) ** 2 +
            (self.y - other_point.y) ** 2)


# p1 = Point()
# p2 = Point()
# p3 = Point()
#
# p1.reset()
# p2.move(3, 4)
# p3.move(6, 8)
#
# print(p2.cal_distance(p1))
# print(p2.cal_distance(p3))
p = Point(3, 4)
print(p.x, p.y)


#5.0
#5.0
3 4

类的两个作用：

• 属性引用
  • 类名。属性
• 实例化
  • 类名加上一个括号就是实例化，他能自动触发__init__函数的运行，进而为每一个实例定制自己的特征

类属性的补充

类属性的查看

• 1.dir(类名)

  • 返回一个列表

• 2.类名.dict

  • 返回一个字典，key为属性名，value是属性值

特殊的类属性

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

总结：

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 #调用类的方法

对象之间的交互

现在定义两个类，Person,Dog

class Person:

    def __init__(self, name, aggressivity, life_value):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self, dog):
        dog.life_value -= self.aggressivity


class Dog:
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name
        self.breed = breed
        self.aggressivity = aggressivity
        self.life_value = life_value

    def bite(self, people):
        people.life_value -= self.aggressivity


per = Person('Jack', 10, 1000)
dog = Dog('Jeorry', 'Husky', 8, 1000)

print(dog.life_value)
per.attack(dog)
print(dog.life_value)


1000
990

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

创建一个类就会创建一个类的名称空间，用来储存我们定义的所有的变量名

类的属性有两种：

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

静态属性是共享给所有对象的

动态属性是绑定到所有对象的

class Student:
    school = 'ZUCC'
    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', 88)
print(id(stu1.school))
print(id(stu2.school))

print(stu1.find_score)
print(stu2.find_score)
print(Student.find_score)


4377367752
4377367752
<bound method Student.find_score of <__main__.Student object at 0x104ee7470>>
<bound method Student.find_score of <__main__.Student object at 0x104ee74a8>>
<function Student.find_score at 0x104edd7b8>

函数的三大特性

• 继承
• 多态
• 封装

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

比如，我们定义一个动物类（Animal),其中一个run()方法如下

class Animal(object):  # 第一父类
    def run(self):
        print('Animal 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())
# husky = Husky()
# husky.run()


Animal is running.
None
Animal is running.
None

继承的查看

ClassName.__bases__

如果不指定基类，Python类会默认继承object类

object是所有Python类的基类，提供一些常见的方法实现

class Animal(object):  # 第一父类
    def run(self):
        print('Animal is running.')

class Animal2:
    pass
class Dog(Animal):  # 单继承
    pass


class Cat(Animal):  # 单继承
    pass


class Husky(Animal, Animal2):  # 多继承，用逗号分隔开
    pass


dog = Dog()
cat = Cat()
# print(dog.run())
# print(cat.run())
# husky = Husky()
# husky.run()

print(Dog.__bases__)
print(Husky.__bases__)
print(Animal.__bases__)
print(Animal2.__class__)




(<class '__main__.Animal'>,)
(<class '__main__.Animal'>, <class '__main__.Animal2'>)
(<class 'object'>,)
<class 'type'>

多态

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

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

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

class Animal(object):  # 第一父类
    def run(self):
        print('Animal is running.')

class Animal2:
    pass
class Dog(Animal):  # 单继承
    def run(self):
        print('Dog is running.')


class Cat(Animal):  # 单继承
    def run(self):
        print('Cat is running.')


class Husky(Animal, Animal2):  # 多继承，用逗号分隔开
    pass


dog = Dog()
cat = Cat()
dog.run()
cat.run()


Dog is running.
Cat is running.

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

class Animal(object):  # 第一父类
    def run(self):
        print('Animal is running.')


class Animal2:
    pass


class Dog(Animal):  # 单继承
    def run(self):
        print('Dog is running.')


class Cat(Animal):  # 单继承
    def run(self):
        print('Cat is running.')


class Husky(Animal, Animal2):  # 多继承，用逗号分隔开
    pass


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


True
True
True

class Animal(object):  # 第一父类
    def run(self):
        print('Animal is running.')


class Animal2:
    pass


class Dog(Animal):  # 单继承
    def run(self):
        print('Dog is running.')


class Cat(Animal):  # 单继承
    def run(self):
        print('Cat is running.')


class Husky(Animal, Animal2):  # 多继承，用逗号分隔开
    pass


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

def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())
run_twice(Dog())




Animal is running.
Animal is running.
Dog is running.
Dog is running.

鸭子类型

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

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

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

class TestFile:
  def read(self):
    pass
  
  def write(self):
    pass
  
class OperFile:
  def read(self):
      pass

    def write(self):
      pass

class Animal(object):  # 第一父类
    def run(self):
        print('Animal is running.')


class Animal2:
    pass


class Dog(Animal):  # 单继承
    def run(self):
        print('Dog is running.')


class Cat(Animal):  # 单继承
    def run(self):
        print('Cat is running.')


class Husky(Animal, Animal2):  # 多继承，用逗号分隔开
    pass

class Test:
    def run(self):
        print('多态测试。')

dog = Dog()
cat = Cat()
test = Test()
dog.run()
cat.run()
test.run()


def run_twice(animal):
    animal.run()
    animal.run()


run_twice(test)



Dog is running.
Cat is running.
多态测试。
多态测试。
多态测试。

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

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

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

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

总结：

继承可以一级一级的继承下来，类比人类，就好比，爷爷奶奶到父母再到子女

任何类都可以追溯到根类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', 88)
print(stu1.score)
stu1.score =97
print(stu2.score)

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

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

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

修改Student类：

class Student:
    school = 'ZUCC'

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

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')
        return

    def find_score(self):
        print(self.__name, ':', self.__score)


stu1 = Student('Tom', 99)
stu2 = Student('Jack', 88)

print(stu1.find_score())
stu1.score = 97
print(stu1.score)
print(stu1.find_score())
print(stu1.set_score(97))
print(stu1.find_score())

print(stu1._Student__score)



Tom : 99
None
97
Tom : 99
None
None
Tom : 97
None
97

封装

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

这样做的点在于：

1.可以将变化隔离

2.便于使用

3.提高安全性

4.提高复用性

封装的原则是：

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