《Python游戏编程入门》——1.3 Python中的对象

简介:

本节书摘来自异步社区《Python游戏编程入门》一书中的第1章,第1.3节,作者[美]Jonathan S. Harbour ,李强 译,更多章节内容可以访问云栖社区“异步社区”公众号查看。

1.3 Python中的对象

Python是面向对象编程语言,这意味着,它至少支持一些面向对象编程概念。现在,我们将花一些时间来介绍这些概念,因为这是一种编写代码的高效方式。面向对象编程(OOP)是一种方法学,也就是做事情的方式。在计算机科学中,有几种较大的、“伞状的”方法学,也就是说,定义了编程语言的功能的方法学。要让我们的技能成为可以传播的,方法学对于这个产业来说很重要。如果每个公司使用他们自己的方法学,那么,为该公司工作的过程中所获取的技能,对于另一个不同的组织来说将会是无用的。软件工程也是一个充满挑战的领域,并且培训的成本很高,因此,对于这个领域相关的每个人(经验丰富的开发者、老板以及教授概念的讲师)来说,方法学都是有益的。

1.3.1 在面向对象之前是什么

天生的好奇心,这是有天分的程序员的共同特点,如果你也有的话,那么,你肯定会问,在面向对象泛型之前,人们使用的是哪一种编程类型呢。让我们来了解一下这个主题,在我们还没有真正开始使用Python之前,先说明一下为什么这个问题如此重要。在编程方法学方面,我们先搞清楚起源在哪里,才能够理解今天位于何处。
结构化编程

在OOP之前,人们所采用的方法学叫作过程化编程(procedural programming)或结构化编程(structured programming),这意味着,在这种情况下使用的是过程和结构。过程通常叫作函数,并且,我们如今仍然在使用函数。是的,甚至在OOP程序中,仍然有独立的函数,如main()。包含在一个对象中的函数,叫作方法,并且当作为对象的一部分讨论的时候,使用方法这个术语而不是函数。但是,在对象之外,函数仍然存在,并且这是从之前的“时代”(方法学)沿用而来的。

结构是复杂的用户定义类型(user-defined types,UDT),它可以将很多的变量包含在一起。最流行的结构化语言是C。然而,结构化编程是一种历史悠久而且颇为成功的方法学,一直延续至今。结构化运动的时间是从20世纪80年代到20世纪90年代,当然,这个时间和其他的方法学的发展有一些重叠。在电子产业中,很多软件开发工具包(SDK)仍然按照结构化的方式来开发,提供了函数库来控制一个电子设备(例如,显卡或嵌入式系统)。可以说,C语言的开发(大概是在20世纪70年代)是以结构化编程为主要方式而进行的。C语言用来创建UNIX操作系统。

如下是Python的结构化程序的一个快速示例。

# Structured program
# Function definition
def PrintName(name):
    print("The name is " + name + ".")
# Start of program
PrintName("Jane Doe")

这段程序产生如下的输出。

The name is Jane Doe.
Pyhon中的注释行都是以#字符开头的。

函数的定义以def开头,后面跟着函数名、参数和一个冒号。Python中没有代码块符号,如C++中的开始花括号({)和结束花括号(})。在Python中,函数的结尾是未定义的,假设函数在下一个未缩进的行之前结束。让我们做一点试验,来测试Python的行为。如下还是我们的示例,不带任何的注释行。你认为它会输出什么?

def PrintName(name):
    print("The name is " + name + ".")
print("END")
PrintName("Jane Doe")

输出是:

END
The name is Jane Doe.

大多数的Python初学者会对此感到惊奇。这里所发生的事情是,print ("END")行向左缩进,因此,它变成了程序的第一行,后面跟着第二行,即PrintName ("Jane Doe")。函数定义不被看作是主程序的部分,并且,只有当调用该函数的时候才会运行。如果我们像下面这样,把函数定义放在主程序的下方,会发生什么情况?

