Medien- und Kommunikationsinformatik

Hochschule Reutlingen
greg.rauhoeft@student.reutlingen-university.de
Abstract: The goal of this document is to offer a direct comparison of the
programming languages H and ython and to check if an empirical and
situational decision can !e made a!out the superiority of one of the languages over
the other. The findings of this study are !ased on the current sta!le releases of
these languages" #hich are H $.%.& and ython %.'." as these are likely to present
the current state of the art of their underlying technologies. The conclusions is
!ased on a num!er of different factors that can !e deemed useful for deciding #hat
language to choose for a certain purpose. The research covers a #ide area of
relevant topics instead of focusing on a single one.
1. Preface
To understand the status (uo of H and ython it may !e useful to first kno# a!out the
origins of !oth languages.
1.1 A Brief History of PHP
H #as initially developed as a set of )R* scripts to create simple dynamic #e!sites
!y Rasmus *erdorf in +,,$ -H'.++-'&/. 0fter a reimplementation and e1pansion in 2
and a source release" it (uickly gained popularity to !e present on +3 of the internets
domains !y +,,4 -H'.++-'&/. 0ndi Gutsman and 5eev 6uraski decided to colla!orate
#ith *erdorf to improve H" as they considered it underpo#ered for e2ommerce use"
resulting in the development of H %" #hich is the !asis of #hat H is today
-H'.++-'&/. 7n +,,8 6uraski and Gutsman re#rote the H core and developed the
5end )ngine -H'.++-'&/. 9y '..+ H had developed into more than a language for
dynamic #e!sites #ith the first release of H-GTK" #hich ena!les developers to #rite
standalone G:7 applications in H -H'..8/. Today" #ith H $" it runs on the 5end
)ngine '.. -H'.++-'&/.
+
PHP vs Python: A Decision
Greg Rauhft
1.2 A Brief History of Python
ython #as developed from its conception !y Guido van Rossum in +,,. -6;'.++-'</
as a general purpose" open source -6;'.++-'$/ scripting language. 7n the year '..+ the
ython 6oft#are ;oundation =6;> #as founded -6;'.++-'$/ as a non-profit
organi?ation to @promote" protect and advance the ython programming languageA
-6;'..,/. '..8 sa# the latest maBor ython release #ith ython %.. -6;'.++-'$/ that
also !roke !ack#ards compati!ility -C'.++/. 0lthough the ython '.1 !ranch is still
!eing developed" it #ill !e phased out and replaced !y the ython %.1 !ranch -C'.++/.
1.3 Introduction
0l!eit H formerly !eing a speciali?ed language for the easy creation of dynamic
#e!sites" it has steadily developed in to a general purpose language that matches ython
in feature completeness and maturity. Chile H is still mainly used as a server side
scripting language it is no longer descri!ed as only such on its official #e!site" also
citing its 2*7 and H-GTK features -H'.++-'4/. ython #as developed as a general
purpose language from scratch so it has never !een pressed in to a certain niche. Due to
these circumstances this study #ill focus primarily on #hat H has gained on ython
regarding general purpose programming. Enly in server-side scripting sector #ill #e
concentrate on ho# ython matches up #ith H. 2oncerning the general language
features !oth languages #ill !e treated as e(ual.
To compare !oth languages" certain aspects" such as language features and uses common
to !oth languages" #ill !e compared directly. This is !y no means complete or definitive"
!ut merely an overvie#" as comparing all features #ould e1ceed the limitations of this
document.
The criteria for the choice of language aspects to compare is !ased on practical
considerations to !e taken to#ards the application of programming languages in general.
This is separated in to t#o partsF General features !elonging to the language and uses of
the languages.
7n the overvie# of the language" documentation #as considered a compara!le aspect" as
a poorly or incompletely documented language is harder to use" cannot !e utili?ed in its
entirety and the outcome of a program may !e une1pected" creating an insecure lia!ility
for the producers and customers alike. 7n addition" the synta1 of the languages #as taken
in to consideration" as a clear and simple synta1 can make it easier for other people to
read and understand the code" making code revie#s and programming in a team easier.
To provide insight in to alternative usage scenarios of the language" a revie# of the
various implementations of !oth languages is provided. 7n more technical terms" gar!age
collection is an aspect of a language that is especially important for long running
programs that fre(uently create o!Bects. 0s such it should !e taken in to consideration
#hen comparing languages for general programming use. This goes hand in hand #ith
the languages type system" as a #eak typing system" especially in an o!Bect oriented
language" can lead to errors that are not necessarily o!vious and" as such" hard to find. 0s
dynamic languages are often used as em!edded scripting languages that may also re(uire
'
an e1tended feature set" em!edda!ility and e1tensi!ility #ill also !e taken in to account.
The final aspects taken revie#ed in the language section are the programming paradigms
that can !e used #ith the language and ho# these can !e utili?ed. These include the
o!Bect oriented =including instances and inheritance>" functional and concurrent
paradigms.
2oncerning the usage of the languages" the most important one for comparison purposes
may !e #ith #e! servers" as this is #here H is most commonly used. Regarding the
*0M stack the comparison #ill go in to more detail" as the @A in *0M can stand for
H or ython =or )R* for that matter>. The 2*7 features of the languages #ill also !e
considered" !ecause this most !asic form of human-computer interaction supplies output
for developers and can !e an important de!ugging and testing tool. Got to mention the
programs that actually use the command line for all their interactions" as they may lack a
G:7. To e1pand upon this" the use of the languages for standalone applications #ill !e
compared" as the use of a general purpose programming language should go !eyond
!eing em!edded or called to perform a certain task for its host program. To perform any
general #ork in a production environment" a rich set of li!raries should !e availa!le to
perform various tasks. Re#riting everything a proBect may re(uire is not a feasi!le task
and a #aste of time" so an overvie# of a diverse set of li!raries #ill also !e given.
0s seemingly no citation-#orthy literature comparing H and ython has previously
!een #ritten" most points of criticism are taken from e1amining their respective official
documentation and #e!sites and comparing these.
2. Language
2.1 Docuentation
H has a single documentation that covers all versions from <.+.. to $.1.1 -H'.++-
+/. Hersion specific information is on the same pages as general information. Despite
!eing very e1tensive" covering all the topics necessary to understand the language" it
lacks a formal language and grammar description in a 9G;-like #ay. This can only !e
ac(uired !y do#nloading the H source code and reading the parser specific source
files contained #ithin it. 0t the time of #riting large parts of the documentation #ere
also incomplete" especially regarding the internals of the 5end )ngine -H'.++-'/. The
H documentation also features a system for user contri!uted notes" #hich allo#s users
of the language to add their o#n e1periences a!out the presented topic" giving hints to
pitfalls and common usage scenarios -H'.++-%/.
ython has separate documentations for every version" salvaging the documentation of
previous versions for unchanged features. 7t uses a modified 9G; grammar notation for
le1ical analysis and synta1 description. -6;'.++-+/
0s the documentations for !oth languages are very e1tensive and feature e1amples and
tutorials" it makes it easy for programmers to learn the languages. The large li!rary
references ena!le programmers to e1tend their kno#ledge and solve specific tasks
(uickly #ith the tools the languages have to offer. 0lthough HIs policy of having one
%
documentation for all versions makes it easy to see #here differences occurred" it does
clutter up the pages and since programmers are likely to use one version of a language to
perform one specific task" the ython documentation is more concise. 9oth the H and
the ython documentation offer lists of update notes that sho# #here differences to
previous versions are. This is likely to !e the !etter approach.
The lack of an easy #ay to access HIs formal synta1 description makes it
unnecessarily hard to fully understand ho# the language #orks in detail and to
implement custom parsers or synta1 highlighters" and the lack of proper documentation
of the 5end )ngineIs internals makes it unnecessarily hard to e1tend and em!ed H. 7t
seems HIs lacking official documentation is compensated through a large amount of
third party !ooks. 0 search on ama?on.co.uk in the @2omputing J 7nternetA section
returns 84.% results for @HA and only %'., results for @ythonA =data from
++..8.'.++>. 7nterestingly enough" a search of the @7)))Kplore Digital *i!raryA
=httpFLLieee1plore.ieee.org> returns almost the same amount of results for @ythonA ='4.
results as of +'..8.'.++> as it does for @HA ='8$ results as of +'..8.'.++> in the
@2omputing and rocessingA section" hinting that !oth languages garner a!out the same
amount of academic interest.
2.2 !ynta"
H #as designed to !e easily em!edda!le in documents containing other data than only
H code. 7t is for this reason that even a pure H file contains a slight overhead in
tags marking the !eginning and end of a H section =commonly <?php and ?>
respectively>. The trivial case of a pure H file #ill have the opening tag right at the
!eginning and the closing tag right at the end of it #hile a file can !e filled #ith an
other#ise ar!itrary num!er of opening and matching closing tags" as the H parser
ignores =or outputs> everything outside of them -H'.++-</.
The general synta1 features elements from 2" Mava and )R* and as such is dominated
!y 2-like !races" Mava-like key#ords and )R*-like varia!les -H'.++-$/. The H
grammar contains inconsistencies in case sensitivity though. 0s such @the varia!le names
are case-sensitive !ut the function names are non-case sensitiveA -2ho.8" p. %/.
0 very different approach #as taken #ith ythonIs synta1. 7nstead of using !races for
structuring code" it uses different levels of indentation. This causes ython to enforce an
implicit coding style" as variations in indentation can either lead to errors or to semantic
differences -6;'.++-'/. ;urthermore" many of ythons operators can either !e #ritten
as sym!ols or as #ords" ena!ling programmers to adopt a coding style that looks and
feels more like a set of )nglish sentences -6;'.++-%/.
Chile HIs synta1 makes it easy for Mava and 2 programmers to migrate to H" due to
itIs familiar look and feel" it does nothing ne# for reada!ility. Due to ython forcing a
certain coding style upon programmers it can make code easier to maintain" as it isnIt
necessary to get accustomed to another programmerIs coding style #hen reading foreign
code. 7ndentation is a common coding style taught in programming courses and can
make code easier to read. ythonIs dependence on indentation removes an error source
that remains in H.
<
2.3 I#$eentations
The standard ython implementation is called 2ython and is" as the name might imply"
#ritten in the 2 language. -6;'.++-+/ To !roaden ythonIs range of usefulness" several
other ython implementations #ere developed" targeting specific platforms" including
Mava #ith Mython and the .G)T ;rame#ork #ith 7ronython. These platform-specific
implementations #ere #ritten in the corresponding target platforms primary languages"
Mava -MC96G'.+./ and 2N -7'.++/ respectively" and make use of their runtime
environments" the Mava Hirtual Machine -MC96G'.+./ and MicrosoftIs 2ommon
*anguage Runtime -7'.++/. 0s such" Mython and 7ronython have access to their host
environments li!raries and vice versa -MC96G'.+./-7'.++/.
0 different approach #as taken !y the developers of the yy ython implementation.
yyIs implementation language is a su!set of ython its self" called Rpython" #hich can
!e converted to 2 code and compiled natively -'.++-'/. 7t claims to !e faster than
2ython in many !enchmarks" as it uses Must-7n-Time compilation or can !e used
stackless to run #ith micro threads -'.++-+/. ;urthermore yy can also run on the
Mava Hirtual Machine and in MicrosoftIs 2ommon *anguage Runtime -'.++-+/.
6tackless ython is a ython implementation that #as specifically #ritten to @reap the
!enefits of thread-!ased programming #ithout the performance and comple1ity
pro!lems associated #ith conventional threadsA -6*'.++-+/. This su!Bect #ill !e
covered in more detail in the section of this paper a!out concurrency.
The standard implementation of H comes in the form of the 5end )ngine ' as of H
$ -H'.++-&/. 7t #as #ritten in the 2 language. H also has a range of alternative
implementations opening the language to different usage scenarios. roBect 5ero" a
@technology incu!ator proBectA -5'..8-+/ for 79MIs @Ce!6phere sMashA -5'..8-+/
contains an implementation #ritten in Mava -5'..8-+/" that still lacks the H function
li!rary" as the focus #as on @language level constructsA -5'..8-+/ up to no#. 7t does"
ho#ever" allo# programmers to #rite H e1tensions in Mava -5'..8-+/.
halanger is a compiler for H" that translates H into the Microsoft 7ntermediate
*anguage to run on MicrosoftIs 2ommon *anguage Runtime -H'.++-+/. 0s such" it
also allo#s for using o!Bects #ritten in other .G)T languages to !e accessed from H
and vice versa -H'.++-+/.
Developers at face!ook #rote a compiler for the H language called @HipHopA that
allegedly @transforms H source code into highly optimi?ed 2OOA -HH'.++-+/" #hile
removing and replacing certain features of the language -HH'.++-+/.
HIs lack of a formal synta1 description makes it hard to #rite other implementations
of the language" #hich is evident !y the lack of complete alternative implementations"
thus limiting HIs usefulness as a multi-purpose scripting language. ythonIs
implementations allo# for a #ide range of usage scenarios and can easily !e used in
proBects that re(uire the cooperation of multiple programming languages.
2.% &arbage 'o$$ection
ythonIs main method of gar!age collection is !y reference counting -6;'.++-</.
$
)very o!Bect has a counter for the num!er of varia!les referencing it -6;'.++-</. 0s
soon as the reference count reaches ?ero" the memory is freed -6;'.++-</. 7n addition
ython also has a cycle detector to detect if a reference to an o!Bect is directly or
indirectly to its self -6;'.++-</. Ence detected it can free these cycles as soon as they
arenIt referenced from any#here else -6;'.++-</.
ythonIs gar!age collector can !e controlled" activated or deactivated and run via its
Gar!age 2ollector 7nterface" called @gcA -6;'.++-$/. 7n addition it @provides access to
unreacha!le o!Bects that the collector found !ut cannot freeA -6;'.++-$/ as #ell as
access to a list of all o!Bects tracked !y the collector -6;'.++-$/. ;urthermore"
de!ugging of the gar!age collection process can !e ena!led from #ithin ython" offering
information a!out leaks" collecta!le and non-collecta!le o!Bects and general collection
statistics -6;'.++-$/. The collection threshold that decides #hen the gar!age collector
is run can also !e set at runtime -6;'.++-$/.
H also uses reference counting for gar!age collection along #ith cycle detection for
self referencing o!Bects -H'.++-8/. 7t frees memory as soon as a re(uest ends or the
reference count reaches ?ero -H'.++-8/. H user control for the gar!age collector is
more limited. 7t only allo#s to !e instructed to !e ena!led" disa!led or run -H'.++-4/.
9y default the gar!age collector in H runs #hen +..... roots are created -H'.++-
8/. This constant cannot !e altered at runtime or in any H settings. 7t re(uires a change
in HIs source code and a su!se(uent recompilation -H'.++-8/.
Despite H and ython using similar approaches for gar!age collection" the greater
control ython offers over the process allo#s for more precise optimi?ation of it. The
information ythonIs gar!age collector offers at runtime can allo# for dynamic
collection optimi?ation and highlight leaks and shortcomings in efficiency that arenIt
currently possi!le #ith HIs implementation. 0lso" the fact that HIs collection
fre(uency cannot !e t#eaked" e1cept through the recompilation of the entire source
code" makes H less suita!le for long running applications" such as G:7 or server
applications.
2.( )y#e !yste
H is a #eakly typed language" #hich allo#s for something the H manual refers to
as @type BugglingA -H'.++-,/ #hich is the implicit conversion !et#een various
primitive and a!stract data types through operators -H'.++-,/. 0s such" H thro#s
no e1ception and generates no #arnings if" for e1ample" the instance of a class is added
=O> to the instance of another class" #hich produces the counter-intuitive result of an
integer #ith the value of '. H also allo#s for e1plicit type casting to primitive types
follo#ing a synta1 e(uivalent to the one used in 2. This can also lead to counter-intuitive
results" such as the conversion of the empty string or a string #ith the value of @.A !oth
evaluating to false if casted to a !oolean -H'.++-+./.
ython uses strong typing as #ell as duck typing as its typing disciplines. 6o in spite of
operations on primitive types re(uiring e1plicit type conversion =e.g. int(5)+5>
-6;'.++-8/" methods #ith the same names and signatures from different classes can !e
called in the same #ay #ithout prior casting and #ithout sharing a common !ase class
&
declaring said methods -6;'.++-4/. This allo#s for a kind of polymorphism that
doesnIt rely on inheritance -6;'.++-4/" #hich can flatten an inheritance tree if used
accordingly. Type conversion #orks in an o!Bect oriented manner in ython" as the type
conversion operators are simply calls to the corresponding !uilt in types constructors
=such as int()> -6;'.++-&" int/.
6eeing as H #as initially developed for server side scripts #here security is crucial"
itIs #eak typing discipline seems dangerous and out of place" as errors caused !y
unchecked and accidental type conversions are not only hard to find !ut can also lead to
une1pected !ehaviour and results -2ho.8" p. +/. ythonIs approach inhi!its this kind of
danger !y re(uiring e1plicit type conversions" thus making it harder for un#anted or
accidental conversions to go unnoticed. ;urthermore" ythonIs approach to type
conversion via constructors instead of a separate language construct as it is in H is
more conse(uent and fits into the nature of the language" #here everything is an o!Bect.
2.* E"tensibi$ity
ython offers t#o distinct #ays to e1tend the language. The first one is through using
ythonIs 2 07 to define a ne# module -6;'.++-+./. This ena!les ython to call native
2 code -6;'.++-+./. The second one is through using ythonIs @ctypesA module" #hich
is part of its Generic Eperating 6ystem 6ervices -6;'.++-,/. This module @provides 2
compati!le data types" and allo#s calling functions in D**s or shared li!rariesA
-6;'.++-,/" thus allo#ing programmers to #rap functionality #ritten in 2 in ython
code.
6imilarly to ython" HIs 5end engine also offers a 2 07 for programming e1tensions
in 2 and allo#s the calling of 2 code from #ithin H -H'.++-'/. 0s large parts of
the documentation a!out the 5end engineIs internals are missing -H'.++-'/ at the time
of #riting" no further Budgement can !e made a!out it at the current time.
)1tending H and ython re(uires a similar amount of effort from sides of the
programmer and #orks very similarly in code. ythonIs ctypes module" ho#ever" can
make the portation of e1isting li!raries significantly easier. The lack of a complete
documentation for HIs 5end )ngineIs internals makes learning the skill of e1tending
the language more trou!lesome than #ith ython.
2.+ Ebeddabi$ity
ython offers t#o separate #ays to !e em!edded in other applications. The first one is
called @Hery High *evel )m!eddingA -6;'.++-++/. 7t allo#s a string of ython code to
!e sent directly to the ython interpreter #ithout using system calls -6;'.++-++/. This
doesnIt allo# for direct interaction #ith the ython application though -6;'.++-++/. To
achieve this" ython offers a method called @ure )m!eddingA -6;'.++-++/. 7t #orks
like e1tending ython" #ith the e1ception that ython code is called from 2 code instead
-6;'.++-++/. Through the com!ined use of @ure )m!eddingA and ythons 2 07"
mutual communication !et#een the t#o languages can !e esta!lished.
4
)m!edda!ility is an undocumented feature of H at the time of #riting. The source
distri!ution of H contains a 607 called @em!edA" yet it contains a #arning to users
a!out it !eing e1perimental and likely to change or !e converted to an e1tension
-)K'.++/.
0s em!edding H is undocumented and still in an e1perimental phase" ython should
!e the language of choice for anyone #anting an em!edded language to enhance the
functionality of a program.
2., Paradigs
2.,.1 -b.ect -rientation
Despite supporting classes" ythonIs default means for data encapsulation are lacking.
ython doesnIt contain a concept of protected mem!ers and private mem!ers are simply
preceded !y t#o underscores = PP >" #hich cause the mem!ers names to !e com!ined
#ith the class name !efore code generation to form a name resem!ling
_classname__membername -6;'.++-+'" private/. The conse(uence of this is that the
access to private mem!ers isnIt actually for!idden" as the mem!er can still !e accessed
through the mangled name. 7t is solely at the programmerIs discretion to avoid accessing
private mem!ers -6;'.++-+'" private/. ython also offers properties similar to those
seen in 2N as a means of access control or mem!er protection as #ell as for clean-up and
creation actions -6;'.++-&" property/. These properties still rely on a private mem!er
varia!le to !e used" #hich can still !e altered !y the aforementioned method.
;urthermore" mem!er methods have to e1plicitly name the reference to their containing
instance as their first parameter" leading to redundancy in code -6;'.++-+'" Random
Remarks/. Chen calling a mem!er method" it is not necessary to e1plicitly pass the
containing instance" as ython considers an instance.method() call to !e the e(uivalent of
class.method(instance) -6;'.++-+'" Method E!Bects/.
ython allo#s the definition of meta-classes to customi?e class creation -6;'.++-+%"
2ustomi?ing 2lass 2reation/. )very class has a meta-class !y default" !ut allo#s for ne#
ones to !e #ritten and assigned and are also inherited from !ase classes #here applica!le
-6;'.++-+%" 2ustomi?ing 2lass 2reation/. The customi?ation features include the
control over instantiation of classes -6;'.++-+%" 2ustomi?ing 2lass 2reation/ and even
to completely deny it =!y over#riting the __new__ function>" as #ell as controlling the
inheritance from !ase classes =!y over#riting the __prepare__ function> -6;'.++-+%"
2ustomi?ing 2lass 2reation/.
The H approach to o!Bect orientation closely resem!les that of Mava. )ncapsulation
modifiers are placed directly in front of the mem!er and include pu!lic" protected and
private -H'.++-++/. These #ork as e1pected #ith pu!lic !eing the default modifier
and visi!le inside the instance as #ell as from the outside" protected !eing visi!le to
su!types and private !eing visi!le only to the containing instance -H'.++-++/. 0s
H for!ids identifiers from standing alone" modifiers also offer a means of declaring a
varia!le #ithout having to initiali?e it -H'.++-+'/. HIs encapsulation features
appear to !e rather secure" #ith the only o!vious means of circumventing them !eing
8
reflection.
The Budgement over #hich programming language offers !etter features for E!Bect
Erientation depend on #hether or not strict encapsulation should !e considered a
language feature or a proBect specific programming guideline. 2onsidering the dynamic
nature of !oth languages" that encourage programmers to take different approaches to
solving pro!lems efficiently and easily" the non-strict variant that ython takes is likely
to #ork out !etter. ;urthermore" ython allo#s for complete control over class creation
!y using meta-classes" so specific rules can !e implemented depending on its use. H
lacks this feature.
2.,.1.1 Instances
7n ython instances of classes can easily !e e1tended and functionality altered !y simply
assigning a value to an ar!itrary identifier. Chere x is not an element of the classIs
mem!ers and y is an e1pression" the follo#ing statements adds a mem!er to this specific
instanceF instance.x = y -6;'.++-+</. The same statement #ith x as a mem!er of the
class #ould override the instanceIs x #ith the result of y -6;'.++-+</. 0s much as this
offers a very dynamic tool to #ork #ith" it can also create pro!lems. Typographical
errors on the left side of an assignment do not lead to an error message !y default" thus
!eing prone to errors #hich can !e hard to de!ug. 7t also offers a #ay to e1tend classes
#ithout the use of inheritance" functionality can !e altered unkno#ingly. This
functionality can !e disa!led !y defining an attri!ute setter and deleter =__setattr__
__delattr__ -6;'.++-+%" 2ustomi?ing 0ttri!ute 0ccess/> for a given class. 7f the
functions !ody is left empty" it prevents the assignment of a value to a previously non-
e1istent identifier" thus preventing the alteration of an instance.
7nstances in H can also !e altered !y means of assigning a value to an ar!itrary
identifier that isnIt contained in the set of class varia!les of the instanceIs class
-H'.++-+%/. This counts for assignments #ithin as #ell as outside of the instance its
self. 7f a varia!le is declared as private or protected and an attempt is made to change its
value from outside of the instance" the program ends #ith a fatal error -H'.++-++/ " as
a Mava or 2OO programmer #ould e1pect. 6imilarly to ythonIs !ehaviour"" H offers
magic methods that can !e used to !ypass this restriction. Defining a general attri!ute
getter and setter for the class =__set __!et -H'.++-+%/> to simply assign a passed
value to an identifier" or return the value of the re(uested identifier respectively" !reaks
any access modifiers -H'.++-+%/. *ike in ython" an empty function !ody can !e
used to ignore any assignments to identifiers and create an instance filled #ith constants.
2onsidering the dynamic nature of the H language" it seems illogical to allo# adding
varia!les to an instance from the outside !ut restricting this feature to varia!les that
arenIt declared as private or protected #ithin the original class" as these shouldnIt !e
visi!le from the outside any#ay. ython takes this into consideration through its name
mangling mechanism" as private mem!ers receive an internal name that differs from the
name they originally received in the class definition" thus not restricting these kinds of
assignments in HIs manner. HIs unnecessary confirmation of the e1istence of
internal private or protected varia!les seems to have passed over from Mava or 2OO
,
#ithout taking the actual necessity for this into consideration. :sing HIs magic
methods" it should !e possi!le to create a custom name mangling system similar to the
one present in ython.
2.,.1.2 Inheritance
ython supports the concepts of inheritance -6;'.++-+'/ and multiple inheritance
-6;'.++-+'/ and allo#s for overriding inherited methods and attri!utes -6;'.++-+'/"
and" due to its dynamic nature and unlike in Mava" inherited class features can !e
removed. This goes hand in hand #ith ythonIs t#o type-checking functions isinstance
and iss"bclass" to check if a varia!le is of a certain type or su!type -6;'.++-+'/. To
support multiple inheritance" ython uses depth-first" from left to right search in order of
!ase class declaration to find mem!ers throughout the !ase classes -6;'.++-+'/. This is
enhanced !y a dynamic restructuring of the !ase classes to avoid the diamond
relationship pro!lem -6;'.++-+'/. The concept of a!stract classes can !e implemented
through meta-classes and a pre-implemented a!stract !ase class meta-class e1ists in
ythonIs standard li!rary -6;'.++-+$/.
H also supports inheritance using the same synta1 present in Mava" through the extends
-H'.++-+$/ key#ord" !ut like ython" inherited mem!ers can !e forgotten if
necessary. 7f a class is derived from another" it inherits all pu!lic and protected mem!ers
of the !ase class -H'.++-+</. 0!stract classes can !e created using the a!stract
key#ord" preventing underived instantiation -H'.++-+&/. 0lso like Mava" interfaces
can !e defined in H" allo#ing a programmer to declare a set of unimplemented pu!lic
functions to !e implemented !y any class using the interface -H'.++-+4/. 0t present"
H offers no predefined means for multiple inheritance.
HIs inheritance mechanism is closely modelled on MavaIs =including the key#ords>"
thus inheriting some of the shortcomings of MavaIs inheritance mechanism" such as the
lack of a means for multiple inheritance. The !enefit of this is an easy transition for
programmers coming from Mava or 2N to HIs approach to o!Bect oriented inheritance.
Despite ython not sharing any inheritance specific synta1 elements #ith Mava" thus
creating a shallo#er learning curve for people coming from a Mava !ackground" its
intuitive and logical means for multiple inheritance make it more versatile than H"
especially if the use of multiple inheritance is deemed necessary.
2.,.1.3 E"ce#tion Hand$ing
ython uses a form of e1ception handling that should !e familiar to anyone #ho kno#s
Mava. 0n e1ception is a class that can !e e1tended to create custom e1ceptions.
)1ceptions can !e thro#n and caught -6;'.++-'&/. 0n uncaught e1ception leads to the
termination of the program -6;'.++-'$/. Chat separates ython from Mava is the
synta1 of )1ception controls. )1ceptions are thro#n !y @raisingA them =raise key#ord>
and caught !y @e1ceptingA =except key#ord> -6;'.++-'$/. The #inally !lock is the
same as in Mava" #hich is e1ecuted regardless of #hether an e1ception occurred
+.
-6;'.++-'$/. Hulnera!le code sections" e1pecting a possi!le error are placed in a try
!lock -6;'.++-'&/. ython also has !uilt-in e1ceptions that are thro#n if a runtime
error occurs -6;'.++-'&/-6;'.++-'$/.
H doesnIt only share the usage of )1ceptions #ith Mava" it also shares the synta1. They
are thro#n my using throw caught !y using catch and e1pected #ith a try !lock
-H'.++-'8/" !ut H completely lacks the #inally !lock -Dop+." p. '84/. ;urthermore
e1ceptions #ere not al#ays a part of the H language" only !eing introduced in version
$ -H'.++-'8/. This leads to the pro!lem that H has t#o kinds of runtime errorsF
those that can !e caught" using the ne# e1ception system and those that simply display a
#arning or cause the program to crash in the #orst case -H'.++-'8/.
Despite ythons syntactical differences" its usage should !e familiar to Mava and 2N
programmers" #hile Hs lack of certain e1ception handling features can !e unintuitive.
The lack of a finally !lock denies a programmer the possi!ility to define a !lock of code
to !e e1ecuted regardless of #hether an error occurred" #hich can lead to code
duplication for the normal program path and the catch !lock as #ell as insta!ility in long
running programs -Dop+." p. '84/. ;urthermore" Hs inconsistent use of catcha!le
e1ception creates a possi!le cause of program crashes that is harder to avoid at runtime.
2.,.2 /unctiona$
H supports closures #hich lays the foundation for programmers to use the functional
paradigm -H'.++-+8/. ;unctions can accept other functions as parameters and are
also a!le to create and return functions -H'.++-+8/. H doesnIt re(uire a name to !e
given to a function -H'.++-+8/ or for it to !e predeclared.
ython supports anonymous functions in form of lam!das -6;'.++-+&/. This
functionality is restricted !y allo#ing lam!da e1pressions only to contain other
e1pressions and not statements -6;'.++-+&/. 9ut as the pure functional paradigm
doesnIt include states" ythons lam!da enforces this rule. *am!das are currently the only
#ay for anonymous functions to !e created in ython" !ut named functions may !e
passed as parameters as #ell" yet have to !e predeclared -6;'.++-+4/.
HIs anonymous function mechanism may offer the programmer greater fle1i!ility" !ut
defining functions in this manner can easily lead to code that is hard to read. Due to
ython restricting itIs anonymous functions to contain only e1pressions and not
statements" it keeps them short" easier to read and avoids state changes. The enforcement
of the e1pression only rule also makes ythonIs lam!das suita!le for academic use" as
they #ork e1actly ho# a student of the lam!da calculus #ould e1pect and preserves the
rules of pure functional programming.
2.,.3 'oncurrency
2oncurrency is featured in ython as @Eptional Eperating 6ystem 6ervicesA -6;'.++-
+8/" meaning it is only availa!le on certain operating systems. ythonIs standard
implementation" 2ython" contains a performance !ased restriction called @Glo!al
++
7nterpreter *ockA -6;'.++-+8/. This restriction only allo#s one thread to e1ecute
ython !yte code at a time -6;'.++-+8/. 0s such" concurrency is only possi!le !y
means of multiprocessing =using ythonIs multiprocessing module -6;'.++-+,/> !y
default -6;'.++-+8/.
The aforementioned 6tackless implementation of ython adds full threading support to
the language in form of microthreads =@TaskletsA -6*'.++-+/>" including communication
!et#een threads -6*'.++-+/" scheduling and thread seriali?ation -6*'.++-+/.
2oncurrency in H is disa!led !y default and must !e compiled #ith a certain s#itch to
activate it -H'.++-+,/. 7t is only availa!le on :ni1 platforms and only !y means of
multiprocessing -H'.++-+,/. H does" ho#ever" allo# multiple copies of H to run
in the same thread =the opposite of ythonIs @Glo!al 7nterpreter *ockA>" so care must !e
taken #hen defining glo!al varia!les #hen #riting e1tensions for H -H'.++-'./.
Despite ythonIs standard implementation not supporting true threading for good
reasons" the 6tackless implementation makes up for these shortcomings. H has
nothing to offer regarding true threading and neglects the danger of hard to find errors
#hich comes #ith glo!al varia!les #hen running several instances in the same thread.
;urthermore" according to 2holakov" Hs lack of true multithreading @is going to !e a
maBor vulnera!ility for the platform in the very near futureA -2ho.8/" as @reasona!le
=and constantly dropping> prices of these components give a good sign that even the
smallest companies #ill tend to use multiple cored Ce! serversA -2ho.8/.
3. 0ses
3.1 1eb !ervers
Got necessarily a language feature" a ython enhancement proposal #as created and
approved in '..% -)'..%/ and e1tended to improve usa!ility in ython % in '.+.
-)'.+./ to create a Ce! 6erver Gate#ay 7nterface =#sgi> specification @for #e!
servers and application servers to communicate #ith #e! applicationsA -C6G7'.+./. 7t
is supported !y a num!er of #e!-frame#orks" such as DBango" ylons" 5ope %
-C6G7'.++/ and 0pache =through modP#sgi -GD'.++/>. ython contains a reference
implementation of the #sgi specification that can assist in #riting #sgi ena!led
applications -6;'.++-'./.
H provides a range of 607s to communicate #ith servers that are included in the
official source distri!ution -H'.++-'+/. These include 0pache" *itespeed among
others and hook directly into the specific servers -H'.++-'+/.
HIs compati!ility #ith Ce! 6ervers is #here it e1cels" pro!a!ly !ecause it #as
initially designed to perform #e!-!ased tasks. 9ut #hile HIs 607s have to !e
re#ritten for every server" ythonIs C6G7 aims at offering a common interface for
application-server and server-server communication.
+'
3.1.1 LA2P
ython support for the *0M =*inu1" 0pache" My6Q*" HLythonLerl> stack #as
initially introduced !y the modPpython proBect" allo#ing the ython interpreter to run as
a module in 0pache -06'.+./. The 0pache Quet?alcoatl proBect #as @charged #ith the
creation and maintenance of open-source soft#are related to modPpython and the ython
programming languageA -06'.++/ " !ut #as cancelled due to community inactivity
-06'.++/ . The official modPpython proBect page claims that the proBect isnIt dead" !ut in
a state that is mature enough to re(uire very little maintenance -06'.+./.
0n alternative is to use modP#sgi" an 0pache module that supports ythonIs Ce! 6erver
Gate#ay 7nterface -GD'.++/.
HIs 0pache module =modPphp> is provided along #ith the H source code
-H'.++-'+/ and can !e connected to 0pache after !eing !uilt #ith s#itches to ena!le
0pache specific e1tensions -H'.++-''/. 0 pre-compiled set of 0pache" My6Q* and
HLerl comes in form of K0M for various operating systems to make the
installation easier.
The 0pache modPpython seems to !e o!solete as itIs parent proBect #as cancelled" #hile
modPphp is still the most commonly used 0pache module. The modP#sgi" ho#ever"
offers consistency for the communication #ith any #e!-server that implements it" #hich
makes it an interesting alternative.
3.2 'LI
9y default ython has several #ays it can !e used #ith a command line interface. The
ython e1ecuta!le run #ithout parameters puts ython in an interactive console mode
-6;'.++-'+/. This allo#s programmers to #rite a line of code and receive direct
feed!ack a!out syntactical correctness as #ell as the result of any e1pression entered
-6;'.++-''/. 7n this mode it can also !e used as an advanced calculator -6;'.++-''/
due to ythonIs large mathematical li!rary. 0nything #ritten into the console during a
session persists until the session ends -6;'.++-''/.
The ython e1ecuta!le follo#ed !y the path of a ython file runs the contained program"
#hich can then access the standard in- and output and use it for user interaction
-6;'.++-'+/.
The 7D) that ships #ith ython" 7D*)" comes #ith a !uilt-in command line -6;'.++-
'%/. The functionality is the same as ython running in the interactive console mode"
#ith the additional features of !eing a!le to retrieve previous commands" as #ell as the
a!ility to save the interactive session" #hich can !e fully recalled -6;'.++-'%/.
HIs 2*7 607 is the default to !e !uilt along #ith the 2G7 607 #hen configuring
H #ithout options -H'.++-'%/. *ike ython" the H e1ecuta!le can !e follo#ed
!y the path of a H file to run the contained program -H'.++-'$/. The 2*7 can also
!e run #ith the $a option to receive an interactive shell -H'.++-'</. The precondition
for this is that H #as compiled #ith the %with$readline option" other#ise the shell #ill
not !e a!le to pass the input to the H interpreter -H'.++-'</. 7t also contains a
peculiar e1ception to HIs opening and closing !rackets rule" in that commands sent
+%
directly to the interpreter in this manner donIt have to !e surrounded !y them -H'.++-
'</.
ythonIs 2*7 features are very sophisticated and #ork out of the !o1 #hile HIs re(uire
a specific configuration !efore compilation to offer a similar amount of features.
3.3 !tanda$one A##$ications
9eyond the previously mentioned 2*7 uses of H and ython" !oth languages have
several other #ays they can !e used to #rite standalone applications" mainly in
com!ination #ith e1ternal li!raries. These include various G:7 toolkits that #ill !e
discussed in the li!raries section of this document.
3.% Libraries
0s ython % !roke !ack#ards compati!ility #ith previous versions" thus also !reaking
compati!ility #ith many previously availa!le li!raries =modules in ython>" the
follo#ing section #ill ignore #hether or not the mentioned li!raries are ython %
compati!le or not.
There are a num!er of modules to provide the use of G:7 toolkits" such as GTK #ith
yGtk -yGTK'.+./" Qt #ith yQt -R92'.+./ or the official y6ide -GEK'..,/ and
Tkinter for TclLTk -TK7'.++/.
;urthermore there are also li!raries to enhance ythonIs a!ilities to !e used for scientific
calculations" such as 6ciy . 7t offers a #ide range of functionality for @mathematics"
science" and engineeringA -6R'.++-+/" including clustering" fourier transforms" linear
alge!ra" image processing" optimi?ation" statistic and signal processing -Eli.4" +,-'./.
6imilarly" 6cientific ython is a collection of modules for scientific computing that
includes =!ut is not limited to> automatic derivative calculation" a ;ortran interface" %D
Hectors and tensors including (uaternions" histogram generation and %D visualisation
modules -KH'..4/.
Ry is a ython interface for the R rogramming language -RR'.+./ #hich allo#s
easy access to statistical computing and graphics -R/.
ython also has a range of li!raries aimed at facilitating the generation of games and
interactive environments. These include ygame" #hich is a #rapper around the 6D*
li!rary -G/" ython-Egre" #hich allo#s the use of the open source Egre%d engine -E/
through ython and yEpenG*" #hich provides ython !indings for EpenG* -G*/.
Targeting #e! applications a num!er of frame#orks #ere developed. DBango is a #e!
application frame#ork that focuses on rapid development and #idespread automation
and includes an o!Bect-relational mapper and an automatic admin interface -D'.++/.
The ylons roBect is a proBect aiming to release a num!er of technologies related to #e!
application frame#orks" the current one !eing yramid -02'.++/. 7t aims to !e simple
and minimalistic and to make it easy for developers to #rite #e! applications -/.
Despite the fact that H is normally used as a server side scripting language" several
li!raries have !een developed to facilitate HIs use as a general purpose language" such
+<
as li!raries to allo# the creation of Qt =through php-(t -HQT/> and GTK =through
php-gtk -H'..,/> G:7s using pure H. These li!raries are a !it outdated though" as
the latest GTK version supported !y php-gtk is '.+' -H'..8/ at the time of #riting
#hile the latest versions of the GTK are '.'< and %.. -GTKO'.++/ and the php-(t proBect
is still in its !eta phase #hile itIs latest release dates !ack to Muly" '.., -HQT'..,/.
Ce! development is still #here H e1cels though" offering a num!er of frame#orks
and content management systems for this purpose. These include Moomla -E6M'.++/"
Media Ciki -CM;'..4/" Drupal -DR/" TRE% and Cordress -C/" #hich #ere all
#ritten and can !e e1tended through the use of the H language. Moomla is a free and
open source 2M6 and application frame#ork" #hose official #e!site claims that it
po#ers '.43 of the #e! -E6M'.++/. Cordress is a pu!lishing system and 2M6 aimed
at !logging" !ut is suita!le for general purpose use -C/. The Media Ciki is a free and
open source #iki that is most famously used for Cikipedia -CM;'..4/. Drupal and
TRE% are !oth content management and pu!lishing systems released through the terms
of the G* -DR/-T%0'.++/.
Chile ythons selection of li!raries is a mi1ture of many aspects of practical and
theoretical computer science" offering solutions to many common tasks" HIs li!raries
sho# a definite !ias to#ards #e!-frame#orks and content management systems.
0ttempts to e1tend HIs reach to desktop applications through G:7 li!raries seem to
have died do#n and !ecome neglected" #hile the #e!-frame#orks and content
management systems are still under active use and development.
%. 'onc$usion
7n conclusion it seems that !oth programming languages have a right to e1ist.
Despite lacking standardisation and !eing limited in use !eyond as a server-side
scripting language" H offers a (uick and easy means for Mava or 2N programmers to
transition to H" if that should !e necessary for a proBect. ;urthermore" the vast amount
of content management systems and #e!-frame#orks #ritten in H make it a good
language of choice for programmers #anting to learn a #e! programming language. 7ts
easy and lenient nature facilitate the #riting of e1tensions for them. This can" ho#ever"
!e deceptive" as its #eak typing system doesnIt al#ays produce errors #hen they #ould
occur in stronger typed languages" thus creating an error source that might not al#ays !e
discovered. The fact that H only has limited support for threading and that the gar!age
collector cannot !e t#eaked easily make it less suita!le for long running applications"
such as programs #ith G:7s or servers. 7t seems it is !est placed to respond to re(uests
on servers" in scripts that run for a short time and terminate" #hich also seems to !e for
#hich H is most commonly used.
ython is a more versatile language" as it #asnIt designed for any other specific purpose
than to !e versatile. 7t seems the inclusion of a formal language description into ythons
documentation nourished the creation of alternative implementations and the academic
use of the language" as is evident through the creation of implementations such as yy"
that take a very different approach to e1ecution than the traditional 2ython" as #ell as
+$
the creation of a large num!er of scientific ython modules. 7ts versatility is evident
through the num!er of different modules for various different purposes that #ere #ritten
for ython" as #ell as through the means parts of the language" such as class creation and
destruction" the gar!age collector or mem!er access" can !e modified to suit the needs of
a given situation or pro!lem. 0s such" it is hard to name usage scenarios for the ython
language" as there is very little it cannot !e used for.
The follo#ing ta!le offers an overvie# of the previously discussed topicsF
Python PHP
Language
Documentation 6eparate documentation for each
release !ased on the previous
release. The grammar is
included in a 9G;-like notation.
0 single documentation for all
versions. MaBor parts of the 5end
)ngines internals are missing.
Hs documentation lacks a
formal grammar description.
6ynta1 :ses mandatory indentation for
code structuring.
:ses 2-like !rackets for
structuring code. 7ndentation is
optional. 7nconsistencies in case
sensitivity.
7mplementations 2ython as the standard
implementation #ritten in 2.
MaBor alternative
implementations include Mython
#ritten in Mava and 7ronython
#ritten in 2N. ;urther" more
speciali?ed implementations
e1ist.
The standard implementation for
H comes in form of the 5end
)ngine '" #hich #as #ritten in 2.
ro!a!ly due to the lack of a
formal grammar description" no
other complete implementations of
H e1ist.
Gar!age
2ollection
Reference counting #ith cycle
detection. The gar!age collector
can !e finely t#eaked and
analy?ed at runtime.
Reference counting #ith cycle
detection. The gar!age collector
can only !e t#eaked through
altering the H source.
Type 6ystem 6trongly typed" duck-typing Ceakly typed
)1tensi!ility Gatively through a 2 07 as
#ell as through a system to call
2 code from #ithin ython
Gatively through a 2 07. This
feature isnIt #ell documented.
)m!edda!ility ossi!ility to send ython code
directly to the interpreter" as #ell
:ndocumented feature. 0n em!ed
607 is contained in the H
+&
as through a 2 07 source" !ut is e1perimental.
Paradigs
E!Bect
Erientation
2lasses #ith private and pu!lic
for encapsulation" multiple
inheritance" fine tuning of access
and class creation through
special methods and meta
classes. )1ception handling is
consistent for runtime errors.
2lasses #ith private" protected and
pu!lic for encapsulation" single
inheritance" a!stract classes and
interfaces. )1ception handling is
inconsistent #ith some runtime
errors that donIt thro# catcha!le
e1ceptions.
;unctional 0nonymous functions through
lam!das" restricted to contain
only e1pressions. ;unctions can
!e passed !y name.
;ull support for anonymous
functions including e1pressions
and statements. ;unctions can !e
passed anonymously or !y name.
2oncurrency 0vaila!le in 2ython via
multiprocessing" also via a fake
threading interface.
7mplementations that support
true threading are availa!le.
Enly availa!le on :ni1 systems
!y means of multiprocessing.
0ses
Ce! 6ervers 6pecification for Ce! 6erver
Gate#ay 7nterface supported !y
many different #e!servers.
Through 607s created for a range
of #e!servers" most commonly
0pache.
2*7 Eut of the !o1 support #ith an
interactive shell !eing the
default action for the python
e1ecuta!le.
2*7 support is !uilt !y default
#hen compiling H" it re(uires
e1tra s#itches for an interactive
shell.
6tandalone
0pplications
Harious G:7 toolkits are
availa!le for GTK" Qt" TclLTk.
G:7 toolkits for H are availa!le
for Qt and GTK" !ut these appear
to !e outdated.
*i!raries *arge range of li!raries for
many different su!Bects" such as
scientific calculations" statistics"
graphics" games" #e!-
frame#orks.
H li!raries are largely restricted
to 2M6 and #e!-frame#orks and
tools for these.
+4
(. 3eferences
-6;'.++-+/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" 7ntroduction" '.++"
ShttpFLLdocs.python.orgLpy%kLreferenceLintroduction.htmlT
=+%..&.'.++>
-6;'.++-'/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" *e1ical 0nalysis" 7ndentation" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLle1icalPanalysis.html
NindentationT =+%..&.'.++>
-6;'.++-%/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" *e1ical 0nalysis" Key#ords" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLle1icalPanalysis.html
Nkey#ordsT =+%..&.'.++>
-6;'.++-</ ython 6oft#are ;oundation" ython v%.' documentation" )1tending
and )m!edding" Reference 2ounts" '.++
ShttpFLLdocs.python.orgLpy%kLe1tendingLe1tending.htmlNreference-
countsT =+%..&.'.++>
-6;'.++-$/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" ython Runtime 6ervices" Gar!age 2ollector
7nterface" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLgc.htmlT =+%..&.'.++>
-6;'.++-&/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" 9uilt-in ;unctions" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLfunctions.htmlT =+<..&.'.++>
-6;'.++-4/ ython 6oft#are ;oundation" ython v%.' documentation" Glossary"
'.++
ShttpFLLdocs.python.orgLpy%kLglossary.htmlUhighlightVduckNterm-
duck-typingT =+<..&.'.++>
-6;'.++-8/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" 9uilt-in )1ceptions" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLe1ceptions.htmlU
highlightVtypeNType)rrorT =+<..&.'.++>
-6;'.++-,/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" Generic Eperating 6ystem 6ervices" ctypes" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLctypes.html T =+<..&.'.++>
-6;'.++-+./ ython 6oft#are ;oundation" ython v%.' documentation" )1tending
and )m!edding the ython 7nterpreter" '.++
ShttpFLLdocs.python.orgLpy%kLe1tendingLe1tending.htmlT =+<..&.'.++>
-6;'.++-++/ ython 6oft#are ;oundation" ython v%.' documentation" )1tending
and )m!edding the ython 7nterpreter" )m!edding ython in 0nother
0pplication" '.++
ShttpFLLdocs.python.orgLpy%kLe1tendingLem!edding.html T
=+<..&.'.++>
+8
-6;'.++-+'/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
Tutorial" 2lasses" '.++
ShttpFLLdocs.python.orgLpy%kLtutorialLclasses.htmlT =+<..&.'.++>
-6;'.++-+%/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" Data Model" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLdatamodel.htmlT =+<..&.'.++>
-6;'.++-+</ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" 6imple 6tatements" 0ssignment 6tatements" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLsimplePstmts.htmlNassignment-
statementsT =+<..&.'.++>
-6;'.++-+$/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" 0!stract 9ase 2lasses" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLa!c.htmlT =+<..&.'.++>
-6;'.++-+&/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
Reference" )1pressions" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLe1pressions.htmlNlam!daT
=+<..&.'.++>
-6;'.++-+4/ ython 6oft#are ;oundation" ython v%.' documentation" ython
;re(uently 0sked Questions" Design and History ;0Q" '.++
ShttpFLLdocs.python.orgLpy%kLfa(Ldesign.htmlN#hy-can-t-lam!da-
forms-contain-statements T =+<..&.'.++>
-6;'.++-+8/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" Eptional Eperating 6ystem 6ervices" threading" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLthreading.htmlT =+<..&.'.++>
-6;'.++-+,/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" Eptional Eperating 6ystem 6ervices"
multiprocessing" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLmultiprocessing.htmlT
=+<..&.'.++>
-6;'.++-'./ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" 7nternet rotocols and 6upport" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryL#sgiref.htmlT =+<..&.'.++>
-6;'.++-'+/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
Tutorial" :sing the ython 7nterpreter" '.++
ShttpFLLdocs.python.orgLpy%kLtutorialLinterpreter.htmlT =+<..&.'.++>
-6;'.++-''/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
Tutorial" 0n 7nformal 7ntroduction to ython" '.++
ShttpFLLdocs.python.orgLpy%kLtutorialLintroduction.htmlT =+<..&.'.++>
-6;'.++-'%/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
6tandard *i!rary" Graphical :ser 7nterfaces #ith Tk" 7D*)" '.++
ShttpFLLdocs.python.orgLpy%kLli!raryLidle.htmlT =+<..&.'.++>
-6;'.++-'</ ython 6oft#are ;oundation" ython v%.' documentation" ython
;re(uently 0sked Questions" '.++
ShttpFLLdocs.python.orgLpy%kLfa(Lgeneral T =+<..&.'.++>
-6;'.++-'$/ ython 6oft#are ;oundation" ython v%.' documentation" *anguage
+,
Reference" )1ecution Model" '.++
ShttpFLLdocs.python.orgLpy%kLreferenceLe1ecutionmodel.htmlT
=+%..&.'.++>
-6;'.++-'&/ ython 6oft#are ;oundation" ython v%.' documentation" The ython
Tutorial" )rrors and )1ception" '.++
ShttpFLLdocs.python.orgLpy%kLtutorialLerrors.htmlT =+%..&.'.++>
-C'.++/ #iki.python.org" ython ' or ython %" '.++
ShttpFLL#iki.python.orgLmoinLython'orython% T =+<..&.'.++>
-6;'.++-'$/ ython 6oft#are ;oundation" ython v%.' documentation" History and
*icense" '.++
ShttpFLLdocs.python.orgLpy%kLlicense.htmlNhistory-and-license T
=+<..&.'.++>
-6;'..,/ ython 6oft#are ;oundation" Mission 6tatement of the ython
6oft#are ;oundation" '..,
ShttpFLL###.python.orgLpsfLmissionLT =+<..&.'.++>
-)'..%/ hillip M. )!yF ython Ce! 6erver Gate#ay 7nterface v+.." ython
)nhancement roposal" '..%-'.++"
ShttpFLL###.python.orgLdevLpepsLpep-.%%%LT =+<..&.'.++>
-)'.+./ hillip M. )!yF ython Ce! 6erver Gate#ay 7nterface v+...+" ython
)nhancement roposal" '.+.-'.++"
ShttpFLL###.python.orgLdevLpepsLpep-%%%%LT =+<..&.'.++>
-C6G7'.+./ #sgi.org" Chat is C6G7" '.+."
ShttpFLL###.#sgi.orgL#sgiLChatPisPC6G7T =+<..&.'.++>
-C6G7'.++/ #sgi.org" ;rame#orks" '.++"
ShttpFLL###.#sgi.orgL#sgiL;rame#orksT =+<..&.'.++>
-GD'.++/ Graham Dumpleton" Chat is modP#sgi" '.++
ShttpFLLcode.google.comLpLmod#sgiLT =+<..&.'.++>
-06'.++/ The 0pache 6oft#are ;oundation" 0pache 0ttic" 0pache Quet?alcoatl"
ShttpFLLattic.apache.orgLproBectsL(uet?alcoatl.htmlT =+<..&.'.++>
-06'.+./ The 0pache 6oft#are ;oundation" ModPython" '.+.
ShttpFLL###.modpython.orgLT =+<..&.'.++>
-6R'.++-+/ 6ciy.org" Homepage" '.++"
ShttpFLL###.scipy.orgLT =+<..&.'.++>
-6R'.++-'/ 6ciy.org" Gumy and 6ciy Documentation" Reference" '.++
ShttpFLLdocs.scipy.orgLdocLscipyLreferenceLT =+<..&.'.++>
-KH'..4/ Konrad Hinsen" 6cientific ython" Evervie# '..4
ShttpFLLdirac.cnrs-orleans.frLploneLsoft#areLscientificpython
Lovervie#LT =+<..&.'.++>
-RR'.+./ Rpy.sourceforge.net" 0!out" '.+.
ShttpFLLrpy.sourceforge.netLrpy.htmlT =+<..&.'.++>
-R/ The R roBect for 6tatistical 2omputing"
ShttpFLL###.r-proBect.orgLT =+<..&.'.++>
-G/ yGame" Ciki" 0!out"
ShttpFLL###.pygame.orgL#ikiLa!outT =+<..&.'.++>
-E/ ython-Egre" Homepage"
'.
ShttpFLL###.pythonogre.comLT =+<..&.'.++>
-G*/ yEpenG*" Homepage"
ShttpFLLpyopengl.sourceforge.netLT =+<..&.'.++>
-D'.++/ DBango 6oft#are ;oundation" Homepage" '.++"
ShttpsFLL###.dBangoproBect.comLT =+<..&.'.++>
-02'.++/ 0gendaless 2onsulting" ylons roBect ;0Q" '.++"
ShttpFLLdocs.pylonsproBect.orgLfa(LpylonsproBect.htmlT =+<..&.'.++>
-/ ylonsroBect.org" 0!out yramid"
ShttpFLLpylonsproBect.orgLproBectsLpyramidLa!outT =+<..&.'.++>
-7'.++/ Microsoft 2orporation" 7ron ython" Evervie#"
ShttpFLLironpython.netLT =+%..&.'.++>
-'.++-+/ The yy roBect" yy" ;eatures
ShttpFLLpypy.orgLfeatures.htmlT =+%..&.'.++>
-'.++-'/ The yy roBect yy v+.$ Documentation" 2oding Guide" Rython"
'.++
ShttpFLLpypy.readthedocs.orgLenLlatestLcoding-guide.htmlNrpythonT
=+%..&.'.++>
-6*'.++-+/ 6tackless" Homepage" ShttpFLL?ope.stackless.comLT =+%..&.'.++>
-yGTK'.+./ The GGEM) roBect and yGTK Team" yGTK Homepage" '.+.
ShttpFLL###.pygtk.orgLT =+<..&.'.++>
-R92'.+./ River!ank 2omputing *imited" yQt Homepage" '.+.
ShttpFLL###.river!ankcomputing.co.ukLsoft#areLpy(tLintroT
=+<..&.'.++>
-GEK'..,/ Gokia 2orporation" y6ide ;0Q" '..,"
ShttpFLLdeveloper.(t.nokia.comL#ikiLy6ideP;0QT =+<..&.'.++>
-TK7'.++/ Tkinter Ciki" ;ront age" '.++"
ShttpFLLtkinter.unpythonic.netL#ikiL;rontageT =+<..&.'.++>
-H'.++-+/ The H Group" H Manual" 0!out the manual" '.++
ShttpFLL###.php.netLmanualLenLa!out.phpversions.phpT =+%..&.'.++>
-H'.++-'/ The H Group" H Manual" H at the 2oreF 0 HackerIs Guide to
the 5end )ngine" '.++
ShttpFLL###.php.netLmanualLenLinternals'.phpT =+%..&.'.++>
-H'.++-%/ The H Group" H Manual" :ser Gote 6ystem" '.++
ShttpFLL###.php.netLmanualLadd-note.phpT =+%..&.'.++>
-H'.++-</ The H Group" H Manual" )scaping from HTM*" '.++
ShttpFLL###.php.netLmanualLenLlanguage.!asic-synta1.phpmode.phpT
=+%..&.'.++>
-H'.++-$/ The H Group" H Manual" reface" '.++
ShttpFLL###.php.netLmanualLenLpreface.phpT =+%..&.'.++>
-H'.++-&/ The H Group" H Manual" ;0Q" General 7nformation" '.++
ShttpFLL###.php.netLmanualLenLfa(.general.php T =+%..&.'.++>
-H'.++-4/ The H Group" H Manual" ;unction Reference" H EptionsL7nfo
;unctions" '.++
ShttpFLL###.php.netLmanualLenLfunction.gc-collect-cycles.phpT
=+%..&.'.++>
'+
-H'.++-8/ The H Group" H Manual" ;eatures" Gar!age 2ollection" '.++
ShttpFLL###..php.netLmanualLenLfeatures.gc.php T =+%..&.'.++>
-H'.++-,/ The H Group" H Manual" *anguage Reference" Types" Type
Muggling" '.++
ShttpFLL###.php.netLmanualLenLlanguage.types.type-Buggling.php T
=+%..&.'.++>
-H'.++-+./ The H Group" H Manual" *anguage Reference" Types" 9ooleans"
'.++
ShttpFLL###.php.netLmanualLenLlanguage.types.!oolean.php
Nlanguage.types.!oolean.castingT =+%..&.'.++>
-H'.++-++/ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" Hisi!ility" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.visi!ility.php T
=+<..&.'.++>
-H'.++-+'/ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" roperties" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.properties.phpT
=+<..&.'.++>
-H'.++-+%/ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" Everloading" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.overloading.php T
=+<..&.'.++>
-H'.++-+</ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" 7nheritance" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.inheritance.phpT
=+<..&.'.++>
-H'.++-+$/ The H Group" H Manual" 0ppendices" 2lasses and E!Bects"
e1tends" '.++
ShttpFLL###.php.netLmanualLenLkey#ord.e1tends.phpT =+<..&.'.++>
-H'.++-+&/ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" 2lass 0!straction" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.a!stract.phpT
=+<..&.'.++>
-H'.++-+4/ The H Group" H Manual" *anguage Reference" 2lasses and
E!Bects" E!Bect 7nterfaces" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.interfaces.phpT
=+<..&.'.++>
-H'.++-+8/ The H Group" H Manual" *anguage Reference" ;unctions"
0nonymous ;unctions" '.++
ShttpFLL###.php.netLmanualLenLlanguage.oop$.interfaces.phpT
=+<..&.'.++>
-H'.++-+,/ The H Group" H Manual" ;unction Reference" rocess 2ontrol
)1tensions" 2GT*" 7nstallation" '.++
ShttpFLL###.php.netLmanualLenLpcntl.installation.phpT =+<..&.'.++>
-H'.++-'./ The H Group" H Manual" H at the 2oreF 0 HackerIs Guide to
''
the 5end )ngine" )1tension Glo!als" '.++
ShttpFLL###.php.netLmanualLenLinternals'.structure.glo!als.phpT
=+<..&.'.++>
-H'.++-'+/ H 6ource 2ode" Hersion $.%.&" php-$.%.&.tar.g?" php-$.%.&LsapiL"
'.++" accessed via ShttpFLL###.php.netLdo#nloads.phpT =+<..&.'.++>
-H'.++-''/ The H Group" H Manual" 7nstallation and 2onfiguration"
7nstallation on :ni1 6ystems" 0pache '.1 on :ni1 systems" '.++
ShttpFLL###.php.netLmanualLenLinstall.uni1.apache'.phpT
=+<..&.'.++>
-H'.++-'%/ The H Group" H Manual" ;eatures" 2ommand *ine :sage"
7ntroduction" '.++
ShttpFLL###.php.netLmanualLenL
features.commandline.introduction.phpT
=+<..&.'.++>
-H'.++-'</ The H Group" H Manual" ;eatures" 2ommand *ine :sage"
7nteractive 6hell" '.++
ShttpFLL###.php.netLmanualLenLfeatures.commandline.interactive.phpT
=+<..&.'.++>
-H'.++-'$/ The H Group" H Manual" ;eatures" 2ommand *ine :sage" :sage"
'.++"
ShttpFLL###.php.netLmanualLenLfeatures.commandline.usage.phpT
=+<..&.'.++>
-H'.++-'&/ The H Group" H Manual" 0ppendices" History of H and related
proBects" History of H" '.++
ShttpFLL###.php.netLmanualLenLhistory.php.phpT =+<..&.'.++>
-H'.++-'4/ The H Group" H Manual" Getting 6tarted" 7ntroduction" Chat can
H doU" '.++
ShttpFLL###.php.netLmanualLenLintro-#hatcando.php T =+<..&.'.++>
-H'.++-'8/ The H Group" H Manual" *anguage Reference" )1ceptions" '.++
ShttpFLLphp.netLmanualLenLlanguage.e1ceptions.phpT =+%..8.'.++>
-H'..,/ The H Group" H GTK" ;0Q" '..,
ShttpFLLgtk.php.netLfa(.phpT =+<..&.'.++>
-H'..8/ The H Group" H GTK" 2hange *og" '..8"
ShttpFLLgtk.php.netLchangelog.phpT =+<..&.'.++>
-GTKO'.++/ The GTKO Team" Do#nload for GG:L*inu1 and :ni1" '.++"
ShttpFLL###.gtk.orgLdo#nloadLlinu1.phpT =+<..&.'.++>
-HQT'..,/ tm'<$" H-Qt 6ource ;orge age" '..,"
ShttpFLLsourceforge.netLproBectsLphp-(tLT =+<..&.'.++>
-HQT/ tm'<$" kniolet" H-Qt !erliE6 age"
ShttpsFLLdeveloper.!erlios.deLproBectsLphp-(tLT =+<..&.'.++>
-)K'.++/ )din Kadri!asic" H 6ource 2ode" Hersion $.%.&" php-$.%.&.tar.g?"
em!ed 607" )1perimental notice" php-$.%.&LsapiLem!edL
)K)R7M)GT0*" '.++" accessed via
ShttpFLL###.php.netLdo#nloads.phpT =+<..&.'.++>
-5'..8-+/ 79M 2orporation" roBect 5ero" ;0Q" '..8"
'%
ShttpFLL###.proBect?ero.orgLa!outL?erofa(.phpT =+%..&.'.++>
-H'.++-+/ halanger" Homepage" '.++"
ShttpFLLphalanger.codeple1.comLT =+%..&.'.++>
-HH'.++-+/ ;ace!ook" HipHop" '.+."
ShttpsFLLgithu!.comLface!ookLhiphop-phpL#ikiLT =+%..&.'.++>
-E6M'.++/ Epen 6ource Matter 7nc" Moomla" 0!out Moomla" '.++"
ShttpFLL###.Boomla.orgLa!out-Boomla.htmlT =+<..&.'.++>
-C/ Cordress.org" Cordress" 0!out Cordress"
ShttpFLL#ordpress.orgLa!outLT =+<..&.'.++>
-CM;'..4/ Cikimedia ;oundation" MediaCiki" '..4"
ShttpFLL###.media#iki.orgL#ikiLMainPageT =+<..&.'.++>
-DR/ Drupal.org" 0!out Drupal"
ShttpFLLdrupal.orgLa!outT =+<..&.'.++>
-T%0'.++/ TRE% 0ssociation" Chat is TRE%U"
ShttpFLLtypo%.comL0!out.+'%+...htmlT =+<..&.'.++>
-0;'.++/ 0pache ;riends" Kai 6eidler" K0M
ShttpFLL###.apachefriends.orgLenL1ampp.htmlT =+'..8.'.++>
-MC96G'.+./ Mosh Muneau" ;rank Cier?!icki" Mim 9aker" *eo 6oto" Hictor GgF The
Definitive Guide to MythonF ython for the Mava latform" 6pringer-
Herlag Ge# Rork":60" '.+." 769GF ,48-+-<%.'-'$'4-." accessed via
ShttpFLL###.Bython.orgLBython!ookLenL+..Linde1.htmlT =+%..&.'.++>
-Dop+./ ;. DopatkaF H )ndlich o!Bektorientiert EE- und :M*-ra1is!uchF
vom 0nfWnger ?um ;ortgeschrittenenX 6oft#are J 6upport Herlag
Gm!HX ;rankfurtX '.+.X 769G ,48-%-8&8.'-.%,-4
-Eli.4/ T.). EliphantF ython for 6cientific 2omputingX inF 2omputing in
6cience and )ngineeringX Holume ," 7ssue %X HD) Herlag 2onference
roceedingsX +8..&.'..4X 766G +$'+-,&+$X p +.-'.X accessed via
ShttpFLLieee1plore.ieee.orgL1plsLa!sPall.BspUarnum!erV<+&.'$.T
=+'..8.'.++>
-2ho.8/ GikolaB 2holakovF En some dra#!acks of the H platformX inF
2omp6ysTech I.8 roceedings of the ,
th
7nternational 2onference on
2omputer 6ystems and Technologies and Corkshop for hD 6tudents
in 2omputingX 02MX Ge# Rork" :60X '..8X 769G ,48-,$<-,&<+-$'-
%X doi +..++<$L+$..84,.+$..8,<X accessed via
ShttpFLLportal.acm.orgLcitation.cfmUidV+$..84,.+$..8,<T
=+'..8.'.++>
'<