python面向对象详解

一.面向过程和面向对象

1.面向过程:

• 面向过程注重于解决问题的步骤，根据问题的解决步骤写出解决步骤，这是一个机械式的方法。
• 优点：对复杂的问题进行流程化，使其变得简单。
• 缺点：代码冗余，可扩展性差。

2.面向对象：

• 面向对象编程就是一种有相似功能的函数的集合，其核心就是对象，采取一种上帝思维，在上帝眼里一切皆为对象，也可以创造对象
• 优点：代码重用，减少代码冗余，增加了代码的可读性，可扩展性高
• 缺点：更加的复杂

3.对象

• 类的具体表现形式，类名加上()就是一个实例化过程，就会被实例化一个对象

二.类

1.类结构

• class用来定义一个类
• Person是这个类的类名，类的命名遵循驼峰式。开头字母必须大写，如果是私有类的话开头加个下划线
• 类结构分为：静态属性，动态方法
• 类的本质：就是拥有相同功能和属性的一类事务

class Person():
    salary = 5000   # 第一部分  静态属性 静态变量 静态字段
    dict = {}
    list = []
    def per(self):    # 第二部分 动态属性 方法 函数
        print(22992,"===")

2.用类名来操作
2.1 用类名操作静态属性：

• 使用类名.__dict__方法（查看类中的所有方法，以字典的形式返回）

class Person():    # 类的命名遵循驼峰式   开头字母必须大写  如果是私有类的话开头加个下划线
    salary = 5000   # 第一部分  静态属性 静态变量 静态字段
    dict = {}
    list = []
    def per(self):    # 第二部分 动态属性 方法 函数
        print(22992,"===")


"""查看类中的所有内容"""
print(Person.__dict__)
print(Person.__dict__["salary"])  # 这种方式只能查询，无法增删改

• 万能的点

# 通过万能的点可以对类中的属性进行增删改查
"""查看类中的静态属性"""
print(Person.salary)   # 5000
"""修改静态属性"""
Person.salary = 6000
print(Person.salary,"修改后salary")   # 6000 修改后salary
"""删除静态属性"""
del Person.salary
# print(person.salary,"删除了salary")    报错，没有salary这个属性
"""增加静态属性"""
Person.sex = "女"
print(Person.sex,"新增的属性")  # 女 新增的属性

2.2 用类名操作动态方法（除了特殊的静态方法和类方法使用这种方法操作，其他一般都不用）

class Person():
    salary = 5000 
    dict = {}
    list = []
    def per(self): 
        print(22992,"===")
Person.per(111)   # 22992 ===

3.从对象角度操作类

3.1 对象是类的具体表现形式，类名()就是一个实例化的过程
3.2 实例化一个对象经历的过程：

• 在内存中开辟了一个对象空间
• 自动执行__init__方法，并且将这个内存空间传给self
• 在__init__中通过self给对象空间增加属性

class Person():
    salary = 5000
    dict = {}
    list = []
    def __init__(self,name,sex):
    	# 通过self给这个内存空间增加属性
        self.name = name
        self.sex = sex
        print(self)   # <vueapp.views.Person object at 0x0000022E3A6BA070> 
    def per(self):
        print("这个人叫%s,年龄是%s"%(self.name,self.sex))

"""实例化对象  执行这一步会自动执行__init__方法"""
person = Person("张三",33)
print(person)   # <vueapp.views.Person object at 0x0000022E3A6BA070>  内存空间地址和self一样

3.3 对象操作属性

class Person():
    salary = 5000
    dict = {}
    list = []
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
        print(self)
    def per(self):
        print("这个人叫%s,年龄是%s"%(self.name,self.sex))


"""实例化对象  执行这一步会自动执行__init__方法"""
per = Person("张三",33)



"""查看属性"""
print(per.name)   # 张三
"""修改属性"""
per.name = "李四"
print(per.name,"修改后name")   # 李四 修改后name
"""删除属性"""
# del per.name
# print(per.name,"删除了name属性")
"""增加属性"""
per.sex = "女"
print(per.sex,"新增的属性")  # 女 新增的属性sex
"""查看对象所有的属性"""
print(per.__dict__,"--")   # {'name': '李四', 'age': 33, 'sex': '女'}

3.4 对象操作类方法

class Person():    # 类的命名遵循驼峰式   开头字母必须大写  如果是私有类的话开头加个下划线
    salary = 5000   # 第一部分  静态属性 静态变量 静态字段
    dict = {}
    list = []
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
        print(self)
    def per(self):    # 第二部分 动态属性 方法 函数
        print("这个人叫%s,年龄是%s"%(self.name,self.sex))

"""实例化对象  执行这一步会自动执行__init__方法"""
# 一个类也可以实例化多个对象
per = Person("张三",33) 
"""执行类中的函数per"""
per.per()   # 这个人叫张三,年龄是33

self的含义：self就是类里面方法的第一个参数，解释器会自动的把对象空间传给self，只不过习惯于把第一个参数写为self。

对象查找属性的顺序：先从对象空间找，其次去类空间找，再去父类空间找
类名查找属性的顺序：先本类空间找，再去父类空间找
类名无法查到对象的属性

三.类与类之间的关系

1.依赖关系

• 依赖关系就是把一个类的对象传到另一个类的方法中。

per = Persosn()
car = Car()
per.open(car)  # open为Person类中的一个方法

2.关联关系，聚合关系，组合关系
2.1 关联关系：就像是人和人之间的喜欢一样，这种喜欢可以是相互的，也可以是单方面的。例如学校和老师的关系，公司和员工的关系。
关联关系指的是：一个类实例对象的属性值另一个类的实例对象

class Company():
    def __init__(self,name,address):
        self.name = name
        self.address = address

class Employee():
    def __init__(self,emname,company):
        self.emname = emname
        self.company = company

com = Company("大公司","中关村")
emp = Employee("br",com)
print(emp.company.name)   # 大公司

2.2 聚合关系：属于关联关系的一种特例
2.3 组合关系：属于关联关系的一种特例
3.实现关系