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)