PrintName("Jane Doe")
def PrintName(name):
    print("The name is " + name + ".")

这段代码实际上会产生语法错误,因为无法找到PrintName函数。这就告诉我们,在调用函数之前Python必须先解析它。换句话说,函数定义必须位于函数调用的“上方”。

Traceback (most recent call last):
  File "FunctionDemo.py", line 4, in <module>
    PrintName("Jane Doe")
NameError: name 'PrintName' is not defined
当使用IDLE保存源代码的时候,确保要包含扩展名.PY,因为IDLE不会自动添加扩展名。

顺序式编程

结构化编程是从早期的顺序式编程方法学发展而来的。这不是正式的教科书的说法,但却是更富有描述性的一种说法。顺序式程序要求在每行代码之前都要有行号。尽管跳转到程序的其他行也是可能的(使用goto或gosub命令),并且这是结构化编程的一个早期的发展方向,但是,顺序式程序倾向于陷入某种程度的复杂性,使得代码变得难以识别或无法修改。这个时候所导致的问题,称为“意大利面条式代码”,这是由于程序似乎要去向每个方向的“流”而导致的。两种最常用的顺序式语言是BASIC和FORTRAN,并且这些语言的全盛期是20世纪70年代到20世纪80年代。随着开发者对于维护“意大利面条式代码”感到厌烦,人们迫切地需要进行范型迁移。随着诸如Pascal和C这样的新的结构化语言的引入,结构化编程应运而生。

10 print "I am freaking out!"
20 goto 10
你是否真正认为这段顺序式代码很有趣呢?我是这么认为的。它把我带回到了几年之前。有一款叫作QB64(www.qb64.net)的不错的编译器(并且是免费的),它支持BASIC、QBASIC以及QuickBasic(它是结构式的,但不是顺序式的)的所有老式的风格。此外,QB64支持OpenGL,因此,它潜在性地支持高级图形和游戏设置,并且支持BASIC的老式变体。

助记式编程

在顺序式编程之前,开发者编写的代码更接近于计算机硬件的层级,而他们使用的是汇编语言。有一个“汇编器”程序,就像是编译器一样,但是,它将会把助记式的指令直接转换为对象或二进制文件中的机器代码,准备好让处理器一次一个字节地运行它们。一条汇编式的助记式指令,直接关联到处理器所能够理解的一条机器指令。这就像是在说机器自身的语言,并且很有挑战性。在MS-DOS的时代,这些汇编性的指令能够把显示模式转换成分辨率为320×200并且具有256(8位)色的图形模式,这对于20世纪90年代的IBM PC游戏来说已经很好了,因为这会很快。记住,在那个时代,我们没有今天这样的显卡,只有构建到ROM BIOS中的“视频输出”以及操作系统所支持的各种模式。这就是那个时代的所有游戏开发者都喜欢的声名狼藉的“VGA mode 13h”。

mov ax, 13h
int 10h
有一个有趣的历史性站点,专门介绍了VGA mode 13h编程: http://www.delorie.com/djgpp/doc/ug/graphics/vga.html。

“AX”是一个16位的处理器寄存器,处理器上的实际的物理电路可以当作一种通用目的的“变量”对待,这里使用了你所熟悉的术语而没有使用电子工程的语言。还有其他3种通用目的寄存器:BX、CX和DX。它们自身都是从8位的Intel处理器升级而来的,而后者拥有叫作A、B、C和D的寄存器。当发展到16位的时候,这些寄存器扩展为AL/AH、BL/BH、CL/CH和DL/DH,它们分别表示每个16位寄存器的两个8位的部分。乍一听起来,这并不复杂。将一个值放到一个或多个这些变量寄存器之中,然后通过调用一个中断来“加载”一个过程。在VGA模式更改的例子中,中断是10h。

现实世界

