Wat is er mis met Perl

Link: http://www.garshol.priv.no/download/text/perl.html

Door: Lars Marius Garshol

wit-vertaling, door Bohdan Zograf.

estse vertaling door Adrian Pantilimonu

Inhoud

  • Voordat we beginnen
  • Kennismaking met de Kameel
  • Het krijgen van een hekel te hebben aan de Kameel
    • Ongeldige syntaxis van
      • Programmeurs en leesbaarheid
    • Te veel speciale constructies
    • Moeilijk om te bouwen data structuren
    • Het definiëren van interfaces
    • Niet echt object-georiënteerde
    • Optelling van it up
  • Het ontdekken van de Python
  • Het vallen in liefde met de Python
    • De standaard-bibliotheken
    • De sig ‘ s
    • Python-software
    • Is het echt beter dan Perl?
      • Leesbaarheid
      • Documentatie
      • Built-ins
      • De structuur van de gegevens
  • Parting shot
    • Wat andere mensen denken
    • Een laatste waarschuwing
  • De aanhangsels
    • Dankwoord

Voordat we starten

Gewoon een opmerking voordat u verder gaat: dit is gebaseerd op mijn persoonlijke ervaring met Perl. Ik weet dat andere mensen hebben andere meningen van deze taal en ze zijn welkom. Ik wil gewoon aanwezig zijn de mijne, want ik zie veel berichten op Usenet van mensen die lijken te zijn over het leren van Perl en ik houden willen om hen te vertellen dat het misschien geen goed idee is. Dus schreef ik dit artikel om dit te krijgen van mijn borst voor eens en voor altijd.

Als je denkt dat alles wat in dit artikel is objectief mis, dan kunt u me mailen over. Ik zou graag dit artikel worden als feitelijk juist mogelijk. Als je gewoon niet met mij eens zijn, kunt u mij vertellen dat ook.

Ik moet misschien uitleggen waarom ik verwijzen naar Perl als “de Kameel”: de Bijbel op alle dingen Perl is Larry Walls Perl Programmeren”, dat wordt uitgegeven door O ‘ Reilly. O ‘ Reilly meestal zet een mooi 19e-eeuwse gravure van een dier op de cover van hun boeken. “Programmeren met Perl” kreeg een kameel en is bekend als “de kameel boek” sinds die tijd. Larry Wall ook vaak verwijst naar Perl als de kameel.

Het artikel moet worden up-to-date als van Python 1.5.2 en Perl 5.005. Als er iets is veranderd sinds die versies, voel je vrij om me te vertellen over het.

Kennismaking met de Kameel

Ik leerde Perl 5 in het begin van ’97. Ik downloadde Patrick M. Ryans uitstekende inleiding tot Perl en ontdekte dat veel van de dingen die ik doe op de harde manier met C, Pascal en Java waren veel en veel makkelijker in Perl. Voor de tekst te verwerken en toegang tot de functies van het systeem Perl zag eruit als een echte God verzenden. Geweldig, dacht ik, en kocht voor mezelf een “Learning Perl”, door Randal Schwartz. (Ook wel bekend als de “lama boek”.)

Ik lees vrij snel en opgezogen al deze geweldige nieuwe features. Het eerste programma maakte ik lees een web server log en telde het aantal keren dat elke pagina had benaderd. Ik schreef het in een half uur en het werkte meteen! Niet alleen het werk, maar Perl bleek ook in staat zijn het hoofd onbelangrijke fouten in plaats van uitvallen of afbreken zoals C/Pascal/Java-programma ‘ s zou zijn.

(Dat programma werd uitgebracht in verschillende versies, en had een groot aantal gebruikers. Dus Perl is niet nutteloos, net onhandig.)

Het Krijgen van een hekel te hebben aan de Kameel

Ik was echt betoverd met deze taal en begon met het meer en meer. Echter, als ik bleef met het hield ik het ontdekken van nieuwe dingen die ik niet leuk. Na een tijdje een vrij aanzienlijke lijst.

