正文 

当前位置： 首页 > 技术 > java教程

python之面向对象(代码片段)

author author     2022-11-29     210

关键词：

首先我们应该知道，python在设计之初就已经是一门面向对象的语言，所以说python中创建一个类和对象是很容易的。

面向对象的技术简介

  • 类（class）:用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不做实例变量使用。
  • 数据成员：类变量或者实例变量用于处理类及实例对象的相关数据。
  • 方法重写：如果从父类继承的方法不能够满足子类的需求，可以对其进行改写，这个过程的方法叫覆盖，也称方法的重写。
  • 实例变量：定义在方法中的变量，只用于当前实例中的类。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
  • 实例化：创建一个类的实例，类的具体对象。
  • 方法：类中定义的函数。
  • 对象：通过类中定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

创建类

创建类，class是关键字，就好比函数中的def 一样。基本格式如

class ClassName:
    def 函数名(self):
        pass
obj = ClassName()
obj.函数名() #执行

创建类中，函数后面的self是必写的参数，相当于传的对象，而obj此时代表的就是一个对象。例如一个简单实例

class foo:
    def f(self, args):

        return args
s = foo()
ret = s.f("你很帅")
print(ret)

面向对象的三大特性：封装、继承、多态

封装

就是把内容封装在某处，日后好调用。首先看一个例子

class foo:
    def f(self,args):
        print(self.name, self.age, self.gender,args)
z = foo()
z.name = "flash"
z.age = 18
z.gender = "man"
z.f("你很帅")

#这种也能实现封装的功能，但是会传很多参数，显得比较low

其实在类中有种自带的特殊的方法：构造方法，这让我们实现封装会比较方便和美观了。如

class Person:
    def __init__(self, name, age):
        self.n = name
        self.a = age
    def foo(self):
        print(self.n, self.a)

flash = Person("Flash",20)
flash.foo()

#注：此时的__init__是构造方法，他会根据类创建的时候自动执行。

继承　　

和现实中的继承类似，都是子类继承父类。继承中默认是全部继承过来，但也可以只继承优点。首先看一个全部继承的例子。

技术分享 
class Father:
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")

class Son(Father):
    def sink(self):
        print("la")

obj = Son()
obj.sink()
obj.eat()
obj.drink()
全部继承

有时我们不想全部继承，这是我们只需要修改一下就行

技术分享 
class Father:
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")

class Son(Father):
    def drink(self):
        print("la")
        super(Son, self).drink()#执行父类中的drink的方法
obj = Son()
obj.drink()
部分继承

那么问题来了，如果一个子类有两个父类，每个父类又各有自己的父类，他们的父类又有相同父类怎么办？

在python中遵循先左后右，一条道走到黑，有相同父类时，父类最后执行的原则。

技术分享

例如下面这个例子

技术分享 
class base:
    pass
class F2(base):
    def a(self):
        print("f2.a")
        self.b()
    def b(self):
        print("f2.b")
class F3(F2):
    def b(self):
        print("f3.b")
class Son(F3,F2):
    pass

obj = Son()
obj.a()
多继承

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
 

类成员的字段和方法

应用场景

如果对象中需要保存一些值，执行某功能时，需要使用对象中的值　－＞　普通方法
不需要任何对象中的值，静态方法

字段

  • 普通字段：保存在对象中，执行只能通过对象访问。
  • 静态字段：保存在类中，  执行 可以通过对象访问 也可以通过类访问。

方法

  • 普通方法，保存在类中，由对象来调用，self=》对象
  • 静态方法，保存在类中，由类直接调用
  • 类方法，保存在类中，由类直接调用，cls=》当前类

属性

按方法的方式去定义，按字段的模式去调用

例如

技术分享 
class provice:
    country = "中国" #静态字段属于类
    def __init__(self,n):
        self.name = n #普通字段属于对象 henan
        print(self.name)

henan = provice("河南")
print(provice.country)
henan.name
字段
技术分享 
class Foo:
    def f1(self): #普通方法
        print(123)

    @staticmethod #静态方法
    def sta():
        print(1,2)

    @classmethod #类方法
    def classmd(cls):
        print("a,b")

    @property #属性
    def per(self):
        print("aaa")
obj = Foo()
obj.f1()

Foo.sta() #调用静态方法,不用创建对象