如果你喜欢电子工程和汇编语言这个主题,那么有一个和老式的工作对应的现代工种,这就是设备驱动编程。如今,这已经成为一种魔法,专门为那些真正理解硬件的工程师而保留。因此,你可以看到,如果你对这个工作感兴趣,学习汇编语言对此是非常有益处的。

1.3.2 接下来是什么

我们已经简单地回顾了从过去到现在的编程方法学,以理解和掌握当今所拥有的工具和语言的方法,下面,我们来介绍一下当前的情况以及有些什么发展。如今,面向对象编程仍然是专业程序员所采用的最主要的方法学。它是Microsoft的Visual Studio和.NET Framework等流行的工具的基础。如今的商业和科学领域中,最主要的编译型OOP语言是C++、C#、BASIC(其现代变体是Visual Basic)以及Java。当然还有其他的语言,但是,这些是最主要的。

Python和LUA都是脚本编程语言。和C++这样的编译型语言相比,Python和LUA的处理方式有很大不同,它们是解释型的,而不是编译型的。当你运行一个Python程序的时候(扩展名为.PY的一个文件),它不会进行编译,而会运行。你可能会在一个Python函数中带入语法错误,但是,在调用该函数之前,Python不会提示错误。

# Funny syntax error example
# Bad function!
def ErrorProne():
printgobblegobble("Hello there!")
print("See, nothing bad happened. You worry too much!")

Python或者这段程序中没有一个名为printgobblegobble()的函数,因此,这里应该产生一个错误。输出如下。

See, nothing bad happened. You worry too much!

但是,如果添加了对ErrorProne()函数的调用,输出将会如下。

Traceback (most recent call last):
  File "ErrorProne.py", line 9, in <module>
    ErrorProne()
  File "ErrorProne.py", line 5, in ErrorProne
    printgobblegobble("Hello there!")
NameError: global name 'printgobblegobble' is not defined

现在,对于Python中这一貌似忽略的部分有一些限制。如果你明显错误地定义了一个变量,那么,在运行之前,它才会初次产生错误。在Python中,还会因为做了另一件奇怪的事情而把事情搞砸,那就是,使用保留字作为变量:

Behold:
print = 10
print(print)

第一行没问题,但是第二行导致了如下的错误。

Traceback (most recent call last):
  File "ErrorProne.py", line 8, in <module>
    print(print)
TypeError: 'int' object is not callable

这条错误的意思是,print变成了一个变量,确切地说,是一个整数,其值设置为10。然后,我们试图调用旧的print()函数,并且Python无法得到它。因为旧的print()函数已经被忽略了。现在,这种奇怪的行为不再适用于Python语言中的保留字了,如while、for、if等保留字,而只是适用于函数。当你发现Python作为一种脚本语言有着巨大的灵活性的时候,我觉得你会感到惊讶的。

像GCC或Visual C++这样的传统的编译器,甚至在考虑运行这样的代码的时候,你就会抓狂。毕竟,它们是编译器。在将程序转换成目标代码之前,它们完整地解析了程序的流程。这么做的缺点就是:编译器无法处理未知的东西,它们只能处理已知的东西,而脚本语言可以很好地处理未知的情况。

顺序式编程演变为结构化编程,结构化编程演变为OOP,编程范型从OOP开始的下一次演进也将继续保持同样的方式,在范型发生变化之前,当前的编程方法学中将会出现一些明显的改变的迹象。今天,发生在OOP上的这些变化,可能会称为自适应编程(adaptive programming)。在当今快节奏的世界中,没有人会像我们以前编程的时候那样,坐在计算机前阅读WordPerfect或Lotus 1-2-3的200页的手册。还是有人会认为“阅读手册”是解决技术问题的有效方法,但是如今,即便是带有类似手册的产品也很少见了。如今,系统必须具有交互性和自适应性。超越OOP的下一次演进,可能是面向实体编程(EOP,entity oriented programming)。

