Guido van Rossum, creatorul limbajului Python, şi-a botezat limbajul dupa spectacolul BBC “Monty Python’s Flying Circus” (Circul zburător al lui Monty Python). De fapt el nu prea agreează şerpii constrictori, care ucid animale pentru hrană strivindu-le.

Guido van Rossum este creatorul Python, una dintre limbile de programare majore pe și de pe web.Comunitatea Python se referă la el ca BDFL (Dictator Bunăvoitor Pentru Viață), un titlu direct dintr-o schiță Monty Python. Sa mutat din Olanda în SUA în 1995, unde și-a întâlnit soția. Până în iulie 2003, ei locuiau în suburbiile de la Virginia din nordul Washingtonului, împreună cu fiul lor Orlijn, care sa născut în 2001. Apoi, ei s-au mutat în Silicon Valley unde Guido lucrează acum pentru Google (petrecând 50% din timp pe Python!). Această intrare în blog este Copyright © 2007 Guido van van Rossum. Toate drepturile rezervate.

Python ro:Introducere Python este un limbaj uşor de învăţat şi puternic. Deţine structuri de date de nivel înalt eficiente şi o abordare simplă dar efectivă asupra programării orientate pe obiecte. Sintaxa elegantă a lui Python şi modul dinamic de selecţie a tipului de date, împreună cu natura sa de limbaj interpretat, îl face un limbaj ideal pentru scriptare şi pentru dezvoltare rapidă de aplicaţii în multe domenii şi pe majoritatea platformelor existente. Citirea unui program bine scris în Python dă aceeaşi senzaţie ca şi citirea unei nuvele în engleză, deşi cu o gramatică foarte strictă! Această natură de pseudocod a lui Python este una din marile sale puteri. Ea îţi permite să te concentrezi asupra soluţiei problemei mai degraba decât asupra limbajului însuşi.

Aşa cum vei vedea, cu Python este extrem de uşor de început. Python are o sintaxă extraordinar de simplă. Python este un exemplu de FLOSS (Free/Libre and Open Source Software). În termeni simpli, poţi distribui liber copii ale acestui software, citi codul sursă, modifica, folosi părţi din el în alte programe free. FLOSS se bazează pe conceptul de comunitate care pune cunoştinţe în comun. Acesta este unul din motivele pentru care Python este aşa de bun – el a fost creat şi îmbunătăţit constant de o comunitate care pur şi simplu îşi doreşte să vadă un Python tot mai bun.

Când scrii programe în Python, nu ai nevoie să te preocupi de detalii de nivel scăzut precum managementul memoriei folosite de program etc…

Portabil: Prin natura sa open source, Python a fost portat (modificat ca să funcţioneze) pe multe platforme. Toate programele tale Python pot funcţiona pe oricare din aceste platforme, fără a necesita vreo modificare, dacă programezi cu grija de a evita facilităţile dependente de sistem ale limbajului.; Poţi folosi Python pe Linux, Windows, FreeBSD, Macintosh, Solaris, OS/2, Amiga, AROS, AS/400, BeOS, OS/390, z/OS, Palm OS, QNX, VMS, Psion, Acorn RISC OS, VxWorks, PlayStation, Sharp Zaurus, Windows CE şi chiar pe PocketPC!

Limbaj interpretat: Aici sunt necesare câteva explicaţii.; Un program scris întrun limbaj compilat, precum C sau C++ este convertit din limbajul sursă întrun format acceptat de calculator (codul binar, cu 1 şi 0) folosind un compilator cu diverse comutatoare şi opţiuni. Când rulezi programul link-editat, software-ul copiază programul de pe harddisc şi începe să îl execute.; Python, pe de altă parte, nu necesită compilare în binar. Pur şi simplu se lansează programul direct din codul sursă. Intern, Python converteşte codul sursă întrun format intermediar numit bytecodes (rom. şir de octeţi), apoi pe acesta îl transformă în limbajul nativ al computerului (cod maşină) şi apoi îl rulează. În fapt toate acestea fac utilizarea limbajului Python mult mai uşoară fiindcă nu mai trebuie să porţi grija compilării programului, a verificării alegerii link-editarii şi încărcării corecte a bibliotecilor etc, etc. Din acelaşi motiv programele scrise în Python sunt mult mai portabile, doar le copiezi pe alt calculator şi imediat merg!

Limbaj orientat pe obiecte: Python suportă şi programarea procedurală, pe lângă programarea orientată pe obiecte. În limbajele orientate pe proceduri programele sunt construite în jurul procedurilor şi funcţiilor acestea nefiind altceva decât porţiuni de program reutilizabile. În limbajele orientate pe obiecte programul este construit În jurul obiectelor, care combină datele şi funcţionalitatea. Python are o metodă foarte puternică, dar simplă de a face programare orientată pe obiecte (OOP), în special în comparaţie cu marile limbaje precum Java sau C++.

Extensibil: Dacă ai nevoie ca o porţiune din codul programului să ruleze foarte rapid sau vrei ca unele soluţii de algoritm să nu fie open, poţi coda partea aceea în C sau C++ şi poţi apela acea parte direct din programul Python.

Implantabil: Se poate implanta cod Python în programe C/C++ pentru a le oferi facilităţi de ‘scripting’ utilizatorilor programelor.

Biblioteci extinse: Biblioteca standard Python este cu adevărat uriaşă. Te poate ajuta să rezolvi diverse probleme referitoare la expresii regulare, generare de documentaţie, testare de părţi, gestiune de fire de execuţie, baze de date, browsere web, CGI, ftp, email, XML, XML-RPC, HTML, fişiere .WAV, criptografie, GUI (graphical user interfaces), Tk şi alte lucruri dependente de sistem. Reţineţi, toate acestea sunt prezente unde este instalat Python. Acest lucru este aşa-numita filozofie ‘cu baterii incluse’ a limbajului Python.; Pe lângă biblioteca standard există diferite alte biblioteci de foarte bună calitate, precumwxPython, Twisted, Python Imaging Library şi multe altele.

Python este întradevăr un limbaj puternic şi antrenant. Are combinaţia corectă de performanţă şi facilităţi care fac scrierea de programe în Python şi distractivă şi uşoară.

De ce nu Perl?

Dacă nu ştiaţi deja, Perl este un alt limbaj de programare open-source interpretat.

Dacă aţi fi încercat vreodată să scrieţi un program mare în Perl, v-aţi fi răspuns singuri la întrebare!

Cu alte cuvinte programele în Perl sunt uşoare când sunt mici şi excelează la mici găselniţe şi scripturi de ‘făcut treaba’. Oricum, ele devin rapid prea complexe îndată ce încep să crească şi vă spun asta din propria experienţă de autor de programe în Perl la Yahoo!

Comparativ cu Perl, programele Python sunt clar mai simple, mai curate, mai uşor de scris şi astfel mai uşor de înţeles şi întreţinut. Eu admir Perl-ul şi îl folosesc zilnic pentru diverse lucruri, dar când încep să scriu un program încep prin a-l gândi în termenii de Python pentru că mie îmi vine mai natural aşa. Perl a suferit aşa de multe perfecţionări şi schimbări încât el pare a fi o mare (dar foarte utilă)găselniţă. Regretabil, dar aşteptatul Perl 6 nu pare a face progrese din acest punct de vedere.

Singurul avantaj foarte semnificativ pentru Perl este reţeaua sa de arhive de module CPAN (the Comprehensive Perl Archive Network). Aşa cum sugerează şi numele ei, CPAN este o colecţie uriaşă de module Perl care impresionează prin extindere şi profunzime – folosind aceste module poţi face virtual orice. Unul din motivele pentru care Perl are mai multe module ca Python este acela că el a apărut mai demult decât Python. În orice caz, situaţia asta pare a se schimba datorită indexului Python Package Index de pachete Python.

De ce nu Ruby?

Dacă nu stiaţi deja, Ruby este un alt limbaj de programare open-source interpretat.

Dacă deja apreciaţi şi folositi Ruby, atunci în mod cert vă recomand să continuaţi să-l folosiţi.

Pentru ceilalti, care nu l-au folosit şi încearcă să judece dacă să înveţe Ruby sau Python, as recomanda Python, pe baza criteriului uşurinţei de învătare. Personal, l-am găsit greu de asimilat, dar cei ce înteleg Ruby propovăduiesc frumuseţea sa. Din nefericire nu sunt atât de norocos.

Ce spun programatorii

Poate vă interesează să citiţi părerea unor mari hackeri, precum ESR despre Python:

Eric S. Raymond este autorul lucrării ‘Catedrala şi bazarul’ fiind de asemenea părintele termenului ‘Open Source’. El spune că Python a devenit limbajul său de programare favorit. Acel articol a fost o adevărată inspiraţie pentru abordarea primelor mele programe în Python.
Bruce Eckel este autorul faimoaselor cărţi ‘Gândire în Java’ şi ‘Gândire în C++’. El spune că nici un limbaj de programare nu i-a adus o productivitate mai mare ca Python. În plus Python este probabil singurul limbaj focalizat pe a uşura munca programatorului. Citeşte interviul completpentru alte detalii.
Peter Norvig este un binecunoscut autor de programe LISP, director de calitatea căutării la Google (mulţumiri lui Guido van Rossum pentru acest pont). El spune ca Python a fost întotdeauna parte integrantă din Google. Îi poţi verifica declaraţia pe pagina Google Jobs care arată cerinţa obligatorie de cunoştinţe de Python pentru inginerii de software.

Despre Python 3.0

Python 3.0 este noua versiune în devenire a limbajului. I se mai spune ‘Python 3000’ sau ‘Py3K’.

Motivul principal pentru o nouă versiune majoră a limbajului Python este eliminarea tuturor micilor probleme şi critici acumulate peste ani şi a face limbajul chiar mai curat.

Daca ai deja mult cod Python versiunea 2.x, există un utilitar pentru a te ajuta să converteşti codul sursă din versiunea 2.x în versiunea 3.x.

Mai multe detalii în:

Introducerea lui Guido van Rossum
Ce e nou în Python 2.6 (facilităţi sensibil diferite de versiunile 2.x precedente care probabil vor fi incluse în Python 3.0)
Ce e nou în Python 3.0
Python 2.6 şi graficul de lansare al versiunii 3.0
Python 3000 (lista oficială definitivă a schimbărilor propuse)
Diverse planuri Python 3.0
Noutăţi Python (lista detaliată a modificărilor)

https://swaroop.wordpress.com/notes/python_ro-introducere/

În comparație cu alte limbi de programare, mecanismul clasei Python adaugă clase cu un minim de sintaxă și semantică noi. Este un amestec al mecanismelor de clasă descoperite în C ++ și Modula-3. Clasele Python oferă toate caracteristicile standard ale programării orientate pe obiecte: mecanismul de moștenire a clasei permite mai multor clase de bază, o clasă derivată poate suprascrie orice metodă a clasei sau clasei sale de bază și o metodă poate apela metoda unei clase de bază cu același nume . Obiectele pot conține cantități arbitrare și tipuri de date. Așa cum este valabil și pentru module, clasele participă la natura dinamică a Python: ele sunt create în timpul execuției și pot fi modificate ulterior după crearea.

