python3中类的使用

最新推荐文章于 2025-04-28 17:01:19 发布
原创 最新推荐文章于 2025-04-28 17:01:19 发布 · 399 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Python3中的面向对象编程，包括类的创建、类变量、实例变量、私有变量、继承、类方法、静态方法、装饰器、闭包、多态、单例模式等核心概念，并通过示例进行演示。

一、面向对象编程

1.1 面向对象编程好处

减少重复代码编写，可以更好的进行程序的维护、扩展、升级

函数式编程和面向对象编程区别：

 

函数式编程：没法保存数据；各个函数之间是独立且无共用的数据

面向对象编程：对特定数据进行维护和管理；各个函数共用一组数据

1.2 类的特征

第一，具有属性（状态），比如人的个数

第二，具有方法，改变状态的方法，比如改变人的个数

1.3 生成一个学生的类

class Student(object):

    def __init__(self,name,age,grade,course=[],course_grade={}):

        self.name=name

        self.age=age

        self.grade=grade

        self.course=course

        self.course_grade=course_grade

    def get_age(self):

        return self.age

    def set_age(self,age):

        self.age=age

        return self.age

    def get_course(self):

        print(self.course)

    def set_course(self,course):

        self.course=course

    def get_course_grade(self):

        for k,v in self.course_grade.items():

            print(k,v)

    def set_course_grade(self,course,grade):

        if course not in self.course:

            return 0

        else:

            self.course_grade[course]=grade

            return 1

 

if __name__=="__main__":

    s1=Student("xiaoming",10,"三年级")

    print(s1.get_age())

    print(s1.set_age(20))

    print(s1.get_course())

    print(s1.get_course_grade())

    print(s1.set_course(["语文","数学","外语"]))

    print(s1.get_course())

    print(s1.set_course_grade("语文",100))

    print(s1.set_course_grade("外语",120))

    print(s1.set_course_grade("历史",100))

    print(s1.get_course_grade())

 

1.4 类变量

class Student(object):

    student_num=0

    def __init__(self,name,age,grade,course=[],course_grade={}):

        self.name=name

        self.age=age

        self.grade=grade

        self.course=course

        self.course_grade=course_grade

        Student.student_num+=1

    def get_student_num(self):

        return Student.student_num

 

if __name__=="__main__":

    s1=Student("xiaoming",10,"三年级")

    print(s1.get_student_num())

1.3.1 类变量的修改

class Student(object):

    student_num=0

    def __init__(self,name,age,grade,course=[],course_grade={}):

        self.name=name

        self.age=age

        self.grade=grade

        self.course=course

        self.course_grade=course_grade

        Student.student_num+=1

    def get_student_num(self):

        return Student.student_num

 

if __name__=="__main__":

    s1=Student("xiaoming",10,"三年级")

    Student.student_num=100

    print(s1.get_student_num())

1.3.2 类变量和实例变量的区别

类变量：声明在实例方法外面,通过 类名.类变量 或者 实例变量.类变量 调用

实例变量：声明在实例方面里面，并且带有self,通过 实例名.实例变量  调用

 

1.5 私有变量

class Student(object):

    __student_num=0

    def __init__(self,name,age,grade,course=[],course_grade={}):

        self.name=name

        self.age=age

        self.grade=grade

        self.course=course

        self.course_grade=course_grade

        Student.__student_num+=1

    def get_student_num(self):

        return Student.__student_num

 

if __name__=="__main__":

    s1=Student("xiaoming",10,"三年级")

    Student.__student_num=100

    print(s1.get_student_num())

 

1.6 继承

class Student(object):

    student_num=0

    def __init__(self,name,age):

        self.name=name

        self.age=age

        Student.student_num+=1

    def get_student_num(self):

        return Student.student_num

    def get_name(self):

        return self.name

 

class Teacher(Student):

    def __init__(self,name,age,subject):

        self.subject=subject

        Student.__init__(self,name,age)

    def get_subject(self):

        return self.subject

 

if __name__=="__main__":

    t1=Teacher("xiaoming",12,"英语老师")

    print(t1.get_name())

    print(t1.get_subject())

 