Foo.classmd() #调用类方法

obj1 = Foo() #调用属性
obj1.per
方法

例如用常用的property属性求分页的问题

技术分享 
class Paragnation:
    def __init__(self,page):
        try:
            p = int(page)
        except Exception as e:
            p = 1
        self.page = p
    @property
    def start(self):

        p = (self.page -1) * 10
        return p
    @property
    def end(self):

        p = self.page * 10
        return p
li = []
for i in range(1000):
    li.append(i)
while True:
    p = input("请输入页码：")
    obj = Paragnation(p)
    print(li[obj.start:obj.end])
property

 成员修饰符

  • 共有成员
  • 私有方法

其中私有成员的表示方法为：双下划线+字段名（__字段名）

私有成员外部不能访问，外部若访问，只能通过类里面的方法间接访问。例如

技术分享 
class F:
    def __init__(self):
        self.__age = 18
    def Show(self):
        return self.__age

class S(F):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
        super(S, self).__init__()


    def show(self):
        print(self.name)
        # print(self.__age) #子类不能继承到父类的私有变量，否则会报错，如果要继承可以通过父类的共有方法间接访问
        print(self.gender)

P = S("flash","男")
P.show()
r = P.Show()
print(r)
私有方法

注：子类继承不了父类的私有方法，也就是说，在子类中不能直接访问父类的私有方法，只能通过父类的方法间接去访问。

python中常见的特殊成员

__init__     类()自动执行
    __del__     del 对象[222]
    __call__     对象()  类()() 自动执行
    __int__      int(对象) 
    __str__      str()
    
    __add__     #对象的封装的加法
    __dict__     # 讲对象中封装的所有内容通过字典的形式返回
    __getitem__  # 切片（slice类型）或者索引
    __setitem__
    __delitem__
    
    __iter__
                # 如果类中有 __iter__ 方法，对象=》可迭代对象
                # 对象.__iter__() 的返回值： 迭代器
                # for 循环，迭代器，next
                # for 循环，可迭代对象，对象.__iter__()，迭代器，next
                # 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
                # 2、循环上一步中返回的对象

异常处理　　

常用语数据库处理

主要语法块

try:
    自定义内容
except Exception as e:
    print("消息")

下面列出几种常见模式

try:
    i = int(input("输入>>>>"))

except IndexError as e:
    print("IndexError", e)
except ValueError as e:
    print("ValueError",e)
except Exception as e:
    print("Exception",e)
else:
    print(i)
finally:
    print("success")
技术分享 
class Foo(Exception):
    def __init__(self,msg):
        self.message = msg

    def __str__(self):
        return self.message
try:
    raise Foo("I‘m error")
except Foo as e:
    print(e)
自定义模块

反射

技术分享 
class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def show(self):
        print("%s-%s" % (self.name, self.age))

obj = Foo("flash", 18)
# print(obj.name)

func = getattr(obj, "name")
print(func)
func1 = getattr(obj, "show")
print(func1())

print(hasattr(obj, "name"))

setattr(obj, "gender", "man")
print(obj.gender)

delattr(obj, "name")
obj.name
例子

单例模式

技术分享 
class Foo:
    V = None

    @classmethod
    def func(cls):
        if cls.V:
            return cls.V
        else:
            cls.V = Foo()
            return cls.V

obj = Foo.func()
print(obj.V)
print(obj)
obj1 = Foo.func()
print(obj1)
例子

 

　　

python之面向对象(代码片段)

首先我们应该知道，python在设计之初就已经是一门面向对象的语言，所以说python中创建一个类和对象是很容易的。面向对象的技术简介类（class）:用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有... 查看详情

学习python之面向对象(代码片段)

