类

最新推荐文章于 2024-09-11 11:22:05 发布
最新推荐文章于 2024-09-11 11:22:05 发布
阅读量116 收藏 1
点赞数
分类专栏： python 文章标签： python 类 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anny0001/article/details/84677810
版权

文章目录

一.类

1.类成员

在这里插入图片描述

2. 类基础

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

    def kanchai(self):
        print('姓名：%s ,年龄：%s岁,性别%s,%s'  %(self.name,self.age,self.gender,'砍柴'))

    def kaiche(self):
        print('姓名：%s ,年龄：%s岁,性别%s,%s'  %(self.name,self.age,self.gender,'开车'))

    def dabaojian(self):
        print('姓名：%s ,年龄：%s岁,性别%s,%s'  %(self.name,self.age,self.gender,'大保健'))

li = people('老李',91,'male')
li.dabaojian()
li.kaiche()
li.kanchai()

在这里插入图片描述

3. 类的继承

class Animal:
    def eat(self):
        print("%s 吃 " %self.name)
    def drink(self):
        print("%s 喝 " %self.name)
    def shit(self):
        print("%s 拉 " %self.name)
    def pee(self):
        print("%s 撒 " %self.name)

class cat(Animal):
    def __init__(self,name):
        self.name = name
        self.breed = 'cat'
    def cry(self):
        print('cat crys!')

cat1 = cat('foolcat')
cat1.cry()
cat1.drink()
cat1.eat()
cat1.pee()
cat1.shit()

在这里插入图片描述

3.1 多继承

在这里插入图片描述

4.多态

二.类进阶用法

1.字段

字段：普通字段和静态字段
最本质的区别是在内存中保存的位置不同
1、普通字段属于对象
2、静态字段属于类


class Province:

    # 静态字段
    country = '中国'
    def __init__(self, name):

        # 普通字段
        self.name = name

# 直接访问普通字段
obj = Province('河北省')
print(obj.name)

# 直接访问静态字段
print(Province.country)

在这里插入图片描述在这里插入图片描述

2.方法

包括：普通方法,静态方法和类方法
三种方法都归属于类，但是区别在于调用方式不同

1).普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
2).类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
3).静态方法：由类调用；无默认参数；

class Foo:

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

    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
        # print self.name
        print('普通方法')

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')


# 调用普通方法
f = Foo('gg')
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

在这里插入图片描述在这里插入图片描述

3.属性

属性就是普通方法的变种
有三个知识点：
1).属性基本使用
2).属性的两种定义方式

1). 属性基本使用

#%% 属性的基本使用
class Foo:

    def func(self):
        print('This %s'%'come from func')

    # 定义属性
    @property
    def prop(self):
        print('This %s'%'come from prop')

# ############### 调用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #调用属性
print('$$'.center(40,'-'))

在这里插入图片描述
*注意：
a.属性在定义的时候前面加上 @property 装饰器；
b.定义时属性仅有一个self参数
c.调用时无需加括号：
方法：foo_obj.func()
属性：foo_obj.prop
例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：

根据用户请求的当前页和总数据条数计算出 m 和 n
根据m 和 n 去数据库中请求数据

代码：

# ############### 定义 ###############
class Pager:
    
    def __init__(self, current_page):
        # 用户当前请求的页码（第一页、第二页...）
        self.current_page = current_page
        # 每页默认显示10条数据
        self.per_items = 10 


    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

# ############### 调用 ###############

p = Pager(1)
p.start 就是起始值，即：m
p.end   就是结束值，即：n

2). 属性定义的两种方式

1).装饰器：在方法上应用装饰器
2).静态字段：在勒种定义值为property对象的静态字段

2-1). 使用装饰器定义属性

经典类和新式类，新式类的属性比经典类的属性丰富。新式类继承object类

# ############### 经典类的属性定义 ###############    
class Goods:

    @property
    def price(self):
        return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

# ############### 新式类的属性定义 ###############
class Goods(object):

    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter'）

    @price.deleter
    def price(self):
        print('@price.deleter')

# ############### 调用 ###############
obj = Goods()

obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数

del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price

obj = Goods()
print(obj.price)         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
print(obj.__dict__)
del obj.price     # 删除商品原价
print(obj.__dir__())
print(obj.__dict__)

在这里插入图片描述

