vineri, 19 ianuarie 2018

Python , un limbaj accesibil 1

Tutorialul Python 

Python este un limbaj de programare ușor de învățat. Are o structură eficientă de date la nivel înalt și o abordare simplă, dar eficientă, a programării orientate pe obiecte. Sintaxa elegantă și tastarea dinamică a lui Python, împreună cu natura interpretată, o fac o limbă ideală pentru scrierea și dezvoltarea rapidă a aplicațiilor în multe zone pe majoritatea platformelor.
Interpretul Python și biblioteca extensivă standard sunt disponibile gratuit în format sursă sau binar pentru toate platformele importante de pe site-ul web Python, http://www.python.org/ , și pot fi distribuite în mod liber. Același site conține, de asemenea, distribuții și indicatori către multe module, programe și instrumente gratuite Python, precum și documentație suplimentară.
Interpretul Python este ușor de extins cu noi funcții și tipuri de date implementate în C sau C ++ (sau alte limbi care pot fi apelate din C). Python este, de asemenea, potrivit ca limbaj de extensie pentru aplicații personalizabile.
Acest tutorial introduce cititorul în mod informal la conceptele și caracteristicile de bază ale limbajului și sistemului Python. Vă ajută să aveți un interpret Python la îndemână pentru experiența hands-on, dar toate exemplele sunt de sine stătătoare, astfel încât tutorialul poate fi citit și offline.

Pentru o descriere a obiectelor și a modulelor standard, consultați Biblioteca standard Python .Referința de limbă Python oferă o definiție mai formală a limbii. Pentru a scrie extensii în C sau C ++, citiți Extinderea și încorporarea Manualului de referință Python Interpreter și Python / C API . Există, de asemenea, câteva cărți care acoperă în profunzime Python.
Acest tutorial nu încearcă să fie cuprinzător și acoperă fiecare caracteristică sau chiar orice caracteristică frecvent utilizată. În schimb, introduceți multe dintre caracteristicile cele mai notabile ale lui Python și vă va oferi o idee bună despre stilul și aroma limbii. După ce ați citit-o, veți putea citi și scrie module și programe Python și veți fi gata să aflați mai multe despre diferitele module de bibliotecă Python descrise în The Python Standard Library .
Glosarul este merită să fie parcurse.


1. Întâlniți-vă apetitul 

Dacă lucrați mult pe computere, în cele din urmă veți găsi că există o sarcină pe care doriți să o automatizați. De exemplu, puteți să căutați și să înlocuiți un număr mare de fișiere text sau să redenumiți și să rearanjați o grămadă de fișiere foto într-un mod complicat. Poate doriți să scrieți o bază de date particularizată sau o aplicație GUI specializată sau un joc simplu.
Dacă sunteți un dezvoltator profesionist de software, este posibil să trebuiască să lucrați cu mai multe biblioteci C / C ++ / Java, dar găsiți că ciclul de scriere / compilare / testare / recalculare obișnuit este prea lent. Poate că scrieți o suită de testare pentru o astfel de bibliotecă și găsiți scrierea codului de testare o sarcină plictisitoare. Sau poate ați scris un program care ar putea folosi un limbaj de extensie și nu doriți să proiectați și să implementați o limbă cu totul nouă pentru aplicația dvs.
Python este doar limba pentru tine.
Aveți posibilitatea să scrieți un script shell Unix sau fișiere batch Windows pentru unele dintre aceste sarcini, dar scripturile shell sunt cele mai bune la deplasarea în jurul fișierelor și schimbarea datelor de text, care nu sunt potrivite pentru aplicațiile sau jocurile GUI. S-ar putea să scrieți un program C / C ++ / Java, dar poate dura mult timp pentru a obține chiar și un program de prim plan. Python este mai simplu de utilizat, disponibil pe sistemele de operare Windows, Mac OS X și Unix, și vă va ajuta să vă ocupați mai repede.
Python este ușor de folosit, dar este un limbaj de programare real, oferind mult mai multă structură și suport pentru programe mari decât cele oferite de fișierele de tip shell sau de fișierele batch. Pe de altă parte, Python oferă și o verificare a erorilor mult mai mult decât C și, fiind un limbaj foarte înalt , are în componență tipuri de date de nivel înalt, cum ar fi matrice și dictionare flexibile. Datorită tipurilor de date mai generale, Python este aplicabil unui domeniu de probleme mult mai mare decât Awk sau chiar Perl, dar multe lucruri sunt cel puțin la fel de ușor în Python ca și în acele limbi.
Python vă permite să vă împărțiți programul în module care pot fi reutilizate în alte programe Python. Acesta vine cu o mare colecție de module standard pe care le puteți utiliza ca bază a programelor dvs. - sau ca exemple pentru a începe să învățați să programați în Python. Unele dintre aceste module oferă lucruri cum ar fi fișiere I / O, apeluri de sistem, prize și chiar interfețe cu seturi de instrumente de interfață grafică utilizator cum ar fi Tk.
Python este un limbaj interpretat, care vă poate economisi timp considerabil în timpul dezvoltării programului, deoarece nu este necesară compilarea și legarea. Interpretul poate fi folosit interactiv, ceea ce face ușor să experimentați cu caracteristici ale limbii, să scrieți programe de aruncare sau să testați funcțiile în timpul dezvoltării programelor de jos în sus. Este, de asemenea, un calculator de birou la îndemână.
Python permite programelor să fie redactate în mod compact și ușor de citit. Programele scrise în Python sunt de obicei mult mai scurte decât programele C, C ++ sau Java echivalente, din mai multe motive:
  • tipurile de date la nivel înalt vă permit să exprimați operații complexe într-o singură declarație;
  • declarația de grupare se face prin indentare în loc de paranteze începând și terminând;
  • nu sunt necesare declarații variabile sau argumente.
