Python LISP Programuotojai

on Nov 20, 13 • by admin • with No Comments

Original: http://www.norvig.com/python-lisp.html Tai trumpas įvadas į Python už LISP programuotojai. (Nors ji buvo ne mano ketinimas, Python programers man pasakė šį puslapį padėjo jiems išmokti LISP.) Iš esmės, Python gali būti vertinamas kaip Lisp dialektas su “tradicinio” sintaksės (ką...
Pin It

Home » Allgemein » Python LISP Programuotojai

Original: http://www.norvig.com/python-lisp.html

Tai trumpas įvadas į Python už LISP programuotojai. (Nors ji buvo ne mano ketinimas, Python programers man pasakė šį puslapį padėjo jiems išmokti LISP.) Iš esmės, Python gali būti vertinamas kaip Lisp dialektas su “tradicinio” sintaksės (ką Lisp žmonės vadina “intarpas” arba “M -švebeldžiuoti “sintaksė). Vienas pranešimą apie comp.lang.python sakė: “Aš niekada nesupratau, kodėl Lisp buvo gera idėja, kol aš pradėjau žaisti su python. Python palaiko visus LISP esminiai bruožai, išskyrus makrokomandas ir jums nereikia praleisti makrokomandas visi, kad daug, nes ji turi eval ir operatorius perkrovos ir reguliarios išraiškos apdorojant, todėl kai kurie – bet ne visos – apie naudojimo atvejais makrokomandas yra taikoma.

Aš pažvelgė į Python, nes buvau ketinate versti į Lisp kodą už Russell & Norvig AI vadovėlio į Java. Kai kurie dėstytojai ir studentai norėjo Java, nes

1. Tai kalba jie labiausiai susipažinęs su iš kitų kursų.

2. Jie nori turėti grafines programas.

3. Mažuma nori Java naršyklėse.

4. Kai kurie tiesiog negali priprasti prie Lisp sintaksė ribotą klasės laiko jie turėjo jai skirti.

Tačiau, mūsų pirmasis bandymas rašyti Java versijos buvo labai unsuccesful. “Java” buvo pernelyg išsami, ir tarp knygoje pseudocode ir Java kodą skirtumai buvo per didelis. Aš mačiau aplink kalba, kuri buvo arčiau knygoje pseudocode, ir atrado, Python buvo arčiausiai. Be to, ir Jython, galėčiau nukreipti Java JVM.

Mano išvada

Python yra puikus kalba mano paskirtį. Tai lengva naudoti (interaktyvus be kompiliavimo nuoroda apkrovos valdomos ciklą), kuri yra svarbi mano pedagoginiams tikslams. Nors Python neatitinka buvimo spelta JAVA sąlyga, Jython yra arti. Python atrodo lengviau skaityti, nei Lisp tiems, be jokių bet kurios kalbos patirtį. Python kodas aš sukūriau atrodo daug kaip (nepriklausomai sukurta) pseudo-kodas knygoje veiklą nei Lisp kodą. Tai svarbu, nes kai kurie studentai skundėsi, kad jie buvo sunku pamatyti, kaip pseudo-kodu knygos susiejamos į internetinę Lisp kodą (nors atrodė akivaizdu, Lisp programuotojų).

Du pagrindiniai trūkumai Python iš mano požiūriu, yra (1) yra labai mažai kompiliavimo klaida analizė ir tipas deklaracija, net mažiau nei Lisp, ir (2) vykdymo laikas yra žymiai lėtesnis nei Lisp, dažnai iš koeficiento 10 (kartais 100, o kartais ir 1). Kokybiškai, Python mano apie tuo pačiu greičiu, kaip juos išaiškino Lisp, bet labai noticably lėčiau nei surinkta Lisp. Dėl šios priežasties aš nepatarčiau Python programas, kurios yra (arba gali tapti per tam tikrą laiką) apskaičiuoti intensyvus (nebent esate pasiruošęs judėti greičio kliūtis į C). Bet mano tikslas yra orientuotas į pedagogiką, o ne gamybos, todėl tai yra ne toks svarbus.

Pristatome Python