2-2). 静态字段方式

创建值为property对象的静态字段(当使用静态字段的方式创建属性时，经典类和新式类无区别)

class Foo:

    def get_bar(self):
        return 'something'

    BAR = property(get_bar)

obj = Foo()
reuslt = obj.BAR        # 自动调用get_bar方法，并获取方法的返回值
print(reuslt)

property的构造方法中有个四个参数:
a.第一个参数是方法名，调用 对象.属性 时自动触发执行方法
b.第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
c.第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
d.第四个参数是字符串，调用 对象.属性.doc ，此参数是该属性的描述信息
由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
例：

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    def get_price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    def set_price(self, value):
        self.original_price = value

    def del_price(self):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Goods()
print(obj.__dict__)
print(obj.PRICE)         # 获取商品价格
print(obj.__dict__)
obj.PRICE = 200   # 修改商品原价
print(obj.__dict__)
del obj.PRICE
print(obj.__dict__)

在这里插入图片描述 注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性

4.类成员的修饰符

对于每一个类的成员而言都有两种形式：
1)公有成员，任何地方都能访问
2)私有成员，只有在类的内部才能访问

1).两者定义不同

私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：init、call、__dict__等）

class C:
 
    def __init__(self):
        self.name = '公有字段'
        self.__foo = "私有字段"

2).两者访问限制不同

a.对于静态字段来说：

公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问；

class C:
    name = "公有静态字段"
    __name = "公有静态字段"
    def func(self):
        print(C.name)
    def func_static(self):
        print(C.__name)

class D(C):
    def show(self):
        print(C.name)
    def show_static(self):
        print(C.__name)

C.name  # 类访问
obj = C()
obj.func()  # 类内部可以访问

obj_son = D()
obj_son.show()  # 派生类中可以访问

try:
    C.__name  # 类访问            ==> 错误
except Exception as e:
    print(e)

obj = C()
obj.func_static()  # 类内部可以访问     ==> 正确

obj_son = D()

try:
    obj_son.show_static()  # 派生类中可以访问   ==> 错误
except Exception as e:
    print(e)

# 强制访问私有字段，可以通过 【对象._类名__私有字段明 】
# 但是不建议强制访问私有成员。
print(D._C__name)

在这里插入图片描述#### b.对于普通字段来说

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
私有普通字段：仅类内部可以访问；

class C:
    def __init__(self):
        self.foo = "公有字段"
        self.__foo = "私有字段"
    def func(self):
        print(self.foo)# 类内部访问公有普通字段
    def func_private(self):
        print(self.__foo)# 类内部访问私有普通字段

class D(C):
    def show(self):
        print(self.foo)#派生类中访问
    def show_private(self):
        print(self.__foo)#派生类中访问类私有普通字段

obj = C()
print(C().__dict__)
print(obj.__dict__)

print(obj.foo)  # 通过对象访问公有普通字段
try:
    obj.__foo  # 通过对象访问私有普通字段 出错
except Exception as e:
    print(e)

obj.func()  # 通过对象调用类内部方法访问公有普通字段
obj.func_private()# 通过对象调用类内部方法访问私有普通字段

obj_son = D()#派生类的对象
print(obj_son.__dict__)
obj_son.show()  # 派生类的对象可直接访问原类的公有普通字段
obj_son.func_private()# 派生类的对象通过调用原类内部方法访问原类的私有普通字段

在这里插入图片描述

5.类的特殊成员

1.xxx__doc__

class Foo:
    """ 描述类信息 """
    def func(self):
        pass
print(Foo.__doc__)

在这里插入图片描述

2.xxx__module__ & xxx__class__

class C:

    def __init__(self):
        self.name ='gg'

from python_primarylearning.类与面向对象.lib_aa import C

obj = C()
print(obj.__module__)     # 输出 lib.aa，即：输出模块
print(obj.__class__)      # 输出 lib.aa.C，即：输出类

在这里插入图片描述

3.xxx__init__

构造方法，通过类创建对象时，自动触发执行。

4.xxx__del__

析构方法，当对象在内存中被释放时，自动触发执行。

5.xxx__call__

对象后面加括号，触发执行。

class Foo:
    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print('现在是调用__call__方法')

obj = Foo()  # 执行 __init__
obj()  # 执行 __call__

