面向对象编程与类

目录

• 面向对象编程
• 1 面向对象编程思想的定义
  • 1.1面向过程
  • 1.2 面向对象
  • 1.3 理解
• 2 类
  • 2.1 类的定义
  • 2.2 类的语法
  • 2.3 类的使用
    • 2.3.1 调用类会产生对象
    • 2.3.2 为对象定制自己独有的属性
    • 2.3.3 总结
    • 2.3.4 应用实例
  • 2.4 类中数据与功能的对比

面向对象编程

1 面向对象编程思想的定义

之前我们学习了面向过程编程的思想，现在可以两个对比着看

1.1面向过程

面向过程的核心是"过程"二字
面向过程的终极奥义就是将程序流程化
面向过程就是"流水线"制造，直接分步骤 解决问题

1.2 面向对象

面向对象核心是"对象"二字
面向对象的终极奥义就是将程序"整合"
对象是"容器"，用来盛放数据与功能的
类也是"容器"，该容器用来存放同类对象共有的数据与功能

1.3 理解

代码总体都是由数据与功能组成的，可以简单理解为变量与函数

程序=数据+功能

学生的容器=学生的数据+学生的功能
课程的容器=课程的数据+课程的功能

以化妆品为例：

粉底、眼影 >原材料=>数据
眉笔、小刷子 ====>工具 =====>功能

# 未分类时各种数据与功能混合在一起，较为混乱，当代码量大时更为严重

# 学生的数据
stu_name='egon'
stu_age=18
stu_gender='male'

# 学生的功能
def tell_stu_info():
    print('学生信息：名字：%s 年龄：%s 性别：%s' %(stu_name,stu_age,stu_gender))

def set_info():
    stu_name='EGON'
    stu_age=19
    stu_gender='female'


# 课程的数据
course_name='python'
course_period='6mons'
course_score=10

# 课程的功能
def tell_coure_info():
    print('课程信息：名字：%s 周期：%s 学分：%s' %(course_name,course_period,course_score))

优化方式：

1. 将同类型相关的数据和功能写入另一个文件，按分文件分类（使用模块的方式）

   缺点：导致文件过多，处理较复杂

2. 将同类型相关的数据和功能放入容器类型，如列表，字典

   缺点：无法将函数的定义部分放入容器，且数据多时代码冗余

总结：文件太大，字典太小

我们需要一种适中的形式存放------>类

# 优化方法二：字典存放
# 明显能看到学生数量多时还会产生代码冗余问题
# 学生的功能
def tell_stu_info(stu_obj):
    print('学生信息：名字：%s 年龄：%s 性别：%s' %(
        stu_obj['stu_name'],
        stu_obj['stu_age'],
        stu_obj['stu_gender']
    ))

def set_info(stu_obj,x,y,z):
    stu_obj['stu_name']=x
    stu_obj['stu_age']=y
    stu_obj['stu_gender']=z

stu_obj={
    'stu_school':'oldboy',
    'stu_name':'egon',
    'stu_age':18,
    'stu_gender':'male',
    'tell_stu_info': tell_stu_info,
    'set_info':set_info
}

stu1_obj={
    'stu_school':'oldboy',
    'stu_name':'lili',
    'stu_age':19,
    'stu_gender':'female',
    'tell_stu_info': tell_stu_info,
    'set_info':set_info
}

2 类

2.1 类的定义

类就是python为使用者提供的支持面向对象编程的解决方案

类是对象们 相似数据与功能 的集合体
所以类体中最常见的是变量与函数的定义，但是类体其实是可以包含任意其他代码的
注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间

2.2 类的语法

class 类名：

​ 在其类体中写相同的数据与功能

注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间

class Student:
    # 1、变量的定义
    stu_school='oldboy'

    # 2、功能的定义
    def tell_stu_info(stu_obj):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    def set_info(stu_obj,x,y,z):
        stu_obj['stu_name']=x
        stu_obj['stu_age']=y
        stu_obj['stu_gender']=z

    print('========>')

print(Student.__dict__)
# 可以通过__dict__方法查看类中含有的名字，值

# 属性访问的语法
# 1、访问数据属性
print(Student.stu_school) # 相当于Student.__dict__['stu_school']
# 2、访问函数属性
print(Student.set_info) # 相当于Student.__dict__['set_info']

Student.x=1111 # 相当于Student.__dict__['x‘]=111
print(Student.__dict__)	# 能看到类的字典中多了x：111

2.3 类的使用

2.3.1 调用类会产生对象

注意：不会和函数一样执行函数体代码，类体代码只在定义阶段执行一次

stu1_obj=Student()
stu2_obj=Student()
stu3_obj=Student()


print(stu1_obj.__dict__)	# {}这里存放的时对象独有的属性，此处为空，还未放入属性
print(stu2_obj.__dict__)	# {}
print(stu3_obj.__dict__)	# {}

2.3.2 为对象定制自己独有的属性

和字典一样，对其添加值dict[key] = value

python提供了 对象+点+key=value 的简单语法，效果与上面一样

stu1_obj.stu_name='egon'   # stu1_obj.__dict__['stu_name']='egon'
stu1_obj.stu_age=18        # stu1_obj.__dict__['stu_age']=18
stu1_obj.stu_gender='male' #  stu1_obj.__dict__['stu_gender']='male'
print(stu1_obj.__dict__)

