Python高级编程之面向对象

一、概述

成都创新互联专注于綦江企业网站建设,自适应网站建设,商城网站建设。綦江网站建设公司,为綦江等地区提供建站服务。全流程定制网站,专业设计,全程项目跟踪,成都创新互联专业和态度为您提供的服务

科班出身的同学应该学过C语言、C++或者Java,编程语言一般分为两种设计方式:面向过程编程、面向对象编程,早期的编程语言多数是面向过程的,像C语言就是面向过程编程,面向过程由多个过程组合在一起,也可以理解为函数编程,而Python在设计的时候就是一种面向对象编程的语言,其实python把面向对象简化了很多,如果学过java的同学再来学习python面向对象就会感觉非常简单。所以本篇文章就让我带着大家来学习一下什么是面向对象编程。

二、面向对象的概念介绍

类(Class)——用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类方法——类中定义的函数。

类属性——属性就是类变量。

方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

实例变量——在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。

继承——即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。

实例化——创建一个类的实例,类的具体对象。

对象——通过类定义的数据结构实例。对象包括两个数据成员:属性和方法。

对象可以分为两个部分:一部分称为属性(变量),一部分称为行为(方法)。

1)类定义

语法格式如下:

class ClassName:
    
    .
    .
    .
    

示例如下:

#!/usr/bin/python3
 
class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为:", x.i)
print("MyClass 类的方法 f 输出为:", x.f())

2)类属性

python类属性分为:私有属性和公开属性,python是没有什么修饰符的,像java就分的更细致,通过private(私有级)、protected(受保护级)、无前缀(默认级)、public(公开级)控制权限。

  • 私有属性(__private_attrs):两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
  • 公开属性(private_attrs):不带两个下划线开头,可以在类外访问,通过实例名访问,也可以在类中访问。

示例如下:

#!/usr/bin/python3
 
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错,实例不能访问私有变量

3)类方法

类方法也是分为:私有方法和公开方法,但是私有变量属性一把通过set/get公开方法操作。示例如下:

class Parents(object):
    __name = "test"
    __age = 35
    
    # 设置姓名
    def set_name(self, name):
        self.__name = name
    
    # 获取姓名
    def get_name(self):
        return self.__name
        
    # 设置年龄
    def set_age(self, age):
        self.__age = age
    
    # 获取年龄
    def get_age(self):
        return self.__age

if __name__ == "__main__":
    # 实例化
    p = Parents()
    # 调用公有方法去设置属性
    p.set_age(30)
    # 获取私有属性
    print(p.get_age())
    
    # 调用公有方法去设置属性
    p.set_name("zhangsan")
    # 获取私有属性
    print(p.get_name())

【温馨提示】self 的名字并不是固定的,也可以使用 this,但是最好还是按照约定使用 self。

4)构造方法(init)

init : 构造函数,在生成对象时调用。

示例如下:

class Parents(object):
    __name = "test"
    __age = 35
    
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    
    # 设置姓名
    def set_name(self, name):
        self.__name = name
    
    # 获取姓名
    def get_name(self):
        return self.__name
        
    # 设置年龄
    def set_age(self, age):
        self.__age = age
    
    # 获取年龄
    def get_age(self):
        return self.__age

if __name__ == "__main__":
    # 实例化
    p = Parents(25, "lisi")
    # 获取私有属性
    print(p.get_age())
    # 获取私有属性
    print(p.get_name())

不单单有构建函数,还有其它专有的函数,都是自动去调用的:

  • __init__ : 构造函数,在生成对象时调用
  • __del__ : 析构函数,释放对象时使用
  • repr : 打印,转换
  • setitem : 按照索引赋值
  • getitem: 按照索引获取值
  • len: 获得长度
  • cmp: 比较运算
  • call: 函数调用
  • add: 加运算
  • sub: 减运算
  • mul: 乘运算
  • truediv: 除运算
  • mod: 求余运算
  • pow: 乘方

三、面向对象封装、继承和多态

面向对象编程有三大特点:封装、继承和多态。

1)封装

就是将一个类的属性、方法全部包装到了一个类中。一般设置属性为私有的,通过方法去调用,当然有些方法只需要在类内部使用也是可以设置成私有的方法的,通过公开的方法来供外部间接调用这些“封装”好的属性和方法,这就是封装。

其实上面的示例就是很好的证明,内部定义私有属性,外部通过公开的方法访问。

class Parents(object):
    __name = "test"
    __age = 35
    
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    
    # 设置姓名
    def set_name(self, name):
        self.__name = name
    
    # 获取姓名
    def get_name(self):
        return self.__name
        
    # 设置年龄
    def set_age(self, age):
        self.__age = age
    
    # 获取年龄
    def get_age(self):
        return self.__age

if __name__ == "__main__":
    # 实例化
    p = Parents(25, "lisi")
    # 获取私有属性
    print(p.get_age())
    # 获取私有属性
    print(p.get_name())

2)继承

继承就非常好理解了,其实通过字面意思理解就行了,一个类是另一个类的子类,那么这个类就可以拥有和父类一样的属性、方法。这就好比是现实当中,儿子继承父母的遗产一样。但是需要注意的是私有属性和私有方法是无法继承的,其它语言也是一样的。

在Python中,所有类默认继承object类,object类是顶级类或基类;其他子类叫做派生类。

示例如下:

class Animal(object):
    # 无法给继续子类
    __name = ""
    # 可以继承给子类
    color = ""

    def __init__(self, name, color):
        self.__name = name
        self.color = color

    # 可以继承给子类
    def set_name(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

    def set_color(self, color):
        self.color = color

    # 无法给继续子类
    def __get_color(self):
        return self.color

class Cat(Animal):
    def __init__(self, name, color):
        self.name = name
        self.color = color
        # 调用父类构造函数
        super(Cat, self).__init__(name, color)
        # Animal.__init__(name, color)

    # 重写父类方法
    def set_name(self, name):
        self.name = name

    # 重写父类方法
    def get_name(self):
        return self.name

if __name__ == "__main__":
    c = Cat("小猫", "黑色")
    # 获取父类公开属性
    print(c.color)

    # 调用子类方法重写的方法
    c.set_name("大猫")

多继承:所谓多继承意思就是一个类同时继承了多个父类

示例如下:

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类,多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s,我是一个演说家,我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同,默认调用的是在括号中参数位置排前父类的方法

3)子类重新方法和super()调用父类方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   # 重新父类方法
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

4)多态

多态首先是建立在继承的基础上的,先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法,即父类同一个方法,在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。

示例如下:

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def print_age(self):
        print("%s's age is %s" % (self.name, self.age))

class Man(Person):
    def print_age(self):
        print("Mr. %s's age is %s" %(self.name, self.age))
class Woman(Person):
    def print_age(self):
        print("Ms. %s's age is %s" %(self.name, self.age))

def person_age(person):
    person.print_age()

if __name__ == "__main__":
    person = Person("kevin", 23)
    man = Man("Bob", 33)
    woman = Woman("Lily", 28)
    person_age(person)
    person_age(man)
    person_age(woman)

【总结】其实多态也很好理解,就是将不同的对象传到相同的函数,表现不同的形态,这就是多态。

名称栏目:Python高级编程之面向对象
URL网址:http://www.mswzjz.com/qtweb/news18/161568.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联