python面向对象编程

面向过程
Python既支持面向对象编程，也支持面向过程编程。

面向过程中核心是过程二字，过程就是先干什么、在干什么、最后干什么，就是机械式的思维方式

在Python中，面向过程编程是一种按照一定顺序执行步骤的编程风格。它将代码分为一个个函数，每个函数都封装了一个特定的功能。通过函数的调用，按照预定的步骤执行程序，从而实现特定的功能。

面向过程编程的设计思路是将复杂的问题拆解成多个独立的模块，每个模块负责完成特定的任务，这些模块之间相互配合，最终完成整个程序的功能。这种设计思路可以使代码结构更加清晰，易于维护和调试。

下面是一个简单的Python面向过程编程示例，实现了两个函数的调用：

def add(a, b):
    result = a + b
    return result
 
def main():
    num1 = 10
    num2 = 20
    sum = add(num1, num2)
    print("The sum of", num1, "and", num2, "is", sum)
 
if __name__ == "__main__":
    main()
这个示例中，add函数实现了两个数字相加的操作，main函数调用了add函数并将其结果输出。通过这种方式，面向过程编程实现了程序的模块化，提高了代码的可读性和可维护性。

优点：复杂的问题简单化、进而流程化
缺点：扩展性差，牵一发而动全身
应用场景: 一般用在对扩展性要求比较差的情况

面向对象编程
对于面向对象的理解

对象是什么?
    在生活中:
        对象就是'特征'与'技能'的集合体
     在程序中：
        对象就是盛放'数据属性'和'功能'的容器

Python是一种面向对象编程（OOP）语言，支持面向对象的编程方式。在Python的OOP中，一切都是对象。对象可以包括数据属性，方法和类。以下是一些Python OOP的重要概念：

类（Class）：类是一种数据类型，它定义了一组属性和方法，可以创建对象。

对象（Object）：对象是类的一个实例，可以有自己的属性和方法。

属性（Attribute）：属性是指对象的特征，可以是数据属性或方法。

方法（Method）：方法是类中的函数，可以通过对象来调用。

继承（Inheritance）：继承是指一个类（子类）继承另一个类（父类）的属性和方法。

多态（Polymorphism）：多态是指不同类的对象可以对相同的方法做出不同的响应。

封装（Encapsulation）：封装是指将数据和方法包含在一个对象中，只对外部公开必要的接口。

在Python中，我们可以使用class关键字定义类，并通过实例化创建对象。 使用OOP编程的优点是可以提高代码的可读性、可维护性和可重用性，并通过继承和多态使代码更加灵活和可扩展。

优点：扩展性强
缺点：简单的问题复杂化了

类的定义和对象的产生
类：一系列相似的特征和相似的技能的结合体

类（Class）：类是一种数据类型，它定义了一组属性和方法，可以创建对象。

专业语法：
 
 
    函数定义
 
    def index():
        pass
 
 
    类的定义
 
    class Student():
        pass
"""
类（class） 的注意事项1. 关键字使用class来声明
2. class后面写的是类名，类名的命名：一般情况下遵循变量的命名规范即可，类名一般首字母都要大写，（小写也行，但是不推荐）
3. 如果你的类名比较长，推荐使用驼峰法，并且是大驼峰
4. 类名后面的小括号不能省略

# def index():
#     print(123)

类（class）案例—— 定义类

class Student():
 
    school = 'SH'  # 类属性，其实就是变量吗?
 
    def choose_course(stu_dict, course): #类方法
        stu_dict['courses'].append(course)
        print("%s选课成功:%s" % (stu_dict['name'], stu_dict['courses']))
 
    print(123)
 
# 如何查看类的名称空间?
print(Student.__dict__)
 
# 调用类产生对象
stu = Student()
print(stu)
 
# 如何查看对象的名称空间
print(stu.__dict__) # {} 默认情况下调用类会得到一个空对象，其实就是一个空字典
 

"""调用类的过程也是实例化的过程，得到的对象也称为是一个实例"""
定义类发生了哪些事情?
    1. 类一旦定义完成，会立马执行类体代码
    2. 会产生类的名称空间，其实就是一个大字典，然后把类中得名字都丢到类的名称空间去
    3. 把类的名称空间绑定给 类名.__dict__中

定制对象自己独有的属性
默认情况下，调用类产生一个对象，它是一个空对象，没有任何的数据
因此，我们需要给每一个对象添加数据

class Student():
 
    school = 'SH'  # 类属性，其实就是变量吗?
 
    """它有特殊的含义, 在类里面必须叫__init__，然后调用类的时候才会自动触发执行"""
 
    # 类里面一定要有这个方法吗? 不一定，也就是说，你如果需要提前定制对象的属性，你就写这个方法， 如果不需要，就不用写
 

    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        self.name = name  # stu.__dict__['name'] = 'kevin'
        self.age = age  # stu.__dict__['age'] = 18
        self.gender = gender  # stu.__dict__['gender'] = 'male'
        self.courses = course  # stu.__dict__['courses'] = []
   
    # 函数写在类里面就称为是方法
 
    def choose_course(stu_dict, course):
        stu_dict['courses'].append(course)
        print("%s选课成功:%s" % (stu_dict['name'], stu_dict['courses']))
 

 
 
 
 

属性的查找顺序
有类属性、对象自己的属性

1. 显示类属性的查找

class Student():
 
    school = 'SH'
 
stu = Student()
1.1 类属性  增、删、改、查 

# 查
# print(Student.__dict__['school'])
print(Student.school)
 
# 增加
Student.x = 'xxx'
Student.z = 666
print(Student.__dict__)
 
# 改
Student.school = 'BJ'
print(Student.__dict__)
 
# 删除
del Student.school
print(Student.__dict__)
2. 对象自己的属性查找

2.1对象的增删改查

以 stu = Student('kevin', 19, 'male') 为例

# 1. 查
print(stu.name)
print(stu.age)
print(stu.gender)
# print(stu.x)
print(stu.school) 

 
如果你使用的是点语法，那么，对象查找属性的时候，先从对象自己的名称空间中查找，如果找不到，就去产生这个对象的类中查找
 
"""如果你使用的__dict__取值，只能够取到对象自己名称空间中得属性，不会去类中查找"""
 
# print(stu.__dict__['school']) # SH  #### 如果你使用的是点语法，那么，对象查找属性的时候，先从对象自己的名称空间中查找，如果找不到，就去产生这个对象的类中查找
print(stu.__dict__)
 

# 增加
stu.x = 666
# stu1.x = 999
 
 
# 改
stu.x = 888
 
# 删除
# del stu.x
del stu.school
print(stu.__dict__)
 
 练习一下
定义一个类，产生一堆对象，然后定义一个计数器，记录产生了多少个对象
class Student():
    school = 'SH'
    count=0
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        self.count+=1 # self是对象自己
        #这里应用用类属性
        Student.count += 1
 
stu = Student('kevin', 19, 'male')
stu1 = Student('kevin1', 19, 'male')
stu2 = Student('kevin2', 19, 'male')
stu3 = Student('kevin3', 19, 'male')
stu4 = Student('kevin4', 19, 'male')
print(Student.count)
print(stu.count)