首页 > 编程语言 >python的面向对象

python的面向对象

时间：2024-02-27 18:12:06浏览次数：25  
标签：__ name python self 面向对象 print age def

面向对象的概念

　　面向过程和面向对象是两种编程方式，这两个种方式是程序员用来代码来抽象世界的不同的方式，本身无优劣之分，针对于不同的抽象，各有利弊。面向对象更倾向于用各种模板来抽象世界，每个实例就是这种抽象的具体描述，这样可以描述更加复杂的关系，且可以让行为和属性和具体的对象进行绑定。而面向过程更倾向于描述解决问题的一种流程，更加的直观，简洁高效。

一个简单的栗子：

class Dog(object):
    def __init__(self, name, bleed, age):
        self.name = name
        self.bleed = bleed
        self.age = age

    def speak(self):
        print("wang!wang!wang!")

    def show(self):
        print('我叫 %s 我是一只 %s 狗，我今年 %s 岁了' % (self.name, self.bleed, self.age))

d = Dog("mjj", "京巴", 3)
d.speak()
d.show()

具体定义描述
class Dog(object):

首先class 是一个关键字，标志了需要定义一个类；

Dog 是这个定义的类的名字，后面我们通过这个类的名字进行数据的实例化调用

（object）是表示此类继承了object类，括号中是父类的名字，python支持多继承，所以在括号内可以写多个类名，但是需要用逗号进行分割！

　　*object是所有python定义类的父类，默认继承，若没有具体的类要继承 那么无需写object，因为可以省略。

类中的方法：

    def speak(self):
        print("wang!wang!wang!")

方法定义没有任何特殊，但是和一般的方法定义，有一个默认的参数，self，这个self标志是实例自己。方法中可以使用self来调用自己的一些实例属性值，类属性的值，可以使用类名.类属性名来进行访问

d = Dog("mjj", "京巴", 3)
创建一个名字叫d实例，它是Dog的一个具体的对象。初始化默认就会调用类的__init__(self,xxxx)方法，因为这个方法是实例方法，所以，self默认，只需要进行self后的形参列表进行传值即可。
d.speak()
使用实例名称.方法名称调用方法,执行你所需的逻辑。

概念解析

类:class关键字后面定义的代码，可以看作一个类的定义。有时候我们说的类，其实就是这样的类的定义。
类名:可以看作一个模板，在创建实例的时候进行调用
实例名: 通过调用类名（）创建的一个类的实例
类方法:一般会有一个@classmethod标签 通过 类名.方法名/实例名称.方法名 进行调用，不可以访类变量，但是不能访问实例变量
实例方法：只能通过 实例变量.方法 名称进行调用，可以访类变量，可以访问实例变量
静态方法：一般会有一个@staticmethod标签

对象之间的关系

组合关系：某些东西只有在一起的时候才能正常工作，下面这个weapon和person就是一个组合关系

class Dog():
    __force_dict = {'京巴': 30, '藏獒': 80}

    def __init__(self, name, bleed, age):
        self.name = name
        self.bleed = bleed
        self.age = age
        self.life_val = 100
        self.force_val = Dog.__force_dict.get(bleed)

    @classmethod
    def speek(self):
        print("wang!wang!wang!")

    def bite(self, p):
        p.life_val -= self.force_val
        print("%s 张口咬了 %s , %s 掉血 %s 还剩 %s 血量" % (self.name, p.name, p.name, self.force_val, p.life_val))


class Weapon():

    def knift(self, d):
        d.life_val -= 80
        print("拿刀捅了 %s , %s 掉血 %s 还剩 %s 血量" % (d.name, d.name, 80, d.life_val))

    def gun(self, d):
        d.life_val -= 100
        print("拿枪扫射了 %s , %s 掉血 %s 还剩 %s 血量" % (d.name, d.name, 100, d.life_val))

    def stick(self, d):
        d.life_val -= 50
        print("拿打狗棍打了 %s , %s 掉血 %s 还剩 %s 血量" % (d.name, d.name, 50, d.life_val))


class Person():
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
        self.life_val = 100
        self.weapon = Weapon()


d = Dog('mjj', '京巴', 3)

p = Person('ty', 'male', 30)

d.bite(p)

p.weapon.knift(d)

两个对象之间存在组合的关系，一方是另外一方的某个实例属性，这样的关系，叫做组合关系。

依赖关系

class Dog():
    def __init__(self, name, bleed, age, person):
        self.name = name
        self.bleed = bleed
        self.age = age
        self.person = person

    def say_hi(self):
        print("我是%s,我的主人是%s" % (self.name, self.person.name))


