10.9 面向对象和类

标签：基于   扩展性   类别   函数   接收   结果   实例   技能   驼峰   

一、面向对象基础

什么是面向对象？

指的是一门编程思想

1.面向过程编程

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

优点：逻辑清晰，复杂的问题流程化，进而简单化。

缺点：可扩展性差，不易修改代码。

2.面向对象编程

核心是’对象‘二字，对象指的是特征与技能的技能的结合体。基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。

优点：可扩展性高，功能独立。

缺点：编写程序的复杂程度要远高于面向过程编程的思想。

优先使用面向过程还是面向对象？--》一起使用。

二、类

什么是类？--》类型、类别、分类。

先定义类，后调用类产生对象。

现实世界中：对象是一个个具体存在的事物，类是由人类文明的发展抽象总结出来的。

程序中：必须遵循，先有类，再有对象。

如何定义类：先从现实世界中，基于一个个对象，抽取出类，再定义类。

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

如何定义类：首先定义类，后调用类创造对象。

定义类的语法：

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

class：用来定义类的，class后跟的是类名。类名用来调用创造对象的。

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

在定义类发生的事情：

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

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

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

相同特征--》类内部的变量

相同技能--》类内部的函数

# 学生类

class OldboyStudent:  #OldboyStudent-->会指向类的名称空间
    #特征
    school='oldboy'
    print('这是特征')

    #技能
    def learn(self):
        print('learn python..')

    def choose_course(self):
        print('choose_coourse..')
        
print(OldboyStudent.__dict__)   #查看类的名称空间内所有名字

print(OldboyStudent.__dict__.get('school')) #oldboy

#改
# OldboyStudent.__dict__['school']='oldgirl'
# print(OldboyStudent.__dict__.get('school'))  #报错

#增
# OldboyStudent.__dict__['address']='SH'
# # print(OldboyStudent.__dict__['address'])  #报错

#删
# del OldboyStudent.__dict__['school']
# print(OldboyStudent.__dict__['school'])  #报错

类.特征或技能的方式对类内部的名字进行修改。"."会指向类内部的名称空间，从而获取名字。

#查
print(OldboyStudent.school)  #oldboy

#改
OldboyStudent.school='oldgirl'
print(OldboyStudent.school)  #oldgirl

#增
# print(OldboyStudent.address) #报错，类OldboyStudent没有属性address
OldboyStudent.address='上海'
print(OldboyStudent.address)

#删
# del OldboyStudent.address
# print(OldboyStudent.address)  #地址已被删除

OldboyStudent.choose_course(123)  #choose_coourse..

三、对象

如何产生对象：

语法：

类名+( )调用类产生对象。

名称空间的产生：

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

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

# 学生类

class OldboyStudent:  # OldboyStudent-->会指向类的名称空间
    # 特征
    school = 'oldboy'
    print('这是特征')

    # 技能
    def learn(self):
        print('learn python..')

    def choose_course(self):
        print('choose_coourse..')
        
stu1=OldboyStudent()  #学生对象1
stu2=OldboyStudent()  #学生对象2
stu3=OldboyStudent()  #学生对象3

print(stu1,stu2,stu3)

print('stu1',stu1.school)
stu1.learn()
stu1.choose_course()
print('stu2',stu2.school)
stu2.learn()
stu2.choose_course()
print('stu3',stu3.school)
stu3.learn()
stu3.choose_course()

运行结果：
这是特征
<__main__.OldboyStudent object at 0x00000000024D0F98> <__main__.OldboyStudent object at 0x00000000024D82E8> <__main__.OldboyStudent object at 0x00000000024D8470>
stu1 oldboy
learn python..
choose_coourse..
stu2 oldboy
learn python..
choose_coourse..
stu3 oldboy
learn python..
choose_coourse..

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

解决：在类内部定义__init__函数，会在调用类时，自动触发该函数。

中文翻译：为对象初始化某些属性。

#学生类
class OldboyStudent:
     #若__init__中有self以外的参数，调用类时必须在括号内传入参数。
     def __init__(self,x,y,z,):  #self-->就是对象本身
         #给对象添加特征的方式：
         self.name=x
         self.age=y
         self.sex=z

     #特征
     school='oldboy'

     #技能
     def learn(self):
         print('learn python...')

     def choose_course(self):
         print('choose_course...')


stu1=OldboyStudent('tank',20,'male')  #学生对象1
stu2=OldboyStudent('nick',21,'male')  #学生对象2
stu3=OldboyStudent('engon',22,'male')  #学生对象3

print(stu1)
print(stu2)
print(stu3)

#给对象添加属性的方式：
print(stu1.name)
print(stu1.age)
print(stu1.sex)
stu1.name='tank'
stu1.age=18
stu1.sex='female'
print(stu1.name,stu1.age,stu1.sex)

运行结果：
<__main__.OldboyStudent object at 0x00000000024E8780>
<__main__.OldboyStudent object at 0x00000000024E87F0>
<__main__.OldboyStudent object at 0x00000000024E8828>
tank
20
male
tank 18 female

调用类发生的事情：

1.首先会产生一个空的对象，就是产生’对象的名称空间‘。

2.会自动触发__init__。

3.会把对象本身以及括号内的参数一并传给__init__函数。

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

#查看类的名称空间
print(OldboyStudent.__dict__)
#查看对象的名称空间
print(stu1.__dict__)  #{'name': 'tank', 'age': 18, 'sex': 'female'}
print(stu1.name,stu1.school)  #tank oldboy

四、对象与类的查找顺序：

class OldboyStudent:
    SCHOOL='oldboy'
    NAME='DDDDD'
    def __init__(self,name,age,sex,school):
        self.name=name
        self.age =age
        self.sex =sex
        self.SCHOOL = school

stu1=OldboyStudent('jeson',17,'female','oldgilr')
print(stu1.SCHOOL)   #oldgilr
print(stu1.NAME)  #DDDDD
print(stu1.AGE)  #报错
print(OldboyStudent.AGE)  #报错

对象与类的查找顺序：

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

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

五、对象绑定方法的特殊之处：

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

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

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

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

class OldboyStudent:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    #特征
    school='oldboy'

    #技能
    def learn(self): #普通函数
        print('learn python...')

    def choose_course(self,course):
        print(f'[{self.name}]choose_course {course}...')


stu1=OldboyStudent('nick',23,'female')
stu2=OldboyStudent('tank',22,'male')

#对象之间与类的功能方法是一样的
OldboyStudent.learn(123)
stu1.learn()
print(OldboyStudent.learn)  #function
print(stu1.learn)
print(stu2.learn)

stu1.choose_course('python')
stu2.choose_course('linux')

运行结果：
learn python...
learn python...
<function OldboyStudent.learn at 0x00000000024F4840>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x00000000024F87F0>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x00000000024F8828>>
[nick]choose_course python...
[tank]choose_course linux...

10.9 面向对象和类

标签：基于   扩展性   类别   函数   接收   结果   实例   技能   驼峰   

原文地址：https://www.cnblogs.com/lidandanaa/p/11643615.html