类（class）

软件开发方式

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

面向过程

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

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

优缺点：

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

面向对象

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

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

在python中，一切皆为对象。

优缺点：

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

类就是类别、种类

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

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

对于现实，现有个体（对象），再有类别；但对于程序，必须先有类，然后再有对象的。

面向对象编程

OOP（object oriented program）

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

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

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

demo:

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

• 面向过程的方式

stu1={'name':'Tom','score':90}
stu2={'name':'Jcak','score':80}
...
	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', 80)
stu1.find_score()

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

类的定义和使用

类的定义

class Classname(object):
    '''dicstring'''
    class_statement

类的命名，大驼峰式，比较规范

所谓大驼峰式就是变量名称的单词的首字母大写。

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

class Student:
    def __init__(self,school, name, age,sex):
        self.school=school
        self.name = name
        self.age=age
        self.sex=sex
stu1 = Student('zucc','Tom',20,'male')
print(stu1.name,stu1.school,stu1.age,stu1.sex)
Tom zucc 20 male

和普通函数相比，在类中定义方法是，第一个参数必须是self（名字可变）。除第一个参数外，其他的和普通参数函数并没有什么区别。

self代表的是实例，而非类。

__init__方法

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

传参

class Point:
    def reset(self,x,y):
        self.x=x
        self.y=y
p=Point()
p.reset(4,5)
print(p.x,p.y)
#4 5

数据封装

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', 80)
stu1.find_score()

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

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

类的两个作用

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

类属性的查看

• dir(类名)
  • 返回一个列表
• 2.类名._dict_
  • 返回一个字典，key为属性名，value是属性值。

特殊的类属性

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

总结

class Classname:
    def __init__(self, para1, para2,...):
        self.属性1 = para1
        self.属性2 = para2
    def 方法1(self):
       内容
    def 方法2(self):
        内容
obj=Classname(para1,para2,...)
#无需传入self，参数一一对应
#结果是返回对象obj
obj.属性#查看对象属性
obj.方法#查看类的方法

对象之间的交互

假如说现在定义两个类，Dog，Cat

class Dog:
    def __init__(self,name,assault,life_value,lv):
        self.name=name
        self.assault=assault
        self.life_value=life_value
        self.lv=lv
    def attack(self,cat):
        cat.life_value -= (self.assault*0.9+self.lv*0.7)
class Cat:
    def __init__(self,name,assault,life_value,lv):
        self.name=name
        self.assault=assault
        self.life_value=life_value
        self.lv = lv
    def attack(self,dog):
        dog.life_value -= (self.assault*0.7+self.lv*1.2)
dog=Dog("DOG1",18,890,6)
cat=Cat("CAT1",25,650,10)
print(dog.life_value,cat.life_value)
while 1:
    if cat.life_value and dog.life_value>0:
        dog.attack(cat)
        cat.attack(dog)
        print(dog.life_value, cat.life_value)
    else:
        if cat.life_value>0:
            print("猫赢了")
        else:
            print("狗赢了")
        break

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

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

类的属性有两种

• 静态属性

  • 直接在类中定义的变量

• 动态属性

  • 在类中定义的方法

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

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

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', 80)
stu2 = Student('Aom', 90)
print(id(stu1.school))
print(id(stu2.school))
print(stu1.find_score)
print(stu2.find_score)
print(Student.find_score)
---------
1986584220760
1986584220760
<bound method Student.find_score of <__main__.Student object at 0x000001CE89A5F320>>
<bound method Student.find_score of <__main__.Student object at 0x000001CE89A5F358>>
<function Student.find_score at 0x000001CE89A5BC80>

类的三大特性

• 继承
• 多态
• 封装

继承

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

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

class Animal(object):#可以不给，默认是最高，给了必须是object，否则报错
    def run(self):
        print("Animal is running")
class Dog(Animal):
    pass
class Cat(Animal):
    pass
class Husky(Dog):
    pass
dog=Dog()
cat=Cat()
dog.run()
cat.run()
husky.run()
#Animal is running
#Animal is running
#Animal is running
#Cat和Dog继承了Animal类，包括里面的run()方法,而Husky继承了Dog,也包括了Dog所继承的Animal类

继承的查看Classname.__bases__

多态

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

class Animal(object):
    def run(self):
        print("Animal is running")
class Dog(Animal):
    def run(self):
        print("Dog is running")
dog=Dog()
dog.run()
#Dog is running

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

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

li=[]
print(isinstance(li,list))
print(isinstance(dog,Dog))
print(isinstance(dog,Animal))
#True
#True
#True

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

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

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

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

—>"开闭"原则

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

总结：

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

任何类都可以追溯到根类object

私有属性

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

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', 80)
print(stu1.score)
#80
stu1.score=97
print(stu1.score)
#97

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

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

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

封装

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

这样做的优点在于：

1.可以将变化隔离；

2.便于使用；

3.提高安全性；

4.提高复用性。

封装的原则是：

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

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

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

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 find_score(self):
        print(self.__name, ":", self.__score)
stu1 = Student('Tom', 80)
print(stu1.get_score())
_Student__score=90
print(stu1.get_score())
#80
#80