Python pentru microcontrolere. Învățăm să programăm computere cu o singură placă într-un limbaj de nivel înalt. Interacțiunea cu bordul. Pregătirea de muncă

| -- [ Pagina 1 ] --

Chaplygin A.N.

Învățarea programării cu Python (Începeți cu Python) Revizia: 170 Revizia: 170 Cuprins Cuprins Cuprins........................ ...... .................................................. .................................................. ...... .....2 Prefață................................................ .............................................................. ............................. ................................. ............. 5 Mulțumesc...................................... ............................ ................................ .................................................. ........7 Introducere................................ ................ ........................................ .......... .............................................. .... ............. 8 z0.1. Cunostinte de baza................................................ .................................................. ...... ...................9 z0.2. De unde pot obține un interpret Python?.......................................... ....... ...............................9 z0.3. Instalarea interpretului Python pe UNIX ................................................ ........ ................ s0.3.1. Instalarea/actualizarea Python dintr-un pachet rpm........................................... .......... ............... s0.3.2. Instalarea Python din codul sursă............................................. ....... ........................... s0.4. Instalarea Python pe Windows.................................................. ...... ................................................ s0.5. Rularea programelor scrise în Python............................................. ....... ............................ s0.6. Mediu de dezvoltare................................................ .................................................. ...... .............. Capitolul 1. Concepte de bază................... .......................................................... .............................................. h1.1. Algoritmi și programe.................................................. ............................. ................................. .......................... .. h1.2. Limbaje de programare și niveluri de abstractizare............................................. ...................... ................ h1.3. Limbaje formale și naturale.................................................. ................................................... ..... h1.4. Interpreți și compilatori.................................................. ................. ................................ ........ h1.5. Primul program............................................................. ................................................... ......... ............. h1.6. Ce este depanarea?................................... .................................................. ...... ........................... s1.6.1. Erori de sintaxă............................................................. .................... ........................ h1.6.2. Erori de rulare................................................. ............................. ................................. s1.6.3. Erori semantice ................................................................ .................... ...................... h1.6.4. Procesul de depanare.................................................. ................................................... ......... ....... Capitolul 2. Variabile, operații și expresii....................... .......... ................................. h2.1 . Valori și tipuri............................................................. .......................................................... ................ ................. h2.2. Conversie de tip................................................. .................................................. ...................... ...... h2.3. Variabile.................................................................. ....... ................................................. ............. ........................... h2.4. Nume de variabile și cuvinte cheie............................................. ................................................... .. s2.5. Expresii................................................. ....... ................................................. ............. ........................ h2.6. Executarea expresiilor.............................................................. ................................................... ......... ... з2.7. Operatori și operanzi................................................... ............................. ................................. .......................... ...... z2.8. Ordinea operațiunilor............................................... .... ................................................. .......... ............. h2.9. Cele mai simple operații pe șiruri............................................. ....... ................................. s2.10. Compoziţie................................................. .................................................. ...... .....................Capitolul 3. Funcții................... ............................................................... ..................... ................................ .............. 3.1 . Subrutine.................................................................. ....... ................................................. ............. ................. h3.2. Apeluri de funcții.................................................. ................................................... ......... ............... h3.3. Sistem de referință................................................ ................ ............................................... h3.4 . Importarea modulelor și a funcțiilor matematice............................................. ....... .................... s3.5. Compoziţie................................................. .................................................. ...... ...................... h3.6. Crearea de funcții.................................................. .................................................. ...... ............ h3.7. Parametri și argumente.............................................................. .... ................................................. .......... .... s3.8. Variabile locale.............................................................. ........................................................ .............. .... s3.9. Fluxul de execuție............................................................. ................................................... ......... ............ h3.10. Diagrame de stivă................................................. ........................................................ ............... ...... s3.11. Funcții care returnează rezultate............................................. ..................... ................................ ......Capitolul 4. Grafica computerizată........... .................................. ............................................................. .............. Revizia: 170 Cuprins Capitolul 5. Expresii logice, condiții și recursivitate... .................... .................................... ...... h5.1. Comentarii în programe.................................................. .... ................................................. ..... s5. 2. Expresii booleene simple și tipul de date boolean........................................... ......... h5.3. Operatori logici.............................................................. ................................................... ......... ..... h5.4. Executarea prin condiție și vid................................................ ....... ................................. s5.5. Introducerea datelor de la tastatură............................................. ....... ................................................. ............. h5.6. Ramuri alternative ale programului (condiționale înlănțuite)........................................... ........ ... з5.7. Blocuri goale.............................................................. ................................................... ......... .................... s5.8. Cuibărit declarații condiționale(Condiționale imbricate).............................................. ..... ..... s5.9. Recursiune.................................................. ........................................................ ............................. ............................ s5.10. Diagrame de stivă ale apelurilor recursive............................................. ....................... .................... h5.11. Adâncimea maximă de recursivitate.................................................. ............................. ................................. ...... h5.12. numerele Fibonacci ................................................. ................................................... ......... ............ Capitolul 6. Cicluri.............................. .......................................................... ................ ................................. .......... h6.1. Operator buclă while .................................................. ...................................................... ............ ..... h6.2. Contoare................................................................ ....... ................................................. ............. ................................. h6.3. Bucle nesfârșite.............................................................. ................................................... ......... .......... h6.4. Ramura alternativă a buclei while.................................................. ........ ................................. s6.5. Tabelul de funcții.................................................. .... ................................................. .......... .. h6.6. Personaje speciale și evadate.................................................. .......................................................... ... s6.7. Numerele Fibonacci și operatorul buclei while ................................................ ......... ........................... s6.8. Instrucțiuni de buclă imbricată și tabele bidimensionale........................................... .......... .......... z6.9. Clasificarea operatorilor de buclă.................................................. ............................. ................................. ...... s6.10. Structuri de control................................................. ........................................................ ..........Capitolul 7. Liniile................................... ............................................................... ..................... ................................. h7. 1. Operator de indexare................................................ ... ............................................. з7 . 2. Lungimea șirului și indici negativi................................................ .................................................... h7. 3. Enumerare și buclă pentru ................................................. ............................................................. ........... ............... s7.4. Tăieri de linie................................................. ........................................................ ............................................. s7.5. Comparație de șiruri................................................ ................................................... ......... ................ s7.6. Liniile nu pot fi modificate.................................................. ............................................................. ........... .... з7.7. funcția de căutare................................................ ................................................... ......... .................... s7.8. Bucle și contoare.................................................. ............................. ................................. .......................................... s7.9. Modulul șiruri de caractere.................................................. ......... .................................................. ...... ............................... s7.10. Clasificarea simbolurilor.................................................. .... ................................................. ..... s7. unsprezece. Șiruri Unicode ................................................. ................................................... ......... ................ Capitolul 8. Liste................... .............................................................. ............................. ................................. ................. h8.1. Crearea listelor................................................. ........................................................ .............. .............. h8.2. Accesarea elementelor din listă.................................................. .............................................................. .................... h8.3. Lungimea listei.................................................. ................................................... ......... .................... s8.4. Apartenența la listă.................................................. ............................................................. ........... ... z8.5. Liste și bucla pentru .................................................. ............................................................. ........... ............... s8.6. Operațiuni pe liste.................................................. ............................. ................................. .......................... .... з8.7. Lista felii................................................ ........................................................ .............. ................... s8.8. Schimbarea listelor.................................................. ........................................................ .............. .......... z8.9. Ștergerea elementelor din listă.................................................. ............................. ................................. ..................... s8. 10. Obiecte și valori.............................................................. ........................................................ ............... ......... z8.11. Legături către obiecte.................................................. ........................................................ ............... .......... z8.12. Copierea listelor.................................................. ................................................... ......... ..... Revizia: 170 Cuprins h8.13. Liste de parametri.............................................................. ............................................................. ................... .......... z8.14. Liste imbricate................................................. ........................................................ .............. .......... z8.15. Matrice.................................................................. ....... ................................................. ............. ......................... s8.16. Liste și șiruri de caractere.................................................. ............................. ................................. .......................... ............... Capitolul 9. Tupluri..... .............................................. ................................... .............. ............................. Capitolul 10. Dicționare... .............. .......................................... ........ ................................................ .. ................. h10.1. Crearea unui dicționar.................................................. .... ................................................. .......... ............ h10.2. Operații pe dicționare.................................................. ............................. ................................. .......................... h10.3. Metode de dicționar.................................................. ........................................................ ............... ........... h10.4. Utilizarea alias-urilor și copierea............................................. ...................... ................... s10.5. Matrici rare.............................................................. ................................................... ......... .... h10.6. Sugestii ................................................. ....... ................................................. ............. ....................... h10.7. Tastați un întreg lung.................................................. ................. ................................ ............... з10.8 . Numărarea literelor.............................................................. ................................................... ......... ...................Capitolul 11. Fișierele și gestionarea excepțiilor............... ................. ................................ ........................ ..... Capitolul 12. Clase și obiecte.............. ................................................... ......................................... ......... ... Capitolul 13. Clase și funcții................................ ......... ............................................... ... ........................Capitolul 14. Metode................................. .. .................................................. .... ................................................. .......... ... Capitolul 15. Seturi de obiecte................................ ............................. ................................. .......................... .............. Capitolul 16. Moștenirea...... .......................................................... .................................................. ..........Capitolul 17. Liste legate.................. ................. ....................................... ........... .................................Capitolul 18. Stive... .......... .............................................. .... . .................................................. ...... ...................Capitolul 19. Cozile și cozile prioritare.................. .......................................................... ...........Capitolul 20. Copaci................................... ............................................................. ................... .......................Capitolul 21. Programarea funcțională... ............................... ................... ............................ Concluzie. Ochiul păsării.............................................. . .................................. Anexa A. Sfaturi pentru depanarea programelor........ . .................................................. ..... .............. Anexa B. Crearea și utilizarea modulelor.............. .......... ................................ Anexa C. Crearea tipurilor de date.. .......................................................... ................ .................... Anexa D. Scrierea programelor GUI........ .......................... ..........Anexa E. Metodologii de dezvoltare a echipei........ .......................... ................................ .. Anexa F. Îndrumări pentru profesori.................. ........................ ........ Revizie: 170 Prefaţă Prefaţă Totul a început când, în vara lui 2002, am fost complet dezamăgit V limbajul php, despre care am scris destul de mult pe vremea aceea. M-am specializat în programare web, așa că alegerea instrumentului a fost în general logică, dar la dezvoltare proiecte majore php s-a arătat departe de partea sa cea mai bună: lipsa instrumentelor de gestionare a excepțiilor în cascadă, moștenirea multiplă și spațiile de nume l-au afectat.

Pe scurt, php nu mi s-a potrivit atât din motive practice, cât și din punct de vedere ideologic. După cum se spune, nimic nu limitează gândirea unui programator mai mult decât un compilator/interpret.

