python笔记六：面向对象编程（OOP）——类和对象

最新推荐文章于 2024-09-05 08:49:27 发布

奶油花生果酱

最新推荐文章于 2024-09-05 08:49:27 发布

阅读量296

点赞数

本文链接：https://blog.csdn.net/qq_41518266/article/details/86514198

版权

一、面向过程和面向对象

1.面向过程：

过程，即步骤，面向过程即找到要完成这个任务所需要的步骤（流水线思维），用函数将这些步骤一一实现，然后依次调用这些函数

2.面向对象：

收到一个任务，首先找到这个任务世界的构成，即对象，然后想到各个对象要具有的属性和行为，然后各对象去完成相应的行为

二、类和对象

1.类：抽象名词，具有相同特征的一类事物的集合（人、狗、猫）

2.对象：具体的事物，单个个体（同桌小明，小狗阿黄）

3.实例化：类---->对象的过程

4.类中的内容：

表明事物的特征，叫做属性（变量）
表明事物的功能或动作，叫做成员方法（函数）

三、类的实现

1.类的命名：

-遵守变量命名规范

-大驼峰：（单词跟单词直接相连，每个单词首字母大写）

-尽量避开和系统命名相似的命名

2.声明类：

-必须用class关键字

-类由属性和方法构成，其他不允许

-成员属性定义可以直接使用变量赋值，如果没有，允许使用None

class SduStudent():  #定义一个类,来表示学生
    name = None    #用None来给不确定的值赋值
    age = 18
    course = 'python'

    def doHomework(self):   #系统默认一个self参数
        print("I'm doing my homework")
        return None   #推荐在函数末尾使用return语句

liu = SduStudent()  #实例化一个叫liu的学生，是一个具体的对象
print(liu.name)
print(liu.age)
liu.doHomework()  #注意成员函数的调用没有传递进去参数

3.类和对象的成员关系

类的属性和对象属性在不对对象属性赋值的前提下指向同一个变量

print(id(SduStudent.age))
print(id(liu.age))

对象访问一个成员时，如果对象中没有该成员，尝试访问类中的同名成员，如果对象中有此成员，一定访问对象中的成员
创建对象时，类中的成员不会放入对象中，而是会得到一个空对象，没有成员
通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员

print(liu.__dict__)
print(SduStudent.__dict__)

liu.name='hhh'
print(liu.__dict__)

4.关于self

self在对方方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数中
self并不是关键字，理论上可以用任何一个普通变量名代替

class SduStudent():  #定义一个类,来表示学生
    name = None    #用None来给不确定的值赋值
    age = 18
    course = 'python'

    def say(self):   #系统默认一个self参数
        self.name='sshhh'
        self.age=20
        print('my name is {}'.format(self.name))
        print('my age is {0}'.format(self.age))
        print(id(self.name))
        return None   #推荐在函数末尾使用return语句

    def sayAgain(s):   #self不是关键字，换成其他变量名也可以
        print('my name is {}'.format(s.name))
        print('my age is {0}'.format(s.age))
        print(id(s.name))

print(id(SduStudent.name))   
liu=SduStudent()
print(id(liu.name))   #输出结果与id(SduStudent.name)一样，说明在不改变对象成员的前提下，类和对象指向同一个变量
liu.say()
print(id(liu.name))
liu.sayAgain()    #输出与liu.say()一样说明把liu传入了self，把liu传入了s

方法中有self形参的方法叫非绑定类方法，可以通过对象访问；没有self是绑定类方法，只能通过类访问

class SduStudent():  #定义一个类,来表示学生
    name = None    #用None来给不确定的值赋值
    age = 18
    course = 'python'

    def say(self):   #系统默认一个self参数
        self.name='sshhh'
        self.age=20
        print('my name is {}'.format(self.name))
        print('my age is {0}'.format(self.age))
        return None   #推荐在函数末尾使用return语句

    def sayAgain():
        print('hello world')

liu=SduStudent()
liu.say()
SduStudent.sayAgain()   #liu.sayAgain()会报错

使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__成员名来访问

class SduStudent():  #定义一个类,来表示学生
    name = 'hhh'   #用None来给不确定的值赋值
    age = 18

    def say(self):   #系统默认一个self参数
        self.name='sshhh'
        self.age=20
        print('my name is {}'.format(self.name))
        print('my age is {0}'.format(__class__.age))  #########可以访问类中的成员
        return None   #推荐在函数末尾使用return语句

    def sayAgain():
        print(__class__.name)   ###########可以访问类中的成员
        print(__class__.age)

liu=SduStudent()
liu.say()
SduStudent.sayAgain()   #liu.sayAgain()会报错

鸭子模型：不管对方是不是鸭子，只要它具有鸭子的属性（嘎嘎叫，会游泳...）就认为对方是鸭子

class A():
    name = 'aaa'
    age = 18

    def __init__(self):
        self.name = 'init aaa'
        self.age = 80

    def say(self):
        print(self.name)
        print(self.age)

class B():
    name = 'bbb'
    age = 20

a=A()  #实例化A为a
a.say()
print('*'*20)

#A.say()   #会报错，TypeError，缺少参数，不会把A当参数传进去，只有是实例化对象时才会把a当参数传进去

A.say(a) #手动把a作为参数传进去
print('*'*20)

A.say(A)  #把A当参数传进去，理论上只要有name和age作为成员变量就不会报错
print('*'*20)

A.say(B)  #传入的是类实例B，因为B具有name和age属性，所以不会报错