Python gali būti laikomas tiek praktiniu (geriau bibliotekos) versijos schemą, arba kaip valyti-up (ne $ @ &% simbolių) versiją Perl. Nors Perlas filosofija yra TIMTOWTDI (yra daugiau nei vienas būdas tai padaryti), Python bando suteikia minimalią poaibį, kad žmonės bus linkę naudoti tokiu pačiu būdu (gal TOOWTDI, nes ten tik vienas būdas tai padaryti, bet, žinoma, visada daugiau nei vienas būdas, jei bandote sunku). Vienas Python prieštaringų savybių, naudojant lygį įtrauką, o ne pradėti / baigti arba petnešas, lėmė šios filosofijos:, nes nėra petnešos, nėra stiliaus karus per kur dėti petnešos. Įdomu tai, Lisp turi lygiai tokį patį philosphy šiuo klausimu: visi naudoja emacs į įtraukoje savo kodą, todėl jie ne ginčytis per įdubimas. Paimkite Lisp programą įtrauka ji tinkamai ir ištrinti atidarymo skliaustelius tuo linijų ir jas atitinkantį artimų skliaustelius pradžios, ir jūs galų gale su kažkuo, kad atrodo, o kaip Python programa.

Python turi padaryti protingus kompromisus, kurie daro paprasti dalykai labai paprasta filosofija, ir netrukdo per daug sunku dalykų. Mano nuomone, tai daro labai gerą darbą. Lengvai viskas yra lengva, sunkiau viskas palaipsniui sunkiau, ir jūs linkę nepastebėti neatitikimų. Lisp turi padaryti mažiau kompromisų filosofija: teikti labai galingas ir visiškai atitinka esmę. Tai gali padaryti LISP sunkiau mokytis, nes jums veikti aukštojo lygio abstrakcijos nuo pat pradžių ir todėl jūs turite suprasti, ką jūs darote, o ne tik remtis tuo, kas atrodo arba atrodo gražiai. Tačiau tai taip pat reiškia, kad Lisp yra lengviau pridėti lygį abstrakcijos ir sudėtingumo; Lisp yra optimizuota padaryti labai sunku dalykai nėra labai sunku, o Python yra optimizuota, kad vidutinio kietumo lengviau.

Čia aš ėmėsi Blurb iš Python.org ir sukūrė du vesions IT: vieną Python mėlynos kursyvu ir vienas Lisp žalia paryškinti. Iš Blurb urmu, bendros abiem kalbomis, yra juodas.

Python / Lisp yra aiškinamos ir renkami, Objektinis, aukšto lygio programavimo kalba su dinaminiais semantika. Jo aukšto lygio pastatytas duomenų struktūras, kartu su dinamišku spausdinimo ir dinaminės įrišimas, kad ji labai patraukli Rapid Application Development, taip pat naudoti kaip skriptų ar klijų kalba sujungti egzistuojančius komponentus kartu. Python / Lisp ‘ai paprasta, lengva išmokti sintaksę pabrėžia, aiškumą ir todėl sumažina programos priežiūros išlaidas. Python / Lisp palaiko modulius ir paketus, kurie skatina programos dinamiškumą ir kodas pakartotinio naudojimo. Python / Lisp vertėjas ir gausi standartinė biblioteka yra prieinama išeities tekstais ar vykdomąja forma be mokestį už visų pagrindinių platformų ir gali būti laisvai platinamas. Dažnai programuotojai įsimylėti Python / Lisp dėl padidėjusio produktyvumo jis aprūpina. Kadangi nėra atskiras rinkinys žingsnis, redaguoti bandymų derinimo ciklas yra neįtikėtinai greitai. Derinimo Python / Lisp programos yra paprasta: klaida ar blogas įvesties niekada sukelti segmentavimo kaltės. Vietoj to, kai vertėjas aptinka klaidą, jis pateikia išimtį. Kai programa pagauna ne išimtis, interpretatorius atspausdina stack’o. Šaltinis lygio Debugger leidžia patikrinimas vietos ir globalių kintamųjų, vertinimo savavališkai išraiškos, nustatant ribines vertes, užlipti kodas linijos vienu metu, ir pan. Debugger yra parašyta Python / Lisp pati liudijo Python / Lisp s introspective galia. Kita vertus, dažnai greičiausias būdas derinti programą yra įtraukti keletą spausdinimo pareiškimus į šaltinį: greitai redaguoti bandymų derinimo ciklas daro tai paprastas metodas labai veiksminga.

Į kurį galiu tik pridėti:

Nors kai kurie žmonės turi pirminį atsparumą atitraukimą kaip blokas / skliaustuose, dauguma ateina patinka / labai vertiname juos.