好处： 基于原有类进行扩展

 

1.7 类方法

class P(object):

    @classmethod

    def print_str(cls,content):

        return content

 

if __name__=="__main__":

    print(P.print_str("hello"))

    p=P()

    print(p.print_str("hi"))

 

1.8 静态方法

class P(object):

    @staticmethod

    def print_str(content):

        return content

 

if __name__=="__main__":

    print(P.print_str("hello"))

    p=P()

    print(p.print_str("hi"))

 

1.9 装饰器

class Goods(object):

    def __init__(self):

        self.value=1

    @property

    def price(self):

        return self.value

    @price.setter

    def price(self,value):

        self.value=value

    @price.deleter

    def price(self):

        del self.value

 

if __name__=="__main__":         

    obj=Goods()

    #自动执行@property修饰的方法price方法

    print(obj.price)

    #自动执行@property.setter修饰的price方法

    obj.price=123

    print(obj.price)

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

    del obj.price

print(obj.price)

 

好处：给所有函数增加一下附加的功能

1.10 闭包

def outer(name):

    def inner():

        print(name)

    return inner

 

p=outer("python")

p()

print(p.__closure__)

 

闭包：返回一个函数，以及执行这个函数所需要的变量

 

1.11 多态

同一个方法，依据参数不同，表现结果不一样，这种方式叫做多态。

 

def add(x,y):

    return x+y

 

print(add(1,2))

print(add("hello","world"))

print(add(1,"abcd"))

 

 

1.12 重写

 

class Parent(object):

    def myMethod(self):

        return "call Parent"

    def printName(self):

        return "my name is Lily"

 

class Child(Parent):

    def myMethod(self):

        Parent.myMethod(self)

        return "call Child"

 

#子类实例   

c=Child()

#子类调用重写方法

print(c.myMethod())

#子类调用从父类继承来的方法

print(c.printName())

 

 

1.12 单例

确保一个类只有一个实例存在

 

应用场景：

服务器有一个配置文件，客户端A访问时需要读取，生成一个实例；客户端B访问时也需要读取，又生成一个实例，这样严重浪费内存资源；我们希望只生成一个实例，供其他对象使用。

1.12.1 单例的三个要点

第一，一个类只能生成一个实例

第二，必须自行创建这个实例

第三，必须自行向整个系统提供这个实例

 

1.12.2 实现单例的四种方法

 

第一，使用模块

第二，使用__new__

第三，使用装饰器

第四，使用元类

 

1.12.2.1 使用模块

python的模块就是天然的单例模式。因为模块第一次导入时，会生成.pyc文件，当第二次导入时，就会之间加载.pyc文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象。

#test.py文件

class Myclass(object):

    def foo(self):

        print('MyClass.foo')

my_class_obj=MyClass()

 

如何使用

 

from test import my_class_obj

my_class_obj.foo()

 

1.12.2.2 使用__new__

 

使用__new__来控制实例的创建过程

class Singleton(object):

    def __new__(cls, *args, **kw):

        if not hasattr(cls, '_instance'):

            orig = super(Singleton, cls)

            cls._instance = orig.__new__(cls, *args, **kw)

        return cls._instance

 

class MyClass(Singleton):

    a = 1

 

one = MyClass()

two = MyClass()

print(one==two)

print(id(one),id(two))

 

1.12.2.3 使用装饰器

 

装饰品可以动态地修改一个类或函数的功能，我们也可以使用装饰器来装饰某个类，使其只能生成一个实例。

 

from functools import wraps

def singleton(cls):

    instance={}

    @wraps(cls)

    def getinstance(*args,**kwargs):

        if cls not in instances:

            instances[cls]=cls(*args,**kwargs)

        return instances[cls]

    return getinstance

 

@singleton

class MyClass(object):

    a=1

 

备注：

我们定义了一个装饰器singleton,它返回了一个内部函数getinstance，该函数会判断某个类是否存在字典instances中。

如果不存在，则会将cls作为key，cls(*args,**kw)作为value存到instances中，否则，直接返回instances[cls]

 