学习Python之面向对象python面向对象1.类的定义2.类的实例化3.调用类中的实例方法4.使用实例变量5.类与对象6.类的构造函数7.类变量与实例变量(1).理解类变量与实例变量(2).类变量和实例变量的查找顺序无继承单继承多继承(3).`__... 查看详情

python之面向对象(代码片段)

father类classfather(object):def__init__(self,name,age):self.__privateFatherAge=age;self.publicFatherName=name;#定义共有属性name和私有属性__privateFatherAge=44;publicFatherName='feige';#私有方法访问共有属性def__priv 查看详情

python基础之面向对象基本概念(代码片段)

面向过程和面向对象概念过程和函数：过程类似于函数，只能执行，但是没有返回结果；函数不仅能执行，还能返回结果。面向过程和面向对象基本概念面向过程-怎么做把完成某一个需求的所有步骤从头到尾逐步实现；根据开... 查看详情

python面向对象之多态(代码片段)

多态第一阶段：判断一个变量是否是某个类型可以用isinstance()判断classAnimal(object):defrun(self):print("Animalisrunning")classDog(Animal):defrun(self):print("Dogisrunning")classCat(Animal):defrun(self):print 查看详情

python3之面向对象编程理解(代码片段)

...义类语classAnimal():class为定义类的关键字，后面跟名字():python命名规范建议:类一般首字母单词大写，属性变量，函数首单词字母小写定义一个类叫Animal,相关代码:classAnimal():##类里定义的属性称为类属性count=0##构造函数,实例化的时... 查看详情

python学习笔记之面向对象(代码片段)

一、面向过程VS面向对象 编程范式   编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路... 查看详情

python基础之面向对象2（封装）(代码片段)

一、封装定义：　　　二、作用　　三、私有成员：　　1、基本概念及作用　　　　　　2、__slots__手段私有成员：　　　　　　3、@property属性手段私有成员：　　　　 四、基础示例代码　　1、用方法封装变量　　　　"""... 查看详情

python数据结构之面向对象(代码片段)

💫在python数据结构的上一章节我们讲述了python的输入输出、控制、异常，希望大家重点掌握输出和控制，这些都是比较简单的啦，多看看就好了，对以前课程感兴趣的小伙伴可以看这里👇:python数据类型:py... 查看详情

进阶学python：python面向对象系列之魔法方法！(代码片段)

本篇主要介绍面向对象编程中类的魔法属性，这些魔法属性均有其特殊的功能，即执行某些操作时，会自动触发这些魔法方法的执行，了解这些魔法方法可以更好的了解面向对象编程的实现原理；在学习魔法... 查看详情

python面向对象之单例模式(代码片段)

...是相同的；__new__方法__new__作用使用类名()创建对象时，python解释器首先会调用__new_ 查看详情

python--面向对象之三个特性:封装继承多态(代码片段)

...法 　　　　obj=类名() 　　　　obj.方法名3、self,形参，python内部传递 4、函数式编程与面向对象式编程的区别示例：#!/usr/bin/envpython#-*-coding:utf-8-*-"""面向对象编程初识"""#先定义一个类classHello():#定义一个方法defsayHell(self,name):pri... 查看详情

进阶学python：python面向对象之属性方法(代码片段)

这次我们主要介绍类中定义的各种属性，例如类属性、实例属性、类的私有属性，以及各种方法，例如实例方法、类方法、静态方法以及property属性方法等相关知识。🚀看一段代码classTool(object):dog_type="Huskie&... 查看详情

python面向对象之文件操作(代码片段)

...以用文本编辑软件查看；本质上还是二进制文件；例如：python源文件。二进制文件保存的文件不是直接给人阅读的，而是提供给其他软件使用 查看详情

python之面向对象知识点汇总（小白必会）(代码片段)

目录Python基础之面向对象一、编程思想1、面向过程2、面向对象二、类与对象的创建1、类的语法结构2、定义与调用3、给对象添加独有属性4、对象独有属性修改三、动态、静态方法1、直接在类中定义的函数2、绑定给类的函数3、... 查看详情

面向对象之继承(代码片段)

...种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。子类会“”遗传”父类的属性，从而解决代码重用问题（比如练习7中Garen与Riven类有很多冗余... 查看详情

最新python大数据之python基础学生管理系统面向对象版(代码片段)

文章目录1、在子类中调用父类方法2、多态3、类属性4、类方法5、静态方法6、面向对象案例7、异常捕获8、捕获指定类型的异常9、else和finally10、自定义异常抛出11、模块的导入12、自定义模块13、模块查询顺序14、`__all__`的... 查看详情

面向对象之继承与派生(代码片段)

继承:单继承/多继承python2与python3在继承上的区别:　　新式类:但凡继承object类的子类,以及该子类的子子类,...都称之为新式类　　经典类:没有继承object类的子类,以及该子类的子子类,...都称之为经典类只有在python2中才区分新式类... 查看详情