在这里插入图片描述

6.xxx__dict__

类或对象中的所有成员
类的普通字段属于对象；类中的静态字段和方法等属于类，即：
在这里插入图片描述

class Province:
    country = 'China'
    def __init__(self, name, count):
        self.name = name
        self.count = count
    def func(self, *args, **kwargs):
        print('func')

# 获取类的成员，即：静态字段、方法、
print(Province.__dict__)
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}

7.xxx__str__

Return str(self)

8. xxx__getitem__、xxx__setitem__和xxx__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__', key)
    def __setitem__(self, key, value):
        self.__dict__[key]= value
    def __delitem__(self, key):
        del self.__dict__[key]

obj = Foo()

print(obj.__dict__)
result = obj['k1']  # 自动触发执行 __getitem__
obj['k2'] = 'gg'  # 自动触发执行 __setitem__
print(obj.__dict__)
a = obj['k2']
print(a)   #为空,因为没对__getitem__的return定义
del obj['k2']  # 自动触发执行 __delitem__
print(obj.__dict__)

在这里插入图片描述

9.xxx__getslice__、xxx__setslice__、xxx__delslice__

该三个方法用于分片操作，如：列表

10.xxx__iter__

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了

参考自：
http://www.cnblogs.com/wupeiqi/p/4766801.html