1.12.2.4 使用metaclass

元类（metaclass）可以控制类的创建过程，它主要做三件事：

第一，拦截类的创建

第二，修改类的定义

第三，返回修改后的类

 

 

class Singleton(type):

    _instances = {}

 

    def __call__(cls, *args, **kwargs):

        if cls not in cls._instances:

            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)

        return cls._instances[cls]

 

# Python2

# class MyClass(object):

#     __metaclass__ = Singleton

 

# Python3

class MyClass(metaclass=Singleton):

   pass

 

 

 

 

 

 

 

 

python：类基础
不怕猫的耗子A
06-17 11万+
1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元，一个对象包含数据和操作数据的函数2、在python中，所有数据类型都被视为对象，也可以自定义对象。自定义对象数据类型就是面向对象中类的概念1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例2、方法：类中定义的函数3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性4、数
Python中定义和使用类的私有属性和方法
hou09tian的博客
08-22 2051
也可以在类的属性和方法名前加入两个下划线将其设置为私有，代码如图4所示。图4 定义类的私有属性其中，“a”是类的共有属性，“__b”是类的私有属性，可以在getb()和setb()中获取和设置私有属性“__b”。如果在类外使用“__b”，此时程序会报错，如图4和图5所示。图4 在类外使用私有变量“__b”的错误代码图5 报错信息从图4和图5中可以看出，c是Myclass类的实例，通过该实例在类外调用私有属性“__b”时，程序的报错信息是Myclass类没有“__b”属性。
python 3 类的用法（自动化）
qq_60832550的博客
08-23 298
#1、创建类及类变量 class person: name = "zhangsan" #类变量 def say (self): #定义方法 print(f"hello{person.name}") #访问类变量 print(person.name) person.name ="lisi" #类名修改影响所有实例 #访问类中定义的方法，需要先实例化类 a = person() #a是实例化类 a.say() a.name = "zhangsan" .
PyThon3类的基本使用
09-10 234
代码： class Person: def __init__(self, name, age, sex): self.name = name self.age = age self.sex = sex def desc(self): print("name:{},age:{},s...
Python3-类基础
The research on computer technolog
11-26 551
和其他编程语言相比，Python 用非常少的新语法和语义将类加入到语言中，提供了面向对象编程的所有标准特性类，也拥有 Python天然的动态特性：它们在运行时创建，可以在创建后修改。#!
python3 面向对象-类的使用 (一）
分享我的点点滴滴，在成长路上与你同行！
01-25 204
一、类的定义 """ 格式一: class 类名: pass 格式二: class 类名: 成员 pass 类命名规范: 大驼峰命名规则 FirstName """ # 类的第一种定义格式 class Student: #没有产生继承关系的情况下,类名()可写可不写 pass #空空如也 class Emp(): pass # 空空如也 # 类的第二种定义格式 # 类的定义 > 对象的创建 (类似于函数的调用) # 学生 &g...
python类的使用3
Jack_Li
09-24 553
#!/usr/bin/python #-*- coding:utf8 -*- #将将Init函数中弗雷的初始化 class Student(object):     def __init__(self, name):         print "student name is: ",name class SmallStudent(Student):     def __in
Python3官方手册中文版
05-14
- **方法对象**: 方法是类中定义的函数。 - **类和实例变量**: 类变量和实例变量的区别及应用场景。 ##### 9.4 一些说明 - 包括类的一些高级特性介绍。 ##### 9.5 继承 - 继承是一种重要的面向对象编程特性，...
Python 中调用方法内部定义的类详解（类在方法中的各种操作）
最新发布
数据知道的博客
04-28 9459
在 Python 中，可以在函数或方法内部定义类，这种类被称为"局部类"或"嵌套类"。​​作用域限制​​：内部类只在方法的作用域内可见​​访问外部变量​​：可以访问方法内的局部变量（Python 3 中使用 nonlocal 关键字）​​动态性​​：每次调用方法都会重新定义类。
python3多线程实战（python3经典编程案例）
热门推荐
数据知道的博客
08-25 8万+
总结： python多线程适用在I/O密集型的任务中。对于I/O密集型任务来说，较少的时间用在cpu计算上，较多的时间用在I/O上，如文件读写，web请求，数据库请求等； 对于计算密集型任务，应该使用多进程。 一. 多线程任务对比 线程也是轻量级进程，是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程的实际运作单位 一个线程可以创建和撤销另一个线程，同一进程的多个线程之间可以并发执行。 线程有就绪，阻塞，运行3中基本状态。 计算密集型任务-多进程 from multiprocessing i
Python3 类
程序一笑
12-01 468
Python3 类 目录 Python3 类 继承 项目组织方式 类编码风格 在Python中，首字母大写的名称值得是类，而小写的名称指的是根据类创建的实例。 Python类中的每个属性都必须有初始值。可以在__init__()方法内为某个属性设置默认初始值，此时无需包含为它提供初始值的形参。 类中的函数称为方法，Python类中的方法都必须有一个参数，该参数是实例化对象的自身引用...
python3 类
舌耳的博客
01-05 944
 类的三要素：名称、属性、方法 面向对象的三要素：封装，继承，多态 class Cat(object): def __init__(self, new_name=' ', new_age=' '): print("我是初始化") self.name = new_name self.age = new_age def ...
Python3——类
血染风采2019
09-11 923
                                   Python3 —— 类 目录 Python3 —— 类 创建和使用类（class） 继承（class Man(People)） 导入类（与导入模块一样） 创建和使用类（class） 类：属性，方法 比如：类People表示人，姓名年龄为属性，吃饭为行为。使用类时需实例化一个对象。 class Peop...
python中类的用法_Python 3中类的理解与使用,python3,class,及
weixin_39929918的博客
11-24 139
一、class的定义及常用称呼本节参考的博客https://blog.youkuaiyun.com/pdstar/article/details/90900944类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象：它是类的实例化。方法：指类中定义的函数。类对象支持两种操作：属性引用 和 实例化。（1）属性引用的语法：obj.属性（2） 类实例化的语法...
Python3入门与进阶笔记（六）：类
xuanshuang的博客
03-07 680
类名建议首字母大写，通常用驼峰规则命名。变量名建议小写，下划线隔开。类最基本的作用是封装。 类的实例化 构造函数：自动执行，可以不写return，此时返回类型是None，不能强制返回其他类型 类变量 VS 实例变量 实例方法： 实例方法关联的是对象，实例方法通常用来操作实例变量，定义实例方法形参要多写一个self（也可以是别的，建议self），在传参数时不需要...
python3中类的重点
qq_41020281的博客
03-20 339
__new__和__init__的区别:__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例，是个静态方法。也就是，__new__在__init__之前被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。"魔法"方法:   ...
Python3之对类的理解
geek_xiong的博客
09-07 410
类 类变量 类变量是类的属性，此属性属于类，不属于此类的实例 类变量的作用：通常用来存储该类创建对象的共有属性 说明： 类变量可以通过该类直接访问 类变量可以通过类的实例直接访问 类变量可以通过此类的对象的class属性间接访问 举个栗子： >>> class Human: total_count = 0 &gt
Python学习之路——单例模式
海纳百川
02-05 248
定义： 单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 举例： 中国的婚姻制度其实就是一个活生生的单例模式。在你和一位女性结婚时，你需要去民政局登记...
python小知识点积累
qq_34620701的博客
02-26 202
shutil.rmtree()表示递归删除文件夹下的所有子文件夹和子文件 from unittest import mock python3.4后内置mock库 python单例模式： """ 装饰器（decorator）可以动态地修改一个类或函数的功能。也可以使用装饰器来装饰某个类，使其只能生成一个实例 """ from functools import wraps # 定...
Python36中mmh3模块使用及安装指南
MurmurHash3是这类算法中的一种，而Python是一种广泛使用的高级编程语言，常用于快速开发应用程序、脚本和自动化任务。 压缩包内的文件列表反映了mmh3模块的组成结构。列表中的"mmh3-2.0-py3.6.egg-info"文件是...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值