În terminologia C ++, în mod normal, membrii clasei (inclusiv membrii de date) sunt publici (cu excepția vederilor Variabile Private ) și toate funcțiile membre sunt virtuale . Ca și în Modula-3, nu există contorii pentru referirea membrilor obiectului din metodele sale: funcția de metodă este declarată cu un prim argument explicit reprezentând obiectul, care este furnizat implicit de apel. Ca și în Smalltalk, clasele sunt obiecte. Aceasta oferă semantică pentru import și redenumire. Spre deosebire de C ++ și Modula-3, tipurile încorporate pot fi folosite ca clase de bază pentru extensie de către utilizator. De asemenea, ca în C ++, majoritatea operatorilor încorporați cu sintaxă specială (operatori aritmetici, subscripting etc.) pot fi redefiniți pentru instanțe de clasă.

(Lipsa terminologiei universal acceptate pentru a vorbi despre clase, voi folosi ocazional termenii Smalltalk și C ++. Aș folosi termeni Modula-3, deoarece semantica orientată pe obiect este mai apropiată de cea a lui Python decât C ++, dar mă aștept ca puțini cititori au auzit de ea.)

Obiectele au individualitate, iar mai multe nume (în mai multe domenii) pot fi legate la același obiect. Aceasta este cunoscută sub numele de aliasing în alte limbi. Acest lucru nu este de obicei apreciat la prima vedere la Python și poate fi ignorat în siguranță atunci când se ocupă cu tipuri de bază imuabile (numere, șiruri, tuple). Cu toate acestea, aliasingul are un efect surprinzător posibil asupra semanticii codului Python care implică obiecte mutabile, cum ar fi listele, dicționarele și majoritatea celorlalte tipuri. Aceasta este de obicei folosită în beneficiul programului, deoarece pseudonimurile se comportă ca indicii în anumite privințe. De exemplu, trecerea unui obiect este ieftină, deoarece doar un indicator este trecut prin implementare; și dacă o funcție modifică un obiect trecut ca argument, apelantul va vedea schimbarea - aceasta elimină necesitatea existenței a două mecanisme diferite de trecere a argumentelor ca în Pascal.

Înainte de a introduce clase, trebuie să vă spun mai întâi despre regulile de aplicare a Python. Definițiile de clasă joacă niște trucuri îngrijite cu spații de nume și trebuie să știți cum funcționează domeniile și spațiile de nume pentru a înțelege pe deplin ce se întâmplă. De altfel, cunoștințele despre acest subiect sunt utile pentru orice programator Python avansat.

Un spațiu de nume este o mapare de la nume la obiecte. Majoritatea spațiilor de nume sunt implementate în prezent ca dicționare Python, dar în mod normal nu sunt vizibile în niciun fel (cu excepția performanței) și se pot schimba în viitor. Exemple de spații de nume sunt: setul de nume încorporate (care conțin funcții precum abs () și nume excepționale construite); numele globale dintr-un modul; și numele locale într-o invocare a funcțiilor. Într-un sens, mulțimea de atribute ale unui obiect formează și un spațiu de nume. Lucrul important de știut despre spațiile de nume este că nu există absolut nicio legătură între numele în spații de nume diferite; de exemplu, două module diferite pot să definească o funcție maximizată fără confuzie - utilizatorii modulelor trebuie să o prefixeze cu numele modulului.

Apropo, folosesc atributul cuvânt pentru orice nume care urmează un punct - de exemplu, în expresia z.real , real este un atribut al obiectului z . În mod strict vorbind, referințele la nume în module sunt referințe atribute: în expresia modname.funcname , modname este un obiect de module și funcnameeste un atribut al acestuia. În acest caz se întâmplă o mapare simplă între atributele modulului și denumirile globale definite în modul: aceștia împărtășesc același spațiu de nume! [1]

Atributele pot fi doar pentru citire sau scriere. În ultimul caz, este posibilă alocarea atributelor. Atributele modulului sunt inscriptibile: puteți scrie modname.the_answer = 42 . Atributele de scriere pot fi șterse și cu instrucțiunea del . De exemplu, del modname.the_answer va elimina atributul the_answer de la obiectul numit modname .

Spațiile de nume sunt create în momente diferite și au durate diferite de viață. Spațiul de nume care conține numele încorporate este creat atunci când interpretul Python pornește și nu este șters niciodată. Spațiul de nume global pentru un modul este creat atunci când se citește definiția modulului; în mod normal, numerele de module ale modulelor durează și până când interpretul se oprește. Instrucțiunile executate de invocarea de nivel superior a interpretului, fie citite dintr-un fișier script, fie interactiv, sunt considerate ca parte a unui modul numit __main__ , deci au propriul lor spațiu de nume global. (Numele încorporate trăiesc de asemenea într-un modul, acest lucru se numește builtins .)

Spațiul de nume local pentru o funcție este creat atunci când funcția este apelată și șters atunci când funcția returnează sau ridică o excepție care nu este tratată în cadrul funcției. (De fapt, uitarea ar fi o modalitate mai bună de a descrie ce se întâmplă de fapt). Desigur, invocările recursive au fiecare propriul lor spațiu de nume local.

Un domeniu este o regiune textuală a unui program Python în care un spațiu de nume este direct accesibil. "Direct accesibil" înseamnă că o referință necalificată la un nume încearcă să găsească numele în spațiul de nume.

Deși scopurile sunt determinate static, ele sunt folosite dinamic. În orice moment în timpul execuției, există cel puțin trei domenii imbricate ale căror spații de nume sunt direct accesibile:

domeniul de aplicare cel mai intim, care este căutat în primul rând, conține numele locale
domeniile oricărei funcții de închidere, care sunt căutate începând cu cel mai apropiat domeniu de aplicare, conțin nume non-locale, dar și non-globale
următorul domeniu de aplicare conține numele global al modulului curent
cel mai îndepărtat domeniu (ultimul căutat) este spațiul de nume care conține numele încorporate

Dacă un nume este declarat global, atunci toate referințele și alocările merg direct la domeniul de aplicare intermediar care conține numele global al modulului. Pentru a rebrand variabilele găsite în afara domeniului interior, se poate folosi declarația nonlocală ; dacă nu sunt declarate nonlocale, acele variabile sunt doar pentru citire (încercarea de a scrie la o astfel de variabilă va crea pur și simplu o nouă variabilă locală în interiorul domeniului interior, lăsând neschimbată variabila externă identică).

De obicei, domeniul de aplicare local se referă la numele local al funcției curente (textuale). În afara funcțiilor, domeniul de aplicare local se referă la același spațiu de nume ca și domeniul global: spațiul de nume al modulului. Definițiile de clasă plasează încă un spațiu de nume în domeniul de aplicare local.

Este important să ne dăm seama că domeniile sunt determinate textual: domeniul global al unei funcții definite într-un modul este spațiul de nume al modulului, indiferent de unde sau prin ce nume se numește funcția. Pe de altă parte, căutarea reală a numelor se face dinamic, la momentul executării - totuși, definiția limbii evoluează spre rezolvarea numelui static, la momentul "compilației", deci nu vă bazați pe rezoluția dinamică a numelui! (De fapt, variabilele locale sunt deja determinate static.)

O chestiune specială a lui Python este că - dacă nu există nicio declarație globală - atribuțiile la nume intră întotdeauna în domeniul cel mai intim. Atribuțiile nu copiază date - ci doar leagă numele la obiecte. Același lucru este valabil și pentru ștergeri: instruciunea del x elimină legarea lui x din spațiul de nume referit de domeniul de aplicare local. De fapt, toate operațiunile care introduc nume noi utilizează domeniul de aplicare local: în special, declarațiile de import și definițiile funcțiilor leagă numele modulului sau al funcției în domeniul local.

Declarația globală poate fi utilizată pentru a indica faptul că anumite variabile trăiesc în sfera globală și ar trebui să revină acolo; nelocal declarație indică faptul că anumite variabile trăiesc într - un domeniu de aplicare împrejmuitor și ar trebui să fie de rebound acolo.

9.2.1. Exemple de spații și nume de case

Acesta este un exemplu care demonstrează modul de referință a diferitelor domenii și spații de nume și modul în care influența globală și nelocală afectează variația obligatorie:

def  scope_test (): 
    def  do_local (): de 
        spam  =  "spam local" 
    def  do_nonlocal (): 
        nelocal de  spam 
        spam -  =  "spam nelocal" 
    def  do_global (): la 
        nivel mondial de  spam de 
        spam  =  " la nivel mondial spam" de 
    spam  =  "test de spam" 
    do_local ( ) 
    print ( "După asignarea locală:" ,  spam ) 
    do_nonlocal () 
    print ( "După alocare nelocală :" ,  spam ) 
    do_global() 
    print ( "După asignarea globală:" ,  spam )

scope_test () 
print ( "În scop global:" ,  spam )

Rezultatul exemplului de cod este:

După atribuirea locală: încercați spam
După alocarea nelocală: spam nonlocal
După alocare globală: spam nonlocal
În domeniul global: spam global

Notă modul în care locale alocare (care este implicit) nu a modificat scope_test e legarea de spam - ului . Nelocal Atribuirea schimbat scope_test e legarea spam - ului , iar la nivel mondial atribuirea schimbat legării la nivel de modul.

De asemenea, puteți vedea că nu a existat nici o obligație anterioară pentru spam înainte de atribuirea globală .

9.3. O primă privire la clase

Clasele introduc un pic de sintaxă nouă, trei tipuri de obiecte noi și câteva semantici noi.

9.3.1. Sintaxa de definire a clasei

Cea mai simplă formă de definire a clasei arată astfel:

Clasa de  ClassName : 
    < declarație - 1 > 
    . 
    . 
    . 
    < declarație - N >

Definițiile de clasă, cum ar fi definițiile funcțiilor ( declarațiile def ) trebuie executate înainte de a avea vreun efect. (Ați putea plasa o definiție de clasă într-o ramură a unei declarații if sau în interiorul unei funcții.)

În practică, afirmațiile din interiorul unei definiții de clasă vor fi, de obicei, definiții de funcții, dar alte declarații sunt permise și uneori utile - vom reveni la aceasta mai târziu. Definițiile funcțiilor dintr-o clasă au, în mod normal, o formă specifică de listă de argumente, dictată de convențiile de apel pentru metode - din nou, acest lucru este explicat mai târziu.

Când se introduce o definiție de clasă, se creează un nou spațiu de nume și se utilizează ca domeniu de aplicare local - astfel, toate asignările la variabilele locale intră în acest nou spațiu de nume. În particular, definițiile funcțiilor leagă numele aici pentru noua funcție.