stu2_obj.stu_name='lili'
stu2_obj.stu_age=19
stu2_obj.stu_gender='female'
print(stu2_obj.__dict__)

stu3_obj.stu_name='jack'
stu3_obj.stu_age=20
stu3_obj.stu_gender='male'
print(stu2_obj.__dict__)

问题1：代码重复
问题2：属性的查找顺序

# 解决问题一：
# 解决方案一：缺点：该函数在类外部，没放入类
def init(obj,x,y,z):
    obj.stu_name=x
    obj.stu_age=y
    obj.stu_gender=z

init(stu1_obj,'egon',18,'male')
init(stu2_obj,'lili',19,'female')
init(stu2_obj,'jack',20,'male')

# 解决方案二：在类中定义__init__，使实例化时直接进行初始化
# __init__函数会在调用类时执行，第一个形参不用传参
class Student:
    # 1、变量的定义
    stu_school='oldboy'

    # 空对象,'egon',18,'male'
    def __init__(obj,x,y,z):
        obj.stu_name=x # 空对象.stu_name='egon'
        obj.stu_age=y  # 空对象.stu_age=18
        obj.stu_gender=z # 空对象.stu_gender='male'
        # return None

    # 2、功能的定义
    def tell_stu_info(stu_obj):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    def set_info(stu_obj,x,y,z):
        stu_obj['stu_name']=x
        stu_obj['stu_age']=y
        stu_obj['stu_gender']=z

    # print('========>')

# 注意：使用Student.__init__()时要传入第一个形参，而调用类时不需要传入
stu1_obj=Student('egon',18,'male') # Student.__init__(stu1,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')

print(stu1_obj.__dict__)
print(stu2_obj.__dict__)
print(stu3_obj.__dict__)

2.3.3 总结

调用类的过程又称之为实例化，发生了三件事
1、先产生一个空对象
2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给__init__方法
3、返回初始完的对象

总结__init__方法
1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在
   类调用时就立刻执行的代码都可以放到该方法内
3、__init__方法必须返回None

查找顺序:
对象-----先从对象本身找变量或功能，如果不存在再从类中寻找

2.3.4 应用实例

如果想对产生的对象数量进行计数，我们应该在类中定义count，而不能在对象中定义，

因为在对象中定义count，该count为对象的独有属性，无法共享，进行计数

class Student:
    # 1、变量的定义
    stu_school='oldboy'
    count=0

    # 空对象,'egon',18,'male'
    def __init__(self,x,y,z):
        Student.count += 1

        self.stu_name=x # 空对象.stu_name='egon'
        self.stu_age=y  # 空对象.stu_age=18
        self.stu_gender=z # 空对象.stu_gender='male'
        # return None

    # 2、功能的定义
    def tell_stu_info(self):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            self.stu_name,
            self.stu_age,
            self.stu_gender
        ))

    def set_info(self,x,y,z):
        self.stu_name=x
        self.stu_age=y
        self.stu_gender=z

    def choose(self,x):
        print('正在选课')
        self.course=x

stu1_obj=Student('egon',18,'male') # Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')

print(stu1_obj.count)	# 3
print(stu2_obj.count)	# 3
print(stu3_obj.count)	# 3

2.4 类中数据与功能的对比

相同点：调用语法

# 1、类的数据属性
print(Student.stu_school)
# 2、类的函数属性
print(Student.tell_stu_info)
print(Student.set_info)

类中的数据与方法是提供给对象使用的

不同点：数据为共享，功能为绑定

# 类的数据属性是共享给所有对象用的，各对象访问的地址都一样
print(id(Student.stu_school))
print(id(stu1_obj.stu_school))
print(id(stu2_obj.stu_school))
print(id(stu3_obj.stu_school))

Student.stu_school='OLDBOY'
# 注意：修改类中的变量，各个对象中的变量会跟着改变
stu1_obj.stu_school='OLDBOY'
# 注意：修改某一对象中的变量，各个对象中的变量不会跟着改变
print(stu1_obj.stu_school)
print(Student.stu_school)
print(stu2_obj.stu_school)
print(stu3_obj.stu_school)

# 类中定义的函数给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同

# 类调用自己的函数属性必须严格按照函数的用法来
Student.tell_stu_info(stu1_obj)
Student.tell_stu_info(stu2_obj)
Student.tell_stu_info(stu3_obj)

Student.set_info(stu1_obj,'EGON',19,'MALE')
Student.tell_stu_info(stu1_obj)

# 绑定方法的特殊之处在于：谁来调用绑定方法就会将谁当做第一个参数自动传入
print(Student.tell_stu_info)
print(stu1_obj.tell_stu_info)
print(stu2_obj.tell_stu_info)
print(stu3_obj.tell_stu_info)

stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj)
stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)


stu1_obj.choose('python全栈开发')
print(stu1_obj.course)

stu2_obj.choose('linux运维')
print(stu2_obj.course)

stu3_obj.choose('高级架构师')
print(stu3_obj.course)


# list中的	使用绑定关系的函数	  与		类直接使用函数
l1=['aa','bb','cc'] # l=list([1,2,3])
l2=[111,222,333] # l=list([1,2,3])
print(l1.append)
print(list.append)

l1.append('dd')
l2.append('dd')
print(l1)
print(l2)

list.append(l1,'dd')
list.append(l2,'dd')
print(l1)
print(l2)

使用面向对象编程思想会对可扩展性有显著提升
但软件质量并非只有可扩展性！不是处处都应使用面向对象编程思想