class Person():
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age


p = Person('tang', 'male', 30)

d = Dog('mjj', '京巴', 3, p)
d.say_hi()

 

关联关系

class Relationship():
    def __init__(self):
        self.couple = []

    def make_couple(self, obj, obj2):
        self.couple = [obj, obj2]

    def break_up(self):
        self.couple = []

    def get_parter(self, obj):
        if len(self.couple) > 0:
            for temp in self.couple:
                if obj != temp:
                    return temp

        
        return None


class Person():
    def __init__(self, name, sex, age, relation):
        self.name = name
        self.sex = sex
        self.age = age
        self.life_val = 100
        self.relation = relation


relationship = Relationship()
p1 = Person('mjj', 'male', 24, relationship)
p2 = Person('zqq', 'famale', 23, relationship)
relationship.make_couple(p1, p2)

print(p1.relation.get_parter(p1).name)
print(p2.relation.get_parter(p2).name)

 

聚合关系：

 

继承关系

狗继承自动物，所以有动物的所有特性，动物的方法也可以被狗使用

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("动物吃东西狼吞虎咽！")


class Dog(Animal):
    def __init__(self, name, age, bleef):
        super().__init__(name, age)
        self.bleef = bleef

    def show(self):
        print("狗在表演站立")


d = Dog('mjj', 3, '京巴')
d.eat()
d.show() 

 

类的三大特性

继承：参看上面

封装：将一些不希望被在类外调用的方法或者属性进行隐藏，这样的方式叫做封装

封装方法：在方法名字前加 __(两个下划线)

封装属性：在属性前面加__(两个下划线)

这样在调用的时候会出现如下错误：AttributeError: 'Dog' object has no attribute 'xxx'

强制调用封装函数：对象._类名+方法名()

d._Dog__show()

多态性

子类重写了父类的方法，那么通过子类调用此方法，那就会先找子类的方法列表中是否存在，不存在，会按照继承顺序，依次向上查找父类，找到就调用。

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("动物吃东西狼吞虎咽！")


class Dog(Animal):
    def __init__(self, name, age, bleef):
        super().__init__(name, age)
        self.bleef = bleef

    def __show(self):
        print("狗在表演站立")
    
    def eat(self):
        print("狗吃东西吧唧嘴！")


d = Dog('mjj', 3, '京巴')
d.eat()

d._Dog__show()

这个eat方法就是体现了多态性！

 

方法的标签

@property

 

class Flight:
    def __init__(self, airline):
        self.airline = airline
        self.__flight_sta = None

    @property
    def flight_status(self):
        print("通过机场的航班查询飞机的状态。。。")
        if self.__flight_sta == 0:
            print("飞机还未到达机场")
        elif self.__flight_sta == 1:
            print("飞机正在登机")
        elif self.__flight_sta == 2:
            print("飞机已经离开机场")

    @flight_status.setter
    def flight_status(self, value):
        self.__flight_sta = value


f = Flight("M219")
# f.flight_status
f.flight_status = 1
f.flight_status

可以将方法看作一个属性来范文，设置属性也可以当作一个属性来赋值

热加载 

__import__("XXXX")
或者(官方推荐使用类库的方式进行加载)

import importlib
importlib.import_module("XXXX")

 

双下划线方法

# 两个对象是否相等 isinstance（）方法可能会用到
def __eq__(self, other):
    pass


# 获取实例属性的长度会调用此方法
def __len__(self):
    pass
#计算hash的结果值会调用此方法
def __hash__(self):
    pass
#获取某个属性会调用此方法
def __getitem__(self, item):
    pass
#设置属性值会调用此方法
def __setitem__(self, key, value):
    pass
#删除属性值会调用此方法
def __delitem__(self, key):
    pass

def __init__(self):
    pass

#类似STR函数 但是场景有不一样
def __repr__(self):
    pass
#直接使用print(obj)则调用此函数
def __str__(self):
    pass
#删除对象时候调用
def __del__(self):
    pass

析构函数

 创建和销毁对象会用到的函数 称之为析构函数

def __init__(self):
    pass
def __repr__(self):
    pass

 

反射

 反射主要是通过这

hasattr(),getattr(),setattr(),delattr()来进行设置
if hasattr(d, 'name'):
    obj = getattr(d, 'name')
    print(obj)

if hasattr(d, 'show'):
    obj = getattr(d, 'show')
    if callable(obj):
        print('是函数')
        obj()