Atunci când o definiție de clasă este lăsată în mod normal (prin capăt), se creează un obiect de clasă . Acesta este, în principiu, un înveliș în jurul conținutului spațiului de nume creat de definiția clasei; vom afla mai multe despre obiectele de clasă în secțiunea următoare. S-a restabilit domeniul original original (cel în vigoare imediat înainte de definirea clasei), iar obiectul de clasă este legat aici de numele clasei din antetul de clasă definit ( ClassName din exemplu).

9.3.2. Obiecte de clasă

Elementele de clasă acceptă două tipuri de operațiuni: referințe de atribute și instanțiere.

Referințele atributelor utilizează sintaxa standard folosită pentru toate referințele atributelor din Python: obj.name . Numele de atribute valide sunt toate numele care au fost în spațiul de nume al clasei atunci când a fost creat obiectul de clasă. Deci, dacă definiția clasei arăta astfel:

clasa  MyClass : 
    "" Un exemplu de clasă exemplară "" " 
    i  =  12345 
    def  f ( self ): 
        întoarcere  " hello world "

apoi MyClass.i și MyClass.f sunt referințe de atribute valide, returnând un întreg și un obiect de funcție, respectiv. De asemenea, pot fi atribuite atribute ale clasei, astfel încât să puteți schimba valoarea lui MyClass.i prin alocare. __doc__ este, de asemenea, un atribut valabil, returnând docstring aparținând clasei: "O clasă de exemple simple " .

Inițializarea clasei utilizează notația funcției. Doar pretindeți că obiectul de clasă este o funcție fără parametri care returnează o nouă instanță a clasei. De exemplu (presupunând clasa de mai sus):

x  =  MyClass ()

creează o nouă instanță a clasei și atribuie acest obiect variabilei locale x .

Operația de instanțiere ("apelarea" unui obiect de clasă) creează un obiect gol. Multe clase le place să creeze obiecte cu instanțe personalizate la o stare inițială specifică. Prin urmare, o clasă poate defini o metodă specială numită __init __ () , după cum urmează:

def  __init__ ( auto ): 
    sine . date  =  []

Atunci când o clasă definește o metodă __init __ () , instanța de clasă invocă automat __init __ () pentru instanța de clasă nou creată. Astfel, în acest exemplu, o nouă instanță inițializată poate fi obținută prin:

x  =  MyClass ()

Desigur, metoda __init __ () poate avea argumente pentru o mai mare flexibilitate. În acest caz, argumentele date operatorului instanței de clasă sunt transmise __init __ () . De exemplu,

>>>

>>> clasa  Complex : 
...     def  __init__ ( sine ,  realpart ,  imagpart ): 
...         sine . r  =  realitate 
...         sine . i  =  imagpart 
... 
>>> x  =  Complex ( 3.0 ,  - 4.5 ) 
>>> x . r ,  x . i 
(3,0, -4,5)

9.3.3. Obiectele de instanță

Acum, ce putem face cu obiectele instanței? Singurele operațiuni înțelese de obiectele instanței sunt referințele atributelor. Există două tipuri de nume de atribute valide, atribute și metode de date.

atributele de date corespund "variabilelor de instanță" din Smalltalk și "membrilor de date" din C ++. Atribuiile de date nu trebuie să fie declarate; cum ar fi variabilele locale, ele apar în momentul în care sunt atribuite pentru prima dată. De exemplu, dacă x este instanța MyClass creată mai sus, următoarea bucată de cod va tipări valoarea 16 , fără a lăsa o urmă:

x . contra  =  1 în 
timp ce  x . contra  <  10 : 
    x . contra  =  x . contra  *  2 
imprimare ( x . contra ) 
del  x . tejghea

Alt tip de referință a atributului de instanță este o metodă . O metodă este o funcție care "aparține" unui obiect. (În Python, metoda termenului nu este unică pentru instanțele de clasă: alte tipuri de obiecte pot avea și metode, de exemplu, obiectele din listă au metode numite adăugați, inserați, ștergeți, sortați și așa mai departe.În următoarea discuție, vom folosi metoda termenului exclusiv pentru a înțelege metode ale obiectelor instanței de clasă, cu excepția cazului în care se specifică altfel.)

Numele de metode valide ale unui obiect de instanță depind de clasa sa. Prin definiție, toate atributele unei clase care sunt obiecte funcționale definesc metodele corespunzătoare ale instanțelor sale. Deci, în exemplul nostru, xf este o referință validă a metodei, deoarece MyClass.f este o funcție, dar xinu este, deoarece MyClass.i nu este. Dar xf nu este același lucru cu MyClass.f - este un obiect de metodă , nu un obiect de funcție.

9.3.4. Metodă Obiecte

De obicei, o metodă este chemată imediat după ce este obligată:

x . f ()

În exemplul MyClass , aceasta va returna șirul "hello world" . Cu toate acestea, nu este necesar să apelați imediat o metodă: xf este un obiect de metodă și poate fi stocat și apelat ulterior. De exemplu:

xf  =  x . f în 
timp ce  True : 
    print ( xf ())

va continua să tipărească lumea salutului până la sfârșitul timpului.

Ce se întâmplă exact atunci când se numește o metodă? Este posibil să fi observat că xf () a fost apelat fără un argument de mai sus, chiar dacă definiția funcției pentru f () a specificat un argument. Ce sa întâmplat cu argumentul? Cu siguranță, Python ridică o excepție atunci când o funcție care necesită un argument este numită fără nici un cuvânt - chiar dacă argumentul nu este utilizat efectiv ...

De fapt, poate ați ghicit răspunsul: lucrurile speciale despre metode sunt că obiectul este trecut ca primul argument al funcției. În exemplul nostru, apelul xf () este exact echivalent cu MyClass.f (x). În general, apelarea unei metode cu o listă de argumente n este echivalentă cu apelarea funcției corespunzătoare cu o listă de argumente care este creată prin introducerea obiectului metodei înaintea primului argument.

Dacă încă nu înțelegeți cum funcționează metodele, o privire la implementarea poate clarifica problemele. Atunci când un atribut instanță este referit, care nu este un atribut de date, se caută clasa sa. Dacă numele denumește un atribut de clasă valabil, care este un obiect funcțional, un obiect de metodă este creat prin împachetarea (indicii către) obiectul instanței și obiectul funcției care au fost găsiți împreună într-un obiect abstract: acesta este obiectul metodei. Atunci când obiectul metodei este numit cu o listă de argumente, se construiește o nouă listă de argumente din obiectul instanță și din lista de argumente, iar obiectul funcțional se numește cu această nouă listă de argumente.

9.4. Alegeri aleatorii

Atributele de date suprascriu atributele metodei cu același nume; pentru a evita conflictele de nume accidentale, care pot provoca erori greu de găsit în programele mari, este înțelept să folosiți un fel de convenție care să minimizeze șansele de conflicte. Contractele posibile includ numele de metode de capitalizare, prefixarea numelor de atribute de date cu un șir unic mic (poate doar o subliniere) sau utilizarea verbelor pentru metode și substantive pentru atributele de date.

Atributele de date pot fi menționate prin metode, precum și de către utilizatorii obișnuiți ("clienți") ai unui obiect. Cu alte cuvinte, clasele nu sunt utilizabile pentru a pune în aplicare tipuri pure de date abstracte. De fapt, nimic din Python nu face posibilă ascunderea datelor ascunse - totul se bazează pe convenție. (Pe de altă parte, implementarea Python, scrisă în C, poate să ascundă complet detaliile implementării și să controleze accesul la un obiect, dacă este necesar, acesta putând fi folosit de extensiile Python scrise în C.)

Clienții ar trebui să folosească atributele de date cu grijă - clienții pot provoca daune invarianților întreținute de metode prin ștampilarea pe atributele lor de date. Rețineți că clienții pot adăuga propriile atribute de date unui obiect de instanță fără a afecta valabilitatea metodelor, atâta timp cât sunt evitate conflictele de nume - din nou, o convenție de numire poate salva o mulțime de dureri de cap aici.

Nu există o stenogramă pentru referirea atributelor de date (sau a altor metode!) Din cadrul metodelor. Consider că acest lucru mărește, de fapt, lizibilitatea metodelor: nu există nicio șansă de a confunda variabilele locale și variabilele de instanță atunci când se uită printr-o metodă.

Adesea, primul argument al unei metode se numește sine . Aceasta nu este altceva decât o convenție: numele de sine nu are absolut nici un înțeles special pentru Python. Rețineți însă că, prin nerespectarea convenției, codul dvs. poate fi mai puțin lizibil pentru alți programatori Python și este de asemenea posibil ca un program de browser de clasă să poată fi scris care se bazează pe o astfel de convenție.

Orice obiect de funcții care este un atribut de clasă definește o metodă pentru instanțele acelei clase. Nu este necesar ca definiția funcției să fie inclusă în text în definiția clasei: atribuirea unui obiect funcțional unei variabile locale în clasă este, de asemenea, ok. De exemplu:

# Funcție definită în afara clasei 
def  f1 ( auto ,  x ,  y ): 
    retur  min ( x ,  x + y )

clasa  C : 
    f  =  f1 
    def  g ( auto ): 
        întoarcere  'hello world' 
    h  =  g

Acum , f , g și h sunt atribute ale clasei C care se referă la obiectele funcției și, prin urmare, toate metode ale instanțelor C - h sunt exact echivalente cu g . Rețineți că această practică servește, de obicei, doar la confuzarea cititorului unui program.

Metodele pot apela alte metode prin utilizarea atributelor metode ale auto argumentului:

 sac de clasă : 
    def  __init__ ( auto ): 
        sine . date  =  [] 
    def  adăugați ( auto ,  x ): 
        auto . date . adăugați ( x ) 
    def  addtwice ( auto ,  x ): 
        self . adăugați ( x ) 
        auto . adaugă ( x )

Metodele pot face referire la nume globale în același mod ca și funcțiile obișnuite. Domeniul de aplicare global asociat unei metode este modulul care conține definiția sa. (O clasă nu este niciodată utilizată ca domeniu de aplicare global). În timp ce se întâlnește rareori un motiv bun pentru utilizarea datelor globale într-o metodă, există multe utilizări legitime ale domeniului global: pentru un singur lucru, funcțiile și modulele importate în domeniul global pot să fie utilizate prin metode, precum și funcții și clase definite în acesta. De obicei, clasa care conține metoda este ea însăși definită în acest domeniu global, iar în următoarea secțiune vom găsi câteva motive bune pentru care o metodă ar dori să se refere la propria clasă.

Fiecare valoare este un obiect și, prin urmare, are o clasă (de asemenea numită tipul ei ). Este stocat ca obiect .__ class__ .

9.5. Moștenire

