码迷,mamicode.com
首页 > 其他好文 > 详细

10.9 面向对象和类

时间:2019-10-09 19:03:35      阅读:68      评论:0      收藏:0      [点我收藏+]

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

一、面向对象基础

什么是面向对象?

指的是一门编程思想

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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!