面向对象基础
面向对象基础
目录
面向对象基础
静待一树花开，盼你叶落归来
面向过程与面向对象编程
面向过程编程的核心是‘’过程‘’，过程指的是做事情的步骤，也就是先做什么后做什么，基于该编程思想编写程序，如同工厂的流水线。
优点：逻辑清晰，复杂的问题流程化，进而简单化
缺点：可扩展性差
什么是面向对象？
向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现。
面向对象编程：
核心是‘’对象‘’，对象指的是特征与技能的结合体。面向对象编程如同在创在世界，要有一种上帝的思维方式。
优点：可扩展性高
缺点：编写程序的复杂程度远远高于面向过程编程思想
优先使用那种思想？
面向过程结合面向对象
类
创造对象需要先学习类，类：类别、类型、分类
类：先定义类，后调用类产生对象 现实世界中：对象是一个个具体存在的事物，类是人总结出来的，所以先有对象后有类；而在程序中遵循先有类后有对象。
类有两种作用：属性引用和实例化
属性引用（类名.属性）
class Person: #定义一个人类
role = 'person' #人的角色属性都是人
def walk(self): #人都可以走路，也就是有一个走路方法
print("person is walking...")
print(Person.role) #查看人的role属性
print(Person.walk) #引用人的走路方法，注意，这里不是在调用实例化对象：调用类即可产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例，实例化会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征，语法：对象名 = 类名（参数）
class Person: #定义一个人类
role = 'person' #人的角色属性都是人
def __init__(self,name):
self.name = name # 每一个角色都有自己的昵称;
def walk(self): #人都可以走路，也就是有一个走路方法
print("person is walking...")
print(Person.role) #查看人的role属性
print(Person.walk()) #调用方法
p1 = Person(xiaozhang)#实例化出一个对象，实例化的过程就是产生对象的过程如何定义类：
- 先从现实世界中抽象出类。
- 定义类。 对象：特征与技能的结合体， 类：一系列对象相同的特征与技能的结合体 定义类的语法：
class 类名：
对象相同的特征
对象相同的技能
#class：用来定义类的，后面跟类名。注意：类名必须要用驼峰体命名,python在定义变量与函数时不推荐使用驼峰体,相同的特征指类内部的变量，相同的技能指类内部的函数。
选课系统项目:
- 在现实世界中:
学生对象1:
特征:
school = '×××' 学校
name = '高峰峰' 姓名
age = 93 年龄
sex = 'female' 性别
技能
learn 学习
choose_course 选课
学生对象2:
特征:
school = '×××'
name = '小丁丁'
age = 84
sex = 'female'
技能
learn
choose_course
学生对象3:
特征:
school = '×××'
name = '大丁丁'
age = 18
sex = 'male'
技能
learn
choose_course
类:
相同的特征:
school = '×××'
相同的技能:
learn
choose_course定义类发生的事情：
1.在定义类时会产生一个空的名称空间，
2.把类内的名字放在名称空间里
类在定义阶段就已经产生好了名称空间执行类内的代码
调用类名时会指向类的名称空间
类.__dict__#查看类的名称空间中所有的名字
#__dict__只在读的时候以字典的形式去展示
类. #指向类的名称空间
类.特征或技能 #对类内部的名字进行修改，
# . 会指向类内部的名称空间从而获取名字特征也称之为属性
class Dog:
def __init__(self,name,aggr,life_value):
self.name = name
self.aggr = aggr
self.life_value = life_value通过类名调用类内部的函数，这个函数就只是一个普通函数 对象的产生： 语法： 类名（）调用类产生对象，然后赋值给一个变量
当实例化出对象后，会在内存中开辟一个存储对象独有特征的名称空间。
__init__:（翻译：为对象初始化某些属性）会在调用类时，自动触发该函数__init__(self)
调用类时发生的事情： 1.首先会产生一个空对象，就是产生的“对象名称空间” 2.自动触发__init__ 3.会把对象本身及括号内的参数一并传给__init__函数
给对象添加属性的方式一：类中有的属性，我们可以一个一个给它们赋值，类中没有的我们也可以通过这种方式添加，添加的内容会存储在对象的名称空间里
stu1.name = 'tank'
stu1.age = 18
stu1.gender = 'male'
print(stu1.name, stu1.age, stu1.gender)给对象添加属性的方式二：
class Person:
def __init__(self,name,money,aggr,life_value):
self.name = name
self.money = money
self.aggr = aggr
self.life_value = life_value
person1 = Person('nick',10000,300,1000)#方式二，当添加类中没有的属性时还是要用方式一
print(person1.__dict__)#对象名.__dict__查看对象的名称空间{'name': 'nick', 'money': 10000, 'aggr': 300, 'life_value': 1000}
对象与类的查找顺序
对象.属性，若对象本身有则先用自己的，若对象本身没有则用类的，若类也没有，则报错。
对象绑定方法的特殊之处
（对象.方法 就是对象的绑定方法）
1.由类调用类内部的函数，则这个函数需要传（self）这个参数； 2.由对象调用对象的绑定方法，会将自己作为self传入绑定方法中 对象的绑定方法__特殊之处就是把对象当做第一个参数传入绑定方法中,由不同的对象调用，就把不同的对象传给不同的绑定方法。__
对象之间与类的方法功能一样，内存地址不同
python 中一切皆对象
小练习
- 人狗大作战
class Person:
def __init__(self,name,money,aggr,life_value):
self.name = name
self.money = money
self.aggr = aggr
self.life_value = life_value
def attack(self,dog):
'''攻击方法'''
if self.life_value > 0:
dog.life_value -= self.aggr
print(f'''
{self.name}攻击{dog.name}成功
{self.name}生命力{self.life_value}
{dog.name}生命力{dog.life_value}
''')
return True
class Weapon:
'''定义武器类'''
def __init__(self,money,aggr,life_value):
self.money = money
self.aggr = aggr
self.life_value = life_value
def update(self,obj):
obj.money -= self.money
obj.life_value += self.life_value
obj.aggr += self.aggr
def pick(self,obj):
obj.life_value -= 500
print(f'{obj.name}的生命力还有{obj.life_value}')
person1 = Person('nick',10000,300,1000)
dog1 = Dog('hashiqi',500,5000)
weap1 = Weapon(5000,300,2500)
if person1.money > weap1.money:
weap1.update(person1)
person1.weapon = weap1#将weapon放入person的个人属性里面，这样就可以调用person了
person1.attack(dog1)
person1.weapon.pick(dog1)2. 定义了一个圆形类；提供计算面积(area)和周长(perimeter)的方法
from math import pi
class Circle:
def __init__(self,radius):
self.radius = radius
def area(self):
aer = pi*(self.radius**2)
return aer
def perimeter(self):
per = 2*pi*self.radius
return per
cir1 = Circle(6)
print(cir1.area())
print(cir1.perimeter())
3. 圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
from math import pi
class Circle:
def __init__(self,radius):
self.radius = radius
def area(self):
aer = pi*(self.radius**2)
return aer
def perimeter(self):
per = 2*pi*self.radius
return per
class Ring:
def __init__(self,out_round,in_round):
self.out_round = Circle(out_round)
self.in_round = Circle(in_round)
def area(self):
are = self.out_round.area() - self.in_round.area()
return are
def perimeter(self):
per = self.out_round.perimeter() + self.in_round.perimeter()
return per
ring1 = Ring(10,5)
print(ring1.perimeter())
print(ring1.area())总结
- 面向过程编程:
核心是“过程”二字，过程指的是做事情的步骤，即先做什么再做什么
基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。
优点:逻辑清晰，复杂的问题流程化，进而简单化。
缺点:可扩展性差。
2. 面向对象编程:
核心是“对象”二字，对象指的是特征与技能的结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。
优点:可扩展性高。
缺点:编写程序的复杂程度要远高于面向过程编程思想。
- 在定义类发生的事情: 1.类在定义时，会产生一个空的名称空间。 2.会把类内部所有名字，扔进类的名称空间中。 注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。
- 调用类发生的事情(******): 1.首先会产生一个空的对象，就是产生“对象的名称空间”。 2.会自动触发__init__。 3.会把对象本身以及括号内的参数一并传给__init__函数。 总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.
- init: 会在调用类时，自动触发该函数。
- （1）类调用类内部的函数,只是调用普通函数. （2）对象的绑定方法特殊之处(*******): - 由对象来调用的,会把对象当作第一个参数传入该方法中 - 由不同的对象来调用,就会把不同的对象传给不同的绑定方法.