Bineînțeles, o caracteristică lingvistică nu ar fi demnă de denumirea "clasă" fără a susține moștenirea. Sintaxa pentru o definiție a clasei derivate arată astfel:

clasă  DerivedClassName ( BaseClassName ): 
    < declarație - 1 > 
    . 
    . 
    . 
    < declarație - N >

Numele BaseClassName trebuie definit într-un domeniu care conține definiția clasei derivate. În locul unui nume de clasă de bază, sunt permise și alte expresii arbitrare. Acest lucru poate fi util, de exemplu, atunci când clasa de bază este definită într-un alt modul:

Clasa de clasa  derivat˘a ( modname . BaseClassName ):

Executarea unei definiții de clasă derivată este aceeași ca și pentru o clasă de bază. Atunci când obiectul de clasă este construit, clasa de bază este amintită. Acesta este folosit pentru rezolvarea referințelor atributului: dacă un atribut solicitat nu este găsit în clasă, căutarea continuă să se uite în clasa de bază. Această regulă este aplicată recursiv dacă clasa de bază în sine este derivată dintr-o altă clasă.

Nu este nimic special în instanțierea claselor derivate: DerivedClassName () creează o nouă instanță a clasei. Referințele la metodă sunt rezolvate după cum urmează: se caută atributul de clasă corespunzător, coborând în jos lanțul de clase de bază, dacă este necesar, iar referința metodei este validă dacă aceasta dă un obiect de funcție.

Clasele derivate pot depasi metodele din clasele de baza ale acestora. Deoarece metodele nu au privilegii speciale atunci când apelați alte metode ale aceluiași obiect, o metodă a unei clase de bază care apelează o altă metodă definită în aceeași clasă de bază poate ajunge la a apela o metodă a unei clase derivate care o suprascrie. (Pentru programatori C ++: toate metodele din Python sunt efectiv virtuale .)

O metodă suprapusă într-o clasă derivată poate, de fapt, să dorească să se extindă mai degrabă decât să înlocuiască pur și simplu metoda de clasă de bază cu același nume. Există o modalitate simplă de a apela metoda directă a clasei de bază: trebuie doar să apelați BaseClassName.methodname (auto, argumente) . Acest lucru este uneori util și pentru clienți. (Rețineți că acest lucru funcționează numai dacă clasa de bază este accesibilă ca BaseClassName în domeniul global.)

Python are două funcții încorporate care funcționează cu moștenire:

Utilizați instanța () pentru a verifica tipul instanței: isinstance (obj, int) va fi Adevăratnumai dacă obj .__ class__ este int sau o anumită clasă derivată din int .
Utilizați issubclass () pentru a verifica moștenirea claselor: issubclass (bool, int) este True deoarece bool este o subclasă de int . Cu toate acestea, issubclass (float, int)este False, deoarece float nu este o subclasă de int .

9.5.1. Moștenire multiplă

Python susține și o formă de moștenire multiplă. O definiție de clasă cu mai multe clase de bază arată astfel:

clasa  DerivedClassName ( Base1 ,  Base2 ,  Base3 ): 
    < declarație - 1 > 
    . 
    . 
    . 
    < declarație - N >

În cele mai multe scopuri, în cele mai simple cazuri, vă puteți gândi la căutarea atributelor moștenite de la o clasă părinte ca adâncime în primul rând, de la stânga la dreapta, fără a căuta de două ori în aceeași clasă în care există o suprapunere în ierarhie. Astfel, dacă un atribut nu este găsit în DerivedClassName , acesta este căutat în Base1 , apoi (recursiv) în clasele de bază ale Base1 și, dacă nu a fost găsit acolo, a fost căutat în Base2 și așa mai departe.

De fapt, este puțin mai complexă decât asta; ordinea de rezoluție a metodei se modifică dinamic pentru a sprijini apelurile de tip cooperativ către super () . Această abordare este cunoscută în alte limbi cu mai multe moșteniri ca metodă call-next și este mai puternică decât super-apelul găsit în limbi de mostenire singulară.

Ordonarea dinamică este necesară deoarece toate cazurile de moștenire multiplă prezintă una sau mai multe relații diamante (în cazul în care cel puțin una dintre clasele părinte poate fi accesată prin mai multe căi din clasa inferioară). De exemplu, toate clasele moștenesc de la obiect , astfel încât orice caz de moștenire multiplă oferă mai mult de o cale pentru a ajunge la obiect. Pentru a păstra clasele de bază accesate de mai multe ori, algoritmul dinamic linearizează ordinea de căutare într-un mod care păstrează ordonarea de la stânga la dreapta specificată în fiecare clasă, care apelează fiecare părinte o singură dată și este monotonică o clasă poate fi subclasată fără a afecta ordinea de prioritate a părinților săi). Luate împreună, aceste proprietăți fac posibilă proiectarea unor clase fiabile și extensibile cu moștenire multiplă. Pentru mai multe detalii, consultațihttp://www.python.org/download/releases/2.3/mro/ .

9.6. Variabile private

Variabilele de instanță "private" care nu pot fi accesate decât în interiorul unui obiect nu există în Python. Cu toate acestea, există o convenție care este urmată de majoritatea codului Python: un nume prefixat cu o subliniere (de exemplu, _spam ) trebuie tratat ca o parte non-publică a API-ului (indiferent dacă este vorba despre o funcție, o metodă sau un membru de date) . Ar trebui să fie considerat un detaliu al implementării și să se schimbe fără notificare.

Deoarece există un caz de utilizare valabil pentru membrii de clasă privat (și anume pentru a evita ciocnirile de nume cu nume definite de subclase), există un sprijin limitat pentru un astfel de mecanism numit mangling nume . Orice identificator al formularului __spam (cel puțin două subliniere de frunte, cel mult un subliniere finală ) este înlocuit textual cu _classname__spam , unde classname este numele curent al clasei cu underscorele principale dezbatete . Acest mangling se face fără să se țină cont de poziția sintactică a identificatorului, atâta timp cât apare în definiția unei clase.

Numele mangling este util pentru a permite subclasele să înlocuiască metodele fără a rupe apelurile prin metoda intraclass. De exemplu:

Clasa de  cartografiere : 
    def  __init__ ( auto ,  iterable ): de 
        sine . items_list  =  [] 
        singur . __update ( iterabil )

    def  update ( auto ,  iterabil ): 
        pentru  element  în  iterabil : 
            auto . items_list . adăugați ( element )

    __update  =  actualizare    # copie privată a metodei original update ()

class  MappingSubclass ( Mapping ):

    def  actualizare ( auto ,  chei ,  valori ): 
        # furnizează o nouă semnătură pentru actualizare () 
        # dar nu rupe __init __ () 
        pentru  elementul  din  zip ( chei ,  valori ): 
            self . items_list . adăugați ( element )

Rețineți că regulile de mangling sunt concepute în principal pentru a evita accidentele; este încă posibil să accesați sau să modificați o variabilă considerată privată. Acest lucru poate fi util chiar și în circumstanțe speciale, cum ar fi în programul de depanare.

Observați că codul trecut la exec () sau eval () nu consideră că clasa clasei invocate este clasa curentă; acest lucru este similar cu efectul instrucțiunii globale , efectul căruia este limitat la codul care este compilat împreună. Aceeași restricție se aplică și pentru getattr () , setattr () și delattr () , precum și când se face referire directă __dict__ .

9.7. Cote și sfârșituri

Uneori este util să aveți un tip de date similar cu "înregistrarea" Pascal sau C "struct", grupând împreună câteva elemente de date numite. O definiție a clasei goale va face bine:

clasa  angajat : 
    treci

john  =  Angajat ()  # Creați o înregistrare a angajatului gol

# Umpleți câmpurile 
john-ului de înregistrare . nume  =  'John Doe' 
john . dept  =  'computer lab' 
john . salariu  =  1000

O bucată de cod Python care așteaptă un anumit tip de date abstract poate fi adesea trecută de o clasă care emulează în schimb metodele acelui tip de date. De exemplu, dacă aveți o funcție care formatează anumite date dintr-un obiect de fișier, puteți defini o clasă cu metode read () și readline () care obțin datele dintr-un tampon șir și o transmit ca un argument.

Metoda instanței are și atribute: m .__ self__ este obiectul instanței cu metoda m () , iar m .__ func__ este obiectul funcției corespunzător metodei.

9.8. Excepțiile sunt prea

Excepțiile definite de utilizator sunt identificate și pe clase. Folosind acest mecanism este posibil să se creeze ierarhii extensibile de excepții.

Există două noi forme valide (semantice) pentru instrucțiunea de creare :

ridica  clasa

ridicați  instanța

În prima formă, clasa trebuie să fie o instanță de tip sau de o clasă derivată din ea. Prima formă este o stenogramă pentru:

ridica  Clasa ()

O clasă în afară de clauză este compatibilă cu o excepție în cazul în care este aceeași clasă sau o clasă de bază ale acestora (dar nu și invers - o clauză cu excepția listarea o clasă derivată nu este compatibilă cu o clasă de bază). De exemplu, următorul cod va imprima B, C, D în ordinea următoare:

clasa  B ( excepție ): 
    treceți 
clasa  C ( B ): 
    treceți 
clasa  D ( C ): 
    treceți

pentru  cls  în  [ B ,  C ,  D ]: 
    incercati : 
        ridica  cls () cu 
    excepția  D : 
        print ( "D" ) , cu 
    excepția  C : 
        print ( "C" ) cu 
    excepția  B : 
        print ( "B" )

Rețineți că dacă clauzele excepționale au fost inversate (cu excepția lui B în prealabil), ar fi imprimat B, B, B - prima potrivire cu excepția clauzei este declanșată.

Când se imprimă un mesaj de eroare pentru o excepție nefolosită, este imprimat numele clasei excepției, apoi un punct și un spațiu, iar în final instanța a fost convertită la un șir folosind funcția built-in str () .

9.9. Iteratori

Până acum ați observat probabil că majoritatea obiectelor container pot fi bucle cu ajutorul unei instrucțiuni pentru :

pentru  elementul  din  [ 1 ,  2 ,  3 ]: 
    print ( elementul ) 
pentru  elementul  din  ( 1 ,  2 ,  3 ): 
    print ( elementul ) 
pentru  cheie  în  { 'one' : 1 ,  'doi' : 2 }: 
    print ( cheie ) 
pentru  char  în  "123" : 
    print ( char ) 
pentru  linie în  deschis ( "myfile.txt" ): 
    print ( linie )

Acest stil de acces este clar, concis și convenabil. Utilizarea iteratoarelor pătrunde și unifică Python. În spatele scenei, instrucțiunea for solicită iter () pe obiectul containerului. Funcția returnează un obiect iterator care definește metoda __next __ () care accesează elementele din container unul câte unul. Atunci când nu există mai multe elemente, __ __next () ridică o StopIteration excepție care spune pentru bucla de a termina. Puteți apela metoda __next __ () folosind următoarea () funcție încorporată; acest exemplu arată cum funcționează toate:

