面向对象
1. 什么是面向对象?
面向对象就是一门编程思想!
面向过程思想:
核心是'过程'二字, 过程指的是解决问题的步骤, 即先干什么, 后干什么.
基于编程思想编写程序, 就好比设计一条流水线, 一种机械化的思维方式.
优点: 将复杂的问题流程化, 进而简单化.
缺点: 牵一发而动全身, 程序可扩展性差.
** 注意编程思想就是一门思想, 与任何技术无关.
核心是'对象'二字, 对象指的是'特征与技能'的结合体
基于该编程思想写程序, 就好比在创建世界, 一种上帝式的思维方式.
优点: 可扩张性高.
缺点: 编写程序的复杂难度闭面向过程高.
2. 如何产生对象:
1)什么是类?
类指的是类型, 类别.
两种方式看待:
现实世界: 先有一个个的对象, 经过谁会的文明发展, 随之总结出类. 对象是实际存在的, 而类是抽象产生.
程序中: 必须先有类, 从而调用用类产生对象.
对象指的是'特征与技能的结合体', 类指的是一系列'对象之间相同的特征与技能'的结合体.
2)如何定义类:
如何写类并产生对象:
先从现实世界中通过一个个对象总结出类, 然后再定义出类, 后调用类产生对象.
定义类语法:
class 关键字: 帮你产生类
- def foo()# 函数名指向的是函数的内存地址
- pass
- print(foo)
定义老男孩学生类
- classoldboyStudent: #类名指向的是类的地址内存
- #学生相同的特征
- #在类中的特征, 也称之为属性
- school = 'oldboy'
- #学生相同的技能
** 注意: 在类内部定义函数, 会默认有一个参数 self
- def learn(self): #self 此时只是一个形参
- print('learning.....')
- # 查看类的名称空间
- print(OldboyStudent.__dict__)
- # 查
- print(OldboyStudent.school)
- # 改
- OldboyStudent.school = 'OldGirl'
- # 删
- del OldboyStudent.school
- # 增
- OldboyStudent.school = 'Oldboy'
- ?
函数的名称空间
在调用时产生, 函数调用结束后销毁.
类的名称空间
在定义阶段产生, 会将类所有的名字, 扔进类的名称空间中.
对象:
对象的产生: 调用类产生对象
类名 +()调用类产生对象
类的名称空间在定义时产生, 对象的名称空间在调用类时产生.
调用类产生对象的过程称之为类的实例化, 对象称之为类的一个实例.
由对象来调用类内部的函数, 称之为对象的绑定方法.
对象的绑定方法特殊之处: 会将对象当作第一个参数传给该方法. 若对象的绑定方法中还有其他参数会一并传入.
- class Student:
- # 学校
- school = 'oldboy'
- ?
- def __init__(self, name, sex, age): # stu1, 'tank', 'male', 17
- print(self.__dict__)
- ?
- # 给对象添加新的属性
- self.name = name # stu1.x = 'tank'
- self.sex = sex # stu1.y = 'male'
- self.age = age # stu1.z = 17
- ?
- # 查看当前对象的名称空间
- print(self.__dict__)
- ?
- # 学习技能 ----> method ---》 方法
- def learn(self):
- print(self) #
- print('learning...')
- Student('tank','male',17)
查看类的名称空间
print(Student.__dict__)
***** 想要在调用类时, 为对象传入对象独有的特征
****** __init__(self,name,sex,age): #name-->tank, sex-->male,age-->17
调用类时, 会将对象当做第一个参数, 与括号内的所有参数一并传给__init__()
- stu1 = Student('tank', 'male', 17)
- # 注意: 凡是在类内部定义的,__开头或结尾的方法都有特殊的意义.
- # 在内部定义的方法, 在调用类触发, 会自动将对象本身当作第一个参数传入, 与括号内所有参数一并传给__init__()
对象名字的查找顺序:
1. 对象. 属性, 会先找对象自己的, 若对象没有, 会先找类的, 如果类也没有就会报错.
- class People:
- country = 'China'
- name = 'jason'
- ?
- def __init__(self, name, age, sex):
- self.name = name
- self.age = age
- self.sex = sex
- ?
- def run(self):
- print('running...')
- ?
- ?
- obj1 = People('tank', 17, 'male')
- print(obj1.name) # tank 找对象自己的 name 属性
- print(obj1.country) # China 对象没有, 找类中的属性
- # AttributeError: 'People' object has no attribute 'jason'
- # print(obj1.jason) # 对象没有, 类也没有, 就会报错!
- print(obj1.__dict__)
- # 给对象的名称空间添加 country='中国' 属性
- obj1.country = '中国'
- print(obj1.__dict__)
- print(People.__dict__)
- print(obj1.country)
栗子:
人狗对战
需求: 有一个?? 对象, 一个?? 对象互相攻击.
对象人:
特征:
生命: life = 500
名字: name = '高留住'
攻击力: arg = 125
技能:
Millennium kill = 千年杀
?
狗对象:
特征:
生命: life = 1000
名字: name = '鬣狗'
攻击力: arg = 70
技能: Anal excavation = 掏肛
人类:
- class People:
- def __init(self,name,life,arg):
- self.name = name
- self.life = life
- self.arg = arg
- ?
- # 人调用 bite 时, 传入狗对象
- def bite(self, dog_obj):
- print(f'人:[{self.name}] 开始 咬 狗:[{dog_obj.name}]!')
- ?
- # 减掉狗对象中的生命值 值为人的攻击力
- dog_obj.life -= self.arg
- print(f'狗的生命值减掉: [{self.arg}], 还剩狗的血量: [{dog_obj.life}]')
- ?
- if dog_obj.life <= 0:
- print(f'狗 [{dog_obj.name}] 已经挂了')
- return True
- ?
- ?
- ?
- # 狗类
- class Dog:
- def __init__(self, name, life, arg):
- self.name = name
- self.dog_type = dog_type
- self.life = life
- self.arg = arg
- ?
- # 狗对象调用 bite 时, 传入人对象
- def bite(self, p_obj):
- print(f'狗:[{self.name}] 开始 咬人:[{p_obj.name}]!')
- ?
- # 减掉人对象中的生命值 值为狗的攻击力
- p_obj.life -= self.arg
- print(f'人的生命值减掉: [{self.arg}], 还剩人的血量: [{p_obj.life}]')
- ?
- if p_obj.life <= 0:
- print(f'人 [{p_obj.name}] 已经挂了')
- return True
- ?
- ?
- p1 = People('高留柱', 500, 125)
- d1 = Dog('鬣狗', 1000, 70)
- ?
- import time
- ?
- while True:
- # 开始人狗互
- # if p1.life or d1.life:
- res1 = d1.bite(p2)
- ?
- if res1:
- break
- ?
- time.sleep(1)
- ?
- res2 = p1.bite(d1)
- ?
- if res2:
- break
- ?
- time.sleep(1)
- ?
面向对象
来源: http://www.bubuko.com/infodetail-3303879.html