面向过程
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
优缺点:
- 优点
- 将问题流程化,
- 从而分解简化问题
- 缺点
- 因为流程分解完毕之后比较钉死,想要对程序进行扩展功能的话需要进行大规模改动
面向对象
优缺点:
面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。
- 优点
- 保证了程序的扩展性
- 缺点
- 相对于面向过程而言复杂度要远高于面向过程
- 交互式问题解决方式,无法准确预测结果
面对对象编程
oop(object oriented programming)
是一种程序设计思想。oop把对象作为程序的基本单元,一个对象就包含了数据和操作数据的函数.
在python中,所有数据类型都可以视为对象,同时,我们也可以自定义对象。而定义了对象的类中的函数,则称为该对象对应的方法
demo:
如果要显示某学生信息中的成绩:
- 面对过程
students=[{'name':name,'id':id,'grade':grade}] #用字典存储一个学生的信息
def find_student(id):
"""用于返回需要的学生对应的下标i"""
i=find_student(id) #通过id确定学生并返回列表索引值
print(student[i]['grade']) #通过字典的key来返回成绩
- 面对对象
class student: #创建一个student类
def __init__(self,name,id,grade):
self.name=name
self.id=id
self.grade=grade
def get_grade(): #get grade的方法
print(self.grade)
stu1=Student('tom',100,55) #创建一个student对象
stu1.get_grade() #调用student的get_grade()方法
类的作用是一个模板,我们可以在创建实例的时候,把一些我们认为必须要绑定的属性填进去。这时候就通过过特殊的"_init_"方法,在创建实例的时候,绑定相关的属性。
和普通函数相比,类中定义的方法,第一个参数必须是self,除此之外与一般函数基本无二。(self指代实例)
- _init_ 方法
- 是类的初始化方法,类似于C#或Java的构造函数。
- 无返回值
- 通过此方法初始化类之后可以直接通过self参数访问实例的属性
类的两个作用
- 属性引用
- “类名.属性名”
- 实例化
- 类名加上一个括号就是实例化,回直接调用"_init_"函数,从而初始化对象的每个属性
特殊的类属性
- ._name_ 返回类的名字
- ._doc_ 类的文档字符串
- ._base_ 类的第一个父类
- ._bases_ 类的所有父类构成的元组
- ._module_ 类定义所在的模块
- ._class_ 实例所对应的类
- ._dict_ 类的字典属性
两个对象之间的交互:
- 人与狗回合制
class Player: #玩家
def __init__(self,name,att,hp):
self.name=name #名字
self.att=att #攻击力
self.hp=hp #血量
def att_dog(self,dog): #对狗发动攻击
dog.hp-=self.att
class Dog:
def __init__(self, att, hp):
self.att = att #攻击力
self.hp = hp #血量
def att_Player(self, player): #对人发动攻击
player.hp -= self.att
p1=Player('pro',10,100)
monster=Dog(10,50)
p1.att_dog(monster)
print(p1.hp,p1.att)
print(monster.hp)
类命名空间与对象,实例的空间
创建一个类就会创建一个类的名称空间,用来存储我们定义的所有的变量名。这些名字就是属性。
类的属性有两种:
- 静态属性
- 直接在类中定义的变量
- 静态属性
- 在类中定义的方法
函数的三大特性
- 继承
- 多态
- 封装
继承
在面对对象编程中,当我们定义一个新类的时候,可以从某个现有的类继承,新的类就被称为子类(Subclass)
,而被继承的类则被称为基类(base) ,父类(father),超类(super)
单继承
class Animal:
def run(self):
print("Animal is running")
class Dog(Animal):
# def run(self):
# print("Dog is running")
pass
class Cat(Animal):
# def run(self):
# print("Cat is running")
pass
dog=Dog()
cat=Cat()
dog.run()
cat.run()
#Animal is running
#Animal is running
如果在子类中有父类中的同名方法,则会覆盖来源父类的方法
class Animal:
def run(self):
print("Animal is running")
class Dog(Animal):
def run(self):
print("Dog is running")
class Cat(Animal):
def run(self):
print("Cat is running")
dog=Dog()
cat=Cat()
dog.run()
cat.run()
#Dog is running
#cat is running
多重继承
- 所谓多重继承,是指python的类可以有两个以上父类,也即有类A,类B,类C,C同时继承类A与类B,此时C中可以使用A与B中的属性与方法。
- 其实在python2.2之后,多继承中基类的寻找顺序是一种广度优先算法
class A:
def foo(self):
print("A foo")
class B:
def foo(self):
print("B foo")
def bar(self):
print("B bar")
class C1(A,B):
pass
class C2(A,B):
def bar(self):
print("C2 bar")
class D(C1,C2):
pass
test=D()
test.bar()
test.foo()
#C2 bar
#A foo
多态
多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)
- 序列类型有多种形态:字符串,列表,元组
- 动物有多种形态:人,狗,猪
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print('say aoao')
私有属性
在类的内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据。
class Dog:
def __init__(self, att, hp):
self.att = att
self.hp = hp
def att_Player(self, player):
player.hp -= self.att
monster=Dog(10,50)
monster.hp=40
print(monster.hp)
#40
从上可以看出,外部可以自由修改一个实例的属性,如果不想被外部访问,可以在属性名称之前加两个下划线(python中如果实例的变量以双下划线开头,就变成了一个私有变量,只有内部可以访问,外部不能访问)
写成私有属性之后再访问就需要在类里写对应的访问方法
class Dog:
def __init__(self, att, hp):
self.att = att
self.__hp = hp
def att_Player(self, player):
player.hp -= self.att
def get_hp(self):
print(self.__hp)
monster=Dog(10,50)
monster.get_hp()
#50
封装
隐藏对象的属性和实现细节,仅对外提供公共访问的方式。
这样做的优点:
- 可以将变化隔离
- 便于使用
- 提高安全性
- 提高复用性
封装的原则:
- 将不需要对外提供的内容隐藏起来
- 隐藏属性,提供公共方法对其进行访问。