>>>

in ? următorul ( it ) StopIteration

După ce am văzut mecanica din spatele protocolului iterator, este ușor să adăugați comportamentul iterator la clasele tale. Definiți o metodă __iter __ () care returnează un obiect cu o metodă __next __ () . Dacă clasa definește __next __ () , atunci __iter __ () se poate întoarce singură :

clasa  inversă : 
    "" "Iterator pentru reluarea unei secvențe înapoi." " 
    def  __init__ ( sine ,  date ): 
        sine . date  =  date de 
        sine . index  =  len ( date ) 
    def  __iter__ ( auto ): 
        întoarcere  self 
    def  __next__ ( auto ): 
        dacă  ești singur . index  ==  0 : 
            ridicați  Auto StopIteration 
        . index =  de sine . index  -  1 
        întoarcerea de  sine . date [ auto . index ]

>>>

>>> rev  =  Reverse ( spam ) 
>>> iter ( rev ) 
<__ principal __ Obiect invers la 0x00A1DB50> 
>>> pentru  char  in  rev : 
...     print ( char ) 
... 
m 
a 
p 
s

9.10. Generatoare

Generatoarele sunt un instrument simplu și puternic pentru crearea iteratorilor. Ele sunt scrise ca funcții obișnuite, dar utilizeazăinstrucțiunea de randament ori de câte ori doresc să returneze date. De fiecare dată cândse cheamă următorul () , generatorul revine la locul unde a rămas (își amintește toate valorile datelor și care a fost executată ultima dată). Un exemplu arată că generatoarele pot fi ușor de creat:

Definiție  inversă ( date ): 
    pentru  indexul  din  intervalul ( len ( date ) - 1 ,  - 1 ,  - 1 ): 
        date privind randamentul  [ index ]

>>>

>>> pentru  char  in  reverse ( "golf" ): 
...     print ( char ) 
... 
f 
l 
o 
g

Orice lucru care se poate face cu generatoarele se poate face, de asemenea, cu iteratori de clasă, așa cum este descris în secțiunea anterioară. Ceea ce face generatoarele atât de compacte este că metodele __iter __ () și __next __ () sunt create automat.

O altă caracteristică cheie este aceea că variabilele locale și starea de execuție sunt salvate automat între apeluri. Acest lucru a făcut ca funcția să fie mai ușor de scris și mult mai clară decât o abordare folosind variabile de exemplu, cum ar fi self.index și auto.data .

În plus față de crearea automată a metodei și de salvarea stării programului, atunci când generatoarele termină, ele cresc automat StopIteration . În combinație, aceste caracteristici ușurează crearea iteratorilor fără efort mai mult decât scrierea unei funcții obișnuite.

9.11. Expresii generatoare

Unele generatoare simple pot fi codificate succint ca expresii utilizând o sintaxă similară înțelegerii listei, dar cu paranteze în loc de paranteze. Aceste expresii sunt concepute pentru situațiile în care generatorul este utilizat imediat printr-o funcție de închidere. Expresiile generatoare sunt mai compacte, dar mai puțin versatile decât definițiile complete ale generatoarelor și tind să fie mai prietenoase față de memorie decât comprehensiunea echivalentă a listelor.

Exemple:

>>>

>>> suma ( i * i  pentru  i  în  intervalul ( 10 ))                  # suma pătratelor 
285

>>> xvec  =  [ 10 ,  20 ,  30 ] 
>>> yvec  =  [ 7 ,  5 ,  3 ] 
>>> sum ( x * y  pentru  x , y  în  zip ( xvec ,  yvec ))          produs # dot 
260

>>> de la  importul de matematică  pi , sin >>> sine_table = { x : sin ( x * pi / 180 ) pentru x în intervalul ( 0 , 91 )}  
        

>>> unique_words  =  set ( cuvânt   pentru  linie  în  pagină   pentru  cuvânt  în  rândul . split ())

>>> valedictorian  =  max (( elev . APG ,  elev . Nume )  pentru  student de  la  absolvenți )

>>> data  =  'golf 
>> >> lista ( date [ i ]  pentru  i  în  intervalul ( len ( data ) - 1 ,  - 1 ,  - 1 )) 
[' f ',' g ']

https://docs.python.org/3.3/tutorial/classes.html

Compatibilitate

Python 3.0 va rupe compatibilitatea înapoi. Intru totul. Nici măcar nu țintim pentru un anumit subset comun. (Desigur, va exista un subset comun, probabil destul de mare, dar nu vrem să facem convenabil sau chiar posibil să scriem programe semnificative în acest subset. Este doar un set de trăsături care se întâmplă neschimbate de la 2.6 la 3.0.)
Python 2.6, pe de altă parte, va menține compatibilitatea completă cu Python 2.5 (și versiunile anterioare, în măsura posibilităților), dar va sprijini și compatibilitatea în viitor, în următoarele moduri:

Python 2.6 va suporta un "modul de avertismente Py3k" care va avertiza dinamic (adica la runtime) despre functiile care vor inceta sa lucreze in Python 3.0, de exemplu presupunand ca range () returneaza o lista.

Python 2.6 va conține versiuni suportate ale mai multor funcții Py3k, fie activate prin instrucțiuni __future__, fie pur și simplu permițând utilizarea sintaxei vechi și noi una lângă cealaltă (dacă noua sintaxă ar fi o eroare de sintaxă în 2.5).

În plus față de caracteristicile de compatibilitate pentru versiunea 2.6, va exista un instrument separat de conversie a codului sursă . Acest instrument poate face o traducere sursă-sursă fără context. Ca exemplu (foarte simplu), se poate traduce aplicarea (f, args) în f (* args) . Cu toate acestea, instrumentul nu poate efectua analiza fluxului de date sau tiparea inferențelor, deci presupune pur și simplu că aplica în acest exemplu se referă la funcția veche încorporată.

Dezvoltare tranzitorie

Modelul de dezvoltare recomandat pentru un proiect care trebuie să sprijine simultan Python 2.6 și 3.0 este următorul:

Începeți cu teste excelente de unitate, în mod ideal aproape de acoperire completă.

Portați proiectul către Python 2.6.

Activați modul avertizări Py3k.

Testați și editați până când nu mai există avertismente.

Utilizați instrumentul 2to3 pentru a converti acest cod sursă în sintaxa 3.0. Nu modificați manual ieșirea!

Testați codul sursă convertit sub 3.0.

Dacă găsiți probleme, faceți corecții la versiunea 2.6 a codului sursă și reveniți la pasul 3.

Când este timpul să lansați, lansați separat 2.6 și 3.0 tarballs (sau orice formă de arhivă pe care o utilizați pentru lansări).

Instrumentul de conversie produce cod sursă de înaltă calitate, care, în multe cazuri, nu poate fi distins de codul convertit manual. Cu toate acestea, este puternic recomandat să nu pentru a începe editarea codului sursă 3.0 până când sunteți gata pentru a reduce sprijin 2.6 la întreținere pură (adică momentul în care v - ar muta în mod normal , codul 2.6 la o ramură de întreținere , oricum).
Pasul (1) este de așteptat să ia efortul obișnuit de a porta orice proiect într-o nouă versiune Python. Încercăm să facem tranziția de la 2,5 la 2,6 cât mai lină posibil.
Dacă instrumentele de conversie și funcțiile de compatibilitate în Python 2.6 funcționează conform așteptărilor, pașii (2) până la (6) nu ar trebui să depună mult mai mult efort decât trecerea tipică de la Python 2.x la 2. (x + 1).

Starea caracteristicilor individuale

Există prea multe modificări pentru a le prezenta pe toate; în schimb, mă voi referi la PEP. Cu toate acestea, aș dori să evidențiez o serie de caracteristici pe care le consider semnificative sau care se așteaptă să fie de interes deosebit sau controversate.

Unicode, codecuri și I / O

Trecem la un model cunoscut din Java: (imutabile) șiruri de text sunt Unicode, iar datele binare sunt reprezentate de un tip de date separat "bytes". În plus, parserul va fi mai prietenos cu Unicode: codarea sursă implicită va fi UTF-8, iar literele non-ASCII pot fi utilizate în identificatori. Există încă o dezbatere despre normalizare, alfabete specifice și dacă putem susține în mod rezonabil scripturi de la dreapta la stânga. Cu toate acestea, biblioteca standard va continua să utilizeze ASCII numai pentru identificatori și va limita utilizarea non-ASCII în comentarii și literali de șir la testele unității pentru unele dintre caracteristicile Unicode și numele autorilor.
Vom folosi "..." sau "..." interschimbabil pentru literalurile Unicode, iar b "..." sau b "..." pentru literali octeți. De exemplu, b'abc " este echivalent cu crearea unui obiect octet folosind octeții de expresie ([97, 98, 99]) .
Adoptăm o abordare puțin diferită a codecurilor: în timp ce în Python 2, codec-urile pot accepta fie unicode, fie 8-biți ca intrare și produc fie ca ieșire, în Py3k, codarea este întotdeauna o traducere dintr-un șir Unicode (text) de octeți, iar decodificarea merge întotdeauna în direcția opusă. Aceasta înseamnă că a trebuit să renunțăm la câteva codecuri care nu se încadrează în acest model, de exemplu, rot13, base64 și bz2 (aceste conversii sunt încă acceptate, doar prin API-ul de codare / decodare).

Noua bibliotecă I / O

Biblioteca I / O se modifică și ca răspuns la aceste modificări. Am vrut să o rescriu oricum, pentru a elimina dependența de biblioteca C stdio. Noua distincție între octeți și șiruri de text a necesitat o modificare (subtilă) a API, iar cele două proiecte au fost realizate mână în mână. În noua bibliotecă există o distincție clară între fluxurile binare (deschise cu un mod ca "rb" sau "wb") și fluxurile de text (deschise cu un mod care nu conține "b"). Fluxurile de text au un atribut nou, codificarea, care poate fi setată explicit când fluxul este deschis; dacă nu este specificată nicio codificare, este utilizată o implicită specifică sistemului (care ar putea folosi ghicitul atunci când se deschide un fișier existent).
Operațiile de citire a fluxurilor binare returnează arhivele de octeți, în timp ce operațiile de citire a fluxurilor de text returnează (Unicode) șirurile de text; și similare pentru operațiile de scriere. Scrierea unui șir de text într-un flux binar sau într-un tablou de octeți într-un flux de text va ridica o excepție.
În caz contrar, API-ul este păstrat destul de compatibil. În timp ce există încă o funcție deschisă () încorporată, definiția completă a noii biblioteci I / O este disponibilă din noul modul io . Acest modul conține, de asemenea, clase de bază abstracte (vezi mai jos) pentru diferitele tipuri de fluxuri, o nouă implementare a StringIO și o nouă clasă similară BytesIO, care este asemănătoare cu StringIO, dar implementează un flux binar, deci citirea și scrierea arhivelor bytes.

