python面向对象

编程的三种方法:

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

面向过程

所谓过程就是我们解决问题的步骤,一步步的按照流程走,有先后之分
整个设计好比流水线,思维上比较机械化

优缺点

优点:

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

面向对象

核心是对象。
正式的来说

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

通过数据和行为方式来描述交互对象的集合。
在python中,一切皆为对象。

面向对象的优缺点

优点:

• 解决程序的拓展性
  缺点:
• 复杂度远高于面向过程
• 交互式解决问题,无法准确预测结果
  在现实世界中,以我们为例

object1:
    
Tom
    特征:
    school=zucc
    name=tom
    age=20
    sex=male
    
    技能:
    eat
    study
    sleep
    
object2:
    特征:
    school=zucc
    name=Jack
    age=20
    sex=male
    
    技能:
    eat
    study
    sleep
    sing
        

类就是类别、种类
对象就是特征和技能的统一体
类则是这一系列相似对象的特征的技能的结合
对于现实世界,先有个体(即对象),才有类别;但对于程序,必须先有类,然后才有对象的

面向对象编程

OOP(object oriented programming)
其是一种程序设计思想。OOP把对象作为程序的一个基本单元,一个对象就包含了数据和操作数据的函数。
在Python中,所有数据类型都可以视为对象,同时,我们也可以自定义对象
自定义的对象的数据类型就是面向对象中类(class)的概念
demo:

stu1={"name":"Tom","score":99}
stu2={"name":"Jack","score":82}

利用函数来实现

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

类的定义和使用

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

类的定义

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__方法

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

数据封装

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

我们通过_init_()让stu1实例本身就拥有了相关数据,如果要访问这些数据,如果要访问这些数据,我们可以直接在Student类的内部定义相关的函数来访问数据,以此"封装"数据。
这些封装数据的函数和Student类本身是关联起来的,他们被称之为方法。

类的两个作用:

• 属性引用
  • 类名.属性
• 实例化
  • 类名加上一个括号就是实例化,他能够自动触发__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  #调用类的方法

对象之间的交互

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
'''
1000
990
992
'''

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

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

• 静态属性
  • 直接在类中定义的变量
• 动态属性
  • 在类中定义的方法
    静态属性是共享给所有对象的
    动态属性是绑定到所有对象的

函数的三大特性

继承

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

class Animal1(object):  # 定义父类
    def run(self):
        print("Animal is running")


class Animal2(object):
    pass


class Dog(Animal1):  # 单继承
    pass


class Cat(Animal1):  # 单继承
    pass


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


dog = Dog()
cat = Cat()
print(Dog.__bases__)  #
print(Husky.__bases__)
print(Animal1.__bases__)
print(Animal2.__class__)
#如果不指定基类，python类会默认继承object类
#object是所有python类的基类，提供一些常见方法的实现
'''
(<class '__main__.Animal1'>,)
(<class '__main__.Animal1'>, <class '__main__.Animal2'>)
(<class 'object'>,)
<class 'type'>
'''

多态

当子类和父类存在相同的方法时，子类的方法会覆盖覆盖父类的方法，再运行代码时，总会调用子类和父类同名的方法。
这就是继承的另一个好处，多态。

class Animal1(object):  # 定义父类
    def run(self):
        print("Animal is running")


class Animal2(object):
    pass


class Dog(Animal1):
    def run(self):# 单继承
        print("Dog is running")


class Cat(Animal1):  # 单继承
    def run(self):
        print("Cat is running")


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


dog = Dog()
cat = Cat()
dog.run()
cat.run()
'''
Dog is running
Cat is running
'''

理解多态，首先要对数据类型再进行说明。定义一个类的时候实际上就是定义了一种数据类型。我们自定义的数据类型和python自带的数据类型，比如str，list，dict没什么区别。
用isinstance()来判断某个变量是否是某个类型。

print(isinstance(dog, Animal1))
print(isinstance(dog, Dog))
'''
True
True
'''

对于一个变量，我们只要知道他的父类型，无需确切知道子类型，就可以放心调用相关的方法.运行时具体的方法是作用在子类型上还是父类型上，由我们运行的对象决定。
也就是说，调用时只管调用，不管细节。
当我们新增一个子类时，只要保证相关的方法正确，就不用管原来的代码时如何调用的。
—>"开闭"原则

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

总结:

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

私有属性

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

比如Student:

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", 89)
print(stu1.score)
stu1.score = 97
print(stu1.score)
'''
99
97
'''

从这可以看出，外部代码可以自由修改一个实例的属性(name，score)
如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线。
在python中，实例的变量名如果以上下划线开头，就变成了一个私有变量，只有内部可以访问，外部不能访问
修改一下Student类:

封装

隐藏对象的属性和实现细节，仅对外提供公共访问的方式
这样做的优点在于：
1.可以将变化隔离；
2.便于使用；
3.提高安全性
4.提高复用性
封装的原则是：

• 将不需要对外提供的内容隐藏起来；
• 隐藏属性，提供公共方法对其进行访问
  —>私有方法，私有变量—>私有属性
  用双下划线开头的方式将属性隐藏，设置为私有的

鸭子类型

不要求有严格的继承关系，一个对象，只要"看起来像鸭子，走起路来还是像鸭子"
也就是说，如果要编写先有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的对象，但与其无任何关系的全新对象。
比方说，利用标准库中定义的各种"与文件类似"的对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法。

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