想象一下,我们使用实体(使用简单规则来解决复杂问题的自包含对象)来编写代码,而不是使用包含了属性(变量)和方法(函数)的对象来编写代码。这似乎是A.I.的研究方向,而且应该能够与如今已有的OOP很好地适应。实际上,已经有了一些早期的迹象出现了。听说过Web Service吗?Web Service是寄存在网上的自包含对象,程序可以使用它来执行独特的服务,而程序自身不知道如何进行这些服务。

这些Web Service可能会只是要求一个库存数据库的参数,并且返回与查询匹配的项目的列表。这种形式的程序交互,一定能够超越编写SQL(structured query language,结构化查询语句,这是关系数据库的语言)!那么,将其带入到下一个层级如何?使用某种库或搜索引擎在线查询一个服务,而不是接入一个已知的服务,这会怎么样?

作为另一个可能的示例,假设有一个在线的、可以用于游戏中的游戏实体的库(很可能是由独立开发者或开源团队创建的),其中的实体将会带有其自己的美工素材(2D精灵、3D网状物、材质、音频剪辑等)以及自身的行为(例如一段Python脚本)。需要某种格式的素材的一个已有的游戏引擎,可能会使用这种EOP的概念来扩展游戏设置。假设你要玩一个游戏,诸如Minecraft(www.minecraft.net)这样的某种世界构造游戏,并且,假设你是游戏中的某个新角色。因此,你向游戏提出查询:“我需要一把短的木头椅子”。在查询发出去后的片刻,一把短的木头椅子出现在你的游戏中。假设有一个用于Minecraft这样的引擎的在线游戏装备库,我们当然可以想象会发生这种情况。

1.3.3 OOP:Python的方式

我们已经进行了足够的历史分析和思考,从而可以触发一些有想象力的思路。现在,让我们来介绍一些具体而实际的内容,即当前的OOP方法学及其在Python中的实现。或者换句话说,我们用Python来创建对象。Python确实支持OOP特性,但是,它不像是高度特定性的语言C++那样,在各个程度上支持OOP。在开始之前,让我们先来了解一些术语。类是一个对象的蓝图。类不能做任何事情,因为它是一个蓝图。只有在运行时创建对象的时候,对象才会存在。因此,当我们编写类代码的时候,它只是一个类的定义,而不是一个对象。只有在运行时,通过类的蓝图来创建对象的时候,它才是真正的对象。类的函数也叫作方法。类的变量通常作为属性来访问(有一种方法用来获取或设置一个变量的值)。当创建一个对象的时候,类实例化为该对象。

让我们来了解Python的OOP特性的一些具体内容。示例如下。

class Bug(object):
    legs = 0
    distance = 0
    def __init__(self, name, legs):
        self.name = name
        self.legs = legs
    def Walk(self):
        self.distance += 1
    def ToString(self):
        return self.name + " has " + str(self.legs) + " legs" + \
               " and taken " + str(self.distance) + " steps."

每个定义的行末,都必须有一个冒号。关键字self描述当前的类,这和它在C++中的作用是相同的。所有的类变量前面必须有一个“self”,以便可以认出这是类的成员;否则,它们将会被当作局部变量。def __init__(self)这一行开始了类的构造函数,这是在类实例化的时候运行的第一个方法。在构造函数之外,可以声明类变量并且在声明的时候进行初始化。

多态

术语多态表示有“多种形式”或“多种形状”,因此,多态是指具备多种形态的能力。在类的环境中,这意味着我们可以使用具有多种形态的方法,也就是说,参数的多种不同的集合。在Python中,我们可以使用可选的参数来让方法具备多种功能。新的Bug类的构造函数,可以使用可选的参数来进行变换,如下所示:

def __init__(self, name="Bug", legs=6):
    self.name = name
    self.legs = legs

同样,Walk()方法可以升级以支持一个可选的参数:

def Walk(self,distance=1):
    self.distance += distance

数据隐藏(封装)