Imprimarea și formatarea

Două alte caracteristici legate de I / O: declarația de venerabil de imprimare devine acum o funcție print () , iar operatorul de formatare de șir quirky % va fi înlocuit cu o nouă metodă format () pe obiecte șir.
Transformarea tipăririi într-o funcție face ca unele ochi să se rotească. Cu toate acestea, există mai multe avantaje: este mult mai ușor de cod refactor folosind funcțiile print () pentru a utiliza, de exemplu, pachetul de înregistrare; iar sintaxa de tipărire a fost întotdeauna un pic controversată, cu fișierul său >> și semantica unică pentru o virgulă de la sfârșit. Argumentele pentru cuvinte cheie preiau aceste roluri și totul este bine.
În mod similar, noua metodă format () evită unele dintre capcanele vechiului operator % , în special comportamentul surprinzător al "% s" % x atunci când x este o tuplă și greseala obișnuită de a părăsi accidental ultimul " s 'în % (nume) s . Noile șiruri de format folosesc {0}, {1}, {2}, ... pentru a face referire la argumentele poziționării pentru metoda format () și {a}, {b}, ... pentru a referenția argumentele cuvintelor cheie. Alte caracteristici includ {abc} pentru referințele atributelor și chiar {a [b]} pentru cartografiere sau accesare secvență. Lungimile câmpului pot fi specificate astfel: {a: 8}; această notație sprijină, de asemenea, transmiterea altor opțiuni de formatare.
Metoda format () este extensibilă într-o varietate de dimensiuni: prin definirea unei metode speciale __format __ () , tipurile de date pot înlocui modul în care sunt formatate și modul în care sunt interpretați parametrii de formatare; puteți crea, de asemenea, clase personalizate de formatare, care pot fi utilizate, de exemplu, pentru a furniza automat variabilele locale ca parametri pentru operațiile de formatare.

Modificări ale sistemului de clasă și tip

S-ar putea să fi ghicit că "clasele clasice" mănâncă în sfârșit praful. Obiectul clasa încorporat este clasa de bază implicită pentru clasele noi. Acest lucru face loc pentru o varietate de caracteristici noi.

Clasic decoratori. Acestea funcționează la fel ca decoratorii de funcții:

@art_deco
clasa C:
    ...

Semnăturile de funcții și metode pot fi acum "adnotate". Limba de bază nu atribuie niciun sens acestor adnotări (altele decât punerea la dispoziție pentru introspecție), dar unele module standard de bibliotecă pot face acest lucru; de exemplu, funcțiile generice (vedeți mai jos) pot folosi aceste funcții. Sintaxa este ușor de citit:

def foobar (a: Integer, b: Secvență) -> String:
    ...

Sintaxă de metaclaz nouă. În loc să setați o variabilă __metaclass__ în corpul unei clase, acum trebuie să specificați metaclase folosind un parametru de cuvânt cheie în poziția de clasă, de exemplu:

clasa C (baze, metaclass = MyMeta):
    ...

Dicționare clasa personalizată. dacă metaclasa definește o metodă __prepare __ () , va fi apelată înainte de a intra în corpul clasei și orice va reveni va fi folosit în locul unui dicționar standard ca spațiu de nume în care este executat corpul clasei. Acest lucru poate fi folosit, printre altele, pentru a implementa un tip "struct" unde ordinea în care elementele sunt definite este semnificativă.

Puteți specifica bazele în mod dinamic, de exemplu:

baze = (B1, B2)

clasa C (* baze):
    ...

Alți parametri de cuvinte cheie sunt, de asemenea, permise în poziția de clasă; acestea sunt transmise metodei " __new__ metaclass" .

Aveți posibilitatea să înlocuiți testele isinstance () și issubclass () , definind metode de clasă numite __instancecheck __ () sau __subclasscheck __ () , respectiv. Atunci când acestea sunt definite, instanța (x, C) este echivalentă cu C .__ instancecheck __ (x) și issubclass (D, C) cu C .__ subclasscheck __ (D) .

Clasele de bază abstracte de bază (ABC). Dacă doriți să definiți o clasă ale cărei instanțe se comportă ca o cartografiere (de exemplu), puteți moșteni în mod voluntar din clasa abc.Mapping . Pe de o parte, această clasă oferă un comportament util mix-in, înlocuind majoritatea funcționalității vechilor UserDict și DictMixin clase. Pe de altă parte, utilizarea sistematică a unor astfel de ABC-uri poate ajuta cadrele mari să facă ceea ce este mai bine cu mai puține presupuneri: în Python 2, nu este întotdeauna ușor de spus dacă un obiect ar trebui să fie o secvență sau o mapare atunci când definește un __getitem __ )metodă. Următoarele standarde ABC sunt furnizate: Hashable, Iterable, Iterator, Sized, Container, Callable; Set, MutableSet; Mapping, MutableMapping; Sequence, MutableSequence; Număr, Complex, Real, Rational, Integer. IO Modulul definește , de asemenea , un număr de ABC - ul, astfel încât , pentru prima dată în istoria Python vom avea un caiet de sarcini pentru nebulos anterior conceptul de fișier asemănător . Puterea cadrului ABC constă în capacitatea (împrumutate de la interfețele Zope) de a "înregistra" o clasă concretă X ca fiind "moștenirea virtuală" a unui ABC Y, unde X și Y sunt scrise de diferiți autori și apar în pachete diferite. (Pentru a clarifica, atunci când se folosește mostenirea virtuală, comportamentul mix-in al clasei Y nu este disponibil pentru clasa X. Singurul efect este acela că este subclasa (X, Y) va reveni la True.)

Pentru a susține definiția ABC care impune ca clasele concrete să pună în practică interfața completă, decoratorul @ abc.abstractmethod poate fi folosit pentru a declara metode abstracte (numai în clase ale căror metaclase este sau derivă din abc.ABCMeta ).

Funcții generice. Includerea acestei caracteristici, descrisă în documentul PEP 3124, este oarecum incertă, deoarece activitatea pe PEP pare să fi încetinit până la stagnare. Sperăm că ritmul va reveni din nou. Acesta acceptă expedierea funcției bazată pe tipul tuturor argumentelor, mai degrabă decât expedierea mai convențională bazată numai pe clasa obiectului țintă ( auto ).

Alte schimbări semnificative

Doar evidențiază.

Reforma excepțiilor

Excepțiile de șir au dispărut (desigur).

Toate excepțiile trebuie să decurgă din BaseException și de preferință de la excepție .

Vom scăpa de StandardError .

Excepțiile nu mai acționează ca secvențe. În schimb, au un atribut args care este secvența de argumente transmise constructorului.

Cu excepția E, e: sintaxa se schimbă cu excepția E ca e ; acest lucru evită confuzia ocazionale cu excepția E1, E2: .

Variabila numit după cum în afară de clauza se elimină cu forța la ieșirea din afară clauza.

sys.exc_info () devine redundant (sau poate să dispară): în schimb, e .__ class__ este tipul de excepție și e .__ traceback__ este trasarea.

Atribute opționale suplimentare __context__ este setat la excepția „anterioară“ , atunci când are loc o excepție în afară sau în cele din urmă clauză; __cause__ poate fi setat în mod explicit atunci când re-ridicarea unei excepții, folosind creșterea E1 de la E2 .

Vechile ridica variante de sintaxă ridica E, e și ridica E, e, tb au dispărut.

Întregul proces de reformare

Va exista un singur tip integrat intreg, numit 'int', al carui comportament este cel al lui 'long' in Python 2. Sufixul literal 'L' dispare.

