面向过程与面向对象
- 面向过程
- 函数式编程
- 面向对象
面向过程
所谓过程就是我们解决问题的步骤,一步步的按照流程走,有先后之分。
整个过程就好比流水线,思维上比较机械化。
优缺点:
- 优点
- 复杂的问题流程化,将问题分解简化。
- 缺点
- 拓展性不好
面向对象
核心是对象。
正式的来说
-
对象是一个数据以及相关行为的集合
-
面向对象是功能上指向建模对象
通过数据和行为方式来描述交互对象的集合。
在Python中,一切皆为对象。
面向对象的优缺点
-
优点
- 解决程序的拓展性
-
缺点
- 复杂度远高于面向过程。
- 交互式解决问题,无法准确预测结果。
object1:
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":87}
利用函数来实现
def find_score(stu):
print(stu["name"],":",stu["score"])
find_score(stu1)
- 面向对象的处理方式
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 ClassName(object):
"""dicstring"""
class_statment
类的命名,大驼峰式
所谓大驼峰式就是变量名称的单词的首字母大写。
创建一个类
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类本身是关联起来的,他们被称之为方法。
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))
# (5, 4)
# (3, 6)
# 通过点记法给一个实例化的对象赋予任何属性
# 没有任何行为
#
class Point :
def reset(self):
self.x = 0
self.y = 0
p = Point()
p.reset()
print((p.x,p.y))
# (0, 0)
#
# 传参
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)
#
# 返回两个对象的距离
import math
class Point :
def move(self,x,y):
self.x = x
self.y = y
def reset(self):
self.move(0,0)
def cal_distence(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_distence(p1))
print(p2.cal_distence(p3))
# 5.0
# 5.0
类的两个作用:
- 属性引用
类名·属性
- 实例化
- 类名加上一个括号就是实例化,他能够自动触发
__init__
函数的运行,进而为每个实例定制自己的特征。
- 类名加上一个括号就是实例化,他能够自动触发
类属性的补充
类属性的查看
-
1.dir(类名)
- 返回一个列表
-
类名.
__dict__
- 返回一个字典,key为属性名,value是属性值。
特殊的类属性
类名.__name__ # 返回类的名字
类名.__doc__ # 类的文档字符串
类名.__base__ # 类的第一个父类
类名.__bases__ # 类的所有父类构成的元组
类名.__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 # 查看对象属性1
obj.方法名1 # 调用类的方法
人狗大战
class Person:
def __init__(self,name,aggressivity,life_value):
self.name = name
self.aggressivity = aggressivity
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)
类命名空间与对象、实例的空间
创建一个类就会创建一个类的名称空间,用来存储我们定义的所有变量名。这些名字就是属性。
类的属性有两种:
-
静态属性
- 直接在类中定义的变量
-
动态属性
- 在类中定义的方法
静态属性是共享给所有对象的
动态属性是绑定到所有对象的
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",80)
print(id(stu1.school))
print(id(stu2.school))
print(stu1.find_score)
print(stu2.find_score)
print(Student.find_score)
# 1865329643904
# 1865329643904
# <bound method Student.find_score of <__main__.Student object at 0x000001B24E4F9C50>>
# <bound method Student.find_score of <__main__.Student object at 0x000001B24E4F9C88>>
# <function Student.find_score at 0x000001B24E4FAAE8>
函数的三大特性
- 继承
- 多态
- 封装
继承
在面向对象编程中,当我们定义一个新类的时候,可以从某个现有的类继承,新的类就被称为子类(SubClass),而被继承的类则被称为基类,父类,超类(Base Class, Father Class, Supper Class)
比如,当我们定义一个动物类(Animal),其有一个run()方法如下:
class Animal(object): # 定义父类
def run(self):
print("Animal is runing.")
class Animal2:
pass
class Dog(Animal): # 单继承
pass
class Cat(Animal): # 单继承
pass
class Husky(Animal,Animal2): # 多继承,用逗号分隔开
pass
dog = Dog()
cat = Cat()
husky = Husky()
dog.run()
cat.run()
husky.run()
# 如果不指定基类,Python类会默认继承object类
# object是所有Python类的基类,提供一些常见方法的实现
继承的查看
ClassName.__bases__
多态
当子类和父类存在相同的方法时,子类的方法会覆盖父类的方法,再运行代码时,总会调用子类的方法。
这样,就是继承的另一个好处,多态。
class Animal(object): # 定义父类
def run(self):
print("Animal is runing.")
class Animal2:
pass
class Dog(Animal): # 单继承
def run(self):
print("Dog is runing.")
pass
class Cat(Animal): # 单继承
def run(self):
print("Cat is runing.")
pass
class Husky(Animal,Animal2): # 多继承,用逗号分隔开
pass
dog = Dog()
cat = Cat()
husky = Husky()
dog.run()
cat.run()
husky.run()
# Dog is runing.
# Cat is runing.
# Animal is runing.
理解多态,首先要对数据类型再进行说明。定义一个类的时候实际上就是定义了一种或数据类型。我们自定义的数据类型和Python自带的数据类型,比如str,list,dict,没什么区别
用isinstance()来判断某个变量是否是某个类型
dog = Dog()
cat = Cat()
li = list()
print(isinstance(li,list))
print(isinstance(dog,Animal))
print(isinstance(dog,Dog))
# True
# True
# True
鸭子类型
鸭子类型不要求有严格的继承关系,一个对象,只要”看起来像鸭子,走起路来还是像鸭子“
也就是说,如果要编写现有对象的自定义版本,可以继承该对象,也可以创建一个外观和行为像,但于其无任何关系的全新对象。
比方说,利用标准库中定义的各种”与文件类似的“的对象,尽管这些对象的工作方式像文件,但他们并没有继承内置文件对象的方法
class Test:
def run(self):
print("多态测试")
dog = Dog()
cat = Cat()
test= Test()
def run_twice(animal):
animal.run()
animal.run()
run_twice(test)
# 多态测试
# 多态测试
class TestFile:
def read(self):
pass
def write(self):
pass
class OperFile:
def read(self):
pass
def write(self):
对于一个变量,我们只要知道他的父类型,无需确切知道子类型,我们就可以放心调用相关方法。运行时具体的方法是作用再子类型上还是父类型上,由我们运行的对象决定。
也就是说,调用时只管调用,不管细节。
当我们新增一个子类时,只要保证相关的方法编写正确,就不用管原来的代码是如何调用的。
—>"开闭"原则
- 对拓展开放:允许新增子类
- 对修改封闭:不需要修改依赖父类类型的函数。
私有属性
在类的内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据。这样,隐藏内部的复杂逻辑。
比如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",80)
print(stu1.score)
stu1.score = 97
print(stu1.score)
从这里可以看出,外部代码可以自由修改一个实例的属性(name,score)
如果要让内部属性不被外部访问,我们可以在属性名称前加两个下划线。
在Python中,实例的变量名如果以双下划线开头,就变成了一个私有变量,只有内部可以访问,外部不能访问。
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")
def find_score(self):
print(self.__name,":",self.__score)
stu1 = Student("Tom",99)
stu2 = Student("Jack",80)
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)
封装
隐藏对象的属性和现实细节,仅对外提供公共访问的方式。
这样做的优点在于:
1.可以将变化隔离
2.便于使用
3.提高安全性
4.提高复用性
封装的原则是:
-
将不需要对外提供的内容隐藏起来
-
隐藏属性,提供公共方法对其进行访问
—>私有方法,私有变量---->私有属性