Python不允许变量和方法声明为私有的或受保护的,因为Python中的所有内容都是公有的。但是,如果你想要让代码像是数据隐藏一样地工作,这也是可以办到的。例如,如下这段代码可以用来访问或修改distance变量(我们假设它是私有的,即便它不是)。

def GetDistance(self):
    return p_distance
def SetDistance(self, value):
    p_distance = value

从数据隐藏的角度来看,你可以将distance重命名为p_distance(使其看上去像是私有变量),然后,使用这两个方法来访问它。也就是说,如果数据隐藏对于你的程序来说很重要的话,可以这么做。
继承

Python支持基类的继承。当定义一个类的时候,基类包含在圆括号中:

class Car(Vehicle):

此外,Python支持多继承,也就是说,一个子类可以继承自多个父类或基类。例如:

class Car(Body,Engine,Suspension,Interior):

只要每个父类中的变量和方法与其他的变量和方法不冲突,新的子类可以访问它们而毫无问题。但是,如果有任何的冲突,来自父类的冲突变量和方法在继承顺序中具有优先性。

当一个Python类继承自一个基类,父类所有的变量和方法都是可用的。变量可以使用,方法可以覆盖。当调用一个基类的构造函数或任何方法的时候,我们可以使用super()来引用基类:

return super().ToString()

但是,当涉及多继承的时候,当共享相同的变量名或方法名的时候,必须使用父类的名称,以避免混淆。

1.3.4 单继承

我们先来看看单继承的示例。如下是一个Point类,以及继承自它的一个Circle类。

class Point():
    x = 0.0
    y = 0.0
    def __init__(self, x, y):
        self.x = x
        self.y = y
        print("Point constructor")
    def ToString(self):
        return "{X:" + str(self.x) + ",Y:" + str(self.y) + "}"
class Circle(Point):
    radius = 0.0
    def __init__(self, x, y, radius):
        super().__init__(x,y)
        self.radius = radius
        print("Circle constructor")
    def ToString(self):
        return super().ToString() + \
               ",{RADIUS=" + str(self.radius) + "}"

我们可以直接测试这些类:

p = Point(10,20)
print(p.ToString())
c = Circle(100,100,50)
print(c.ToString())

这会得到如下输出。

Point constructor
{X:10,Y:20}
Point constructor
Circle constructor
{X:100,Y:100},{RADIUS=50}

我们看到Point的功能很简单,但是,Circle先调用Point的构造函数,然后才调用自己的构造函数,然后复杂地调用Point的ToString()并添加自己的新的radius属性。这真的有助于我们了解,为什么所有的类都有一个ToString()方法。

多继承是一片沼泽。我建议尽可能避免使用它,并且尽可能保持类的简单和直接,大多数情况下,可能只有一个层级的继承。尽可能地给你的类众多的功能,而不是将它们划分到多个类中。

现在,当创建Circle类的时候,调用构造函数并传递给它3个参数(100,100,50)。注意,调用了父类(Point)的构造函数来处理x和y参数,而radius参数在Circle中处理:

def __init__(self, x, y, radius):
    super().__init__(x,y)
    self.radius = radius

super()调用了Point类的构造函数,Point类是Circle类的父类或基类。当使用单继承的时候,这种做法的效果令人惊奇。

1.3.5 多继承

尽管多继承是一片沼泽,但至少还是要展示一下它是如何工作的。使用多继承的时候,我们基本上不会使用super()来调用父类中的任何内容,除非每个父类中的变量和方法都是独特的。这里有另一对类,它们构建在前面已经给出的两个类的基础之上。还记得吧,我警告过你,Python是一种看上去很奇怪的语言。我们现在来看看。别忘了,Python是一种脚本语言,而不是编译型语言。Python代码是在运行时解释的。

