类和对象

目录

• 面向对象
  • 面向对象基础:
  • 面向过程编程:
  • 面向对象编程:
• 类
  • 什么是类
  • 定义类
• 对象
  • 定义方式
  • 名称空间的产生
  • 对象与对象之间的特征与技能一样
  • 第一种
  • 第二种
  • 调用类发生的事情
• 对象与类的查找顺序
  • 顺序
• 对象绑定方法的特殊之处
• python中一切皆对象

面向对象

面向对象基础:

1.什么是面向对象？
指的是一门编程思想。

面向过程编程:

核心是“过程”二字，过程指的是做事情的步骤，即先做什么再做什么
基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。

优点:
逻辑清晰，复杂的问题流程化，进而简单化。
缺点:
可扩展性差。

面向对象编程:

核心是“对象”二字，对象指的是特征与技能的结合体。

基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。

优点:
可扩展性高。
缺点:
编写程序的复杂程度要远高于面向过程编程思想。

类

什么是类

对象是特征与技能的结合体，类是一系列对象相同的特征与技能的结合体

定义类

class 类名:
    对象相同的特征
    对象形同的技能

class:用来定义类的，class后跟的是类名

类名：类的名字，用来调用创造对象的

注意：类名必须要遵守驼峰命名法，python在定义变量与函数时不推荐使用，但是在定义类时推荐使用。

在定义类发生的事情：

​ 1.类在定义时，会产生一个空的名称空间。

​ 2.会把类内部所有的名字，仍进类的名称空间中

​ 注意：类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码

#类.特征或技能的方式对类内部的名字进行修改
#'.'会指向类内部的名称空间，从而获得名字
class OldboyStudent:
    school='oldboy'
    def learn(self):
        print('learn')
#查
print(OldboyStudent.school)#oldboy
#改
OldboyStudent.school='oldgirl'
print(OldboyStudent.school)#oldgirl
#增
OldboyStudent.address='上海'
print(OldboyStudent.address)#上海
#删
del OldboyStudent.address
print(OldboyStudent.address)#type object 'OldboyStudent' has no attribute 'address'

对象

定义方式

类名+（）

名称空间的产生

​ 1.类的名称空间在类定义阶段就已经产生了

​ 2.对象的名称空间，在调用类时就产生了

class OldboyStudent:
    school='oldboy'
    print('oldboy')
    def learn(self):
        print('learn')

stu1=OldboyStudent()#oldboy
print(stu1)#<__main__.OldboyStudent object at 0x000001CC059C1748>
stu1.learn()#learn
print(stu1.school)#oldboy

对象与对象之间的特征与技能一样

解决：在类的内部定义——int——函数

为对像初始化某些属性，init会在调用类时，自动触发该函数

第一种

class OldboyStudent:

    school='oldboy'

    def learn(self):
        print('stu:',self)
        print('learn')

    def choose_course(self):
        print('choose_course')
stu1=OldboyStudent()
stu1.name='ghj'
stu1.age=45
stu1.sex='male'
print(stu1.name,stu1.age,stu1.sex)

第二种

class OldboyStudent:
    def __init__(self,x,y,z):
        # print(self,x,y,z)
        self.x=x
        self.y=y
        self.z=z

    school='oldboy'

    def learn(self):
        print('stu:',self)
        print('learn')

    def choose_course(self):
        print('choose_course')
stu1=OldboyStudent('fsdf',45,'male')
print(stu1.x)

调用类发生的事情

·1.首先会产生一个空的对象，就是产生“对象的名称空间”

2.会自动触发--init--函数

3.会把对象本身已经括号内的参数一并传给--init--函数

总结：调用类会产生一个对像，调用类的过程叫做类的实例化，产生的对象成为类的一个实例

print(OldboyStudent.__dict__)#查看类的名称空间
print(stu1.__dict__)#查看对象的名称空间

对象与类的查找顺序

class OldboyStudent:
    SCHOOL = 'oldboy'
    NAME = 'DDDDDDDD'

    def __init__(self, name, age, sex, school):
        self.name = name
        self.age = age
        self.sex = sex
        self.SCHOOL = school


stu1 = OldboyStudent('小正正', 17, 'male', 'oldgirl')
print(stu1.SCHOOL)#oldgirl

顺序

1.若对象本身有，则优先查找对象自己的

2.若对象本身没有，则去类里面找，若类没有，则报错

对象--》类--》报错

对象绑定方法的特殊之处

类内部的函数主要是给对象用的

​ 1.由类来调用类内部的函数，该函数只是一个普通的函数，普通函数需要接受几个参数就得传入几个参数

​ 2.由对象来调用的称之为对象的绑定方法，不同的对象调用该绑定方法，则会将不同的对象传入该绑定方法种

​ 对象的绑定方法是由对象来调用的，特殊之处就是把对象当作第一个参数传入该方法种

class OldboyStudent:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 特征
    school = 'oldboy'
    # 技能
    def learn(self):  # 普通函数
        # print('stu:', self)
        print('learn python...')

    def choose_course(self, course):  # self =
        print(f'[{self.name}]choose_course {course} ....')
stu1 = OldboyStudent('高凤凤1', 73, 'female')
stu2 = OldboyStudent('高凤凤2', 84, 'male')
stu1.choose_course('python')  # choose_course(self, 'python')
stu2.choose_course('linux')  # choose_course(self, 'python')
#[高凤凤1]choose_course python ....
#[高凤凤2]choose_course linux ....

python中一切皆对象

int,float,str,list,tuple,dict,set,bool
在python中一切皆对象.