Python este extensibil : dacă știți cum să programați în C, este ușor să adăugați o nouă funcție sau un modul încorporat interpretului, fie pentru a efectua operații critice la viteză maximă, fie pentru a conecta programele Python la biblioteci care pot fi disponibile numai în formă binară (cum ar fi o bibliotecă grafică specifică vânzătorului). Odată ce sunteți cu adevărat cuplat, puteți conecta interpretul Python într-o aplicație scrisă în C și să o utilizați ca extensie sau limbaj de comandă pentru acea aplicație.
Apropo, limba este numită după emisiunea BBC "Monty Python's Circus Flying" și nu are nimic de-a face cu reptilele. Efectuarea de referințe la schițele Monty Python în documentație nu este permisă, este încurajată!
Acum că sunteți entuziasmați de Python, veți dori să o examinați mai detaliat. Deoarece cea mai bună metodă de a învăța o limbă este să o folosești, tutorialul te invită să te joci cu interpretul Python pe măsură ce citești.
În capitolul următor sunt explicate mecanismele de utilizare a interpretului. Aceasta este o informație destul de luminoasă, dar esențială pentru a încerca exemplele prezentate mai târziu.
Restul tutorialului introduce diferite exemple de limbaj și sistem Python prin exemple, începând cu expresii simple, instrucțiuni și tipuri de date, prin funcții și module și atingând în cele din urmă concepte avansate precum excepțiile și clasele definite de utilizator.

2. Folosirea Interpretului Python 

2.1. Invocarea interpretului 


Interpretul Python este de obicei instalat ca /usr/local/bin/python3.3 pe acele mașini în care este disponibil; punerea / usr / local / bin în calea de căutare a shell-ului Unix vă permite să o porniți tastând comanda:
python3.3
la coajă. [1] Deoarece alegerea directorului în care trăiește interpretul este o opțiune de instalare, sunt posibile și alte locuri; consultați-vă cu guru-ul local Python sau cu administratorul de sistem. (De exemplu, / usr / local / python este o locație alternativă populară.)
Pe mașinile Windows, instalarea Python este, de obicei, plasată în C: \ Python33 , deși puteți schimba acest lucru când executați programul de instalare. Pentru a adăuga acest director în calea dvs., puteți introduce următoarea comandă în linia de comandă într-o casetă DOS:
set  path =% path % ; C : \ python33
Tastarea unui caracter de sfârșit de fișier ( Control-D pe Unix, Control-Z pe Windows) la promptul principal determină ieșirea interpretului cu o stare de ieșire zero. Dacă aceasta nu funcționează, puteți ieși din interpret tastând următoarea comandă: quit () .
Funcțiile de editare a traducerilor de obicei nu sunt foarte sofisticate. Pe Unix, oricine a instalat interpretul ar fi permis activarea suportului pentru biblioteca GNU readline, care adaugă funcții de editare interactive și istorie mai elaborate. Poate că verificarea cea mai rapidă pentru a vedea dacă editarea liniei de comandă este acceptată este tastarea Control-P la primul prompt Python pe care îl primiți. În cazul în care emite un beep, aveți editarea liniei de comandă; consultați Anexă Modificarea intrărilor interactive și înlocuirea istoricului pentru introducerea cheilor. Dacă nu se întâmplă nimic sau dacă echivalentul lui ^ P nu este disponibilă editarea liniei de comandă; veți putea utiliza doar spațiul de backspace pentru a elimina caracterele din linia curentă.
Interpretul funcționează într-o oarecare măsură ca shell-ul Unix: când este apelat cu intrare standard conectată la un dispozitiv tty, citește și execută comenzi interactiv; când este apelat cu un argument de nume de fișier sau cu un fișier ca intrare standard, citește și execută un script din acel fișier.
Un al doilea mod de a porni interpretul este comanda python -c [arg] ... , care execută instrucțiunile din comanda , analog cu opțiunea shell -c . Deoarece declarațiile Python conțin adesea spații sau alte caractere care sunt speciale pentru shell, este de obicei recomandat să citezi comandaîn întregime cu ghilimele simple.
Unele module Python sunt, de asemenea, utile ca scripturi. Acestea pot fi invocate folosind modululpython -m [arg] ... , care execută fișierul sursă pentru modul ca și cum l-ați scrise numele complet pe linia de comandă.
Atunci când se utilizează un fișier de script, uneori este util să puteți rula scriptul și apoi să intrați în modul interactiv. Acest lucru se poate face trecând -i înainte de scenariu.

2.1.1. Argumentul de trecere 


