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)