python之类与对象

一、面向对象介绍

面向过程：
　　核心是"过程"二字
　　过程是"流水线"，用来分步骤解决问题的
　　过程的终极奥义就是将程序流程化,进而程序设计会变得简单化
　　可扩展性差

​

面向对象：
　　核心是"对象"二字
　　对象是"容器"，用来盛放数据与功能的
　　对象的终极奥义就是将程序"高度整合"
　　类也是"容器"，该容器用来存放同类对象共有的数据与功能
　　提升程序的解耦合程度，进而增加程序的可扩展性
　　设计起来较为复杂

​

程序=数据+功能

通俗理解：程序就是如何存放数据，并且运用相对应的功能对数据进行一系列操作

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

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

学生的功能:

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':'ZJNU',
    'stu_name':'pipi',
    'stu_age':18,
    'stu_gender':'male',
    'tell_stu_info': tell_stu_info,
    'set_info':set_info
}

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

# 课程的数据

course_name='python'
course_period='6mons'
course_score=10

# 课程的功能

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

二、实现面向对象编程

在现实生活中：
　　先找出现实生活中的对象
　　然后总结归纳出现实生活中的类
　　
在程序中：
　　先定义程序中的类
　　后调用类产生程序中的对象（调用类的过程又称为实例化）

语法：

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

    # 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

# 类名.__dict__ 访问到产生的类体代码的名称空间
print(Student.__dict__)  

# 属性访问的语法
# 1、访问数据属性
print(Student.stu_school) # Student.__dict__['stu_school']

# 2、访问函数属性
print(Student.set_info) # Student.__dict__['set_info']

# 3. 属性修改与添加(Student类体代码中 没有如下x数据属性就添加<和类有关>,有则修改<和对象有关>)
Student.x=1111 #Student.__dict__['x']=111
print(Student.__dict__)

# 二：再调用类产生对象
stu1_obj=Student()
stu2_obj=Student()
stu3_obj=Student()

# 因为这三个对象没有定制自己独有的属性, 因此都是空对象
print(stu1_obj.__dict__)
print(stu2_obj.__dict__)
print(stu3_obj.__dict__)

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

# 为对象定制自己独有的属性
# 问题1：代码冗余
# 问题2：属性的查找顺序
stu1_obj.stu_name='pipi'   # 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(stu3_obj.__dict__)


# 解决问题一：
# 解决方案一：
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')

# 解决方案二：
# 一：先定义类
class Student:
    # 1、变量的定义
    stu_school='oldboy'
　　# 在类中使用__init__会在调用阶段执行__init__功能并把参数传入.
    # 空对象,'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


"""
二：再调用类产生对象
调用类的过程又称之为实例化，发生了三件事
1、先产生一个空对象
2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给__init__方法
3、返回初始完的对象
"""
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.__dict__)
print(stu2_obj.__dict__)
print(stu3_obj.__dict__)

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

三、熟悉查找

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)
print(stu2_obj.count)
print(stu3_obj.count)

# 类中存放的是对象共有的数据与功能
# 一：类可以访问：
# 1、类的数据属性
print(Student.stu_school)
# 2、类的函数属性
print(Student.tell_stu_info)
print(Student.set_info)

# 二：但其实类中的东西是给对象用的
# 1、类的数据属性是共享给所有对象用的，大家访问的地址都一样
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='BOY111'
stu1_obj.stu_school='BOY'
print(stu1_obj.stu_school)  # 'BOY'
#
print(Student.stu_school)
print(stu2_obj.stu_school)
print(stu3_obj.stu_school)

# 2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同
# 类调用自己的函数属性必须严格按照函数的用法
print(Student.tell_stu_info)
print(Student.set_info)

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)

拓展：

# 拓展: Python中一切皆为对象,所以我们之前早就接触过
l1 = [1, 2, 3]
l2 = list([1, 2, 3])  # 上面其实就是在调用类list实例化了一个对象l1

# 每个对象下面都可以访问到类"list"中的公共的函数属性, 基于对象的角度我们称之为绑定方法, 且绑定到不同的对象就是不同的绑定方法, 内存地址个不相同
print(l1.append)
print(l2.append)

# 每个实例化出来的对象都是独立的个体, 因此我们往l1对象中添加值, 并不会影响到l2
l1.append(4)
print(l1)  # [1, 2, 3, 4]
print(l2)  # [1, 2, 3]

# Python3中"类"与"类型"是一个概念
print(type(li1))  # <class 'list'>
print(type(li2))  # <class 'list'>