1.什么是面向对象？
面向对象时一门编程思想！
-面向过程编程思想：
核心是‘过程’二字，过程指的是解决问题的步骤，即先干什么，再干什么！
基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。
优点：将复杂的问题流程化，进而简单化
缺点：牵一发而动全身，程序的可扩展性差
注：编程思想仅是一门思想，与任何的技术无关
-面向对象编程思想：
注意：要将自己当做一个上帝！
核心是‘对象’二字，对象指的是‘特征与技能’的结合体
基于编程思想写程序，就好比创造世界，一种‘上帝式’的思维方式
优点：
可扩展性高
缺点：
编写程序的复杂程度比面向过程高
2、如何产生对象：
1）什么是类？
类指的是类型、类别
-在两种角度去看待：
-在现实世界中：
-先有一个个的对象，经过社会的文明发展，随之总结出来
对象时实际存在的，而类抽象产生的
-在程序中：
-必须先有类，再通过‘调用类，产生对象’
对象指的是‘特征与技能’的结合体，类指的是一系列‘对象之间相同的特征与技能’的结合体。
2）如何定义类：
-如何写类并产生对象：
-先从现实世界中通过一个个对象总结出来
-然后再定义类，后调用类产生对象
比如: 选课系统:
- 选课系统学生类:
- 学生对象1:
特征:
- 姓名: hcy
- 性别: female
- 年龄: 95
- 学校: oldboy
- 技能:
- 技术: python
- 学习: learn
- 选课: course
- 学生对象2:
特征:
- 姓名: gaodi
- 性别: female
- 年龄: 98
- 学校: oldboy
- 技能:
- 技能:
- 技术: python
- 学习: learn
- 选课: course
3）定义类语法：
class 关键字：帮你产生类的
class 类的名字：
-对象之间相同的特征
-学校
school = ‘old boy’
-对像之间相同的技能
-python
def python():
pass
-learn
def learn():
pass
-course
def course():
pass
class 类名：
特征
技能
定义类名的规范：
-驼峰命名法
def foo(): #函数名指向的是函数的内存地址 pass print(foo) #<function foo at 0x10528b8b0>
#定义学生类
class OldboyStudet: #类名指向的是类的内存地址 #学生相同的特征 #在类中的特征 也称为之为"属性"attribute school = 'oldbay' #学生相同的技能 #注意：在类内部定义函数，会默认有一个参数self def learn(self): #self 此时当做一个形参 print('learn...') print(OldboyStudet)
查看类的名称空间
# 查看类的名称空间 print(OldboyStudent.__dict__) #{'__module__': '__main__', 'school': 'oldbay', # 'learn': <function OldboyStudent.learn at 0x109319820>, # '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, # '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None} print(OldboyStudent.__dict__['school']) #oldbay print(OldboyStudent.__dict__['learn']) #<function OldboyStudent.learn at 0x109319820> OldboyStudent.__dict__['learn'](123) #learn... 注：123是仅是一个参数(替换了原self)
类提供一种特殊取名字的方式，‘类名.名字’的方式
# 查 print(OldboyStudent.school) # oldbay OldboyStudent.learn('tank') # learn... #改 OldboyStudent.school = 'OldGirl' print(OldboyStudent.school) #OldGirl #删 del OldboyStudent.school # print(OldboyStudent.school) #type object 'OldboyStudent' has no attribute 'school' #增 OldboyStudent.school = 'Oldboy' print(OldboyStudent.school) # Oldboy OldboyStudent.Old_student = 'haha' print(OldboyStudent.Old_student) #haha
-函数的名称空间：
在调用函数是产生，函数调用结束后销毁
-类的名称空间：
在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
对象的产生：
-调用类产生对象
类名 +（）调用类产生对象
类的名称空间在定义时产生，对象的名称空间在调用类时产生
调用类产生对象的过程称之为类的实例化，对像称之为类的一个实例。
class Student: school = 'oldboy' #学习技能 --->method ---->方法 def learn(self): print(self) print('learning...')
stu1 = Student() stu2 = Student() stu3 = Student() # print(stu1) #<__main__.Student object at 0x10145c6d0> # # print(stu1.school,'stu1---') #oldboy stu1--- # # print(stu1.learn,'stu1####') #<bound method Student.learn of <__main__.Student object at 0x10b8b96d0>> stu1#### # # #对象调用方法时：会将对象当做一个参数传入方法中 # stu1.learn() #<__main__.Student object at 0x10bcd06d0> # #learning... # print(stu2) #<__main__.Student object at 0x10e4fedf0> # print(stu2.school,'stu2---') print(stu2.learn,'stu2...') #<bound method Student.learn of <__main__.Student object at 0x10695edf0>> stu2... # print(stu2.learn(),'stu2...') stu2.learn() #<__main__.Student object at 0x10ceb6df0> #learning...
由对象来调用类内部的函数，称之为对象的绑定方法
对象的绑定方法特殊之处：会将对象当做第一个参数传给该方法。
调用类产生对象发生的事情：
1、会产生一个空对象的名称空间
2、会自动触发__init__，并且会将对象当做第一个参数传入
3、会将调用类括号内的参数一并传给__init__()
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('learn...') #查看类的名称空间 # print(Student.__dict__) stu1 = Student('kangheng', 'female', 18) # stu2 = Student() # stu3 = Student() # print(stu1) #<__main__.Student object at 0x109f706d0> # print(stu2) #<__main__.Student object at 0x109f84df0> # print(stu3) #<__main__.Student object at 0x109f9bc10> stu1.name = 'kangheng' stu1.sex = 'female' stu1.age = 84 print(stu1.name, stu1.sex, stu1.age) print(stu1) #<__main__.Student object at 0x1014546d0># '''
总结：
class People: country = 'China' def __init__(self, name, age, sex): print(self.__dict__) print(self) self.name = name self.age = age self.sex = sex print(self.__dict__) # 注意: 看到self就应该知道是对象本身 def learn(self): print('learning....') p_obj = People('tank', 17, 'male') print(p_obj.name, p_obj.age, p_obj.sex) # 2.查看类与对象的名称空间 类.__dict__ 对象.__dict__ print(People.__dict__) print(p_obj.__dict__) # 3.类或对象的属性操作: 查、增、改、删 print(People.country) People.number = 1500 print(People.number) People.country = '中国' print(People.country) # del People.country # print(People.country) # print(p_obj.name) # p_obj.sal = 150000000 # print(p_obj.sal) # p_obj.age = 16 # print(p_obj.age) # del p_obj.sal # print(p_obj.sal) # 4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。 # p_obj1 = People('tank', 17, 'male') # p_obj2 = People('jason', 71, 'female') # p_obj3 = People('大饼', 72, 'female') # print(p_obj1.country, id(p_obj1.country)) # print(p_obj2.country, id(p_obj2.country)) # print(p_obj3.country, id(p_obj3.country)) # 5.类中的方法（类中的函数）: 类中的方法是给对象使用的， # 由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。 # print(People.learn) # print(p_obj1.learn) # bound method # print(p_obj2.learn) # print(p_obj3.learn) # 6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找 # print(p_obj1.country) # print(p_obj1.country2) # 7.对象绑定方法的特殊之处: ''' 1.会将对象当做第一个参数传入。****** 2.若对象的绑定方法中还有其他参数，会一并传入。 ''' # p_obj1对象.对象的绑定方法learn(p_obj1): # p_obj1.learn() # 8.一切皆对象: 在python3中，类即类型。 # print(type(p_obj1)) # <class '__main__.People'> # str1 = 'tank' # print(type(str1)) # <class 'str'> # # list1 = [1, 2, 3] # print(type(list1)) # <class 'list'>
实例：人狗大战
''' 需求: 有一个人对象，狗对象，人狗互咬。 - 对象人1: - 特征: - 生命 - 名字: name = 'gaodi' - 攻击力: arg - 技能: - 咬：bite - 对象人2: - 特征: - 生命 - 名字: name = 'kangheng' - 攻击力: arg - 技能: - 咬：bite - 对象人3: - 特征: - 生命 - 名字: name = 'wangyagn' - 攻击力: arg - 技能: - 咬：bite - 抽象出类: - 人类: - 相同特征 - 生命 - 相同技能 - 咬 狗对象1: - 特征: - 生命: 250 - 名字: name = 'HCY' - 品种: dog_type = '哈士奇' - 攻击力: arg - 技能: - 咬：bite 狗对象2: - 特征: - 生命: 400 - 名字: name = 'jason' - 品种: dog_type = '哈巴犬' - 攻击力: arg - 技能: - 咬：bite 狗对象3: - 特征: - 生命: 200 - 名字: name = 'sean' - 品种: dog_type = '沙皮' - 攻击力: arg - 技能: - 咬：bite 狗类: - 相同特征 - 相同技能 - 咬 ''' #人类 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 , dog_type, 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('高地',2000, 500) d1 = Dog('HCY', 250, '哈士奇',2500) p2 = People('高地2', 5000, 50) 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)