关于python:python的面向对象编程

43次阅读

共计 4122 个字符,预计需要花费 11 分钟才能阅读完成。

面向对象:Object Oriented Programming,简称 OOP,即面向对象程序设计。

类 (Class) 和对象(Object)

类是用来形容具备雷同属性和办法对象的汇合。对象是类的具体实例。

比方,学生都有姓名和分数,那么这个姓名和分数就是独特的属性,这时就能够设计一个类,用来记录学生的姓名和问题。

这里解释一下属性和办法

  • 属性:Attribute,用来形容所有对象私有的属性,如学生的姓名和分数。
  • 办法:Method,蕴含在类外面的函数,也叫类函数,区别于类之外的函数,用来实现某些性能,比方打印出学生的姓名和分数。

应用关键词 class 来创立一个类

class Student():
    def __init__(self,name,score):
        self.name = name
        self.score = score    def out(self):
        print("%s:%s"%(self.name,self.score)

以上案例中,只是定义了一个类,电脑并没有创立存储空间。

只有实现类的实例化,能力创立出类的具体的对象,并为之调配存储空间。所以说,对象是类的一个实例。
接下来创立一个对象,只须要增加一下两行代码即可实现

Student1 = Student('Anny','100')
Student2 = Student('Mike','90')

这样一来,Student 是类,student1 和 student2 是创立的这个类的具体的对象。当有以上代码的时候,Python 会主动调用 init 初始自构函数来创立具体的对象。关键字 self 是十分重要的参数,代表创立了函数自身。

当创立了具体的对象之后,就能够应用 Student1.name 和 Student1.score 来别离获取该学生的姓名和分数,也能够间接调用办法 Student1.out()来获取所有信息。

类变量与实例变量

假如当初须要增加一个计数器,每当增加一个学生时计数器就加 1。

这个计数器不属于某一个学生,而是属于类的属性,所以称之为类。

而姓名和分数是属于每个学生的,所以称之为实例变量,也叫对象变量。
失常状况下,这样增加一个计数器

class Student():

    number = 0

    def __init__(self,name,score):
        self.name = name
        self.score = score
        number = number + 1

    def show(self):
        print("%s:%s"%(self.name,self.score))

student1 = Student('Anny',100)
student2 = Student('Mike',90)

print(student1.name)

这里的 number 是类变量,所以将其搁置办法外边,name 和 score 是实例变量,所以将其搁置办法外面。

类变量和实例变量区别很大,拜访形式也不一样。

类变量:class variables,类变量在整个实例化的对象中是专用的,类变量定义在类中,且在函数体外。拜访或者调用类变量的具体方法是类名. 变量名,或者 self.class. 变量名,self.class. 主动返回每个对象的类名。
实例变量:instance variables,定义在函数之内的变量,属于某个具体的对象,拜访或者调用实例变量的办法是对象名. 变量名,或者 self. 变量名。

执行上述代码会发现报错
UnboundLocalError: local variable 'number' referenced before assignment
英语贼差,某道云翻译的:大抵意思是局部变量 number 的援用之前的工作,
所以说,如果要调用属于类的变量 number,则应用 Student.number 或者 self.class.number

批改如下:

class Student():

    number = 0

    def __init__(self,name,score):
        self.name = name
        self.score = score
        Student.number = Student.number + 1

    def show(self):
        print("%s:%s"%(self.name,self.score))

student1 = Student('Anny',100)
student2 = Student('Mike',90)

student1.show()
print(student2.number)

类办法

有些变量只属于类,有些办法也只属于类,不属于具体的对象。不难发现,在属于对象的办法外面都有 self 的参数,比方 init(self)、show(self) 等,而在类中,则应用 cls,与 self 相似,它示意类自身,个别加上 @classmethod 的修饰符以作阐明。

这里应用自定义的类办法来打印学生的数量

class Student():

    number = 0

    def __init__(self,name,score):
        self.name = name
        self.score = score
        Student.number = Student.number + 1

    def show(self):
        print("%s:%s"%(self.name,self.score))    @classmethod
    def people(cls):
        print("一共有 %s 名学生"%Student.number)

student1 = Student('Anny',100)
student2 = Student('Mike',90)

student1.show()
student2.show()
Student.people()

类的公有属性和公有办法

类外面的公有属性和公有办法都是以双下划线__结尾的,公有属性和办法不能在类的内部间接应用或拜访。将 score 变为公有属性,而后 print(Student.score),就会发现报错。然而调用 show 的时候不会报错,这是因为 show 是类外面的函数,所以能够拜访公有变量。

公有办法也是同样的情理,值得注意的是,公有办法必须含有 self 参数并且将其作为第一个参数。

在面向对象的编程中,通常很少让外部类间接拜访类外部的属性和办法,而是向内部提供一些按钮,对其外部的成员进行拜访,以保障程序的安全性,这就叫封装。

@property
    def scores(self):
        print("该学生问题为 %s"%self.score)

加上装璜器之后不必加括号可间接调用。

类的继承

面向对象编程最大的益处就是防止反复的代码,也就是将一段代码重复使用,办法之一就是继承。

先定义一个基类或者父类,再通过 class 类名(父类):pass 创立子类,这样一来,子类取得了父类的所有属性和办法,这种景象就叫做继承。

再写段代码,用 Schoolmember 示意父类,姓名和年龄是所有人的属性,然而老师有工资 (salary) 这个专有属性,学生有分数 (score) 这个专有属性

# 创立父类学校成员 SchoolMemberclass SchoolMember:

    def __init__(self, name, age):
        self.name = name
        self.age = age    def tell(self):
        # 打印个人信息
        print('Name:"{}"Age:"{}"'.format(self.name, self.age), end=" ")# 创立子类老师 Teacherclass Teacher(SchoolMember):

    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age) # 利用父类进行初始化
        self.salary = salary    # 办法重写
    def tell(self):
        SchoolMember.tell(self)
        print('Salary: {}'.format(self.salary))# 创立子类学生 Studentclass Student(SchoolMember):

    def __init__(self, name, age, score):
        SchoolMember.__init__(self, name, age)
        self.score = score    def tell(self):
        SchoolMember.tell(self)
        print('score: {}'.format(self.score))

teacher1 = Teacher("John", 44, "$60000")
student1 = Student("Mary", 12, 99)

teacher1.tell()  # 打印 Name:"John" Age:"44" Salary: $60000student1.tell()  # Name:"Mary" Age:"12" score: 99

通过以上代码不难看出

  • 在创立子类的过程中,须要手动调用父类的构造函数 init 来实现子类的创立。
  • 在子类中调用父类的办法时,需加上父类的类名前缀,且必须带 self 参数变量。例 SchoolMember.tell(self)。
  • 如果子类调用了每个办法或者属性,Python 会先在父类中寻找,找不到就会去子类寻找。

== 在理论的我的项目中,一个子类能够继承多个父类。==

应用 super()关键字调用父类

在子类中能够应用 super 关键字间接调用父类中的属性或者办法,简化代码,也反映出人生苦短,我用 Python 的主旨。

# 创立子类学生 Studentclass Student(SchoolMember):

    def __init__(self, name, age, score):
        SchoolMember.__init__(self, name, age)
        self.score = score    def tell(self):
        super().tell() # 等同于 SchoolMember.tell(self)
        print('score: {}'.format(self.score))

以上的例子中,学生子类调用了父类的 tell 办法,等同于 SchoolMember.tell(self),应用 super 关键字调用时,需去掉括号里的 self。

本次的分享就到这啦,如果对您有帮忙的话,麻烦点个关注再走吧~ 感激浏览。

正文完
 0