Am început să caut o alternativă la php. Înainte de php, a trebuit să lucrez cu limbajul perl, care nu mi se potrivea din aceleași motive. De asemenea, C++ nu este cel mai convenabil limbaj pentru dezvoltarea aplicațiilor web, deoarece... Costul deținerii unor astfel de aplicații este destul de mare. Și așa am dat peste Python (Python, ideea de a folosi Python a fost preluată de Dmitry Brechalov, prietenul meu, cu care am corespondat foarte productiv și am făcut schimb de cărți. A stăpânit rapid Python-ul și a reușit să scrie în el chiar și pentru Psionul său De asemenea, mi-a trimis prin e-mail un link către site-ul web al proiectului Cum să gândești ca un informatician. Învățarea cu Python (am citit cartea dintr-o singură ședință, m-a surprins felul în care a fost prezentat materialul. De exemplu, conceptul de recursiunea în această carte este introdusă înaintea constructelor sintactice care implementează bucle și este foarte clară și elegantă.În programele școlare algoritmi recursivi sunt de obicei incluse în categoria problemelor olimpiadei.

Impulsul final a fost atunci când am început să predau cursuri de informatică la fundația Intellect Club pentru copii cu vârsta cuprinsă între 9 și 13 ani. Experimentele cu Pascal au fost nesatisfăcătoare pentru că... A trebuit să fiu distras de complexitatea implementării tipului și de diversele limitări inerente acestui limbaj, distragând atenția de la esența programării.

Nici măcar nu am încercat să folosesc C++, pentru că... este si mai complicat. Python a venit din nou în ajutor.

mi-ar placea sa multumesc director executiv fundație, Andrei Repyakh, care mi-a dat libertate deplină, încurajându-mi experimentele.

Pentru a fi sigur că nu am ratat nimic, am încercat un alt limbaj - Ruby (site-ul web al proiectului, dar a revenit curând la Python. Ruby, ca și perl, este plin de constructe pe care doar guruii le pot citi, ceea ce nu ajută deloc programatorii începători. Și în ceea ce privește numărul de module, Python este încă superior acestuia.

Pentru ca copiii să poată studia independent, am decis să traduc cartea Cum să gândești ca un informatician. Dar în timpul procesului de traducere am avut constant dorința de a-l completa cu propriile mele idei, de a rearanja capitolele astfel încât prezentarea materialului să fie mai logică. Mai mult, am descoperit multe probleme controversate. Am ajuns să scriu propria mea carte, bazată pe Cum să gândești ca un informatician, dar cu completări și revizuiri. Putem spune că aceasta este o ediție în limba rusă sau o ramură a proiectului.

Cartea s-a dovedit a fi puțin mai complicată decât era planificat: în general, corespunde nivelului de liceu și cursuri inițiale Universitățile, dar și elevii de liceu, cu sprijinul profesorului, vor putea stăpâni fără mare dificultate materialul din carte.

Această carte este distribuită sub licență OPL (cu restricția VI-B), ceea ce înseamnă că textul din această carte poate fi folosit în mod liber în orice scop, cu excepția celor comerciale.

Revizie: 170 Prefață Desigur, copiile necomerciale trebuie distribuite cu licență și fără modificarea dreptului de autor al cărții. În caz contrar, vi se oferă libertate deplină. Ia-l. Foloseste-l.

:) Revizie: 170 Mulțumiri Mulțumiri Această carte este distribuită la fel de liber ca și cuvântul în gură. Prin urmare, este, de asemenea, dezvoltat în mod liber, fără restricții de către alte licențe decât OPL. Această carte se datorează în mare parte contribuțiilor persoanelor enumerate aici:

X Shlyakov Dmitry X Rudskikh Vyacheslav X Voloshin Evgeniy X Belchenko Alexander X Brechalov Dmitry X Otkidach Denis X Olishchuk Andrey X Churanov Mihail X Pushilin Sergey X Litvinova Elena X Lipanin Anton X Jukov Boris Multumesc pasionatilor liberei miscari software(trăind în toată lumea, pentru ceea ce fac.

Mulțumiri speciale echipei de proiect a suitei de birou deschise OpenOffice.org (pentru produsul bun în care a fost scrisă această carte.

Revizuire: 170 Introducere Introducere La școală, profesorul îi întreabă pe elevi ce fac părinții lor. Fata întinde mâna:

Tatăl meu este doctor.

Aceasta este o profesie bună”, spune profesorul.

„Și tatăl meu este șofer”, se laudă unul dintre băieți.

Ce profesie interesantă. Ce face tatăl tău? - o întreabă profesorul pe Vovochka, la care acesta răspunde calm:

Cântă la pian într-un bordel.

Profesorul este șocat;

în aceeași zi ea merge acasă la Vovochka și îi spune indignată tatălui ei:

Cum poți crește un copil în astfel de condiții?! Chiar cânți la pian într-un bordel?!

Tatăl lui Vovochka este jenat:

Vezi tu, eu sunt programator. Sunt specializat în rețele TCP/IP, scriu aplicații de rețea distribuite pentru sisteme de operare UNIX, dar cum pot explica asta unui băiețel de șapte ani?

Din exterior, profesia de programator (și orice alt specialist în computer) pare oarecum misterioasă. Ce fac oamenii astia? Stau toată ziua la computer și își spun glume ciudate – până de curând așa credeau majoritatea oamenilor. Dar astăzi, tehnologiile informaționale au pătruns aproape în toate domeniile activității umane: de la lucruri familiare precum telefoanele mobile până la tehnologiile spațiale. Calculatoarele simplifică lucrul cu documente și ajută la optimizarea proceselor de afaceri. Datorită persoanelor discrete care stau la computer toată noaptea, putem comunica în timp real cu prietenii și partenerii de afaceri aflați oriunde în lume folosind internetul. Budiștii Zen spun: Lucrarea maestrului nu este vizibilă.

Această carte își propune să vă învețe nu doar cum să scrieți programe, ci și cum să gândiți ca un specialist în computer. Acest mod de gândire combină abordări utilizate în matematică, știință și inginerie. La fel ca matematicienii, informaticienii folosesc limbaje formale pentru a înregistra idei, algoritmi și operațiuni pe anumite obiecte. La fel ca inginerii, ei proiectează obiecte prin asamblarea diferitelor componente în sisteme și alegând soluții dintre posibilele alternative. La fel ca oamenii de știință naturală, ei studiază comportamentul sisteme complexe, construiți ipoteze, efectuați experimente.

Cea mai importantă abilitate a unui specialist în computer este capacitatea de a rezolva probleme. Această abilitate implică capacitatea de a le formula, de a gândi creativ la soluțiile posibile și de a comunica clar opțiunea aleasă. După cum se dovedește, învățarea programării este o oportunitate excelentă de a dezvolta toate aceste abilități.

Asadar, haideti sa începem. O descriere detaliată a procesului de instalare a interpretului Python și a tot ceea ce aveți nevoie pentru a lucra cu cartea poate fi citită în secțiunea următoare.

Revizuire: 170 Introducere Este recomandat să vă familiarizați cu acesta înainte de a trece la studiul primului capitol, pentru a nu avea probleme în procesul de stăpânire a materialului din carte. Dar nu uitați că principalul lucru este dorința de a învăța, capacitatea de a pune întrebări și de a căuta răspunsuri la ele.

z0.1. Cunoștințe de bază Pentru a stăpâni materialul din această carte, veți avea nevoie de cunoștințe de bază de calculator, și anume:

X Lucrul cu fișiere și foldere (directoare);

X Lansați programe;

X Editarea fișierelor text;

X Dacă aveți un sistem UNIX instalat pe computer, va fi foarte util să puteți lucra în consolă;

X Lucrul pe Internet - puteți găsi acolo o mulțime de informații utile;

X Cel puțin o cunoaștere de bază a limbii engleze va fi foarte utilă.

Rețineți că pachetele de birou (MS Office, OpenOffice.org, StarOffice și altele asemenea) nu vă vor ajuta la programare. Programele sunt tastate în editori de text simple, cum ar fi MS Notepad (alias Notepad).

Este bine dacă știți ce este codul binar și știți cum să convertiți numerele dintr-un sistem numeric în altul, toate acestea sunt de obicei predate în cursurile de informatică din școală.

Nu contează ce sistem de operare este instalat pe computerul tău - Python are implementări pentru toate cele mai comune platforme: Windows, UNIX (GNU/Linux, FreeBSD, etc.) și chiar Mac OS X. Mai mult, programele scrise în același sistem de operare , va fi executat cu succes în oricare altul dacă există un interpret Python instalat!

Python este inclus cu majoritatea distribuțiilor GNU/Linux, dar aceasta nu este neapărat cea mai recentă versiune. Prin urmare, ar trebui să vă uitați în continuare la pagina Python și să citiți știrile. Python, ca majoritatea proiectelor comunitare sursa deschisa, se dezvoltă foarte dinamic. Vă recomandăm insistent să utilizați versiunea 2.3.3 sau o versiune superioară a interpretului Python - această versiune a corectat erorile care făceau dificilă scrierea de programe non-engleze.

Acum să aruncăm o privire mai atentă asupra procesului de instalare a interpretorului Python pe diferite sisteme de operare.

z0.2. De unde pot obține un interpret Python?

Interpretul de limbaj Python este distribuit gratuit sub Licența Python Software Foundation (PSF) (care, în anumite privințe, este chiar mai democratică decât GNU GPL (GNU General Public License):

Site-ul oficial al proiectului de limbaj Python se află la adresa. Aici, în secțiunea Descărcări, puteți descărca cea mai recentă versiune pentru sistemul dvs. de operare. Pentru sisteme asemănătoare UNIX Distribuția interpretului este disponibilă în două versiuni: în cod sursă (archive.tar.gz), ca pachet rpm (.rpm, .src.rpm, compilat pentru distribuția dvs.) sau un pachet .deb (pentru distribuția Debian Linux) . Pentru sistemul de operare Windows, descărcați fișierul exe, care conține interpretul însuși și programul de instalare.

Revizie: 170 Introducere z0.3. Instalarea interpretului de limbaj Python pe UNIX În toate sistemele de operare asemănătoare UNIX (orice sisteme BSD, GNU/Linux, Solaris etc.), procesul de instalare va fi în general același. În distribuțiile GNU/Linux care acceptă sistemul de gestionare a pachetelor RPM, pe lângă procesul standard de instalare UNIX din codul sursă, puteți instala Python dintr-un pachet rpm. Mai mult, în distribuțiile GNU/Linux bazate pe RPM (RedHat Linux, Mandrake, SuSE Linux, ASPLinux, ALTLinux) se recomandă instalarea Python din rpm.

Descărcați distribuția Python și instalați-o în consecință. Pentru a face acest lucru, veți avea nevoie de drepturi de superutilizator (root). Dacă nu aveți o parolă de superutilizator, atunci, evident, ar trebui să cereți ajutor administratorului de sistem care întreține computerul.

z0.3.1. Instalarea/actualizarea Python dintr-un pachet rpm Dacă sunteți autentificat ca utilizator neprivilegiat, treceți la modul superutilizator:

# Apoi mergeți în folderul în care se află pachetul rpm și introduceți comanda (ținând cont de ce versiune de Python ați descărcat):

# rpm -i python-x.x.rpm z0.3.2. Instalarea Python din codul sursă Despachetați codul sursă din arhiva descărcată:

$ gzip -cd python-x.x.tar.gz | tar xvf Accesați folderul în care a fost extrasă distribuția și rulați comanda:

$./configure Apoi ar trebui să porniți procesul de construire Python:

$ make După ce este finalizat, trebuie să comutați în modul superutilizator și să rulați comanda make install:

# make install De fapt, aici nu există diferențe față de instalarea standard din codul sursă pentru sistemele de operare asemănătoare UNIX. Pe majoritatea sistemelor, se recomandă să construiți software-ul în folderul /usr/local/src/.

Revizie: 170 Introducere z0.4. Instalarea Python pe sistemul de operare Instalare Windows Python pe Windows este mai simplu decât pe UNIX. Doar descărcați fișierul de instalare (de exemplu, Python-2.3.3.exe), rulați-l pe computer și răspundeți la toate întrebările din programul de instalare, completând răspunsul făcând clic pe butonul Următorul.

Mai întâi trebuie să specificați unde trebuie instalat interpretul. În mod implicit, este plasat în directorul C:\PythonXX, unde XX este numărul versiunii. La acest pas, trebuie doar să faceți clic pe butonul Următorul.

Dacă instalați Python pentru prima dată, atunci bifați opțiunea Nu, nu face backup.

Următorul pas este să selectați componentele de instalat. Este mai bine să activați instalarea a tot ceea ce este oferit (inclusiv documentația). Setul complet ocupă aproximativ 20 de megaocteți pe hard disk.

În cele din urmă, trebuie să setați un nume de grup pentru meniul principal. Puteți face pur și simplu clic pe Următorul. Programul va afișa informații rezumative despre ce va fi instalat și unde. Faceți clic din nou pe Următorul și așteptați finalizarea instalării. Faceți clic pe Terminare pentru a părăsi programul de instalare.

z0,5. Rularea programelor scrise în Python Pentru a rula un program scris în Python, pe sistemele UNIX trebuie să apelați interpretul Python și să îi transmiteți ca parametru numele fișierului în care se află programul care urmează să fie lansat:

$ python my_program.py În plus, pe sistemele de operare UNIX, este posibil ca un program să specifice ce interpret trebuie apelat pentru a-l executa. Pentru a face acest lucru, în prima linie a programului puteți scrie:

#! /usr/bin/env python Apoi trebuie să faceți fișierul cu scriptul executabil:

$ chmod u+x my_program.py După aceasta, scriptul poate fi executat prin simpla introducere a numelui său pe linia de comandă:

$ my_program.py sau, dacă prima opțiune nu funcționează:

$./my_program.py Secvența de caractere #! programatorii o citesc de obicei ca she-bang!.

În OS programe Windows scrise în Python sunt lansate în modul obișnuit - utilizați Explorer pentru a găsi fișierul care conține programul și faceți dublu clic pe pictograma acestuia cu butonul stâng al mouse-ului. Python, când este instalat, asociază extensia de fișier .py cu interpretul Python, așa că făcând dublu clic pe un astfel de fișier va lansa Python, care va executa programul scris în fișier. Dacă programul dumneavoastră nu are o interfață grafică, sistemul de operare Windows va deschide o fereastră de consolă. După terminarea programului, această fereastră va fi imediat închisă, astfel încât este posibil să nu aveți timp să vedeți rezultatul muncii sale. Puteți evita acest lucru adăugând următoarea linie la sfârșitul programului:

raw_input("Apăsați orice tastă pentru a ieși") Acest lucru va forța interpretul să aștepte ca orice tastă să fie apăsată înainte de a ieși din program.

Dacă ați specificat o altă extensie, metoda de lansare cu dublu clic nu va funcționa. Pe Windows, programele Python trebuie să aibă întotdeauna extensia .py sau .

pyw. A doua opțiune diferă prin faptul că Python pornește în tăcere, adică fără a deschide o fereastră de consolă. Extensia .pyw este recomandată pentru programele care au o interfață grafică și nu necesită deloc o fereastră de consolă.

O altă opțiune este să deschideți o fereastră de sesiune MS-DOS (sau să rulați FAR) și să rulați următoarea comandă:

C:\Examples> python my_program.py Cu această comandă lansăm interpretul Python și îi spunem programului din ce fișier ar trebui să execute.

z0.6. Mediul de dezvoltare Pachetul standard Python include mediul de dezvoltare integrat IDLE, în care programele de editare vor fi mult mai convenabile decât într-un simplu editor de text. IDLE este scris în Python folosind biblioteca Tcl independentă de platformă, astfel încât poate rula cu ușurință pe orice sistem de operare pentru care există o implementare Python. IDLE are, de asemenea, un sistem de depanare încorporat care vă permite să rulați programul linie cu linie, ceea ce face mai ușor să găsiți erori. Dacă din anumite motive IDLE nu ți se potrivește, poți încerca și alte medii de dezvoltare.

Sistemele UNIX au multe editoare care au propriile avantaje și dezavantaje, atât editori de consolă (vi, emacs, editor mc încorporat), cât și grafici (vim, emacs, kate, editor IDLE etc.).

Cea mai ușoară alegere poate fi Kate - este inclusă cu cele mai recente versiuni ale mediului de ferestre KDE. Kate poate evidenția sintaxa programului, are un emulator de consolă încorporat și un modul special care facilitează lucrul cu programele scrise în Python: un browser de cod, care este activat prin meniul Setări din secțiunea Module de aplicație.

Un alt editor interesant: SciTE (Pe lângă evidențiere, poate restrânge blocuri de text, ceea ce face foarte ușor să lucrezi cu programe mari, dar nu are un browser de cod (cel puțin în pachetul standard), în plus, SciTE încă trebuie să fie rusificată, ceea ce poate cauza unele dificultăți începătorilor.

Pentru programarea Python pe Windows, există, de asemenea, mai multe editori și medii bune, altele decât IDLE.

În primul rând, acesta este PythonWin - un mediu de dezvoltare Python foarte bun pentru Windows (poate fi descărcat de pe site-ul web PythonWin se distinge prin absența problemelor cu caracterele rusești, un mediu de programare convenabil și integrarea cu sistemul de operare.

Revizie: 170 Introducere Vă putem recomanda și editorul UniRed ( îl puteți descărca de pe site. Acesta este un editor de text excelent pentru Windows 95/98/NT/2000/XP, care înțelege atât sintaxa Python, cât și toate codificările posibile (inclusiv toate chirilic și toate codificările familiei Unicode).

În cele din urmă, este foarte util pentru dezvoltarea și rularea programelor manager de fișiere DEPARTE. Oricine a lucrat cu Norton sau Volkov Commander va fi bine versat în FAR.

Editorul încorporat înțelege atât codurile rusești utilizate în Windows, iar managerul în sine este mult mai convenabil pentru rularea programelor de consolă decât o fereastră standard DOS. Pe sistemul de operare Windows, FAR este poate cel mai potrivit mediu pentru rularea programelor Python.

Acum suntem complet înarmați și pregătiți să începem să învățăm programarea în Python. Să trecem la următorul capitol, care acoperă conceptele de bază.

Revizie: 170 Concepte de bază Capitolul 1. Concepte de bază Mai întâi, va trebui să înțelegeți câteva concepte de bază. Nu este nevoie să le memorezi – este suficient să le înțelegi măcar la nivel intuitiv. Mai târziu, vei începe să le folosești în practică și totul va cădea la locul lor. Aceasta este poate una dintre cele mai plictisitoare părți ale cărții.

h1.1. Algoritmi și programe Conceptul de algoritm este unul dintre conceptele centrale ale întregii discipline informatice. Cuvântul algoritm, în esență, este sinonim cu cuvintele metodă sau rețetă. Putem vorbi, în acest sens, despre un algoritm de găsire a rădăcinilor unei ecuații din coeficienții ei, sau despre un algoritm de descompunere numar naturalîn factori primi. Dacă algoritmii se bazează pe calcule simple, atunci astfel de algoritmi se numesc numerici. Cu toate acestea, algoritmii non-numerici sunt, de asemenea, luați în considerare destul de des. De exemplu, secvențele de simboluri: texte, formule etc. pot acționa ca date și rezultate sursă. Rolul operațiilor nu este operațiile obișnuite de adunare, înmulțire și altele asemenea, ci operațiuni de concatenare a șirurilor sau operații de înlocuire a unor caractere cu altele conform unui tabel de corespondență. Un exemplu este codificarea textului în cod Morse. Există algoritmi pentru a construi obiecte grafice complexe și pentru a le converti. Pentru a învăța un computer să facă ceva, mai întâi trebuie să creați un algoritm.

Un algoritm este o metodă descrisă în toate detaliile pentru obținerea de rezultate care satisfac condițiile stabilite pe baza datelor inițiale.

Un program este o secvență de instrucțiuni de mașină care descrie un algoritm.

Desigur, pentru a scrie un program, trebuie să veniți cu un algoritm.

Programele de calculator sunt de obicei scrise în limbaje speciale de programare.

h1.2. Limbaje de programare și niveluri de abstractizare Există mai multe abordări ale programarii. Inițial, calculele au fost descrise la nivelul instrucțiunilor mașinii în cod binar. Logică programe similare a fost destul de greu de înțeles din cauza faptului că programatorul a trebuit să acorde atenție unor probleme precum, de exemplu, câte locații de memorie ar trebui alocate pentru a stoca o anumită valoare. Pentru a adăuga două numere, a fost necesar să calculați mai întâi adresele celulelor de memorie în care au fost stocate valorile adăugate și numai după aceea să efectuați operația de adăugare. numere binare. Această abordare a programării este uneori numită bazată pe adrese.

A fost foarte greu de citit și de înțeles cum funcționează un program scris în cod binar, cu atât mai puțin să găsiți și să remediați o eroare în el. Prin urmare, pentru a-și simplifica munca, programatorii au venit cu coduri mnemonice (din grecescul Mnemonikos mnemon - amintiți-vă) sau mnemonice - denumiri de litere ale instrucțiunilor binare ale mașinii, care sunt mai ușor de reținut decât secvențele de zerouri și unu. Pentru a simplifica lucrul cu celulele de memorie, a început să fie folosit conceptul de variabilă.

O variabilă - în programare, este o desemnare cu litere a unei zone de memorie în care este stocată o anumită valoare.

Revizia: 170 Concepte de bază Pentru a traduce codurile mnemonice în instrucțiuni de mașină și numele variabilelor în adrese ale celulelor de memorie, a fost folosit un program special - un traducător. Limbajele de cod mnemonic sunt numite asamblatori.

Tehnologiile de dezvoltare au continuat să se dezvolte, specialiștii au căutat noi abordări, iar în curând au început să se cristalizeze ideile care au stat ulterior la baza așa-numitei abordări structurale. S-a observat că toate calculele sunt reduse la următoarele acțiuni elementare:

X Introducerea datelor de la tastatură, dintr-un fișier sau de pe orice dispozitiv;

X Trimiteți date pe ecran, într-un fișier, pe o imprimantă sau alt dispozitiv;

X Efectuați unele operații pe numere, șiruri sau alte obiecte;

X Selectarea unei ramuri de execuție a programului pe baza deciziei luate (de exemplu, pe baza rezultatelor comparării a două valori);

X Repetarea unui grup de operații, cel mai adesea cu modificarea unuia sau mai multor parametri.

Veți vedea în curând că acesta este într-adevăr cazul. În același timp, au început să apară noi traducători care au convertit programele scrise în limbi bazate pe aceste operațiuni de bază în instrucțiuni ale mașinii. Astfel de limbi au început să fie numite structurale sau limbi nivel inalt. Programe pentru limbi de nivel înalt descrie procesul de calcul la un nivel superior de abstractizare, de ex. permite programatorului să facă abstracție de la caracteristicile implementării mașinii.

Să ilustrăm acest lucru cu două exemple simple. Primul program imită un limbaj de nivel scăzut, iar al doilea imită unul de nivel înalt:

1. Introduceți adresa primului număr în registrul edx Introduceți în registrul contor Introduceți în registrul eax Etichetă lp:

Comparați valoarea registrului eax cu valoarea stocată la adresa preluată din registrul edx. Dacă este mai mică sau egală, atunci mergeți la eticheta l_next. Scrieți în registrul eax valoarea din celula a cărei adresă este stocată în edx. Eticheta l_next:

Adăugați la valoarea registrului edx Dacă registrul contor nu este 0, atunci micșorați valoarea din registrul contor cu 1 și mergeți la eticheta lp Scrieți valoarea din registrul eax în variabila Max 2. Scrieți în variabila Max. Repetați până când variabila i se schimbă de la 1 la 10 s pasul +1:

Dacă numărul i-lea este mai mare decât Max, atunci puneți-l în variabila Max. Afișați valoarea variabilei Max.

Revizia: 170 Concepte de bază Ambele programe găsesc maximum zece numere naturale date.

Numele operațiunilor au fost schimbate cu omologii lor în limba rusă (această metodă de scriere se numește uneori pseudocod), dar sensul acțiunilor a fost păstrat, așa că nu este greu de înțeles diferența lor.

Cel mai adesea, programele scrise în limbi de nivel înalt funcționează mai lent, deoarece... traducătorii nu construiesc cel mai optim Codul mașinii conform textului programului. Dar limbile de nivel înalt au multe avantaje: sunt mai ușor de citit și de înțeles și sunt, de asemenea, portabile. Aceasta înseamnă că programele de nivel înalt pot rula pe diferite tipuri de computere sau sisteme de operare cu modificări reduse sau deloc, în timp ce programele de nivel scăzut sunt de obicei scrise pentru un anumit tip de computer sau sistem de operare și pentru a porta astfel de programe trebuie să fie rescris pe o altă platformă.

Vă rugăm să rețineți că în primul program rezultatul nu este tipărit. Metoda de retragere program de nivel scăzut va varia in functie de platforma pe care va fi executat acest program. Mai mult, acest program nu va putea funcționa nici pe un procesor Intel 80286, deoarece registrele edx și eax au apărut doar în Intel 80386.

Limbajele structurate clasice sunt C1 și Pascal. Ele vă permit să descrieți procesele computaționale la un nivel de abstractizare mai înalt decât asamblatorii, dar, cu toate acestea, au o serie de dezavantaje. În special, un programator care scrie în aceste limbi trebuie încă să specifice în mod explicit tipul de variabile cu care vor funcționa programele sale, astfel încât traducătorul să știe câtă memorie să aloce pentru stocarea lor.

În plus, este imposibil să stocați, de exemplu, un șir în variabile concepute pentru a stoca numere întregi.

Recent, așa-numitele limbi de nivel foarte înalt au început să câștige popularitate. Ele vă permit să faceți abstracție de la tipurile variabile, ceea ce deschide noi posibilități. Îi vom cunoaște pe măsură ce studiem. Limbajul Python, care este unul dintre reprezentanții acestui grup de limbaje de programare.

h1.3. Limbaje formale și naturale Să ne dăm seama cum diferă limbajele de programare de ale noastre limba maternă, despre care vorbim încă din copilărie. Există două tipuri de limbaje: naturale și formale.

Limbile naturale includ limbile vorbite de oameni: rusă, engleză, franceză, arabă și altele. Cel mai probabil, ele au apărut în mod natural atunci când în antichitate oamenii încercau să-și explice ceva unii altora. Toate sunt destul de complexe, deși de multe ori pur și simplu nu le observăm. Pentru a simplifica învățarea limbilor străine, oamenii au creat reguli și dicționare în care cuvintele dintr-o limbă primesc echivalente din alte limbi. Sanskrita este considerată cea mai complexă limbă naturală: prima colecție de reguli sanscrite (gramatica lui Panini, numită Octateuch, secolul al IV-lea î.Hr.) conținea peste 4.000 de reguli gramaticale. Sanscrita are cazuri, 3 numere în nume, câteva sute de forme verbale și verbale și există mijloace pentru formarea liberă a numeroase cuvinte derivate. În plus, în sanscrită puteți găsi până la câteva zeci de cuvinte care simbolizează același obiect, dar reflectând diferite nuanțe de semnificație, astfel încât capacitățile sale expresive depășesc cel mai adesea nevoile medii.

1 Citiți ca și.

Revizie: 170 Concepte de bază Unul dintre cele mai multe limbaje simple Limba pe care o poți vorbi este Esperanto.

Esperanto a fost inventat de medicul oftalmolog Lazar (Ludovik) Markovich Zamenhof în secolul al XIX-lea.

Încă din copilărie, Zamenhof a avut ideea că o singură limbă comună ar ajuta popoarele să se înțeleagă mai bine și să se respecte mai mult.

Zamenhof avea abilități excelente pentru limbi străine și, în timp ce era încă școlar, pe lângă nativa sa rusă, poloneză și idiș, a studiat germană, franceză, engleză, latină, greacă veche, ebraică - aproximativ paisprezece limbi în total. Curând a devenit convins că nici limbile antice, nici cele moderne nu erau potrivite ca limbi comune. Apoi a decis să creeze Limba noua; limbaj nou, care nu ar aparține niciunei națiuni, ar fi ușor de învățat, dar, în același timp, nu ar fi inferioară limbilor naționale în flexibilitate și expresivitate. Și a reușit - întreaga gramatică a Esperanto (împreună cu regulile fonetice) se încadrează pe două pagini tipărite, toate cuvintele sunt internaționale, iar din punct de vedere al expresivității Esperanto nu este inferior (și în anumite privințe chiar superior) rusului. Esperanto este tre interesat și prima lingvo.

Esperanto poate fi numită o limbă naturală? Cred că nu. În ciuda faptului că își trăiește propria viață și se dezvoltă natural, gramatica Esperanto este încă strict formalizată. Prin urmare, se referă mai degrabă la limbaje formale.

Limbile formale sunt limbaje inventate de oameni pentru a rezolva probleme specifice. De exemplu, un set de simboluri și reguli speciale pentru scrierea formulelor utilizate de matematicieni pentru a scrie formule și a demonstra teoreme este un limbaj formal.

Chimiștii își folosesc și limbajul formal pentru a scrie structura chimică a substanțelor. Limbajele de programare sunt limbaje formale concepute pentru a descrie algoritmi.

Limbile formale se caracterizează prin reguli sintactice clare.

De exemplu, 3+3=6 este o notație matematică corectă din punct de vedere sintactic, dar 3=+6$ nu este. H2O este o formulă chimică corectă din punct de vedere sintactic pentru o substanță, dar 2Zz nu este.

Când citești o propoziție în rusă sau o expresie într-o limbă formală, îi determini structura, adesea inconștient. Acest proces se numește analiză sintactică sau analiză. Termenul echivalent în engleză este parsing.

De exemplu, când citești expresia Mama a spălat cadrul, folosești spațiile pentru a determina începutul și sfârșitul cuvintelor și abia după aceea găsești subiectul (lmama) și predicatul (lmyla). După ce ați analizat structura sintactică, puteți înțelege sensul acesteia - semantică.

Înainte de a converti un program într-o formă ușor de înțeles pentru un computer, orice traducător efectuează o analiză sintactică. În timpul analizei sintactice, traducătorul analizează structura sintactică a expresiilor și găsește așa-numitele simboluri (jetoane) - părți indivizibile din punct de vedere sintactic. În acest context, simbolurile pot fi nume de variabile, numere, semne de operare, cuvinte cheie și denumiri ale elementelor chimice.

Folosirea simbolului $ în formula 3=+6$ nu are sens, ceea ce este unul dintre motivele pentru care nu este corect din punct de vedere matematic. Aceeași problemă există și în formula chimică Zz: nu există niciun element în tabelul periodic cu denumirea Zz.

Al doilea tip de erori de sintaxă este asociat cu o structură incorectă a expresiei, adică.

succesiune de caractere. Expresia 3=+6$ are o structură incorectă, deoarece Un semn de adunare nu poate urma imediat semnul egal. La fel, formulele moleculare folosesc indicele, dar nu pot preceda elementul chimic.

Revizuire: 170 Concepte de bază Deși limbajele formale și naturale au multe în comun, ele au o serie de diferențe importante:

1. Neambiguitate Limbile naturale au multe expresii și metafore;

Adesea oamenii determină sensul frazelor în funcție de situația în care sunt folosite. Limbile formale sunt concepute pentru a se asigura că expresiile nu sunt ambigue. Aceasta înseamnă că o expresie trebuie să aibă un singur sens, indiferent de context.

2. Redundanță Pentru a scăpa de ambiguitate și a evita neînțelegerile, limbajele naturale folosesc redundanța: definiții și completări.

Limbile formale sunt concise și maxim expresive.

Majoritatea oamenilor obișnuiți cu limbajele naturale întâmpină de obicei dificultăți în a se obișnui cu limbajele formale (inclusiv programe). Dar merită să ne amintim că densitatea semnificației în astfel de limbi este mai mare, astfel încât acestea sunt mai lente de citit și de înțeles. Structura este foarte importantă în limbajele formale, așa că citirea de la dreapta la stânga sau de jos în sus nu este cea mai bună modalitate de a le înțelege. Și, în sfârșit, lucrurile mărunte contează. Micile erori de ortografie și de punctuație (și greșelile de scriere, de asemenea), care pot fi ignorate în limbile naturale, vor avea un impact mare în limbajele formale, chiar schimbând sensul în sens invers.

În matematică există o întreagă secțiune dedicată teoriei limbajelor formale. Pe aparatul matematic al acestei teorii se bazează analizatorii parser ai traducătorilor.

h1.4. Interpreți și compilatoare Există două tipuri de traducători care convertesc codul sursă al programului în instrucțiuni de mașină: interpreți și compilatori. Interpretul citește un program de nivel înalt (sau cod sursă) și interacționează direct cu sistemul de operare pentru a-l executa. Conversia și execuția programului se face linie cu linie.

Rezultat Sursă Operating Interpreter codul de execuție program program Spre deosebire de interpreți, compilatoarele convertesc complet codul sursă al programului în cod mașină (sau așa-numitul cod obiect), pe care sistemul de operare îl poate executa singur. Acest lucru permite programelor compilate să ruleze chiar și pe computere care nu au un compilator.

În plus, astfel de programe rulează mai repede datorită faptului că computerul nu trebuie să îl analizeze și să îl convertească într-o formă pe care o înțelege de fiecare dată înainte de a porni programul.

Obiect Rezultat Inițial Operațional Compiler (executable) cod de execuție cod de program de sistem Cu toate acestea, interpreții moderni sunt, de asemenea, capabili să stocheze cod intermediar, a cărui execuție durează mai puțin timp datorită economiilor la analizarea codului sursă. Cu toate acestea, un astfel de cod intermediar este de înțeles doar pentru interpret, așa că pentru a rula programul este încă necesar să îl aveți pe computer.

Trebuie spus că, cu puterea computerului modern și capacitatea de memorie, diferența de viteză de execuție a programelor de către interpreți și compilatori este aproape inobservabilă, dar procesul de dezvoltare și depanare a programelor în limbaje interpretate este mult mai simplu2.

Limbajul Python este interpretat deoarece... programele scrise pe el sunt executate de un interpret.

Există un proiect interesant pentru versiunea Windows de Python: py2exe, care vă permite să creați fișiere exe independente din scripturi.

De fapt, py2exe nu este un compilator în sine - convertește scriptul în cod intermediar folosind Python însuși și plasează partea necesară a interpretului în fișierul executabil, împreună cu acest cod intermediar și codul tuturor modulelor utilizate în program.

Astfel, obțineți un fișier exe și unul sau mai multe fișiere dll care conțin programul dvs. împreună cu mediul de rulare. Acum nu aveți nevoie de un interpret Python separat pentru a rula acest program.

Cu toate acestea, fișierul executabil rezultat poate rula numai sub sistemul de operare Windows. Dacă programul dvs. este destinat să ruleze numai pe acel sistem și nu doriți să solicitați utilizatorilor să instaleze Python, atunci py2exe poate fi un instrument foarte util.

obține Informații suplimentareși puteți descărca py2exe aici:

z1.5. Primul program Este timpul să lansați interpretul Python și să scrieți primul program.

Există două moduri de a utiliza interpretul: modul de comandă și modul de execuție din fișiere. Dacă introduceți o comandă pe linia de comandă a interpretului Python, interpretul va afișa imediat rezultatul execuției sale:

$ python Python 2.3+ (#1, 23 septembrie 2003, 23:07:16) pe Linux Tastați „help”, „copyright”, „credits” sau „license” pentru mai multe informații.

>>> printează „Bună lume!” Salut Lume!

Prima linie a exemplului este o comandă care pornește interpretul Python pe sistemul de operare UNIX. În sistemul de operare Windows, pentru a apela interpretul, apelați pur și simplu mediul de dezvoltare IDLE din meniul Start Programs. Următoarele două rânduri sunt informații de la interpret (numărul versiunii, drepturile de autor - deci 2 limbi compilate sunt încă indispensabile în sistemele în timp real, în care chiar și cea mai mică întârziere poate duce la dezastru (de exemplu, astfel de sisteme sunt folosite pentru a controla manevrele navelor spațiale și fluxul de procese fizice complexe în condiții de laborator și de producție).

Revizie: 170 Concepte de bază prezentate). Al patrulea începe cu promptul interpretului >>>, care indică faptul că este gata să execute comenzi. Am tastat comanda print „Bună lume!”, adică. au fost instruiți să afișeze pe ecran linia „Bună lume!” și rândul următor interpretul a scos ceea ce am cerut.

De asemenea, putem scrie programul într-un fișier și folosim un interpret pentru a-l executa. Un astfel de fișier se numește script sau script (din limba engleză script - script). De exemplu, folosind un editor de text, creați un fișier prog1.py cu următorul conținut:

printează „Bună lume!” Se obișnuiește să se încheie numele fișierelor care conțin programe Python cu secvența de simboluri .py (cei care lucrează în sisteme de operare sisteme DOS sau Windows o va numi extensie). Pentru a executa programul, trebuie să trecem numele script-ului interpretului ca parametru:

$ python prog1.py Bună lume!

În alte medii software, metoda de pornire a programelor poate fi diferită, dar principiul apelării interpretului va rămâne același.

Exercițiu. Încercați să schimbați primul program astfel încât să conțină erori de sintaxă: mai întâi o eroare asociată cu o unitate de sintaxă nerecunoscută (adică, un cuvânt necunoscut), apoi o eroare asociată cu o structură incorectă a programului (puteți încerca să schimbați unitățile de sintaxă).

Experiment.

h1.6. Ce este depanarea?

Programarea este un proces destul de complex și este destul de natural ca un programator să facă o greșeală. S-a întâmplat că erori de software numite bug-uri (din engleza bug - bug). Nu veți găsi acest cuvânt în literatura în limba rusă, dar în argoul programatorilor este folosit destul de des împreună cu cuvântul glitch. Procesul de găsire și eliminare a erorilor din literatura engleză este de obicei denumit depanare, dar îl vom numi depanare.

Există trei tipuri de erori care pot apărea în programe:

erori de sintaxă, erori de rulare și erori semantice. Pentru a le găsi și a le repara mai repede, este logic să învățați să faceți distincția între ele.

h1.6.1. Erori de sintaxă Orice interpret va putea executa un program numai dacă programul este corect din punct de vedere sintactic. În consecință, compilatorul nu va putea converti programul în instrucțiuni de mașină dacă programul conține erori de sintaxă. Când traducătorul găsește o eroare (adică vine vorba de o instrucțiune pe care nu o poate înțelege), își întrerupe activitatea și afișează un mesaj de eroare.

Pentru majoritatea cititorilor, erorile de sintaxă nu reprezintă o mare problemă. De exemplu, există adesea poezii fără semne de punctuație, dar le putem citi cu ușurință, deși acest lucru creează adesea ambiguitate în interpretarea lor. Dar Versiune: 170 traducătorii de concepte de bază (și interpretul Python nu face excepție) sunt foarte pretențioși în privința erorilor de sintaxă.

Chiar dacă Python găsește chiar și o greșeală minoră în programul dvs., va afișa imediat un mesaj care vă va spune unde a găsit-o și va ieși. El nu va putea realiza un astfel de program și, prin urmare, îl va respinge. În primele săptămâni ale practicii de dezvoltare de software, veți petrece probabil o perioadă destul de mare de timp căutând erori de sintaxă. Pe măsură ce câștigi experiență, le vei admite din ce în ce mai puțin și le vei găsi mai repede.

h1.6.2. Erori de rulare Al doilea tip de erori apare de obicei în timpul execuției programului (de obicei sunt numite excepții sau, pe scurt, excepții). Astfel de erori au un alt motiv. Dacă apare o excepție într-un program, înseamnă că s-a întâmplat ceva neașteptat în timpul execuției: de exemplu, o valoare incorectă a fost transmisă programului sau programul a încercat să împartă o anumită valoare la zero, ceea ce este inacceptabil din punct de vedere discret. matematică. Dacă sistemul de operare trimite o solicitare de a închide imediat programul, se ridică și o excepție. Dar în programele simple, aceasta este o apariție destul de rară, așa că este posibil să nu le întâlniți imediat.

h1.6.3. Erori semantice Al treilea tip de erori sunt erorile semantice. Primul semn că programul dumneavoastră are o eroare semantică este că se execută cu succes, adică. fără excepții, dar nu face ceea ce vă așteptați să facă.

În astfel de cazuri, problema este că semantica programului scris este diferită de ceea ce aveai în minte. Găsirea unor astfel de erori este o sarcină non-trivială, deoarece...

trebuie să te uiți la rezultatele programului și să-ți dai seama ce face programul de fapt.

h1.6.4. Procesul de depanare Vechea eroare este mai bună decât noile două.

Proverba populară a programatorului Abilitatea de a depana programe pentru un programator este o abilitate foarte importantă.

Procesul de depanare necesită mult efort mental și concentrare, dar este unul dintre cele mai interesante lucruri de făcut.

Depanarea este foarte asemănătoare cu munca unui om de știință naturală. Studiind rezultatele experimentului anterior, trageți câteva concluzii, apoi schimbați programul în consecință, îl rulați și începeți din nou să analizați rezultatele.

Dacă rezultatul obținut nu coincide cu cel așteptat, atunci va trebui să înțelegeți din nou motivele care au dus la aceste discrepanțe. Dacă ipoteza dvs. se dovedește a fi corectă, atunci veți putea prezice rezultatul modificărilor programului și veți fi cu un pas mai aproape de finalizarea lucrării la acesta, sau poate vă va face și mai convins de iluzie.

Prin urmare, pentru a verifica funcționalitatea unui program, nu este suficient să îl verificați o dată - trebuie să veniți cu toate seturile posibile de date de intrare care pot afecta cumva stabilitatea sistemului dumneavoastră. Astfel de seturi de date de intrare sunt numite valori limită.

Uneori, procesul de scriere și depanare a programelor este împărțit nu numai în timp, ci și între membrii echipei de dezvoltare. Dar, recent, așa-numitele metodologii de dezvoltare flexibile au devenit din ce în ce mai populare. În ele, codarea nu este separată de depanare: programatorii care scriu codul sunt, de asemenea, responsabili de pregătirea testelor și de identificarea cât mai multor erori în timpul procesului de codare. Acest lucru le permite să se bucure pe deplin de munca lor.

Nucleul Linux, al cărui cod sursă conține milioane de linii, a început ca un simplu program care Linus Torvalds(Linus Torvalds) a studiat posibilitatea executării în paralel a sarcinilor pe procesorul Intel 80386. Unul dintre primele programe ale lui Linus a fost un program care comuta între două procese: tipărirea secvențelor AAAA și BBBB. Acest program a devenit mai târziu Linux (Larry Greenfield, The Linux Users" Guide Beta Version 1).

Deci, programarea este un proces de rafinare treptat și depanare până când programul face ceea ce ne dorim. Ar trebui să începeți cu un program simplu care face ceva simplu și apoi puteți începe să construiți funcționalitatea acestuia făcând mici modificări și depanând bucățile de cod adăugate.

Astfel, la fiecare pas vei avea un program de lucru, care, într-o oarecare măsură, îți va permite să judeci câtă muncă ai făcut deja.

În capitolele următoare veți avea ocazia să exersați programele de depanare.

Câteva sfaturi utile de depanare sunt incluse în Anexa A - asigurați-vă că îl citiți când aveți timp liber, de preferință spre finalul studiului capitolului al șaselea.

Revizie: 170 Variabile, operații și expresii Capitolul 2. Variabile, operații și expresii Și, în final, trecem la programarea propriu-zisă. Puteți lansa imediat interpretul Python. Nu va strica dacă testați exemplele pe computer și experimentați cu ele. Dacă găsiți vreo eroare sau greșeală de tipar, scrieți la [email protected]. Poate că numele tău va apărea pe lista dezvoltatorilor de cărți.

h2.1. Valori și tipuri Toate programele funcționează cu valori. Valoarea poate fi un număr sau un șir.

De exemplu, în primul program am imprimat deja pe ecran valoarea șirului „Hello world!”. Într-un mod similar, putem scoate numărul:

>>> printează „Bună lume!” iar 12 îi aparțin tipuri variate: str (din engleză string - string) și int (din engleză integer - integer)3. Interpretul distinge un șir de un număr prin ghilimele în care este inclus.

Dacă există numere întregi, atunci, în teorie, ar trebui să existe și fracții. Să încercăm această comandă:

>>> print 2, 2 Iată primul exemplu de eroare semantică: ne așteptam ca interpretul să imprime un număr zecimal, dar a confundat virgula ca un separator între două numere întregi și le-a tipărit separate printr-un spațiu. În general, ne-a înțeles greșit, pentru că separatorul este fracționat și părți întregi numerele în Python, ca și în majoritatea celorlalte limbaje de programare, sunt dot4:

>>> print 2. 2. Dacă nu sunteți sigur de ce tip este o valoare, o puteți verifica astfel:

>>> type("Hello world!") >>> type(12) >>> type(2.4) Tipul șirului se numește str în Python, tipul întreg este numit int, iar tipul fracționar este float (din număr în virgulă mobilă engleză - numere în virgulă mobilă).

3 În unele versiuni de Python, aceste tipuri sunt numite neabredute: șir și întreg.

4 Această metodă neobișnuită pentru noi de a separa părțile întregi și fracționale este standardul american pentru scrierea fracțiilor zecimale.

Revizia: 170 Variabile, operații și expresii Exercițiu. Efectuați singur următorul experiment: verificați tipurile de valori „12” și „2,4”? Ce fel sunt și de ce?

Exercițiu. Ce se întâmplă dacă încercați să convertiți șirul „8.53” într-un număr întreg folosind funcția int()? Cum se rezolvă această problemă?

h2.2. Conversia tipului În secțiunea anterioară am învățat cum să afișam numerele întregi - este destul de ușor de făcut, nu-i așa? Dar pentru interpret această sarcină pare ceva mai complicată, pentru că trebuie să le convertească în șiruri de caractere înainte de a scoate valori numerice.

Un programator poate face și asta - Python are o întreagă colecție de funcții încorporate care pot converti valori de un tip în altul. De exemplu, funcția int() convertește o valoare într-un tip întreg. Dacă conversia nu poate fi efectuată, se face o excepție:

>>> int("32") >>> int("Salut") Traceback (cel mai recent apel ultimul):

Fișierul „”, rândul 1, în ?

ValueError: literal invalid pentru int(): Bună ziua Funcția int() poate transforma în numere întregi și fracționale, dar rețineți că pur și simplu se elimină la conversie parte fracționată:

>>> int(3.99999) >>> int(-2.3) - Funcția float() convertește numerele întregi și șiruri de caractere în tip fracțional.

>>> float(32) 32. >>> float("3.14159") 3. Și, în sfârșit, funcția str() este responsabilă pentru conversia în tip șir. Aceasta este ceea ce pre-rulează comanda de imprimare:

>>> str(32) "32" >>> str(3.14149) "3.14149" Revizia: 170 Variabile, operații și expresii Poate părea ciudat că Python distinge întregul 1 de fracționarul 1.0: este același număr, dar aparțin unor tipuri diferite. Faptul este că tipul de valoare determină modul în care este stocată în memorie.

h2.3. Variabile La fel ca orice alt limbaj de programare, Python acceptă conceptul de variabile, dar cu o ușoară diferență. Dacă în C++ sau Pascal o variabilă este numele unei locații de memorie în care este stocată o valoare, atunci în Python o variabilă este o referință la o locație de memorie. Diferența, la prima vedere, este nesemnificativă, dar de fapt este o abordare ușor diferită a organizării stocării obiectelor în memorie. Cu toate acestea, nu suntem deosebit de îngrijorați de acest lucru deocamdată.

Pentru a vă aminti o valoare, trebuie doar să o atribuiți unei variabile. Acest lucru se face folosind un operator de atribuire special, care este notat cu semnul egal (=).

>>> mesaj = "Bună lume!" >>> n = >>> pi = 3. V în acest exemplu variabilei mesaj este atribuită (sau mapată) la „Hello world!”, variabilei n i se atribuie valoarea 12, iar variabilei pi i se atribuie valoarea 3.14159.

Cel mai simplu mod reprezentare grafică variabile: scrieți numele variabilei, desenați o săgeată, la celălalt capăt căreia adăugați valoarea atribuită.

Astfel de desene sunt uneori numite diagrame de stare deoarece ele reprezintă starea în care se află variabila, adică ce valoare i se atribuie în prezent.

mesaj УHello world!Ф n pi 3. Comanda print funcționează și cu variabile:

>>> tipăriți mesajul Bună lume!

>>> print n >>> print pi 3. După cum puteți vedea, comanda print nu imprimă numele variabilelor, ci valorile acestora. Variabilele, ca și valorile, au un tip. Să verificăm acest lucru folosind funcția type():

>>> tip(mesaj) >>> tip(n) >>> tip(pi) Revizie: 170 Variabile, operații și expresii Tipul unei variabile este același cu tipul valorii atribuite acesteia. Să ne uităm la un alt exemplu:

>>> mesaj = "Bună lume!" >>> n = >>> tip(mesaj) >>> mesaj = n >>> tipărire mesaj >>> tip(mesaj) Acest exemplu este interesant din două motive. În primul rând, folosește capacitatea de a atribui valoarea unei variabile alteia. Construcția mesaj = n funcționează în mod similar cu atribuirea unei valori unei variabile: variabilei mesaj i se atribuie valoarea variabilei n. În acest caz, valoarea 12 este stocată în memorie o singură dată - Python folosește memoria destul de economic.

mesaj УHello world! Ф n În al doilea rând, după cum se poate observa din exemplu, variabila mesaj, după ce i-a atribuit valoarea n, și-a schimbat tipul. Nu orice limbaj de programare poate face acest lucru atât de ușor.

h2.4. Nume de variabile și cuvinte cheie După cum a remarcat Frederick P. Brooks, Jr.5, cel mai interesant lucru despre a fi programator este că lucrează cu idei în forma lor cea mai pură: el scrie idei abstracte în limbaje formale, astfel încât acestea să facă munca de altii mai usor...

Pentru a transforma o idee abstractă, nemanifestată în lumea materială, în cod de program, este necesar să identificăm entitățile și acțiunile, să venim cu nume pentru a le gestiona și să urmărim conexiunile dintre ele și proprietățile lor. Probabil ați ghicit că numele entităților cu care lucrează programatorul sunt variabile. Prin urmare, merită să alegeți nume de variabile semnificative.

Numele variabilelor pot avea o lungime arbitrară, dar încercați să alegeți nume care nu sunt nici prea scurte, nici prea lungi - de acest lucru depinde lizibilitatea programului.

Când compuneți nume de variabile în Python, puteți utiliza orice litere, numere latine și semnul _ (subliniere). Sublinierea poate fi folosită pentru a 5 Frederick P. Brooks, Jr. a condus faimosul proiect IBM OS/360;

el este autorul principiului No Silver Bullet (NSB - There is no Silver Bullet, în sensul unui mijloc universal de combatere a proiectelor monstru). Vorbim despre cartea sa The Mythical Man-Month, sau despre cum sunt create sistemele software.

Versiune: 170 Variabile, operații și expresii care separă cuvintele care alcătuiesc numele variabilei: de exemplu, user_name sau full_price. Dar numele variabilelor nu pot începe cu un număr.

>>> 1message = "Bună lume!" Fișier " ", line 1message = "Bună lume!" ^ SyntaxError: sintaxă invalidă >>> price_in_$ = Fișier " ", line price_in_$ = ^ SyntaxError: sintaxă invalidă >>>>", line>

>>> print = "Un mesaj" Fișier " ", line print = "Un mesaj" ^ SyntaxError: sintaxă invalidă Aceasta este o situație familiară, nu-i așa? Să analizăm ce am primit. Am încercat să folosim comanda print ca nume de variabilă și am primit o eroare similară, adică cuvânt>

Într-adevăr, cuvintele>

Versiunea totală în Python este 2.3. 29 de cuvinte cheie sunt rezervate:

Revizie: 170 Variabile, operații și expresii și del for este raise assert elif din lambda return break altfel global nu încercați>

Vă rugăm să rețineți, de asemenea, că interpretul distinge între litere mari și mici, de ex.

mesajul și mesajul vor fi variabile diferite.

Exercițiu. Scrieți un program care verifică dacă interpretul Python face distincția între litere mici și litere mici litere mariîn nume de variabile.

h2.5. Expresii În primul capitol, am întâlnit deja conceptul de expresii într-o formă generală și le-am folosit în program. Să definim acest termen. O expresie este o secvență de unități sintactice care descrie o acțiune elementară într-un limbaj de programare. De exemplu, imprimați „Bună lume!” iar mesajul = n sunt expresii.

Când tastați o expresie pe linia de comandă, interpretul o execută și tipărește rezultatul, dacă există. Rezultatul tipăririi expresiei „Hello world!” este linia: Bună lume!. Expresia de atribuire nu produce nimic.

Scripturile conțin de obicei o secvență de expresii, iar rezultatele expresiilor sunt tipărite pe măsură ce sunt executate. De exemplu, să rulăm un script care conține următoarele expresii:

print x = print x Acest script va scoate următoarele:

Din nou, expresia de atribuire nu produce nicio ieșire.

h2.6. Executarea expresiilor În esență, o expresie este o secvență de valori, variabile și operatori.

Dacă scrieți o expresie, interpretul o va executa și va afișa:

>>> 1 + Valoarea în sine este tratată ca o expresie, la fel ca o variabilă:

Revizie: 170 Variabile, operații și expresii >>> >>> x = >>> x Dar executarea și afișarea rezultatului executării unei expresii nu este exact aceeași:

>>> mesaj = "Bună lume!" >>> mesaj „Bună lume!” >>> tipăriți mesajul Bună lume!

Când Python scoate valoarea unei expresii în modul comandă, folosește același format care este folosit la introducerea acelei valori. De exemplu, atunci când scoateți șiruri de caractere, le include între ghilimele. Comanda print tipărește și valoarea unei expresii, dar în cazul șirurilor de caractere, imprimă conținutul șirului fără ghilimele.

În scripturi, expresiile nu scot deloc nimic decât dacă conțin o instrucțiune print.

De exemplu, următorul script nu scoate o singură linie:

3. „Bună, lume!” 1 + Exercițiu. Modificați scriptul din exemplul anterior, astfel încât să imprime valorile tuturor celor patru expresii.

În modul de comandă, interpretul Python stochează rezultatul ultimei expresii într-o variabilă specială _ (subliniere). Puteți vizualiza rezultatul ultimei expresii și îl puteți utiliza în expresiile dvs.:

>>> 1.25 + 2. >>> print _ 2. >>> 5 + _ 7. Prin urmare, Python este destul de convenabil de utilizat ca un simplu calculator. În secțiunile următoare, vom înțelege ce operațiuni este capabil să efectueze interpretul Python.

Revizia: 170 Variabile, operații și expresii 32.7. Operatori și operanzi Operatorii sunt caractere speciale (sau secvențe de caractere) care reprezintă anumite operații. De exemplu, semnul + denotă adunarea, iar semnul * denotă înmulțirea. Valorile pe care se efectuează operația se numesc operanzi.

Toate expresiile următoare sunt corecte din punctul de vedere al lui Python:

20+32 oră-1 oră*60+minut/60 5**2 (5+9)*(15-7) Sensul celor mai multe dintre ele nu este greu de înțeles. Semnificațiile simbolurilor +, -, * și / în Python sunt aceleași ca în matematică. Parantezele sunt folosite pentru a grupa operațiuni, iar două asteriscuri (**) indică operația de exponențiere.

Dacă operandul este o variabilă, atunci înainte ca expresia să fie evaluată, valoarea indicată de variabilă este înlocuită în locul ei.

Adunarea, scăderea, înmulțirea și exponentiația funcționează în același mod pe care îl cunoaștem, dar împărțirea funcționează puțin diferit. Următorul exemplu ilustrează acest lucru:

>>> minute = >>> minute/ Valoarea variabilei minute este 59;

Rezultatul împărțirii a 59 la 60 ar trebui să fie 0,98333, nu 0. Motivul acestei discrepanțe este că Python efectuează diviziunea întregului.

Când ambii operanzi sunt numere întregi și Python presupune că rezultatul trebuie să fie și un număr întreg. Prin urmare, împărțirea întregului elimină întotdeauna partea fracțională.

Cum să obțineți rezultate fracționate? Este suficient să convertiți forțat unul dintre operanzi într-un număr fracționar:

>>> minut = >>> float(minut) / 0. O altă opțiune:

>>> minut = >>> minut / 60. 0. Dacă unul dintre operanzi aparține tip plutitor, apoi al doilea este convertit automat în acest tip, ca într-unul mai complex.

h2.8. Ordinea operatorilor Majoritatea limbajelor de programare vă permit să grupați mai mulți operatori într-o singură expresie. Acest lucru este convenabil, de exemplu, dacă trebuie să calculați raportul procentual a două cantități:

Revizie: 170 Variabile, operații și expresii >>> print 100 * 20 / 80, "%" 25% Acest exemplu calculează procentul a două numere: 20 și 80. După rezultatul expresiei, este afișat simbolul % - interpretul calculează expresia aritmetică și afișează rezultatul, apoi adaugă linia după virgulă.

Atunci când într-o expresie există mai mult de un operator, succesiunea operațiilor depinde de ordinea în care apar în expresie, precum și de precedența lor. Prioritățile operatorilor din Python coincid complet cu prioritățile operațiilor matematice.

Cea mai mare prioritate este acordată parantezelor, care vă permit să schimbați succesiunea operațiilor. Astfel, operațiile din paranteze se execută mai întâi.

De exemplu, 2*(3-1) este egal cu 4, (1+1)**(5-2) este 8. De asemenea, este convenabil să folosiți paranteze pentru a face expresiile mai ușor de citit, chiar dacă prezența lor în expresia nu afectează rezultatul: (100*20)/80.

Următoarea prioritate este operația de exponențiere, deci 2**1+1 este 3, nu 4, iar expresia 3*1**3 va avea ca rezultat 3, nu 27.

Înmulțirea și împărțirea au aceeași prioritate, mai mare decât adunarea și scăderea. 2*3-1 este egal cu 5, nu 4;

2/3-1 este -1, nu 1 (rezultatul împărțirii întregilor este 2/3=0).

Operatorii cu aceeași prioritate sunt executați de la stânga la dreapta. Deci în expresia 100*20/80 se face mai întâi înmulțirea (expresia devine 2000/80);

apoi se efectuează împărțirea, rezultând o valoare de 25. Dacă operațiile ar fi efectuate de la dreapta la stânga, rezultatul ar fi diferit.

Exercițiu. Schimbați expresia 100*20/80 astfel încât succesiunea operațiilor să fie inversată. Ce rezultat ai obținut după ce ai făcut-o și de ce?

h2.9. Operații simple pe șiruri În general, nu puteți efectua aceleași operații pe șiruri ca și pe numere, așa că următoarele exemple nu vor funcționa:

mesaj-1 "Bună ziua"/123 "Bună ziua"*"lume!" „15”+ Dar operatorul + lucrează cu șiruri, deși denotă o operațiune diferită: concatenarea sau concatenarea șirurilor.

>>> str1 = "Bună ziua" >>> str2 = "lume" >>> printează str1 + str2 + "!" Salut Lume!

Observați că a doua linie începe cu un spațiu. Spațiul este un personaj la fel ca oricare altul.

Operatorul * poate fi folosit și cu șiruri de caractere, dar numai dacă unul dintre operanzi este un număr întreg. În acest caz, operatorul * simbolizează operația de repetare a șirurilor (sau iterația). De exemplu, „Fun”*3 va produce rezultatul „FunFunFun”.

Revizie: 170 Variabile, operații și expresii Puteți urmări analogia dintre operațiile pe numere și operațiunile pe șiruri: la fel cum 4*3 este echivalent cu 4+4+4, „Distracție”*3 este echivalent cu „Distracție”+”Distracție "+"Distracție".

Dar, pe de altă parte, concatenarea și repetarea au câteva diferențe semnificative față de adunare și înmulțire.

Exercițiu. Toate operațiile din matematică sunt clasificate în funcție de proprietățile lor (comutativitate, asociativitate etc.). Ce proprietăți au adunarea și înmulțirea pe care nu le au concatenarea și repetarea?

Nu fi leneș să te uiți într-o carte de referință matematică - înțelegerea proprietăților obiectelor cu care operezi îți va oferi mari avantaje.

Exercițiu. Ce rezultat se va obtine in urma executarii expresiei "hello"+"world"*3?Ce concluzii se pot trage pe baza acestui rezultat?

h2.10. Compoziție În sfârșit, să ne uităm la un alt concept important: compoziția. Fără să observăm, deja l-am întâlnit.

Întreaga lume din jurul nostru este formată din părți componente. De exemplu, casele sunt făcute din cărămizi sau blocuri de construcție, cărămizile, la rândul lor, sunt făcute din granule mici de nisip, iar acestea sunt făcute din molecule și atomi. Pentru a modela fenomenele din lumea înconjurătoare, un instrument de construire a modelelor trebuie, de asemenea, să poată asambla obiecte mici în sisteme, care la rândul lor vor fi combinate în complexe și mai complexe.

Un instrument de modelare (adică descrierea diverse obiecteși situații) pentru un programator sunt limbaje de programare. Toate limbajele de nivel înalt implementează capacitatea de a crea sisteme din elemente mai simple sau compoziție.

De exemplu, știm cum să adunăm două numere și cum să afișam valoarea rezultată.

Deci o putem face într-o singură expresie:

>>> print 17 + De fapt, adăugarea și ieșirea unei valori nu au loc în același timp: mai întâi se evaluează expresia, iar apoi rezultatul este scos. Dar puteți scoate rezultatul oricărei expresii în acest fel, indiferent cât de complexă este.

Expresiile pot fi construite din alte expresii în mai multe moduri.

Luați în considerare acest exemplu:

>>> procent = 100 * 20 / 80;

print percentage În primul rând, expresiile pot fi imbricate una în alta. În special, expresia de atribuire are o astfel de structură încât în ​​stânga semnului de atribuire trebuie să fie numele variabilei căreia îi este atribuit rezultatul evaluării expresiei din dreapta operatorului de atribuire. La rândul său, expresia din partea dreaptă este de asemenea complexă:

calculul se efectuează în ordinea determinată de prioritățile operațiunilor. Operația de împărțire din exemplul nostru ia rezultatul înmulțirii ca prim operand - acesta este, de asemenea, un exemplu de expresii de imbricare.

Revizie: 170 Variabile, operații și expresii A doua opțiune pentru aranjarea expresiilor este următoarea. În exemplu, două expresii (expresia de atribuire și expresia pentru afișarea valorii variabilei procentuale) sunt separate prin punct și virgulă. Aceste expresii sunt executate una după alta. În general, orice program este o secvență de expresii. Dacă expresiile sunt situate pe linii separate, atunci nu este necesar să puneți un punct și virgulă la sfârșitul fiecărei expresii: în în acest caz, Separatorul de expresie este terminatorul de linie. Această regulă se aplică pentru Python, dar în C++ și Pascal, expresiile trebuie să se termine cu punct și virgulă.

Mai târziu veți vedea că compoziția poate fi folosită pentru a combina orice unități sintactice și expresii, inclusiv apeluri de subrutine.

Exercițiu. Încercați să rulați comanda pe linia de comandă a interpretului Python: 100 * 20 / 80 = procent. Ce rezultat ai obținut și de ce?

Revizie: 170 Funcții Capitolul 3. Funcții h3.1. Subprograme În vremea programării adreselor, sa observat că unele părți ale unui program pot fi utilizate de mai multe ori dacă valoarea unui parametru este modificată. De exemplu, un program poate calcula o valoare folosind o anumită formulă de mai multe ori, dar de fiecare dată valorile introduse în formulă se schimbă.

Programatorii au început să generalizeze soluțiile la subprobleme mici și repetate și să acceseze părți ale programului cu aceste soluții acolo unde era necesar. Programele au încetat să mai fie liniare, așa că au început să semene cu un pachet de paste, pentru că... a constat în lanțuri de instrucțiuni, iar comutarea între ele a fost efectuată folosind comenzi de tranziții condiționate sau necondiționate și etichete care defineau începutul fiecărei paste.

Într-o oarecare măsură, acest lucru a complicat semnificativ procesul de depanare și extindere a funcționalității programelor, dar, pe de altă parte, a deschis noi oportunități pentru programatori: în primul rând, programele au început să ocupe mai puțin spațiu și au devenit mai ușor de navigat;

în al doilea rând, corectarea erorilor a devenit mult mai ușoară, deoarece programatorii nu mai trebuiau să caute toate părțile codului care au fost repetate cu modificări minore pentru a remedia o eroare găsită într-una dintre ele - a fost suficient să remedieze acest defect într-un singur loc.

Idee reutilizare codul este foarte important în programare, deoarece fără ea, sprijinul și dezvoltarea modernului produse software Având în vedere complexitatea lor, aceasta reprezintă o sarcină aproape imposibilă. Cel puțin, costul deținerii de programe ar fi mult mai mare fără el, iar utilizarea lor ar deveni neprofitabilă în majoritatea cazurilor.

Limbajele de programare structurate implementează conceptul de reutilizare a codului în mai multe moduri diferite. Una dintre ele este scrierea subrutinelor.

Subrutinele reprezintă același set de instrucțiuni ca și programul în sine, dar rezolvă probleme mai puțin complexe. Subrutinele pot primi un anumit set de parametri ca intrare și pot returna o anumită valoare ca ieșire.

ÎN limbajul Pascal Există două tipuri de subrutine: proceduri și funcții. În Python, precum și în C++, subrutinele sunt implementate într-o formă mai generală, deci nu există o astfel de diviziune - în aceste limbaje există doar funcții.

Uneori, subrutinele sunt grupate în așa-numitele module - fișiere speciale care stochează o descriere a acestor funcții, care pot fi conectate și utilizate în orice parte a proiectului sau chiar în alte proiecte. Cum să creați și să conectați module în Python este descris în detaliu în Anexa B. Dar, deocamdată, să începem să stăpânim funcțiile.

Revizie: 170 Funcții 3.2. Apeluri de funcții Am întâlnit deja apeluri de funcție atunci când definim și convertim tipuri de valori și variabile:

>>> type("Hello world!") >>> int("32") Funcția care determină tipul unei valori sau variabile se numește tip();

Valoarea sau variabila care trebuie convertită trebuie să vină după numele funcției din paranteze - acesta se numește argumentul funcției. După cum puteți vedea din exemplu, funcția int() este apelată într-un mod similar.

Astfel, pentru a apela o funcție, trebuie doar să-i tastați numele și să enumerați parametrii în paranteze, iar dacă nu trebuie să treceți parametri, atunci nu trebuie să scrieți nimic în paranteze. De exemplu, în funcția str() primul parametru este opțional, adică. poate fi omis:

>>> str() "" 3.3. Help System Python are multe funcții definite care vă permit să rezolvați diverse probleme.

Unele dintre ele sunt grupate după scop și plasate în module separate. În secțiunea următoare, vom învăța cum să importam module și să folosim funcții din ele, dar mai întâi ne vom da seama cum să stabilim pentru ce este o anumită funcție.

Această abilitate vă va fi foarte utilă în viitor, deoarece... Este adesea destul de dificil să ghiciți scopul funcțiilor după numele lor.

Pentru a simplifica munca programatorului, Python oferă un document variabil încorporat (începe și se termină cu perechi de caractere de subliniere), care stochează de obicei informații de referință minime:

>>> print str.doc str(obiect) -> string Returnează o reprezentare frumoasă în șir a obiectului.

Dacă argumentul este un șir, valoarea returnată este același obiect.

>>> Funcția str() s-a prezentat și a afișat informații despre ea însăși: ce parametri ia, ce tip de valoare returnează și a descris pe scurt ce face.

Începând cu versiunea 2.2, Python a introdus un sistem de ajutor, implementat sub forma funcției help(). Această funcție ia numele oricărui obiect (inclusiv un modul sau o funcție) ca parametru și afișează informații de ajutor despre acesta.

Exercițiu. Verifică informații generale funcțiile str(). Vă rugăm să rețineți că funcția help() nu va funcționa în versiunile Python sub 2.2. Ieșiți din sistemul de ajutor folosind tasta [Q].

Revizie: 170 Funcții 3.4. Importul de module și funcții matematice Pe lângă cele mai simple operații pe numere, pe care le-am luat deja în considerare, Python este capabil să calculeze valorile celor mai complexe functii matematice:

trigonometrice, logaritmice etc. Pentru a accesa aceste funcții, trebuie să importați sau să conectați un modul special în care sunt stocate definițiile acestor funcții. Puteți face acest lucru folosind următoarele instrucțiuni:

>>> import math >>> Această comandă importă modulul matematic. Python acceptă importul parțial de module (puteți citi mai multe despre acest lucru în Anexa B), dar încă nu avem nevoie de el.

Deci, am importat un modul cu o descriere a funcțiilor matematice și acum vom încerca să apelăm una dintre ele din el. Mai întâi, să determinăm ce funcții și constante sunt definite în modul:

>>> dir(math) ["doc", "file", "name", "acos", "asin", "atan", "atan2", "ceil", "cos", "cosh", "e „, „exp”, „fabs”, „floor”, „fmod”, „frexp”, „hypot”, „ldexp”, „log”, „log10”, „modf”, „pi”, „pow”, "sin", "sinh", "sqrt", "tan", "tanh"] >>> Ca urmare a executării acestei comenzi, interpretul a tipărit toate numele definite în acest modul. Printre acestea se numără variabila doc. Pentru a accesa o variabilă sau o funcție dintr-un modul importat, trebuie să specificați numele acesteia, să puneți un punct și să scrieți numele cerut:

>>> print math.doc Acest modul este întotdeauna disponibil. Oferă acces la funcțiile matematice definite de standardul C.

>>> print math.pi 3. >>> decibel = math.log10(17.0) Prima linie a exemplului imprimă o descriere a modulului;

al patrulea este valoarea constantei, iar al șaselea calculează valoarea logaritmului 17 în baza 10. Pe lângă logaritmul zecimal, modulul definește și un logaritm natural (adică cu baza e = 2,7182818284590451): math.log() . Inca un exemplu:

>>> înălțime = math.sin(45) >>> înălțimea de tipărire 0. Dacă ați studiat trigonometrie, probabil vă amintiți că sinusul de 45 de grade este egal cu rădăcina pătrată a lui 2 împărțită la 2. Să verificăm rezultatul calculul funcției:

Revizie: 170 Funcții >>> math.sqrt(2) / 2. 0. Rezultatele au fost diferite. De ce? Au făcut o greșeală dezvoltatorii? Este foarte probabil ca nimeni să nu fie imun la greșeli. Dar, înainte de a scrie un raport de eroare și de a-l trimite dezvoltatorilor, să aruncăm o privire la ajutorul pentru această funcție:

>>> help(math.sin) Ajutor pentru funcția încorporată sin:

sin(...) sin(x) Returnează sinusul lui x (măsurat în radiani).

(END) Din ajutor puteți vedea că funcțiile trigonometrice iau ca parametru valoarea unghiului în radiani. Apăsați [Q] pentru a părăsi sistemul de ajutor cu un sentiment de mândrie: acum știm cum funcționează funcția math.sin();

Să convertim în radiani:

>>> grade = >>> unghi = grade * math.pi / 180. >>> inaltime = math.sin(unghi) >>> inaltime de tiparire 0. Acum rezultatele sunt aceleasi - totul este corect.

Exercițiu. Rulați următoarele instrucțiuni pe linia de comandă a interpretului Python versiunea 2.2 sau mai recentă:

>>> import matematică >>> imprimare math.doc...

>>> ajutor (matematică) Citiți descrierea modulului și funcțiile acestuia. Tot ajutorul nu va încadra pe ecran, dar puteți derula textul folosind tastele săgeți. Ieșiți din sistemul de ajutor folosind tasta [Q].

Dacă doriți, vă puteți juca cu aceste funcții scriind câteva programe simple folosindu-le. Unde pot fi folosite?

h3.5. Compoziție În al doilea capitol ne-am uitat deja la compoziție în raport cu operatii aritmeticeși expresii simple. Dar compoziția vă permite și să combinați apeluri de funcții: o funcție poate lua ca parametru orice expresie care returnează o valoare care se încadrează în sfera definiției sale;

pe de altă parte, un apel de funcție (mai precis, rezultatul execuției sale) poate fi folosit ca operand:

>>> x = math.sin(math.asin(math.sqrt(2) / 2.0) + math.pi / 2) >>> print x 0. >>> Să ne uităm la acest exemplu. Prima operație pe care o întâlnește analizatorul atunci când parsează această expresie este atribuirea valorii expresiei din dreapta semnului = variabilei x. Înainte de atribuire, interpretul trebuie să evalueze valoarea acestei expresii, i.e. calculați sinusul valorii expresiei math.asin(math.sqrt (2) / 2.0) + math.pi / 2, care, la rândul său, este egal cu suma valorilor subexpresiilor math.asin(math. .sqrt(2) / 2.0) și math.pi / 2. Primul dintre ele se calculează într-un mod similar: mai întâi se calculează valoarea expresiei din paranteze, apoi se apelează funcția math.asin(), la care se trece ca argument expresia rezultată. A doua subexpresie este /2. După ce a calculat suma acestor două subexpresii, interpretul transmite valoarea rezultată ca argument funcției math.sin() și atribuie rezultatul variabilei x.

Scrieți un program care calculează rădăcinile ecuației pătratice ax2+bx+c=0, a0 din coeficienții acestei ecuații. Coeficienții trebuie introduși la începutul programului în variabilele a, b și c.

Încercați să setați variabilele a, b și c la 1, 0 și respectiv -1. Programul ar trebui să scoată valorile 1.0 și -1.0. Verificați dacă rezultatele sunt cele așteptate.

Când experimentați cu alți coeficienți, aveți în vedere că există ecuații care nu au soluții (astfel de ecuații au un discriminant mai mic decât zero), așa că nu vă alarmați dacă în programul dvs. apare o eroare de formă: ValueError: math domain error. Puțin mai târziu vom afla cum să evităm acest lucru.

h3.6. Crearea de funcții Până acum am folosit funcțiile și funcțiile încorporate ale lui Python din modulele care vin cu Python. Dar puterea limbajelor de programare structurată este că ne putem crea propriile funcții, iar acest lucru se face destul de simplu. ÎN programare structurată O funcție este o secvență numită de expresii care efectuează o operație necesară. Python are un operator special de definire a funcției cu următoarea sintaxă:

def FUNCTION_NAME(PARAMETER_LIST):

SECVENȚA DE EXPRESIUNI Regulile de alegere a numelor de funcții sunt complet similare cu regulile de alegere a numelor de variabile descrise în capitolul anterior. Lista de parametri definește un set de valori care pot fi transmise funcției ca date de intrare - parametrii sunt listați separați prin virgule. Prima linie a definiției se numește de obicei antetul funcției, notat cuvânt cheie def (din engleza define - a determina). Un antet de funcție în Python se termină cu două puncte. Poate fi urmată de orice număr de expresii, dar acestea trebuie scrise offset de la începutul liniei. Pentru Revizie: 170 Funcții ale unui astfel de offset, puteți utiliza unul sau mai multe spații, dar, poate, cel mai convenabil este să utilizați un caracter de tabulație (cheie) în loc de spații. Să scriem și să testăm prima noastră funcție;

pentru a finaliza secvența de expresii care alcătuiesc corpul funcției, trebuie doar să apăsați din nou tasta (într-un editor care acceptă indentarea automată, va trebui să apăsați și pentru a elimina indentarea adăugată automat):

>>> def printAnything(obiect):

Imprimare obiect...

>>> printAnything("Un șir") Un șir >>> număr = >>> printAnything(număr) În primele două rânduri ale exemplului, am definit funcția PrintAnything(), care tipărește obiectul transmis ca parametru. Putem trece un șir sau un număr acestei funcții, ceea ce am încercat să facem în rândurile a patra și a șaptea din exemplu.

Rezultatele obținute au coincis cu cele așteptate, dar să nu ne oprim asupra acestui lucru și să facem un alt experiment.

Ce se întâmplă dacă treceți numele funcției ca parametru? Să apelăm PrintAnything(), indicând numele său în paranteze:

>>> printAnything(printAnything) >>> Python a tipărit informații despre funcție: numele acesteia și adresa din memorie unde este stocată! În acest caz, adresa este 0x80d7554, dar această adresă de pe computer poate fi diferită. Acum să deschidem un editor de text și să scriem un program ca acesta:

def printHello():

tipăriți „Bună ziua!” def runFunction(nume_funcție):

function_name() runFunction(printHello) Salvați programul într-un fișier numit prog2.py și rulați-l din linia de comandă (în sistemul de operare Windows, faceți dublu clic pe butonul stâng al mouse-ului pe pictograma acestui fișier6):

$ python prog2.py Bună ziua!

6 Nu uitați să scrieți o comandă pentru a aștepta apăsarea unei taste în ultima linie a programului, așa cum este descris în secțiunea Rularea programelor scrise în Python (vezi Introducere).

Revizie: 170 Funcții Probabil că ați înțeles deja ce a făcut Python când am apelat funcția runFunction() și i-am transmis numele funcției printHello() ca parametru: a înlocuit funcția_name cu valoarea parametrului transmis și astfel a numit printHello( ) funcție. Este un limbaj de programare rar să aibă acest tip de flexibilitate. În C++ sau Pascal, acest lucru se face într-un mod departe de a fi banal.

De asemenea, rețineți că nu puteți apela o funcție înainte de a fi definită - aceasta va arunca o excepție.

Exercițiu. Convertiți programul pentru calcularea rădăcinilor unei ecuații pătratice în funcția printRoots(). Parametrii acestei funcții trebuie să fie coeficienții polinomului pătratic: a, b și c. După ce a calculat rădăcinile ecuației, funcția ar trebui să le imprime.

Exercițiu. Scrieți o funcție care calculează distanța dintre două puncte dintr-un plan (sunt date coordonatele (x1, y1) și (x2, y2)).

distanta x1, y1, x2, y2= x2 -x12 y2 - y 3.7. Parametri și argumente Până acum am învățat cum să ne creăm propriile funcții și să facem diferența între definițiile de funcții și apelurile de funcții. Acum să definim terminologia: care este diferența dintre un parametru de funcție și argumentul său? Există o mare diferență, dar s-ar putea să nu o observi.

Parametrii funcției sunt o listă de variabile cărora li se atribuie valorile transmise la apelarea acestei funcție. Și valorile transmise însele sunt numite argumente. În corpul său, o funcție operează cu parametri, dar nu cu argumente. Să ne uităm la un exemplu din secțiunea anterioară:

>>> def printAnything(obiect):

Imprimare obiect...

>>> printAnything("Un șir") Un șir >>> număr = >>> printAnything(număr) Aici obiectul variabil este parametrul, iar șirul "Un șir" și numărul variabilei sunt argumentele. Astfel, este corect să spunem transmiteți un argument sau treceți o valoare ca parametru, dar nu transmiteți un parametru funcției. Încercați să nu confundați aceste concepte.

h3.8. Variabile locale Să revenim la funcția PrintRoots() pentru găsirea rădăcinilor unei ecuații pătratice. Arata cam asa:

def printRoots(a, b, c):

Revizie: 170 Funcții D = b**2 - 4 * a * c import math x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * un print „x1 =", x1, "\nx2 =", x Secvența de caractere \n din ultima linie a corpului funcției indică comenzii de imprimare să meargă la linie nouă. Corpul funcției definește trei variabile: D, x și x2. Astfel de variabile sunt numite locale, deoarece ele pot fi accesate numai în cadrul corpului funcției însuși. După ce funcția este finalizată, acestea sunt șterse din memorie. Următorul program poate ilustra acest lucru:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import matematică x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print " x1 =", x1, "\nx2 =", x printRoots(1.0, 0, -1.0) print D Dacă îl rulați, interpretul va afișa imediat o eroare ca aceasta după finalizarea funcției PrintRoots():

$ python prog5.py x1 = 1. x2 = -1. Traceback (cel mai recent apel ultimul):

Fișierul „prog5.py”, rândul 12, în ?

print D NameError: numele „D” este nedefinit De ce a fost ales acest comportament? Cum crezi? Să ne modificăm programul astfel:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import math print "În funcția D = ", D x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt( D)) / 2 * a print "x1 =", x1, "\nx2 =", x Revizia: 170 Funcții D = "test" print "Înainte de a apela funcția D = ", D printRoots(1.0, 0, -1.0) print "După apelul funcției D = ", D Să rulăm programul și să analizăm rezultatul.

$ python prog5.py Înainte de apelul funcției D = test În funcția D = 4. x1 = 1. x2 = -1. După apelul funcției D = test Deci, după definirea funcției printRoots(), am atribuit variabilei D valoarea „test” și am verificat rezultatul: a fost tipărit șirul „test”. Apoi au numit funcția printRoots(), în corpul căreia, după atribuirea rezultatului calculului formulei discriminante variabilei D, se afișează și valoarea variabilei D: 4.0. După finalizarea funcției, imprimăm din nou valoarea variabilei D: de data aceasta valoarea atribuită este din nou egală cu șirul „test”.

De fapt, D în programul principal și D în corpul funcției printRoots() sunt două variabile diferite. Puteți verifica acest lucru modificând ușor programul nostru.

Să folosim funcția id(). Returnează adresa unui obiect din memorie. Programul modificat va arăta cam așa:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import math print "În funcția D = ", D, "\nAdresa:", id(D), "\n" x1 = (-b + math.sqrt(D )) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print "x1 =", x1, "\nx2 =", x D = "test" print "Înainte de apelul funcției D = ", D, "\nAdresa:", id(D), "\n" printRoots(1.0, 0, -1.0) print "După apelul funcției D = ", D, "\nAdresa:", id(D), „\n” Rezultatul programului va fi următorul:

$ python prog5.py Înainte de apelul funcției D = test Adresă: Revizie: 170 Funcții În funcția D = 4. Adresă: x1 = 1. x2 = -1. După apelul de funcție D = Adresa de test: Pe computerul dvs., adresele pot fi diferite, dar puteți trage aceleași concluzii: adresele D din programul principal și D din corpul funcției printRoots() sunt diferite.

Q.E.D.

Exercițiu. Parametrii funcției sunt variabile locale?

h3.9. Fluxul de execuție După cum sa menționat deja, odată cu apariția funcțiilor (și a procedurilor), programele au încetat să mai fie liniare, în legătură cu aceasta, a apărut conceptul de flux de execuție - secvența de execuție a instrucțiunilor care alcătuiesc programul.

Execuția unui program scris în Python începe întotdeauna cu prima expresie, iar expresiile ulterioare sunt executate una după alta de sus în jos. Mai mult, definițiile funcțiilor nu afectează în niciun fel fluxul de execuție, deoarece Corpul oricărei funcții nu este executat până când nu este apelată funcția corespunzătoare.

Când interpretul, analizând codul sursă, ajunge la un apel de funcție, acesta, după ce a calculat valorile argumentelor, începe să execute corpul funcției apelate și numai după finalizarea acesteia trece la analiza următoarei instrucțiuni.

Totul este destul de simplu, deși urmărirea fluxului de execuție în programe complexe se dovedește adesea a fi o sarcină netrivială, deoarece în corpul oricărei funcții se poate apela o altă funcție, care poate conține și apeluri de funcție în corpul ei etc.

Cu toate acestea, interpretul Python își amintește de unde a fost apelată fiecare funcție și, mai devreme sau mai târziu, dacă nu sunt aruncate excepții în timpul execuției, va reveni la apelul inițial pentru a trece la următoarea instrucțiune.

Deci, imaginați-vă că avem trei funcții: f1(), f2() și f3(). Mai mult, se numesc unul pe altul astfel:

print "f1() începe" print "Bună lume!" print "f1() se termină" def f2():

print "f2() incepe" f1() Revizia: 170 Functii print "f2() se termina" def f3():

print "f3() începe" f2() print "f3() se termină" print "Începe programul principal" f3() print "Programul principal se termină" Pentru a urmări secvența operațiilor, am adăugat comenzi care vor semnala când se termină începe și fiecare funcție se încheie.

Deci, hai să rulăm programul și să vedem ce avem:

$ python prog6.py Programul principal începe f3() începe f2() începe f1() începe Bună lume!

f1() se termină f2() se termină f3() se termină Programul principal se termină Să analizăm rezultatul. După cum sa menționat deja, definițiile funcțiilor nu afectează în niciun fel execuția programului principal. Excepția este atunci când interpretul întâlnește o eroare de sintaxă în corpul unei funcții: chiar dacă nu este încă timpul să o execute, va imprima un mesaj de eroare și va ieși.

Programul principal începe prin afișarea unui mesaj despre pornirea acestuia, apoi este apelată funcția f3(), care, atunci când este prezentată, apelează funcția f2(). Aceasta, la rândul său, face același lucru, apelând f1(). f1() afișează, de asemenea, un mesaj despre începerea sa, apoi un salut de testare către lume și un mesaj despre finalizarea acestuia. Firul de execuție revine în corpul funcției f2() în punctul în care a fost apelat f1(), după care este executată următoarea instrucțiune, imprimând un mesaj care indică faptul că funcția f2() și-a încheiat activitatea. După cum probabil ați ghicit, fluxul de execuție revine în corpul funcției f3() și, după finalizarea acesteia, în programul principal.

h3.10. Diagrame de stivă Pentru claritate, puteți desena așa-numitele diagrame de stivă. Se numesc așa dintr-un motiv: reprezintă o stivă de apeluri.

O stivă este o structură de date specială care seamănă cu o stivă de plăci, deoarece interacțiunea cu stiva se realizează conform unei reguli speciale LIFO (Last In First Revision: 170 Out functions - last in, first out). Revenind la analogia unui teanc de farfurii, stivuim farfuriile una peste alta si le ridicam incepand de sus. Puțin mai târziu, vom învăța cum să modelăm o stivă și alte structuri de date care sunt adesea folosite pentru a rezolva diverse sarcini, dar deocamdată, limitându-ne la o înțelegere intuitivă a stivei, să desenăm o diagramă stivă pentru exemplul din secțiunea anterioară.

F1() începe f1() se termină f1() Bună lume!

f2() începe f2() se termină f2() f3() începe f3() se termină f3() Programul principal începe Programul principal se termină main În această diagramă, fluxul de execuție este indicat prin săgeți, subprogramele sunt indicate prin blocuri dreptunghiulare;

Liniile ieșite de program sunt adăugate la dreapta și la stânga diagramei stivei. În partea de jos a stivei se află programul principal (notat principal);

În consecință, nu se poate finaliza până când toate funcțiile care se află deasupra lui în stiva de apeluri nu sunt finalizate. Astfel, utilizarea unei stive pentru a urmări fluxul de execuție este soluția cea mai naturală și simplă.

În timpul execuției programului, stiva de apeluri poate crește și se poate goli de multe ori.

Când apare o excepție într-una dintre funcții, este adesea destul de dificil de înțeles în ce condiții (sau în ce set de parametri) a avut loc defecțiunea, deoarece Aceeași funcție poate fi apelată de mai multe ori din diferite locuri din program. Prin urmare, pentru a facilita procesul de depanare, interpretul Python afișează nu numai numărul liniei în care a apărut excepția, ci și întreaga stivă de apeluri la momentul în care a apărut excepția.

Să modificăm puțin programul nostru, astfel încât o excepție de diviziune cu zero să fie aruncată în funcția f1(), înlocuind ieșirea de salut la pace cu expresia a = 1/0:

printează „f1() începe” a = 1/ printează „f1() se termină”...

Acum hai să rulăm acest program:

$ python prog6.py Programul principal începe f3() începe f2() începe f1() începe Traceback (cel mai recent apel ultimul):

Versiune: 170 Fișier de funcții „prog6.py”, linia 17, în ?

f3() Fișier „prog6.py”, linia 13, în f f2() Fișierul „prog6.py”, linia 8, în f f1() Fișierul „prog6.py”, linia 3, în f a = 1/ ZeroDivisionError: Diviziune întreagă sau modulo cu zero După mesajul despre începerea execuției funcției f1(), interpretul a afișat așa-numitul traceback (programatorii vorbitori de limbă rusă spun de obicei traceback sau pur și simplu trace). Traceback conține nu numai numele funcțiilor din stiva de apeluri, ci și numerele de linie de la care a fost efectuat fiecare apel. Pe lângă numere, este indicat și numele fișierului cu programul, deoarece proiectul poate conține mai mult de un modul. Deci, devine mult mai ușor să găsiți și să remediați eroarea.

h3.11. Funcții care returnează un rezultat În sfârșit, să ne familiarizăm cu o altă caracteristică importantă a funcțiilor. Nu este dificil să ne imaginăm o situație în care rezultatele unei funcții pot fi necesare pentru funcționarea ulterioară a programului. Dar după ce funcția își finalizează activitatea, toate variabilele care au fost inițializate în corpul său sunt distruse, deoarece sunt locale.

Prin urmare, dacă este necesar să returnați rezultatul unei funcții la subrutina din care a fost apelată, comanda return este folosită pentru procesarea ulterioară. Arata cam asa:

>>> def getSum(x,y):

Z = x + y... returnează z...

>>> print getSum(1,3) >>> După cum puteți vedea, valoarea returnată de funcție este percepută de interpret ca rezultat al expresiei care apelează această funcție.

În Python, funcțiile sunt capabile să returneze mai multe valori în același timp7. De exemplu, luați funcția de calculare a rădăcinilor unei ecuații pătratice:

>>> def PrintRoots(a, b, c):

D = b**2 - 4 * a * c... import matematică 7 Apropo, în Pascal și C++ este imposibil să returnați mai multe valori dintr-o funcție simultan folosind instrumente standard. Aceasta este o altă comoditate pe care o oferă Python.

Revizie: 170 Funcții... x1 = (-b + math.sqrt(D)) / 2 * a... x2 = (-b - math.sqrt(D)) / 2 * a... return x1, X...

>>> print PrintRoots(1.0, 0, -1.0) (1.0, -1.0) În plus, putem atribui rezultatele funcției mai multor variabile simultan:

>>> x1, x2 = PrintRoots(1.0, 0, -1.0) >>> print "x1 =", x1, "\nx2 =", x x1 = 1. x2 = -1. >>> Cel mai probabil, ați ghicit deja că funcțiile încorporate ale lui Python returnează valori exact în același mod.

Revizie: 170 Grafică pe computer Capitolul 4. Grafică pe computer /* modul țestoasă*/ Revizie: 170 Expresii logice, condiții și recursivitate Capitolul 5. Expresii logice, condiții și recursivitate h5.1. Comentarii în programe Orice prost poate scrie un program pe care compilatorul îl va înțelege. Programatorii buni scriu programe pe care alți programatori le pot înțelege.

Martin Fowler, „Refactoring” Pe măsură ce programele tale devin mai mari, mai devreme sau mai târziu te vei întâlni cu o singură problemă: vor deveni mai greu de citit. În mod ideal, un program ar trebui să fie citit la fel de ușor ca și cum ar fi fost scris într-un limbaj natural, dar, pe de o parte, limbile naturale încă nu au o formă formală atât de clară pentru descrierea obiectelor și proceselor, iar pe de altă parte , formalizarea excesivă duce adesea la descrieri de complicații ale lucrurilor simple. Prin urmare, pentru a îmbunătăți înțelegerea codului, este util să îl adnotăm în limbaj natural, iar majoritatea limbajelor de programare, fără a exclude Python, oferă această caracteristică.

Jokerii spun că după o zi grea la computer, un programator tipic se duce acasă, se așează la computer și astfel se relaxează. Dar adevărul este de fapt mult mai rău decât această glumă: mulți dintre noi, când venim acasă de la serviciu, dedicăm timpul rămas înainte de culcare... programării microcontrolerelor. 🙂 Oamenii obișnuiți nu înțeleg, dar Arduino, Teensy sau ESP sunt într-adevăr un hobby foarte bun. Singurul lor dezavantaj este necesitatea de a programa la un nivel destul de scăzut, dacă nu în Assembler, atunci în Arduino C sau Lua. Dar acum Python a apărut în lista de limbi pentru microcontrolere. Mai precis, MicroPython. În acest articol voi încerca să-i demonstrez capabilitățile pe cât posibil.

De unde a început totul?

Totul a început cu o campanie Kickstarter. Damien George, un dezvoltator din Anglia, a proiectat o placă de microcontroler special pentru Python. Și campania a luat startul. Suma anunțată inițial a fost de 15.000 de lire sterline, dar a ajuns să strângă de șase ori și jumătate această sumă - 97.803 de lire sterline.

De ce este mai bună această placă?

Putere - MP este mai puternic în comparație cu Microcontroler Arduino, aici sunt folosite procesoare ARM pe 32 de biți precum STM32F405 (168 MHz Cortex-M4, 1 MB memorie flash, 192 KB RAM).

Ușurință în utilizare - limbajul MicroPython se bazează pe Python, dar este oarecum simplificat, astfel încât comenzile pentru controlul senzorilor și motoarelor pot fi scrise în doar câteva rânduri.

Fără compilator - pentru a rula un program pe platforma MicroPython, nu este nevoie să instalați software suplimentar pe computer. Placa este detectată de computer ca pe o unitate USB obișnuită - trebuie doar să aruncați un fișier text cu cod pe ea și să reporniți, programul va începe imediat să se execute. Pentru comoditate, puteți instala în continuare un emulator de terminal pe computer, ceea ce face posibilă introducerea elementelor de cod de pe computer direct pe platformă. Dacă îl utilizați, nici măcar nu va trebui să reporniți placa pentru a verifica programul; fiecare linie va fi imediat executată de microcontroler.

Cost redus - în comparație cu Raspberry Pi, platforma PyBoard este oarecum mai ieftină și, prin urmare, mai accesibilă.

• Platformă deschisă - la fel ca Arduino, PyBoard este o platformă deschisă, toate circuitele vor fi disponibile public, ceea ce înseamnă că puteți proiecta și crea singur o astfel de placă, în funcție de nevoile dvs.

Deci ce, doar taxa oficială?

Nu. Cu toate avantajele sale, PyBoard (așa este numele plăcii de la dezvoltatorul MicroPython) este o plăcere destul de costisitoare. Dar datorită platformei deschise, multe plăci populare pot rula deja MicroPython, construit special pentru acesta. În prezent există versiuni:

• pentru BBC micro:bit - dezvoltare britanică, poziționată ca ajutor oficial de predare pentru lecțiile de informatică;
• Circuit Playground Express este o dezvoltare a celebrei companii Adafruit. Aceasta este o placă care include LED-uri, senzori, pini și butoane. În mod implicit, este programabil folosind Microsoft MakeCode pentru Adafruit. Este un editor de „cod” bazat pe blocuri (ca Scratch);
• ESP8266/ESP32 este una dintre cele mai populare plăci pentru dezvoltarea IoT. Ar putea fi programat în Arduino C și Lua. Astăzi vom încerca să instalăm MicroPython pe el.

Pregătirea de muncă

Înainte de a scrie programe, trebuie să configurați placa, să instalați firmware-ul pe ea și să instalați programele necesare pe computer.

INFO

Toate exemplele au fost verificate și testate pe următoarele echipamente:

• Placa NodeMCU ESP8266-12E;
• driver de motor L293D;
• Afișaj I2C 0,96″ 128 × 64;
• Adafruit NeoPixel Ring 16.

Firmware-ul controlerului

Pentru a flash firmware-ul plăcii, vom avea nevoie de Python. Mai exact, nici măcar el, ci utilitatea esptool, distribuită folosind pip. Dacă aveți instalat Python (indiferent de versiune), deschideți un terminal (linie de comandă) și tastați:

Pip instalează esptool

După instalarea esptool, trebuie să faceți două lucruri. Primul lucru este să descărcați versiunea de firmware pentru ESP8266 de pe site-ul oficial. Și în al doilea rând, determinați adresa plăcii atunci când vă conectați la un computer. Cel mai simplu mod este să vă conectați la computer, să deschideți Arduino IDE și să vă uitați la adresa din lista de porturi.

Pentru a fi mai ușor de înțeles, adresa plăcii din exemplu va fi /dev/ttyUSB0, iar fișierul firmware este redenumit esp8266.bin și se află pe desktop.

Deschideți un terminal (linie de comandă) și accesați desktop:

Desktop CD

Formatarea memoriei flash a plăcii:

Esptool.py --port /dev/ttyUSB0 erase_flash

Dacă apar erori în timpul formatării, atunci trebuie să activați manual modul firmware. Apăsăm butoanele de resetare și flash de pe placă. Apoi eliberăm resetarea și, fără a elibera flash, încercăm să formatăm din nou.

Și încărcați firmware-ul pe placă:

Esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 esp8266.bin

Interacțiunea cu bordul

Toată interacțiunea cu placa poate avea loc în mai multe moduri:

• prin portul serial;
• printr-un interpret web.

Când se conectează prin portul serial, utilizatorul vede un interpret Python aproape obișnuit în terminalul său (în linia de comandă).

Pentru conectarea prin serial există diferite programe. Pentru Windows puteți folosi PuTTY sau TeraTerm. Pentru Linux - picocom sau minicom. Ca soluție multiplatformă, puteți utiliza monitorul portului Arduino IDE. Principalul lucru este să identificați corect portul și să specificați rata de transfer de date de 115200.

Picocom /dev/ttyUSB0 -b115200

În plus, mai multe programe au fost deja create și postate pe GitHub pentru a facilita dezvoltarea, de exemplu EsPy. Pe lângă portul serial, acesta include un editor de fișiere Python cu evidențiere de sintaxă, precum și un manager de fișiere care vă permite să descărcați și să încărcați fișiere în ESP.

Dar toate metodele de mai sus sunt bune doar atunci când avem posibilitatea de a ne conecta direct la dispozitiv folosind un cablu. Dar placa poate fi integrată în orice dispozitiv, iar dezasamblarea ei doar pentru a actualiza programul este cumva suboptimă. Probabil, pentru astfel de cazuri a fost creat WebREPL. Aceasta este o modalitate de a interacționa cu placa printr-un browser de pe orice dispozitiv aflat în aceeași rețea locală, dacă placa nu are un IP static, și de pe orice computer, dacă un astfel de IP este prezent. Să setăm WebREPL. Pentru a face acest lucru, conectați-vă la placă și formați

Importați webrepl_setup

Apare un mesaj despre starea acționării automate WebREPL și vă întreabă dacă activați sau dezactivați rularea automată a acestuia.

Stare de pornire automată a demonului WebREPL: activat Doriți să-l (E)activați sau (D)dezactivați rularea la pornire? (Linie goală pentru a ieși) >

După introducerea q, apare un mesaj despre setarea unei parole de acces:

Pentru a activa WebREPL, trebuie să setați parola pentru it Parolă nouă (4-9 caractere):

Îl introducem și apoi confirmăm. Acum, după o repornire, ne vom putea conecta la placă prin Wi-Fi.

Deoarece nu am configurat placa să se conecteze la rețeaua Wi-Fi, aceasta funcționează ca punct de acces. Numele rețelei Wi-Fi este MicroPython-******, unde am înlocuit o parte din adresa MAC cu asteriscuri. Ne conectăm la el (parolă - micropythoN).

Piton,

Dezvoltare site

Dacă căutați un răspuns la întrebarea: „Ce limbaj de programare să alegeți mai întâi”, atunci în aproximativ 90% din cazuri vi se va oferi Python - ca cel mai ușor limbaj de învățat. Și este evident că un anumit număr de oameni care nu au învățat programarea înainte vor alege Python din cauza acestor recomandări. Și aici avem o problemă, care va fi discutată mai jos. Desigur, cu o descriere a modului în care am ajuns la această viață.

Despre mine

Chiar și în anii studenției, mi-am dat seama că specialitatea mea nu era atât de roz pe cât mi se părea la 18 ani. Așa că am început să mă gândesc cum să câștig bani corespunzători. Și după ce am ascultat povești despre cum vărul meu primea bani nebuni la acea vreme în 1C, am decis și eu să-mi conectez viața cu IT.

Inițial, acestea erau site-uri șabloane care foloseau constructori de site-uri web și WordPress, apoi m-am implicat în SEO și la un moment dat am dat peste Habr, după care am decis să devin programator cu drepturi depline. Nu aveam matematică superioară, așa că am decis să aleg un domeniu în care nu era necesar - dezvoltarea web.

Am avut o întrebare evidentă: ce limbă să aleg - php/python/ruby. După ce am văzut suficiente articole despre Habré, am citit ceva ură față de php după ce am vizionat câteva videoclipuri motivaționale de la Yandex. Am ales Python. Sper că cunoașteți avantajele limbajului, așa că nu voi vorbi despre asta.

Pregătirea limbii primare

Am combinat învățarea limbilor străine cu meseria mea principală, așa că am citit cărți, am urmărit tutoriale și am lucrat la proiecte mici seara. În general, într-un an I

1) Cărți studiate:

• Mark Lutz - Learning Python
• Mark Lutz - Programare Python
• Chad Fowler – Fanatic programator
• Bill Lubanovich - Python simplu

2) Am studiat o mulțime de videoclipuri de la autori ucraineni/burghezi pe Django
3) A finalizat un curs de la codeacademy
4) Stăpânirea PyCharm

Primul tău proiect

Atunci mi-a venit ideea unui mic serviciu pe o temă foarte specifică, pe care am decis să-l creez pentru a-mi consolida cunoștințele despre Python + Django.

În crearea site-ului I

1) Cărți studiate:

• John Duckett - HTML și CSS. Dezvoltare si design site web
• David Flanagan - JavaScript. Ghid detaliat
• Ben Forta - Învață SQL pe cont propriu.

2) Am studiat documentația Django pentru sarcinile mele
3) Am studiat implementarea proiectelor pe Django Gunicorn + nginx + centOS

Primul meu proiect normal

După ce primul site web adecvat a eșuat, am decis să creez ceva util, am ales o idee, am ales o schemă de implementare și am finalizat-o seara în 3 luni.

Proiectul și-a arătat viabilitatea (până în ziua de azi îmi aduce niște bani, de care sunt incredibil de fericit). Și am decis să o pompa mai bine.

După ce am citit cartea „Percival H. - Test-Driven Development with Python”, am decis să scriu mai întâi teste bazate pe componentele Django, apoi am căutat documentația Selenium și am făcut deja teste externe.

Vreau să fiu cool

După ce am deschis posturi vacante pentru dezvoltatorii Python-Django, m-am uitat la ce altceva este necesar de obicei în astfel de posturi vacante:

• Cadrul de odihnă Django
• Țelină
• Tornado/Twisted/asyncio (Alegeți unul)
• Vizualizare bazată pe clasă Django
• Angular/React (Alegeți unul)

Am petrecut 3 luni cunoscând/încercând aceste lucruri. Am luat, de asemenea, biblioteca standard Python + biblioteca de analiză externă beautifulSoup.

Nu poți lucra fără C/C++

Există o părere că, fără cunoștințe de C/C++, un programator nu se poate numi programator. Prin urmare, când am avut timp liber, m-am familiarizat cu cărțile:

• Brian Kernighan – Limbajul de programare C
• Stanley B Lippman – limbaj de programare C++. Curs de bază

Am citit cărțile, am schimbat codul, m-am uitat la compilație, m-am uitat la exemplele de cod. În general, acum nu am făcut ochii mari la menționarea referințelor, indicatorilor, sortării, POO și a o grămadă de matrice diferite cu la viteze diferite prelucrarea unui element in functie de pozitia acestuia.

Sunt gata să lupt!

Și aici ajungem la punctul cel mai important. După ce a petrecut un total de 2 ani învățând toate elementele de programare web pe care le-am menționat mai sus. M-am considerat suficient de pregătit pentru a aplica pentru un post de dezvoltator web Python. Desigur, unele lucruri nu știam foarte bine, unele superficial și altele nu le cunoșteam deloc (de exemplu, Flask), dar înțelegerea generală și abilitățile erau destul de bune.

Și aici au început problemele cu Python, pe care oamenii de cele mai multe ori nu se concentrează. Și anume, pe cererea de afaceri pentru dezvoltatori Python de nivel junior/pre-mediu.

Am intrat pe piata cu aceasta intrebare.

Deși la prima vedere pare că sunt destul de multe posturi vacante în Python, când încep specificul, totul se schimbă dramatic.

1. Imediat are loc o mare screening de posturi vacante în care Python este exclusiv un limbaj auxiliar. Cel mai adesea acestea sunt poziții de dezvoltatori Java, Administratori de sistem, QA Automation. De asemenea, acum există un abandon mare în Data Learning, care necesită o educație matematică + limbajul R. Numai cu Python, nu veți putea găsi acest post vacant.

2. S-a dovedit că în orașul meu nu există locuri libere pentru Python, literalmente deloc. După ce am extins căutarea în toată zona, am primit și rezultate nesatisfăcătoare. Câteva posturi vacante în PHP, unde Python a fost un plus. Când am deschis filtrul în ultimii 3 ani, am mai descoperit că nu sunt deloc locuri libere pentru Python. Acestea. afacerile din provincii aleg cel mai adesea tehnologii mai simple și mai populare decât Python.

3. După ce am deschis posturile vacante Python într-un motor de căutare general, am descoperit următoarele tendințe:

• Peste 90% din locurile de muncă vacante sunt situate în Moscova sau Sankt Petersburg
• Peste 90% din posturile vacante necesită nivel mediu+/superior
• ~100% din posturile vacante pentru posturi de juniori la Moscova sau Sankt Petersburg (cel mai adesea de la giganți)

Cu alte cuvinte, situația s-a dovedit că, dacă nu locuiești la Moscova, Sankt Petersburg și nu vei merge să le „cucerești”, atunci practic nu ai unde să-ți obții primul loc de muncă.

Desigur, există câteva locuri în care Python este încă folosit, de exemplu, în Kazan. Dar cel mai adesea aceasta este o singură companie, unde posturile vacante sunt, de asemenea, foarte middle+/ senior.

4. Opțiunea de căutare a muncii la distanță la nivelul actual a arătat, de asemenea, că angajatorii nu sunt pregătiți să își asume un astfel de risc. Puțină experiență + lucru la distanță = acesta este un fel de fantezie.
Cu toate acestea, am reușit să găsesc încă câteva opțiuni, dar deja în timpul interviului inițial a devenit clar că era o prostie de genul: „Lucrezi pentru noi trei luni, iar dacă clientul plătește pentru munca ta, noi te vom plăti. de asemenea." Nu este cea mai bună opțiune.

5. Am vorbit cu un cuplu de HR din companii mari, ei au exprimat acest trend. „De obicei angajăm oameni cu cel puțin un an de experiență în Python, plus experiență într-o altă limbă (3+ ani). Cel mai adesea php/Java." Cu alte cuvinte, nu s-au gândit deloc să angajeze pe cineva doar cu Python.

6. După ce am vorbit cu băieți de pe forumuri specializate, a devenit clar că aceasta este o situație destul de tipică. Din poveștile lor, a devenit clar că oamenii, după o căutare inutilă, fie s-au dus să lucreze pe PHP/1c, fie au urcat cumva prin upwork/propul proiect/test automatizare.
Dar din nou, de la caz la caz.

În general, s-a dovedit că Python este un limbaj excelent care vă permite să creați proiecte puternice. Și se întâmplă ca concentrarea lor să fie în capitale. Și deoarece acestea sunt proiecte complexe, atunci angajații sunt necesari la nivelul mediu+. Este o persoană care tocmai a învățat Python gata să obțină un astfel de post vacant? Dificil!

Dar există o altă cale!

În acest moment, numai în orașul meu sunt 24 de posturi vacante pentru PHP de diferite niveluri (de la companii mici care trebuie să susțină site-ul actual până la giganți de comerț electronic care oferă o extindere consistentă a funcționalității). Și cam tot atâtea posturi vacante pentru 1C. Și în aproximativ jumătate dintre aceste posturi vacante sunt pregătiți să angajeze o persoană care măcar știe ceva despre programare. Cel mai probabil, acestea nu sunt cele mai multe cele mai bune locuri, dar acesta este deja primul job după care vei deveni oficial un programator cu experiență pentru HR.

Deci in final

Se pare că poți învăța limbajul de programare Python și poți sta pe stradă. Sau puteți învăța php/1c „urât” și puteți obține un loc de muncă. Calitatea acestei lucrări, desigur, lasă multe întrebări - dar aceasta este deja experiență.

În ceea ce mă privește, în condițiile mele (nu merg la Moscova/Sankt Petersburg), de fapt am petrecut timp învățând o limbă care acum este solicitată exclusiv în propriile proiecte. Nu am reușit să găsesc de lucru local sau de la distanță. Acum mă îndrept către php, deoarece pur și simplu are de lucru.

Prin urmare, dacă nu locuiți la Moscova, Sankt Petersburg sau nu sunteți student la o universitate tehnică, atunci nu v-aș sfătui să învățați Python ca primă limbă. Atenție la PHP - întotdeauna există locuri pentru el, există muncă, există experiență. Și calea ulterioară de dezvoltare este deja a ta.

P.S. După cum mi-a spus prietenul meu, situația este aproape aceeași în Ruby. Dar aici nu mai pot vorbi cu încredere.