class Size():
    width = 0.0
    height = 0.0
    def __init__(self,width,height):
        self.width = width
        self.height = height
        print("Size constructor")
    def ToString(self):
        return "{WIDTH=" + str(self.width) + \
               ",HEIGHT=" + str(self.height) + "}"
class Rectangle(Point,Size):
    def __init__(self, x, y, width, height):
        Point.__init__(self,x,y)
        Size.__init__(self,width,height)
        print("Rectangle constructor")
    def ToString(self):
        return Point.ToString(self) + "," + Size.ToString(self)

Size类是一个新的辅助类,而Rectangle是我们这个示例中真正的焦点。这里,Rectangle将继承自Point和Size:

class Rectangle(Point,Size):

Point是早就定义了的,而Size刚刚定义。现在,我们应该可以开始使用Point.x、Point.y、Size.width和Size.height,以及每个类中的ToString()方法了。Python应该不会抱怨。但是,思路是通过调用父类的构造函数来自动初始化父类。否则,我们会丧失OOP的所有优点,并且只是在编写结构化的代码。因此,Rectangle构造函数必须按照名称来调用每个父类的构造函数:

def __init__(self, x, y, width, height):
    Point.__init__(self,x,y)
    Size.__init__(self,width,height)

注意,x和y传递给了Point.__init__(),而width和height传递给了Size.__init__()。这些变量在它们各自的类中正确地初始化。当然,我们可以只是在Rectangle中定义x、y、width和height,但是,这只是一个演示。通常,为了保持代码简单,我们不建议那么做。在真正的编程中,绝不要以这种方式使用继承。这里只是为了说明多继承。测试一下新的Size和Rectangle类:

s = Size(80,70)
print(s.ToString())
r = Rectangle(200,250,40,50)
print(r.ToString())

产生如下输出。

Size constructor
{WIDTH=80,HEIGHT=70}
Point constructor
Size constructor
Rectangle constructor
{X:200,Y:250},{WIDTH=40,HEIGHT=50}

现在,这真的有点意思了。Size足够简单,很容易理解,但是看一下Rectangle的输出。我们调用了Point的构造函数和Size的构造函数,这完全是按照计划进行的。此外,ToString()方法有效地组合了Point.ToString()和Size.ToString()各自的输出。