Când este cunoscut interpretului, numele script-ului și argumentele suplimentare ulterior sunt transformate într-o listă de șiruri și atribuite variabilei argv în modulul sys . Puteți accesa această listă executând sys import . Lungimea listei este cel puțin una; când nici un script și nici un argument nu sunt date, sys.argv [0] este un șir gol. Când numele script-ului este dat ca '-' (adică input standard), sys.argv [0] este setat la '-' . Când se utilizează comanda -c , sys.argv [0] este setat la "-c" . Când se utilizează modulul -m , sys.argv [0] este setată la numele complet al modulului localizat. Opțiuni găsite după -c comanda sau -m modulul nu sunt consumate de procesare opțiunea interpretului Python, darplecat în sys.argv pentru comanda sau modulul săocupe.

2.1.2. Modul Interactiv 


Când comenzile sunt citite de la un tty, interpretul se spune că este în modul interactiv . În acest mod, se solicită următoarea comandă cu promptul principal , de obicei trei semne mai mari decât cele ( >>>); pentru linii de continuare se solicită cu prompt secundar , implicit trei puncte ( ... ). Interpretul tipărește un mesaj de întâmpinare care precizează numărul versiunii și o notă privind drepturile de autor înainte de a imprima primul prompt:
$ python3.3
Python 3.3 (implicit, 24 septembrie 2012, 09:25:04)
[GCC 4.6.3] pe linux2
Introduceți "ajutor", "drepturi de autor", "credite" sau "licență" pentru mai multe informații.
>>>
Liniile de continuitate sunt necesare atunci când intri într-un construct multi-linie. De exemplu, aruncați o privire la această declarație if :
>>>
>>> the_world_is_flat  =  1 
>>> dacă  the_world_is_flat : 
...     print ( "Aveți grijă să nu cădeți!" ) 
... 
Aveți grijă să nu cădeți!

2.2. Traducătoarea și a mediului său 

2.2.1. Efectuarea erorilor 



Când apare o eroare, interpretul imprimă un mesaj de eroare și o urmă de stivă. În modul interactiv, acesta revine la promptul principal; când intrarea a provenit de la un fișier, acesta iese după o stare de ieșire nonzero după imprimarea urmelor stivei. (Excepții manipulate de o , cu excepția clauză într - o încercare declarație nu sunt erori în acest context.) Unele erori sunt în mod necondiționat fatale și pot provoca o ieșire cu o ieșire nenul; acest lucru se aplică în cazul inconsecvențelor interne și al unor cazuri de epuizare a memoriei. Toate mesajele de eroare sunt scrise în fluxul de eroare standard; ieșirea normală din comenzile executate este scrisă la ieșirea standard.
Tastarea caracterului de întrerupere (de obicei Control-C sau DEL) la solicitarea primară sau secundară anulează intrarea și revine la promptul principal. [2] Tastarea unei întreruperi în timp ce o comandă este executată ridică excepția KeyboardInterrupt , care poate fi tratată printr-o instrucțiune try .

2.2.2. Șabloane de execuție Python 


Pe sistemele Unix BSD, script-urile Python pot fi făcute direct executabile, cum ar fi scripturile shell, prin plasarea liniei
#! / usr / bin / env python3.3
(presupunând că interpretul se află pe ecranul utilizatorului PATH ) la începutul scriptului și oferind fișierului un mod executabil. #! trebuie să fie primele două caractere ale fișierului. Pe unele platforme, această primă linie trebuie să se încheie cu o linie de tip Unix care se termină ( '\ n' ), nucu o linieWindows ( '\ r \ n' ) care se termină. Rețineți că hash, sau literă, caracter, "#" , este folosit pentru a începe un comentariu în Python.
Scriptul poate primi un mod executabil sau permisiune, folosind comanda chmod :
$ chmod + x myscript.py
Pe sistemele Windows, nu există nicio noțiune de "mod executabil". Programul de instalare Python asociază automat fișierele .py cu Python.exe, astfel încât un dublu-clic pe un fișier Python îl va executa ca un script. Extensia poate fi, de asemenea , .pyw , în acest caz, fereastra consolei care apare în mod normal este suprimată.

2.2.3. Codificarea codului sursă 


În mod implicit, fișierele sursă Python sunt tratate ca fiind codificate în UTF-8. În această codificare, caracterele celor mai multe limbi din lume pot fi utilizate simultan în literali de șir, identificatori și comentarii - deși biblioteca standard utilizează numai caractere ASCII pentru identificatori, o convenție pe care trebuie să o urmeze orice cod portabil. Pentru a afișa corect toate aceste caractere, editorul dvs. trebuie să recunoască faptul că fișierul este UTF-8 și trebuie să utilizeze un font care să accepte toate caracterele din fișier.
De asemenea, este posibil să specificați o codificare diferită pentru fișierele sursă. Pentru a face acest lucru, puneți încă o linie de comentariu specială imediat după #! line pentru a defini codificarea fișierului sursă:
# - * - codare: codare - * -
Cu această declarație, totul din fișierul sursă va fi tratat ca având codificarea codării în loc de UTF-8. Lista codificărilor posibile poate fi găsită în Python Library Reference, în secțiunea despre codecuri .
De exemplu, dacă editorul ales nu suportă fișiere codate UTF-8 și insistă să utilizeze alte codări, de exemplu Windows-1252, puteți scrie:
# - * - codare: cp-1252 - * -
și încă utilizați toate caracterele din setul de caractere Windows-1252 din fișierele sursă. Comentariul special de codificare trebuie să fie în prima sau a doua linie din fișier.

