Python第十天笔记——面向对象

面向过程

所谓过程就是我们解决问题的步骤。

优点：

• 复杂的问题流程化，将问题分解简化

缺点

• 拓展性不好

面向对象

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

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

在Python中，一切皆为对象。

• 优点

  • 解决程序的拓展性

• 缺点

  • 就是复杂度远高于面向过程
  • 交互式解决问题，无法准确预测结果

  类就是类别、种类；对象就是特征和技能的统一体；类则是这一系列对象的特征和技能的集合，对于现实世界，先有个体（即对象），才有类别，但对于程序，必须先有类然后才有对象。

面向对象编程

oop(object oriented programming)

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

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

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

#demo：处理成绩

• 面向过程的方式

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

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

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",18,"male")
stu1.sleep()

1、类的定义：

class ClassName(object):
    '''docstring'''
     class_statement

2、类的使用：

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

3、类的命名：

大驼峰式，就是变量名称的首字母大写。

4、创建一个类：

class MyFirstClass:
     pass

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

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

和普通函数相比，在类中定义方法时，第一个参数必须是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()

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

类的两个作用：

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

类属性的查看

• dir(类名)
  • 返回一个列表
• 类名.__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 #调用类的方法

#demo:

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("Jerry","Husky",8,1000)

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

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

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

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

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

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

函数的三大特性

• 继承
• 多态
• 封装

1、继承

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

比如，我们定义一个动物类（Animal）

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

print(Dog.__bases__)
print(Husky.__bases__)
print(Animal.__bases__)
print(Animal2.__bases__)
#如果不指定基类，Python类会默认继承object类；
#object类是所有Python类的基类，提供一些常见方法的实现。

#输出结果：
(<class '__main__.Animal'>,)
(<class '__main__.Animal'>, <class '__main__.Animal2'>)
(<class 'object'>,)
(<class 'object'>,)

继承的查看：

ClassName.__bases__

2、多态

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

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

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

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

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

当新增一个子类时，只要保证相关的方法编写正确，就不用管原来的代码如何调用。---->"开闭"原则。

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

总结：

继承可以一级一级的继承，任何类都可以追溯到根类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)
print(stu1.score)
stu1.score=97
print(stu1.score)

#输出结果：
99
97

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

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

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

3、封装

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

#优点：

1、可以将变化隔离；

2、便于使用；

3、提高安全性；

4、提高复用性。

#原则：

1、将不需要对外提供的内容隐藏起来；

2、隐藏属性，提供公共方法对齐进行访问。

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

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

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,score):
        return self.__score
    def set_score(self,score):
        if 0<=score <=100:
            self.__score=score
        else:
            raise ValueError("Bad score.")
    def find_score(self):
        print(self.__name,":",self.__score)
stu1=Student("Tom",99)
stu1.score=97
print(stu1.score)
print(stu1.find_score())
print(stu1._Student__score)

#输出结果：
97
Tom : 99
99