Python新手：我的印象与Perl / Ruby [英] New to Python: my impression v. Perl/Ruby
问题描述
我是一名长期以来的Perl程序员，虽然我没有使用过大量的包裹，也没有使用过大量的OO。
几年前，我决定研究Python和Ruby。 Python
看起来不错，但没有那么不同。我确实喜欢缩进为小组的想法，
这是不同的。 Ruby看起来非常酷。但是不可能获得好的文档。它似乎是一个日本邪教组织，有一些西方同修的b $ b $
好吧，MacOS X附带Perl，Python和Ruby（以及PHP，和。 ..）所以我
最近想到我会再试一次。我仍然觉得Ruby更有趣，
但我已经选择了Python。为什么？
好吧，Perl是一种权宜之计（对我而言）不会扩大规模并且
具有可怕的OO语法。 （所以我从来没有用过太多。）如果你要去阅读别人的Perl，你最好是在区域内。
几个月前，我写了一个快速的Perl脚本，这将是b $ b" unstick"同事的POP电子邮件。问题是基于Windows的POP
服务器太愚蠢了，实现消息不会以CRLF结束，所以它只需追加一段时间然后CRLF认为它''做得很好但是
期间不会单独排在一条线上，所以它不是有效的
终止消息。所以他们的电子邮件程序挂起等待
正确终止。叹息。
一周前，剧本破了，因为我没有正确说明
这个用户可能有数百条消息排队的事实。 （我
没有使用Perl POP包，可能已经处理过了，但只是
自己把它扔到了一起。是的，那就是使Perl代码更有价值&b $ b与其他两个解决方案竞争。）
所以我认为这可能是尝试Python的一个很好的练习。使用Python的POP3软件包，它可以非常快速地与
一起使用。然后我决定用
在Ruby中试一试。我认为代码的一小部分显示了两种文化之间的
差异。
问题是邮件没有正确终止，所以你需要
超时并抓住超时以实现嗯，畸形。在
Python我有：
M = poplib.POP3（''172.16.30.1''）;
M. user（''foo''）;
M.pass_（''bar''）
num_mesgs = len（M.list（）[1 ]）
bad_mesgs = 0
for msg in range（num_mesgs）：
try：
M.retr（msg + 1）
....等等......
如何在5秒后让它超时我该如何理解？
在线文档相当不错，但我不得不猜测POP3是在套接字包上构建的。
。看看socket的文档，我找到了正确的
命令和异常。我必须在POP3命令将默认套接字超时设置为5之前包括：
socket.setdefaulttimeout（5.0）
>
秒。除了socket.timeout之外，还有
：
是捕获超时的正确方法。这两件事都在
套接字文档中。
与Ruby对比。 Ruby文档不太完整，但他们确实提到POP是从协议中继承的，你必须查看
协议的来源，看看如何有用。通过协议查看，我想看看该做什么，它更优雅。
协议类有一个read_timeout，但是因为Ruby的口头禅可能是
据说是真正的OO，POP代码已写成你可以
说
POP打开后，pop.read_timeout = 5
，它将该弹出连接的超时设置为5
秒。几乎就像POP自动将read_timeout上游传递给socket
一样。 （我不认为Ruby会这么做，但它的编码看起来像是b
。）
我的经验有限，但感觉很棒像这个例子给两种语言带来了很好的感觉。 Python有更好的文档记录，并且很快就会出现问题。 Ruby最终有一个更优雅的解决方案，但
的记录更差。这与咒语相呼应：Python's是
Batteries Included，而Ruby'可能是Real OO。
On个人记录，我通常更喜欢优雅的解决方案，但是当
语言到目前为止考虑
0.step（360,45）<我认为这是合理的，我的头疼。我知道有语法糖，所以我
不必像那样编码。我知道一切都是一个对象。但是，
该死，一个常数整数是一个具有常数值的整数，并且
导致它迭代太过分了。
I''ve been a long-time Perl programmer, though I''ve not used a boatload
of packages nor much of the tacky OO.
A couple of years ago, I decided to look into Python and Ruby. Python
looked OK, but not that different. I did like the indent-as-group idea,
which was different. Ruby looked very cool. But it was impossible to
get good documentation. It seemed like a Japanese cult with a few
western initiates.
Well, MacOS X ships with Perl, Python, and Ruby (and PHP, and ...) so I
recently figured I''d try them again. I still find Ruby more intriguing,
but I''ve settled on Python. Why?
Well, Perl is an expedient measure that (for me) doesn''t scale up and
has that horrible OO syntax. (So I never used it much.) If you''re going
to read someone else''s Perl, you had better be "in the zone".
A couple of months ago, I''d written a quick Perl script that would
"unstick" a co-worker''s POP email. The problem is the Windows-based POP
server is too stupid to realize a message does not end in CRLF, so it
just appends a period then CRLF thinking it''s doing well. But the
period ends up not being alone on a line, so it''s not a valid
termination to the message. So their email program hangs waiting for a
proper termination. Sigh.
A week ago, the script broke because I hadn''t properly accounted for
the fact that the user might have hundreds of messages queued up. (I
hadn''t used a Perl POP package, which might''ve handled it, but just
threw it together myself. Yes, that would''ve made the Perl code more
competitive with the other two solutions.)
So I decided this might be a nice exercise to try Python. And it went
together very quickly using Python''s POP3 package. Then I decided to
try it in Ruby. I think one little portion of the code shows the
difference between the two cultures.
The problem is that the message is not properly terminated, so you need
to time out and catch that timeout to realize, "hmmm, malformed". In
Python I had:
M = poplib.POP3 (''172.16.30.1'') ;
M.user (''foo'') ;
M.pass_ (''bar'')
num_mesgs = len (M.list ()[1])
bad_mesgs = 0
for msg in range (num_mesgs):
try:
M.retr (msg + 1)
.... blah blah...
How do I get it to time out after 5 seconds and how do I catch that?
The online docs are pretty good, but I had to guess that POP3 was built
on the socket package. Looking at socket''s docs I found the proper
command and exception. I had to include:
socket.setdefaulttimeout (5.0)
before the POP3 commands to set the default socket timeout to 5
seconds. And
except socket.timeout:
is the proper way to catch the timeout. Both of these things are in the
socket documentation.
Contrast this with Ruby. The Ruby docs are less complete, but they did
mention that POP was subclassed from protocol and you''d have to look at
protocol''s source to see how it works. Looking through protocol, I
figured out what to do and it was more elegant.
The protocol class had a read_timeout, but since Ruby''s mantra might be
said to be "Real OO", the POP code had been written such that you could
say
pop.read_timeout = 5
after the POP open and it set the timeout for that pop connection to 5
seconds. Almost as if POP passed the read_timeout upstream to socket
automatically. (I don''t think Ruby does, but it''s coded to look that
way.)
My experience is limited, but it feels like this example gives a good
feel for the two languages. Python was better documented and things
came together quickly. Ruby ultimately had a more elegant solution, but
was more poorly documented. This echoes the mantras: Python''s is
"Batteries Included", while Ruby''s might be "Real OO".
On a personal note, I usually prefer an elegant solution, but when the
language goes so far as to consider
0.step(360, 45)
to be reasonable, my head hurts. I know there''s syntactic sugar so I
don''t have to code like that. I know everything''s an object. But,
dammit, a constant integer is an integer with constant value and
causing it to iterate is a step too far.
推荐答案
Wayne Folta< wf **** @ netmail.to>写道：
[...]
Wayne Folta <wf****@netmail.to> writes:
[...]
所以我认为这可能是一个很好的练习Python。使用Python的POP3包很快就能完成它。然后我决定在Ruby中试用它。我认为代码的一小部分显示了两种文化之间的差异。
问题是消息没有正确终止，所以你需要超时和抓住那个超时来实现，嗯，格式错误。
在Python中我有：
M = poplib.POP3（''172.16.30.1''）;
M .user（''foo''）;
M.pass_（''bar''）
num_mesgs = len（M.list（）[1]）
bad_mesgs = 0
对于范围内的msg（num_mesgs）：
尝试：
M.retr（msg + 1）
...等等......等等/>
如何在5秒后让它超时？我如何抓住它？
在线文档非常好，但我不得不猜测POP3是建立在套接字包。看看socket的文档我找到了
嗯，如果知道
互联网是如何运作的话，这并不是一个巨大的飞跃。我不确定Python的文档是否应该在教育人们的事务中...
正确的命令和异常。我不得不包括：
socket.setdefaulttimeout（5.0）
在POP3命令之前将默认套接字超时设置为5
秒。
除了socket.timeout：
是捕获超时的正确方法。这两件事都在套接字文档中。
....但是在套接字模块的客户端模块中没有超时支持的事实是套接字模块是一个已知的错误：
http://www.python.org/peps/pep -0042.html
http：//www.python。 org / sf / 723287
它很可能在2.4中修复。套接字上的超时仅仅是在Python 2.3中引入的
（虽然在此之前很长一段时间内有一个第三方库
将改进的超时改为
标准库）。
与Ruby对比。 Ruby文档不太完整，但他们确实提到POP是从协议中分类的，你必须看看协议的来源，看看它是如何工作的。通过协议查看，我想知道该怎么做，它更优雅。
好吧，如果Python的标准库已经决定从一些''协议''基类中继承所有内容，那么文档确实会提到
事实上，因为那是关于Python标准库的事实，而不是关于网络的一般情况。它没有，所以它没有。
协议类有一个read_timeout，但由于Ruby的口头禅可能被称为真正的OO，POP代码已写成你
So I decided this might be a nice exercise to try Python. And it went
together very quickly using Python''s POP3 package. Then I decided to
try it in Ruby. I think one little portion of the code shows the
difference between the two cultures.
The problem is that the message is not properly terminated, so you
need to time out and catch that timeout to realize, "hmmm, malformed".
In Python I had:
M = poplib.POP3 (''172.16.30.1'') ;
M.user (''foo'') ;
M.pass_ (''bar'')
num_mesgs = len (M.list ()[1])
bad_mesgs = 0
for msg in range (num_mesgs):
try:
M.retr (msg + 1)
... blah blah...
How do I get it to time out after 5 seconds and how do I catch that?
The online docs are pretty good, but I had to guess that POP3 was
built on the socket package. Looking at socket''s docs I found the
Well, that''s not exactly a huge leap given any knowledge of how the
internet works. I''m not sure that Python''s docs should be in the
business of educating people about that...
proper command and exception. I had to include:
socket.setdefaulttimeout (5.0)
before the POP3 commands to set the default socket timeout to 5
seconds. And
except socket.timeout:
is the proper way to catch the timeout. Both of these things are in
the socket documentation.
....but the fact that there is no timeout support in client modules of
the socket module is a known bug:
http://www.python.org/peps/pep-0042.html
http://www.python.org/sf/723287
It''s likely to be fixed in 2.4. Timeouts on sockets were only
introduced in Python 2.3 (though there was a third party library
around for a long time before that that retrofitted timeouts into
the standard library).
Contrast this with Ruby. The Ruby docs are less complete, but they did
mention that POP was subclassed from protocol and you''d have to look
at protocol''s source to see how it works. Looking through protocol, I
figured out what to do and it was more elegant.
Well, if Python''s standard library had decided to subclass everything
from some ''protocol'' base class, the docs would indeed mention that
fact, since that''s would be a fact about the Python standard library
rather than about networking in general. It didn''t, so it doesn''t.
The protocol class had a read_timeout, but since Ruby''s mantra might
be said to be "Real OO", the POP code had been written such that you
[...]
在没有对什么做出某些解释的情况下你的意思是真实的OO，
听起来很无聊。
我不知道Python中缺少的功能如何显示< Python和Ruby之间的文化，除了Ruby
之外，人们喜欢实现继承，而不是那些设计了Python标准库的人。
John
[...]
In the absence of some explanation of what you mean by "Real OO", that
sounds trollish.
I don''t see how a missing feature in Python reveals any difference in
culture between Python and Ruby, other than perhaps that the Ruby
people like implementation inheritance more than the people who
designed the Python standard library.
John
John，
我认为这里有一个问题就是我不知何故离开了一个段落我的
原始帖子。经过多年的Perl使用，我评估了Ruby
和Python，并采用了Python。 Ruby引起了我的兴趣，但它并不是我用来完成任务的
。我认为作为两个人的新手，我虽然可能与那些以b $ b b本地用户的人有不同的观点，因此我发帖。
我可以看到，如果没有这些信息，可能看起来我是
可能提倡Ruby而不是Python，这对于一个不合适的
Pyton论坛。我为这种混乱道歉！
John,
I think one problem here is that somehow I left a paragraph out of my
original posting. After years and years of Perl use, I evaluated Ruby
and Python and have adopted Python. Ruby intrigues me, but it''s not
what I will use to get things done. I thought that as a newcomer to
both, I though I might have a different perspective from people who
were native users, hence my posting.
I can see that without that info, it may have appeared that I was
possibly advocating Ruby over Python, which would be inappropriate in a
Pyton forum. I apologize for the confusion!
嗯，如果知道互联网是如何运作的话，这并不是一个巨大的飞跃。我不确定Python的文档应该用于教育人们的业务......
之间没有必要的联系协议栈和软件
包。 POP3是基于套接字构建的，这是好的和明智的，但它可以基于my_sockets或_socket或者谁知道什么是基于
。我不是要求将整个协议栈记录下来，并且它并不像
明显那样。事情没有在Python的其他地方详细记录。 （对于
的例子，套接字'gethostname（）上有一整段。我可以用
修辞说这很明显它应该用'替换' ;返回
主机名或参见GETHOSTNAME（3）"？）
对我来说，这对我来说是完全自然的说，POP3包是使用套接字包构建的
并且套接字异常不会被
POP3捕获。那句话立即告诉我我需要的一切
知道。这就是我记录任何更高级别的套餐的方式，无论是否有明显的底层套餐候选人（或
班级）是否b / b
。对我来说，它基本上提到了
函数返回的类型，或者它的参数是什么类型，或者是另一个类的
子类。 br />
...但是套接字模块的客户端模块中没有超时支持的事实是一个已知的错误：
这是一个错误？我想这可能会导致底层软件包出现问题，
但我肯定希望处理异常，然后重新提升为
timeout_proto或者与error_proto不同的东西。我个人
更喜欢细粒度的异常，我认为最好利用
多个 - 除了try子句。我讨厌抓东西然后不得不通过变量排序来弄清楚究竟发生了什么。
从外部的角度来看，我看不出那么大的差异
修复之间这个bug，只是简单地记录了你可能会从底层软件包中看到的其他异常。
如果没有对Real OO的含义进行一些解释，那<听起来很有说服力。
没有拖钓意图。我只是已经阅读了Python拥护者所说的关于Python的内容以及Ruby拥护者对Ruby的看法（与像Python这样的b
语言相比）并说了这些。我没有对
现实作出任何陈述，而仅仅是关于鼓吹咒语是什么。 （或者实际上，我小心翼翼地说，可能是。）
（实际上，现在我重读了它，我应该'说纯粹的OO，我相信它更能反映他们的陈述。而且这有一些基础
其实我相信，如果你看一下v1 Ruby和Python以及什么
是一流的，什么不是。）
我不知道Python中缺少的功能是如何显示出来的Python和Ruby之间的文化，除了Ruby
人们喜欢实现继承之外，还有比设计Python标准库的人更多。
Well, that''s not exactly a huge leap given any knowledge of how the
internet works. I''m not sure that Python''s docs should be in the
business of educating people about that...
There''s no necessary connection between the protocol stack and software
packages. It''s good and sensible that POP3 is built on socket, but it
could be based on my_sockets or _socket or who knows what. I''m not
asking that the entire protocol stack be documented, and it''s not as if
"obvious" things aren''t documented in detail elsewhere in Python. (For
example, there''s an entire paragraph on socket''s gethostname(). I could
rhetorically say this is so obvious it should be replace with "returns
host name" or "see GETHOSTNAME(3)"?)
For me, it''s just totally natural that I''d say, "The POP3 package is
built using the socket package and socket exceptions are not caught by
POP3." That single sentence immediately tells me everything I needed to
know. That''s the way I''d document any higher-level package, regardless
of whether there was an obvious candidate for underlying packages (or
classes) or not. For me, it''s as basic as mentioning what types a
function returns, or what types its arguments are, or what class is a
subclass of another.
...but the fact that there is no timeout support in client modules of
the socket module is a known bug:
This is a bug? I guess it can cause problems in the underlying package,
but I sure hope that the exception is handled and then re-raised as
timeout_proto or something distinct from error_proto. I personally
prefer fine-grained exception, which I believe best takes advantage of
multiple-except try clauses. I hate catching something then having to
sort through variables to figure out what really happened.
From an external viewpoint I don''t see that much difference between
"fixing" this bug and simply documenting the other exceptions you might
see from underlying packages.
In the absence of some explanation of what you mean by "Real OO", that
sounds trollish.
No trolling intended. I simply have read what Python advocates say
about Python and what Ruby advocates say about Ruby (in comparison to
languages like Python) and said that. I''m making no statement about
reality, but simply about what advocates mantras are. (Or actually, as
I carefully said, "might be".)
(Actually, now that I reread it, I should''ve said "pure OO", which I
believe is more reflective of their statements. And this has some basis
in fact, I believe, if you look at the v1 of Ruby and Python and what
is first-class and what is not.)
I don''t see how a missing feature in Python reveals any difference in
culture between Python and Ruby, other than perhaps that the Ruby
people like implementation inheritance more than the people who
designed the Python standard library.
你已经接受了我的观察并将其转化为我的
部分的无知以及Python上的假设错误。一旦你做到了，是的，
它不再是启发性的。
再次，正如你自己所说，他们选择了子协议服务<一个类''协议''的
和Python没有。事实上，Python选择了
而不是任何东西的子类POP3。为什么？因为文化，在我的b $ b意见中。 Ruby强调OO并且它是纯粹的OO。 （他们的意见）和
所以一个实现涉及一个Smalltalk-ish子类化
一切都推荐自己。
Python有一种不同的文化，这种严格的树状类
结构不推荐自己。 Python的'电池包括'
哲学导致更直接和（大部分）更好的b / b
记录的方式。
从理智上讲，我更喜欢Ruby。 Ruby和Smalltalk引起了我的兴趣。但是
纯OO方法（这次我的话）很烦人，甚至在一些
点不一致，正如我在段落中提到的关于0.step（）。我觉得Python已经得到了正确的平衡，它的OO和漂亮的b $ b完全如此，但不是狂热的。这就是我所采用的。
你可以看到这三种语言是由中央
个性推动的，用户群反映这些人物。之前
Perl是各种语言和shell / awk / sed。 Larry在半脚本，权宜之计的测量区域中进行了三角测量，并在一个标记中插入了一面旗帜。
（我的意思是做什么，瑞士军用电锯。）他的辉煌在于将一个非常不同的工具捆绑在一起，用一种语法挂在一起，然后做了正确的事情。基于这些其他工具的工作原理。
（而且他摆脱了shell脚本的一些弱点，比如
替代评估，那里有因为他们首先是互动的，然后成为脚本语言。不知怎的，TCL没有学到这样的教训，我从来没有喜欢它。） />
不幸的是，权宜之计不能很好地扩展，而且Perl已经有了一个名言所说的，超出了它的性能范围。
（可能在第5版。）
Guido能够向Perl学习，并更倾向于使用脚本编写更远的语言
语法更清晰，更实用
OO等等。但他保留了我认为最好的Perl'权宜之计
哲学。 （包含电池。）
Matz看到了这两个并且选择了纯，Smalltalk-ish OO。他还保留了Perl的一些权宜之计，但更多的是语法方式。所以我发现Ruby是一个几乎狂热的OO哲学的奇怪组合
但同时也是一种权宜之计。
只是我的意见。但总的来说，我更喜欢Python。对我来说感觉很对。
OO但不是我称之为Ruby的狂热OO。清洁语法。好的
包捆绑。不知怎的，我会说它的语法不太灵活，但是更灵活的哲学。 （这很好。）
（好的，有一件事是我在MacOS X和Python的EasyDialogs是
非常方便并且有吸引力，其他程序似乎没有.b $ b b等价。对我来说，使用
编程并不是没有意义的事情。允许在具有如此出色GUI的
机器上与用户轻松进行GUI交互。）
You have taken my observation and transformed it into ignorance on my
part and a supposed bug on Python''s part. Once you''ve done that, yes,
it is no longer illuminative.
Again, as you yourself say, they chose to subclass protocol services
off of a class ''protocol'' and Python did not. In fact, Python chose to
not subclass POP3 from anything. Why? Because of the culture, in my
opinion. Ruby emphasizes OO and that it''s "pure OO" (their opinion) and
so an implementation that involves a Smalltalk-ish subclassing of
everything recommends itself.
Python has a different culture where such strict tree-like class
structure does not recommend itself. Python''s "batteries included"
philosophy resulted in a more straightforward and (mostly) better
documented way to do it.
Intellectually, I prefer Ruby. Ruby and Smalltalk intrigue me. But the
"pure OO" approach (my words this time) is annoying, and even at some
point inconsistent, as I mentioned in my paragraph about 0.step(). I
feel like Python has got the right balance where it''s OO and pretty
much fully so, but not fanatically so. And it''s what I''ve adopted.
You can see that the three languages have been driven by central
personalities and the user groups reflect these personalities. Before
Perl were various languages and shell/awk/sed. Larry triangulated
things and stuck a flag in the semi-script, expedient measure area.
("Do what I mean", "Swiss Army Chainsaw".) His brilliance was in tying
very disparate tools together in one syntax that hung together and did
the "right thing" based on how these other tools worked.
(And he got away from some of the weaknesses of shell scripts, such as
substititional evaluation, which were there because they were
interactive first, then became scripting languages. Somehow TCL didn''t
learn this kind of lesson and I''ve never liked it.)
Unfortunately, expedient measures don''t scale well and Perl has, as
someone famous said, pushed well beyond its performance envelope.
(Probably in v5.)
Guido was able to learn from Perl and moved more towards a language
that was farther removed from "scripting" with a cleaner syntax, solid
OO, etc. But he kept what I''d consider the best of Perl''s expediency
philosophy. ("Batteries Included".)
Matz saw both of these and went for a "pure", Smalltalk-ish OO. He also
kept some of Perl''s expediency, but in more of a syntactic way. So I
find Ruby to be a strange combination of almost fanatical OO philosophy
but at the same time an expediency of syntax.
Just my opinion. But in summary, I prefer Python. It feels right to me.
OO but not what I''d call the fanatical OO of Ruby. Clean syntax. Good
packages bundled. Somehow, I would say it has a less-flexible syntax,
but more-flexible philosophy. (Which is good.)
(OK, one thing to add is I''m on MacOS X and Python''s EasyDialogs is
VERY convenient and attractive and the other programs don''t seem to
have an equivalent. It just doesn''t make sense for me to program with
something that doesn''t allow for easy GUI interaction with a user on a
machine with such a great GUI.)
Wayne Folta < WF **** @ netmail.to>在留言中写道
新闻：ma ************************************ ** @ pyth on.org ...
"Wayne Folta" <wf****@netmail.to> wrote in message
news:ma**************************************@pyth on.org...
对我而言，我说使用套接字包构建POP3包是完全自然的
POP3没有捕获和套接字异常。那句话立即告诉我我需要知道的一切。
如果您认为这是一个doc bug或缺陷，请转到sourceforge，如果您没有，请注册
，转到
http://sourceforge.net/tracker/?grou...70&atid= 105470
并提交doc bug。给出一个像上面这样的具体建议，给出
LibRef部分编号和段落和句子编号，你可以把它放在
上。还给出了理由（我剪了一下）解释了你作为新人如何不必要地困惑，误导或其他什么。如果其中一个doc
维护者同意，正如他们对我的大多数建议一样，他们会在LaTex主副本中添加
。 （也可以接受LaTex源补丁，
那些能够做到这一点的人。）这就是文档不断改进的方式。
没有拖钓意图。
For me, it''s just totally natural that I''d say, "The POP3 package is
built using the socket package and socket exceptions are not caught by
POP3." That single sentence immediately tells me everything I needed to
know.
If you consider it a doc bug or deficiency, go to sourceforge, register if
you have not, go to
http://sourceforge.net/tracker/?grou...70&atid=105470
and file a doc bug. Give a specific suggestion like the above, giving the
LibRef section number and paragraph and sentence number where you would put
it. Also give rationale (which I snipped) explaining how as newcomer you
were unnecessarily puzzled, mislead, or whatever. If one of doc
maintainers agree, as they have with most of my suggestions, they will add
to the LaTex master copy. (Patches to LaTex source are also accepted, for
those who can make such.) This is how docs keep getting better.
No trolling intended.
我从没想过。你显然已经非常认真地看了三种语言，给他们一个公平的个人评价 - 并且来'
''正确'的结论;-)。
Terry J. Reedy
I never thought so. You have obviously looked pretty carefully at all
three languages, given them a fair if personal evaluation -- and come to
the ''right'' conclusion ;-).
Terry J. Reedy
这篇关于Python新手：我的印象与Perl / Ruby的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