2.2.4. Fișierul de pornire interactivă 


Atunci când utilizați Python interactiv, este frecvent util să executați comenzi standard de fiecare dată când este pornit interpretul. Puteți face acest lucru setând o variabilă de mediu numităPYTHONSTARTUPla numele unui fișier care conține comenzile de pornire. Acest lucru este similar cu caracteristica.profile a shell-urilor Unix.
Acest fișier este citit numai în sesiuni interactive, nu când Python citește comenzi dintr-un script, și nu când dev / tty este dat ca sursă explicită de comenzi (care altfel se comportă ca o sesiune interactivă). Se execută în același spațiu de nume în care sunt executate comenzi interactive, astfel încât obiectele pe care le definește sau le importă pot fi utilizate fără o calificare în sesiunea interactivă. De asemenea, puteți modifica instrucțiunile sys.ps1 și sys.ps2 în acest fișier.
Dacă doriți să citiți un fișier de pornire suplimentar din directorul curent, puteți să îl programați în fișierul global de pornire utilizând codul de tipul if os.path.isfile ('. Pythonrc.py'): exec (open (' .pythonrc.py "). citiți ()) . Dacă doriți să utilizați fișierul de pornire într-un script, trebuie să faceți acest lucru explicit în script:
import  os 
filename  =  os . environ . get ( 'PYTHONSTARTUP' ) 
dacă  numele fișierului  și  os . calea . isFile ( numele fișierului ): 
    exec ( deschis ( nume de fișier ) . citește ())

2.2.5. Modulele de personalizare 


Python oferă două cârlige pentru a vă permite să o personalizați: sitecustomize și usercustomize . Pentru a vedea cum funcționează, trebuie mai întâi să găsiți locația directorului pentru pachetele de site-uri pentru utilizatori. Porniți Python și rulați acest cod:
>>>
>>> import  site - ul 
>>> site - ul . getusersitepackages () 
'/home/user/.local/lib/python3.2/site-packages'
Acum puteți crea un fișier numit usercustomize.py în acel director și puneți tot ce doriți în el. Aceasta va afecta fiecare invocare a Python, dacă nu este inițiată cu opțiunea -s pentru a dezactiva importul automat.
sitecustomize funcționează în același mod, dar este, în mod obișnuit, creat de un administrator al calculatorului în directorul global de site-uri cu pachete și este importat înaintea usercustomize . Consultați documentația modulului site pentru mai multe detalii.
Note de subsol
[1]Pe Unix, interpretul Python 3.x nu este instalat implicit cu executabilul numit python , astfel încât să nu fie în conflict cu un executabil Python 2.x instalat simultan.
[2]O problemă cu pachetul GNU Readline poate împiedica acest lucru.

3. O introducere informală în Python 

În exemplele următoare, intrarea și ieșirea se disting prin prezența sau absența instrucțiunilor ( >>> și ... ): pentru a repeta exemplul, trebuie să tastați totul după prompt, când apare promptul; linii care nu încep cu o solicitare sunt emise de interpret. Rețineți că un prompt secundar pe o linie de la sine într-un exemplu înseamnă că trebuie să tastați o linie goală; acest lucru este folosit pentru a încheia o comandă multi-linie.
Multe dintre exemplele din acest manual, chiar și cele introduse la promptul interactiv, includ comentarii. Comentariile din Python încep cu caracterul hash, # și se extind până la sfârșitul liniei fizice. Un comentariu poate apărea la începutul unei linii sau după un spațiu alb sau un cod, dar nu într-un literal șir. Un caracter hash într-un literal șir este doar un caracter hash. Deoarece comentariile sunt de clarificare a codului și nu sunt interpretate de Python, ele pot fi omise atunci când tastați în exemple.
Cateva exemple:
# acesta este primul comentariu 
spam  =  1   # și acesta este al doilea comentariu 
          # ... și acum o treime! 
text  =  "# Acesta nu este un comentariu deoarece este în interiorul citatelor".

3.1. Utilizarea Python ca Calculator 


Să încercăm niște comenzi simple de Python. Porniți interpretul și așteptați solicitarea primară, >>> . (Nu ar trebui să dureze mult.)

3.1.1. Numere 


Interpretul funcționează ca un simplu calculator: puteți tasta o expresie la ea și va scrie valoarea. Sintaxa de expresie este simplă: operatorii + , - , * și / funcționează la fel ca în cele mai multe alte limbi (de exemplu, Pascal sau C); parantezele ( () ) pot fi utilizate pentru grupare. De exemplu:
>>>
>>> 2  +  2 
4 
>>> de 50  - de  5 * 6 
20 
>>> ( de 50  - de  5 * 6 )  /  4 
5.0 
>>> 8  / de  5   # diviziune returnează întotdeauna un punct număr flotant 
1.6
Numerele întregi (de exemplu , 2 , 4 , 20 ) au tipul int , cele cu o parte fracționată (de ex. , 5.0 , 1.6) au tip float . Vom vedea mai multe despre tipurile numerice mai târziu în tutorial.
Diviziunea ( / ) întoarce întotdeauna un flotor. Pentru a face diviziunea podelei și a obține un rezultat întreg (eliminând orice rezultat fracționat), puteți utiliza // operatorul; pentru a calcula restul pe care îl puteți utiliza % :
>>>
>>> 17  /  3   # diviziune clasic returnează un flotor 
5.666666666666667 
>>> 
>>> 17  //  3   # diviziune podea aruncate înapoi partea fracționară 
5 
>>> 17  %  3   # operatorul% returnează restul împărțirii 
2 
>> > 5  *  3  +  2   # rezultatul * divizorul + restul 
17
Cu Python, este posibil să utilizați operatorul ** pentru a calcula puterile [1] :
>>>
>>> 5  **  2   # 5 pătrat 
25 
>>> 2  **  7   # 2 la puterea de 7 
128
Semnul egal ( = ) este folosit pentru a atribui o valoare unei variabile. Ulterior, nu se afișează niciun rezultat înainte de următorul prompt interactiv:
>>>
>>> latime  =  20 
>>> înălțime  =  5  *  9 
>>> lățime  *  înălțime 
900
Dacă o variabilă nu este "definită" (atribuită o valoare), încercarea de ao utiliza vă va da o eroare:
>>>
>>> n   # încercați să accesați o variabilă nedefinită 
Traceback (ultimul apel ultimul): 
  Fișierul "<stdin>" , rândul 1 , în <modul> 
NameError : numele 'n' nu este definit
Există suport complet pentru punctul de plutire; operatorii cu operanzi de tip mixt convertesc operandul intreg la punctul flotant:
>>>
>>> 3  *  3.75  /  1.5 
7.5 
>>> 7.0  /  2 
3.5
În modul interactiv, ultima expresie tipărită este atribuită variabilei _ . Acest lucru înseamnă că, atunci când utilizați Python ca un calculator de birou, este ceva mai ușor să continuați calculele, de exemplu:
>>>
>>> tax  =  12.5  /  100 
>>> preț  =  100.50 
>>> preț  *  taxă 
12.5625 
>>> preț  +  _ 
113.0625 
>>> rotund ( _ ,  2 ) 
113.06
Această variabilă ar trebui tratată ca utilizată doar de citire. Nu îi alocați în mod explicit o valoare - ați crea o variabilă locală independentă cu același nume care maschează variabila încorporată cu comportamentul său magic.
În plus față de int și float , Python acceptă și alte tipuri de numere, cum ar fi Decimal și Fraction . Python are, de asemenea, suport încorporat pentru numere complexe și utilizează sufixul j sau Jpentru a indica partea imaginară (de ex. 3 + 5j ).

3.1.2. Stringuri 


Pe lângă numere, Python poate manipula și șiruri de caractere, care pot fi exprimate în mai multe moduri. Ele pot fi închise în citate simple ( "..." ) sau citate duble ( "..." ) cu același rezultat [2] . \pot fi folosite pentru a scăpa de citate:
>>>
>>> „ouă de spam“   citate # singur 
„ouă de spam“ 
>>> „doesn \“ t „   # utilizare \“ pentru a scăpa de un singur citat ... 
«nu» 
>>> «nu»   #. .. sau utilizați în schimb citate duble 
"nu" 
>>> "" Da ", a spus el. 
- Da, spuse el. 
>>> " \" Da, \ " a spus el." 
- Da, spuse el. 
>>> '"Isn \' t" , a spus ea. " 
- Nu este, spuse ea.
În interpretul interactiv, șirul de ieșire este inclus în ghilimele și caracterele speciale sunt evacuate cu backslash-uri. În timp ce acest lucru ar putea uneori să pară diferit de intrare (citatele de închidere se pot modifica), cele două șiruri sunt echivalente. Șirul este inclus în ghilimele duble în cazul în care șirul conține o singură cotație și nici un ghilimele duble, altfel este inclus în ghilimele simple. Funcția print () produce o ieșire mai lizibilă, prin omiterea cotelor de închidere și prin tipărirea caracterelor evacuate și speciale:
>>>
>>> '"Isn \' t" , a spus ea. " 
- Nu este, spuse ea. 
>>> print ( "Nu este " , a spus ea. ) 
"Nu este," a spus ea. 
>>> s  =  'Prima linie. \ n Al doilea rând. "   # \ n înseamnă noua linie 
>>> s   # fără imprimare (), \ n este inclusă în ieșirea 
"Prima linie. \ nLinița a doua". 
>>> print ( s )   # with print (), \ n produce o nouă linie 
Prima linie. 
A doua linie.
Dacă nu vreți ca caracterele prefabricate de \ să fie interpretate ca caractere speciale, puteți utiliza șiruri brute prin adăugarea unui r înaintea primei citate:
>>>
>>> print ( 'C: \ some \ n ame' )   # aici \ n înseamnă newline! 
C: \ some 
ame 
>>> print ( r'C: \ some \ name ' )   # notați r înainte de citatul 
C: \ some \ name
Stratul literal poate cuprinde mai multe linii. O modalitate este folosirea citatelor triple: "" "..." ""sau "'' ... '' ' . Sfârșitul liniilor este inclus automat în șir, dar este posibil să se împiedice acest lucru prin adăugarea unui \ la capătul liniei. Următorul exemplu:
imprimare ( „“ „ \ 
Utilizare: thingy [OPȚIUNI] 
     -h Afișează acest mesaj de folosire a 
     HOST - ului H nume de gazdă pentru a se conecta la 
«»“ )
produce următoarea ieșire (rețineți că noua linie inițială nu este inclusă):
Utilizare: lucru [OPȚIUNI]
     -h Afișați acest mesaj de utilizare
     -H Numele gazdei pentru care se conectează
Șirurile pot fi concatenate (lipite împreună) cu operatorul + și repetate cu * :
>>>
>>> # 3 ori 'un', urmat de 'ium' 
>>> 3  *  'un'  +  'ium' 
'unununium'
Două sau mai multe literali de șir (adică cele cuprinse între citate) unul lângă celălalt sunt concatenate automat.
>>>
>>> 'Py'  'thon' 
'Python'
Acest lucru funcționează numai cu doi literali, dar nu cu variabile sau expresii:
>>>
>>> prefix  =  'Py' 
>>> prefixul  'thon'   # nu poate concatena o variabila si un sir literal 
  ... 
SyntaxError: sintaxa invalida 
>>> ( 'un'  *  3 )  'ium' 
  ... 
SyntaxError : sintaxa invalida
Dacă doriți să concatenați variabile sau o variabilă și literală, folosiți + :
>>>
>>> prefix  +  'thon' 
'Python'
Această caracteristică este utilă în special atunci când doriți să rupeți șiruri lungi:
>>>
>>> text  =  ( 'Puneți mai multe șiruri în paranteze' 
            ') 
>>> text 
' Puneți mai multe șiruri în paranteze pentru a le uni.
Șirul poate fi indexat (abonat), primul caracter având index 0. Nu există un tip de caractere separat; un personaj este pur și simplu un șir de mărimea unu:
>>>
>>> cuvânt  =  'Python' 
>>> cuvânt [ 0 ]   # caracter în poziția 0 
'P' 
>>> cuvânt [ 5 ]   # caracter în poziția 5 
'n'
Indicii pot fi și numere negative, pentru a începe numărarea din dreapta:
>>>
>>> cuvânt [ - 1 ]   # ultimul caracter 
'n' 
>>> cuvânt [ - 2 ]   # a doua ultimul caracter 
'o' 
>>> cuvânt [ - 6 ] 
'P'
Rețineți că din moment ce -0 este același ca 0, indicii negativi încep de la -1.
În plus față de indexare, este suportat și felierea . În timp ce indexarea este folosită pentru a obține caractere individuale, felierea vă permite să obțineți subrețele:
>>>
>>> cuvânt [ 0 : 2 ]   # caractere din poziția 0 (inclus) la 2 (exclus) 
'Py' 
>>> cuvânt [ 2 : 5 ]   # caractere din poziția 2 (inclus) la 5 (exclus) 
'Tho'
Rețineți cum este inclus întotdeauna începutul, iar sfârșitul este întotdeauna exclus. Acest lucru face ca s [: i] + s [i:] să fie întotdeauna egal cu s :
>>>
>>> cuvânt [: 2 ]  +  cuvânt [ 2 :] 
'Python' 
>>> cuvânt [: 4 ]  +  cuvânt [ 4 :] 
'Python'
Indicii de segmentare au valori implicite utile; un indice primul omis este implicit zero, un indice al doilea omis este implicit la dimensiunea șirului care este tăiat.
>>>
>>> cuvânt [: 2 ]   # de caractere de la început până la poziția 2 (exclus) 
'Py' 
>>> cuvânt [ 4 :]   # caractere de la poziția 4 (inclus) la sfârșitul anului 
'pe' 
>>> cuvânt [ - 2 :]  # caractere de la al doilea - ultimul (inclus) până la capătul 
"pe"
O modalitate de a ne aminti cum funcționează felii este să ne gândim la indicii ca fiind indicatori întrecaractere, cu marginea din stânga a primului caracter numerotat 0. Apoi marginea dreaptă a ultimului caracter al unui șir de caractere n are indicele n , de exemplu:
 + --- + --- + --- + --- + --- + --- + 
 |  P  |  y  |  t  |  h  |  o  |  n  | 
 + --- + --- + --- + --- + --- + --- + 
 0    1    2    3    4    5    6 
- 6   - 5   - 4   - 3   - 2   - 1
Primul rând de numere dă poziția indicilor 0 ... 6 în șir; al doilea rând dă indicii negativi corespunzători. Felia de la i la j constă din toate caracterele dintre marginile etichetate i și respectiv j .
Pentru indicii non-negativi, lungimea unei felii este diferența dintre indicii, dacă ambele sunt în limite. De exemplu, lungimea cuvântului [1: 3] este 2.
Încercarea de a utiliza un index care este prea mare va duce la o eroare:
>>>
>>> cuvânt [ 42 ]   # cuvântul are doar 7 caractere 
Traceback (cel mai recent apel ultimul): 
  Fișierul "<stdin>" , rândul 1 , în <modul> 
IndexError : indicele șir din interval
Cu toate acestea, indicele de raportare din rază de acțiune este tratat grațios atunci când este utilizat pentru tăierea:
>>>
>>> cuvânt [ 4 : 42 ] 
'pe' 
>>> cuvânt [ 42 :] 
''
Comenzile Python nu pot fi schimbate - ele sunt imuabile . Prin urmare, atribuirea unei poziții indexate în șir rezultă dintr-o eroare:
>>>
>>> word [ 0 ]  =  'J' 
  ... 
TypeError: obiectul 'str' nu suporta atribuirea elementului 
>>> word [ 2 :]  =  'py' 
  ... 
TypeError: misiune
Dacă aveți nevoie de un șir diferit, ar trebui să creați unul nou:
>>>
>>> 'J'  +  cuvânt [ 1 :] 
'Jython' 
>>> cuvânt [: 2 ]  +  'py 
'
Funcția încorporată len () returnează lungimea unui șir:
>>>
>>> s  =  'supercalifragilisticexpialidocious' 
>>> len ( s ) 
34
Vezi si
Tipul secvenței de text - p
Șirurile sunt exemple de tipuri de secvențe și sprijină operațiile comune susținute de astfel de tipuri.
Metode de șir
Șirurile suportă un număr mare de metode pentru transformări și căutări de bază.
String Formatare
Informații despre formatarea șirului cu str.format () sunt descrise aici.
printf-stil de formatare de caractere
Vechile operații de formatare invocate atunci când șiruri de caractere și șiruri de caractere Unicode sunt operandul stâng al operatorului % sunt descrise mai detaliat aici.

3.1.3. Liste 


Python cunoaște un număr de tipuri de date compuse , utilizate pentru a grupa alte valori. Cea mai versatilă este lista care poate fi scrisă ca o listă de valori (elemente) separate între virgulă între paranteze pătrate. Listele ar putea conține elemente de diferite tipuri, dar, de obicei, toate elementele au același tip.
>>>
>>> pătrate  =  [ 1 ,  4 ,  9 ,  16 ,  25 ] 
>>> pătrate 
[1, 4, 9, 16, 25]
Ca șiruri de caractere (și toate celelalte tipuri de secvențe încorporate ), listele pot fi indexate și tăiate:
>>>
>>> pătrate [ 0 ]   # indexarea returnează elementul 
1 
>>> pătrate [ - 1 ] 
25 
>>> pătrate [ - 3 :]   # slicing returnează o nouă listă 
[9, 16, 25]
Toate operațiile cu secțiuni returnează o nouă listă care conține elementele solicitate. Aceasta înseamnă că următoarea secțiune returnează o nouă copie (superficială) a listei:
>>>
>>> pătrate [:] 
[1, 4, 9, 16, 25]
Listele acceptă, de asemenea, operații cum ar fi concatenarea:
>>>
>>> pătrate  +  [ 36 ,  49 ,  64 ,  81 ,  100 ] 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Spre deosebire de șiruri de caractere, care sunt imuabile , listele sunt un tip mutable , adică este posibil să se modifice conținutul acestora:
>>>
>>> cuburi  =  [ 1 ,  8 ,  27 ,  65 ,  125 ]   # ceva e greșit aici 
>>> 4  **  3   # cubul de 4 este 64, nu 65! 
64 
>>> cuburi [ 3 ]  =  64   # înlocuiți valoarea greșită 
>>> cuburi 
[1, 8, 27, 64, 125]
Puteți adăuga , de asemenea , elemente noi , la sfârșitul listei, folosind append () metoda (vom vedea mai multe despre metodele de mai târziu):
>>>
>>> cuburi . adăugați ( 216 )   # adăugați cubul de 6 
>>> cuburi . adăugați ( 7  **  3 )   # și cubul de 7 
>>> cuburi 
[1, 8, 27, 64, 125, 216, 343]
De asemenea, este posibilă alocarea în felii, ceea ce poate chiar să modifice dimensiunea listei sau să o elimine complet:
>>>
>>> litere  =  [ 'a' ,  'b' ,  'c' ,  'd' ,  'e' ,  'f' ,  'g' ] 
>>> litere 
[ 'a', 'b', 'c' , 'd', 'e', 'f', 'g'] 
>>> # înlocui unele valori 
>>> litere [ 2 : 5 ]  =  [ 'C' ,  'd' ,  'e' ] 
>>> literele 
['a', 'b', 'C', 'D ',' E ',' f ',' g '] 
>>> # eliminați-le acum 
>>> litere [ 2 :5 ]  =  [] 
>>> litere 
[, 'b' 'o' 'f', 'g'] 
>>> # șterge lista prin înlocuirea tuturor elementelor cu o listă goală 
>>> litere [:]  =  [] 
>>> litere 
[]
Funcția built-in len () se aplică și listelor:
>>>
>>> litere  =  [ 'a' ,  'b' ,  'c' ,  'd' ] 
>>> len ( litere ) 
4
Este posibil să se creeze liste (creați liste care conțin alte liste), de exemplu:
>>>
>>> a  =  [ 'a' ,  'b' ,  'c' ] 
>>> n  =  [ 1 ,  2 ,  3 ] 
>>> x  =  [ a ,  n ] 
>>> x 
[[ 'o', 'b', 'c'], [1, 2, 3]] 
>>> x [ 0 ] 
[, 'b' 'o', 'c'] 
>>> x [ 0 ] [ 1 ] 
'b'

3.2. Primii pași spre programare 


Desigur, putem folosi Python pentru sarcini mai complicate decât adăugarea a două și două împreună. De exemplu, putem scrie o sub-secvență inițială a seriei Fibonacci după cum urmează:
>>>
>>> # Seria Fibonacci: 
... # suma celor două elemente definește următoarea 
... a ,  b  =  0 ,  1 
>>> în timp ce  b  <  10 : 
...     print ( b ) 
...     a ,  b  =  b ,  a + b 
... 
1 
1 
2 
3 
5 
8
Acest exemplu introduce câteva caracteristici noi.
  • Prima linie conține o asignare multiplă : variabilele a și b obțin simultan noile valori 0 și 1. Pe ultima linie se folosește din nou, demonstrând că expresiile din partea dreaptă sunt evaluate înainte de oricare dintre alocările avea loc. Expresiile din partea dreaptă sunt evaluate de la stânga la dreapta.
  • În timp ce bucla execută atâta timp cât condiția (aici: b < 10 ) rămâne adevărată. În Python, ca în C, orice valoare întregă non-zero este adevărată; zero este falsă. Condiția poate fi, de asemenea, o valoare de șir sau de listă, de fapt orice secvență; orice lucru cu o lungime diferită de zero este adevărat, secvențele goale sunt false. Testul utilizat în exemplu este o simplă comparație. Operatorii de comparare standard sunt scrise la fel ca în C: < (mai puțin decât), >(mai mare decât), == (egal cu), <= (mai mic sau egal cu), > = (mai mare sau egal cu) și ! = (nu egal cu).
  • Corpul buclei este indentat : indentare este modul de grupare a declarațiilor lui Python. La solicitarea interactivă, trebuie să introduceți o filă sau spațiu (e) pentru fiecare linie indentată. În practică, veți pregăti o intrare mai complicată pentru Python cu un editor de text; toți editorii de text decent au o facilitate automată. Când o instrucțiune compusă este introdusă interactiv, trebuie să fie urmată de o linie necompletată pentru a indica finalizarea (deoarece parserul nu poate ghici când ați tastat ultima linie). Rețineți că fiecare linie dintr-un bloc de bază trebuie să fie indentată de aceeași sumă.
  • Funcția print () scrie valoarea argumentului (argumentelor) pe care este dat. Acesta diferă de scrierea expresiei pe care doriți să o scrieți (așa cum am făcut-o mai devreme în exemplele de calcul) în modul în care gestionează mai multe argumente, cantități în virgulă mobilă și șiruri de caractere. Șirurile sunt tipărite fără ghilimele și un spațiu este inserat între ele, astfel încât să puteți formata lucrurile frumos, cum ar fi:
    >>>
    >>> i  =  256 * 256 
>>> print ( 'Valoarea i este' ,  i ) 
Valoarea lui i este 65536
    Sfârșitul argumentului pentru cuvinte cheie poate fi folosit pentru a evita linia nouă după ieșire sau pentru a termina ieșirea cu un șir diferit:
    >>>
    >>> a ,  b  =  0 ,  1 
>>> în timp ce  b  <  1000 : 
...     print ( b ,  end = '' ) 
...     a ,  b  =  b ,  a + b 
... 
1,1, 2,3,5,8,13,21,34,55,89,144,233,377,610,987,
Note de subsol
[1]Deoarece ** are precedență mai mare decât - , -3 ** 2 va fi interpretată ca - (3 ** 2) și rezultând astfel în -9 . Pentru a evita acest lucru și a obține 9 , puteți utiliza (-3) ** 2 .
[2]Spre deosebire de alte limbi, caracterele speciale precum \ n au același înțeles atât cu citatesimple ( "..." ), cât și duble ( "..." ). Singura diferență dintre cele două este că în cadrul citatelor unice nu trebuie să scăpați " (dar trebuie să scăpați " ) și invers.


4. Mai multe instrumente de control al fluxului 

Pe lângă timp ce declarația tocmai a introdus, Python cunoaște de obicei declarațiile de control al fluxului cunoscute din alte limbi, cu unele răsturnări de situație.

4.1. dacă Declarațiile 


Probabil cel mai cunoscut tip de declarație este declarația if . De exemplu:
>>>
>>> x  =  int ( input ( "Vă rugăm să introduceți un număr întreg:" )) 
Introduceți un număr întreg: 42 
>>> dacă  x  <  0 : 
...     x  =  0 
...     print ( 'Negativ schimbat la zero' ) 
... elif  x  ==  0 : 
...     print ( 'Zero' ) 
... elif  x  ==  1 : 
...     print ( 'Single' ) 
... alt :
...     print ( Mai mult ) 
... 
Mai mult
Pot exista zero sau mai multe părți elif , iar cealaltă parte este opțională. Cuvântul cheie " elif " este scurt pentru "altceva dacă" și este util pentru a evita indentarea excesivă. O secvență if if ... elif ... elif ... este un înlocuitor al declarațiilor de comutare sau de caz găsite în alte limbi.






Publicat de la Un comentariu:
Etichete: , , , , , , , ,
Abonați-vă la: Postări (Atom)