1. 面向对象和面向过程
面向过程编程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么...基于面向过程编程的思想编写程序好比在设计一条流水线，是一种机械式的思维方式。
面向过程：
优点：复杂问题流程化，进而简单化
缺点：可扩展性差
面向对象编程的核心是对象二字，对象是特征与技能的结合体。
基于面向对象编程的思想编写程序，就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式。
面向对象：
优点：可扩展性高
缺点：编写复杂
2. 类与对象
'''
对象：属性和方法的结合体
类：一系列共同的属性和方法
现实生活中：先有对象再有类
程序中：先有类再有对象
'''
'''
学生1：
学校：老男孩
姓名：吴子豪
性别：女
年龄：30
方法：
选课
学习
学生1：
学校：老男孩
姓名：小吴
性别：女
年龄：18
方法：
选课
学习
'''
# 定义类(类名建议用驼峰体命名)
# class关键字 类名
class Student:
# 变量表示属性
school = 'oldboy'
def choose(self):
print('选课')
def study(self):
print('学习')
# 生成对象 类加括号，生成对象
stu1 = Student()
# 获取属性和方法 通过 . 获取
print(stu1.school) # oldboy
print(stu1.choose()) # 选课
None
# 查看类中的属性和方法
print(Student.__dict__)
print(Student.__dict__['school']) # oldboy
print(Student.__dict__['choose']) # <function Student.choose at 0x000002237C792EA0>
Student.__dict__['choose'](123) # 选课
Student.choose(123) # 选课
# print(Student.scool) # 报错
# 获取对象的属性和方法
stu1 = Student()
print(stu1.__dict__) # {}
print(stu1.school) # oldboy
# 对象来调用方法，第一个参数不用传
print(stu1.choose) # <bound method Student.choose of <__main__.Student object at 0x000001DE86039128>>
stu2 = Student()
print(stu2.school) # oldboy
# 对象自己的属性和方法
stu1 = Student()
stu1.name = 'nick'
stu1.school = 'xxxx'
print(stu1.school) # xxxx
print(stu1.__dict__) # {'name': 'nick', 'school': 'xxxx'}
# 属性查找顺序
# 先从对象自身找---->类中找---->报错
Student.school = 'xxx'
stu1 = Student()
print(stu1.school) # xxx
# 像对象中放属性
# 第一种方式：
stu1 = Student()
stu1.name='nick'
# 第二种方式：通过__init__方法
class Student:
# 变量表示属性
school = 'oldboy'
def __init__(self,name):
self.name = name
def choose(self):
print('选课')
def study(self):
print('学习')
# 产生对象
# stu1 = Student()
stu1 = Student('nick')
# 内部帮我们做了一些事：当我在实例化产生对象的时候，会自动调用__init__方法，完成对象的初始化
print(stu1.name) # nick
stu2 = Student('jason')
print(stu2.name) # jason
def change(obj,name):
obj.name = name
stu1 = Student('xxx')
Student.__init__(stu1,'nick')
change(stu1,'nick')
print(stu1.name) # nick
stu2 = Student('bob')
print(stu2.name) # bob
3. 绑定方法
# 绑定方法：
# 定义在类内部的方法：
# 如果类来调用：就是一个普通函数，有几个参数就需要传几个参数
# 对象来调用：他叫对象的绑定方法，第一个参数不需要传，自动传递
class Student:
# 变量表示属性
school = 'oldboy'
def __init__(self,name):
self.name = name
def choose(self):
print('选课')
def study(self):
print(f'{self.name}学会了python')
stu1 = Student('nick')
stu1.study()
stu1 = Student('bob')
stu1.study()
4. 一切皆对象
# python中，字典，列表，字符串...都是对象
# 类即类型
# l1 = [1,2,3]
# 类实例化产生对象
l1 = list([1,2,3])
l2 = list([5,6,7])
# 对象调用对象的绑定方法，修改对象自己
l1.append(5)
print(l1) # [1, 2, 3, 5]
list.append(l1,9)
print(l1) # [1, 2, 3, 5, 9]
print(type(l1)) # <class 'list'>
class Student:
school = 'oldboy'
def choose(self):
print('选课')
def study(self):
print('学习')
a = Student()
print(type(a)) # <class '__main__.Student'>
5. 人狗大战
# 人狗大战
# 定义一个狗类
class Dog:
type_dog = '哈士奇'
def __init__(self,name,aggressivity,hp=100):
self.name = name
self.aggressivity = aggressivity
self.hp = hp
def bite(self,target):
# 当前狗的攻击力：self.aggressivity
# 人的血量：target.hp
target.hp -= self.aggressivity
print(f'''
狗的品种：{self.type_dog}
{self.name}狗咬了一下{target.name}
人掉血：{self.aggressivity}
人的血量剩余：{target.hp}
''')
class Human:
def __init__(self,name,aggressivity,hp=100):
self.name = name
self.aggressivity = aggressivity
self.hp = hp
def bite(self,target):
target.hp -= self.aggressivity
print(f'''
{self.name}人咬了一下狗{target.name}
狗掉血：{self.aggressivity}
狗的剩余血量：{target.hp}
''')
# 实例化产生狗对象
dog1 = Dog('haha',20)
human1 = Human('bob',50)
dog1.bite(human1)
print(human1.hp)
human1.bite(dog1)
print(dog1.hp)