相关文章
|
6天前
|
搜索推荐 Python
Python上下文管理器DIY指南:从入门到精通,轻松驾驭资源管理
【7月更文挑战第6天】Python的上下文管理器是资源管理的利器,简化文件操作、网络连接等场景。通过定义类及`__enter__`、`__exit__`方法,可自定义管理器,如示例中的`MyContextManager`,实现资源获取与释放。使用with语句,提升代码可读性和维护性,不仅用于基本资源管理,还可扩展到事务控制、自动重试等高级应用,让编程更加高效和灵活。
20 0
|
7天前
|
机器学习/深度学习 数据采集 数据可视化
Python数据分析入门涉及基础如Python语言、数据分析概念及优势。
【7月更文挑战第5天】Python数据分析入门涉及基础如Python语言、数据分析概念及优势。关键工具包括NumPy(数组操作)、Pandas(数据处理)、Matplotlib(绘图)、Seaborn(高级可视化)和Scikit-learn(机器学习)。流程涵盖数据获取、清洗、探索、建模、评估和展示。学习和实践这些将助你有效利用数据。
|
4天前
|
安全 Java 调度
「Python入门」Python多线程
1. **线程与进程区别**:线程共享内存,进程独立;线程启动快,多线程效率高于多进程。 2. **多线程使用**:直接使用Thread类,通过`target`指定函数,`args`传递参数;或继承Thread,重写`run`方法。 3. **守护线程**:设置`setDaemon(True)`,主线程结束时,守护线程一同结束。 4. **join线程同步**:主线程等待子线程完成,如`t.join()`。 5. **线程锁**(Mutex):防止数据竞争,确保同一时间只有一个线程访问共享资源。 6. **RLock(递归锁)**:允许多次锁定,用于需要多次加锁的递归操作。
15 1
「Python入门」Python多线程
|
4天前
|
数据采集 XML JSON
「Python入门」Python代码规范(风格)
**Python编码规范摘要** - 编码:使用UTF-8编码,文件开头可声明`# -- coding: utf-8 --`。 - 分号:避免在行尾使用,不用于分隔命令。 - 行长:不超过80字符,长表达式可使用括号换行。 - 缩进:使用4个空格,禁止混用tab。 - 注释:行注释始于`#`和空格,块注释和文档注释遵循特定格式。 - 空行:函数和类定义间用2空行,方法间1空行,内部适当空行。 - 空格:运算符两侧各空一格,逗号后空格,括号内不空格。 - 命名:模块小写,变量下划线分隔,类驼峰式,布尔变量前缀`is_`。 - 引号:保持一致性,可使用单引号或双引号。
10 1
「Python入门」Python代码规范(风格)
|
9天前
|
测试技术 Python
|
8天前
|
数据采集 编译器 iOS开发
【Python从入门到精通】(一)就简单看看Python吧
【Python从入门到精通】(一)就简单看看Python吧
30 8
|
4天前
|
SQL 关系型数据库 MySQL
「Python入门」python操作MySQL和SqlServer
**摘要:** 了解如何使用Python的pymysql模块与MySQL数据库交互。首先,通过`pip install pymysql`安装模块。pymysql提供与MySQL的连接功能,例如创建数据库连接、执行SQL查询。在设置好MySQL环境后,使用`pymysql.connect()`建立连接,并通过游标执行SQL(如用户登录验证)。注意防止SQL注入,使用参数化查询。增删改操作需调用`conn.commit()`来保存更改。pymssql模块类似,但导入和连接对象创建略有不同。
「Python入门」python操作MySQL和SqlServer
|
4天前
|
并行计算 Java Python
「Python入门」Python多进程
本文探讨Python中的单进程和多进程。多进程使用`multiprocessing`库,如`Process`类,类似于`threading.Thread`。进程是操作系统分配资源的基本单位,每个程序至少有一个进程。多进程允许多个任务并发执行,提升效率,尤其在多核CPU上优于多线程,因Python的GIL限制了多线程的并行计算。文中通过吃饭睡觉打豆豆的例子,展示了单进程按顺序执行,多进程则可并发执行。还介绍了带参数的多进程、获取进程ID、主进程等待子进程结束及子进程守护等概念。在IO或网络密集型任务中,多线程和多进程各有优势,具体选择应根据任务类型和资源需求。
「Python入门」Python多进程
|
4天前
|
IDE PHP 开发工具
「Python入门」python环境搭建及VScode使用python运行方式
**Python 概述与环境搭建摘要** Python是一种解释型、面向对象、交互式的脚本语言,以其简单易学和丰富库著称。安装Python时,推荐在Windows上选择.exe安装程序,记得勾选“Add Python to PATH”。安装完成后,通过环境变量配置确保Python可被系统识别。验证安装成功,可在CMD中输入`python --version`。Visual Studio Code (VScode)是流行的Python IDE,安装Python插件并选择解释器后,可直接在VScode内编写和运行Python代码。
14 0
「Python入门」python环境搭建及VScode使用python运行方式
|
9天前
|
存储 JSON 测试技术
python中json和类对象的相互转化
针对python中类对象和json的相关转化问题, 本文介绍了4种方式,涉及了三个非常强大的python库jsonpickle、attrs和cattrs、pydantic,但是这些库的功能并未涉及太深。在工作中,遇到实际的问题时,可以根据这几种方法,灵活选取。 再回到结构化测试数据的构造,当需要对数据进行建模时,也就是赋予数据业务含义,pydantic应该是首选,目前(2024.7.1)来看,pydantic的生态非常活跃,各种基于pydantic的工具也非常多,建议尝试。