一、面向过程编程和面向对象编程的优缺点

1.1 面向过程编程

面向过程编程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么.......

基于面向过程编程的思想编写程序好比在设计一条流水线，是一种机械式的思维方式。

优点：把复杂的问题流程化、进而简单化
缺点：可扩展性差

1.2 面向对象编程

面向对象编程的核心是对象二字，对象是特征与技能的结合体。

基于面向对象编程的思想编写程序，就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式。

优点：可扩展性强
缺点：编程的复杂度高

二、面向对象编程

2.1 类与对象

对象：属性和方法的结合体
类：一系列共同的属性和方法得结合体

现实世界生活中：先有对象再有类；python程序中先有类再有对象

定义类：类名要用驼峰体

# 关键字class 类名:
# 例如：
class Student:
    school = 'oldboy'  # 变量表示共同的属性
    def choose(self):  # 函数表示方法
        print('选课')

定义对象：

调用类即可生成对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例

stu1 = Student()  # 定义了类的一个对象stu1，调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例

获取属性和方法

print(stu1.school)   # oldboy  通过.获取属性
print(stu1.choose)   # 得到绑定方法的内存地址
stu1.choose()  # 打印选课  .函数() 获取方法

查看类中的属性和函数(方法)

print(Student.__dict__)  # 得到类中的所有属性和方法
-----------------------------------------------------------------------------
{'__module__': '__main__', 'school': 'oldboy', 'choose': <function Student.choose at 0x0000022C607F3D90>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

类调用属性和方法

方式一：通过dict获取（复杂，不用）

print(Student.__dict__['school'])  # oldboy

方式二：类名.属性/函数名

print(Student.school)  # oldboy
print(Student.choose)  # 输出函数的内存地址  <function Student.choose at 0x0000027B8AB73D90>
Student.choose(123)  # 类调用方法，第一个参数必须传

对象获取属性和方法

stu1 = Student()
print(stu1.__dict__)  # {} 还没有给对象放属性，所以为空

对象调用属性和方法

对象 . 属性/方法，对象调用方法时，第一个参数不用传

stu1 = Student()
print(stu1.school)  # 对象调用属性
stu1.choose()  # 对象调用方法，第一个参数不用传

向对象中放属性

方式一：

class Student:
    school = 'oldboy'  # 变量表示共同的属性
    def choose(self):  # 函数表示方法
        print('选课')
stu1 = Student()
stu1.name = 'zyl'
print(stu1.name)  # zyl

方式二：通过__init__方法

class Student:
	school = 'oldboy'  # 变量表示共同的属性
    def __init__(self,name):
        #在类中定义`__init__`方法，方法内写一些参数
        self.name = name
	def choose(self):  # 函数表示方法
        print('选课')

stu1 = Student('zyl')  # 必须传一个参数给__init__中的形参name
#内部帮我们做了一些事:当我在实例化产生对象的时候,会自动调用__init__方法,完成对象的初始化
print(stu1.name)  # zyl

注意：

调用类时发生两件事：

创造一个空对象
自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入

2.2 对象属性查找顺序

先从对象自身的名称空间找，没有就去类中找，类中也没有就报错

2.3 绑定方法

绑定方法就是定义在类内部的方法

如果类来调用：该方法就是一个普通函数，有几个参数就需要传几个参数

如果对象来调用：它就叫对象的绑定方法，第一个参数不需要传，自动传递，自动把对象传过来，在方法内部就可以修改该对象

class Student:
    #变量表示属性
    school='oldboy'
    #__init__ 看好名字,不是__int__
    def __init__(x,name):
        x.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print('%s学会了python'%self.name)

stu1=Student('nick')  # 给对象stu1放属性，name是nick
stu1.study()  # 对象调用绑定方法第一个参数不需要传，自动传递  打印nick学会了python
stu1=Student('李铁蛋')
stu1.study()  # 打印 李铁蛋学会了python

2.4 一切皆对象

python中，字典、列表、字符串...都是对象

类即类型

#类实例化产生对象
ll=list([1,2,3])  #这里list就是一个类，调用就生成一个对象l1
l2=list([5,7,8])  #调用类list生成一个对象l2

#对象调用对象的绑定方法,修改对象自己
ll.append(5)  # append就是类list中的绑定方法，对象l1调用绑定方法，第一个参数就自动传递
print(ll)   # [1, 2, 3, 5]

list.append(ll,9) # 类来调用绑定方法，有几个参数就得传几个
print(ll)  # [1, 2, 3, 5, 9]

2.5 面向对象实例：人狗大战

# 定义狗类
class Dog:
    type_dog = '藏獒'
    def __init__(self,name,attack,hp=100):  # 给对象放属性：姓名，攻击力，血量
        self.name = name
        self.attack = attack
        self.hp = hp

    def bite(self,enemy):  # 绑定方法，咬的方法，给定参数，自身和敌人
        enemy.hp -= self.attack
        print(f'''
        狗的品种:{self.type_dog}
        {self.name}咬了{enemy.name}一口
        {enemy.name}掉血:{self.attack}
        {enemy.name}剩余血量:{enemy.hp}
        ''')

# 定义人类
class Human:
    def __init__(self,name,attack,hp=300):
        self.name = name
        self.attack = attack
        self.hp = hp

    def hit(self,enemy):
        enemy.hp -= self.attack
        print(f"""
        {self.name}击打了{enemy.name}一下
        {enemy.name}掉血:{self.attack}
        {enemy.name}剩余血量:{enemy.hp}
        """)

dog1 = Dog('来福',10,200)  # 生成一个狗类的对象来福
human1 = Human('奥特曼',20,500)  # 生成一个人类对象奥特曼
dog1.bite(human1)  # 调用dog1绑定方法，
human1.hit(dog1)  # 调用human1绑定方法