Onleesbaar syntaxis

ik zal toegeven dat de leesbaarheid eronder lijdt een beetje…

–Larry Wall <[email protected]>

Een van de eerste dingen die ik ontdekte dat ik niet leuk vond was de syntaxis. Het is erg complex en er zijn veel van de operatoren en speciale syntaxis. Dit betekent dat je op korte, maar complexe code, met veel fouten in de syntaxis die wat tijd om uit te sorteren.

Het betekent ook dat het lezen van andermans code is moeilijk. Je kunt niet gemakkelijk begrijpen van iemand anders scripts en aan te passen aan uw eigen behoeften, noch kunt u gemakkelijk over het onderhoud van iemand anders het programma.

Ik schrijf vrij schoon Perl code, want ik blijf uit de buurt van de meeste van het verduisteren van functies, maar ook dus het wordt erg moeilijk om te lezen. Dit is een gewone voorbeeld:

foreach $Key (@SearchEngines) {
    if ($fields[11] =~ /$Key/i) {
	  $HitFrom[4]++;           #Yes, search engine
	  $SEReferrals{$SENames{$Key}}++;
	  $PageRefs{$fields[6]}{$SENames{$Key}}++;
	  $found=1;
	  last;
    }
}

Het is niet eens een bijzonder slecht voorbeeld. Hier is een functie van de Perl-distributie die produceert een Soundex-waarde van een naam of woord:

sub soundex
{
  local (@s, $f, $fc, $_) = @_;

  push @s, '' unless @s;	# handle no args as a single empty string

  foreach (@s)
  {
    tr/a-z/A-Z/;
    tr/A-Z//cd;

    if ($_ eq '')
    {
      $_ = $soundex_nocode;
    }
    else
    {
      ($f) = /^(.)/;
      tr/AEHIOUWYBFPVCGJKQSXZDTLMNR/00000000111122222222334556/;
      ($fc) = /^(.)/;
      s/^$fc+//;
      tr///cs;
      tr/0//d;
      $_ = $f . $_ . '000';
      s/^(.{4}).*/$1/;
    }
  }

Maar zelfs dit is niet echt slecht. De Perl Journal voerde een Obfuscated Perl wedstrijd. De winnaars zijn hier . Maar wees gewaarschuwd. Deze programma ‘ s geeft het woord onleesbaar geheel nieuwe en ongekende betekenis. (En nee, dit is niet een argument voor Perl wordt onleesbaar, maar vooral als een grappige en nieuwsgierige item).

Programmeurs en leesbaarheid

Sommige mensen die dit lezen hebben geklaagd dat ‘Maar iedereen kan schrijven onleesbare code in elke taal!’ en dit is zeker waar. Echter, sommige talen lijken te moedigen moeilijk leesbare code, terwijl anderen lijken te ontmoedigen.

Van wat ik heb gezien van mijn eigen en van andermans code Perl stimuleert moeilijk-te-lezen-programma ‘ s. De Soundex bovenstaande voorbeeld komt uit de Perl distributie en werd gevonden door gewoon willekeurig te kijken door middel van 2 of 3 bestanden. Kijken door het weer nu zie ik nog tal van andere voorbeelden (zoals lib/pod/tekst.pm-en lib/file/kopiëren.pm), hoewel de meeste scripts zijn te kort om te lezen.

Er wordt wel betoogd dat Perl is meer als natuurlijke talen dan de meeste programmeertalen, en dit is zeker lijkt me juist. En voor mij is dat een nadeel: natuurlijke taal is uiterst complex, dubbelzinnig en vol van subtiele nuances en betekenissen. Ik wil zeker niet mijn programma ‘ s te zijn, maar het lijkt erop dat sommige doen. Ik denk dat de lezer zal hebben om uit te zoeken voor hem/haar in welke categorie hij behoort.

Te veel speciale constructies

Veel van Perl functies zijn ingebouwd in de taal kern zelf, in plaats van te worden geplaatst in aparte bibliotheken. Een voorbeeld hiervan is de behandeling van reguliere expressies waarvoor een speciale syntax. Dit heeft het voordeel dat er een aantal handige manieren van doen van de dingen die zijn gebeurt vaak, maar het betekent ook dat je niet de voordelen van objecten.

Om één voorbeeld, Perl heeft een speciale construct genoemd formaten, die een soort van sjablonen die u kunt gebruiken om mooie tekstuele verslagen. Heel handig, maar die is ingebouwd in de taal. Dus, je kunt niet een lijst van formaten, keren ze van functies, die zal in veel gevallen een ernstige ongemak.

Ik denk dat je kan deze dingen doen met bestandsingangen, maar omdat ze ook behandeld te worden als speciale gevallen heb ik nooit in staat geweest om erachter te komen hoe. Ik heb geprobeerd met behulp van verwijzingen, maar nooit maakte het werk.

Moeilijk om te bouwen data structuren

In de Perl documentatie er is een aparte handleiding voor het maken van arrays binnen arrays en hashes binnen hashes. En het is echt nodig. Ik had een veel van pijn proberen te achterhalen hoe om dit te doen, zelfs na het lezen van het meerdere malen. Dit is iets dat echt schudde mij, want in de andere talen is dit iets wat je gewoon doet, zonder na te denken.

In Lisp, dit stelt de variabele a een lijst:

(setq a'(1 2 3 4))

Hier maken we een lijst b, waarbij het eerste element is een andere lijst:

(setq b '((0.8 0.9 1) 2 3 4))

Hier is de eerste lijst in Perl:

@a=(1,2,3,4);

en hier is de tweede:

@b=((0.8,0.9,1),2,3,4);

(De @s voor de namen van de variabele vertelt Perl dat deze zijn matrix-variabelen.) Dat was niet zo erg was het? Nou, laten we proberen om dit te gebruiken.

Op te halen uit het eerste element van de eerste lijst in Lisp, je schrijft

(first a)

en Lisp geeft u

1

Om het eerste element uit de tweede lijst schrijf je

(first b)

en Lisp geeft u

(0.8 0.9 1)

Laten we proberen dit in Perl.

$a[0]

geeft ons

1

De $ vóór de naam van de variabele vertelt Perl dat wij willen een enkele waarde (scalaire in Perl lingo), niet een array. De [0] vertelt Perl dat we willen dat de eerste waarde van de array. Perl, net als vele andere talen en Api ‘ s telt van 0.

Dan doen we

$b[0]

en Perl gelukkig geeft ons

0.8

Dat klopt, Perl heeft gebroken in de lijst in de b-lijst en haalde de eerste waarde is. Of, integendeel, het afgeplatte b in één lijst bij, dus het is nu echt een opeenvolgende lijst met 6 elementen.

Om dit goed te doen moeten we hebben geschreven

@b=([(0.8,0.9,1)],2,3,4);

toen hebben we de lijst. De []en voer een verwijzing naar de innerlijke lijst als het eerste element van de buitenste lijst in plaats van het afvlakken van de binnenste lijst in de uiterlijke.

OK. Dus proberen we het opnieuw:

$b[0]

geeft ons

ARRAY(0xb75eb0)

Dus uiteraard hebben we beheren te vinden in de matrix, maar nog iets mis gaat langs de weg. Het probleem is dat we gebruik maken van $b, waardoor Perl denk dat willen we een scalaire en dus het geeft ons een verwijzing naar de matrix in plaats van de matrix zelf (die is niet een scalaire).

Aha! Natuurlijk! We moeten gebruik maken van

@b[0]

omdat @ vertelt Perl willen we een array waarde. Niet dus. We krijgen

ARRAY(0xb75eb0)

nogmaals. Ik heb nog nooit in geslaagd om te begrijpen waarom dit zo is en op dit punt dat ik gaf over het hele ding.

Enkele weken later zag ik een nuttige plaatsen op nr.perl: één moeten vragen om een verwijzing naar de matrix, zoals deze

@{$b[0]}

eigenlijk geeft ons

(0.8 0.9 1)

Dus nu kan ik het schrijven van code met arrays in arrays en hashes in hashes.

Nu, stel jezelf de vraag: denk je echt dat je moet hebben om te gaan door dit alles in het werk te stellen om een lijst in een andere?

Definiëren van interfaces

Een ander groot nadeel Perl is dat van de functie (of subroutine, in Perl lingo) handtekeningen, of liever, het ontbreken van handtekeningen. In de meeste programmeertalen als u declareert een functie die u ook verklaren zijn handtekening onder vermelding van de namen van de parameters en in sommige talen ook hun types. Perl doet dit niet.

Dus wat in Java is

public String substring(String str, int, int) {

wordt

sub substring {
  local($str, $from, $to) = @_;

in Perl. In andere woorden, je moet handmatig decoderen van de parameter-lijst. Perl is de laatste tijd uitgebreid met het begrip van prototypes, wat betekent dat u kunt schrijven

sub substring($, $, $) {
  local($str, $from, $to) = @_;

en Perl controleer of het aantal argumenten is juist. Dit is niet verplicht, maar, en er is veel Perl code die geen gebruik maken van deze syntaxis.

De nadelen zijn er nog niet, hoewel. Veel programmeurs niet destructure de parameter array zoals in het voorbeeld hierboven, dat maakt de code veel moeilijker te lezen in een oogopslag, en dit maakt het ook onmogelijk om het automatisch genereren van goede documentatie.

En, wat meer is, je krijgt niet de voordelen van meer geavanceerde talen van functies zoals trefwoord argumenten (zonder re-implementatie van hen zelf met een hekje). Bijvoorbeeld, als u wilt maken van een hash-tabel in Common Lisp u bellen met de make-hash-tabel-functie, die in de volgende trefwoord argumenten:

  • test (welke functie te gebruiken om te testen voor de toets gelijk aan),
  • size (een suggestie van het aantal inschrijvingen verwacht),
  • rehash-size (tips voor het herkauwen van de tabel)
  • rehash-size (hoe vol de tafel kan krijgen voordat ze herkauwt)

Dit betekent dat alle volgende aanroepen, zal het maken van hash-tabellen correct:

(make-hash-table)
  (make-hash-table :test #'eq)
  (make-hash-table :size 1000)
  (make-hash-table :rehash-size 2.0 :rehash-threshold 0.7)

Het betekent ook dat u kunt hebben van de functie die een groot aantal parameters (make-array duurt 7) en toch blijven zowel de leesbaarheid en het gemak van het gebruik. U kunt hetzelfde doen in Perl, maar je bent zeker niet aangemoedigd, documentatie gereedschappen niet begrijpen, kunnen lezers niet en het is zeker niet handig in vergelijking met de manier waarop het is in Common Lisp:

(defun make-hash-table(&key test size rehash-size rehash-threshold)

Niet echt object-georiënteerde

Hoewel de object-oriëntatie is niet zo fantastisch als vele van ons zou denken, Perl ondersteuning. Echter, het heeft dus alleen halfslachtig, omdat objecten zijn toegevoegd, vrij laat in het leven van de taal.

Het resultaat hiervan is dat de normale bestanden, sockets, hashes en lijsten zijn geen objecten, wat betekent dat de interfaces zijn niet zo gemakkelijk als ze had kunnen zijn. Nieuwere versies van Perl komen met object-georiënteerde modules met wrappers voor deze soorten objecten, wat betekent dat Perl heeft een protocol voor dergelijke objecten en u kunt uw eigen implementaties van deze protocollen. Echter, het betekent ook dat je moet onderscheid gemaakt worden tussen gewone bestand verwerkt en file-objecten, die is een beetje onhandig.

Een ander ding is het feit dat bij het maken van objecten moet u expliciet het beheer van het inwendige van uw objecten. In Perl, het maken van een object is handmatig. Een klasse is gedeclareerd als een pakket, en de functies in het pakket vervolgens worden de methoden van de klasse. Om een object te maken, maak je een hash-tabel en vervolgens te zegenen (met behulp van de ingebouwde functie ‘zegenen’) maken het tot een object. De ‘perlobj’ man pagina, en dat verklaart de Perl object-eigenschappen, raadt deze vorm van object initializer:

package MyClass;
sub new {
    my $class = shift;
    my $self = {};
    bless $self, $class
    $self->initialize();  # do initialization here
    return $self;
}

Er zijn andere manieren om dat te doen object initialisatie, sommige van die problemen veroorzaken voor de erfenis. Persoonlijk vind ik het verbazingwekkend dat dit soort dingen nodig zou moeten zijn. Het bovenstaande is gelijk aan deze Python code:

class MyClass:
pass

Het resultaat is dat men kan gemakkelijk krijgen object constructie fout is (zoals door niet-catering voor overname), het definiëren van klassen is lastig en het is moeilijk te onderscheiden van de code wanneer een klasse is gedefinieerd (voor zowel mens lezers en documentatie van software tools).

Optelling van het omhoog

In het algemeen, wat dit betekent is dat Perl is een grote en complexe taal, die duurt een lange tijd om te leren goed. In mijn mening is deze complexiteit is onnodig en een eenvoudiger taal zou veel beter zijn geweest. Ik denk dat dit ook betekent dat veel niet-deskundige Perl ontwikkelaars schrijven suboptimale code.

Een ander ding is dat ik denk dat maar weinig Perl ontwikkelaars (percentage-wise) schrijf de algemene en herbruikbare modules, omdat je nodig hebt om de taal te leren en voor te doen, iets dat relatief moeilijk en kost tijd. Een ander ding is dat de taal zelf niet moedigen dit aan.

Het Ontdekken van de Python

programmeertalen leren je niet te willen wat ze niet kunnen geven. Je moet denken in een taal te schrijven programma ‘ s, en het is moeilijk om iets wilt, je niet kunt beschrijven. Toen ik voor het eerst begonnen met het programmeren in BASIC – ik heb niet missen recursie, want ik wist niet dat er zoiets bestond. Ik dacht dat in de BASIS. Ik kon alleen maar bedenken iteratieve algoritmen, dus waarom zou ik het missen van recursie?

–Paul Graham, ANSI Common Lisp.

Dus, na het ontdekken van al deze slechte dingen over Perl, wat heb ik gedaan? Ik bleef gebruiken. Immers, zo slecht als het was, het was nog beter dan het doen van de tekst te verwerken en web programmeren met C, Pascal of Java, en waren er geen betere alternatieven.

Of zo dacht ik. Aan de Universiteit boekwinkel was er het boek “Internet Programmeren met Python”. Zowel een taal-freak en een internet freak, ik dacht dat het interessant was en raapte het op. Ergens in het begin van het boek was er een anekdote over een Python programmeur die schreef al zijn Python programma ‘ s zo, dat wanneer een fout is opgetreden (dat wil zeggen: als een uitzondering werd gegooid) de error handler genoemd zijn pieper.

Wow, dacht ik. Dit klinkt interessant. Dus ik ging naar huis, vond de Python tutorial, drukte het uit en begon te spelen met Python. Die avond schreef ik een POP3-client bibliotheek in Python. Net als dat. Na het naar bed gaan had ik een idee: zou het niet veel mooier zijn als ik in de cache van de berichten en dat maakte het voor de gebruiker onzichtbaar? In de ochtend heb ik toegevoegd dat in een half uur.

Sindsdien heb ik gebruik gemaakt van deze bibliotheek naar e-mail verwijderen zonder het te downloaden, verplaatsen van 150 e-mails van een POP-account naar de andere en vele andere dingen. (Ja, ik heb een kleine SMTP-bibliotheek.) Ik kan het zelfs gebruiken als een e-mail client met behulp van de Python-interpreter als een opdrachtregel.

Ik bleef met Python meer en meer na deze. Ik schreef een link checker dat ging over mijn web pagina ‘ s te controleren op fouten en hield het toevoegen van meerdere protocollen en functies. Na een tijdje dacht ik: dit programma besteedt veel tijd aan het wachten op server reacties. Misschien kan ik versnellen door het gebruik van multi-threading, zodat het kan wachten op meerdere servers tegelijkertijd?

Ik had nog nooit echt gebruikt multithreading voor, maar wist de theorie achter. Ik toegevoegd aan de link checker in een uur en dat is inclusief het graven in de bibliotheek documentatie en het verwijderen van de paar fouten die ik heb introduceren. (Multithreading is veel complexer dan het klinkt op het eerste, omdat de dingen gelijktijdig te gebeuren. Dat is geen Python ‘ s schuld, dat wel.)

Na het lezen van dit je kan nu worden er van overtuigd dat ik een meester programmeur, in plaats van dat Python is een grote programmeertaal voor dit soort dingen. Persoonlijk, ik denk niet dat dit waar is. (Vergeet niet, ik ben de kerel die kunnen niet eens een Perl subroutine een bestand retourneren handvat.) Ook, van wat ik hoor, veel andere mensen heb soortgelijke ervaringen met Python. Hier is een voorbeeld:

In mijn eerste 15 minuten van de programmering Python schreef ik een programma dat het downloaden van alle artikelen in een nieuwsgroep in een mh-map voor me – en comp.lang is.python was mijn eerste nieuwsgroep!

–Thomas Corbin, in een persoonlijke e-mail aan de auteur

Vallen in liefde met de Python

De standaard bibliotheken

Deed het stoppen? Het is zeker niet. Sindsdien heb ik ontdekt dat deze dingen in de Python bibliotheken:

  • Ondersteuning voor het serialiseren van objecten
  • Ondersteuning voor het opslaan van geserialiseerde objecten in eenvoudige databases
  • Een Python parser
  • Ondersteuning voor eenvoudige tekst-databases (Perl heeft dit ook)
  • Bibliotheken voor ZIP-bestand compressie-en decompressie –
  • Een profiler (en een hele leuke ook!)
  • EEN CGI library
  • EEN URL parser bibliotheek
  • Een algemene URL connection library
  • Vereenvoudigde HTML, SGML en XML-parsers
  • Een eenvoudige web-server met CGI ondersteuning
  • POP -, IMAP-en SMTP-bibliotheken (Python 1.5.1; ik begon met 1,4)

En dit zijn de dingen die komen met de standaard Python distributie! Perl heeft ook de meeste van dit spul, maar het komt niet met de tolk en de kwaliteit van de documentatie en interfaces varieert.

In de Python je niet alleen deze zaken met de tolk, compleet met documentatie, ze zijn ook zeer eenvoudig in gebruik en voorzien van precies het soort dingen die men vaak wil. Zeggen dat je het schrijven van een web-robot en de robot de URL van de huidige pagina in een string (cur_url) en een relatieve URL van deze pagina naar de volgende pagina in een andere (next_url) en u wilt berekenen van de absolute URL van de volgende pagina. Dit is de code:

next_url=urlparse.urljoin(cur_url,next_url)

Python ondersteunt ook de GUI programmering via Tk op Win32, Mac en Unix. Het is echt eenvoudig te installeren, maar niet te goed gedocumenteerd. Er zijn ook vele andere manieren om de GUI programmeren met Python. (Ja, er is voor Perl.)

De SIGs

Python kan worden zo groot als Perl of Tcl. Het is meer “lief” dan die, hoewel misschien ook meer omstreden. Het heeft een uiterst ondersteunende gemeenschap van gebruikers, en dat is wat maakt het groot.

–Guido van Rossum, de schepper van Python

Wanneer ze willen om nieuwe bibliotheken maken of “normen”, de Pythoners vorm: van de Speciale Interesse Groepen van vrijwilligers, die iedereen kan meedoen. Sommige van de resultaten van dit tot dusver is een gemeenschappelijke API voor database modules (wat betekent dat u kunt gebruik maken van de Sybase-module en vervolgens uitwisselen met de Oracle enige verandering 2 regels code), een IDL-to-Python-toewijzing voor CORBA, een gemeenschappelijke tekst formaat voor de documentatie van de snaren en het gemeenschappelijke tools en Api ‘ s voor XML parsing zijn in ontwikkeling.

Python-software

Maar, als deze taal is echt zo groot is, moeten mensen niet hebben geschreven een aantal mooie handige software? Goed, ze hebben. Hier zijn enkele voorbeelden:

  • kwParsing, een parser generator
  • Horzel , een relationele database (ja, in Python!)
  • Graal, een web browser
  • Fnorb, een CORBA-ORB
  • Paos, een simpel object-georiënteerde database
  • Bobo, een systeem dat publiceert Python objecten door een web server
  • Medusa, een high-performance, extensible Internet server kader. (Web server, FTP-server en de chat-server is gebouwd op dezelfde kernel.)

Persoonlijk, mijn huidige project in Python is een volledig valideren XML-parser .

Is het echt beter dan Perl?

Ik heb deze sectie in het geval je wilt weten hoe je Python omgaat met de dingen die ik klaagde over in Perl.

Leesbaarheid

Python is de meest leesbare taal die ik ooit heb geprogrammeerd. Het kostte me een half uur om te begrijpen Medusa (ook al is het behoorlijk vreemd in concept) en nog een half uur om het te veranderen, zodat ik kon de kaart URL paden in de web server in te Python functies. Een uur daarna kon ik lees mijn Gnus mail boxen via de web-server. Nog een uur, en ik kon het nieuws door.

Hier is mijn eigen implementatie van de soundex-functie, geschreven in November ’97, toen was ik nog steeds nieuwe bij deze:

# no_tbl is an array I've constructed that maps characters to numbers
# is_letter is written by me, but I've since discovered that Python
# has it

def soundex(string):
    """Returns the Soundex code of the string. Characters not A-Z skipped."""
    string=lower(string)   

    if not is_letter(string[0]): string=string[1:]
    last=no_tbl[ord(string[0])-97]
    res =upper(string[0]) # This is where the result will end up

    for char in string[1:]:
	if is_letter(char):
	    new=no_tbl[ord(char)-97]
	    if (new!="0" and new!=last):
		res=res+new
	    last=new

    if len(res)<4:
	return res+"0"*(4-len(res))
    else:
	return res[:4]

Documentatie

Er is een Python programma genereert javadoc-als documentatie van de documentatie snaren in Python programma ‘ s. Het kan produceren uitvoer in HTML, platte tekst en FrameMaker-formaat.

Als de standaard bibliotheek documentatie kunt u zie voor jezelf .

Uitschakelen output buffering is niet verblindend voor de hand liggende, maar niet te moeilijk. Je vrij snel leren dat sys.stdout, sys.stdin en sys.stderr file-objecten die staan standaard uit, standaard en standaard fout. Dus, omdat stdout is een gewone file-object, moet zich gedragen als een met betrekking tot de output buffering. En het werkt. Deze objecten hebben geen methoden uit te schakelen buffering, maar je kan spoelen gegevens met de flush methode:

sys.stdout.flush()

Als je merkt dat het lastig is er een commando-regel optie voor de tolk die kunt u uitschakelen buffering. Echter, je moet het uitvoeren van de tolk met ‘python -?’ om dit uit te zoeken, dus ik kon niet echt zeggen dat dit ook goed gedocumenteerd.

Gebouwd-ins

Python heeft een heel aantal ingebouwde functies in vergelijking met Perl. Reguliere expressies komen in een aparte module worden geïmplementeerd als objecten. Hier is een lijst samengesteld van reguliere expressies:

reg_list=[re.compile("foo"),re.compile("[Bb][Aa][Rr]"),re.compile("ba[z]")]

Bestanden zijn ook objecten, zoals Python modules en de meeste andere dingen. Dit betekent dat u kunt doorgeven als parameters, spullen hen in lijsten, subklasse hen en zelfs klassen maken met dezelfde methoden en gebruik ze waar de code verwacht van een file-object of een module.

Gegevensstructuren

Dit is de lijst twee voorbeelden in Python (=> laat zien wat de resultaten zijn):

a=[1,2,3,4]
a[0] => 1
b=[[0.8,0.9,1],2,3,4]
b[0] => [0.8,0.9,1]

Python heeft ook hash-tabellen, tupels (vaste lengte lijsten) en volledig object-oriëntatie.

Parting shot

Wat andere mensen denken

Wilt u misschien om te horen wat andere mensen denken, dus hier zijn een aantal links naar andere meningen over Perl en Python:

  • de reden Waarom ik hou van Python, een aantal Python propaganda door Paul Prescod.
  • Keith Waclena schrijft hij over zijn zoektocht naar goede programmeertalen in Mijn programmeertaal Crisis
  • Een Verhaal van Vijf Talen vertelt over James Logajan de evaluatie van vijf scripting talen voor een embedded project
  • Eric S. Raymond legt uit waarom hij liever Python in Waarom Python?
  • Sam Holden heeft geschreven een geannoteerde versie van dit artikel, met opmerkingen over de dingen die hij het niet eens is met. (Opmerking: ik heb bijgewerkt het artikel sinds Sam schreef zijn versie.)

Een laatste waarschuwing

Kamelen zijn volgzaam als goed opgeleid en behandeld, maar, vooral in de bronsttijd, zijn aansprakelijk tot woedeaanvallen. Ze spit wanneer geïrriteerd en kan bijten en schoppen gevaarlijk.

–Encyclopedia Britannica.

Als je na dit alles toch gebruik wilt maken van Perl, dan worden mijn gast en ga je gang. Ik ben niet van plan om te stoppen met je. U bent gewaarschuwd, dat wel.

Echter kan je misschien nieuwsgierig zijn naar wat de Encyclopedia Britannica te zeggen heeft over Pythons? Hier is het:

…Monty Python Flying Circus gezelschap, die een standaard die in de jaren 1970 voor zijn eigenzinnige parodieën en maffe humor op televisie en later in films.

–Encyclopedia Britannica

Dat klopt. Python is vernoemd naar een comedy troupe, niet na een vervelende reptiel. Dit is de reden waarom er zo veel rare namen en voorbeelden in de Python tutorials en source code. 🙂

Bijlagen

Colofon

Met dank aan:

  • Trond Eivind Glomsrød voor het wijzen op een fout (en niet vlammende mij voor het schrijven van dit artikel).
  • Kjell Arne Rekaa voor het wijzen op een hard-to-spot typefout en dat er haast van overtuigd.
  • Robin Friedrich voor het wijzen op twee typefouten en linken naar dit artikel van Python-site.
  • Greg Phillips voor het wijzen op een hard-to-spot Lisp typefout.
  • Steinar Knutsen voor me te vertellen dat de Python-interpreter is een command-line optie voor het uitschakelen van buffer.
  • James Lee voor het wijzen op een typefout in mijn voorbeeld van Perl code.
  • Thomas Corbin voor het wijzen op nog een ander type-en onbedoeld het verstrekken van mij met een mooie quote.
  • Ronald J. Kimball voor enkele pertinente kritiek.
  • Andrew Ho voor zeer open-minded en kritiek, en voor het geven van Python te proberen.
  • Georg Bisseling, voor het aanwijzen van verschillende gebroken links.