1/2 va returna 0,5 , nu 0 . (Folosiți 1 // 2 pentru asta.)

Sintaxa literală octală se modifică la 0o777 , pentru a evita confundarea dezvoltatorilor tineri.

Binare literale: 0b101 == 5 , bin (5) == '0b101' .

Iteratori sau Iterables în loc de Liste

seturile dict.keys () și dict.items () retur (vizualizări, într-adevăr); dict.values () returnează o vizualizare de container iterabilă. Iter * () variantele dispar.

range () returnează tipul de obiect pe care xrange () îl folosește pentru a reveni; xrange () dispare.

zip () , map () , filtru () returnează iterables (ca și omologii lor din itertools deja fac).

Diverse

Ordonarea comparațiilor ( < , <= , > , > = ) va ridica Tipul de eroare în mod implicit, în loc să returneze rezultate arbitrare. Comparațiile egalitate implicite ( == , ! = , Pentru clase care nu suprascrie __eq__ ) compara identitatea de obiect ( este , este nu ). (Acesta din urmă este neschimbat față de 2.x, comparațiile dintre tipurile compatibile, în general, nu se schimbă, numai comanda implicită bazată pe adresa de memorie este eliminată, deoarece a cauzat rezultate ireproductibile.)

Instrucțiunea nelocală vă permite să atribuiți variabilelor în domenii exterioare (non-globale).

Noul apel super () : Apelarea super () fără argumente este echivalentă cu super (<this_class>, <first_arg>) . Se rădăcește în interiorul cadrului stivă pentru a obține clasa dintr-o celulă specială numită __class__ (pe care o puteți folosi și direct) și pentru a obține primul argument. __class__ se bazează pe includerea statică și textuală a metodei; este completat după ce metaclașul a creat obiectul de clasă (dar înainte de a se executa decoratorii de clasă). super () lucrează atât în metodele obișnuite, cât și în metodele de clasă.

Setați literalii: {1, 2, 3} și chiar setați înțelegeri: {x pentru x în y dacă P (x)} . Rețineți că setul gol este setat () , deoarece {} este un dict gol!

reduce () a dispărut (într-adevăr, a fost mutat în functools). Acest lucru nu înseamnă că nu-mi plac funcțiile de ordin superior; reflectă pur și simplu faptul că aproape tot codul care folosește reduce () devine mai ușor de citit când se rescrie folosind o buclă veche obișnuită. ( Exemplu .)

lambda , totuși, trăiește.

Sintaxa backtick-ului, de multe ori greu de citit, a dispărut (utilizați repr () ), la fel este operatorul <> (folosiți ! = ; Era prea flagrant o încălcare a TOOWTDI ).

La nivelul C, va exista un API tampon nou, mult îmbunătățit, care va oferi o mai bună integrare cu numaba. (PEP 3118)

Reforma bibliotecii

Nu vreau să spun prea multe despre modificările aduse bibliotecii standard, deoarece acesta este un proiect care va începe să funcționeze real după lansarea versiunii 3.0a1 și nu o voi supraveghea personal (limba centrală este tot Mă descurc). Este clar deja că eliminăm o mulțime de crustă neacceptată sau pur și simplu depășită (de exemplu, multe module aplicabile numai în cadrul SGI IRIX) și încercăm să redenumim modulele cu nume CapWords, cum ar fi StringIOsau UserDict , pentru a se conforma cu PEP 8 nume de standard pentru numele modulelor (care necesită un cuvânt cu litere mici).

Și, în sfârșit

Am menționat că viața lambda ? Mai primesc cererea ocazională să o păstrez, așa că m-am gândit să o menționez de două ori. Nu vă faceți griji, cererea a fost acordată de peste un an.

Vorbire Angajamente

Voi prezenta (sau am prezentat) acest material personal la mai multe evenimente:

Google Phoenix, biroul AZ, 21 iunie

Tabăra O'Reilly foo, 23 iunie, Sebastopol, CA (primeste-ma beat :-) http://foocamp.crowdvine.com

CWI, Amsterdam, 5 iulie, ora 15:00 (locul de naștere al lui Python!) Http://www.cwi.nl

EuroPython, Vilnius, Lituania, 10 iulie (nota principală) http://www.europython.org/sections/tracks_and_talks/draft-timetable

OSCON, Portland, OR, 26 iulie, 14:35 (pistă Python) http://conferences.oreillynet.com/cs/os2007/view/e_sess/12753

Diapozitivele de la OSCON sunt sus: http://conferences.oreillynet.com/presentations/os2007/os_vanrossum.ppt (versiunile anterioare au fost aproape identice).

Răspunde!

Au o părere? Cititorii au postat deja 47 de comentarii despre această intrare în blog. De ce să nu adăugați a ta ?

RSS Feed

Dacă doriți să fiți anunțat ori de câte ori Guido van van Rossum adaugă o nouă intrare la blogul său , să vă abonați la feedul său RSS .

http://www.artima.com/weblogs/viewpost.jsp?thread=208549

Download the latest source release Python 3.6.4

OpenPGP Keys Public

Sursă și executabile binare sunt semnate de managerul de lansare folosind cheia OpenPGP. Managerii de lansare și constructorii binare de la Python 2.3 au fost:

Anthony Baxter (ID-ul cheii: 6A45C816 )
Georg Brandl (ID-ul cheii: 36580288 )
Ned Deily (ID-uri cheie: AA65421D , 6F5E1540 și Apple Developer ID DJ3H93M7VJ )
Steve Dower (ID-ul cheii: 487034E5 )
Larry Hastings (ID-ul cheii: F73C700D )
Martin v. Löwis (cheia id: 7D9DC8D2 )
Ronald Oussoren (ID-ul cheii: E6DF025C)
Benjamin Peterson (ID cheie: 18ADD4FF și A4135B38 )
Barry Varșovia (ID-uri cheie: A74B06BF, EA5BBD71 și ED9D77D5 )

Notă: ID-ul cheie al lui Barry A74B06BF este folosit pentru a semna versiunile Python 2.6.8 și 2.6.9. ID-ul său cheie EA5BBD71 a fost folosit pentru a semna toate celelalte versiuni Python 2.6 și 3.0. ID-ul său cheie ED9D77D5 este o cheie v3 și a fost folosit pentru a semna versiuni mai vechi; deoarece este o cheie veche MD5 și respinsă de implementări mai recente, ED9D77D5 nu mai este inclusă în fișierul cheie public.

Puteți importa cheile publice ale managerului de lansare fie prin descărcarea fișierului de chei publice de aici , fie apoi prin difuzarea acestuia

gpg --import pubkeys.txt

sau prin prinderea cheilor individuale direct din rețeaua keyserver executând această comandă:

gpg --recv-keys 6A45C816 36580288 7D9DC8D2 18ADD4FF A4135B38 A74B06BF EA5BBD71 E6DF025C AA65421D 6F5E1540 F73C700D 487034E5

Pe paginile de descărcare specifice versiunii, ar trebui să vedeți un link atât la fișierul descărcabil, cât și la un fișier de semnătură detașat. Pentru a verifica autenticitatea descărcării, apucați ambele fișiere și apoi executați această comandă:

gpg --verify Python-3.6.2.tgz.asc

Rețineți că trebuie să utilizați numele fișierului de semnătură și trebuie să utilizați unul corespunzător descărcării pe care o verificați.

(Aceste instrucțiuni sunt orientate către utilizatorii de linii de comandă GnuPG și Unix. Sunt binevenite contribuțiile instrucțiunilor pentru alte platforme și aplicații OpenPGP).

Alte elemente utile

Căutați modulele Python de la terțe părți ? Index Pachetul are multe dintre ele.
Puteți vizualiza documentația standard pe internet sau o puteți descărca în format HTML, PostScript, PDF și alte formate. Vedeți pagina principală de documentare .
Informații despre instrumentele pentru dezarhivarea fișierelor de arhivă furnizate pe portalul python.org sunt disponibile.
Sfat : chiar dacă descărcați un binar gata pentru platforma dvs., este logic să descărcați și sursa . Aceasta vă permite să parcurgeți biblioteca standard (subdirectorul Lib ) și colecțiile standard de demonstrații ( Demo ) și de instrumente ( Instrumente ) care vin împreună cu acestea. Există multe lucruri pe care le puteți învăța de la sursă!
Există, de asemenea, o colecție de pachete Emacs pe care Pythoneer-ul Emacsing ar putea fi utile. Acestea includ moduri majore de editare a interfețelor de depanare Python, C, C ++, Java, etc., etc. Cele mai multe pachete sunt compatibile cu Emacs și XEmacs.

Doriți să contribuiți?

Doriți să contribuiți? Consultați Ghidul dezvoltatorului Python pentru a afla cum este gestionată dezvoltarea Python. Sursa : https://www.python.org/downloads/

Ce este python?

Python este un limbaj de programare interpretat. Pentru cei care nu stiu, un limbaj de programare este ceea ce scrii pentru a-i spune unui calculator ce are de facut. Oricum, computerul nu citeste limbajul in mod direct - exista sute de limbaje de programare si nu ar putea sa le inteleaga pe toate. Deci, cand cineva scrie un program, il va scrie in limbajul selectat si apoi il va compila - aceasta inseamna transformarea intr-o multime de 0 si de 1, pe care computerul le poate intelege rapid si usor. Diversele programele pe care le poti cumpara pentru calculatorul tau sunt deja compilate pentru Windows - daca incerci sa deschizi un astfel de program cu Notepad sau Wordpad, vei vedea doar o multime de caractere ciudate.

Un program care este compilat pentru Windows nu va functiona pe un alt sistem de operare. Diferenta dintre Python si astfel de programe este ca acest limbaj nu este niciodata compilat in totalitate - la rulare, fiecare instructiune este transformata in serii de 0 si 1 pe care computerul tau le poate intelege. In plus, totul este facut pe loc - codul este executat pe masura ce rulezi programul. Daca ai iesi din program si ai reveni in alta zi, bitii ar fi din nou compilati. Ti se pare a fi pierdere de timp? Poate, dar asta inseamna ca un program Python poate rula pe diferite sisteme de operare, fara a necesita ajustari. Ai putea trimite programul unui prieten, care utilizeaza un alt tip de computer. Sau ai putea posta programul pe Internet, de unde sa fie descarcat de persoane lucrand pe calculatoare diferite. Acesta este miracolul unui limbaj de programare interpretat - este un limbaj pe care orice sistem il poate INTELEGE.

Cum se instaleaza python

Mai intai downloadeaza Python urmand acest link( http://www.python.org/download/).
Pentru acest tutorial a fost utilizata versiunea 2.6.2.
Executa fisierul downloadat si urmeaza comenzile.

OK! Sa speram ca totul a mers bine! Acum, pentru a testa daca functioneaza, tasteaza urmatoarea instructiune in fereastra de comenzi - daca lucrezi pe Windows, cauta Python in Programs, acceseaza Python (command line), apoi ruleaza urmatoarea comanda:

 print "Hello World!"

Incearca, vezi ce se intampla. Pentru a inchide fereastra, tasteaza 'quit()', apoi apasa Enter.

'Programe' foarte simple

Introducere

OK! Am instalat python, si acum? Pai, sa programam!

Si este usor (cel putin pentru moment). Python face sa fie usor de rulat linii singulare de cod - programe mono-liniare. Sa incercam!

Deschidem IDLE

Mergi in meniul de start, gaseste Python si ruleaza programul denumit 'IDLE' (Vine de la Integrated Development Environment - Mediu Integrat de Dezvoltare).

Acum te afli in mediul IDLE. Acesta este locul in care iti vei petrece majoritatea timpului. Aici poti deschide o noua fereastra pentru a scrie un program sau poti pierde vremea cu linii singulare de cod, ceea ce vom si face. Tasteaza urmatoarele si apasa enter:

 >>> print "Hello World!"

Ce s-a intamplat? Tocmai ai creat un program care afiseaza cuvintele 'Hello, World'. Mediul IDLE in care te afli compileaza imediat orice ai tastat. Este extrem de util pentru testare, de exemplu la definirea variabilelor, sau pentru a verifica daca o anumita linie de cod functioneaza.

Matematica in Python

Cu Python poti efectua anumite operatii matematice, cum ar fi:

- Adunare

 >>> 1 + 1
2
>>> 20+80
100
>>> 18294+449566
467860

-Scadere

>>> 6-5
1

- Inmultire

>>> 2*5
10

- Ridicare la putere

>>> 5**2
25

- Impartire

>>> 21/3
7
>>> 23/3
7
>>> 23.0/3.0
7.6666�

- Restul impartirii

>>> 23%3
2
>>> 49%10
9

In plus, poti afisa sume si variabile printr-un singur apel al functiei print, utilizand virgula pentru a separa diferitele sectiuni:

>>> print "un kilobyte este 2^10 bytes, sau", 2**10, "bytes"
un kilobyte este 2^10 bytes, sau 1024 bytes

ALTE TUTORIALE PYTHON:

Era intr-adevar o confuzie in tutorial referitor la comanda "python -V". Aceasta presupune ca python este pornit din Command Prompt (Start > Run, apoi tasteaza cmd) , care nu este acelasi lucru cu "Python (command line)". Pentru ca Windows-ul sa recunoasca instructiunea "python" trebuie ca variabila Path sa fie setata din Control Panel > System. In scurt timp vom adauga un tutorial despre cum trebuie setata aceasta variabila. In legatura cu eroarea de sintaxa, banuiesc ca tu ai instalat Python 3.1, in timp ce exemplele din acest tutorial au fost testate pe Python 2.6.2. Am corectat si am adaugat cateva lamuriri suplimentare in tutorial, care speram sa-ti fie de folos.

Sursa : http://www.e-learn.ro/tutorial/python/introducere-in-python-partea-i/149/1/367.htm

PITON IN LINUX
Pentru a rula un script din linia de comandă, tastați: python my_script.py. Pentru a ieși din linia de comandă, tastați exit () sau apăsați ctrl + d
puteți încerca IDLE. Deschideți o fereastră terminal și tastați: 'inactiv'. (fără ghilimele). Veți vedea shell-ul grafic python încărcat.
puteți încerca IDLE. Deschideți o fereastră terminal și tastați: 'inactiv'. (fără ghilimele). Veți vedea shell-ul grafic python încărcat.
Pentru a scrie un script Python, faceți clic pe Fișier> Fereastră nouă. Aceasta va deschide un fel de editor de tip Notepad. Introduceți codul următor:
# linuxversion.py
# Aveți versiunea de intrare a utilizatorului și răspunsul la imprimare
name = raw_input ("Ce versiune de Linux folosiți?")
print "Îmi place de asemenea", nume, "- Reguli Linux!" Salvați fișierul, cu o extensie .py, apoi faceți clic pe Run> Run Module din meniu pentru a rula programul.

Acum că aveți Python în funcțiune, veți dori, fără îndoială, să treceți la programe mai puțin complexe. Una dintre cele mai bune resurse este principalul site Python . Iată câteva recomandări suplimentare:
Tutorialul Python
Ghidul începătorului pentru Python Wiki
Prezentare ecran
Sunteți gata să vă testați abilitățile în Python? Vedeți cum s-au supusacestei evaluări de la Smarterer . Începeți acest test Python acum.

https://www.pluralsight.com/blog/software-development/introduction-to-python-programming-in-ubuntu-linux

Programarea Python pentru începători

Dacă doriți să depășiți Inchiziția spaniolă, învățați Python. Acest articol este o introducere practică în scrierea de aplicații non-triviale în Python.

În ciuda a ceea ce codul de asamblare și codificatorii C ne-ar putea spune, limbile de nivel înalt își au locul în fiecare cutie de instrumente a programatorului, iar unele dintre ele sunt mult mai mult decât o curiozitate în domeniul informaticii. Din multele limbi de nivel înalt pe care le putem alege de astăzi, Python pare a fi cel mai interesant pentru cei care vor să învețe ceva nou și să facă o muncă reală în același timp. Implementarea ei fără program de orientare obiect și sintaxa sa curată și ușor de înțeles îl fac o limbă care este distractivă de a învăța și de a folosi, ceea ce nu este ceva ce putem spune despre cele mai multe alte limbi.
În acest tutorial veți învăța cum să scrieți aplicații care utilizează opțiunile de linie de comandă, citiți și scrieți pe conducte, accesați variabilele de mediu, gestionați întreruperi, citiți și scrieți fișiere, creați fișiere temporare și scrieți în jurnale de sistem. Cu alte cuvinte, veți găsi rețete pentru scrierea de aplicații reale în loc de vechiul plictisitor Hello, World! chestie.

Noțiuni de bază

Pentru a începe, dacă nu ați instalat interpretul Python pe sistemul dvs., acum este timpul. Pentru a face acest pas mai ușor, instalați ultima distribuție Python utilizând pachete compatibile cu distribuția dvs. Linux. rpm, deb și tgz sunt de asemenea disponibile pe CD-ul dvs. Linux sau on-line. Dacă urmați procedurile de instalare standard, nu trebuie să aveți probleme.
Apoi, citiți excelentul Tutorial Python scris de Guido van Rossum, creatorul limbajului de programare Python. Acest tutorial face parte din documentația oficială Python și îl puteți găsi în catalogul /usr/doc/python-docs-1.5.2 sau /usr/local/doc/python-docs-1.5.2. Acesta poate fi livrat în format LaTeX brut, care trebuie prelucrat mai întâi; dacă nu știți cum să faceți acest lucru, accesați http://www.python.org/doc/ pentru al descărca într-un format alternativ.
De asemenea, vă recomandăm să aveți instrucțiunea Bibliotecii Python la îndemână; ați putea dori atunci când explicațiile date aici nu corespund nevoilor dumneavoastră. O puteți găsi în aceleași locuri ca și Tutorialul Python .
Crearea de scripturi se poate face folosind editorul de text preferat atâta timp cât salvează textul în format ASCII simplu și nu introduce automat pauze de linie atunci când linia este mai lungă decât lățimea ferestrei editorului.
Începeți întotdeauna scenariile dvs. cu oricare dintre ele

#! / Usr / local / bin / python

#! / Usr / bin / python

Dacă calea de acces la sistemul binar python din sistemul dvs. este diferită, modificați acea linie, lăsând primele două caractere ( #! ) Intacte. Asigurați-vă că această linie este cu adevărat prima linie din scenariul dvs., nu doar prima linie ne-goală - vă va salva o mulțime de frustrare.
Utilizați chmod pentru a seta permisiunile fișierelor pe scriptul dvs. pentru a deveni executabil. Dacă scriptul este pentru tine singur, tastați chmod 0700 scriptfilename .py ; dacă doriți să îl partajați cu alții din grupul dvs., dar nu lăsați-l să-l editeze, utilizați 0750 ca valoare chmod; dacă doriți să acordați acces tuturor celorlalți, utilizați valoarea 0755 . Pentru ajutor cu comanda chmod, tastați chmod om .

Citirea opțiunilor și a argumentelor liniei de comandă

Opțiunile și argumentele din linia de comandă vin la îndemână când vrem să le spunem script-urilor noastre cum să se comporte sau să treacă la ele anumite argumente (nume de fișiere, nume de directoare, nume de utilizatori etc.). Toate programele pot citi aceste opțiuni și argumente dacă doresc, iar scripturile dvs. Python nu diferă.
Implementarea handler-ilor adecvați se reduce la citirea listei argv și verificarea opțiunilor și argumentelor pe care doriți să le recunoască scriptul. Există câteva moduri de a face acest lucru. Listarea 1 este o opțiune de tratare a opțiunilor simple, care recunoaște opțiunile comune -h, -help și -help, iar când acestea sunt găsite, aceasta se termină imediat după afișarea mesajului de ajutor.
Listarea 1
Copiați și salvați acest script ca help.py, faceți-l executabil cu comanda help.py chmod 0755 și executați-l de mai multe ori, specificând diferite opțiuni, ambele recunoscute de manipulator și nu; de exemplu, cu una dintre opțiuni, veți vedea acest mesaj: ./help.py -h sau ./help.py -o . Dacă managerul de opțiuni recunoaște una dintre opțiuni, veți vedea acest mesaj:

help.py-nu face nimic util (încă)
opțiuni: -h, -help sau -help-afișează acest ajutor
Drepturi de autor (c) Jacek Artymiak, 2000

Dacă invocați help.py cu o opțiune pe care nu o recunoaște sau fără nicio opțiune, acesta va afișa mesajul "Nu recunosc această opțiune".
Rețineți că trebuie să importem modulul sys înainte de a putea verifica conținutul listei argv și înainte de a putea apela funcția de ieșire . Instrucțiunea sys.exit este o caracteristică de siguranță care împiedică executarea ulterioară a programului atunci când una dintre opțiunile de ajutor este găsită în interiorul listei argv . Acest lucru asigură că utilizatorii nu fac ceva periculos înainte de a citi mesajele de ajutor (pentru care nu ar avea nevoie altfel).
Modulul simplu de manipulare a opțiunilor de ajutor descris mai sus funcționează destul de bine și puteți să îl duplicați și să îl modificați pentru a recunoaște opțiunile suplimentare, dar aceasta nu este cea mai eficientă modalitate de a recunoaște mai multe opțiuni cu sau fără argumente. Modul "potrivit" de a face acest lucru este de a folosi modulul getopt , care convertește opțiunile și argumentele într-o listă drăguță de tupluri. Lista 2 arată cum funcționează.
Listing 2
Copiați acest script, salvați-l ca options.py și faceți-l executabil. După cum puteți vedea, utilizează două module: sys și getopt care sunt importate chiar la început. Apoi definim o funcție simplă care afișează mesajul de ajutor atunci când ceva nu merge bine.
Procesarea efectivă a argumentelor liniei de comandă începe cu instrucțiunea try , unde testează lista opțiunilor și argumentelor din linia de comandă (sys.argv) pentru erorile definite ca opțiuni necunoscute sau argumente lipsă; în cazul în care sunt detectate, script - ul va afișa un mesaj de eroare și de ieșire imediat ( a se vedea în afara cazului de grup declarație). Atunci când nu s-au detectat erori, scriptul nostru împarte lista opțiunilor și argumentele lor în tuple din lista de opțiuni și începe să le parseze executând o serie de bucle, fiecare căutând o opțiune și argumentele așteptate.
Funcția getopt.getopt generează două liste în scriptul nostru de mostre: opțiuni care conțin opțiuni și argumentele acestora; și xargumente care conțin argumente care nu sunt legate de niciuna dintre opțiuni. Putem ignora în siguranță în cele mai multe cazuri.
Pentru a recunoaște opțiunile scurte (cu o singură literă precum -h ) și long (cu cele prefixate cu - ), getopt.getopt utilizează două argumente separate. Lista opțiunilor scurte conține toate listate într-un singur șir, de exemplu, getopt.getopt (sys.argv, 'ahoinmdwq') . Este posibil să specificăm în șirul respectiv opțiunile care necesită absolut un argument pentru a le urma imediat (de exemplu, -v nume fișier ) sau după un spațiu (de exemplu, -v nume de fișier). Acest lucru se face prin inserarea două puncte ( : ) dupa optiunea, ca aceasta: getopt.getopt (sys.argv, „ahoiv: emwn“). Cu toate acestea, aceasta creează o problemă proastă care poate provoca o anumită confuzie și pierde în mod inutil timpul; dacă utilizatorul uită să specifice argumentul pentru opțiunea care o cere, opțiunea care urmează îl devine argument. Luați în considerare acest exemplu:

script.py -v -h

Dacă ați pus v: în argumentul șirului opțional scurt al funcției getopt.getopt, opțiunea -h va fi tratată ca argumentul opțiunii -v . Aceasta este o problemă și face parsarea listei de opțiuni tuple , argument mult mai dificil. Soluția la această problemă este simplă: nu folosiți colonul, ci verificați cel de-al doilea element al tuplei care conține opțiunea (primul element al tuplei analizate) care necesită un argument. Dacă este gol, raportați o eroare, cum ar fi opțiunea -aopțiunea de manipulare.
Opțiunile lungi prefixate cu - trebuie să fie listate ca un argument separat pentru getopt.getopt, de exemplu, getopt.getopt (sys.argv, 'ah', ['view', 'file =']) . Acestea pot fi întreținute de același manipulant ca opțiunile scurte.
Ce faceți după ce localizați opțiunile oferite de utilizator depinde de dvs. Listarea 2 poate fi utilizată ca șablon pentru scripturile dvs.

Sursa : http://www.linuxjournal.com/article/3946

sâmbătă, 13 ianuarie 2018

Python - Guido van Rossum