Mystery_zero
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python之导入类
m0_64365419的博客
07-24 6775
导入类的目的，导入单个类；在一个模块中，存储多个类；从一个模块中导入多个类；导入整个模块；导入模块中的所有类；在一个模块中导入另一个模块；自定义工作流程；python标准库；类编码风格...
Android快速开发系列 10个常用工具类 程序源码
09-05
在Android应用开发中，工具类（Utils）是程序员经常使用的辅助模块，它们包含了一系列静态方法，用于处理各种常见的任务，从而提高代码的复用性和可维护性。本资源"Android快速开发系列 10个常用工具类 程序源码...
python函数注释翻译_对同事好一些 - Python 函数参数注解（Type Annotations）
weixin_29623691的博客
01-13 439
函数参数注释不会影响程序运行时间，它们不会被类型检查，这些注释会在运行的时候被忽略掉。它存在的主要目的是用于增加程序的可读性，让你或者其他程序员更好地使用它。第三方工具和IDE框架可能会对这些注解添加语义。同时它们也会出现在文档中。如何来使用函数参数注释：def mysteryCobine(a: str, b: str, times: int) -> str:return (a+b)*tim...
python的进程模块
Mystery
02-20 705
进程与线程 假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入（I/O操作），而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。是不是在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让程序B暂停，然后让程序A继续执行？当然没问题，但这里有一个关键词：切换。 切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B...
抽象类
QTDS7493的博客
07-19 2269
1、子类继承抽象类的话，必须覆写抽象类的所有抽象方法 abstract class LeagueOfLegendsPlayer { public static final String TEAM = "RNG"; private String name = "Uzi"; public String getName(){ return name; } ...
配置类Configuration
ડUN的博客
01-13 9252
配置类@Configuration 01、概述 配置类：在springboot中被@Configuration或者@SpringBootConfiguration标注的类称之为配置类。 02、作用&目的 在配置类可以定义很多@Bean的方法，可以让这些@Bean修饰的方式让spring框架加载到ioc容器中去。 03、那为什么会存在配置 方便你覆盖底层的配置类 让你去扩展的bean的一种机制。 04、一个springboot项目中的加载的bean有那些呢？ 程序员自己编写的开发的bean ,
Collections类详解
qq_50692350的博客
08-11 1万+
Java
如何写模板类？（模板类的简单例子）
沧海一帆的专栏
10-31 5359
本文通过c++ primer plus中的例子来学习写模板类． 1.为什么需要模板类？ 为了满足代码重用的需求． 比如stack类，希望不同的类型都能用． 先看看用typedef 定义的stack类． // stack.h -- class definition for the stack ADT #ifndef STACK_H_ #define STACK_H_ typedef unsigne...
复数类
daydaystudy__c的博客
04-11 3823
已知一个名为Complex的复数类，这个类包含： （1）私有成员：实部、虚部，且均为int 型 （2）公有的带默认形参值的构造函数、复制构造函数 （3）公有成员函数Display，其作用为显示复数 要求： （1）实现满足上述属性和行为的Complex类定义； （2）设计函数AddComplex，函数AddComplex功能为实现两个复数相加，要求该函数的形参为复数类的常引用； （3）保证如下主函数能正确运行。 /* 请在这里填写答案 */ int main(){ int x,y; cin&
面试题：请介绍 JVM 类加载机制
xujunson的博客
04-23 2878
JVM 类加载机制Java 代码执行流程类的生命周期加载验证准备解析初始化clinit 和 init 方法类加载的时机被动引用类加载器双亲委派机制 我们在前面分析JVM架构解析的时候，简单介绍了 Java 类加载机制，本文带大家深入分析一下。 Java 代码执行流程 根据上图所示，Java 代码执行步骤如下： 步骤 1： 获取 Java 源代码； 步骤 2： 编译器把 java 文件转变成 class 文件。编译过程大致可以分为 1 个准备过程和 3 个处理过程： 准备过程：初始化插入式注解处理器 解
Java中的日期时间类详解
热门推荐
Clearlove_S7的博客
04-29 1万+
Java早期通过使用Date来计算时间，后来大部分Date类的方法都过时了，又转而希望用Calendar类代替Date类，然而Calendar类也是不尽如人意。因此专门在本文中对Java中Date类的基本概念、常见操作及相关类进行总结和归纳，方便日后的开发，希望对大家有所帮助。
垃圾分类数据集及代码
11-11
数据集主要包括6类图片：硬纸板、纸、塑料瓶、玻璃瓶、铜制品、不可回收垃圾 代码运行说明： 1、 安装运行项目所需的python模块，包括tensorflow | numpy | keras | cv2 2、 train.py用于训练垃圾分类模型，由于训练...
C++ 包含类两个类互相调用彼此的类成员变量和方法
09-13
这种设计允许类A访问类B的成员，同时类B也可以访问类A的成员，形成一种循环依赖的关系。然而，这种关系需要谨慎处理，以避免编译错误和设计上的问题。下面我们将深入探讨这个主题。 首先，我们要理解C++中的“包含...
CWebPage类
07-13
在Microsoft Visual C++（VC）和MFC（Microsoft Foundation Classes）框架中，`CWebPage` 类是一个自定义的类，用于与Web页面交互，尤其是调用JavaScript函数。这个类通常是在开发桌面应用程序时，需要集成Web内容...
【FFMPEG】Install FFmpeg CUDA gltransition in Ubuntu
RockWang的博客
09-05 449
FFMPEG gltranlations CUDA
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定
weixin_53707653的博客
09-09 762
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 388
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
篮球和运动员检测系统源码分享
最新发布
weixin_qunmasj的博客
09-11 840
数据集信息展示在本研究中，我们采用了名为“Basketball detection”的数据集，以改进YOLOv8在篮球场景中的运动员和篮球检测能力。该数据集专门设计用于满足篮球运动相关的视觉识别需求，包含了丰富的图像数据，能够有效支持深度学习模型的训练与优化。数据集的类别数量为三，具体类别包括“ball”（篮球）、“basket”（篮球架）和“person”（运动员），这些类别的选择旨在涵盖篮球比赛中最为关键的元素，以便模型能够准确识别和定位这些对象。
基于人工智能的音乐情感分类系统
stm32d1219的博客
09-06 1004
音乐作为一种强烈的情感表达方式，不同的音调、节奏和和声传递着不同的情感信息。通过人工智能技术，能够自动识别音乐中的情感，为用户提供个性化的音乐推荐或情感分析服务。通过使用MFCC特征提取与神经网络分类算法，音乐情感分类系统可以有效地分析音乐中的情感信息，并根据不同情感对音乐进行分类。随着深度学习技术的进一步发展，音乐情感分类系统的准确性和应用范围将得到进一步提升。音乐情感分类是通过对音乐音频信号进行分析，识别出音乐传递的情感，如“愉快”、“悲伤”、“愤怒”等。问题讨论，人工智能的资料领取可以私信！
MyInteger类：设计与实现
在这个题目中，我们将会深入探讨名为"MyInteger"的自定义C++类的设计和实现，该类用于处理整数相关的操作。这个类主要包含以下几个关键部分： 1. **数据成员与构造函数**: - 类中有一个私有成员变量`int num`，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值