Norėdami sužinoti daugiau apie Python, jei esate patyręs programuotojas, aš rekomenduoju eiti į atsisiuntimo puslapį į Python.org ir gauti dokumentų paketą ir atkreipiant ypatingą dėmesį į Python Reference Manual ir Python Library Reference. Yra visi vadovėliai ir išleistų knygų rūšių, tačiau šios nuorodos yra tai, ką tikrai reikia.

Toliau pateiktoje lentelėje tarnauja kaip Lisp / Python vertimo vadove. Įrašai raudonųjų pažymėti vietas, kur vienos kalbos noticibly blogiau, mano nuomone. Įrašai pusjuodžiu pažymėti vietas, kur kalbos yra noticibly skiriasi, tačiau nei požiūris yra akivaizdžiai geriau. Įrašai reguliariai šriftu reiškia kalbos yra panašios; sintaksė gali šiek tiek skirtis, tačiau šios sąvokos yra tos pačios arba labai artimos. Lentelė po to sąrašo gotchas ir kai kurių programų pavyzdžius Python.

Pagrindinės funkcijos Lisp funkcijos Python funkcijos
Viskas yra objektas Taip Taip
Objektai turi tipo kintamieji nėra Taip Taip
Palaikymo nevienalyčių sąrašus Taip (susijęs sąrašas ir masyvas / vektorius) Taip (masyvas)
Kelių paradigma kalba Taip: Funkcionali, imperatyvas, OO, Bendrasis Taip: Funkcionali, imperatyvas, OO
Atmintinių valdymo Automatinis šiukšlių surinkimo Automatinis šiukšlių surinkimo
Paketai / moduliai Sunkiau naudoti Lengva naudoti
Savistaba daiktai, klasių Stiprus Stiprus
Makrokomandos metaprogramming Galingas makrokomandos Nereikia makrokomandų
Interaktyvus skaityti ver-spausdinimo kilpa > (String papildymą “labas” “” “pasaulis”)
“Hello world”
>>> “”. prisijungti (['Apie', 'pasaulis'])
“Hello world”
Trumpas išraiškinga kalba (Defun perkelti (m)
(Taikoma # “mapcar # SĄRAŠAS m))
> (Perkelti “((1 2 3) (4 5 6)))
((1 4) (2 5) (3 6))
Def perkelti (m):
grįžti zip (* M)
>>> Perkelti ([[1,2,3], [4,5,6]])
[(1, 4), (2, 5), (3, 6)]
Cross-platform perkeliamumo Windows, Mac, Unix, GNU / Linux Windows, Mac, Unix, GNU / Linux
Taškų diegimas Daug Vienas pagrindinis, plius šakos (pvz., Jython, Stackless)
Plėtros modelis Nuosavybės ir atviro kodo Atvirojo kodo
Efektyvumas Apie 1 iki 2 kartų lėčiau nei C + + Apie 2 100 kartų lėčiau nei C + +
GUI, interneto ir tt librariees Nestandartinis GUI interneto bibliotekos standartas
Metodai
Metodas išsiuntimas
Dinamiškas, (me objektas ARG) sintaksė
Runtime tipo, multi-metodai
Dinamiškas, obj.meth (ARG) sintaksė
Runtime tipo, vieno klasė pagrindu
Duomenų tipai Lisp Duomenų tipai Python Duomenų tipai
Sveikasis skaičius
Bignum
Plaukti
Sudėtingas
Styga
Simbolis
Hashtable / Žodynas
Funkcija
Klasė
Instancija
Srautas
Būlio
Tuščias seka
Trūkstama vertė:
Lisp sąrašas (prijungtas)
Python sąrašas (reguliuojamas masyvas)Kiti
42
100000000000000000
12.34
# C (1, 2)
“Labas”
Sveiki
(Make-maišos lentelė)
(Lambda (x) (+ xx))
(Defclass kamino …)
(Kad “kamino)
(Atviras “failas”)
t, nulis
(), # () Susieta sąrašas, masyvas
nulis
(1 2,0 “trys”)
(Make-arrary 3 reguliuojamas t
: Pradiniai-turinys “(1 2 3))
Daugelis (pagrindinėse kalba)
42
100000000000000000
12.34
1 + 2J
“Labas” arba “labas” # # nekintamas
“Sveiki”
{}
lambda x: x + x
klasė kamino: …
Kamino ()
atidaryti (“failas”)
True, false
() [] Kortežas, masyvas
Nė vienas
(1, (2.0 (“trys”, Nėra)))
[1, 2.0, "trys"] Daugelis (bibliotekose)
Valdymo struktūros Lisp kontrolės struktūros Python kontrolės struktūros
Pareiškimai ir išsireiškimai Viskas yra išraiška Išskirkite pareiškimus išraiškos
Neteisingų vertės nulis yra tik klaidinga vertė Netiesa, Nėra, 0,”, [], {} yra visų klaidingų
Skambinimo funkcijos (Funkcija “xyz) funkcija (x, y, z)
Sąlyginis testas (Jei xyz) jei X: Y
kitas z
Sąlyginė išraiška (Jei xyz) m jei x kita z
Nors kilpa (Ciklas while (testas) daryti (f)) o testas (): F ()
Kiti kilpos (Dotimes (ne) (fi))
(Kilpa x s daryti (fx))
(Kilpa (vardas adr atlyginimo) db daryti …)
for i in (N): F (i)
for x in S: f (x) # # veikia bet seka
už (vardas, adr, darbo užmokestis) dB: …
Užduotis (Setq xy)
(Psetq x 1 y 2)
(Rotatef xy)
(Setf (lizdas x), y)
(Vertės 1 2 3) kamino
(Daugkartinio vertės setq (xy) (vertės 1 2))
x = y
x, y = 1, 2
x, y = y, x
x.slot = y
(1, 2, 3) naudoja atminties krūvos
x, y = 1, 2
Išimtys (Ginti (/ = DENOM 0))
(Išsileisti apsaugoti (bandymas) (regeneravimas)) (Žvejybos “kamuolys … (mesti” kamuolys))
teigti DENOM! = 0, “DENOM! = 0″
bandymas atnaujinti: bandyti ()
pagaliau: atkūrimas ()
bandymas atnaujinti: <…>; kelti “kamuolys”
išskyrus “kamuolys”: …
Kitos valdymo struktūros atveju, etypecase, dir, su-atidaryti-failą, ir tt Išplėstinį su ataskaita
Jokios kitos kontrolės struktūros
Leksinė struktūra Lisp Leksikos struktūra Python Leksikos struktūra
Komentarai ;; Kabliataškiu eilutės pabaigos # # Maišos ženklą į pabaigą linijos
Skirtukus Skliaustai atriboti frazių:
(Defun tai (n)
(Jei (<= n 1) 1
(* N (tai (- n 1)))))
Įspaudas atriboti frazių:
def tai (n):
jei n <= 1: return 1
kita: grįžti n * tai (n – 1)
Aukštojo Užsakymo funkcijos Lisp aukštesnio lygio funkcijos Python aukštesnio lygio funkcijos
Funkcija taikymas
įvertinti išraišką
vykdyti pareiškimą
įkelti failą
(Taikoma FN args)
(Eval “(+ 2 2)) => 4
(Eval “(dolist (x sąrašas) (fx)))
(Įkelti “file.lisp”) arba (“būtinas failą)
taikyti (fn, args) arba fn (* args)
eval (“2 +2″) => 4
exec (“for x sąraše: f (x))
execfile (“file.py”) arba importo failą
Sekos funkcijos (Mapcar ilgis “(” vieno “(2 3))) => (3 2 skyriai)

(Sumažinti # ‘+ numerius)
(Kas # “oddp” (1 3 5)) => T
(Kai kurie # “oddp” (1 2 3)) => 1
(Remove-jei-ne # “evenp numeriai)

(Sumažinti # ‘Minimalus numerius)

žemėlapis (LEN, ["vienas" [2, 3]]) => [3, 2]
arba [Len (x) X ["vienas" [2, 3]]]
sumažinti (operator.add, skaičiai)
visos (x% 2 for x in [1,3,5]) => True
bet (x% 2 for x in [1,2,3]) => True
filtras (lambda x: x% 2 == 0, skaičius)
arba [x for x skaičiais jei x% 2 == 0]
minutės (skaičiai)
Kitos aukštesnio lygio funkcijos skaičiuoti, jei ir tt
: Testas,: pagrindiniai ir tt raktiniai žodžiai
Jokių kitų aukštesnio lygio funkcijos built-in
Nėra žemėlapyje žodžiai / sumažinti / filtruoti
Uždaryti nei tik skaityti var
Uždaryti per įrašomąjį var
(Lambda (x) (FXY))
(Lambda (x) (INCF yx))
lambda x: f (x, y)
Negali būti padaryta; naudojimo objektų
Parametrų sąrašai Lisp Parametrų sąrašai Python Parametrų sąrašai
Neprivaloma arg
Kintamo ilgio arg
Nenurodyta raktažodžių args
Skambinimas konvencija
(Defun f (& neprivaloma (ARG val) …)
(Defun f (& poilsio ARG) …)
(Defun f (ir leidžia-Kita-raktai ir poilsio ARG) …)
Kvietimas su raktiniais žodžiais tik tada, kai pareiškė:
(Defun f (& raktas xy) …)
(F y 1 x 2)
def f (arg = val): …
def f (* ARG): …
def f (** ARG): …
Skambinkite į bet kurį su raktiniais žodžiais funkcija:
def f (x, y): …
f (y = 1, x = 2)
Efektyvumas Lisp efektyvumo klausimai Pitonas vartojimo efektyvumo klausimus
Kompiliacija
Funkcija nuoroda raiška
Deklaracijos
Kaupia į gimtąją kodą
Dauguma funkcija / metodas paieška “yra sparčiai
Deklaracijos gali būti efektyvumo
Kaupia į bytecode tik
Dauguma funkcija / metodas paieška “yra lėtas
Nėra deklaracijos
Savybės Lisp funkcijų ir funkcijos Python funkcijų ir funkcijos
Citata Quote visą sąrašą struktūra:
“Sveiki
“(Tai yra testas)
“(Hello world (+ 2 2))
Cituoti atskirų eilučių ar Split (.):
“Sveiki”
“Tai testas”. Padalijimas ()
['Apie', 'pasaulis', [2 "+", 2]]
Introspectible doc stygos (Defun f (x)
“Apskaičiuoti f vertę”
…)
> (Dokumentacija “F” funkcija)
“Apskaičiuoti f vertę”
def f (x):
“Apskaičiuoti f vertę”

>>> F.__doc__
“Apskaičiuoti f vertę”
Sąrašas prieiga Per funkcijas:
(Pirmasis sąrašas)
(Setf (ELT sąrašas n) Val)
(Pirmasis (paskutinis sąraše))
(Subseq sąrašas pradžia pabaiga)
(Subseq sąrašas pradžia)
Per sintaksė:
sąrašas [0]
sąrašas [n] = Val
sąrašas [-1]
sąrašas [pradžia: pabaiga]
sąrašas [pradžia:]
Hashtable prieiga Per funkcijas:
(Setq h (make-maišos lentelė))
(Setf (gethash “vienas” h) 1,0)
(Gethash “vienas” h)
(Jau ((h (make-maišos lentelė)))
(Setf (gethash “vienas” h) 1)
(Setf (gethash “du” h) 2)
h)
Per sintaksė:
h = {}
H ["vienas"] = 1,0
H ["vienas"] arba h.get (“vienas”)
h = {“vienas”: 1, “du”: 2}
Veiksmai su sąrašais (Trūkumai xy)
(Automobilių x)
(CdR x)
(Atitinka xy)
(EQ xy)
nulis
(Ilgis punktus)
(Vektorius 1 2 3)
[X] + y bet O (n), taip pat y.append (x)
x [0]
x [1], bet O (n)
x == y
x yra y
() Arba []
Len (punktai)
(1, 2, 3)
Veiksmai su matricomis (Įsitikinkite, matrica 10: pradinis elementas 42)
(Aref xi)
(INCF (aref xi))
(Setf (aref xi) 0)
(Ilgis x)
# (10 20 30), jei dydis nesikeičia
10 * [42]
x [i]
x [i] + = 1
x [i] = 0
LEN (x)
[10, 20, 30]

Svarbus dalykas daugeliui žmonių yra Python ir Lisp greitis, lyginant su kitomis kalbomis. Jo sunku gauti lyginamuosius duomenis, kurie yra reikiamą informaciją apie savo programų rinkinys, tačiau tai gali būti naudinga:

 

Santykiniai greitis 5 kalbų apie 10 rodiklių iš Didžiosios kompiuterinę kalbą Shootout .
Testas Švebeldžiuoti Java Pitonas Perlas C + +
maišos prieiga 1.06 3.23 4.01 1.85 1.00
Išimties tvarkymas 0.01 0,90 1.54 1.73 1.00 Legenda
suma numerius iš failo 7.54 2.63 8.34 2.49 1.00 > 100 x C + +
atvirkštinės linijos 1.61 1.22 1.38 1.25 1.00 50-100 x C + +
matricos daugyba 3.30 8.90 278.00 226.00 1.00 10-50 x C + +
heapsort 1.67 7.00 84.42 75.67 1.00 5-10 x C + +
masyvas prieiga 1.75 6.83 141,08 127.25 1.00 2-5 x C + +
sąrašas apdorojimas 0.93 20.47 20.33 11.27 1.00 1-2 x C + +
objekto egzemplioriaus 1.32 2.39 49.11 89.21 1.00 <1 x C + +
žodžių 0.73 4.61 2.57 1.64 1.00
Vidutinis 1.67 4.61 20.33 11.27 1.00
25% 75% 0,93-1,67 2,63-7,00 2,57-84,42 1,73-89,21 1,00-1,00
Diapazonas 0,01-7,54 0,90-20,47 1,38-278 1,25-226 1,00-1,00

Greitis yra normalus, todėl g+ + kompiliatorius, C + + yra 1.00, tai 2.00 reiškia perpus lėčiau; 0.01 priemonė 100 kartų greičiau. Dėl Lisp, CMUCL sudarytojas buvo naudojamas. Fono spalvos koduojamos pagal legendos dešinėje. Pastarieji trys eilutės suteikia vidutinis balas, 25% iki 75% Quartile balai (atmetus du apatiniai ir aukščiausios du balai kiekvienai kalbai) ir bendrą diapazoną. Lyginant Lisp ir Python ir mesti iš viršaus ir apačios du, mes Python yra 3-85 kartų lėčiau nei Lisp – apie kaip Perl pats, bet daug lėčiau nei Java arba LISP. Lisp yra maždaug du kartus taip greitai, kaip Java.

Gotchas už LISP programuotojų Python

Čia aš išvardyti konceptualias problemas man, kaip Lisp programuotojas artėja prie Python:

  1. Sąrašai nėra Conses. Python sąrašai iš tikrųjų, kaip reguliuojamas masyvų į Lisp ar vektorius Java. Tai reiškia, kad sąrašas prieiga O (1), bet abiejų trūkumus ir cdr generuoti O (n) naujasis saugojimo ekvivalentas. Jūs tikrai norite naudoti žemėlapį ar už E X: o ne automobilių / CdR rekursija. Atkreipkite dėmesį, kad yra daug tuščios sąrašai, o ne tik vieną. Tai nustato bendrą kirminas Lisp, kur vartotojai (nconc metai nauja) ir tikisi, kad metai turi būti pakeista, tačiau jis nėra pakeistas, kai senas yra lygus nuliui. Python, old.extend (nauja) veikia net tada, kai vyras yra []. Tačiau tai nereiškia, kad jūs turite patikrinti prieš [] su ==, o ne tai, o tai reiškia, kad jei jūs nustatote numatytąjį argumentą, lygią [] Tu geriau ne keisti vertę.
  2. Python yra mažiau funkcionalus. Iš dalies dėl to sąrašai nėra conses, Python naudoja daugiau metodų, kurie mutuoja sąrašas struktūra nei Lisp, ir pabrėžti, kad jie mutuoti, jie linkę grįžti Nėra. Tai pasakytina apie metodus, pavyzdžiui, list.sort, list.reverse ir list.remove. Tačiau daugiau naujesnės versijos Python buvo slapčia funkcinius versijas atgal, kaip funkcijos, o ne būdų: dabar mes turime rūšiuoti ir atvirkščiai (bet ne pašalinti).
  3. Python klasės yra daugiau funkcinių. Be Lisp (CLOSE), kai jūs iš naujo C klasės, objektas, kuris yra C gauna keisti. Esami pavyzdžiai ir poklasiai, kurie nurodo į C yra taip nukreipti į naują klasę. Kartais tai gali sukelti problemų, tačiau interaktyviosios derinimo paprastai tai yra tai, ko norite. Python, kai jūs iš naujo apibrėžti klasę gausite naują klasės objektą, tačiau seni atvejų ir poklasiai dar kreiptis į senąją klasę. Tai reiškia, kad didžiąją laiko dalį jūs turite perkrauti savo poklasius ir atstatyti savo duomenų struktūras kiekvieną kartą iš naujo apibrėžti klasę. Jei pamiršote, galite gauti supainioti.
  4. Python yra labiau dinamiškas, ar mažiau klaidų tikrinimas. Python jūs negausite jokių neapibrėžtų funkcijų arba laukuose, arba Netinkamas argumentų skaičius nėra perduota funkcija, arba beveik nieko daugiau ne krovimosi laiką įspėjimus, jums teks palaukti, kol vykdymo metu. Komercinių Lisp diegimas bus pažymėti daugelis iš šių, kaip įspėjimų; paprastesni diegimas, pavyzdžiui, clisp ne. Viena vieta, kur Python yra akivaizdžiai labiau pavojinga, kai jūs self.feild = 0, kai siekiama įvesti self.field = 0; buvęs dinamiškai sukurti naują lauką. Į Lisp ekvivalentas (setf (feild si) 0) suteiks jums klaida. Kita vertus, pasiekti neapibrėžtą lauką duos jums abiem kalbom klaida.
  5. Nepamirškite savęs, tai daugiau “Java” programuotojai nei LISP programuotojų:. Per metodą, įsitikinkite, kad jums self.field, o ne lauko. Yra jokių numanomų apimtis. Dauguma laiko, tai suteikia jums run-time klaida. Tai erzina, bet manau, vienas mokosi ne padaryti jį po kurio laiko.
  6. Nepamirškite grįžti Rašymas def du kartus (x). X + x yra viliojanti, nerodantis įspėjimą ar išimtis, bet jūs tikriausiai reiškė turėti ten grįžti. Tai ypač įkyrus, nes per lambda jums draudžiama rašyti grąžą, tačiau semantika yra padaryti grąžą.
  7. Saugokitės pavienių tuples. Kortežas yra tik nekintamas sąrašą ir sudaro su skliaustelius, o ne kvadratiniai petnešomis. () Yra tuščias kortežas, ir (1, 2) yra du elementas kortežas, bet (1) yra tik 1. Naudokite (1) vietoj. Fu. Damian Mortonas nurodė man, kad jis turi prasmę, jei jūs suprantate, kad tuples spausdinami naudojant skliaustelius, bet jie susidaro kableliais; į skliaustelius yra tik tam, kad dviprasmiškumą grupavimą. Pagal šį aiškinimą, 1, 2 yra du elementas aštuntukas ir 1, yra vienas elementas kortežas, ir skliaustelius kartais reikia, priklausomai nuo to, kur aštuntukas atrodo. Pavyzdžiui, 2, + 2 yra juridinis išraiška, bet tai turbūt būtų aiškiau naudoti (2) + (2) arba (2, 2).
  8. . Saugokitės tam tikromis išimtimis Būkite atsargūs: dict [raktas] kelia KeyError kai raktas trūksta, Lisp hashtable vartotojai tikisi nuliui. Jūs turite sugauti išimtis ar bandymas su raktu žodyne.
  9. Python yra Lisp-1.Tuo aš noriu pasakyti, kad Python turi vieną vardų funkcijas, ir kintamuosius, pavyzdžiui, schema, o ne du, kaip bendrosios Lisp. Pavyzdžiui:
     def f (sąrašas, ilg): grįžti sąrašas ((ilg, ilg (sąrašas))) # # blogas Python
     (Define (f sąrašas ilgis) (sąrašas ilgis (ilgis sąrašas)));; blogas schema
     (Defun f dalis (sąrašas ilgis) (sąrašas ilgis (ilgis sąrašas)));; juridinis Bendra Lisp

    Tai taip pat pasakytina ir apie laukus ir metodus, jūs negalite suteikti abstrakcijos lygio lauku su to paties pavadinimo būdą:

     C klasė:
         def f (si): grįžti self.f # # blogas Python
         ...
  10. Python stygos yra ne visai kaip LISP simboliais. Python nėra simbolį lookup interning styginiams maišos lenteles, kad egzistuoja modulius ir klases. Tai yra, kai rašote obj.slot Python ieško eilutės "lizdas" į maišos lentelė dėl obj klasės, vykdymo metu. Python taip pat stažuotojai kai styginiams vartotojo kodą, pavyzdžiui, kai jūs sakote, x = "g". Bet tai nėra intern eilutes, kad neatrodo kaip kintamųjų, kaip ir x = "g" (ačiū Brian Spilsbury už pažymėdamas tai atlikti).
  11. Python neturi makrokomandas.Python ar turite prieigą prie abstrakčios sintaksės medis programų, tačiau tai nėra už silpnumą širdies. Apie plius pusėje, moduliai yra lengva suprasti, ir penkių minučių iki penkių eilučių kodo galėjau gauti tai:
     >>> Apdoroti ("2 + 2")
     ['Eval_input "[" testlist "[' testas ', [' and_test" ["not_test" ["palyginimas"
      ["Išraiška" ["xor_expr" ["and_expr" ["shift_expr" ["arith_expr" ["sąvoka", 
       ['Koeficientas', ["galia", ["atomas", [2, '2 ']]]]], [14, "+"], ["terminas", ["veiksnys",
        ["Galia", ["atomas", [2, '2 ']]]]]]]]]]]]]]], [4''], [0,'']]

    Tai buvo gana disapointment man. Lisp apdoroti lygiaverčio išraiškos (+ 2 2). Atrodo, kad tik tikras ekspertas norėtų manipuliuoti Python parsēšanas medžius, o Lisp parse medžiai yra paprasta tiems, naudoti. Jis vis dar įmanoma sukurti kažką panašaus į makrokomandas Python pagal concatenating stygos, tačiau ji nėra integruota su kalba poilsio, ir taip praktiškai nėra padaryta. Be Lisp, yra du pagrindiniai tikslai makrokomandas: naujos valdymo struktūros, ir nestandartinių problemų konkrečios kalbos. Buvęs tiesiog nėra padaryta Python. Vėliau gali būti padaryta dėl duomenų su problema specifinio formato Python: mažiau nei aš apibrėžti kontekstą nemokamą gramatikos Python naudojant builtin sintaksė žodynų ir Preprocesorius žingsnis, kuris suvokia eilutes į duomenų struktūrų derinys. Derinys yra beveik toks pat gražus, kaip LISP makrokomandas. Tačiau daugiau sudėtingos užduotys, pavyzdžiui, raštu už loginio programavimo kalbos kompiliatorius, yra lengva Lisp, bet sunku Python.

Lyginant Lisp ir Python programa

Aš paėmė pirmajame pavyzdyje programą iš paradigmų dirbtinio intelekto programavimo , yra paprastosios atsitiktinės sakinių generatorių ir išversti jį į Python. Išvados: glaustumas yra panašus; Python pelnas, nes gramatikos [frazė] yra paprastesnis nei (taisyklė-dešinėje (doc frazė * gramatikos *)), tačiau Lisp pelnas, nes "(NP VP) beats ['NP", "VP"]. Python programa tikriausiai yra mažiau efektyvus, bet tai ne taškas. Abi kalbos atrodo labai gerai tinka panašiose programose. Padaryti Jūsų naršyklė langas platus, kad pamatyti tai tinkamai.

Python Program simple.py (idiomatic version)

"""Generate random sentences from a grammar.  The grammar
consists of entries that can be written as S = 'NP VP | S and S',
which gets translated to {'S': [['NP', 'VP'], ['S', 'and', 'S']]}, and
means that one of the top-level lists will be chosen at random, and
then each element of the second-level list will be rewritten; if a symbol is
not in the grammar it rewrites as itself.   The functions generate and
generate_tree generate a string and tree representation, respectively, of
a random sentence."""

import random

def Grammar(**grammar):
  "Create a dictionary mapping symbols to alternatives."
  for (cat, rhs) in grammar.items():
    grammar[cat] = [alt.split() for alt in rhs.split('|')]
  return grammar

grammar = Grammar(
  S  = 'NP VP',
  NP = 'Art N',
  VP = 'V NP',
  Art= 'the | a',
  N  = 'man | ball | woman | table',
  V  = 'hit | took | saw | liked'
  )

def generate(symbol='S'):
  "Replace symbol with a random entry in grammar (recursively); join into a string."
  if symbol not in grammar:
    return symbol
  else:
    return ' '.join(map(generate, random.choice(grammar[symbol])))

def generate_tree(symbol='S'):
  "Replace symbol with a random entry in grammar (recursively); return a tree."
  if symbol not in grammar:
    return symbol
  else:
    return {symbol: map(generate_tree, random.choice(grammar[symbol]))}

Related Posts

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

*

Du kannst folgende HTML-Tags benutzen: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

Scroll to top