def print_char(char, num):
    val = char * num
    print(val)
setattr(d, "print_char", print_char)
d.print_char("*", 10)

 

单例模式和__new__()

class Printer():
    instance = None

    def __init__(self, file):
        if hasattr(self, "files"):
            self.files.append(file)
        else:
            self.files = []
            self.files.append(file)

    def print(self):
        for temp in self.files:
            print(temp)

    def __new__(cls, *args, **kwargs):
        if cls.instance == None:
            cls.instance = super().__new__(cls)

        return cls.instance


p1 = Printer("pdf")
p2 = Printer("word")
p3 = Printer("excel")

print(p1, p2, p3)

p3.print()

 

标签：__,name,python,self,面向对象,print,age,def
From： https://www.cnblogs.com/jones-walker/p/18036147

相关文章

  • python中几种括号的使用：()、[]、{}的基础使用
    Python中的三种数据类型，分别是小括号（）、中括号[]、花括号{}()：代表tuple元组tup=（1,2,3）[]：代表list列表list=[1,2,3]{}：代表dict字典tinydict={'a':1,'b':2}嗯1、()tuple元组小括号（）代表元组，元组是不可改变的序列。创建方式如下图：2、[]list列表[]中......
  • java面向对象-第一步
    面向过程&面向对象面向过程思想◆步骤清晰简单，第一步做什么，第二步做什么….◆面对过程适合处理一些较为简单的问题◆面向对象思想◆物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面......
  • Java基础-面向对象概述
    本章重点针对面向对象的三大特征：继承、封装、多态进行详细的讲解。另外还包括抽象类、接口、内部类等概念。很多概念对于初学者来说，更多的是先进性语法性质的了解。1.面向对象-继承：1.继承的实现：继承通过如下格式实现：class子类名extends父类名[implements<接口名>]{}......
  • Java基础-面向过程和面向对象
    面向过程和面向对象都是对软件分析、设计和开发地一种思想，它指导着人们以不同的方式去分析、设计和开发软件。这两种思想是相辅相成的。面向过程：使用面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终完成。这个思想适合简单任务，不需要过多......
  • Python并发编程的协程
    一、协程的概念1、协程是单线程下的并发，它是程序员级别的，我们来控制如何切换。2、进程的开销>>>>>>线程的开销>>>>>>协程的开销3、协程的使用需要借助于第三方模块gevent模块或者asyncio模块4、gevent 和 asyncio 是两个在Python中常用的协程框架，它们都提供了在......
  • Python脚本给数据库插入数据报错： raise errorclass(errno, errval) pymysql.err.Integ
    一、问题描述在SQL客户端插入数据时执行SQL语句INSERTINTOuser_xxx(id,uid,total,balance,wallet_type,ctime,utime)VALUES(0,'336448391',271,89000098,'coin',1708588247,1709007766);可以成功执行没报错；使用python脚本执行SQL语句INSERTINTOuser_xxx......
  • python-dotenv模块的使用
    安装模块pip3installpython-dotenv使用方式需要在根路径下新建.env文件，并写入配置importosfromdotenvimportload_dotenvfromdotenvimportdotenv_values###方法一res=load_dotenv()#takeenvironmentvariablesfrom.env#返回True或Falseprint(res......
  • python 的深浅拷贝
    python的深浅拷贝在Python中，深拷贝（deepcopy）和浅拷贝（shallowcopy）是用于复制数据结构（如列表或字典）的两种不同方式，它们有以下区别：浅拷贝（ShallowCopy）：浅拷贝创建一个新的对象，然后将原始对象中的元素（如果是可变对象）复制到新对象中。但是，如果元素本身也是一个可变对象，则新对象中的......
  • python中的列表和元组有什么区别
    python中的列表和元组有什么区别在Python中，列表（List）和元组（Tuple）都是用来存储一组有序元素的数据结构，它们之间有几个重要的区别：可变性：列表是可变的（Mutable），意味着你可以改变列表中的元素，包括添加、删除、修改元素。元组是不可变的（Immutable），一旦创建后就无法修改。你不能在元组中......
  • Java面向对象之接口和抽象类的区别一目了然
    介绍相信对于Java面向对象部分，很多人很长一段时间对于接口和抽象类的区别，使用场景都不是很熟悉，同是作为抽象层重要的对象，工作中到底什么情况下使用抽象类，不是很清楚。本文就一次性把这些概念一次性说清楚，不用再烦恼了，哈哈！核心概念接口与抽象类最明显的区别可能就是使用上的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99