Informatica , SEO , Optimizare , HTML , pagini web , Internet

Cuvintele Cheie

2025-05-13T10:49:00.000-07:00

Cele mai bune practici pentru găsirea unor cuvinte cheie noi

Identificați cuvinte-cheie noi

Căutați cuvinte sau expresii legate de produsele sau serviciile pe care le oferiți. Instrumentul de analiză a cuvintelor-cheie vă va ajuta să identificați cuvintele-cheie cele mai relevante pentru companie.

Cuvintele-cheie potrivite vă pot afișa anunțul clienților potriviți, iar Planificatorul de cuvinte-cheie Google Ads vă stă la dispoziție.

Găsiți cuvintele cheie ale campaniei cu Planificatorul de cuvinte cheie – Google Ads

Faceți publicitate pe blog - Blogger Ajutor

Faceți publicitate pe blog

Important: nu sunt permise reclamele în bloguri destinate adulților. Aflați mai multe despre Politica de conținut și Termenii și condițiile Blogger.

Pentru a câștiga bani cu Blogger, puteți afișa AdSense și alte anunțuri în pagini. Pentru a folosi AdSense, blogul dvs. trebuie să respecte politicile și restricțiile AdSense.

Sfat: Politica de conținut Blogger și Termenii și condițiile se aplică în continuare modului în care folosiți Blogger.

Download Windows 11

Criteriile de eligibilitate pentru AdSense - Google AdSense Ajutor Conținutul trebuie să fie de înaltă calitate, original și atractiv pentru public. Consultați sfaturile noastre pentru a vă asigura că paginile site-ului dvs. sunt pregătite pentru AdSense. Asigurați-vă că site-ul dvs. respectă politicile de produs înainte de a vă crea un cont. Rețineți că putem modifica oricând politicile și, conform Termenilor și condițiilor, este responsabilitatea dvs. să fiți la curent cu acestea.

Înscrieți-vă la AdSense

Important: asigurați-vă că urmați toți pașii înainte să dați clic pe Redirecționați.

Conectați-vă la Blogger.
În stânga sus, selectați un blog.
În meniul din stânga, dați clic pe Venituri Creați un cont AdSense.
- Dacă blogul nu este eligibil, aflați cum să vă calificați pentru AdSense.
Selectați adresa de e-mail Google asociată contului Blogger.
Completați formularul AdSense și dați clic pe Creați un cont.
Introduceți detaliile de plată și confirmați numărul de telefon.
Dați clic pe Trimiteți.
- Sistemul vă va direcționa automat la Blogger pentru a finaliza procesul. În caz contrar, dați clic pe Redirecționați.

Sfat: dacă procesul se întrerupe înainte de a parcurge pașii, urmați din nou pașii 1 – 5. Dacă în pagina de pornire AdSense apare mesajul „Se lucrează la configurare” mai mult de câteva zile, dați clic pe Acceptați asocierea.

Afișați anunțuri între postări

Conectați-vă la Blogger.
În stânga sus, alegeți blogul în care doriți să afișați anunțuri.
În meniul din stânga, dați clic pe Aspect.
În funcție de șablon:
- în secțiunea „Postări de pe blog”, sub opțiunea „Corpul paginii”, dați clic pe Modificați.;
- în secțiunea „Postări de pe blog”, sub opțiunea „Principale”, dați clic pe Modificați..
Bifați caseta din dreptul opțiunii „Afișați anunțuri între postări”.
Alegeți formatul și culorile anunțurilor, precum și frecvența cu care doriți să se afișeze acestea.
Dați clic pe Salvați.
Pentru a salva setările, în dreapta jos, dați clic pe Salvați .

Afișați anunțuri în coloane

Conectați-vă la Blogger.
În stânga sus, alegeți blogul în care doriți să afișați anunțuri.
În meniul din stânga, dați clic pe Aspect.
Sub „Bara laterală”, dați clic pe Adăugați un gadget.
Lângă AdSense, dați clic pe Adăugați .
Configurați AdSense și dați clic pe Salvați.
Pentru a salva setările, în dreapta jos, dați clic pe Salvați .

Afișați anunțuri de la alte servicii de anunțuri

Conectați-vă la Blogger.
În stânga sus, alegeți blogul în care doriți să afișați anunțuri.
În meniul din stânga, dați clic pe Aspect.
Plasați cursorul pe spațiul în care doriți să afișați anunțuri și dați clic pe Adăugați un gadget.
În fereastra pop-up, lângă „HTML/JavaScript”, dați clic pe Adăugați .
Opțional: introduceți un titlu.
În secțiunea „Conținut”, copiați și inserați codul din site-ul serviciului publicitar.
Dați clic pe Salvați.
Pentru a salva setările, în dreapta jos, dați clic pe Salvați .

Consultați raportul privind veniturile din Blogger

Conectați-vă la Blogger.
În stânga sus, alegeți un blog de examinat.
În meniul din stânga, dați clic pe Venituri Vedeți veniturile.

Sfat: pentru a afla ce înseamnă fiecare termen din raport, folosiți glosarul AdSense.

Ce trebuie să faceți dacă AdSense nu se activează

Important: pentru a verifica dacă respectivul cont este încă activ, accesați AdSense.

Conectați-vă la Blogger.
În stânga sus, selectați un blog.
În meniul din stânga, dați clic pe Aspect.
În gadgetul AdSense, dați clic pe Modificați Salvați.
Repetați pasul 4 pentru fiecare gadget AdSense de pe blog.
În partea de jos a gadgetului „Postări pe blog”, dați clic pe Modificați Salvați.
Pentru a salva setările, în dreapta jos, dați clic pe Salvați .

Configurați un fișier ads.txt

Dacă blogul dvs. generează bani prin furnizori terță parte sau ați integrat manual AdSense pe blog, va trebui să configurați manual conținutul fișierului ads.txt. Aflați mai multe despre fișierul ads.txt pentru AdSense.

Conectați-vă la Blogger.
În stânga sus, alegeți blogul pe care doriți să îl configurați.
În meniul din stânga, dați clic pe Setări.
Sub „Generare de bani”, activați Activați fișierul ads.txt personalizat.
Dați clic pe Fișier ads.txt personalizat.
Copiați setările de la furnizorul terță parte pentru generare de bani și inserați-le în caseta de text.
Dă clic pe Salvați.

Sfat: ca să verificați conținutul fișierului ads.txt, accesați http://<adresa blogului>/ads.txt.

Faceți backup sau importați blogul - Blogger Ajutor

Clip Călin G https://x.com/i/status/1922039658172535163

N Dan - Sume enorme de la Primărie în fiecare zi ! https://www.facebook.com/reel/1184455306278194

Python , un limbaj accesibil 1

2018-01-19T13:32:00.007-08:00

Tutorialul Python

Python este un limbaj de programare ușor de învățat. Are o structură eficientă de date la nivel înalt și o abordare simplă, dar eficientă, a programării orientate pe obiecte. Sintaxa elegantă și tastarea dinamică a lui Python, împreună cu natura interpretată, o fac o limbă ideală pentru scrierea și dezvoltarea rapidă a aplicațiilor în multe zone pe majoritatea platformelor.

Interpretul Python și biblioteca extensivă standard sunt disponibile gratuit în format sursă sau binar pentru toate platformele importante de pe site-ul web Python, http://www.python.org/ , și pot fi distribuite în mod liber. Același site conține, de asemenea, distribuții și indicatori către multe module, programe și instrumente gratuite Python, precum și documentație suplimentară.

Interpretul Python este ușor de extins cu noi funcții și tipuri de date implementate în C sau C ++ (sau alte limbi care pot fi apelate din C). Python este, de asemenea, potrivit ca limbaj de extensie pentru aplicații personalizabile.

Acest tutorial introduce cititorul în mod informal la conceptele și caracteristicile de bază ale limbajului și sistemului Python. Vă ajută să aveți un interpret Python la îndemână pentru experiența hands-on, dar toate exemplele sunt de sine stătătoare, astfel încât tutorialul poate fi citit și offline.

Medium -Unlock Your Future: A Step-by-Step Guide to the Best Free Coding Resources in 2025 | by Logupradeep | Jan, 2025 | Python in Plain English

piZap - free online photo editor - fun photo effects editor

Pentru o descriere a obiectelor și a modulelor standard, consultați Biblioteca standard Python .Referința de limbă Python oferă o definiție mai formală a limbii. Pentru a scrie extensii în C sau C ++, citiți Extinderea și încorporarea Manualului de referință Python Interpreter și Python / C API . Există, de asemenea, câteva cărți care acoperă în profunzime Python.

Acest tutorial nu încearcă să fie cuprinzător și acoperă fiecare caracteristică sau chiar orice caracteristică frecvent utilizată. În schimb, introduceți multe dintre caracteristicile cele mai notabile ale lui Python și vă va oferi o idee bună despre stilul și aroma limbii. După ce ați citit-o, veți putea citi și scrie module și programe Python și veți fi gata să aflați mai multe despre diferitele module de bibliotecă Python descrise în The Python Standard Library .

Glosarul este merită să fie parcurse.

1. Îngăduiți-vă apetitul

2. Folosind interpretul Python

2.1. Invocând interpretul

2.1.1. Argumentul care trece

2.1.2. Mod interactiv

2.2. Interpretul și mediul său

2.2.1. Eroare de manipulare

2.2.2. Script-uri Python executabile

2.2.3. Codificarea codului sursă

2.2.4. Fișierul de pornire interactivă

2.2.5. Modulele de personalizare

3. O introducere informală în Python

3.1. Utilizarea Python ca Calculator

3.1.1. numere

3.1.2. Siruri de caractere

3.1.3. liste

3.2. Primii pași spre programare

4. Mai multe instrumente de control al fluxului

4.1. `dacă` declarațiile

4.2. `pentru` declarații

4.3. `Intervalul ()` Funcția

4.4. `întrerupeți` și `continuați` declarațiile, și `altfel` clauzele pe buclă

4.5. `trece` declarațiile

4.6. Definirea funcțiilor

4.7. Mai multe despre definirea funcțiilor

4.7.1. Valori implicite ale argumentelor

4.7.2. Argumente pentru cuvinte cheie

4.7.3. Liste de argumente arbitrare

4.7.4. Despachetarea listelor de argumente

4.7.5. Expresii Lambda

4.7.6. Structuri de documentare

4.7.7. Funcții adnotări

4.8. Intermezzo: Stilul de codificare

5. Structuri de date

5.1. Mai multe despre Liste

5.1.1. Utilizarea listelor ca stive

5.1.2. Utilizarea listelor ca cozi

5.1.3. Lista de înțelegeri

5.1.4. Cuprinsul listei încorporate

5.2. `Del` Declarația

5.3. Tupele și secvențe

5.4. seturi

5.5. dicţionare

5.6. Tehnici de buclă

5.7. Mai multe despre Condiții

5.8. Comparând secvențele și alte tipuri

6. Module

6.1. Mai multe despre module

6.1.1. Executarea modulelor ca scripturi

6.1.2. Calea căutării modulelor

6.1.3. "Compilate" fișierele Python

6.2. Module standard

6.3. `Dir ()` Funcția

6.4. pachete

6.4.1. Importul * dintr-un pachet

6.4.2. Intrările în pachet

6.4.3. Pachete în mai multe directoare

7. Intrare și ieșire

7.1. Formatul ieșirii fancierului

7.1.1. Formatul de șir vechi

7.2. Citirea și scrierea fișierelor

7.2.1. Metode de obiecte de fișiere

7.2.2. Salvarea datelor structurate cu `json`

8. Erori și excepții

8.1. Sintaxă Erori

8.2. excepţii

8.3. Manipularea excepțiilor

8.4. Ridicarea excepțiilor

8.5. Excepții definite de utilizator

8.6. Definirea acțiunilor de curățare

8.7. Acțiuni de curățare predefinite

9. Clase

9.1. Un cuvânt despre nume și obiecte

9.2. Python Scopes și Namespaces

9.2.1. Scopes și Namespaces Exemplu

9.3. O primă privire la clase

9.3.1. Sintaxa de definire a clasei

9.3.2. Obiecte de clasă

9.3.3. Obiectele instanței

9.3.4. Obiectele obiectului

9.4. Comentarii aleatorii

9.5. Moştenire

9.5.1. Moștenire multiplă

9.6. Variabile private

9.7. Mărunţişuri

9.8. Excepțiile sunt prea clare

9.9. iteratori

9.10. generatoare

9.11. Expresii generatoare

10. Scurt tur al Bibliotecii Standard

10.1. Interfața sistemului de operare

10.2. Fișiere Wildcards

10.3. Argumentele liniei de comandă

10.4. Eroare de redirecționare a erorilor și terminare program

10.5. String Matching Pattern

10.6. Matematică

10.7. Acces la internet

10.8. Datele și orele

10.9. Comprimarea datelor

10.10. Măsurarea performanței

10.11. Control de calitate

10.12. Baterii incluse

11. Scurt tur al Bibliotecii Standard - Partea a II-a

11.1. Formatul de ieșire

11.2. templating

11.3. Lucrul cu layout-urile de înregistrare a datelor binare

11.4. Multi-threading

11.5. Logging

11.6. Referințe slabe

11.7. Instrumente pentru lucrul cu liste

11.8. Zecimal de plutire punct aritmetică

12. Ce anume?

13. Editarea interactivă de intrare și înlocuirea istoricului

13.1. Editare rând

13.2. Înlocuirea istoriei

13.3. Legarea cheilor

13.4. Alternative la interpretul interactiv

14. Aritmetica punctului plutitor: probleme și limitări

14.1. Eroare de reprezentare

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

Dacă lucrați mult pe computere, în cele din urmă veți găsi că există o sarcină pe care doriți să o automatizați. De exemplu, puteți să căutați și să înlocuiți un număr mare de fișiere text sau să redenumiți și să rearanjați o grămadă de fișiere foto într-un mod complicat. Poate doriți să scrieți o bază de date particularizată sau o aplicație GUI specializată sau un joc simplu.

Dacă sunteți un dezvoltator profesionist de software, este posibil să trebuiască să lucrați cu mai multe biblioteci C / C ++ / Java, dar găsiți că ciclul de scriere / compilare / testare / recalculare obișnuit este prea lent. Poate că scrieți o suită de testare pentru o astfel de bibliotecă și găsiți scrierea codului de testare o sarcină plictisitoare. Sau poate ați scris un program care ar putea folosi un limbaj de extensie și nu doriți să proiectați și să implementați o limbă cu totul nouă pentru aplicația dvs.

Python este doar limba pentru tine.

Aveți posibilitatea să scrieți un script shell Unix sau fișiere batch Windows pentru unele dintre aceste sarcini, dar scripturile shell sunt cele mai bune la deplasarea în jurul fișierelor și schimbarea datelor de text, care nu sunt potrivite pentru aplicațiile sau jocurile GUI. S-ar putea să scrieți un program C / C ++ / Java, dar poate dura mult timp pentru a obține chiar și un program de prim plan. Python este mai simplu de utilizat, disponibil pe sistemele de operare Windows, Mac OS X și Unix, și vă va ajuta să vă ocupați mai repede.

Python este ușor de folosit, dar este un limbaj de programare real, oferind mult mai multă structură și suport pentru programe mari decât cele oferite de fișierele de tip shell sau de fișierele batch. Pe de altă parte, Python oferă și o verificare a erorilor mult mai mult decât C și, fiind un limbaj foarte înalt , are în componență tipuri de date de nivel înalt, cum ar fi matrice și dictionare flexibile. Datorită tipurilor de date mai generale, Python este aplicabil unui domeniu de probleme mult mai mare decât Awk sau chiar Perl, dar multe lucruri sunt cel puțin la fel de ușor în Python ca și în acele limbi.

Python vă permite să vă împărțiți programul în module care pot fi reutilizate în alte programe Python. Acesta vine cu o mare colecție de module standard pe care le puteți utiliza ca bază a programelor dvs. - sau ca exemple pentru a începe să învățați să programați în Python. Unele dintre aceste module oferă lucruri cum ar fi fișiere I / O, apeluri de sistem, prize și chiar interfețe cu seturi de instrumente de interfață grafică utilizator cum ar fi Tk.

Python este un limbaj interpretat, care vă poate economisi timp considerabil în timpul dezvoltării programului, deoarece nu este necesară compilarea și legarea. Interpretul poate fi folosit interactiv, ceea ce face ușor să experimentați cu caracteristici ale limbii, să scrieți programe de aruncare sau să testați funcțiile în timpul dezvoltării programelor de jos în sus. Este, de asemenea, un calculator de birou la îndemână.

Python permite programelor să fie redactate în mod compact și ușor de citit. Programele scrise în Python sunt de obicei mult mai scurte decât programele C, C ++ sau Java echivalente, din mai multe motive:

tipurile de date la nivel înalt vă permit să exprimați operații complexe într-o singură declarație;

declarația de grupare se face prin indentare în loc de paranteze începând și terminând;

nu sunt necesare declarații variabile sau argumente.

Python este extensibil : dacă știți cum să programați în C, este ușor să adăugați o nouă funcție sau un modul încorporat interpretului, fie pentru a efectua operații critice la viteză maximă, fie pentru a conecta programele Python la biblioteci care pot fi disponibile numai în formă binară (cum ar fi o bibliotecă grafică specifică vânzătorului). Odată ce sunteți cu adevărat cuplat, puteți conecta interpretul Python într-o aplicație scrisă în C și să o utilizați ca extensie sau limbaj de comandă pentru acea aplicație.

Apropo, limba este numită după emisiunea BBC "Monty Python's Circus Flying" și nu are nimic de-a face cu reptilele. Efectuarea de referințe la schițele Monty Python în documentație nu este permisă, este încurajată!

Acum că sunteți entuziasmați de Python, veți dori să o examinați mai detaliat. Deoarece cea mai bună metodă de a învăța o limbă este să o folosești, tutorialul te invită să te joci cu interpretul Python pe măsură ce citești.

În capitolul următor sunt explicate mecanismele de utilizare a interpretului. Aceasta este o informație destul de luminoasă, dar esențială pentru a încerca exemplele prezentate mai târziu.

Restul tutorialului introduce diferite exemple de limbaj și sistem Python prin exemple, începând cu expresii simple, instrucțiuni și tipuri de date, prin funcții și module și atingând în cele din urmă concepte avansate precum excepțiile și clasele definite de utilizator.

2. Folosirea Interpretului Python

2.1. Invocarea interpretului

Interpretul Python este de obicei instalat ca /usr/local/bin/python3.3 pe acele mașini în care este disponibil; punerea / usr / local / bin în calea de căutare a shell-ului Unix vă permite să o porniți tastând comanda:

python3.3

la coajă. [1] Deoarece alegerea directorului în care trăiește interpretul este o opțiune de instalare, sunt posibile și alte locuri; consultați-vă cu guru-ul local Python sau cu administratorul de sistem. (De exemplu, / usr / local / python este o locație alternativă populară.)

Pe mașinile Windows, instalarea Python este, de obicei, plasată în C: \ Python33 , deși puteți schimba acest lucru când executați programul de instalare. Pentru a adăuga acest director în calea dvs., puteți introduce următoarea comandă în linia de comandă într-o casetă DOS:

set  path =% path % ; C : \ python33

Tastarea unui caracter de sfârșit de fișier ( Control-D pe Unix, Control-Z pe Windows) la promptul principal determină ieșirea interpretului cu o stare de ieșire zero. Dacă aceasta nu funcționează, puteți ieși din interpret tastând următoarea comandă: quit () .

Funcțiile de editare a traducerilor de obicei nu sunt foarte sofisticate. Pe Unix, oricine a instalat interpretul ar fi permis activarea suportului pentru biblioteca GNU readline, care adaugă funcții de editare interactive și istorie mai elaborate. Poate că verificarea cea mai rapidă pentru a vedea dacă editarea liniei de comandă este acceptată este tastarea Control-P la primul prompt Python pe care îl primiți. În cazul în care emite un beep, aveți editarea liniei de comandă; consultați Anexă Modificarea intrărilor interactive și înlocuirea istoricului pentru introducerea cheilor. Dacă nu se întâmplă nimic sau dacă echivalentul lui ^ P nu este disponibilă editarea liniei de comandă; veți putea utiliza doar spațiul de backspace pentru a elimina caracterele din linia curentă.

Interpretul funcționează într-o oarecare măsură ca shell-ul Unix: când este apelat cu intrare standard conectată la un dispozitiv tty, citește și execută comenzi interactiv; când este apelat cu un argument de nume de fișier sau cu un fișier ca intrare standard, citește și execută un script din acel fișier.

Un al doilea mod de a porni interpretul este comanda python -c [arg] ... , care execută instrucțiunile din comanda , analog cu opțiunea shell -c . Deoarece declarațiile Python conțin adesea spații sau alte caractere care sunt speciale pentru shell, este de obicei recomandat să citezi comandaîn întregime cu ghilimele simple.

Unele module Python sunt, de asemenea, utile ca scripturi. Acestea pot fi invocate folosind modululpython -m [arg] ... , care execută fișierul sursă pentru modul ca și cum l-ați scrise numele complet pe linia de comandă.

Atunci când se utilizează un fișier de script, uneori este util să puteți rula scriptul și apoi să intrați în modul interactiv. Acest lucru se poate face trecând -i înainte de scenariu.

2.1.1. Argumentul de trecere

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

2.1.2. Modul Interactiv

Când comenzile sunt citite de la un tty, interpretul se spune că este în modul interactiv . În acest mod, se solicită următoarea comandă cu promptul principal , de obicei trei semne mai mari decât cele ( >>>); pentru linii de continuare se solicită cu prompt secundar , implicit trei puncte ( ... ). Interpretul tipărește un mesaj de întâmpinare care precizează numărul versiunii și o notă privind drepturile de autor înainte de a imprima primul prompt:

$ python3.3
Python 3.3 (implicit, 24 septembrie 2012, 09:25:04)
[GCC 4.6.3] pe linux2
Introduceți "ajutor", "drepturi de autor", "credite" sau "licență" pentru mai multe informații.
>>>

Liniile de continuitate sunt necesare atunci când intri într-un construct multi-linie. De exemplu, aruncați o privire la această declarație if :

>>>

>>> the_world_is_flat  =  1 
>>> dacă  the_world_is_flat : 
...     print ( "Aveți grijă să nu cădeți!" ) 
... 
Aveți grijă să nu cădeți!

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

2.2.1. Efectuarea erorilor

Când apare o eroare, interpretul imprimă un mesaj de eroare și o urmă de stivă. În modul interactiv, acesta revine la promptul principal; când intrarea a provenit de la un fișier, acesta iese după o stare de ieșire nonzero după imprimarea urmelor stivei. (Excepții manipulate de o , cu `excepția` clauză într - o `încercare` declarație nu sunt erori în acest context.) Unele erori sunt în mod necondiționat fatale și pot provoca o ieșire cu o ieșire nenul; acest lucru se aplică în cazul inconsecvențelor interne și al unor cazuri de epuizare a memoriei. Toate mesajele de eroare sunt scrise în fluxul de eroare standard; ieșirea normală din comenzile executate este scrisă la ieșirea standard.

Tastarea caracterului de întrerupere (de obicei Control-C sau DEL) la solicitarea primară sau secundară anulează intrarea și revine la promptul principal. [2] Tastarea unei întreruperi în timp ce o comandă este executată ridică excepția `KeyboardInterrupt` , care poate fi tratată printr-o instrucțiune `try` .

2.2.2. Șabloane de execuție Python

Pe sistemele Unix BSD, script-urile Python pot fi făcute direct executabile, cum ar fi scripturile shell, prin plasarea liniei

#! / usr / bin / env python3.3

(presupunând că interpretul se află pe ecranul utilizatorului PATH ) la începutul scriptului și oferind fișierului un mod executabil. #! trebuie să fie primele două caractere ale fișierului. Pe unele platforme, această primă linie trebuie să se încheie cu o linie de tip Unix care se termină ( '\ n' ), nucu o linieWindows ( '\ r \ n' ) care se termină. Rețineți că hash, sau literă, caracter, "#" , este folosit pentru a începe un comentariu în Python.

Scriptul poate primi un mod executabil sau permisiune, folosind comanda chmod :

$ chmod + x myscript.py

Pe sistemele Windows, nu există nicio noțiune de "mod executabil". Programul de instalare Python asociază automat fișierele .py cu Python.exe, astfel încât un dublu-clic pe un fișier Python îl va executa ca un script. Extensia poate fi, de asemenea , .pyw , în acest caz, fereastra consolei care apare în mod normal este suprimată.

2.2.3. Codificarea codului sursă

În mod implicit, fișierele sursă Python sunt tratate ca fiind codificate în UTF-8. În această codificare, caracterele celor mai multe limbi din lume pot fi utilizate simultan în literali de șir, identificatori și comentarii - deși biblioteca standard utilizează numai caractere ASCII pentru identificatori, o convenție pe care trebuie să o urmeze orice cod portabil. Pentru a afișa corect toate aceste caractere, editorul dvs. trebuie să recunoască faptul că fișierul este UTF-8 și trebuie să utilizeze un font care să accepte toate caracterele din fișier.

De asemenea, este posibil să specificați o codificare diferită pentru fișierele sursă. Pentru a face acest lucru, puneți încă o linie de comentariu specială imediat după #! line pentru a defini codificarea fișierului sursă:

# - * - codare: codare - * -

Cu această declarație, totul din fișierul sursă va fi tratat ca având codificarea codării în loc de UTF-8. Lista codificărilor posibile poate fi găsită în Python Library Reference, în secțiunea despre codecuri .

De exemplu, dacă editorul ales nu suportă fișiere codate UTF-8 și insistă să utilizeze alte codări, de exemplu Windows-1252, puteți scrie:

# - * - codare: cp-1252 - * -

și încă utilizați toate caracterele din setul de caractere Windows-1252 din fișierele sursă. Comentariul special de codificare trebuie să fie în prima sau a doua linie din fișier.

2.2.4. Fișierul de pornire interactivă

Atunci când utilizați Python interactiv, este frecvent util să executați comenzi standard de fiecare dată când este pornit interpretul. Puteți face acest lucru setând o variabilă de mediu numităPYTHONSTARTUPla numele unui fișier care conține comenzile de pornire. Acest lucru este similar cu caracteristica.profile a shell-urilor Unix.

Acest fișier este citit numai în sesiuni interactive, nu când Python citește comenzi dintr-un script, și nu când dev / tty este dat ca sursă explicită de comenzi (care altfel se comportă ca o sesiune interactivă). Se execută în același spațiu de nume în care sunt executate comenzi interactive, astfel încât obiectele pe care le definește sau le importă pot fi utilizate fără o calificare în sesiunea interactivă. De asemenea, puteți modifica instrucțiunile sys.ps1 și sys.ps2 în acest fișier.

Dacă doriți să citiți un fișier de pornire suplimentar din directorul curent, puteți să îl programați în fișierul global de pornire utilizând codul de tipul if os.path.isfile ('. Pythonrc.py'): exec (open (' .pythonrc.py "). citiți ()) . Dacă doriți să utilizați fișierul de pornire într-un script, trebuie să faceți acest lucru explicit în script:

import  os 
filename  =  os . environ . get ( 'PYTHONSTARTUP' ) 
dacă  numele fișierului  și  os . calea . isFile ( numele fișierului ): 
    exec ( deschis ( nume de fișier ) . citește ())

2.2.5. Modulele de personalizare

Python oferă două cârlige pentru a vă permite să o personalizați: sitecustomize și usercustomize . Pentru a vedea cum funcționează, trebuie mai întâi să găsiți locația directorului pentru pachetele de site-uri pentru utilizatori. Porniți Python și rulați acest cod:

>>>

>>> import  site - ul 
>>> site - ul . getusersitepackages () 
'/home/user/.local/lib/python3.2/site-packages'

Acum puteți crea un fișier numit usercustomize.py în acel director și puneți tot ce doriți în el. Aceasta va afecta fiecare invocare a Python, dacă nu este inițiată cu opțiunea -s pentru a dezactiva importul automat.

sitecustomize funcționează în același mod, dar este, în mod obișnuit, creat de un administrator al calculatorului în directorul global de site-uri cu pachete și este importat înaintea usercustomize . Consultați documentația modulului site pentru mai multe detalii.

Note de subsol

[1]	Pe Unix, interpretul Python 3.x nu este instalat implicit cu executabilul numit `python` , astfel încât să nu fie în conflict cu un executabil Python 2.x instalat simultan.

[2]	O problemă cu pachetul GNU Readline poate împiedica acest lucru.

3. O introducere informală în Python

În exemplele următoare, intrarea și ieșirea se disting prin prezența sau absența instrucțiunilor ( >>> și ... ): pentru a repeta exemplul, trebuie să tastați totul după prompt, când apare promptul; linii care nu încep cu o solicitare sunt emise de interpret. Rețineți că un prompt secundar pe o linie de la sine într-un exemplu înseamnă că trebuie să tastați o linie goală; acest lucru este folosit pentru a încheia o comandă multi-linie.

Multe dintre exemplele din acest manual, chiar și cele introduse la promptul interactiv, includ comentarii. Comentariile din Python încep cu caracterul hash, # și se extind până la sfârșitul liniei fizice. Un comentariu poate apărea la începutul unei linii sau după un spațiu alb sau un cod, dar nu într-un literal șir. Un caracter hash într-un literal șir este doar un caracter hash. Deoarece comentariile sunt de clarificare a codului și nu sunt interpretate de Python, ele pot fi omise atunci când tastați în exemple.

Cateva exemple:

# acesta este primul comentariu 
spam  =  1   # și acesta este al doilea comentariu 
          # ... și acum o treime! 
text  =  "# Acesta nu este un comentariu deoarece este în interiorul citatelor".

3.1. Utilizarea Python ca Calculator

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

3.1.1. Numere

Interpretul funcționează ca un simplu calculator: puteți tasta o expresie la ea și va scrie valoarea. Sintaxa de expresie este simplă: operatorii + , - , * și / funcționează la fel ca în cele mai multe alte limbi (de exemplu, Pascal sau C); parantezele ( () ) pot fi utilizate pentru grupare. De exemplu:

>>>

>>> 2  +  2 
4 
>>> de 50  - de  5 * 6 
20 
>>> ( de 50  - de  5 * 6 )  /  4 
5.0 
>>> 8  / de  5   # diviziune returnează întotdeauna un punct număr flotant 
1.6

Numerele întregi (de exemplu , 2 , 4 , 20 ) au tipul int , cele cu o parte fracționată (de ex. , 5.0 , 1.6) au tip float . Vom vedea mai multe despre tipurile numerice mai târziu în tutorial.

Diviziunea ( / ) întoarce întotdeauna un flotor. Pentru a face diviziunea podelei și a obține un rezultat întreg (eliminând orice rezultat fracționat), puteți utiliza // operatorul; pentru a calcula restul pe care îl puteți utiliza % :

>>>

>>> 17  /  3   # diviziune clasic returnează un flotor 
5.666666666666667 
>>> 
>>> 17  //  3   # diviziune podea aruncate înapoi partea fracționară 
5 
>>> 17  %  3   # operatorul% returnează restul împărțirii 
2 
>> > 5  *  3  +  2   # rezultatul * divizorul + restul 
17

Cu Python, este posibil să utilizați operatorul ** pentru a calcula puterile [1] :

>>>

>>> 5  **  2   # 5 pătrat 
25 
>>> 2  **  7   # 2 la puterea de 7 
128

Semnul egal ( = ) este folosit pentru a atribui o valoare unei variabile. Ulterior, nu se afișează niciun rezultat înainte de următorul prompt interactiv:

>>>

>>> latime  =  20 
>>> înălțime  =  5  *  9 
>>> lățime  *  înălțime 
900

Dacă o variabilă nu este "definită" (atribuită o valoare), încercarea de ao utiliza vă va da o eroare:

>>>

>>> n   # încercați să accesați o variabilă nedefinită 
Traceback (ultimul apel ultimul): 
  Fișierul "<stdin>" , rândul 1 , în <modul> 
NameError : numele 'n' nu este definit

Există suport complet pentru punctul de plutire; operatorii cu operanzi de tip mixt convertesc operandul intreg la punctul flotant:

>>>

>>> 3  *  3.75  /  1.5 
7.5 
>>> 7.0  /  2 
3.5

În modul interactiv, ultima expresie tipărită este atribuită variabilei _ . Acest lucru înseamnă că, atunci când utilizați Python ca un calculator de birou, este ceva mai ușor să continuați calculele, de exemplu:

>>>

>>> tax  =  12.5  /  100 
>>> preț  =  100.50 
>>> preț  *  taxă 
12.5625 
>>> preț  +  _ 
113.0625 
>>> rotund ( _ ,  2 ) 
113.06

Această variabilă ar trebui tratată ca utilizată doar de citire. Nu îi alocați în mod explicit o valoare - ați crea o variabilă locală independentă cu același nume care maschează variabila încorporată cu comportamentul său magic.

În plus față de int și float , Python acceptă și alte tipuri de numere, cum ar fi Decimal și Fraction . Python are, de asemenea, suport încorporat pentru numere complexe și utilizează sufixul j sau Jpentru a indica partea imaginară (de ex. 3 + 5j ).

3.1.2. Stringuri

Pe lângă numere, Python poate manipula și șiruri de caractere, care pot fi exprimate în mai multe moduri. Ele pot fi închise în citate simple ( "..." ) sau citate duble ( "..." ) cu același rezultat [2] . \pot fi folosite pentru a scăpa de citate:

>>>

>>> „ouă de spam“   citate # singur 
„ouă de spam“ 
>>> „doesn \“ t „   # utilizare \“ pentru a scăpa de un singur citat ... 
«nu» 
>>> «nu»   #. .. sau utilizați în schimb citate duble 
"nu" 
>>> "" Da ", a spus el. 
- Da, spuse el. 
>>> " \" Da, \ " a spus el." 
- Da, spuse el. 
>>> '"Isn \' t" , a spus ea. " 
- Nu este, spuse ea.

În interpretul interactiv, șirul de ieșire este inclus în ghilimele și caracterele speciale sunt evacuate cu backslash-uri. În timp ce acest lucru ar putea uneori să pară diferit de intrare (citatele de închidere se pot modifica), cele două șiruri sunt echivalente. Șirul este inclus în ghilimele duble în cazul în care șirul conține o singură cotație și nici un ghilimele duble, altfel este inclus în ghilimele simple. Funcția print () produce o ieșire mai lizibilă, prin omiterea cotelor de închidere și prin tipărirea caracterelor evacuate și speciale:

>>>

>>> '"Isn \' t" , a spus ea. " 
- Nu este, spuse ea. 
>>> print ( "Nu este " , a spus ea. ) 
"Nu este," a spus ea. 
>>> s  =  'Prima linie. \ n Al doilea rând. "   # \ n înseamnă noua linie 
>>> s   # fără imprimare (), \ n este inclusă în ieșirea 
"Prima linie. \ nLinița a doua". 
>>> print ( s )   # with print (), \ n produce o nouă linie 
Prima linie. 
A doua linie.

Dacă nu vreți ca caracterele prefabricate de \ să fie interpretate ca caractere speciale, puteți utiliza șiruri brute prin adăugarea unui r înaintea primei citate:

>>>

>>> print ( 'C: \ some \ n ame' )   # aici \ n înseamnă newline! 
C: \ some 
ame 
>>> print ( r'C: \ some \ name ' )   # notați r înainte de citatul 
C: \ some \ name

Stratul literal poate cuprinde mai multe linii. O modalitate este folosirea citatelor triple: "" "..." ""sau "'' ... '' ' . Sfârșitul liniilor este inclus automat în șir, dar este posibil să se împiedice acest lucru prin adăugarea unui \ la capătul liniei. Următorul exemplu:

imprimare ( „“ „ \ 
Utilizare: thingy [OPȚIUNI] 
     -h Afișează acest mesaj de folosire a 
     HOST - ului H nume de gazdă pentru a se conecta la 
«»“ )

produce următoarea ieșire (rețineți că noua linie inițială nu este inclusă):

Utilizare: lucru [OPȚIUNI]
     -h Afișați acest mesaj de utilizare
     -H Numele gazdei pentru care se conectează

Șirurile pot fi concatenate (lipite împreună) cu operatorul + și repetate cu * :

>>>

>>> # 3 ori 'un', urmat de 'ium' 
>>> 3  *  'un'  +  'ium' 
'unununium'

Două sau mai multe literali de șir (adică cele cuprinse între citate) unul lângă celălalt sunt concatenate automat.

>>>

>>> 'Py'  'thon' 
'Python'

Acest lucru funcționează numai cu doi literali, dar nu cu variabile sau expresii:

>>>

>>> prefix  =  'Py' 
>>> prefixul  'thon'   # nu poate concatena o variabila si un sir literal 
  ... 
SyntaxError: sintaxa invalida 
>>> ( 'un'  *  3 )  'ium' 
  ... 
SyntaxError : sintaxa invalida

Dacă doriți să concatenați variabile sau o variabilă și literală, folosiți + :

>>>

>>> prefix  +  'thon' 
'Python'

Această caracteristică este utilă în special atunci când doriți să rupeți șiruri lungi:

>>>

>>> text  =  ( 'Puneți mai multe șiruri în paranteze' 
            ') 
>>> text 
' Puneți mai multe șiruri în paranteze pentru a le uni.

Șirul poate fi indexat (abonat), primul caracter având index 0. Nu există un tip de caractere separat; un personaj este pur și simplu un șir de mărimea unu:

>>>

>>> cuvânt  =  'Python' 
>>> cuvânt [ 0 ]   # caracter în poziția 0 
'P' 
>>> cuvânt [ 5 ]   # caracter în poziția 5 
'n'

Indicii pot fi și numere negative, pentru a începe numărarea din dreapta:

>>>

>>> cuvânt [ - 1 ]   # ultimul caracter 
'n' 
>>> cuvânt [ - 2 ]   # a doua ultimul caracter 
'o' 
>>> cuvânt [ - 6 ] 
'P'

Rețineți că din moment ce -0 este același ca 0, indicii negativi încep de la -1.

În plus față de indexare, este suportat și felierea . În timp ce indexarea este folosită pentru a obține caractere individuale, felierea vă permite să obțineți subrețele:

>>>

>>> cuvânt [ 0 : 2 ]   # caractere din poziția 0 (inclus) la 2 (exclus) 
'Py' 
>>> cuvânt [ 2 : 5 ]   # caractere din poziția 2 (inclus) la 5 (exclus) 
'Tho'

Rețineți cum este inclus întotdeauna începutul, iar sfârșitul este întotdeauna exclus. Acest lucru face ca s [: i] + s [i:] să fie întotdeauna egal cu s :

>>>

>>> cuvânt [: 2 ]  +  cuvânt [ 2 :] 
'Python' 
>>> cuvânt [: 4 ]  +  cuvânt [ 4 :] 
'Python'

Indicii de segmentare au valori implicite utile; un indice primul omis este implicit zero, un indice al doilea omis este implicit la dimensiunea șirului care este tăiat.

>>>

>>> cuvânt [: 2 ]   # de caractere de la început până la poziția 2 (exclus) 
'Py' 
>>> cuvânt [ 4 :]   # caractere de la poziția 4 (inclus) la sfârșitul anului 
'pe' 
>>> cuvânt [ - 2 :]  # caractere de la al doilea - ultimul (inclus) până la capătul 
"pe"

O modalitate de a ne aminti cum funcționează felii este să ne gândim la indicii ca fiind indicatori întrecaractere, cu marginea din stânga a primului caracter numerotat 0. Apoi marginea dreaptă a ultimului caracter al unui șir de caractere n are indicele n , de exemplu:

 + --- + --- + --- + --- + --- + --- + 
 |  P  |  y  |  t  |  h  |  o  |  n  | 
 + --- + --- + --- + --- + --- + --- + 
 0    1    2    3    4    5    6 
- 6   - 5   - 4   - 3   - 2   - 1

Primul rând de numere dă poziția indicilor 0 ... 6 în șir; al doilea rând dă indicii negativi corespunzători. Felia de la i la j constă din toate caracterele dintre marginile etichetate i și respectiv j .

Pentru indicii non-negativi, lungimea unei felii este diferența dintre indicii, dacă ambele sunt în limite. De exemplu, lungimea cuvântului [1: 3] este 2.

Încercarea de a utiliza un index care este prea mare va duce la o eroare:

>>>

>>> cuvânt [ 42 ]   # cuvântul are doar 7 caractere 
Traceback (cel mai recent apel ultimul): 
  Fișierul "<stdin>" , rândul 1 , în <modul> 
IndexError : indicele șir din interval

Cu toate acestea, indicele de raportare din rază de acțiune este tratat grațios atunci când este utilizat pentru tăierea:

>>>

>>> cuvânt [ 4 : 42 ] 
'pe' 
>>> cuvânt [ 42 :] 
''

Comenzile Python nu pot fi schimbate - ele sunt imuabile . Prin urmare, atribuirea unei poziții indexate în șir rezultă dintr-o eroare:

>>>

>>> word [ 0 ]  =  'J' 
  ... 
TypeError: obiectul 'str' nu suporta atribuirea elementului 
>>> word [ 2 :]  =  'py' 
  ... 
TypeError: misiune

Dacă aveți nevoie de un șir diferit, ar trebui să creați unul nou:

>>>

>>> 'J'  +  cuvânt [ 1 :] 
'Jython' 
>>> cuvânt [: 2 ]  +  'py 
'

Funcția încorporată len () returnează lungimea unui șir:

>>>

>>> s  =  'supercalifragilisticexpialidocious' 
>>> len ( s ) 
34

Vezi si

Tipul secvenței de text - p: Șirurile sunt exemple de tipuri de secvențe și sprijină operațiile comune susținute de astfel de tipuri.
Metode de șir: Șirurile suportă un număr mare de metode pentru transformări și căutări de bază.
String Formatare: Informații despre formatarea șirului cu str.format () sunt descrise aici.
printf-stil de formatare de caractere: Vechile operații de formatare invocate atunci când șiruri de caractere și șiruri de caractere Unicode sunt operandul stâng al operatorului % sunt descrise mai detaliat aici.

3.1.3. Liste

Python cunoaște un număr de tipuri de date compuse , utilizate pentru a grupa alte valori. Cea mai versatilă este lista care poate fi scrisă ca o listă de valori (elemente) separate între virgulă între paranteze pătrate. Listele ar putea conține elemente de diferite tipuri, dar, de obicei, toate elementele au același tip.

>>>

>>> pătrate  =  [ 1 ,  4 ,  9 ,  16 ,  25 ] 
>>> pătrate 
[1, 4, 9, 16, 25]

Ca șiruri de caractere (și toate celelalte tipuri de secvențe încorporate ), listele pot fi indexate și tăiate:

>>>

>>> pătrate [ 0 ]   # indexarea returnează elementul 
1 
>>> pătrate [ - 1 ] 
25 
>>> pătrate [ - 3 :]   # slicing returnează o nouă listă 
[9, 16, 25]

Toate operațiile cu secțiuni returnează o nouă listă care conține elementele solicitate. Aceasta înseamnă că următoarea secțiune returnează o nouă copie (superficială) a listei:

>>>

>>> pătrate [:] 
[1, 4, 9, 16, 25]

Listele acceptă, de asemenea, operații cum ar fi concatenarea:

>>>

>>> pătrate  +  [ 36 ,  49 ,  64 ,  81 ,  100 ] 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Spre deosebire de șiruri de caractere, care sunt imuabile , listele sunt un tip mutable , adică este posibil să se modifice conținutul acestora:

>>>

>>> cuburi  =  [ 1 ,  8 ,  27 ,  65 ,  125 ]   # ceva e greșit aici 
>>> 4  **  3   # cubul de 4 este 64, nu 65! 
64 
>>> cuburi [ 3 ]  =  64   # înlocuiți valoarea greșită 
>>> cuburi 
[1, 8, 27, 64, 125]

Puteți adăuga , de asemenea , elemente noi , la sfârșitul listei, folosind append () metoda (vom vedea mai multe despre metodele de mai târziu):

>>>

>>> cuburi . adăugați ( 216 )   # adăugați cubul de 6 
>>> cuburi . adăugați ( 7  **  3 )   # și cubul de 7 
>>> cuburi 
[1, 8, 27, 64, 125, 216, 343]

De asemenea, este posibilă alocarea în felii, ceea ce poate chiar să modifice dimensiunea listei sau să o elimine complet:

>>>

>>> litere  =  [ 'a' ,  'b' ,  'c' ,  'd' ,  'e' ,  'f' ,  'g' ] 
>>> litere 
[ 'a', 'b', 'c' , 'd', 'e', 'f', 'g'] 
>>> # înlocui unele valori 
>>> litere [ 2 : 5 ]  =  [ 'C' ,  'd' ,  'e' ] 
>>> literele 
['a', 'b', 'C', 'D ',' E ',' f ',' g '] 
>>> # eliminați-le acum 
>>> litere [ 2 :5 ]  =  [] 
>>> litere 
[, 'b' 'o' 'f', 'g'] 
>>> # șterge lista prin înlocuirea tuturor elementelor cu o listă goală 
>>> litere [:]  =  [] 
>>> litere 
[]

Funcția built-in len () se aplică și listelor:

>>>

>>> litere  =  [ 'a' ,  'b' ,  'c' ,  'd' ] 
>>> len ( litere ) 
4

Este posibil să se creeze liste (creați liste care conțin alte liste), de exemplu:

>>>

>>> a  =  [ 'a' ,  'b' ,  'c' ] 
>>> n  =  [ 1 ,  2 ,  3 ] 
>>> x  =  [ a ,  n ] 
>>> x 
[[ 'o', 'b', 'c'], [1, 2, 3]] 
>>> x [ 0 ] 
[, 'b' 'o', 'c'] 
>>> x [ 0 ] [ 1 ] 
'b'

3.2. Primii pași spre programare

Desigur, putem folosi Python pentru sarcini mai complicate decât adăugarea a două și două împreună. De exemplu, putem scrie o sub-secvență inițială a seriei Fibonacci după cum urmează:

>>>

>>> # Seria Fibonacci: 
... # suma celor două elemente definește următoarea 
... a ,  b  =  0 ,  1 
>>> în timp ce  b  <  10 : 
...     print ( b ) 
...     a ,  b  =  b ,  a + b 
... 
1 
1 
2 
3 
5 
8

Acest exemplu introduce câteva caracteristici noi.

Prima linie conține o asignare multiplă : variabilele a și b obțin simultan noile valori 0 și 1. Pe ultima linie se folosește din nou, demonstrând că expresiile din partea dreaptă sunt evaluate înainte de oricare dintre alocările avea loc. Expresiile din partea dreaptă sunt evaluate de la stânga la dreapta.
În timp ce bucla execută atâta timp cât condiția (aici: b < 10 ) rămâne adevărată. În Python, ca în C, orice valoare întregă non-zero este adevărată; zero este falsă. Condiția poate fi, de asemenea, o valoare de șir sau de listă, de fapt orice secvență; orice lucru cu o lungime diferită de zero este adevărat, secvențele goale sunt false. Testul utilizat în exemplu este o simplă comparație. Operatorii de comparare standard sunt scrise la fel ca în C: < (mai puțin decât), >(mai mare decât), == (egal cu), <= (mai mic sau egal cu), > = (mai mare sau egal cu) și ! = (nu egal cu).
Corpul buclei este indentat : indentare este modul de grupare a declarațiilor lui Python. La solicitarea interactivă, trebuie să introduceți o filă sau spațiu (e) pentru fiecare linie indentată. În practică, veți pregăti o intrare mai complicată pentru Python cu un editor de text; toți editorii de text decent au o facilitate automată. Când o instrucțiune compusă este introdusă interactiv, trebuie să fie urmată de o linie necompletată pentru a indica finalizarea (deoarece parserul nu poate ghici când ați tastat ultima linie). Rețineți că fiecare linie dintr-un bloc de bază trebuie să fie indentată de aceeași sumă.
Funcția print () scrie valoarea argumentului (argumentelor) pe care este dat. Acesta diferă de scrierea expresiei pe care doriți să o scrieți (așa cum am făcut-o mai devreme în exemplele de calcul) în modul în care gestionează mai multe argumente, cantități în virgulă mobilă și șiruri de caractere. Șirurile sunt tipărite fără ghilimele și un spațiu este inserat între ele, astfel încât să puteți formata lucrurile frumos, cum ar fi:
>>>
```
>>> i  =  256 * 256 
>>> print ( 'Valoarea i este' ,  i ) 
Valoarea lui i este 65536
```
Sfârșitul argumentului pentru cuvinte cheie poate fi folosit pentru a evita linia nouă după ieșire sau pentru a termina ieșirea cu un șir diferit:
>>>
```
>>> a ,  b  =  0 ,  1 
>>> în timp ce  b  <  1000 : 
...     print ( b ,  end = '' ) 
...     a ,  b  =  b ,  a + b 
... 
1,1, 2,3,5,8,13,21,34,55,89,144,233,377,610,987,
```

Note de subsol

[1]	Deoarece `` are precedență mai mare decât `-` , `-3 2` va fi interpretată ca `- (3 2)` și rezultând astfel în `-9` . Pentru a evita acest lucru și a obține `9` , puteți utiliza `(-3) 2` .

[2]	Spre deosebire de alte limbi, caracterele speciale precum `\ n` au același înțeles atât cu citatesimple ( `"..."` ), cât și duble ( `"..."` ). Singura diferență dintre cele două este că în cadrul citatelor unice nu trebuie să scăpați `"` (dar trebuie să scăpați `"` ) și invers.

4. Mai multe instrumente de control al fluxului

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

4.1. `dacă` Declarațiile

Probabil cel mai cunoscut tip de declarație este declarația if . De exemplu:

>>>

>>> x  =  int ( input ( "Vă rugăm să introduceți un număr întreg:" )) 
Introduceți un număr întreg: 42 
>>> dacă  x  <  0 : 
...     x  =  0 
...     print ( 'Negativ schimbat la zero' ) 
... elif  x  ==  0 : 
...     print ( 'Zero' ) 
... elif  x  ==  1 : 
...     print ( 'Single' ) 
... alt :
...     print ( Mai mult ) 
... 
Mai mult

Pot exista zero sau mai multe părți elif , iar cealaltă parte este opțională. Cuvântul cheie " elif " este scurt pentru "altceva dacă" și este util pentru a evita indentarea excesivă. O secvență if if ... elif ... elif ... este un înlocuitor al declarațiilor de comutare sau de caz găsite în alte limbi.

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

Python un lombaj accesibil

2018-01-19T13:31:00.003-08:00

4.2. `pentru` declarații

Instrucțiunea pentru Python diferă puțin de ceea ce puteți folosi în C sau Pascal. Mai mult decât oricare ar fi iterând asupra unei evoluții aritmetice a numerelor (ca în cazul lui Pascal) sau oferind utilizatorului posibilitatea de a defini atât etapa de repetare, cât și starea de oprire (ca C), instrucțiunea lui Python pentru iterație se repetă asupra elementelor din orice secvență (o listă sau un șir), în ordinea în care apar în secvență. De exemplu (nu este destinat jocului):

>>>

>>> # Măsura unele caractere 
de caractere: ... cuvinte  =  [ 'pisică' ,  'fereastră' ,  'defenestrate' ] 
>>> pentru  w  în  cuvinte : 
...     printare ( w ,  Len ( w )) 
.. . 
pisică 3 
fereastra 6 
defenestrate 12

Dacă trebuie să modificați secvența pe care o repetați în interiorul bucla (de exemplu, pentru a duplica elementele selectate), este recomandat să creați o copie. Iterarea unei secvențe nu se face implicit o copie. Notatia de felie fata ca acest lucru deosebit de convenabil:

>>>

>>> pentru  w  version  cuvinte [:]:   # Bucla Faceți o copie cu peste un INTREGII Secțiune liste. 
...     dacă  lămâie ( w )  >  6 : 
...         cuvinte . inserați ( 0 ,  w ) 
... 
>>> cuvinte 
['defenestrate', 'cat', 'fereastră', 'defenestrate']

4.3. `Intervalul ()` Funcția

Dacă trebuie să repetați o secvență de numere, intervalul de funcții încorporat () este la îndemână. Aceasta generează progrese aritmetice:

>>>

>>> pentru  i  în  intervalul ( 5 ): 
...     print ( i ) 
... 
0 
1 
2 
3 
4

Punctul final dat nu este niciodată parte a secvenței generate; intervalul (10) generează 10 valori, indici legali pentru elementele cu o secvență de lungime 10. Este posibil să lăsăm intervalul să înceapă la un alt număr sau să specificăm o altă valoare (chiar negativă, uneori se numește "pas" ):

intervalul ( 5 ,  10 ) de la 
   5  la  9

intervalul ( 0 ,  10 ,  3 ) 
   0 ,  3 ,  6 ,  9

Gama ( - 10 ,  - 100 ,  - 30 ) 
  - 10 ,  - 40 ,  - 70

Pentru a itera peste indicii unei secvențe, puteți combina range () și len () după cum urmează:

>>>

>>> a  =  [ 'Maria' ,  ' a avut' ,  'o' ,  'mic' ,  'miel' ] 
>>> pentru  i  în  gama ( len ( a )): 
...     print ( i ,  o [ i ]) 
... 
0 Mary 
1 avea 
2 și 
3 puține 
4 mieluri

În majoritatea acestor cazuri, cu toate acestea, este convenabil să utilizați funcția enumerate () , consultați tehnicile de buclă .

Un lucru ciudat se întâmplă dacă imprimați doar o gamă:

>>>

>>> imprimare ( interval ( 10 )) 
interval (0, 10)

În multe privințe, obiectul returnat de domeniul () se comportă ca și cum ar fi o listă, dar de fapt nu este. Este un obiect care returnează elementele succesive ale secvenței dorite atunci când o iterați peste ea, dar nu face într-adevăr lista, economisind astfel spațiu.

Spunem că un astfel de obiect este iterabil , adică potrivit ca țintă pentru funcții și construcții care se așteaptă la ceva din care pot obține elemente succesive până la epuizarea aprovizionării. Am văzut că declarația pentru este un astfel de iterator . Lista de funcții () este alta; creează liste de la iterables:

>>>

>>> lista ( intervalul ( 5 )) 
[0, 1, 2, 3, 4]

Mai târziu vom vedea mai multe funcții care returnează iterabile și vor lua iterații ca argument.

4.4. `întrerupeți` și `continuați` declarațiile, și `altfel`Clauzele pe buclă

Pauză declarație, cum ar fi în C, izbucnește celui mai mic pentru sau în timp ce bucla.

Comportamentele buclă pot avea o altă clauză; se execută atunci când bucla se termină prin epuizarea listei (cu for ) sau atunci când condiția devine falsă (cu timp ), dar nu și atunci când bucla este terminată printr-o declarație de pauză . Acest lucru este exemplificat de următoarea buclă, care caută numere prime:

>>>

>>> pentru  n  în  intervalul ( 2 ,  10 ): 
...     pentru  x  în  intervalul ( 2 ,  n ): 
...         dacă  n  %  x  ==  0 : 
...             print ( n ,  'equals' ,  x ,  '*' ,  n // x ) 
...             pauză 
...     altceva : 
...         # buclă a căzut fără a găsi un factor 
...         print (n ,  „este un număr prim“ ) 
... 
2 este un număr prim 
3 este un număr prim 
4 este egal cu 2 * 2 
5 este un număr prim 
6 este egal cu 2 * 3 
7 este un număr prim 
8 este egal cu 2 * 4 
9 egal cu 3 * 3

(Da, acest lucru este codul corect Uită - te atent:. Altfel clauza aparține pentru bucla, nu dacă . Statement)

Atunci când este utilizat cu o buclă, altfel clauza are mai multe în comun cu altcineva clauza de o încercare declarație decât o face cea în cazul în declarații: o încercare declarație de altă clauză rulează atunci când are loc nici o excepție, și o buclă de altă clauză funcționează atunci când nu pauză apare . Pentru mai multe informații despre instrucțiunile de încercare și despre excepții, consultați Excepții de manipulare .

Declarația continuă , de asemenea împrumutată de la C, continuă cu următoarea iterație a buclei:

>>>

>>> pentru  num  în  interval ( 2 ,  10 ): 
...     if  num  %  2  ==  0 : 
...         print ( "A găsit un număr par" ,  num ) 
...         continue 
...     print ( " num " ,  num ) a 
găsit un număr par 2 a 
găsit un număr 3 a 
găsit un număr par 4 a 
găsit un număr 5 a 
găsit un număr par 6 a 
găsit un număr 7 a 
găsit un număr par 8 a 
găsit un număr 9

4.5. declarații `trecute`

Declarația de trecere nu face nimic. Acesta poate fi folosit atunci când o declarație este cerută sintactic, dar programul nu necesită nicio acțiune. De exemplu:

>>>

>>> în timp ce  True : 
...     pass   # Busy-așteptați întreruperea tastaturii (Ctrl + C) 
...

Acest lucru este folosit în mod obișnuit pentru crearea unor clase minime:

>>>

>>> clasa  MyEmptyClass : 
...     treci 
...

Un alt loc de trecere poate fi folosit ca un suport pentru o funcție sau un corp condiționat atunci când lucrați la un nou cod, permițându-vă să continuați să vă gândiți la un nivel mai abstract. Trecere este ignorat în tăcere:

>>>

>>> def  initlog ( * args ): 
...     pass    # Amintiți-vă să implementați acest lucru! 
...

4.6. Definirea funcțiilor

Putem crea o funcție care scrie seria Fibonacci la o limită arbitrară:

>>>

>>> def  fib ( n ):     # scrie seria Fibonacci pana la n 
...     "" "Imprimați o serie Fibonacci pana la n" "" 
...     a ,  b  =  0 ,  1 
... în     timp ce  o  <  n : 
...         imprimare ( un ,  final = '' ) 
...         a ,  b  =  b ,  a + b 
...     imprimare () 
... 
>>> # acum apela funcția tocmai am definit: 
...fib ( 2000 ) 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Cuvântul cheie def introduce o funcție definiție . Acesta trebuie urmat de numele funcției și de lista paranteză a parametrilor formali. Instrucțiunile care formează corpul funcției încep la următoarea linie și trebuie să fie indentate.

Prima declarație a corpului funcției poate fi, opțional, un literal șir; acest șir literal este șirul de documentare al funcției sau docstring . (Mai multe despre docstrings pot fi găsite în secțiunea Documentation Strings .) Există instrumente care folosesc docstrings pentru a produce automat documente online sau imprimate sau pentru a permite utilizatorului să navigheze interactiv prin cod; este o practică bună să includeți docstrings în codul pe care îl scrieți, așa că faceți un obicei.

Executarea unei funcții introduce un nou tabel de simboluri folosite pentru variabilele locale ale funcției. Mai precis, toate alocările variabile ale unei funcții stochează valoarea în tabela simbolurilor locale; în timp ce referințele variabile se uită prima dată în tabela simbolurilor locale, apoi în tabelele cu simboluri locale ale funcțiilor de închidere, apoi în tabelul simbolurilor globale și, în final, în tabelul cu numele încorporate. Astfel, variabilele globale nu pot fi atribuite direct unei valori în cadrul unei funcții (cu excepția cazului în care sunt menționate într-o instrucțiune globală ), deși pot fi menționate.

Parametrii reali (argumente) la un apel funcțional sunt introduse în tabelul simbolului local al funcției numite atunci când este apelată; astfel, argumentele sunt transmise prin apel prin valoare (unde valoarea este întotdeauna o referință de obiect , nu valoarea obiectului). [1] Când o funcție apelează o altă funcție, este creată o nouă tabelă de simboluri locale pentru acel apel.

O definiție a funcției introduce numele funcției în tabela simbolică curentă. Valoarea numelui funcției are un tip care este recunoscut de către interpret ca o funcție definită de utilizator. Această valoare poate fi atribuită unui alt nume care poate fi folosit și ca o funcție. Acest lucru servește ca un mecanism general de redenumire:

>>>

>>> fib 
<function fib la 10042ed0> 
>>> f  =  fib 
>>> f ( 100 ) 
0 1 1 2 3 5 8 13 21 34 55 89

Venind din alte limbi, s-ar putea să vă obiectați că fibra nu este o funcție, ci o procedură, deoarece nu revine o valoare. De fapt, chiar și funcții fără întoarcere declarație returnează o valoare, chiar dacă una destul de plictisitoare. Această valoare se numește Niciuna (este un nume încorporat). Scrierea valorii Niciunul nu este în mod normal suprimat de interpret dacă ar fi singura valoare scrisă. Puteți vedea dacă doriți cu adevărat să utilizați print () :

>>>

>>> fib ( 0 ) 
>>> print ( fib ( 0 )) 
Nici unul

Este simplu să scrieți o funcție care returnează o listă cu numerele seriei Fibonacci, în loc să o tipăriți:

>>>

>>> def  fib2 ( n ):  # returnați seria Fibonacci până la n 
...     "" "Returnați o listă care conține seria Fibonacci până la n." " 
...     result  =  [] 
...     a ,  b  =  0 ,  1 
... în     timp ce  o  <  n : 
...         rezultat . append ( a )     # a se vedea mai jos 
...         a ,  b  =  b ,  a + b 
...     rezultatul returnat  ...

>>> f100  =  fib2 ( 100 )     # numesc 
>>> F100                 # scrie rezultatul 
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Acest exemplu, ca de obicei, demonstrează câteva noi caracteristici Python:

Retur Declarația revine cu o valoare dintr - o funcție. întoarcere fără un argument expresie returnează Niciuna . Falling off de la sfârșitul unei funcții, de asemenea, returnează Nici unul.
Instrucțiunea result.append (a) apelează o metodă a rezultatului obiectului listă . O metodă este o funcție care "aparține" unui obiect și este numită obj.methodname , unde objeste un obiect (aceasta poate fi o expresie), iar methodname este numele unei metode care este definită de tipul obiectului. Diferitele tipuri definesc diferite metode. Metodele de diferite tipuri pot avea același nume fără a cauza ambiguități. (Este posibil să definiți propriile tipuri de obiecte și metode, folosind clase , vedeți Clase ) Metoda append ()prezentată în exemplu este definită pentru obiectele din listă; adaugă un nou element la sfârșitul listei. În acest exemplu este echivalent cu rezultatul = rezultat + [a] , dar mai eficient.

4.7. Mai multe despre definirea funcțiilor

De asemenea, este posibil să se definească funcții cu un număr variabil de argumente. Există trei forme care pot fi combinate.

4.7.1. Valori implicite ale argumentelor

Forma cea mai utilă este să specificați o valoare implicită pentru unul sau mai multe argumente. Aceasta creează o funcție care poate fi apelată cu mai puține argumente decât este definită pentru a permite. De exemplu:

def  ask_ok ( promptă ,  reîncearcă = 4 ,  plângere = 'Da sau nu, te rog!' ): în 
    timp ce  Adevărat : 
        OK  =  intrare ( solicitare ) 
        dacă este  OK  în  ( 'y' ,  'voi' ,  'da' ): 
            întoarce  Adevărat 
        dacă  ok  în  ( 'n' ,  'nu' ,  'nop' ,  'nope' ): 
            întoarcere  False 
        retries  =  retries  - 1 
        dacă  retries  <  0 : 
            raise  IOError ( "utilizator necooperant" ) 
        print ( plângere )

Această funcție poate fi apelată în mai multe moduri:

precizându -se numai argumentul obligatoriu: ask_ok ( „Nu ai într - adevăr doriți sărenunțați?“)
oferind unul dintre argumentele opționale: ask_ok ( „OK pentru a suprascrie ? fișierul“,2)
sau chiar da toate argumentele: ask_ok ( „OK pentru a suprascrie fișierul?“, 2, „Haipe, doar da sau nu!“)

Acest exemplu introduce , de asemenea , în cuvinte cheie. Aceasta testează dacă o secvență conține o anumită valoare sau nu.

Valorile implicite sunt evaluate în punctul de definire a funcției în domeniul definitoriu , astfel încât

i  =  5

def  f ( arg = i ): 
    print ( arg )

i  =  6 
f ()

va imprima 5 .

Avertisment important: Valoarea implicită este evaluată o singură dată. Aceasta face o diferență când implicit este un obiect mutabil, cum ar fi lista, dicționarul sau instanțele majorității clasei. De exemplu, următoarea funcție acumulează argumentele care i-au fost transmise în apelurile următoare:

def  f ( a ,  L = []): 
    L . adăugați ( a ) 
    returnați  L

print ( f ( 1 )) 
print ( f ( 2 )) 
print ( f ( 3 ))

Aceasta va fi imprimată

[ 1 ] 
[ 1 ,  2 ] 
[ 1 ,  2 ,  3 ]

Dacă nu doriți ca parola implicită să fie împărțită între apelurile ulterioare, puteți scrie funcția în felul acesta:

def  f ( a ,  L = None ): în 
    cazul în care  L  este  None : 
        L  =  [] 
    L . adăugați ( a ) 
    returnați  L

4.7.2. Argumentele pentru cuvinte cheie

Funcțiile pot fi de asemenea apelate folosind argumentele de cuvinte cheie ale formulei kwarg = value . De exemplu, următoarea funcție:

def  papagal ( tensiune ,  starea = 'o rigid' ,  acțiune = 'Voom' ,  tip = 'norvegian albastru' ): 
    Print ( "- Acest papagal nu" ,  acțiune ,  sfârșitul = '' ) de 
    imprimare ( „dacă ați a pus“ ,  tensiune ,  "volți prin ea". ) 
    Print ( "- penaj Lovely, a" , de  tip ) 
    print ( "- e" , stat ,  "!")

acceptă un argument necesar ( tensiune ) și trei argumente opționale ( stare , acțiune și tip ). Această funcție poate fi apelată în oricare din următoarele moduri:

papagal ( 1000 )                                           # 1 pozițional argument 
papagal ( tensiune = 1000 )                                   # 1 cuvânt cheie argument 
papagal ( tensiune = 1000000 ,  acțiune = 'VOOOOOM' )              # 2 argumente cuvânt cheie 
papagal ( acțiune = 'VOOOOOM' ,  tensiune = 1000000 )              # 2 argumente cuvinte cheie 
papagal ( "un milion" ,  "lipsă de viață" ,  "salt" )          argumente 
pozitive # 3 papagal ('o mie' ,  stat = 'împingând margaretele' )   # 1 pozițional, 1 cuvânt cheie

dar toate apelurile următoare ar fi nevalide:

papagal ()                      # necesar lipsește argumentul 
papagal ( tensiune = 5,0 ,  'mort' )   # Argumentul de bază non-cuvânt cheie după un argument cuvânt cheie 
papagal ( 110 ,  tensiune = 220 )      # valoarea duplicat pentru același argument 
papagal ( actor = 'John Cleese' )   argument argument # necunoscut

Într-un apel pentru funcții, argumentele cuvintelor cheie trebuie să respecte argumentele poziționale. Toate argumentele de cuvinte cheie trecute trebuie să se potrivească cu unul dintre argumentele acceptate de funcție (de exemplu, actorul nu este un argument valid pentru funcția de papagal ) și ordinea lor nu este importantă. Acest lucru include și argumente non-opționale (de exemplu, papagalul (tensiunea = 1000) este valabil și). Nici un argument nu poate primi o valoare mai mult decât o dată. Iată un exemplu care nu reușește din cauza acestei restricții:

>>>

>>> Funcția def  ( a ): ... pass ... >>> funcția ( 0 , a = 0 ) Traceback (ultimul apel ultim): 
  Fișier "<stdin>" , line 1 , in ? TypeError : function () a primit mai multe valori pentru argumentul "a"

Atunci când este prezent un parametru formal final al formulei ** , acesta primește un dicționar (vezi tipurile de mapare - dict ) care conțin toate argumentele cuvintelor cheie, cu excepția celor care corespund unui parametru formal. Aceasta poate fi combinată cu un parametru formal al formularului * (descris în următoarea subsecțiune) care primește o tuplă care conține argumentele poziționale dincolo de lista de parametri formali. ( * numele trebuie să aibă loc înainte de ** nume .) De exemplu, dacă definim o funcție ca aceasta:

def  cheeseshop ( un fel ,  * argumente ,  ** cuvinte cheie ): 
    Print ( "- Ai" , un  fel ,  "?" ) de 
    imprimare ( "- Îmi pare rău, suntem cu toții în afara" , un  fel ) 
    pentru  arg  în  argumente : 
        imprimare ( arg ) 
    Print ( "-"  *  40 ) 
    chei  =  sortate ( cuvinte cheie . chei ()) 
    pentru  kw în  chei : 
        imprimare ( kw ,  ":" ,  cuvinte cheie [ kw ])

Ar putea fi numit astfel:

cheeseshop ( "Limburger" ,  "Este foarte alergat, domnule" , 
           "Este foarte foarte, foarte fugi, domnule" , 
           magazin = "Michael Palin" , 
           client = "John Cleese" , 
           sketch = "Cheese Shop Sketch" )

și, desigur, ar tipări:

- Ai vreun Limburger?
- Îmi pare rău, am ieșit din Limburger
E foarte risipit, domnule.
Este într-adevăr foarte, foarte curgător, domnule.
----------------------------------------
client: John Cleese
negustor: Michael Palin
schiță: Schița magazinelor de brânzeturi

Rețineți că lista de nume de cuvinte cheie ale cuvintelor cheie este creată prin sortarea rezultatelor metodei tastelor () ale dicționarului cuvintelor cheie înainte de a imprima conținutul; dacă acest lucru nu se face, ordinea în care sunt imprimate argumentele este nedefinită.

4.7.3. Liste de argumente libere

În cele din urmă, opțiunea cea mai puțin frecvent utilizată este de a specifica că o funcție poate fi apelată cu un număr arbitrar de argumente. Aceste argumente vor fi înfășurate într-o tuplă (a se vedea Tupele și secvențele ). Înainte de numărul variabil de argumente, pot apărea zero sau mai multe argumente normale.

def  write_multiple_items ( fișier ,  separator ,  * args ): 
    fișier . scrie ( separator . join ( args ))

În mod normal, aceste argumente variadic vor fi ultime în lista parametrilor formali, pentru că vor scoate toate argumentele de intrare rămase care sunt transmise funcției. Orice parametri formali care apar după parametrul * args sunt argumentele "doar pentru cuvinte cheie", ceea ce înseamnă că ele pot fi folosite doar ca cuvinte cheie, nu ca argumente poziționale.

>>>

>>> def  concat ( * args ,  sep = "/" ): 
...    return  sep . se alăture ( args ) 
... 
>>> concat ( "pământ" ,  "Marte" ,  "Venus" ) 
'pământ / Marte / Venus' 
>>> concat ( "pământ" ,  "Mars" ,  "Venus" ,  sep = "." ) 
"earth.mars.venus"

4.7.4. Despachetarea listelor de argumente

Situația inversă apare atunci când argumentele se află deja într-o listă sau în tuplu, dar trebuie să fie despachetate pentru un apel de funcție care necesită argumente poziționale separate. De exemplu, funcția range () încorporată așteaptă argumente separate de pornire și oprire . Dacă acestea nu sunt disponibile separat, scrieți apelul pentru funcții cu * -operatorul pentru a despacheta argumentele dintr-o listă sau dintr-o listă:

>>>

>>> lista ( interval ( 3 ,  6 ))             # apel normal cu argumente distincte 
[3, 4, 5] 
>>> ARGS  =  [ 3 ,  6 ] 
>>> lista ( interval ( * args ))             # apel cu argumente despachetat dintr-o listă 
[3, 4, 5]

În același mod, dicționarele pot furniza argumente de cuvinte cheie cu ** -operator:

>>>

>>> def  papagal ( tensiune ,  starea = 'o rigid' ,  acțiune = 'Voom' ): 
...     Print ( "- Acest papagal nu" ,  acțiune ,  sfârșitul = '' ) 
...     Print ( " dacă puneți " ,  tensiunea ,  " volte prin el " ,  end = '' ) 
...     tipăriți ( " E's " ,  state ,  "! " ) 
...
>>> d =  { "Tensiune" :  "patru milioane" ,  " de stat" :  "bleedin' defunctului" ,  "acțiune" :  "VOOM" } 
>>> papagal ( ** d ) 
- Acest papagal nu ar Voom dacă ai pus patru milioane de volți prin el. E bleedin a demisionat!

4.7.5. Expresii Lambda

Funcțiile anonime mici pot fi create cu cuvântul cheie lambda . Această funcție returnează suma celor două argumente: lambda a, b: a + b . Funcțiile Lambda pot fi utilizate ori de câte ori sunt necesare obiecte funcționale. Acestea sunt limitate sintactic la o singură expresie. Semantic, ele sunt doar zahăr sintactic pentru o definiție normală a funcției. Asemenea definițiilor de funcții imbricate, funcțiile lambda pot să vadă variabile din domeniul de aplicare care conține:

>>>

>>> def  make_incrementor ( n ): 
...     întoarcere  lambda  x :  x  +  n 
... 
>>> f  =  make_incrementor ( 42 ) 
>>> f ( 0 ) 
42 
>>> f ( 1 ) 
43

Exemplul de mai sus utilizează o expresie lambda pentru a returna o funcție. O altă utilizare este aceea de a transmite o funcție mică ca argument:

>>>

>>> perechi  =  [( 1 ,  'unul' ),  ( 2 ,  'două' ),  ( 3 ,  'trei' ),  ( 4 ,  'patru' )] 
>>> perechi . sortare ( cheie = pereche lambda  : pereche [ 1 ]) >>> perechi [(4, 'patru'], (1, 'unul'), 

4.7.6. Structuri de documentare

Iată câteva convenții despre conținutul și formatarea șirurilor de documentație.

Prima linie trebuie să fie întotdeauna un rezumat scurt și concis al scopului obiectului. Pentru brevitate, nu ar trebui să precizeze în mod explicit numele sau tipul obiectului, deoarece acestea sunt disponibile prin alte mijloace (cu excepția cazului în care numele se întâmplă să fie un verb care descrie funcționarea unei funcții). Această linie trebuie să înceapă cu o literă mare și să se încheie cu o perioadă.

Dacă există mai multe linii în șirul de documentație, al doilea rând trebuie să fie necompletat, separând vizual rezumatul de restul descrierii. Următoarele rânduri ar trebui să fie unul sau mai multe paragrafe care descriu convențiile de apel ale obiectului, efectele sale secundare etc.

Parserul Python nu dezinstalează indentarea de la literali de șir multi-line în Python, așa că instrumentele care procesează documentația trebuie să desprindă indentarea, dacă se dorește. Aceasta se face folosind următoarea convenție. Prima linie ne-goală după prima linie a șirului determină cantitatea de indentare pentru întregul șir de documentație. (Nu putem folosi prima linie deoarece este în general adiacentă citatelor de deschidere ale șirului, astfel încât indentarea sa nu este vizibilă în literalul șir.) Spațiul alb "echivalent" cu această indentare este apoi desprins de la începutul tuturor liniilor șirului . Linii care sunt mai puțin indentate nu trebuie să apară, dar dacă se întâmplă, toate spațiile lor de vârf trebuie să fie dezbrăcate. Echivalența spațiilor albe trebuie testată după expansiunea filelor (în mod normal, la 8 spații).

Iată un exemplu de docstring multi-linie:

>>>

>>> def  my_function (): 
...     "" "Nu faceți nimic, ci documentați-l 
...
...     Nu, într-adevăr, nu face nimic. 
...     "" 
... ...     treceți 
... 
>>> print ( my_function . __doc__ ) 
Nu faceți nimic, ci documentați-l.

    Nu, într-adevăr, nu face nimic.

4.7.7. Annotările funcției

Funcțiile adnotărilor sunt complet opționale, informații despre metadatele arbitrare despre funcțiile definite de utilizator. Nici Python, nici biblioteca standard nu utilizează adnotări de funcții în nici un fel; această secțiune arată doar sintaxa. Proiectele terților pot folosi adnotări de funcții pentru documentare, verificări de tip și alte utilizări.

Adnotările sunt stocate în atributul __annotations__ al funcției ca dicționar și nu au efect asupra niciunei alte părți a funcției. Adnotările adnotărilor sunt definite după un nume de parametru printr-o colonă, urmată de o expresie evaluând valoarea adnotării. Returnarea adnotărilor este definită printr-un literal -> , urmat de o expresie, între lista de parametri și colon care denotă sfârșitul instrucțiunii def . Următorul exemplu are un argument pozițional, un argument cheie și valoarea returnată adnotată cu nonsens:

>>>

>>> def  f ( sunca :  42 ,  ouă :  int  =  'spam - ului' )  ->  "Nimic de văzut aici" : 
...     Print ( "Adnotările:" ,  f . __annotations__ ) 
...     Print ( "Argumente:" ,  șuncă ,  ouă ) 
... 
>>> f ( 'minunat' ) 
adnotărilor: { 'ouă': <clasa 'int'>, 'return': 'Nimic de văzut aici', 'șuncă': 42} 
Argumente:minunat spam

4.8. Intermezzo: Stilul de codificare

Acum că sunteți pe punctul de a scrie mai multe piese mai complexe de Python, este un moment potrivit să vorbiți despre stilul de codare . Cele mai multe limbi pot fi scrise (sau mai concise, formatate) în diferite stiluri; unele sunt mai ușor de citit decât altele. A face ușor pentru alții să vă citească codul este întotdeauna o idee bună, și adoptarea unui stil de codare frumos ajută extraordinar pentru asta.

Pentru Python, PEP 8 a apărut ca ghid de stil pe care majoritatea proiectelor respectă; promovează un stil de codare foarte lizibil și plăcut pentru ochi. Fiecare dezvoltator Python ar trebui să o citească la un moment dat; aici sunt cele mai importante puncte extrase pentru tine:

Utilizați indentare cu 4 spații și nu există file.

4 spații sunt un compromis bun între indentarea mică (permite o adâncime de cuibare mai mare) și o indentare mare (mai ușor de citit). Filele introduc confuzie și sunt cel mai bine evitate.

Înfășurați linii astfel încât să nu depășească 79 de caractere.

Acest lucru ajută utilizatorii cu afișaje mici și face posibilă existența mai multor fișiere de coduri pe ecranele mai mari.

Utilizați linii goale pentru a separa funcțiile și clasele și blocurile mai mari de coduri din interiorul funcțiilor.

Când este posibil, puneți comentariile pe o linie proprie.

Utilizați docstrings.

Utilizați spațiile în jurul operatorilor și după virgule, dar nu direct în interiorul bracketing constructe: `a = f (1, 2) + g (3, 4)` .

Denumiți cursurile și funcțiile în mod consecvent; convenția este de a folosi `CamelCase` pentru clase și `lower_case_with_underscores` pentru funcții și metode. Utilizați întotdeauna `sine` ca nume pentru primul argument al metodei (consultați A First Look at Classes pentru mai multe despre clase și metode).

Nu utilizați codificări fanteziste dacă codul dvs. este destinat să fie utilizat în medii internaționale. Python implicit, UTF-8, sau chiar simplu ASCII funcționează cel mai bine în orice caz.

De asemenea, nu utilizați caractere non-ASCII în identificatori dacă există doar cel mai mic șansă ca persoanele care vorbesc o limbă diferită să citească sau să mențină codul.

Notă de subsol

[1] De fapt, apelul după referința obiectului ar fi o descriere mai bună, deoarece dacă un obiect mutabil este trecut, apelantul va vedea orice schimbare pe care apelantul o face (elementele introduse în listă).

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

Python un limbaj accesibil

2018-01-19T13:28:00.001-08:00

Python este un limbaj de programare general, versatil și puternic. Este o limbă maternă excelentă, deoarece este concisă și ușor de citit. Orice vrei să faci, Python o poate face. De la dezvoltarea web la învățarea automată până la știința datelor

Structuri de date Acest capitol descrie unele lucruri pe care le-ați învățat deja în detaliu și adaugă și câteva lucruri noi.Mai multe despre Liste

Tipul de date listă are mai multe metode. Iată toate metodele de listă a obiectelor:

listă. adăugați ( x ): Adăugați un element la sfârșitul listei. Echivalent cu o [len (a):] = [x] .

listă. extinde ( L ): Extindeți lista adăugând toate elementele din lista dată. Echivalent cu un [len (a):] = L .

listă. inserați ( i , x ): Introduceți un element într-o poziție dată. Primul argument este indexul elementului înaintea căruia se introduce, astfel încât a.insert (0, x) se inserează în partea din față a listei și a.insert (len (a), x) este echivalent cu a.append ( x) .

listă. eliminați ( x ): Eliminați primul element din lista a cărei valoare este x . Este o eroare dacă nu există un astfel de element.

listă. pop ( [ i ] ): Scoateți articolul din poziția dată din listă și returnați-l. Dacă nu este specificat niciun index, a.pop () elimină și returnează ultimul element din listă. (Parantezele pătrate în jurul valorii de i în semnătura metodei indică faptul că parametrul este opțional, nu că trebuie să introduceți paranteze pătrate în acea poziție. Veți vedea această notație frecvent în Python Library Reference.)

listă. clar ( ): Eliminați toate elementele din listă. Echivalent cu del a [:] .

listă. index ( x ): Returnați indexul în lista primului element a cărui valoare este x . Este o eroare dacă nu există un astfel de element.

listă. număr ( x ): Reveniți de câte ori x apare în listă.

listă. sort ( ): Sortați elementele din listă în loc.

listă. invers ( ): Inversați elementele din listă în loc.

listă. copie ( ): Returnați o copie superioară a listei. Echivalent cu un [:] .

Un exemplu care utilizează majoritatea metodelor listă:

>>>

>>> a  =  [ 66,25 ,  333 ,  333 ,  1 ,  1234,5 ] 
>>> print ( a . Conta ( 333 ),  un . Conta ( 66,25 ),  un . Număr ( 'x' )) 
2 1 0 
>>> a . inserați ( 2 ,  - 1 ) 
>>> a . adăuga ( 333 ) 
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333] 
>>> a . index ( 333 ) 
1 
>>> a . eliminați ( 333 ) 
>>> a 
[66.25, -1, 333, 1, 1234.5, 333] 
>>> a . inversă () 
>>> a 
[333, 1234.5, 1, 333, -1, 66.25] 
>>> a . sortare () 
>>> a 
[-1, 1, 66.25, 333, 333, 1234.5]

S-ar putea să fi observat că metode cum ar fi inserarea , ștergerea sau sortarea care modifică lista nu au nici o valoare returnată imprimată - acestea returnează Niciuna . [1] Acesta este un principiu de proiectare pentru toate structurile de date mutabile din Python.

Ce să mai citim?

  Ne pregătim pentru Marte
   Robot pe Marte

Ce să mai citim?
Tatăl fondator al Uniunii Europene.
Colonizarea de pe Marte !
  Ne pregătim pentru Marte
Colonizarea Marte poate determina umanitatea să-și modifice ADN-ul ?
Cine mai urăște să poarte mască?

5.1.1. Utilizarea listelor ca stive

Metodele din listă fac foarte ușor utilizarea unei liste ca stiva, unde ultimul element adăugat este primul element preluat ("last-in, first-out"). Pentru a adăuga un element în partea de sus a stivei, utilizați atașați () . Pentru a prelua un element din partea de sus a stivei, folosiți pop () fără un index explicit. De exemplu:

>>>

>>> stivă  =  [ 3 ,  4 ,  5 ] 
>>> stivă . adăugați ( 6 ) 
>>> stivă . adăugați ( 7 ) 
>>> stivă 
[3, 4, 5, 6, 7] 
>>> stivă . pop () 
7 
>>> stivă 
[3, 4, 5, 6] 
>>> stivă . pop () 
6 
>>> stivă . pop () 
5 
>>> stivă 
[3, 4]

5.1.2. Utilizarea listelor ca Cozile

Este, de asemenea, posibilă utilizarea unei liste ca o coadă, în care primul element adăugat este primul element preluat ("first-in, first-out"); totuși, listele nu sunt eficiente în acest scop. În timp ce apendicele și pop-urile de la sfârșitul listei sunt rapide, inserarea sau ștampila de la începutul unei liste este lentă (deoarece toate celelalte elemente trebuie să fie deplasate de una).

Pentru a pune în aplicare o coadă, utilizați collections.deque care a fost proiectat pentru a avea rapide apendice și apare de la ambele capete. De exemplu:

>>>

>>> din  colecții  import  deque 
>>> queue  =  deque ( "Eric" ,  "John" ,  "Michael" )) 
>>> coadă . append ( "Terry" )            # Terry sosește 
>>> coadă . append ( "Graham" )           # Graham sosește 
>>> coadă . popleft ()                  # Primul care ajunge acum lasă 
"Eric" 
>>> coadă .                 
'John' 
>>> coadă                            # 
Coada rămasă în ordinea sosirii deque (['Michael', 'Terry', 'Graham'])

5.1.3. Lista înțelegerilor

Lista de înțelegeri oferă o modalitate concisă de a crea liste. Aplicațiile comune sunt de a face noi liste în care fiecare element este rezultatul unor operații aplicate fiecărui membru al unei alte secvențe sau iterabil sau pentru a crea o subsecventa a acelor elemente care satisfac o anumită condiție.

De exemplu, presupunem că vrem să creăm o listă de pătrate, cum ar fi:

>>>

>>> pătrate  =  [] 
>>> pentru  x  în  intervalul ( 10 ): 
...     pătrate . adăugați ( x ** 2 ) 
... 
>>> pătrate 
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Putem obtine acelasi rezultat cu:

pătrate  =  [ x ** 2  pentru  x  în  intervalul ( 10 )]

Aceasta este, de asemenea, echivalentă cu pătratele = listă (hartă (lambda x: x ** 2,interval (10))) , dar este mai concisă și mai lizibilă.

O înțelegere a listei constă din paranteze care conțin o expresie urmată de o clauză pentru , apoi de zero sau mai mult pentru sau în cazul clauzelor. Rezultatul va fi o nouă listă care rezultă din evaluarea expresiei în contextul clauzelor for și if care o urmează. De exemplu, această listcomp combină elementele a două liste dacă nu sunt egale:

>>>

>>> [( x ,  y )  pentru  x  în  [ 1 , 2 , 3 ]  pentru  y  în  [ 3 , 1 , 4 ]  dacă  x  ! =  Y ] 
[(1, 3), (1, 4), (2 , 3), (2, 1), (2, 4), (3, 1), (3, 4)]

și este echivalent cu:

>>>

>>> fag  =  [] 
>>> pentru  x  în  [ 1 , 2 , 3 ]: 
...     pentru  y  în  [ 3 , 1 , 4 ]: 
...         dacă  x  ! =  y : 
...             piepteni . atașa (( x ,  y )) 
... 
>>> piepteni 
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1 ), (3, 4)]

Rețineți cum ordinea instrucțiunilor for și if este aceeași în ambele aceste fragmente.

Dacă expresia este o tuplă (de exemplu, (x, y) din exemplul anterior), trebuie să fie paranteză.

>>>

>>> vec  =  [ - 4 ,  - 2 ,  0 ,  2 ,  4 ] 
>>> # a crea o nouă listă cu valorile dublate 
>>> [ x * 2  pentru  x  în  vec ] 
[-8, -4, 0 , 4, 8] 
>>> # filtrați lista pentru a exclude numerele negative 
>>> [ x  pentru  x  în  vec  dacă  x  > =  0 ] 
[0, 2, 4] 
>>> # aplică o funcție la toate elementele 
> >>[abs ( x )  pentru  x  în  vec ] 
[4, 2, 0, 2, 4] 
>>> # apela o metodă pe fiecare element 
>>> freshfruit  =  [ 'banana' ,  'loganberry' ,  'fructul pasiunii' ] 
> >> [ arma . benzi ()  pentru  arme  în  freshfruit ] 
[ 'banana', 'loganberry', 'fructul pasiunii'] 
>>> # a crea o listă de 2-tuple ca (număr, pătrat) 
>>> [( x ,  pentru  x  în  interval ( 6 )] 
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)] 
>>> # tensiunea trebuie să fie parantezată, în caz contrar apare o eroare 
>>> [ x ,  x ** 2  pentru  x  în  intervalul ( 6 )] 
  Fișierul "<stdin>", rândul 1, în? 
    [x, x ** 2 pentru x în intervalul (6)] 
               ^ 
SyntaxError: sintaxa nevalidă 
>>> # aplatizarea unei liste folosind o listă compusă cu două 'pentru' 
>>> vec  =  [[ 1 , 2 , 3 ] [ 4 , 5 , 6 ],  [ 7 , 8 , 9 ]] 
>>> [ num  pentru  elem  în  vec  pentru  num  în  elem ] 
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Lista comprehensions poate conține expresii complexe și funcții imbricate:

>>>

>>> din  importul de matematică  pi >>> [ str ( rotund ( pi , i )) pentru i în intervalul ( 1 , 6 )] ['3.1', '3.14', '3.142', '3.1416' ]

5.1.4. Înțelegeri ale listei încorporate

Expresia inițială într-o înțelegere a listei poate fi orice expresie arbitrară, incluzând o altă înțelegere a listei.

Luați în considerare următorul exemplu de matrice 3x4 implementată ca o listă cu 3 liste de lungime 4:

>>>

>>> matrice  =  [ 
...     [ 1 ,  2 ,  3 ,  4 ], 
...     [ 5 ,  6 ,  7 ,  8 ], 
...     [ 9 ,  10 ,  11 ,  12 ], 
... ]

Următoarea listă de înțelegere va transpune rândurile și coloanele:

>>>

>>> [[ rând [ i ]  pentru  rândul  în  matrice ]  pentru  i  în  intervalul ( 4 )] 
[[1, 5, 9], [ 8, 12]]

Așa cum am văzut în secțiunea anterioară, lista listată imbricată este evaluată în contextul pentrucare o urmează, deci acest exemplu este echivalent cu:

>>>

>>> transpus  =  [] 
>>> pentru  i  în  intervalul ( 4 ): 
...     transpus . adăugați ([ rând [ i ]  pentru  rând  în  matrice ]) 
... 
>>> transpuse 
[[1, 5, 9], [2, 6, 10], [ 12]]

care, la rândul său, este la fel ca:

>>>

>>> transpus  =  [] 
>>> pentru  i  în  raza de acțiune ( 4 ): 
...     # Următoarele 3 rânduri implementează lista imbricată 
...     transposed_row  =  [] 
...     pentru  rândul  în  matrice : 
...         transposed_row . adăugați ( rând [ i ]) 
...     transpus . adăugați ( transposed_row ) 
... 
>>> transpus 
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4,8,12]]

În lumea reală, ar trebui să preferați funcțiile încorporate în declarațiile de flux complexe. Funcția zip () ar face o treabă excelentă pentru acest caz de utilizare:

>>>

>>> lista ( zip ( * matrix )) 
[(1, 5, 9), (2, 6, 10), (3, 7, 11)

Consultați Dezarhivarea listelor de argumente pentru detalii despre asterisc în acest rând.

5.2. `Del` Declarația

Există o modalitate de a elimina un element dintr-o listă în locul indexului său, în locul valorii sale: instrucțiunea del . Aceasta diferă de metoda pop () care returnează o valoare. Instrucțiunea delpoate fi de asemenea folosită pentru a elimina felii dintr-o listă sau pentru a șterge întreaga listă (ceea ce am făcut mai devreme prin alocarea unei liste goale la felie). De exemplu:

>>>

>>> a  =  [ - 1 ,  1 ,  66.25 ,  333 ,  333 ,  1234,5 ] 
>>> del  a [ 0 ] 
>>> a 
[1, 66.25, 333, 333, 1234,5] 
>>> del  a [ 2 : 4 ] 
>>> a 
[1, 66.25, 1234.5] 
>>> del  a [:] 
>>> a 
[]

del poate fi, de asemenea, utilizat pentru a șterge variabilele întregi:

>>>

>>> del  a

Referindu-se la denumirea de mai jos este o eroare (cel puțin până când îi este atribuită o altă valoare). Vom găsi alte utilizări pentru del mai târziu.

5.3. Tupele și secvențe

Am văzut că listele și șirurile au multe proprietăți comune, cum ar fi operațiile de indexare și de tăiere. Acestea sunt două exemple de tipuri de date de secvență (vedeți Tipuri de secvențe - listă, tuplă, interval ). Din moment ce Python este un limbaj în evoluție, pot fi adăugate alte tipuri de date secvențiale. Există, de asemenea, un alt tip de date standard de secvență: tupla .

O trupă constă dintr-un număr de valori separate prin virgule, de exemplu:

>>>

>>> t  =  12345 ,  54321 ,  "salut!" 
>>> t [ 0 ] 
12345 
>>> t 
(12345, 54321, 'alo!') 
>>> # Tuples poate fi imbricate: 
... u  =  t ,  ( 1 ,  2 ,  3 ,  4 ,  5 ) 
> >> u 
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5)) 
>>> # Tuples sunt imuabile: 
... t [ 0 ]  =  88888
Traceback (cel mai recent apel ultima): 
  Fișier "<stdin>" , linia 1 , în <modul> 
TypeError : 'tuplu' obiect nu are suport pentru atribuirea element 
>>> # dar ele pot conține obiecte modificabile: 
... v  =  ( [ 1 ,  2 ,  3 ],  [ 3 ,  2 ,  1 ]) 
>>> v 
([1, 2, 3], [3, 2, 1]

După cum vedeți, pe tuplele de ieșire sunt întotdeauna închise în paranteze, astfel că nopțile imbricate sunt interpretate corect; ele pot fi introduse cu sau fără paranteze înconjurătoare, deși adesea paranteze sunt necesare oricum (dacă tuplul face parte dintr-o expresie mai mare). Nu este posibilă alocarea elementelor individuale ale unei tuple, însă este posibil să se creeze tupluri care conțin obiecte mutabile, cum ar fi liste.

Deși tuplele pot părea similare cu listele, ele sunt adesea folosite în situații diferite și în scopuri diferite. Tupele sunt imuabile și conțin, de obicei, o secvență eterogenă de elemente care sunt accesate prin despachetare (a se vedea mai târziu în această secțiune) sau indexare (sau chiar prin atribut în cazul numerelor ). Listele sunt mutabile , iar elementele lor sunt, de obicei, omogene și sunt accesate prin iterarea în listă.

O problemă specială este construirea de tupluri care conțin 0 sau 1 elemente: sintaxa are unele ciudățenii suplimentare pentru a le acomoda. Gândurile goale sunt construite de o pereche goală de paranteze; un tuplu cu un element este construit urmând o valoare cu o virgulă (nu este suficient să închideți o singură valoare în paranteze). Urât, dar eficace. De exemplu:

>>>

>>> empty  =  () 
>>> singleton  =  'hello' ,     # <- virgula cu note în urmă 
>>> len ( gol ) 
0 
>>> len ( singleton ) 
1 
>>> singleton 
('hello',)

Declarația t = 12345, 54321, "salut!" este un exemplu de ambalare în tuple : valorile 12345 , 54321 și "salut!" sunt ambalate împreună într-o tuplă. Este posibilă și operarea inversă:

>>>

>>> x ,  y ,  z  =  t

Aceasta se numește, suficient de adecvat, despachetarea succesivă și funcționează pentru orice secvență din partea dreaptă. Descărcarea secvențelor necesită existența a numeroase variabile pe partea stângă a semnalului egal, deoarece există elemente în secvență. Rețineți că atribuirea mai multor este într-adevăr doar o combinație de împachetare tuplă și despachetare succesivă.

5.4. Seturi

Python include, de asemenea, un tip de date pentru seturi . Un set este o colecție neordonată fără elemente duplicate. Utilizările de bază includ testarea membrilor și eliminarea intrărilor duplicate. Setarea obiectelor suportă și operații matematice cum ar fi unirea, intersecția, diferența și diferența simetrică.

Comenzile curry sau funcția set () pot fi folosite pentru a crea seturi. Notă: pentru a crea un set gol trebuie să utilizați set () , nu {} ; acesta din urmă creează un dicționar gol, o structură de date pe care o discutăm în secțiunea următoare.

Iată o scurtă demonstrație:

>>>

>>> coș  =  { 'apple' ,  'orange' ,  'apple' ,  'pear' ,  'orange' ,  'banana' } 
>>> print ( coș )                       # arată că duplicatele au fost eliminate 
{ banana "," pere "," mere "} 
>>> " portocaliu "  în  coș                  # rapid de testare a calității de membru 
Adevărat 
>>> 'crabgrass'  în  coș 
Fals

>>> # set operații pe Demonstrați scrisori unice de la două cuvinte 
... 
>>> un  =  set ( 'Abracadabra' ) 
>>> b  =  set ( 'alacazam' ) 
>>> un                                   scrisori # unic într - un 
{ 'o ',' r ',' b ',' c ',' d '} 
>>> a  -  b                               # litere într-un, dar nu în b 
{' r ',' d ',' b '} 
>>> a  |  b "                               litere în a sau b 
{'a', 'c', 'r', 'd', 'b', 'm', '
                                

a  ^  b                               # litere în a sau b, dar nu ambele 
{'r', 'd', 'b', 'm', 'z', 'l'}

În mod similar cu înțelegerile din listă , sunt de asemenea acceptate înțelegeri setate:

>>>

>>> a  =  { x  pentru  x  în  'abracadabra'  dacă  x  nu este  în  'abc' ) 
>>> a 
{'r', 'd'}

5.5. Dicționare

Un alt tip de date util construit în Python este dicționarul (consultați Tipuri de cartografiere - dict ). Dicționarele sunt uneori găsite în alte limbi ca "amintiri asociative" sau "matrice asociative". Spre deosebire de secvențe, care sunt indexate printr-o serie de numere, dicționarele sunt indexate prin chei , care pot fi orice tip imuabil; șirurile și numerele pot fi întotdeauna chei. Tupele pot fi folosite ca chei dacă conțin numai șiruri, numere sau tuple; dacă o tuplă conține un obiect mutabil, direct sau indirect, nu poate fi folosit ca o cheie. Nu puteți utiliza listele ca chei, deoarece listele pot fi modificate în loc utilizând asignări index, alocări slice sau metode cum ar fi append () și extend () .

Cel mai bine este să gândiți un dicționar ca un set neordonat de perechi de chei: valoare , cu cerința că cheile sunt unice (într-un singur dicționar). O pereche de bretele creează un dicționar gol: {} . Plasarea unei liste separate de virgulă a perechilor de chei: valoare în cadrul brațelor adaugă cheia inițială: perechi de valori în dicționar; acesta este și modul în care sunt scrise dictionarele de ieșire.

Principalele operații dintr-un dicționar sunt stocarea unei valori cu unele chei și extragerea valorii date de tastă. Este, de asemenea, posibil să ștergeți o pereche cheie: valoare cu del . Dacă stocați utilizând o cheie deja utilizată, vechea valoare asociată acelei chei este uitată. Este o eroare să extrageți o valoare utilizând o cheie inexistentă.

Efectuarea unei liste (d.keys ()) într-un dicționar returnează o listă a tuturor cheilor folosite în dicționar, în ordine arbitrară (dacă doriți să fie sortată, utilizați în schimb sortate (d.keys () ). [2]Pentru a verifica dacă o singură tastă este în dicționar, utilizați cuvântul cheie în .

Iată un mic exemplu folosind un dicționar:

>>>

>>> tel  =  { 'jack' :  4098 ,  'sape' :  4139 ) 
>>> tel [ 'guido' ]  =  4127 
>>> tel 
{'sape': 4139, 'guido' 4098} 
>>> tel [ 'jack' ] 
4098 
>>> del  tel [ 'SAPE' ] 
>>> tel [ 'Irv' ]  =  4127 
>>> tel 
{ 'guido': 4127, 'Irv': 4127,'jack': 4098} 
>>> lista ( tel .chei ()) 
[ 'Irv', 'Guido', 'jack'] 
>>> sortate ( tel . chei ()) 
[ 'guido', 'Irv', 'jack'] 
>>> 'guido'  in  tel 
Adevărat 
>>> "Jack"  nu este  în  tel 
Fals

Constructorul dict () construiește dicționare direct din secvențe de perechi cheie-valoare:

>>>

>>> dict ( ' ( ' sape ' ,  4139 ),  ( ' guido ' ,  4127 ),  ( ' jack ' ,  4098 )]) 
{sape' 4139, jack: 4098, guido:

În plus, înțelegerile dict pot fi folosite pentru a crea dicționare din expresii cheie și valori arbitrare:

>>>

>>> { x :  x ** 2  pentru  x  în  ( 2 ,  4 ,  6 )} 
{2: 4, 4: 16, 6: 36}

Când cheile sunt șiruri simple, uneori este mai ușor să specificați perechi folosind argumentele cuvintelor cheie:

>>>

>>> dict ( sape = 4139 ,  guido = 4127 ,  jack = 4098 ) 
{'sape': 4139, 'jack': 4098, 'guido'

5.6. Tehnici looping

Când se creează buclă prin dicționare, cheia și valoarea corespunzătoare pot fi preluate în același timp folosind metoda items () .

>>>

>>> knights  =  { 'gallahad' :  'pur' ,  'robin' :  'curajos' } 
>>> pentru  k ,  v  în  cavaleri . articole (): 
...     print ( k ,  v ) 
... 
gallahad pur și simplu 
curajos

Când se trece printr-o secvență, indicele de poziție și valoarea corespunzătoare pot fi preluate în același timp folosind funcția enumerate () .

>>>

>>> pentru  i ,  v  in  enumerate ([ 'tic' ,  'tac' ,  'toe' ]): 
...     print ( i ,  v ) 
... 
0 tic 
1 tac 
2 toe

Pentru a intra în două sau mai multe secvențe în același timp, intrările pot fi asociate cu funcția zip () .

>>>

>>> întrebări  =  [ 'nume' ,  'quest' ,  'culoarea preferata' ] 
>>> răspunsuri  =  [ 'Lancelot' ,  'Sfântul Graal' ,  'albastru' ] 
>>> pentru  q ,  o  în  ZIP ( întrebări ,  răspunsuri ): 
...     Print ( 'Care este {0} este {1}?.' . format ( q ,  a )) 
... 
Care este numele tău? Este lancelot.
Care este misiunea ta? Acesta este Sfântul Graal. 
Care este culoarea ta preferata? Este albastru.

Pentru a bifa o secvență în sens invers, mai întâi specificați secvența într-o direcție înainte și apoi apelați funcția inversă () .

>>>

>>> pentru  i  în sens  invers ( interval ( 1 ,  10 ,  2 )): 
...     print ( i ) 
... 
9 
7 
5 
3 
1

Pentru a bifa o secvență în ordinea sortată, utilizați funcția sort () care returnează o nouă listă sortată, lăsând în același timp sursa neschimbată.

>>>

>>> coș  =  [ 'mere' ,  'orange' ,  'măr' ,  'pere' ,  'orange' ,  'banana' ] 
>>> pentru  f  în  sortat ( set ( coș )): 
...     print ( f ) 
... 
mere 
banane 
portocale 
pere

Pentru a modifica o secvență pe care o repetați în interiorul bucla (de exemplu, pentru a duplica anumite elemente), este recomandat să creați o copie. Lovitura peste o secvență nu face implicit o copie. Notatia de felie face ca acest lucru deosebit de convenabil:

>>>

>>> cuvinte  =  [ 'cat' ,  'fereastră' ,  'defenestrate' ] 
>>> pentru  w  în  cuvinte [:]:   # Faceți buclă pe o copie a unei liste întregi. 
...     dacă  lămâie ( w )  >  6 : 
...         cuvinte . inserați ( 0 ,  w ) 
... 
>>> cuvinte 
['defenestrate', 'cat', 'window', 'defenestrate']

5.7. Mai multe despre condițiile

Condițiile utilizate în instrucțiunile de timp și dacă pot conține orice operatori, nu doar comparații.

Operatorii de comparație în și nu în Verificați dacă apare o valoare (nu apare) într - o secvență. Operatorii este și este nu compara dacă două obiecte sunt într - adevăr același obiect; acest lucru contează doar pentru obiecte mutabile, cum ar fi listele. Toți operatorii de comparare au aceeași prioritate, care este mai mică decât cea a tuturor operatorilor numerici.

Comparațiile pot fi înlănțuite. De exemplu, un < b == c testează dacă a este mai mic decât b și în plus b este egal cu c .

Comparațiile pot fi combinate folosind operatorii booleani și și sau , iar rezultatul unei comparații (sau al oricărei alte expresii booleene) poate fi negat cu nu . Acestea au priorități mai mici decât operatorii de comparație; între ele, nu are cea mai mare prioritate și sau cea mai mică, astfel încât A și nu Bsau C este echivalent cu (A și (nu B)) sau C . Ca întotdeauna, parantezele pot fi folosite pentru a exprima compoziția dorită.

Operatorii booleeni și și sau sau așa-numiții operatori de scurt-circuit : argumentele lor sunt evaluate de la stânga la dreapta și evaluarea se oprește de îndată ce rezultatul este determinat. De exemplu, dacă A și C sunt adevărate , dar B este fals, A și B și C nu evaluează expresia C . Atunci când este folosit ca valoare generală și nu ca booleană, valoarea de retur a operatorului de scurt-circuit este ultimul argument evaluat.

Este posibil să se atribuie rezultatul unei comparații sau al altei expresii booleene unei variabile. De exemplu,

>>>

>>> string1 ,  string2 ,  string3  =  '' ,  'Trondheim' ,  'Hammer Dance' 
>>> non_null  =  string1  sau  string2  sau  string3 
>>> non_null 
'Trondheim'

Rețineți că în Python, spre deosebire de C, atribuirea nu poate apărea în interiorul expresiilor. Programatorii C ar putea bâzâi despre acest lucru, dar evită o clasă comună de probleme întâlnite în programele C: tastând = într-o expresie când == a fost intenționată.

5.8. Compararea secvențelor și a altor tipuri

Obiectele de secvență pot fi comparate cu alte obiecte cu același tip de secvență. Comparația folosește ordonarea lexicografică : mai întâi se compară primele două elemente și dacă acestea diferă, determină rezultatul comparației; dacă sunt egale, următoarele două elemente sunt comparate și așa mai departe, până când fiecare secvență este epuizată. Dacă două elemente care trebuie comparate sunt ele însele secvențe de același tip, comparația lexicografică se face recursiv. Dacă toate elementele a două secvențe se compară egale, secvențele sunt considerate egale. Dacă o secvență este o sub-secvență inițială a celeilalte, secvența mai scurtă este cea mai mică (mai mică). Ordonarea lexicografică pentru șiruri de caractere utilizează numărul codului Unicode pentru a comanda caractere individuale. Câteva exemple de comparații între secvențe de același tip:

( 1 ,  2 ,  3 )               <  ( 1 ,  2 ,  4 ) 
[ 1 ,  2 ,  3 ]               <  [ 1 ,  2 ,  4 ] 
'ABC'  <  'C'  <  'Pascal'  <  'Python' 
( 1 ,  2 ,  3 ,  4 )            <  ( 1 ,  2 ,  4 ) 
( 1 ,  2 )                  < ( 1 ,  2 ,  - 1 ) 
( 1 ,  2 ,  3 )              ==  ( 1,0 ,  2,0 ,  3,0 ) 
( 1 ,  2 ,  ( 'aa' ,  'ab' ))    <  ( 1 ,  2 ,  ( 'abc' ,  'a' ),  4 )

Rețineți că compararea obiectelor de diferite tipuri cu < sau > este legală, cu condiția ca obiectele să aibă metode de comparare adecvate. De exemplu, tipurile numerice mixte sunt comparate în funcție de valoarea lor numerică, deci 0 este egală cu 0,0, etc. Altfel, în loc să furnizeze o comandă arbitrară, interpretul va ridica o excepție TypeError .

Note de subsol

[1]	Alte limbi pot returna obiectul mutant, care permite înlănțuirea metodei, cum ar fi `d-> inserați ("a") -> eliminați ("b") -> sort ();` .

[2]	Apelarea `tastelor d ()` va returna un obiect de vizualizare a dicționarului . Acceptă operații precum testul de membru și iterația, dar conținutul său nu este independent de dicționarul original - este doar o viziune .

Modulele

Dacă renunțați la interpretul Python și îl introduceți din nou, definițiile pe care le-ați făcut (funcții și variabile) sunt pierdute. Prin urmare, dacă doriți să scrieți un program oarecum mai lung, vă recomandăm mai bine să utilizați un editor de text pentru a pregăti intrarea pentru interpret și pentru ao executa cu acel fișier ca intrare. Acest lucru este cunoscut ca crearea unui script . Pe măsură ce programul dvs. devine mai lung, vă recomandăm să îl împărțiți în mai multe fișiere pentru o întreținere mai ușoară. Poate doriți să utilizați o funcție utilă pe care ați scris-o în mai multe programe, fără a copia definiția acesteia în fiecare program.

Pentru a sprijini acest lucru, Python are o modalitate de a pune definițiile într-un fișier și de a le utiliza într-un script sau într-o instanță interactivă a interpretului. Un astfel de fișier este numit modul ; definițiile dintr-un modul pot fi importate în alte module sau în modulul principal (colecția de variabile la care aveți acces într-un script executat la nivel superior și în modul calculator).

Un modul este un fișier care conține definiții și declarații Python. Numele fișierului este numele modulului cu sufixul .py atașat. În cadrul unui modul, numele modulului (ca șir) este disponibil ca valoare a variabilei globale __name__ . De exemplu, utilizați editorul de text preferat pentru a crea un fișier numit fibo.py în directorul curent cu următorul conținut:

Modul # numere Fibonacci

def  fib ( n ):     # scrie seria Fibonacci pana la n 
    a ,  b  =  0 ,  1 în 
    timp ce  b  <  n : 
        print ( b ,  end = '' ) 
        a ,  b  =  b ,  a + b 
    print ()

def  fib2 ( n ):  # returnați seria Fibonacci până la n 
    rezultat  =  [] 
    a ,  b  =  0 ,  1 în 
    timp ce  b  <  n : 
        rezultat . append ( b ) 
        a ,  b  =  b ,  a + b 
    revenire  rezultat

Acum introduceți interpretul Python și importați acest modul cu următoarea comandă:

>>>

>>> import  fibo

Aceasta nu introduce numele funcțiilor definite în fibo direct în tabela simbolică curentă; intră doar în numele modulului fibo acolo. Folosind numele modulului puteți accesa funcțiile:

>>>

>>> fibo . fib ( 1000 ) 
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 
>>> fibo . fib2 ( 100 ) 
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 
>>> fibo . __name__ 
'fibo'

Dacă intenționați să utilizați o funcție de multe ori, puteți să o atribuiți unui nume local:

>>>

>>> fib  =  fibo . fib 
>>> fib ( 500 ) 
1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1. Mai multe despre module

Un modul poate conține instrucțiuni executabile, precum și definiții ale funcțiilor. Aceste instrucțiuni sunt destinate inițializării modulului. Ele sunt executate numai pentru prima dată când numele modulului este întâlnit într-o declarație de import. [1] (De asemenea, se execută dacă fișierul este executat ca script).

Fiecare modul are propria tabelă de simboluri private, care este utilizată ca tabelă simbol globală de toate funcțiile definite în modul. Astfel, autorul unui modul poate folosi variabilele globale în modul fără să se preocupe de ciocniri accidentale cu variabilele globale ale utilizatorului. Pe de altă parte, dacă știți ce faceți, puteți atinge variabilele globale ale unui modul cu aceeași notație folosită pentru a vă referi la funcțiile sale, modname.itemname .

Modulele pot importa alte module. Este obișnuit, dar nu este necesar să plasați toate declarațiile de import la începutul unui modul (sau script, de pildă). Numele modulelor importate sunt plasate în tabelul simbolului global al modulului de import.

Există o variantă a instrucțiunii de import care importează numele dintr-un modul direct în tabelul cu simboluri al modulului de import. De exemplu:

>>>

>>> de la  fibo  import  fib ,  fib2 
>>> fib ( 500 ) 
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Acest lucru nu introduce numele modulului din care se fac importurile în tabelul simbolurilor locale (așa că în exemplul de față fiboxul nu este definit).

Există chiar și o variantă pentru a importa toate denumirile pe care un modul le definește:

>>>

>>> de la  fibo  import  * 
>>> fib ( 500 ) 
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Aceasta importă toate denumirile, cu excepția celor care încep cu o subliniere ( _ ). În majoritatea cazurilor, programatorii Python nu utilizează această facilitate deoarece introduc un set necunoscut de nume în interpret, ascunzând eventual unele lucruri pe care le-ați definit deja.

Rețineți că, în general, practica importării * de la un modul sau un pachet este încruntată, deoarece provoacă adesea un cod ușor de citit. Cu toate acestea, este bine să o utilizați pentru a salva scrierea în sesiuni interactive.

Notă

Din motive de eficiență, fiecare modul este importat doar o singură sesiune de interpret. Prin urmare, dacă modificați modulele, trebuie să reporniți interpretul - sau, dacă este doar un modul pe care doriți să-l testați interactiv, utilizați imp.reload () , de ex. Import imp; imp.reload (modulename) .

6.1.1. Executarea modulelor ca scripturi

Când rulați un modul Python cu

python  fibo . py  < argumentele >

codul din modul va fi executat, ca și cum l-ați importat, dar cu __name__ setat la "__main__" . Aceasta înseamnă că prin adăugarea acestui cod la sfârșitul modulului dvs.:

dacă  __name__  ==  "__main__" : 
    import  sys 
    fib ( int ( sys . argv [ 1 ]))

puteți face fișierul utilizabil ca script, precum și un modul importabil, deoarece codul care analizează linia de comandă rulează numai dacă modulul este executat ca fișier "principal":

$ python fibo.py 50
1 1 2 3 5 8 13 21 34

Dacă modulul este importat, codul nu este rulat:

>>>

>>> import  fibo 
>>>

Acest lucru este adesea folosit fie pentru a oferi o interfață de utilizare convenabilă unui modul, fie pentru scopuri de testare (funcționarea modulului ca script execută o suită de testare).

6.1.2. Calea de căutare a modulului

Când un modul numit `spam` este importat, interpretul caută mai întâi un modul încorporat cu acest nume. Dacă nu este găsit, acesta caută apoi un fișier numit `spam.py` într-o listă de directoare date de variabila `sys.path` . `sys.path` este inițializată din aceste locații:

directorul care conține scriptul de intrare (sau directorul curent).

`PYTHONPATH` (o listă de nume de directoare, cu aceeași sintaxă ca variabila shell`PATH` ).

implicit pentru instalare.

După inițializare, programele Python pot modifica `sys.path` . Directorul care conține scriptul care se execută este plasat la începutul căii de căutare, înainte de calea standard a bibliotecii. Aceasta înseamnă că script-urile din directorul respectiv vor fi încărcate în locul modulelor cu același nume în directorul bibliotecii. Aceasta este o eroare, cu excepția cazului în care se intenționează înlocuirea. Vezi secțiunea Module standard pentru mai multe informații.

6.1.3. „Compilat“ fișiere Python

Pentru a accelera modulele de încărcare, Python `cachează` versiunea compilată a fiecărui modul din directorul `pycache` sub `modulul de` nume `.` `versiunea` `.pyc` , unde versiunea codifică formatul fișierului compilat; conține, în general, numărul versiunii Python. De exemplu, în versiunea CPython 3.3, versiunea compilate a spam.py va fi stocată ca `pycache / spam.cpython-33.pyc` . Această convenție de numire permite modulelor compilate din diferite versiuni și diferite versiuni ale Python să coexiste.

Python verifică data modificării sursei împotriva versiunii compilate pentru a vedea dacă este depășită și trebuie să fie recompilată. Acesta este un proces complet automat. De asemenea, modulele compilate sunt independente de platformă, astfel încât aceeași bibliotecă poate fi împărțită între sisteme cu arhitecturi diferite.

Python nu verifică memoria cache în două situații. În primul rând, întotdeauna recompilează și nu stochează rezultatul pentru modulul încărcat direct din linia de comandă. În al doilea rând, nu verifică memoria cache dacă nu există niciun modul sursă. Pentru a suporta o distribuție non-sursă (compilate numai), modulul compilat trebuie să fie în directorul sursă și nu trebuie să existe un modul sursă.

Câteva sfaturi pentru experți:

Puteți utiliza comutatoarele -O sau -OO din comanda Python pentru a reduce dimensiunea unui modul compilat. `-O` Comutatorul elimină afirma declarații, `-OO` comutatorul îndepårteazå afirma declarații și șiruri doc. Întrucât unele programe se pot baza pe faptul că acestea sunt disponibile, trebuie să utilizați această opțiune numai dacă știți ce faceți. Modulele "optimizate" au un .pyo mai degrabă decât un sufix .pyc și sunt de obicei mai mici. Eliberările viitoare pot schimba efectele optimizării.

Un program nu rulează mai repede când este citit dintr-un fișier `.pyc` sau `.pyo` decât atunci când este citit dintr-un fișier `.py` ; singurul lucru care este mai rapid despre fișierele `.pyc` sau `.pyo` este viteza cu care sunt încărcate.

Modulul `compileall` poate crea fișiere .pyc (sau fișiere .pyo când se utilizează -O ) pentru toate modulele dintr-un director.

Există mai multe detalii despre acest proces, inclusiv o diagramă a deciziilor, în PEP 3147.

6.2. Module standard

Python vine cu o bibliotecă de module standard, descrisă într-un document separat, Python Library Reference ("Biblioteca de referință" de mai jos). Unele module sunt construite în interpret; acestea oferă acces la operații care nu fac parte din miezul limbii, dar sunt totuși construite, fie pentru eficiență, fie pentru a oferi acces la primitivi ai sistemului de operare, cum ar fi apelurile de sistem. Setul de astfel de module este o opțiune de configurare care depinde și de platforma de bază. De exemplu, modulul winreg este furnizat numai pe sistemele Windows. Un modul special merită o atenție deosebită: sys , care este construit în fiecare interpret Python. Variabilele sys.ps1 și sys.ps2 definiți șirurile utilizate ca mesaje primare și secundare:

>>>

>>> import  sys 
>>> sys . ps1 
'>>>' 
>>> sys . ps2 
'...' 
>>> sys . ps1  =  'C' ' 
C> print (' Yuck! ') 
Yuck! 
C>

Aceste două variabile sunt definite numai dacă interpretul este în modul interactiv.

Variabila sys.path este o listă de șiruri care determină calea de căutare a modulelor de interpretare. Aceasta este inițializată la o cale implicită luată din variabila de mediuPYTHONPATH sau dintr-o valoare implicită încorporată dacă PYTHONPATH nu este setat. Puteți să o modificați utilizând operațiuni de listă standard:

>>>

>>> import  sys 
>>> sys . calea . adăugați ( '/ ufs / guido / lib / python' )

6.3. `Dir ()` Funcția

Funcția built-in dir () este utilizată pentru a afla ce nume definește un modul. Returnează o listă ordonată de șiruri de caractere:

>>>

>>> import  fibo ,  sys 
>>> dir ( fibo ) 
[ '__name__', 'fib', 'fib2'] 
>>> dir ( sys )   
[ '__egginsert' '__displayhook__', '__doc__', '__excepthook__' , 
'__loader__', '__name__', '__package__', '__plen', '__stderr__', 
'__stdin__', '__stdout__', _clear_type_cache, 
_current_frames, _debugmallocstats, _getframe, _mercurial ',' _xoptions ', 
' abiflags ',' api_version ',' argv ',' base_exec_prefix ','base_prefix', 
'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 
'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info'
"excepție", "exec_prefix", "executabil", "ieșire", "flags", "float_info", 
"float_repr_style", "getcheckinterval", "getdefaultencoding", 
"getdjeckinflags", "getfilesystemencoding" ', 
' getrequsionlimit ',' getrefcount ',' getizeof ',' getwitchinterval ', 
' gettotalrefcount ',' gettrace ',' hash_info ',' hexversion ', 
' implementation ',' int_info ',' intern ',' maxsize ' 'maxunicode', 
'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 
'platform', 'prefix', 'ps1', 'setdlopenflags', 'setcheckinterval' 
'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 
'stderr', 'stdin', 'stdout', 'thread_info', 'versiune', 'version_info', 
„warnoptions „]

Fără argumente, dir () listează numele pe care le-ați definit în prezent:

>>>

>>> a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ] 
>>> import  fibo 
>>> fib  =  fibo . fib 
>>> dir () 
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

Rețineți că acesta afișează toate tipurile de nume: variabile, module, funcții etc.

dir () nu conține numele funcțiilor și variabilelor încorporate. Dacă doriți o listă a acestora, acestea sunt definite în modulul standard builtins :

>>>

>>> import  Afi 
>>> dir ( Afi )   
[ 'ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 
'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 
'ChildProcessError', ' ConnectionAbortedError“, 'ConnectionError', 
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 
'EOFError', 'Ellipsis', 'EnvironmentError', 'Excepție', 'fals', 
'fileexistserror', 'FileNotFoundError', 'FloatingPointError' , 
"FutureWarning", "GeneratorExit", "IOError "," ImportError ", 
" ImportWarning "," IndentationError "," IndexError "," InterruptedError ",
"IsADirectoryError", "KeyError", "KeyboardInterrupt", "LookupError", 
"MemoryError", "NameError", "None", "NotADirectoryError", 
"NotImplemented", "NotImplementedError", "OverflowError", 
PendingDeprecationWarning ',' 
RunError ', 
' RuntimeWarning ',' StopIteration ',' SyntaxError ',' SyntaxWarning ',' SystemError ', 
' SystemExit ',' TabError ', 
' PermissionError ',' ProcessLookupError ', ' ReferenceError ',' ResourceWarning ' "TimeoutError", "Adevărat", "TypeError", "UnboundLocalError", "UnicodeDecodeError", "UnicodeEncodeError", 
"UnicodeError", "UnicodeTranslateError", "UnicodeWarning", "UserWarning", 
"ValueError", "Avertisment", "ZeroDivisionError", "_", "__build_class__"
'__debug__', '__doc__', '__import__', '__name__', '__package__', 'ABS', 
'toate', 'orice', 'ascii', 'bin', 'bool', 'bytearray', „bytes ',' 
chr ',' classmethod ',' compile ',' complex ',' copyright ',' credits ', 
' delattr ',' dict ',' dir ',' divmod ' 'eval', 'exec', 'exit', 
'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 
'hash', 'help' ',' id ',' intrare ',' int ',' isinstance ',' issubclass ', 
'iter ',' len ',' local ',' map ',' max ',' memoryview ', 
' min ',' next ',' , "ord", "pow", "print", "proprietate", 
"quit", "gamă", "repr", "inversat 
" sort "," staticmethod "," str "," sum "," super "," tuplu "," tip "," vars "proprietățile ", " quit "," intervalul "," repr "," inversat "," rotund "," set "," setattr "," slice " , "super", "tuplu", "tip", "vars",proprietățile ", " quit "," intervalul "," repr "," inversat "," rotund "," set "," setattr "," slice " , "super", "tuplu", "tip", "vars",
 'Zip']

6.4. Pachete

Pachetele reprezintă o modalitate de a structura spațiul de nume al modulelor Python utilizând "nume de module punctate". De exemplu, numele modulului AB desemneaza un submodul B într - un pachet numit A . La fel ca utilizarea modulelor salvează autorii diferitelor module de faptul că trebuie să vă faceți griji în legătură cu numele variabilelor globale ale fiecăruia, folosirea numelor de module întrerupte salvează autorii pachetelor multi-modul cum ar fi NumPy sau Biblioteca de Imagistică Python de la a fi nevoiți să vă faceți griji pentru fiecare numele altor module.

Să presupunem că doriți să proiectați o colecție de module (un "pachet") pentru o manipulare uniformă a fișierelor audio și a datelor de sunet. Există multe formate diferite de fișiere de sunet (de obicei, recunoscute de extensia lor, de exemplu: .wav , .aiff , .au ), astfel încât este posibil să fie nevoie să creați și să mențineți o colecție de module pentru convertirea între diferitele formate de fișiere. Există, de asemenea, multe operațiuni diferite pe care doriți să le efectuați pe date de sunet (cum ar fi amestecarea, adăugarea de ecouri, aplicarea unei funcții egalizatoare, crearea unui efect stereo artificial), astfel încât, în plus, veți scrie un flux neîntrerupt de module pentru a efectua aceste operațiuni. Iată o structură posibilă pentru pachetul dvs. (exprimată în termeni de sistem de fișiere ierarhic):

sunet / pachet de nivel superior
      __init__.py Inițializați pachetul de sunet
      formate / Subpachet pentru conversii în format de fișier
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      efecte / subpachet pentru efecte sonore
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filtre / subpachetare pentru filtre
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

La importul pachetului, Python caută directoarele pe sys.path căutând subdirectorul de pachete.

Cele __init__.py Fișierele sunt necesare pentru a face Python trateze directoarele ca pachete care conțin; acest lucru se face pentru a împiedica directoarele cu un nume comun, cum ar fi șirul , să ascundă neintenționat module valide care apar ulterior pe calea de căutare a modulelor. În cel mai simplu caz, __init__.py poate fi doar un fișier gol, dar poate executa și codul de inițializare pentru pachet sau poate seta variabila __all__ descrisă mai târziu.

Utilizatorii pachetului pot importa module individuale din pachet, de exemplu:

import  sound.effects.echo

Acest lucru încarcă submodul sound.effects.echo . Trebuie să fie menționată cu numele său complet.

sunet . efecte . echo . echofilter ( intrare ,  ieșire ,  întârziere = 0,7 ,  atten = 4 )

O modalitate alternativă de a importa submodul este:

de la  sound.effects  import  echo

De asemenea, se încarcă ecoul submodulului și îl face disponibil fără prefixul pachetului, astfel încât acesta poate fi folosit după cum urmează:

echo . echofilter ( intrare ,  ieșire ,  întârziere = 0,7 ,  atten = 4 )

O altă variantă este importul direct al funcției sau al variabilei dorite:

de la  sound.effects.echo  import  echofilter

Din nou, acest lucru încarcă ecou submodule , dar acest lucru face ca funcția sa echofilter () să fie direct disponibilă:

echofilter ( intrare ,  ieșire ,  întârziere = 0,7 ,  atten = 4 )

Rețineți că atunci când utilizați din elementul de import al pachetelor , elementul poate fi fie un submodul (sau subpachetul) al pachetului, fie un alt nume definit în pachet, ca o funcție, o clasă sau o variabilă. Instrucțiunea de import verifică mai întâi dacă articolul este definit în pachet; dacă nu, presupune că este un modul și încearcă să îl încarce. Dacă nu reușește să o găsească, o excepție ImportError este ridicată.

Contrar, atunci când se utilizează o sintaxă precum importul item.subitem.subsubitem , fiecare articol, cu excepția ultimului, trebuie să fie un pachet; ultimul element poate fi un modul sau un pachet, dar nu poate fi o clasă sau o funcție sau o variabilă definită în articolul anterior.

6.4.1. Importul * dintr-un pachet

Acum ce se întâmplă atunci când utilizatorul scrie din importul sound.effects * ? În mod ideal, s-ar speranța că aceasta va ieși într-o oarecare măsură în sistemul de fișiere, va afla care submodule sunt prezente în pachet și le importă pe toate. Acest lucru ar putea dura mult timp, iar sub-modulele de import ar putea avea efecte secundare nedorite care ar trebui să se producă numai atunci când submodulul este importat explicit.

Singura soluție este ca autorul pachetului să furnizeze un indice explicit al pachetului. Instrucțiunea de import utilizează următoarea convenție: dacă codul __init__.py al unui pachet definește o listă numită __all__ , este considerată lista cu numele de module care ar trebui să fie importate când se întâlnește din importul de pachete * . Depinde de autorul pachetului să păstreze actualizarea acestei liste atunci când este lansată o nouă versiune a pachetului. Autorii pachetelor pot, de asemenea, să decidă să nu o susțină, dacă nu văd o utilizare pentru importul * din pachetul lor. De exemplu, fișierul sunet / efecte / __ init__.py ar putea conține următorul cod:

__all__  =  [ "ecou" ,  "surround" ,  "invers" ]

Acest lucru ar însemna că importul * de la sound.effects ar importa cele trei submodule numite ale pachetului de sunet .

Dacă __all__ nu este definit, declarația de la Sound.Effects import * nu nu importa toate submodule din pachetul Sound.Effects în spațiul de nume curent; se asigură numai că au fost importate efecte sonore ale pachetului (eventual executând orice cod de inițializare în __init__.py) și apoi importă orice nume sunt definite în pachet. Aceasta include orice nume definite (și submodule încărcate explicit) de __init__.py . Acesta include, de asemenea, toate submodulele pachetului care au fost încărcate în mod explicit de declarațiile anterioare de import . Luați în considerare acest cod:

import  sound.effects.echo 
import  sound.effects.surround de 
la  sound.effects  import  *

În acest exemplu, modulele de ecou și surround sunt importate în spațiul de nume curent deoarece sunt definite în pachetul sound.effects atunci când declarația de import din ... este executată. (Aceasta funcționează și atunci când __all__ este definit.)

Deși anumite module sunt proiectate să exporte numai nume care urmează anumite modele atunci când utilizați import * , este încă considerată o practică nepotrivită în codul de producție.

Rețineți că nu este nimic în neregulă cu utilizarea din pachetul de import specific_submodule ! De fapt, aceasta este notația recomandată dacă modulul de import nu trebuie să utilizeze submodule cu același nume din diferite pachete.

6.4.2. Referințe-pachet intra

Când pachetele sunt structurate în subpachete (ca în cazul pachetului de sunet din exemplu), puteți utiliza importurile absolute pentru a vă referi la submodulele pachetelor de frați. De exemplu, dacă modulul sound.filters.vocoder trebuie să utilizeze modulul ecou din pachetul sound.effects , acesta poate folosi din sound.effects import echo .

Puteți scrie , de asemenea , importurile relative, cu de la modulul de import numele sub formă de declarație de import. Aceste importuri utilizează puncte de vârf pentru a indica pachetele actuale și părțile implicate în importul relativ. De exemplu, de la modulul surround , este posibil să utilizați:

de la  .  importă  ecou 
din  ..  formate de import  din ..filters import egalizator
   

Rețineți că importurile relative se bazează pe numele modulului curent. Deoarece numele modulului principal este întotdeauna "__main__" , modulele destinate a fi utilizate ca modul principal al unei aplicații Python trebuie să utilizeze întotdeauna importuri absolute.

6.4.3. Pachete în mai multe directoare

Pachetele suportă încă un atribut special, `path` . Aceasta este inițializată pentru a fi o listă care conține numele directorului care ține fișierul `init.py` al pachetului înainte ca codul din acel fișier să fie executat. Această variabilă poate fi modificată; acest lucru afectează căutările viitoare pentru module și subpachete conținute în pachet.

În timp ce această caracteristică nu este adesea necesară, ea poate fi utilizată pentru a extinde setul de module găsite într-un pachet.

Note de subsol

[1] De fapt, definițiile funcțiilor sunt și "declarații" care sunt "executate"; execuția unei definiții a funcției la nivel de modul introduce numele funcției în tabela simbolică globală a modulului.

7. Intrări și ieșiri

Există mai multe modalități de prezentare a rezultatelor unui program; datele pot fi tipărite într-o formă ușor de citit de om sau scrise într-un fișier pentru utilizare ulterioară. Acest capitol va discuta câteva posibilități.

7.1. Formatul de ieșire pentru fancier

Până acum am întâlnit două modalități de scriere a valorilor: declarații de expresie și funcția print (). (A treia cale este folosirea metodei write () a obiectelor de fișier, fișierul de ieșire standard poate fi referit ca sys.stdout .

Deseori veți dori mai mult control asupra formatării ieșirii decât prin simpla imprimare a valorilor separate de spațiu. Există două moduri de formatare a ieșirii; prima modalitate este de a face toate manipularea string-ului; folosind operațiuni de tăiere în șir și operații de concatenare, puteți crea orice aspect pe care să-l puteți imagina. Tipul de șir are câteva metode care efectuează operații utile pentru ștanțarea șirurilor la o anumită lățime a coloanei; acestea vor fi discutate în scurt timp. A doua modalitate este de a folosi metoda str.format () .

Șir Modulul conține un șablon de clasă care oferă încă un alt mod de a înlocui valorile în șiruri.

O întrebare rămâne, bineînțeles: cum convertiți valori în șiruri de caractere? Din fericire, Python are modalități de a converti orice valoare într-un șir: treceți-l la funcțiile repr () sau str () .

Funcția str () are rolul de a returna reprezentări ale valorilor care pot fi citite de oameni, în timp ce repr () este destinat să genereze reprezentări care pot fi citite de interpret (sau vor forța un SyntaxError dacă nu există o sintaxă echivalentă). Pentru obiectele care nu au o reprezentare specială pentru consumul uman, str () va reveni la aceeași valoare ca și repr () . Multe valori, cum ar fi numere sau structuri precum liste și dicționare, au aceeași reprezentare utilizând oricare dintre funcții. Șirurile, în special, au două reprezentări distincte.

Cateva exemple:

>>>

>>> s  =  'Bună ziua, lume.' 
>>> str ( s ) 
"Bună ziua, lumea". 
>>> repr ( s ) 
" 'Bună ziua, lume.'" 
>>> str ( 1 / 7 ) 
'' 0.14285714285714285 
>>> x  =  10  *  3.25 
>>> y  =  200  *  200 
>>> s  =  „The valoarea lui x este '  +  repr ( x )  +  ', iar y este '  )  +  '...' 
>>> print ( s ) 
Valoarea lui x este 32.5, iar y este 40000 ... 
>>> # Repr () dintr-un șir adaugă citate șir și spate: 
... hello  =  'Bună ziua, lume \ n ' 
>>> hellos  =  repr ( alo ) 
>>> print ( hellos ) 
'Bună ziua, lume \ n' 
>>> # argumentul repr () poate fi orice obiect Python: 
... Repr (( x ,  y ,  ( 'spam' , „ouă“))) 
"(32.5, 40000, (" spam "," ouă "))"

Iată două modalități de a scrie o tabelă cu pătrate și cuburi:

>>>

>>> pentru  x  in  gama ( 1 ,  11 ): 
...     print ( repr ( x ) . Rjust ( 2 ),  repr ( x * x ) . Rjust ( 3 ),  end = '' ) 
...     # Notă utilizarea 'final' pe linia anterioară 
...     imprimare ( repr ( x * x * x ) . rjust ( 4)) 
... 
1 1 1 
2 4 8 
3 9 27 
4 16 64 
5 25 125 
6 36 216 
7 49 343 
8 64 512 
9 81 729 
10 100 000

>>> pentru  x  in  gama ( 1 ,  11 ): 
...     print ( '{0: 2d} {1: 3d} {2: 4d}' . Format ( x ,  x * x ,  x * x * x ) ) 
... 
1 1 1 
2 4 8 
3 9 27 
4 16 64 
5 25 125 
6 36 216 
7 49 343 
8 64 512 
9 81 729 
10 100 1000

(Rețineți că în primul exemplu, un spațiu între fiecare coloană a fost adăugat prin modul print () : acesta adaugă întotdeauna spații între argumentele sale.)

Acest exemplu demonstrează metoda str.rjust () a obiectelor șir, care justifică corect un șir dintr-un câmp de o anumită lățime, umplând-l cu spații în stânga. Există metode similare str.ljust () șistr.center () . Aceste metode nu scriu nimic, ci doar returnează un nou șir. Dacă șirul de introducere este prea lung, nu îl trunchiază, ci îl returnează neschimbat; acest lucru va afecta structura coloanei, dar de obicei este mai bună decât alternativa, care ar fi mincinoasă despre o valoare. (Dacă vreți cu adevărat trunchierea, puteți adăuga întotdeauna o operație cu felie, ca în x.ljust (n) [: n].)

Există o altă metodă, str.zfill () , care pătrunde într- un șir numeric în stânga cu zerouri. Înțelege semnele plus și minus:

>>>

>>> '12' . zfill ( 5 ) 
'00012' 
>>> '-3,14' . zfill ( 7 ) 
'-003.14' 
>>> '3.14159265359' . zfill ( 5 ) 
"3.14159265359"

Utilizarea de bază a metodei str.format () arată astfel:

>>>

>>> Print ( 'Suntem {} care spun "{}!"' . Format ( 'cavaleri' ,  'Ni' )) 
Noi suntem cavaleri care spun "Ni!"

Parantezele și caracterele din ele (numite câmpuri de format) sunt înlocuite cu obiectele transmise în metoda str.format () . Un număr din paranteze poate fi folosit pentru a se referi la poziția obiectului trecut în metoda str.format () .

>>>

>>> print ( '{0} și {1}' . Format ( "spam ,  'ouă' )) 
spam și ouă 
>>> print ( '{1} și {0}' . Format ( " spam ,  "ouă" )) 
ouă și spam

În cazul în care argumentele de cuvinte cheie sunt utilizate în metoda str.format () , valorile lor sunt menționate folosind numele argumentului.

>>>

>>> print ( 'This {food} este {adjectiv}.' . format ( 
...       food = 'spam' ,  adjectiv = 'absolut oribil' )) 
Acest spam este absolut oribil.

Argumentele poziționate și ale cuvintelor cheie pot fi combinate arbitrar:

>>>

>>> print ( 'Povestea {0}, {1} și {alt}.' . Format ( 'Bill' ,  'Manfred' , 
                                                       alt = 'Georg')) 
Povestea lui Bill, Manfred și Georg .

'a' (se aplică ascii () ), '! s' (se aplică str () ) și '! r' (se aplică repr () ) poate fi folosit pentru a converti valoarea înainte de a fi formatat:

>>>

>>> import  math 
>>> print ( 'Valoarea lui PI este de aproximativ {}.' . Format ( matematică . Pi )) 
Valoarea PI este de aproximativ 3.14159265359. 
>>> Print ( 'Valoarea lui PI este de aproximativ {!} R.' . Format ( matematică . Pi )) 
Valoarea PI este de aproximativ 3.141592653589793.

Un opțional ":" și un specificator de format poate urma numele câmpului. Acest lucru permite un control mai mare asupra modului în care este formatată valoarea. Exemplul de mai jos trasează Pi la trei locuri după zecimală.

>>>

>>> import  math 
>>> print ( 'Valoarea lui PI este de aproximativ {0: .3f}.' . Format ( matematică . Pi )) 
Valoarea PI este de aproximativ 3.142.

Trimiterea unui număr întreg după ':' va determina ca acest câmp să aibă un număr minim de caractere lățime. Acest lucru este util pentru a face mese destul.

>>>

>>> table  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  7678 } 
>>> pentru  nume ,  telefon  în  tabel . articole (): 
...     imprimare ( '{0:10} ==> {1: 10d}' . format ( nume ,  telefon )) 
... 
Jack ==> 4098 
Dcab ==> 7678 
Sjoerd ==> 4127

Dacă aveți un șir de format foarte lung pe care nu doriți să-l împărțiți, ar fi bine dacă ați putea face referire la variabilele care urmează să fie formatate în funcție de nume în loc de poziție. Acest lucru se poate face prin simpla trecere a dictului și folosirea parantezelor [] pentru a accesa cheile

>>>

>>> tabel  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  8637678 } 
>>> print ( „Jack: {0 [Jack]: d}; Sjoerd: {0 [Sjoerd]: d }; ' 
...       'Dcab: {0 [Dcab]: d}' . format ( tabel )) 
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Acest lucru se poate face și prin trecerea tabelului ca argumente pentru cuvinte cheie cu notația '**'.

>>>

>>> Tabelul  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  8637678 } 
>>> print ( 'Jack: {Jack: d} : d}“ . format ( ** tabelul )) 
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Acest lucru este util în special în combinație cu funcția încorporată vars () , care returnează un dicționar care conține toate variabilele locale.

Pentru o prezentare completă a formatării șirului cu str.format () , consultați Sintaxa de formatare a șirului .

7.1.1. Formatarea șirului vechi

% Operatorul poate fi de asemenea utilizat pentru formatarea șir de caractere. Aceasta interpretează argumentul stâng la fel ca un șir de format sprintf () -style pentru a fi aplicat argumentului drept și returnează șirul rezultat din această operație de formatare. De exemplu:

>>>

>>> import  math 
>>> print ( 'Valoarea lui PI este de aproximativ% 5.3f.'  %  Math . Pi ) 
Valoarea lui PI este de aproximativ 3.142.

Mai multe informații pot fi găsite în secțiunea Formatting String în stil printf .

7.2. Citirea și scrierea fișierelor

open () returnează un obiect de fișier și este cel mai frecvent utilizat cu două argumente: open (nume fișier, mod) .

>>>

>>> f  =  deschis ( 'workfile' ,  'w' )

Primul argument este un șir care conține numele fișierului. Al doilea argument este un alt șir care conține câteva caractere care descriu modul în care fișierul va fi utilizat. Modul poate fi "r" atunci când fișierul va fi citit numai, "w" pentru scris doar (un fișier existent cu același nume va fi șters), iar"a" deschide fișierul pentru adăugare; toate datele scrise în fișier sunt adăugate automat la final. 'r +' deschide fișierul pentru citire și scriere. Modul Argumentul este opțională; "r" va fi asumat dacă este omis.

În mod normal, fișierele sunt deschise în modul text , adică citiți și scrieți șiruri din și în fișier, care sunt codificate într-o anumită codificare (implicit UTF-8). "b" atașat la modul deschide fișierul în modul binar : acum datele sunt citite și scrise sub formă de obiecte bytes. Acest mod ar trebui să fie utilizat pentru toate fișierele care nu conțin text.

În modul text, setarea implicită la citire este de a converti terminațiile liniei specifice platformei ( \ n pe Unix, \ r \ n pe Windows) la doar \ n . Când scrieți în modul text, implicit este să convertiți aparițiile \ n înapoi la terminalele liniei specifice platformei. Această modificare a datelor din fișiere în spatele scenei este bună pentru fișierele text, dar va corupe datele binare, cum ar fi cele din fișierele JPEGsau EXE . Fiți foarte atent să utilizați modul binar atunci când citiți și scrieți astfel de fișiere.

7.2.1. Metode ale obiectelor de fișiere

Restul exemplelor din această secțiune presupun că un obiect de fișier numit f a fost deja creat.

Pentru a citi conținutul unui fișier, apelați f.read (size) , care citește o cantitate de date și o returnează ca un obiect șir sau bytes. dimensiunea este un argument numeric opțional. Atunci când mărimea este omisă sau negativă, întregul conținut al fișierului va fi citit și returnat; problema dvs. este dacă fișierul este de două ori mai mare decât memoria mașinii dvs. În caz contrar, la cele mai multe dimensiuni, octeții sunt citiți și returnați. Dacă sa ajuns la sfârșitul fișierului, f.read () va returna un șir gol ( '' ).

>>>

>>> f . read () 
'Acesta este întregul fișier. \ n' 
>>> f . citiți () 
''

f.readline () citește o singură linie din fișier; un caracter de linie nouă ( \ n ) este lăsat la sfârșitul șirului și este omis pe ultima linie a fișierului dacă fișierul nu se termină într-o linie nouă. Aceasta face ca valoarea de retur să fie neechivocă; dacă f.readline () returnează un șir gol, sa ajuns la sfârșitul fișierului, în timp ce o linie necompletată este reprezentată de '\ n' , un șir care conține doar o singură linie nouă.

>>>

>>> f . readline () 
'Aceasta este prima linie a fișierului. \ n' 
>>> f . readline () 
'A doua linie a fișierului \ n' 
>>> f . readline () 
''

Pentru citirea liniilor dintr-un fișier, puteți să le cuplați peste obiectul de fișier. Aceasta este memorie eficientă, rapidă și duce la un cod simplu:

>>>

>>> pentru  linia  in  f : 
...     print ( line ,  end = '' ) 
... 
Aceasta este prima linie a fisierului. 
A doua linie a dosarului

Dacă doriți să citiți toate liniile unui fișier dintr-o listă, puteți utiliza și lista (f) sau f.readlines () .

f.write (string) scrie conținutul șirului în fișier, returnând numărul de caractere scrise.

>>>

>>> f . scrie ( 'Acesta este un test \ n ' ) 
15

Pentru a scrie ceva diferit de un șir, trebuie mai întâi să fie convertit într-un șir:

>>>

>>> value  =  ( 'răspunsul' ,  42 ) 
>>> s  =  str ( valoare ) 
>>> f . scrie ( e ) 
18

f.tell () returnează un număr întreg care dă poziția curentă a obiectului fișierului în fișierul reprezentat ca număr de octeți de la începutul fișierului când este în modul binar și un număr opac înmodul text .

Pentru a modifica poziția obiectului fișierului, utilizați f.seek (offset, from_what) . Poziția este calculată prin adăugarea de compensare la un punct de referință; punctul de referință este selectat de argumentul from_what . O from_what valoare de 0 măsuri de la începutul fișierului, 1 utilizează poziția fișierului curent și 2 utilizează sfârșitul fișierului ca punct de referință. from_what poate fi omis și defaults la 0, folosind începutul fișierului ca punct de referință.

>>>

>>> f  =  deschide ( 'workfile' ,  'rb +' ) 
>>> f . scrie ( b '0123456789abcdef' ) 
16 
>>> f . căutați ( 5 )      # Mergeți la cel de-al 6-lea octet din fișier 
5 
>>> f . citiți ( 1 ) 
b'5 ' 
>>> f . căutați ( - 3 ,  2 )  # Mergeți la cel de-al treilea byte înainte de finalul 
13 
>>> f .( 1 ) 
b'd '

În fișierele text (cele deschise fără un b în șirul de moduri) sunt permise doar căutările relative la începutul fișierului (excepția este căutată până la sfârșitul fișierului cu căutarea (0, 2) ) și singurele valori ofset valide sunt cele returnate de la f.tell () , sau zero. Orice altă valoare compensată produce comportament nedefinit.

Când ați terminat cu un fișier, apelați f.close () pentru al închide și a elibera toate resursele de sistem preluate de fișierul deschis. După ce a sunat f.close () , încercările de a utiliza obiectul de fișier vor eșua automat.

>>>

>>> f . închide () 
>>> f . citiți () 
Traceback (cel mai recent apel ultimul): 
  Fișierul "<stdin>" , rândul 1 , în ? 
ValueError : operare I / O pe fișier închis

Este o bună practică să folosească cu cuvinte cheie atunci când se ocupă cu obiecte de fișiere. Acest lucru are avantajul că fișierul este închis corespunzător după terminarea suitei sale, chiar dacă se ridică o excepție pe parcurs. Este, de asemenea, mult mai scurtă decât scrierea încercăriiechivalente - în cele din urmă blocuri:

>>>

>>> cu  open ( 'workfile' ,  'r' )  ca  f : 
...     read_data  =  f . citiți () 
>>> f . închis 
Adevărat

Obiectele de fișiere au câteva metode suplimentare, cum ar fi isatty () și truncate (), care sunt mai puțin utilizate; consultați Biblioteca Referință pentru un ghid complet al obiectelor de fișier.

7.2.2. Salvarea datelor structurate cu `json`

Șirurile pot fi ușor scrise și citite dintr-un fișier. Numerele fac un efort mai mic, deoarece metoda read () returneaza numai siruri de caractere, care trebuie sa fie transmise unei functii precum int () , care ia un sir ca '123' si isi returneaza valoarea numerica 123. Cand vrei sa salvați mai complexe tipuri de date, cum ar fi liste imbricate și dicționare, parsarea și serializarea manuală devine complicată.

Mai degrabă decât dacă utilizatorii au în mod constant scrierea și depanarea codului pentru a salva tipuri de date complicate în fișiere, Python vă permite să utilizați formatul popular de schimb de date numit JSON (JavaScript Object Notation) . Modulul standard denumit json poate lua ierarhiile de date Python și le poate converti în reprezentări de șir; acest proces se numește serializare . Reconstruirea datelor din reprezentarea șirului se numește deserializare . Între serializarea și deserializarea, șirul reprezentând obiectul ar fi putut fi stocat într-un fișier sau date sau trimis printr-o conexiune de rețea la o anumită mașină îndepărtată.

Notă

Formatul JSON este utilizat în mod obișnuit de aplicații moderne pentru a permite schimbul de date. Mulți programatori sunt deja familiarizați cu acesta, ceea ce îl face o alegere bună pentru interoperabilitate.

Dacă aveți un obiect x , puteți vizualiza reprezentarea șirului JSON cu o linie simplă de cod:

>>>

>>> json . haldele ([ 1 ,  "simplu" ,  "listă" ]) 
"[1," simplu "," listă "

O altă variantă a funcției dumps () , denumită dump () , serializează pur și simplu obiectul într-un fișier text . Deci, dacă f este un obiect de fișier text deschis pentru scriere, putem face acest lucru:

json . dump ( x ,  f )

Pentru a decoda obiectul din nou, dacă f este un obiect de fișier text care a fost deschis pentru citire:

x  =  json . sarcină ( f )

Această tehnică de serializare simplă poate gestiona liste și dicționare, însă serializarea instanțelor de clasă arbitrare din JSON necesită un efort suplimentar. Referința pentru modulul json conține o explicație a acestui lucru.

Vezi si

pickle - modulul pickle

Spre deosebire de JSON , pickle este un protocol care permite serializarea obiectelor Python arbitrar complexe. Ca atare, este specific pentru Python și nu poate fi folosit pentru a comunica cu aplicații scrise în alte limbi. Este, de asemenea, nesigur în mod implicit: deserializarea datelor de muraturi care provin dintr-o sursă neîncrezătoare pot executa un cod arbitrar, dacă datele au fost create de un atacator calificat.

8. Erori și excepții

Până acum mesajele de eroare nu au fost mai mult decât menționate, dar dacă ați încercat exemplele pe care le-ați văzut probabil unele. Există (cel puțin) două tipuri de erori distincte: erori de sintaxă și excepții .

8.1. Erori de sintaxă

Erorile de sintaxă, cunoscute și sub numele de erori de parsing, sunt probabil cele mai comune tipuri de reclamații pe care le obțineți în timp ce învățați încă Python:

>>>

>>> în timp ce  Print True  ( "Bună ziua" )   Fișier "<stdin>", linia 1, în?     în timp ce True print ('Hello world')                    ^ SyntaxError: sintaxă invalidă

Parserul repetă linia infracțională și afișează o mică "săgeată" care indică cel mai devreme punct din linia unde a fost detectată eroarea. Eroarea este cauzată de (sau cel puțin detectată) de tokenul precedent de săgeată: în exemplu, eroarea este detectată la funcția print () , deoarece un colon ( ':' ) lipsește înainte de aceasta. Numele fișierului și numărul liniei sunt tipărite, astfel încât să știți unde să căutați în cazul în care intrarea a venit dintr-un script.

8.2. Excepții

Chiar dacă o declarație sau o expresie este corectă din punct de vedere sintactic, poate provoca o eroare atunci când se face o încercare de ao executa. Erori detectate în timpul execuției sunt numite excepții și nu sunt necondiționat fatale: în curând veți afla cum să le gestionați în programele Python. Cele mai multe excepții nu sunt tratate de programe, cu toate acestea, și rezultă în mesaje de eroare, după cum se arată aici:

>>>

>>> 10  *  ( 1 / 0 ) 
Traceback (apel cele mai recente Ultima): 
  Fișier "<stdin>" , linia 1 , în ? 
ZeroDivisionError : împărțire la zero 
>>> 4  +  spam * 3 
Traceback (ultimul apel ultimul): 
  Fișierul "<stdin>" , linia 1 , în ? 
NumeError : numele "spam" nu este definit 
>>> '2'  +  2 
Traceback (cel mai recent apel ultimul): 
  Fișierul "<stdin>", în ? 
TypeError : Imposibil de convertit obiectul 'int' la str implicit

Ultimul rând al mesajului de eroare indică ce sa întâmplat. Excepțiile vin în diferite tipuri, iar tipul este tipărit ca parte a mesajului: tipurile din exemplu sunt ZeroDivisionError , NameError și TypeError . Șirul imprimat ca tip de excepție este numele excepției integrate care a apărut. Acest lucru este valabil pentru toate excepțiile integrate, dar nu este necesar să fie adevărat pentru excepțiile definite de utilizator (deși este o convenție utilă). Numele excepționale standard sunt identificatorii încorporați (nu sunt cuvinte cheie rezervate).

Restul liniei oferă detalii pe baza tipului de excepție și a ceea ce a cauzat-o.

Partea anterioară a mesajului de eroare arată contextul în care sa produs excepția, sub forma unei traseback de stivă. În general, acesta conține o linie de sursă a liniei sursă de traseback; cu toate acestea, nu va afișa liniile citite de la intrarea standard.

Excepțiile construite listează excepțiile încorporate și semnificațiile acestora.

8.3. Excepții de manipulare

Este posibil să scrieți programe care să trateze excepțiile selectate. Uitați-vă la exemplul următor, care solicită utilizatorului introducerea până la introducerea unui număr întreg valid, dar permite utilizatorului să întrerupă programul (folosind Control-C sau orice suport acceptă sistemul de operare); rețineți că o întrerupere generată de utilizator este semnalizată prin ridicarea excepției KeyboardInterrupt .

>>>

>>> în timp ce  Adevărat : 
...     încercați : 
...         x  =  int ( introduceți ( "Introduceți un număr:" )) 
...         pauză 
...     cu excepția  ValueError : 
...         print ( "Oops! un număr valid, încercați din nou ... " ) 
...

Instrucțiunea try funcționează după cum urmează.

În primul rând, clauza try (declarația (e) între încercare și cu excepția cuvintelor cheie) este executat.
Dacă nu se produce nicio excepție, clauza excepțională este omisă și executarea instrucțiunii try este terminată.
Dacă se produce o excepție în timpul executării clauzei de încercare, restul clauzei este omisă. Apoi , în cazul în care tipul său se potrivește cu excepția numit după excepția cuvintelor cheie, clauza except este executat, iar apoi de execuție este după încercare declarația.
Dacă apare o excepție care nu se potrivește cu excepția numită în clauza excepțională, aceasta este transmisă unor instrucțiuni exterioare de încercare ; dacă nu se găsește niciun manipulator, este o excepție nefolosită și execuția se oprește cu un mesaj așa cum este arătat mai sus.

O instrucțiune try poate avea mai mult de o excepție, cu excepția clauzei, pentru a specifica manipulatorii pentru diferite excepții. La cel mult un handler va fi executat. Handlerele gestionează exclusiv excepțiile care apar în clauza de încercare corespunzătoare, nu și în alte manipulatoare ale aceleiași instrucțiuni de încercare . O clauză excepțională poate numi mai multe excepții ca o paranteză paranteză, de exemplu:

...  cu excepția  ( RuntimeError ,  TypeError ,  NameError ): 
...      pass

Ultimul, cu excepția clauzei, poate omite numele de excepție, pentru a servi drept wildcard. Utilizați acest lucru cu precauție extremă, deoarece este ușor să mascați o eroare de programare reală în acest fel! De asemenea, poate fi folosit pentru a imprima un mesaj de eroare și apoi re-ridicați excepția (permițând unui apelant să facă față și excepției):

import  sys

încercați : 
    f  =  open ( 'myfile.txt' ) 
    s  =  f . readline () 
    i  =  int ( s . benzi ()) cu 
excepția  IOError  ca  err : 
    print ( "eroare I / O: {0}" . format ( err )) cu 
excepția  ValueError : 
    print ( „Nu am putut converti datele la un întreg. " ) 
cu excepția : 
    print ( " Eroare neașteptată: " ,  sys .exc_info () [ 0 ]) 
    crește

Încercare ... cu excepția declarație are o opțională clauză else , care, atunci când este prezent, trebuie să urmeze toate , cu excepția clauzelor. Este util pentru codul care trebuie executat dacă clauza de încercare nu ridică o excepție. De exemplu:

pentru  arg  în  sys . argv [ 1 :]: 
    încercați : 
        f  =  deschis ( arg ,  'r' ) , cu 
    excepția  IOError : 
        imprimare ( 'nu se poate deschide' ,  arg ) 
    altceva : de 
        imprimare ( arg ,  'are' ,  len ( f . readlines ()),  " linii " ) 
        f . închide ()

Utilizarea altfel clauza este mai bună decât adăugarea de cod suplimentar la încercare clauza deoarece evită prinderea în mod accidental o excepție care nu a fost ridicată de codul fiind protejat de încercare ... cu excepția declarație.

Când apare o excepție, poate avea o valoare asociată, cunoscută și ca argumentul excepției . Prezența și tipul argumentului depind de tipul excepției.

Clauza excepțională poate specifica o variabilă după numele excepției. Variabila este legată de o instanță de excepție cu argumentele stocate în instanța.args . Pentru comoditate, instanța de excepție definește __str __ () astfel încât argumentele pot fi imprimate direct fără a fi nevoie să se facă referință .args . De asemenea, se poate instantiza o exceptie inainte de ao ridica si de a adauga orice atribut dupa dorinta.

>>>

>>> încercați : 
...    ridica  excepție ( 'spam - ului' ,  'ouă' ) 
... cu excepția  Excepție  ca  inst : 
... de    imprimare ( de tip ( Inst ))     # excepției de exemplu 
...    imprimare ( inst . Args )      # argumente stocate în .args 
...    print ( inst )           # __str__ permite args să fie imprimate direct, 
...                         # dar pot fi suprascrise în subclasele de excepție 
...    x , y  =  inst . ARGS      # despachetați args 
...    print ( 'x =' ,  x ) 
...    print ( 'y =' ,  y ) 
... 
<class 'Excepție'> 
( 'spam 'ouă') 
( "spam , "ouă") 
x = spam 
y = ouă

Dacă o excepție are argumente, ele sunt tipărite ca ultima parte ("detaliu") a mesajului pentru excepții nefolosite.

Excepții de manipulare nu se ocupă doar de excepții dacă apar imediat în clauza de încercare, dar și în cazul în care apar în interiorul funcțiilor care sunt numite (chiar indirect) în clauza de încercare. De exemplu:

>>>

>>> def  this_fails (): 
...     x  =  1 / 0 
... 
>>> try : 
...     this_fails () 
... cu excepția  ZeroDivisionError  ca  ERR : 
... de     imprimare ( „eroare de manipulare run-time: " ,  err ) 
... 
Manipularea erorii run-time: int divizare sau modulo la zero

8.4. Ridicarea excepțiilor

Instrucțiunea de creare permite programatorului să forțeze o excepție specificată. De exemplu:

>>>

>>> ridica  Traseback NameError ( 'HiThere' ) 
(ultimul apel ultimul): 
  Fișierul "<stdin>" , linia 1 , în ? 
NumeError : HiThere

Singurul argument pe care îl ridică indică excepția care trebuie ridicată. Aceasta trebuie să fie o instanță de excepție sau o clasă de excepție (o clasă care derivă din Excepție ).

Dacă trebuie să determinați dacă a fost ridicată o excepție, dar nu intenționați să o gestionați, o formă mai simplă a instrucțiunii de ridicare vă permite să re-ridicați excepția:

>>>

>>> încercați : 
...     ridica  NameError ( 'HiThere' ) 
... cu excepția  NameError : 
...     print ( 'O excepție a zburat!' ) 
...     ridica 
... 
O excepție a zburat! 
Traceback (cel mai recent apel ultimul): 
  Fișierul "<stdin>" , linia 2 , în ? 
NumeError : HiThere

8.5. Excepții definite de utilizator

Programele își pot numi excepțiile prin crearea unei noi clase de excepție (consultați clasele pentru mai multe despre clasele Python). Excepțiile ar trebui, de obicei, să fie derivate din clasa de excepție, direct sau indirect. De exemplu:

>>>

>>> clasa  MyError ( excepție ): 
...     def  __init__ ( sine ,  valoare ): 
...         sine . Valoarea  =  valoarea 
...     def  __str__ ( auto ): 
...         întoarcere  Repr ( auto . valoare ) 
... 
>>> încercați : 
...     ridica  MyError ( 2 * 2 ) 
... cu excepția  MyError  ca  e :
... de     imprimare ( 'excepție mea a avut loc, valoarea:' ,  e . Valoarea ) 
... 
excepție mea a avut loc, valoarea: 4 
>>> ridica  MyError ( '! Oops' ) 
Traceback (apel cele mai recente Ultima): 
  Fișier „< stdin> " , linia 1 , în ? 
__main __. MyError : "Oops!"

În acest exemplu, valoarea implicită __init __ () a excepției a fost înlocuită. Noul comportament creează pur și simplu atributul value . Aceasta înlocuiește comportamentul implicit al creării atributului args .

Clasele de excepție pot fi definite care fac ceea ce poate face orice altă clasă, dar de obicei sunt păstrate simple, adesea oferind doar un număr de atribute care permit ca informațiile despre eroare să fie extrase de către manipulanți pentru excepție. Când se creează un modul care poate genera mai multe erori distincte, o practică obișnuită este crearea unei clase de bază pentru excepțiile definite de acel modul și a unei subclase care să creeze clase excepționale specifice pentru diferite condiții de eroare:

Clasa de  eroare ( Excepție ): 
    „“ „clasa de baza pentru excepții în acest modul“ „“ 
    trecere

class  InputError ( Error ): 
    "" "Excepție ridicată pentru erori la intrare.

    Atribute: 
        expresie - expresie de intrare în care a apărut 
        mesajul 
eroare - explicarea erorii     "" "

    def  __init__ ( sine ,  expresie ,  mesaj ): 
        sine . expresie  =  expresie de 
        sine . mesaj  =  mesaj

Class  TransitionError ( Error ): 
    "" Crescut atunci când o operație încearcă o tranziție de stat care nu este 
    permisă.

    Atribute: 
        precedent - starea de la începutul tranziției 
        următoare - încercarea unui nou 
        mesaj de 
stare - explicarea motivului pentru care nu este permisă tranziția specifică     "" "

    def  __init__ ( sine ,  precedent ,  următor ,  mesaj ): 
        sine . anterior  =  anterior de 
        sine . next  =  next 
        sine . mesaj  =  mesaj

Cele mai multe excepții sunt definite cu nume care se termină în "Eroare", similar cu denumirea excepțiilor standard.

Multe module standard definesc propriile excepții de a raporta erorile care pot apărea în funcțiile pe care le definesc. Mai multe informații despre clase sunt prezentate în capitolele Clase .

8.6. Definirea acțiunilor de curățare

Instrucțiunea try are o altă clauză opțională, care este destinată să definească acțiunile de curățare care trebuie executate în toate circumstanțele. De exemplu:

>>>

>>> încercați : 
...     ridicați  KeyboardInterrupt 
... în sfârșit : 
...     print ( "La revedere, lumea!" ) 
... 
La revedere, lume! 
KeyboardInterrupt

O clauză finală este întotdeauna executată înainte de a părăsi instrucțiunea try , indiferent dacă a apărut o excepție sau nu. Atunci când a avut loc o excepție în încercați clauza și nu a fost tratată printr - o , cu excepția clauza (sau a avut loc într - o afară sau altceva clauza), acesta este re-raise după ce în cele din urmă clauza a fost executată. În cele din urmă clauză este , de asemenea , executat „pe cale de ieșire“ , atunci când orice altă clauză de încercare declarația este lăsată printr - o pauză , să continue sau a reveni declarație. Un exemplu mai complicat:

>>>

>>> def  divide ( x ,  y ): 
...     încercați : 
...         rezultatul  =  x  /  y 
... cu     excepția  ZeroDivisionError : 
...         Print ( "diviziune de la zero!" ) 
...     altceva : 
...         print ( "rezultatul este" ,  rezultat ) 
... în     cele din urmă : 
...         print ( "executând definitiv clauza" ) 
... 
>>> divide ( 2 , 1 ) 
rezultatul este 2.0 
executând în cele din urmă clauza 
>>> diviziunea ( 2 ,  0 ) 
împărțirea la zero! 
executând în final clauza 
>>> divide ( "2" ,  "1" ) 
executând în cele din urmă clauza 
Traceback (ultimul apel ultimul): 
  Fișier "<stdin>" , rândul 1 , în ? 
  Fișierul "<stdin>" , rândul 3 , în diviziune 
TypeError : tipuri de operand neacceptate pentru /: 'str' și 'str'

După cum puteți vedea, clauza finală este executată în orice caz. TypeError ridicată prin împărțirea două șiruri nu este tratată de către excepția clauzei și , prin urmare , reraise după ce în final clauza a fost executată.

În aplicațiile din lumea reală, clauza finală este utilă pentru eliberarea de resurse externe (cum ar fi fișiere sau conexiuni de rețea), indiferent dacă utilizarea resurselor a avut succes.

8.7. Acțiuni de curățare predefinite

Unele obiecte definesc acțiunile standard de curățare care trebuie întreprinse atunci când obiectul nu mai este necesar, indiferent dacă operația care utilizează obiectul a reușit sau nu a reușit. Uitați-vă la următorul exemplu, care încearcă să deschidă un fișier și să imprime conținutul acestuia pe ecran.

pentru  linia  în  deschisă ( "myfile.txt" ): 
    imprimare ( linia ,  end = "" )

Problema cu acest cod este că ea lasă fișierul deschis pentru o perioadă nedeterminată de timp după ce această parte a codului a terminat executarea. Aceasta nu este o problemă în scenarii simple, dar poate fi o problemă pentru aplicațiile mai mari. Instrucțiunea cu permite ca obiectele ca fișierele să fie utilizate într-un mod care să asigure că acestea sunt întotdeauna curățate prompt și corect.

cu  open ( "myfile.txt" )  ca  f : 
    pentru  linia  în  f : 
        print ( linia ,  capăt = "" )

După executarea instrucțiunii, fișierul f este întotdeauna închis, chiar dacă a apărut o problemă în timpul procesării liniilor. Obiectele care, ca fișiere, oferă acțiuni de curățare predefinite, vor indica acest lucru în documentația lor.

9. Clasele

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

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

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

9.1. Un cuvânt despre nume și obiecte

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

9.2. Python Scopes și Namespaces

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

Să începem cu câteva definiții.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"
    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

Rezultatul exemplului de cod este:

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

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

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

9.3. O primă privire la clase

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

9.3.1. Sintaxa de definire a clasei

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

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

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

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

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

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

9.3.2. Obiecte de clasă

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

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

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

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

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

x  =  MyClass ()

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

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

def __init__(self):
    self.data = []

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

x  =  MyClass ()

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

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

9.3.3. Obiectele de instanță

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

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

x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

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

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

9.3.4. Metodă Obiecte

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

x . f ()

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

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

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

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

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

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

9.4. Alegeri aleatorii

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

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

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

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

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

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

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1
    def g(self):
        return 'hello world'
    h = g

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

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

class Bag:
    def __init__(self):
        self.data = []
    def add(self, x):
        self.data.append(x)
    def addtwice(self, x):
        self.add(x)
        self.add(x)

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

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

9.5. Moștenire

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

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

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

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

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

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

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

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

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

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

9.5.1. Moștenire multiplă

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

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

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

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

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

9.6. Variabile private

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

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

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

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

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

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

class  MappingSubclass ( Mapping ):

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

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

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

9.7. Cote și sfârșituri

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

clasa  angajat : 
    treci

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

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

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

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

9.8. Excepțiile sunt prea

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

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

ridica  clasa

ridicați  instanța

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

ridica  Clasa ()

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

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

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

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

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

9.9. Iteratori

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

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

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

>>>

in ? următorul ( it ) StopIteration

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

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

>>>

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

9.10. Generatoare

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

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

>>>

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

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

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

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

9.11. Expresii generatoare

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

Exemple:

>>>

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

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

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

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

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

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

Note de subsol

[1] Cu excepția unui singur lucru. Obiectele modulului au un atribut secret read-only numit__dict__ care returnează dicționarul utilizat pentru a implementa spațiul de nume al modulului; numele __dict__ este un atribut, dar nu un nume global. Evident, folosirea acestei metode încalcă abstractizarea implementării spațiului de nume și ar trebui să se limiteze la lucruri ca debuggerii post-mortem.

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

USB Tool

2018-01-18T14:59:00.001-08:00

Instalați DBAN pe o unitate flash USB utilizând Windows

Rulați DBAN dintr-o unitate flash : În următorul tutorial, vă prezentăm modul în care am creat o unitate flash USB de tip DBAN din Windows utilizând programul de instalare USB universal al terților. Darik's Boot and Nuke (DBAN) este un instrument simplu de boot de distrugere a datelor creat de Darik Horn. Poate fi utilizată pentru a șterge în siguranță un întreg hard disk sau un disc extern atașat (IDE sau SCSI), complet ștergând tot conținutul discului. După finalizare, ar trebui să puteți rula DBAN de pe dispozitivul USB.

Cum se pornește unitatea USB DBAN Off pentru a șterge unitatea hard disk

DBAN este un instrument foarte eficient de ștergere a datelor, care elimină complet datele pe hard disk pe care urmează să le eliminați. Este un disc de boot autonom care încarcă computerul și șterge datele pe care le găsește pe hard disk. Funcționează minunat, așa cum promite, pe orice computer care echipează dispozitivele CD / DVD Rom.

Dar cum ar fi acele computere care nu au un Rom / CD sau au unul care refuză să mai lucreze? Iată pașii în care puteți pune DBAN pe o unitate USB de boot. Vă mulțumim pentru pendrivelinux.com pentru partajare .

1. Descărcați ultimul DBAN.

2. Descărcați (link direct de descărcare) Universal USB Installer și lansați-l.

3. Selectați DBAN 2.2.6 din lista derulantă și alegeți litera unității pentru unitatea USB.

Nu fii înșelat de anunțurile "Descărcați"

Unele dintre cele mai reușite anunțuri sunt acelea care îi smulgă pe cititorul unei pagini să creadă că anunțul nu este într-adevăr un anunț, ci ceva util pe acel site.

Aceste tipuri de anunțuri rulează frecvent pe paginile de descărcare de software, care apar ca butoane DOWNLOAD gigant. În măsura în care aceste butoane mari ar putea să pară a fi ceea ce trebuie să faceți pentru a descărca software-ul pe care îl urmați, credeți-mă, nu sunt.

Mai rău, aceste anunțuri DOWNLOAD nu merg către site-uri benigne - de obicei, aceștia merg la o pagină malware-răsfățată, unde într-adevăr poți descărca ceva, nu doar ceva ce ai crezut că primești.

Butoanele de descărcare reală tind să fie mai mici și situate mai aproape de numele fișierului descărcat, numărul versiunii și ultima dată actualizată. Nu toate paginile de descărcare de software au butoane de descărcare, fie - multe sunt doar linkuri.

O altă problemă "ce să faceți clic" este un pic mai greu de rezolvat, dar merită încercați:

Evitați "Instalatori" și "Descărcați manageri"

Site-urile de descărcare de software full-time, cum ar fi Download.cnet.com și Softpedia , de obicei găzduiesc programele producătorilor de software gratuit.

O modalitate prin care aceste site-uri de descărcare își fac banii este prin difuzarea de anunțuri pe site-urile lor. Un alt mod din ce în ce mai obișnuit de a face bani este prin împachetarea descărcărilor pe care le servesc în interiorul unui program numit instalator sau, mai puțin frecvent, în cadrul unui manager de descărcare .

Aceste programe sunt adesea denumite PUP (programe potențial nedorite) și nu au nimic de-a face cu programul pe care încercați să îl descărcați și să-l instalați. Site-ul de descărcare câștigă bani de la producătorii acestor programe, incluzându-i pe aceia pe care îi urmați.

Facem tot posibilul pentru a evita conectarea la site-uri care folosesc instalatori și managerii de descărcări, dar uneori este imposibil, pur și simplu pentru că software-ul pe care îl recomand nu este disponibil în altă parte.

Presupunând că nu puteți găsi un link de descărcare care nu este instalat pentru software-ul dorit, puteți oricând să instalați pachetul, fiind extrem de atent la ce sunteți de acord cu procesul de instalare:

Alegeți "Instalare particularizată" și declinați software-ul suplimentar

Nu în ultimul rând, vă rugăm să încetiniți și să citiți ecranele la care vă prezentați când instalați software-ul pe care tocmai l-ați descărcat .

Nu vorbesc despre termenii și condițiile sau despre politica de confidențialitate. Nu mă înțelegeți greșit, ar trebui să le citiți și pe ei, dar asta este o altă discuție.

Ceea ce este important aici sunt ecranele care fac parte din expertul de instalare: ecranele cu casetele de selectare, butoanele "următor" și toate lucrurile pe care le accepți sau dezactivați pentru a permite instalarea sau urmărirea.

Cu excepția cazului în care vă plac barele de instrumente ale browserului, pagina dvs. de pornire fiind modificată în mod automat, abonamentele la software liber pe care nu le veți utiliza și alte chestii asemănătoare, atunci vă recomandăm să citiți cu atenție fiecare ecran din expertul de instalare și să refuzați orice " nu te interesează.

Cel mai mare sfat pe care îl avem aici este să alegeți metoda de instalare personalizatădacă vi se oferă opțiunea. Acest lucru face ca procesul de instalare să fie mai lung cu câteva ecrane suplimentare pe care le adaugă, dar este aproape întotdeauna în cazul în care opțiunile "Nu instalați acest lucru" sunt ascunse.

O modalitate de a evita toate aceste probleme de instalare este alegerea software-ului portabil în loc de software-ul instalabil , atunci când este disponibil. Mulți producători de software creează versiuni ale programelor care rulează fără a fi nevoie să fie instalate deloc.

Sfaturi avansate: verificați integritatea fișierelor și utilizați un scaner online de virusi

Dacă sunteți mai mult decât un utilizator de computer novice, vă mai aduc în minte încă două lucruri care ar trebui să ușureze orice preocupare cu privire la ceea ce descărcați și instalați:

Scanați fișierul pentru programe malware înainte de al descărca

Dacă sunteți preocupat de faptul că un program pe care doriți să îl descărcați ar putea fi infectat cu malware, nu trebuie să îl descărcați și să-l scanați singur, ceea ce poate fi puțin riscant.

Un serviciu online gratuit de scanare a virușilor, cum ar fi VirusTotal, va descărca fișierul pe serverele sale, îl va scana pentru programe malware folosind toate programele antivirus majore și apoi va raporta rezultatele lor.

Verificați integritatea fișierului descărcat

Dacă vă faceți griji că ați fost posibil să fi descărcat ceva diferit de cel pe care l-ați așteptat, este posibil să puteți verifica pentru a vedea că ceea ce aveți este ceea ce trebuia să obțineți.

Unele site-uri web oferă ceva numit valoare de control cu descărcările lor. Va arăta ca un șir lung de litere și numere. După descărcare, puteți utiliza un calculator de control de cont pentru a produce ceea ce este, sperăm, o potrivire exactă cu valoarea de control sumă listată cu descărcarea.

Consultați Cum se verifică integritatea fișierelor în Windows Cu FCIV pentru un tutorial complet.

Care site-uri de descărcare sunt cele mai bune?

În general, site-ul unui dezvoltator este cel mai sigur pariu pentru descărcarea de software, dar nu-și găzduiește întotdeauna propriile programe.

În ceea ce privește site-urile de descărcare, evităm următoarele, atunci când putem , din cauza tendinței lor de a include instalatori ori de câte ori este posibil:

Download.com [ www.download.com ]

BrotherSoft [ www.brothersoft.com ]

Softonic [ www.softonic.com ]

Freeware Fișiere [ www.freewarefiles.com ]

Tucows [ www.tucows.com ]

FileHippo.com [ www.filehippo.com ]

SourceForge [ www.sourceforge.com ]

În timp ce aceste site-uri de descărcare nu pot fi 100% libere de manageri de descărcare și de instalatori care se strecoară, rareori dacă le vedem vreodată:

LO4D.com [ www.lo4d.com ]

MajorGeeks [ www.majorgeeks.com ]

TechSpot [ www.techspot.com/downloads ]

Softpedia [ www.softpedia.com ]

SnapFiles [ www.snapfiles.com ]

Betanews [ fileforum.betanews.com ]

Uptodown [ uptodown.com ]

MyPublicWiFi 5.1 AutoVPNConnect 3.1 My WiFi Router 3.0

Instrumentul Windows USB / DVD Download vă permite să creați o copie a fișierului ISO Windows 7/8 pe o unitate flash USB sau pe un DVD. Pentru a crea un DVD bootabil sau o unitate flash USB, descărcați fișierul ISO și apoi executați instrumentul Windows 7 USB / DVD Download. Odată ce acest lucru este făcut, puteți instala Windows 7 sau Windows 8 direct de pe unitatea flash USB sau DVD.

Fișierul ISO conține toate fișierele de instalare Windows combinate într-un singur fișier necomprimat. Când descărcați fișierul ISO, trebuie să îl copiați pe un mediu pentru a instala Windows. Acest instrument vă permite să creați o copie a fișierului ISO pe o unitate flash USB sau pe un DVD. Pentru a instala Windows de pe unitatea flash USB sau DVD, tot ce trebuie să faceți este să introduceți unitatea flash USB în portul USB sau să introduceți DVD-ul în unitatea DVD și să executați Setup.exe din dosarul rădăcină al unității.

Notă: Nu puteți instala Windows din fișierul ISO până când îl copiați pe o unitate flash USB sau DVD cu instrumentul de descărcare USB / DVD de pe Windows 7 și instalați de acolo.

Copia fișierului ISO pe care creează instrumentul Windows USB / DVD Download este bootabilă. Mijloacele bootabile vă permit să instalați Windows 7 fără a trebui să rulați mai întâi un sistem de operare existent pe aparat. Dacă schimbați ordinea de încărcare a unităților în BIOS-ul computerului, puteți rula instalarea Windows 7 direct de pe unitatea flash USB sau DVD-ul când porniți computerul. Consultați documentația pentru computerul dvs. pentru informații despre schimbarea ordinii de boot a unităților de disc BIOS.

Conexiunea la Internet în Linux

2018-01-17T17:17:00.001-08:00

Software-ul NetworkManager inclus de Ubuntu are scopul de a face ca conexiunile dvs. de rețea să "funcționeze". Cu toate acestea, uneori lucrurile merg prost. Există momente în care trebuie să ajustați sau să modificați setările de conectare, în special atunci când utilizați un laptop - la fel ca în Windows .

Din fericire, nu va trebui să scoateți terminalul și să tastați orice comenzi arcane pentru a vă face conexiunea la Internet să funcționeze.

Verificați mai întâi elementele de bază

Înainte de a da vina pe Ubuntu, încercați să vă conectați la Internet pe alte dispozitive. Dacă se confruntă cu aceeași problemă, nu este cu Ubuntu - este cu altceva. De exemplu, poate fi necesar să reporniți ruterul, modemul sau ambele . Merită întotdeauna să verificați aceste elemente fundamentale înainte de a vă deplasa în depanare.

Unele laptopuri au comutatoare hardware care pot fi comutate pentru a activa sau dezactiva rapid Wi-Fi. În cazul în care dispozitivul Wi-Fi nu pare să funcționeze deloc, verificați comutatorul Wi-Fi al laptopului.

Dacă utilizați o conexiune prin cablu, asigurați-vă că cablul ethernet este conectat ferm atât la portul Ethernet al computerului, cât și la portul Ethernet al routerului. Sigur, acest lucru poate părea un pic evident, dar este ușor să pierdeți un întrerupător accidentat sau un cablu slăbit.

Pentru a rezolva problemele legate de puterea semnalului cu rețelele Wi-Fi, aranjați routerul, computerul și alte obiecte din casă pentru a obține cea mai bună putere a semnalului Wi-Fi .

Configurați setările de conectare în NetworkManager

NetworkManager se conectează la rețelele Wi-Fi și configurează automat conexiunile de rețea prin cablu atunci când conectați un cablu ethernet. Înainte de NetworkManager, va trebui să faceți acest lucru cu comenzile terminale.

Meniul pop-up pentru NetworkManager apare când faceți clic pe pictograma de conectare (fie prin cablu sau fără fir) în zona de notificări a Ubuntu.

Dacă ceva nu funcționează corect, este posibil să fie necesar să configurați NetworkManager. Faceți clic pe conexiunea de rețea sau pe pictograma Wi-Fi din panoul din colțul din dreapta sus al ecranului pentru a accesa meniul NetworkManager, apoi alegeți o rețea. Dacă aveți nevoie să vizualizați informații despre conexiunea dvs. în scopuri de depanare - adresa IP a computerului dvs., de exemplu, faceți clic pe Informații conexiune

Fereastra Informații despre conexiunea NetworkManager afișează toate detaliile despre conexiunile dvs. active, inclusiv interfața de rețea, securitatea și viteza de conectare, precum și adresele MAC și IP.

Dacă conexiunea la rețea locală nu funcționează, asigurați-vă că opțiunile Activare rețea și Activare Wi-Fi sunt selectate aici în meniu. Aceste opțiuni vă permit să dezactivați rapid și să activați conexiunile, ceea ce este util pentru a vă pune laptopul în modul avion . Dacă ați dezactivat accidental, nu veți avea o conexiune la Internet până când nu le reactivați.

NetworkManager vă permite să gestionați mai multe conexiuni de rețea și să utilizați diferite setări pentru fiecare.

Configurați conexiunile făcând clic pe Editați conexiunile . Veți vedea o fereastră cu una sau mai multe conexiuni, în funcție de câte adaptoare de rețea aveți pe computer. Selectați o conexiune și faceți clic pe Editați pentru a modifica setările.

Asigurați-vă că opțiunea "Conectare automată la această rețea când este disponibilă" este activată în fila General. Dacă este dezactivată, NetworkManager nu se va conecta automat la o rețea cu fir sau fără fir atunci când porniți computerul.

NetworkManager utilizează în mod implicit Dynamic Host Configuration Protocol (DHCP), astfel încât computerul dvs. va încerca să obțină automat setările de conexiune - adresa IP, serverele DNS și gateway-ul implicit - de la router sau de la furnizorul de servicii Internet.

Pentru rețelele care necesită o configurație IP statică , va trebui să vizitați fie Setările IPv4, fie panoul Setări IPv6 și selectați metoda "Manuală". (Dacă nu sunteți sigur care utilizați, probabil că încă mai folosiți IPv4.) Introduceți detaliile pe care le cere conexiunea dvs. aici - ISP sau administratorul de rețea vă poate spune ce trebuie să introduceți dacă nu știți.

Puteți configura ușor conexiunea pentru a utiliza setările manuale și pentru a introduce aceste setări în NetworkManager.

Dacă, din anumite motive, rețeaua dvs. permite numai conectarea dispozitivelor care au o adresă MAC specifică, faceți clic pe fila Ethernet și introduceți acea informație în caseta "Adresa MAC clonată".

Continuați să citiți mai multe despre verificarea driverelor Wi-Fi și a instrumentelor de diagnosticare .

Sursa : https://www.pcworld.com/article/2455972/how-to-fix-your-internet-connection-in-ubuntu-linux.html

Python pentru începători

2018-01-17T16:48:00.001-08:00

Noțiuni de bază

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

Începeți întotdeauna scenariile dvs. cu oricare dintre ele

#! / Usr / local / bin / python

#! / Usr / bin / python

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

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

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

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

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

script.py -v -h

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

Listarea 3
Funcția care ne permite să capturam semnale este signal.signal . Cele două argumente sunt numărul semnalului pe care doriți să-l captați și numele dispozitivului de gestionare a semnalului. Listarea 3 este un script simplu care captează semnalul SIGINT (numerele semnalului are propriile echivalente simbolice) semnalul trimis la el când apăsați CTRL-C .
Semnalul SIGINT nu este singurul pe care îl puteți captura. Dacă doriți să capturați semnale suplimentare, adăugați mai multe apeluri semnal.signale pentru a le manipula, schimbând numărul semnalului ( semnal.SIG xxx constant) și numele handlerului (opțional; puteți utiliza același handler cu mai mult de un semnal ). Pentru a vedea ce semnale sunt disponibile în Linux, tastați kill -l pe linia de comandă.
Listing 4
Semnalele pot fi ignorate, ceea ce este util dacă doriți ca unele dintre ele să nu perturbe executarea scriptului. Lista 4 arată modul în care faceți acest lucru (aveți grijă, acest script nu poate fi oprit cu CTRL-C ).
Un alt semnal care merită să ne amintim este SIGALRM. Configurarea unui handler pentru semnalul respectiv vă permite să opriți executarea scriptului dvs. după numărul de secunde dat. Acest lucru se face cu signal.alarm așa cum este prezentat în Lista 5.
Listarea 5

Lucrul cu fișierele

Lista 6
Multe scripturi trebuie să funcționeze cu fișiere. Rețineți că înainte de a putea citi sau scrie într-un fișier, acesta trebuie să existe și să fie deschis. Lista 6 este un exemplu de script care deschide un fișier pentru citire. Scrierea într-un fișier necesită doar o mică modificare (a se vedea Lista 7).
Listarea 7
După cum puteți vedea, primul dintre cele două scripturi afișate în listele 6 și 7 nu reușește să deschidă un fișier pentru a citi dacă fișierul nu există. Acesta este un comportament corect. Al doilea script încearcă să deschidă un fișier pentru scriere: dacă fișierul există, acesta este trunchiat (adică conținutul său este șters); dacă nu există, este creat. Este posibil să nu fie întotdeauna comportamentul dorit. Când doriți să adăugați date la sfârșitul unui fișier, ar trebui să îl deschideți pentru scriere, păstrând în același timp conținutul original. Pentru a face acest lucru, schimbați al doilea argument al funcției deschise de la 'w' la 'a' .
Odată ce fișierul este deschis, îl putem citi sau scrie utilizând următoarele metode:

citiți ( n ): citește cel mult n octeți dintr-un fișier (dacă omiteți numărul de octeți, întreg fișierul va fi citit), de exemplu fi.read (200) , care citește până la 200 octeți.
readline : citește câte o linie la un moment dat, de exemplu fi.readline () .
readlines : citește toate liniile dintr-un fișier, de exemplu fi.readlines () .
scrie ( șir ): scrie un șir într-un fișier, de ex. fo.write ('alabama') .
writelines ( list ): scrie o listă a șirurilor unui fișier, de ex., fo.writelines (['alaska <\ n>', 'california', 'nevada'

Când doriți să închideți un fișier, utilizați metoda sa de închidere , de exemplu, fo.close () .
Lista 8
Dacă doriți ca scriptul dvs. să creeze fișiere temporare, utilizați modulul tempfile . Acesta simplifică sarcina de a crea fișiere temporare prin crearea automată a unor nume de fișiere unice pe baza șabloanelor definite în variabilele tempdir și șablon . Nu creează sau șterge fișiere temporare în sine, dar puteți realiza acest lucru folosind o metodă similară cu cea utilizată în Lista 8.
Rețineți că trebuie să utilizați ambele simboluri os.O_CREAT și os.RDWR pentru a spune funcției os.open crearea unui fișier temporar atât pentru citire cât și pentru scriere. De asemenea, nu uitați să închideți și să eliminați toate fișierele temporare create înainte de a părăsi un script. Veți găsi mai multe informații despre funcțiile, constantele și variabilele utilizate în exemplul respectiv în secțiunile os, posix și tempfile din Manualul de Referință al Bibliotecii Python .
Listing 9
Este o idee bună să implementați un singur handler care va elimina fișierele temporare înainte de a ieși din script, ca în Lista 9.

Nu există nici măcar o comparație între Windows și Linux atunci când vine vorba de programare.
Linux este mult mai bun. Toți cei care au multe cunoștințe despre acest subiect știu acest lucru.

Python are seturi de instrumente excelente (Gtk, wx, Qt), designeri GUI și IDE-uri vizuale și biblioteci uriașe. Este atât de bun încât multe aplicații Windows sunt scrise în el și mulți oameni aleg Linux deoarece scripturile sunt atât de sărace pe Windows. Dacă doriți ceva orientat mai mult spre scripting, aveți Tcl / Tk, Expect, Bash și Perl. În loc de HTA, primiți Firefox și xulrunner (în funcție de ce nivel de control doriți). Toate acestea sunt documentate copios. AutoHotkey, Autoit și RapidBatch nu se apropie nici măcar, iar Windows este relativ slab când vine vorba de scripting.

M-am uitat la o serie de limbi de programare și scripting târziu. A venit peste "Titanium", care este o solutie cross-platform pentru Windows, Linux, OSX precum si iPhone si Android. Este capabil să lucreze cu JS, Python, PHP și o serie de alte softTech.

Mai multe informații aici:
http://en.wikipedia.org/wiki/Appcelerator_Titanium
http://www.appcelerator.com/products/

Există multe exemple de cod simplu aici ...

http://www.java2s.com/Code/Python/CatalogPython.htm

ceva mai complexe exemple de cod, și nu atât de inutile, așa cum sugerează titlul aici ...

http://www.uselesspython.com/

atunci este cartea de bucate ...

http://aspn.activestate.com/ASPN/Cookbook/Python/

și trezile lui Parnass ...

http://py.vaults.ca/apyllo.py

care ar trebui să țină ypu ocupat pentru o vreme.

decimal_number = 0
st_binary_number = "1000111"

n = 1 (n =
1)
pentru i în intervalul (n):
dacă (numărul st_binary [i] == '1'):
decimal_number + = pwr
pwr = pwr >> 1

imprimați numărul zecimal

convertește binarul "1000111" în zecimal 71;)

binary_number = "1000111"
decimal_number = int (numărul binar, 2)

print decimal_number # Imprimă 71

print a, '=', os.environ. [a]
ar trebui să fie
imprimate a, '=', os.environ [a]

Exemplu de folosire a argumentelor de comandă:
user @ host $ script.py arg1 arg2


import sys
var = sys.argv [2]
print var
#will print arg2

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

MODIFICAREA SETĂRILOR COOKIE-URILOR

Rețineți că browserele de internet vă permit să modificați setările cookie-urilor. Aceste setări sunt de obicei găsite în meniul "opțiuni" sau "preferințe" al browserului dvs. de internet. Pentru a înțelege aceste setări, următoarele link-uri ar putea fi de ajutor. În caz contrar, trebuie să utilizați opțiunea "Ajutor" în browserul dvs. de internet pentru mai multe detalii.

ookie-urile "strict necesare" vă permit să vă deplasați pe site și să utilizați funcții esențiale cum ar fi zonele securizate. Fără aceste cookie-uri, nu putem furniza serviciile solicitate. Utilizăm aceste cookie-uri Strictly Necessary pentru a:

Identificați-vă că sunteți conectat (ă) la site-ul nostru și că vă autentificați
Asigurați-vă că vă conectați la serviciul potrivit pe site-ul nostru atunci când facem orice schimbări în modul în care funcționează site-ul Web
Din motive de securitate

Acceptarea acestor cookie-uri este o condiție de utilizare a site-ului, astfel încât, dacă împiedicați aceste cookie-uri, nu putem garanta modul în care Website-ul sau securitatea pe site-ul nostru va fi efectuată în timpul vizitei.

Cookie - urile "Performanță" colectează informații despre modul în care utilizați site-ul nostru, de exemplu, paginile pe care le accesați și dacă întâmpinați erori. Aceste cookie-uri nu colectează nicio informație care să vă poată identifica și sunt utilizate numai pentru a ne ajuta să îmbunătățim funcționarea site-ului nostru, să înțelegem ce interesează utilizatorii noștri și să evalueze eficiența publicității noastre. Utilizăm cookie-urile de performanță pentru:

Realizați analize web: furnizați statistici privind utilizarea site-ului nostru web
Obțineți date despre numărul de utilizatori ai site-ului care au vizualizat un produs
Ajutați-ne să îmbunătățim website-ul prin măsurarea oricăror erori care apar
Testați diferite modele pentru site-ul Web

Unele dintre cookie-urile noastre de performanță sunt gestionate de noi de către terțe părți. Nu permitem părții terțe să utilizeze cookie-urile în alte scopuri decât cele enumerate mai sus.

Prin utilizarea site-ului nostru sau prin exprimarea consimțământului dvs. conform altor dispoziții legale aplicabile, acceptați utilizarea cookie-urilor "Performanță". Dacă preveniți cookie-urile, nu putem garanta modul în care site-ul nostru va funcționa pentru dvs.

Cookie-urile "funcționale" sunt utilizate pentru a furniza servicii sau a vă aminti setările pentru a vă îmbunătăți vizita. Utilizăm cookie-urile "funcțional" în scopuri precum:

Amintiți-vă setările pe care le-ați aplicat, cum ar fi aspectul, dimensiunea textului, limba, preferințele și culorile
Amintiți-vă dacă v-am întrebat deja dacă doriți să completați un sondaj
Amintiți-vă dacă ați angajat cu o anumită componentă sau o listă de produse pe site-ul web, astfel încât să nu-l afișați din nou
Afișați-vă când sunteți conectat (ă) la site-ul Web
Pentru a furniza și a afișa conținut video încorporat

Unele dintre aceste cookie-uri sunt gestionate pentru noi de către terțe părți. Nu permitem părții terțe să utilizeze cookie-urile în alte scopuri decât cele enumerate mai sus.

Cookie-urile "vizate" sunt utilizate pentru a urmări vizita dvs. pe site-ul Web și pe alte site-uri web, inclusiv paginile pe care le-ați vizitat și legăturile pe care le-ați urmat, ceea ce permite terților să afișeze anunțuri direcționate pe site-urile pe care le vizitați.

Noi și furnizorii noștri de servicii terțe folosim cookie-uri de direcționare către:

Legătura cu rețelele sociale, cum ar fi Facebook, care ulterior pot utiliza informații despre vizita dvs. pe site-ul nostru, pentru a oferi publicitate sau alte oferte care ar putea fi de interes pentru dvs. atunci când vizitați alte site-uri web.
Oferiți terților informații cu privire la vizita dvs., astfel încât să vă poată prezenta anunțuri sau alte oferte care ar putea fi de interes pentru dvs.

Dacă vă aflați în UE, puteți renunța la anumite cookie-uri terță parte pe care noi și alte site-uri web le putem utiliza pentru direcționare prin http://www.youronlinechoices.eu sau www.aboutads.info. Dacă renunțați la una sau mai multe rețele publicitare, înseamnă că acești membri nu vor mai oferi conținut sau anunțuri vizate. Nu înseamnă că nu veți mai primi niciun conținut sau anunțuri direcționate pe site-urile noastre sau pe alte site-uri terțe. Dacă browserul dvs. este configurat să respingă cookie-urile când vizitați una dintre paginile de renunțare menționate mai sus și mai târziu ștergeți cookie-urile, utilizați un computer diferit sau modificați browserele Web, este posibil ca preferința dvs. să nu mai fie activă. Întrucât toate aceste module cookie sunt gestionate de terțe părți, trebuie să consultați notificările și politicile de confidențialitate ale site-urilor terțe pentru informații suplimentare (mai jos, pentru mai multe informații despre cookie-urile direcționate utilizate pe site-ul nostru).

Utilizatorii din Statele Unite pot renunța la mai multe rețele publicitare terțe. De exemplu, puteți merge la pagina de alegere a consumatorilor digitală ("DAA") pentru informații despre renunțarea la publicitatea bazată pe categorii de interese și alegerile acestora privind informațiile utilizate de companiile DAA . De asemenea, puteți accesa pagina de oprire a consumatorilor pentru inițiativa Network Advertising Initiative ("NAI") pentru informații despre renunțarea la publicitatea bazată pe categorii de interese și alegerile acestora privind informațiile utilizate de membrii NAI .

Dacă renunțați la una sau mai multe companii listate pe pagina de alegere a consumatorilor DAA sau pe pagina de renunțare la consumatori a NAI, veți renunța la furnizarea de conținuturi sau anunțuri de către acele companii, dar nu înseamnă că nu veți mai fi primiți orice publicitate prin intermediul site-ului nostru sau pe alte site-uri web. Puteți continua să primiți reclame, de exemplu, pe baza site-ului web pe care îl vizualizați (adică anunțuri bazate pe contextual). De asemenea, în cazul în care browserele dvs. sunt configurate pentru a respinge cookie-urile atunci când renunțați la site-urile DAA sau NAI, opțiunea de excludere este posibil să nu fie eficientă. Informații suplimentare sunt disponibile pe site-ul web al DAA la www.aboutads.infosau pe site-ul web al NAI la www.networkadvertising.org .

MAI MULTE INFORMAȚII DESPRE COOKIE-URI

TOTUL DESPRE COOKIE-URI

Informații utile despre modulele cookie pot fi găsite la adresa:

http://www.allaboutcookies.org/

BIROUL DE PUBLICITATE PE INTERNET

Un ghid de publicitate comportamentală și de confidențialitate online a fost produs de industria de publicitate pe internet, care poate fi găsit la adresa:

http://www.youronlinechoices.eu/

Localizarea informațiilor dvs.

Orice servere sau servicii care conțin informații de identificare personală se află în UE. Pentru YouTrack InCloud, oferim clienților noștri posibilitatea de a alege între găzduirea instanței lor în UE sau în SUA. Uneori, JetBrains poate procesa sau transfera unele dintre datele personale (cum ar fi numele și adresa de e-mail) către companiile afiliate din afara UE. Orice astfel de transfer se va face în conformitate cu legile aplicabile privind protecția datelor și cu politica de confidențialitate. Prin transmiterea oricăror informații personale sau prin utilizarea site-ului web, sunteți de acord cu acest transfer și cu prelucrarea datelor dvs. personale în afara UE.

https://www.jetbrains.com/company/privacy.html#using-website

TOATE INSTRUMENTELE PYTHON

ÎNTR-UN SINGUR LOC

Economisiți timp în timp ce PyCharm se ocupă de rutină. Concentrați-vă pe lucruri mai mari și îmbrățișați abordarea centrată pe tastatură pentru a obține cele mai multe caracteristici ale productivității PyCharm.

Obțineți asistență inteligentă

PyCharm știe totul despre codul tău. Bazați-vă pe acesta pentru finalizarea codului inteligent, verificarea erorilor pe loc și remedierile rapide, navigarea ușoară a proiectelor și multe altele.

Îmbunătățiți calitatea codului

Scrieți un cod curat și întreținut, în timp ce IDE vă ajută să păstrați calitatea sub control cu verificări PEP8, asistență de testare, refactorizări inteligente și o serie de inspecții.

Tot ce ai nevoie

PyCharm este proiectat de către programatori, pentru programatori, pentru a oferi toate instrumentele de care aveți nevoie pentru dezvoltarea productivă a Python.DESCĂRCAȚI ACUM PYCHARM

PyCharm este proiectat de către programatori, pentru a oferi toate instrumentele de care aveți nevoie pentru dezvoltarea productivă a Python.

Kali Linux sau Parrot

2018-01-14T13:45:00.003-08:00

Kali Linux este preinstalat cu peste 600 de programe de testare a pătrunderii, inclusiv nmap (un scaner de port), Wireshark (un analizor de pachete), John the Ripper (un cracare cu parole), Aircrack-ng (un pachet software pentru LAN fără fir pentru testarea penetrării) , Burp suite și OWASP ZAP (ambele scanere de securitate pentru aplicații web). Kali Linux poate rula nativ când este instalat pe hard disk-ul unui computer, poate fi încărcat de pe un CD live sau live USB sau poate rula într-o mașină virtuală. Este o platformă suportată de Metasploit Framework a proiectului Metasploit, un instrument pentru dezvoltarea și executarea exploitărilor de securitate.

Download options:

Sursa : https://www.techspot.com/downloads/6738-kali-linux.html

Cum să accelerați conexiunea la internet pe Linux

Uneori, site-urile Web de navigare par a fi oarecum "nebunești", imaginile care nu se încarcă corect, valori de latență mari între computerul dvs. și serverul de rezolvare a DNS și problemele cache-ului online. Acest lucru poate fi un semn că DNS-ul furnizorului de servicii de internet nu este în sarcină, deci este posibil să trebuiască să treceți la o opțiune alternativă. Cele două cele mai populare alternative server DNS sunt DNS publică Google și OpenDNS, dar există și mai multe opțiuni libere de a utiliza alternative.

Iată cum puteți trece la DNS public Google pe distribuțiile bazate pe Ubuntu. Deschideți setările de rețea și treceți la "Setări avansate". Aceasta va deschide o fereastră nouă în care veți găsi filele "Setări IPv4 și IPv6". Navigați la ambele și modificați "Metoda" de la numai DHCP (Automatic) (DHCP) la numai adresele (DHCP). Apoi introduceți "8.8.8.8" pe caseta serverelor DNS din fila IPv4 și "2001: 4860: 4860 :: 8888" pe fila IPv6. Acum, faceți clic pe butonul "Salvați" și ați terminat.

Pentru a testa dacă noile setări DNS funcționează corect sau nu, introduceți orice adresă IP fixă care indică spre un site web și vedeți dacă aceasta se rezolvă corect. Introduceți "91.189.94.40" în bara de adrese a browserului dvs. și, dacă se rezolvă ubuntu.com, ați făcut lucrurile bine. Puteți reveni mereu la DNS prestabilit, lăsând caseta serverelor DNS goale și setând metoda înapoi la "Automatic (DHCP)". De asemenea, puteți compara noul DNS cu ajutorul utilitarului benchmarking DNS namebench open source și puteți vedea cât de mult a fost cu adevărat posibil navigarea pe Internet. Este demn de remarcat faptul că schimbarea DNS îmbunătățește de asemenea confidențialitatea, securitatea și poate deschide accesul la conținut geoblocked.

Sursa : https://www.howtoforge.com/tutorial/how-to-speed-up-your-internet-connection-on-linux/

Tutorial Instalare Kali Linux - Distributie de Linux pentru Hackeri - Invata Securitate #5
Kali Linux este distributia de Linux (cea mai) folosita de catre Hackeri si Pentesteri profesionisti datorita amalgamului de programe existente pe aceasta.
In Kali Linux poti gasi extrem de multe programe axate pe partea de securitate si mai exact pe partea de testare a vulnerabilitatii sistemului.
Pentru a instala Kali Linux, avem nevoie sa trecem prin cativa pasi. In primul rand avem nevoie de programul VirtualBox (sau un alt program de virtualizare – ex: VMware Workstation) si de imaginea OS-ului Kali Linux (pe care o poti downloada printr-o simpla cautare pe Google)
Urmatorul pas, dupa descarcarea imaginii sistemului de operare Kali Linux si a programului de virtualizare Virtualbox revine procesului de instalare (mai exact creearii unei masini virtuale),

Sursa : https://ramonnastase.ro/blog/tutorial-instalare-kali-linux/

Imaginile CD-urilor pot fi descărcate de la http://www.linux-iso.com/ şi din alte locuri, prezentate în Appendix A. O alternativă interesantă pentru cei care nu vor să facă pasul către o instalare a Linux-ului pe calculatorul lor este cea a distribuţiilor de Linux care pot rula şi de pe CD, precum Knoppix (http://www.knoppix.com/) sau Ubuntun.t. (http://www.ubuntu.com/ ).
● Capitolul 1: Ce este Linux-ul, cum a apărut el, avantaje şi dezavantaje, ce va aduce viitorul pentru Linux, cine ar trebui să-l folosească, instalarea în calculatorul dumneavoastră. ● Capitolul 2: Să începem, autentificarea la sistem, comenzile de bază, unde să căutăm ajutor. ● Capitolul 3: Sistemul de fişiere, fişiere şi directoare importante, lucrul cu fişierele şi directoarele, protejarea datelor. ● Capitolul 4: Înţelegerea proceselor şi lucrul cu acestea, procedurile de pornire şi închidere, amânarea sarcinilor, sarcini repetitive. ● Capitolul 5: Ce este o intrare standard, o ieşire şi o eroare şi cum sunt folosite aceste elemente din prompterul de comandă. ● Capitolul 6: De ce ar trebui să învăţaţi să lucraţi cu un editor de text, discutarea celor mai comune editoare de text. ● Capitolul 7: Configurarea mediului dumneavoastră, grafic, text sau audio, setări pentru utilizatorii de Linux pentru care engleza nu este limba maternă, sfaturi pentru adăugarea altor programe. ● Capitolul 8: Convertirea fişierelor în format pentru tipărire, scoaterea acestora la imprimantă, sfaturi pentru rezolvarea problemelor legate de tipărire. ● Capitolul 9: Pregătirea datelor pentru copiile de rezervă, discutarea diverselor unelte, copii de rezervă la distanţă. ● Capitolul 10: Trecerea în revistă a uneltelor de reţea ale Linux-ului şi a aplicaţiilor pentru utilizatori, cu o scurtă discuţie axată pe programele tip servicii (service daemon) şi reţea securizată. ● Capitolul 11: Sunet şi video, incluzând aici Voice over IP şi înregistrarea sunetului. ● Appendix A: Ce cărţi să citiţi şi ce saituri să vizitaţi după terminarea acestei cărţi. ● Appendix B: O comparaţie. ● Appendix C: Dacă vă blocaţi, acest tabel poate fi de ajutor. De asemenea, un bun argument atunci când şeful insistă ca DUMNEAVOASTRĂ să folosiţi shell-ul SĂU favorit.
Sursa : http://tille.garrels.be/training/tldp/ITL-Romanian.pdf

Parrot OS sau Kali Linux

Parrot "arată" mai bine cu unele caracteristici minunate, și are un TON de instrumente.

Cu toate acestea, dacă sunteți mai stabil, puteți sugera BT5R3. Iată o listă a lui Pentesting Distro, pe care o cunosc:
Kali Linux
BackTrack (1,2,3,4,5)
Parrot OS
Backbox
BugTraq (1 și 2)
Cyborg Hawk

Kali Linux și este foarte foarte bun și actualizat frecvent.

Nu am putut instala kdirstat pe kali linux, cred că trebuie să dau seama cum să instalez software-ul extern descărcat în mod corespunzător

Parrot în sine este în regulă, prea multe bug-uri pentru a fi viabile ca o soluție cu normă întreagă.

Cred ca KALI OS este mult mai stabil decat parrot os
si versiunea care vine in curand Kali v2.0 akka "SANA" arata mult mai stabila decat precedenta

Python - Guido van Rossum

2018-01-13T21:03:00.002-08:00

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

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

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

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

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

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

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

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

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

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

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

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

De ce nu Perl?

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

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

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

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

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

De ce nu Ruby?

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

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

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

Ce spun programatorii

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

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

Despre Python 3.0

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

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

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

Mai multe detalii în:

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

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

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

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

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

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

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

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

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

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

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

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

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

Rezultatul exemplului de cod este:

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

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

9.3. O primă privire la clase

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

9.3.1. Sintaxa de definire a clasei

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

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

9.3.2. Obiecte de clasă

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

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

x  =  MyClass ()

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

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

x  =  MyClass ()

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

>>>

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

9.3.3. Obiectele de instanță

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

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

9.3.4. Metodă Obiecte

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

x . f ()

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

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

9.4. Alegeri aleatorii

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

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

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

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

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

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

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

9.5. Moștenire

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

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

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

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

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

9.5.1. Moștenire multiplă

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

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

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

9.6. Variabile private

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

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

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

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

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

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

class  MappingSubclass ( Mapping ):

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

9.7. Cote și sfârșituri

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

clasa  angajat : 
    treci

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

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

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

9.8. Excepțiile sunt prea

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

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

ridica  clasa

ridicați  instanța

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

ridica  Clasa ()

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

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

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

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

9.9. Iteratori

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

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

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

>>>

in ? următorul ( it ) StopIteration

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

>>>

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

9.10. Generatoare

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

>>>

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

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

9.11. Expresii generatoare

Exemple:

>>>

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

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

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

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

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

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

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

Compatibilitate

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

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

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

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

Dezvoltare tranzitorie

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

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

Portați proiectul către Python 2.6.

Activați modul avertizări Py3k.

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

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

Testați codul sursă convertit sub 3.0.

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

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

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

Starea caracteristicilor individuale

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

Unicode, codecuri și I / O

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

Noua bibliotecă I / O

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

Imprimarea și formatarea

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

Modificări ale sistemului de clasă și tip

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

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

@art_deco
clasa C:
    ...

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

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

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

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

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

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

baze = (B1, B2)

clasa C (* baze):
    ...

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

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

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

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

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

Alte schimbări semnificative

Doar evidențiază.

Reforma excepțiilor

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

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

Vom scăpa de StandardError .

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

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

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

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

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

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

Întregul proces de reformare

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

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

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

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

Iteratori sau Iterables în loc de Liste

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

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

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

Diverse

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

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

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

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

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

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

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

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

Reforma bibliotecii

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

Și, în sfârșit

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

Vorbire Angajamente

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

Google Phoenix, biroul AZ, 21 iunie

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

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

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

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

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

Răspunde!

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

RSS Feed

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

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

Download the latest source release Python 3.6.4

OpenPGP Keys Public

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

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

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

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

gpg --import pubkeys.txt

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

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

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

gpg --verify Python-3.6.2.tgz.asc

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

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

Alte elemente utile

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

Doriți să contribuiți?

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

Ce este python?

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

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

Cum se instaleaza python

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

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

 print "Hello World!"

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

'Programe' foarte simple

Introducere

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

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

Deschidem IDLE

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

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

 >>> print "Hello World!"

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

Matematica in Python

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

- Adunare

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

-Scadere

>>> 6-5
1

- Inmultire

>>> 2*5
10

- Ridicare la putere

>>> 5**2
25

- Impartire

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

- Restul impartirii

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

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

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

ALTE TUTORIALE PYTHON:

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

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

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

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

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

Programarea Python pentru începători

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

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

Noțiuni de bază

#! / Usr / local / bin / python

#! / Usr / bin / python

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

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

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

script.py -v -h

Programare - Secvențe și Exemple

2018-01-13T20:42:00.001-08:00

Installing Python 3 on Linux

This document describes how to install Python 3.6 on Ubuntu Linux machines.

To see which version of Python 3 you have installed, open a command prompt and run

$ python3 --version

If you are using Ubuntu 16.10 or newer, then you can easily install Python 3.6 with the following commands:

$ sudo apt-get update
$ sudo apt-get install python3.6

If you’re using another version of Ubuntu (e.g. the latest LTS release), we recommend using the deadsnakes PPA to install Python 3.6:

$ sudo apt-get install software-properties-common
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt-get update
$ sudo apt-get install python3.6

If you are using other Linux distribution, chances are you already have Python 3 pre-installed as well. If not, use your distribution’s package manager. For example on Fedora, you would use dnf:

$ sudo dnf install python3

Note that if the version of the python3 package is not recent enough for you, there may be ways of installing more recent versions as well, depending on you distribution. For example installing the python36 package on Fedora 25 to get Python 3.6. If you are a Fedora user, you might want to read about multiple Python versions available in Fedora.

Working with Python 3

At this point, you may have system Python 2.7 available as well.

$ python

This will launch the Python 2 interpreter.

$ python3

This will launch the Python 3 interpreter.

Python 2.7.9 and later (on the python2 series), and Python 3.4 and later include pip by default.

To see if pip is installed, open a command prompt and run

$ command -v pip

To install pip, follow the official pip installation guide - this will automatically install the latest version of setuptools.

Note that on some Linux distributions including Ubuntu and Fedora the pip command is meant for Python 2, while the pip3 command is meant for Python 3.

$ command -v pip3

How to Download and Install Python 3.6 on Windows 10

Cum se instalează Python pe Windows

Python nu vine preambalat cu Windows, dar asta nu înseamnă că utilizatorii Windows nu vor găsi limbajul de programare flexibil util. Nu este chiar atât de simplu ca instalarea celei mai noi versiuni, deci asigurați-vă că obțineți instrumentele potrivite pentru sarcina la îndemână.

Primul lansat în 1991, Python este un popular limbaj de programare la nivel înalt utilizat pentru programarea generală. Datorită unei filozofii de design care accentuează lizibilitatea, aceasta a fost mult timp un favorit al programatorilor de hobby și al programatorilor grave. Nu numai că este un limbaj ușor (comparativ vorbind, că este) de a ridica, dar veți găsi mii de proiecte online care necesită ai instalat Python pentru a utiliza programul.

Versiunea pe care o doriți depinde de scopul final. Să spunem, de exemplu, că ați citit articolul despre extinderea lumii Minecraft cu MCDungeon și suntețiîncântați să adăugați lucruri reci în lumile voastre. Proiectul este codificat în Python și necesită Python 2.7 - nu puteți rula proiectul MCDungeon cu Python 3.6. De fapt, dacă explorați proiecte de hobby ca MCDungeon, veți găsi că aproape toți aceștia utilizează 2.7. Dacă obiectivul dvs. este să obțineți un proiect care se termină într-o extensie ".py", atunci există o sansă foarte bună, veți avea nevoie de 2.7 pentru aceasta.

NCURSES Programming HOWTO

A Word about Windows

Before we plunge into the myriad ncurses functions, let me clear few things about windows. Windows are explained in detail in following sections . A Window is an imaginary screen defined by curses system. A window does not mean a bordered window which you usually see on Win9X platforms. When curses is initialized, it creates a default window named stdscr which represents your 80x25 (or the size of window in which you are running) screen. If you are doing simple tasks like printing few strings, reading input etc., you can safely use this single window for all of your purposes. You can also create windows and call functions which explicitly work on the specified window. For example, if you call

    printw("Hi There !!!");
    refresh();

It prints the string on stdscr at the present cursor position. Similarly the call to refresh(), works on stdscr only.

Say you have created windows then you have to call a function with a 'w' added to the usual function.

    wprintw(win, "Hi There !!!");
    wrefresh(win);

As you will see in the rest of the document, naming of functions follow the same convention. For each function there usually are three more functions.

    printw(string);        /* Print on stdscr at present cursor position */
    mvprintw(y, x, string);/* Move to (y, x) then print string     */
    wprintw(win, string);  /* Print on window win at present cursor position */
                           /* in the window */
    mvwprintw(win, y, x, string);   /* Move to (y, x) relative to window */
                                    /* co-ordinates and then print         */

Usually the w-less functions are macros which expand to corresponding w-function with stdscr as the window parameter.

Introduction
In the olden days of teletype terminals, terminals were away from computers and were connected to them through serial cables. The terminals could be configured by sending a series of bytes. All the capabilities (such as moving the cursor to a new location, erasing part of the screen, scrolling the screen, changing modes etc.) of terminals could be accessed through these series of bytes. These control seeuqnces are usually called escape sequences, because they start with an escape(0x1B) character. Even today, with proper emulation, we can send escape sequences to the emulator and achieve the same effect on a terminal window.

Suppose you wanted to print a line in color. Try typing this on your console.
echo "^[[0;31;40mIn Color"

The first character is an escape character, which looks like two characters ^ and [. To be able to print it, you have to press CTRL+V and then the ESC key. All the others are normal printable characters. You should be able to see the string "In Color" in red. It stays that way and to revert back to the original mode type this.
echo "^[[0;37;40m"

Now, what do these magic characters mean? Difficult to comprehend? They might even be different for different terminals. So the designers of UNIX invented a mechanism named termcap. It is a file that lists all the capabilities of a particular terminal, along with the escape sequences needed to achieve a particular effect. In the later years, this was replaced by terminfo. Without delving too much into details, this mechanism allows application programs to query the terminfo database and obtain the control characters to be sent to a terminal or terminal emulator.

Compiling With the NCURSES Library

To use ncurses library functions, you have to include ncurses.h in your programs. To link the program with ncurses the flag -lncurses should be added.

    #include <ncurses.h>
    .
    .
    .

    compile and link: gcc <program file> -lncurses

Example 1. The Hello World !!! Program

#include <ncurses.h>

int main()
{ 
 initscr();   /* Start curses mode     */
 printw("Hello World !!!"); /* Print Hello World    */
 refresh();   /* Print it on to the real screen */
 getch();   /* Wait for user input */
 endwin();   /* End curses mode    */

 return 0;
}

An Example
Let's write a program which will clarify the usage of these functions.
Example 2. Initialization Function Usage example

#include <ncurses.h>

int main()
{ int ch;

 initscr();   /* Start curses mode   */
 raw();    /* Line buffering disabled */
 keypad(stdscr, TRUE);  /* We get F1, F2 etc..  */
 noecho();   /* Don't echo() while we do getch */

     printw("Type any character to see it in bold\n");
 ch = getch();   /* If raw() hadn't been called
      * we have to press enter before it
      * gets to the program   */
 if(ch == KEY_F(1))  /* Without keypad enabled this will */
  printw("F1 Key pressed");/*  not get to us either */
     /* Without noecho() some ugly escape
      * charachters might have been printed
      * on screen   */
 else
 { printw("The pressed key is ");
  attron(A_BOLD);
  printw("%c", ch);
  attroff(A_BOLD);
 }
 refresh();   /* Print it on to the real screen */
     getch();   /* Wait for user input */
 endwin();   /* End curses mode    */

 return 0;
}

This program is self-explanatory. But I used functions which aren't explained yet. The function getch() is used to get a character from user. It is equivalent to normal getchar() except that we can disable the line buffering to avoid <enter> after input. Look for more about getch()and reading keys in the key management section . The functions attron and attroff are used to switch some attributes on and off respectively. In the example I used them to print the character in bold. These functions are explained in detail later.

NCURSES Programming HOWTO

Table of Contents

1. Introduction

1.1. What is NCURSES?
1.2. What we can do with NCURSES
1.3. Where to get it
1.4. Purpose/Scope of the document
1.5. About the Programs
1.6. Other Formats of the document
1.7. Credits
1.8. Wish List
1.9. Copyright

2. Hello World !!!

2.1. Compiling With the NCURSES Library
2.2. Dissection

3. The Gory Details

4. Initialization

4.1. Initialization functions
4.2. raw() and cbreak()
4.3. echo() and noecho()
4.4. keypad()
4.5. halfdelay()
4.6. Miscellaneous Initialization functions
4.7. An Example

5. A Word about Windows

6. Output functions

6.1. addch() class of functions
6.2. mvaddch(), waddch() and mvwaddch()
6.3. printw() class of functions
6.4. addstr() class of functions
6.5. A word of caution

7. Input functions

7.1. getch() class of functions
7.2. scanw() class of functions
7.3. getstr() class of functions
7.4. Some examples

8. Attributes

8.1. The details
8.2. attron() vs attrset()
8.3. attr_get()
8.4. attr_ functions
8.5. wattr functions
8.6. chgat() functions

9. Windows

9.1. The basics
9.2. Let there be a Window !!!
9.3. Explanation
9.4. The other stuff in the example
9.5. Other Border functions

10. Colors

10.1. The basics
10.2. Changing Color Definitions
10.3. Color Content

11. Interfacing with the key board

11.1. The Basics
11.2. A Simple Key Usage example

12. Interfacing with the mouse

12.1. The Basics
12.2. Getting the events
12.3. Putting it all Together
12.4. Miscellaneous Functions

13. Screen Manipulation

13.1. getyx() functions
13.2. Screen Dumping
13.3. Window Dumping

14. Miscellaneous features

14.1. curs_set()
14.2. Temporarily Leaving Curses mode
14.3. ACS_ variables

15. Other libraries

16. Panel Library

16.1. The Basics
16.2. Compiling With the Panels Library
16.3. Panel Window Browsing
16.4. Using User Pointers
16.5. Moving and Resizing Panels
16.6. Hiding and Showing Panels
16.7. panel_above() and panel_below() Functions

17. Menus Library

17.1. The Basics
17.2. Compiling With the Menu Library
17.3. Menu Driver: The work horse of the menu system
17.4. Menu Windows
17.5. Scrolling Menus
17.6. Multi Columnar Menus
17.7. Multi Valued Menus
17.8. Menu Options
17.9. The useful User Pointer

18. Forms Library

18.1. The Basics
18.2. Compiling With the Forms Library
18.3. Playing with Fields
18.4. Form Windows
18.5. Field Validation
18.6. Form Driver: The work horse of the forms system

19. Tools and Widget Libraries

19.1. CDK (Curses Development Kit)
19.2. The dialog
19.3. Perl Curses Modules CURSES::FORM and CURSES::WIDGETS

20. Just For Fun !!!

20.1. The Game of Life
20.2. Magic Square
20.3. Towers of Hanoi
20.4. Queens Puzzle
20.5. Shuffle
20.6. Typing Tutor

21. References

Un alt mod în care puteți folosi Python în Linux este prin IDLE (mediul de dezvoltare integrat Python), o interfață grafică de utilizator pentru scrierea codului Python. Înainte de instalare, este o idee bună să efectuați o căutare pentru a afla care sunt versiunile disponibile pentru distribuția dvs.:

# aptitude search idle     [Debian and derivatives]
# yum search idle          [CentOS and Fedora]
# dnf search idle          [Fedora 23+ version]

$ sudo aptitude install idle-python3.2     # Folosesc Linux Mint 13

După instalare, veți vedea următorul ecran după lansarea IDLE . În timp ce seamănă cu shell-ul Python, puteți face mai mult cu IDLE decât cu shell-ul.

python-parrot 1.0.0

Download
python-parrot-1.0.0.tar.gz

Parrot este un server HTTP simplu care răspunde la cererile cu un nume de fișier specificat

Ultima versiune: 1.0.2

parrot este un server HTTP simplu care răspunde la orice solicitare GET validă cu fișierul specificat pe linia de comandă.

Este utilă în timpul testelor (de exemplu, pentru a șterge o aplicație de server) sau pentru a efectua testarea clientului. Atât fișierele text cât și fișierele binare sunt difuzate corect.

Singura ei dependență este biblioteca excelentă de magie python pentru ghicitul de tip mime. Funcționează pe Python 3.

$ pip install python-parrot

Usage

$ parrot port filename

The following arguments are required:

port: Port to listen on
filename: Filename of the data to send in response to all requests

MathJax / mhchem Manual

Mhchem este un instrument de scriere a ecuațiilor chimice frumoase cu ușurință.
Acesta este manualul pentru sintaxa de intrare a lui mhchem.
Acesta acoperă versiunea 3.2.x a lui MathJax / mhchem.
mhchem este o extensie terță parte pentru MathJax . Pentru informații despre cum să încărcați extensia și să faceți \cecomanda disponibilă, consultați documentele oficiale MathJax . Pe scurt, utilizați această config:

MathJax.Ajax.config.path["mhchem"] =
  "https://cdnjs.cloudflare.com/ajax/libs/mathjax-mhchem/3.2.0";
MathJax.Hub.Config({
  TeX: {
    extensions: ["[mhchem]/mhchem.js"]
  }
});

ecuațiile chimice (ce)
C O 2+C⟶2C OCOX2+C⟶2CO
$\ce{CO2 + C -> 2 CO}$

H g 2 +-→I -H g I 2-→I -[ H g I - amI 4] 2 -HgX2+→euX-HgeuX2→euX-[HgXeueueuX4]X2-
$\ce{Hg^2+ ->[I-] HgI2 ->[I-] [Hg^{II}I4]^2-}$

SEO - OPTIMIZAREA PAGINII WEB

2012-10-07T15:08:00.000-07:00

Optimizarea on-site sau on-page este una dintre cele mai importante parti ale optimizarii pentru motoarele de cautare si trebuie sa fie facuta ok atat pentru motoarele de cautare, cat si pentru oamenii ce va vor citi site-ul. Bineinteles ca in functie de tipul site-ului (e-commerce, blog, site de prezentare etc…) , structura acestuia va fi diferita, insa va trebui sa aiba multe din urmatoarele elemente prezente.

Motoarele de căutare sînt programate să utilizeze în mod optim baza de date obţinută de roboţii tîrîtori (indexatori) care analizează conţinutul paginilor de pe internet. Scopul lor este să prezinte foarte rapid internauţilor liste cu pagini web în care primele locuri să fie ocupate de pagini cu un conţinut informativ şi util pentru tema căutată. Deci algoritmul de sortare a paginilor trebuie să fie foarte bine conceput, pentru că el are rolul de a sorta mii sau zeci de mii de pagini într-un timp foarte scurt şi cu un rezultat care să fie pe placul internauţilor.

Un robot tîrîtor nu vede paginile web aşa cum le văd oamenii, el acordă o importanţă covîrşitoare textului unei pagini, fără a fi impresionat deloc de aspectul ei grafic. Ca urmare, bazele de date ale motoarelor de căutare conţin pagini indexate după conţinutul lor scris şi nu după cel grafic. Acest conţinut scris este cel care dă 70% din relevanţa unei pagini web, restul de 30% fiind dat de optimizarea ("cosmetizarea") paginii web.

Sarcina lingviştilor şi a matematicienilor implicaţi în dezvoltarea motoarelor de căutare a stat tocmai în crearea şi optimizarea unui algoritm care să poată să ordoneze un număr mare de pagini web în funcţie de utilitatea conţinutului lor scris. În mod evident, unele din caracteristicile algoritmului nu sînt uşor de sesizat de către persoanele care nu au lucrat la el. Alte caracteristici pot fi însă deduse analizînd paginile web care apar în mod constant pe primele locuri ale listelor generate de motoarele de căutare.

Este uşor de intuit faptul că algoritmul favorizează paginile web care au un conţinut mai mare de text, pentru că se consideră că aceste pagini conţin multă informaţie, iar internauţii caută în mod special această caracteristică a paginilor web. Nu se ştie precis cum este evaluat de către un anumit algoritm conţinutul de text al unei pagini, dar este foarte posibil să fie luat în calcul numărul de caractere (litere) din pagină, aşa cum a fost calculat de robotul tîrîtor care a indexat pagina. Asta nu înseamnă că paginile umplute cu text pînă la refuz au un succes garantat în ce priveşte aprecierea lor de către motoarele de căutare. Trebuie să ţinem cont şi de alte aspecte, cum este de exemplu calitatea expunerii informaţiilor din textul respectiv.

Paginile cu mult text sînt pe placul algoritmilor de căutare, dar oamenii sînt mai rafinaţi, ei preferă de cele mai multe ori o cantitate rezonabilă de text şi care în plus trebuie să fie interesant, util, bine scris şi formatat în aşa fel încît să fie plăcut de citit. Un alt aspect care nu trebuie neglijat este actualizarea periodică a conţinutului sitului şi adăugarea de noi materiale.

Atunci cînd scriem textul dintr-o pagină trebuie să ne asigurăm că folosim inclusiv sinonime pentru cuvintele-cheie şi de asemenea că folosim şi variante mai puţin folosite ale acestora. De exemplu într-o pagină web care tratează un subiect despre siturile web (găzduire de ex.) trebuie folosit în principal cuvîntul "sit", dar trebuie pusă în paranteză şi varianta "site", încă destul de folosită, deşi este incorectă. În acest fel dacă un internaut va căuta paginile care conţin sintagma "găzduire site web", avem toate şansele ca şi pagina noastră care tratează acest subiect să fie luată în seamă de motorul de căutare pentru includerea pe lista rezultatelor căutării.

Ce este SEO?

SEO (search engine optimization) este procesul de îmbunătățire a performanței, experienței și autorității site-ului dvs., astfel încât să poată obține o vizibilitate mai bună în motoarele de căutare precum Google.

Mai exact, SEO se referă la clasarea mai sus în rezultatele căutării organice (unpaid). Nu rezultate plătite sau sponsorizate.

De ce este important SEO ?

SEO este important, deoarece poate aduce mai mult trafic, clienți potențiali, clienți și venituri pentru afacerea dvs. Chiar și strategiile SEO de bază pot oferi o rentabilitate uriașă a investiției. Sursa Info !

Cercetare organică Vrei să ajungi în vârful SERP?

Începeți cu a învăța ce funcționează cel mai bine pentru concurenții dvs.

Descoperiți cele mai bune cuvinte cheie ale concurenților

Explorați clasamentele de cuvinte cheie ale rivalilor dvs. pe desktop și mobil
Vizualizați paginile lor de destinație afișate în SERP-uri pentru un anumit cuvânt cheie
Vedeți cât trafic aduce organic un termen de căutare.
Găsiți noi concurenți organici
- Păstrați o atenție deosebită asupra peisajului competitiv organic dinamic
- Obțineți o reprezentare vizuală a locului în care se află site-ul dvs., printre alți jucători de căutare organică
- Vedeți o listă de domenii cu care vă luptați pentru primele poziții în Google și Bing
- Observați schimbările de poziție ale domeniilor
  Fiți la curent cu modul în care pozițiile de domeniu ale rivalilor dvs. se schimbă în rezultatele organice
  Afla ce cuvinte cheie noi i-au ajutat pe competitorii tai sa intre in top 20 Google sau Bing
  Înțelegeți unde câștigă propriile tactici și dacă există loc de îmbunătățire
Vezi Sursa Info AICI

PROMOVARE SITE

2012-10-06T13:50:00.001-07:00

PROMOVAREA UNUI SIT WEB

Orice webmaster vrea, fie că o recunoaşte deschis sau nu, ca situl său să fie vizitat de cît mai mulţi internauţi şi dacă se poate, cît mai des. Această dorinţă (care ţine de considerente financiare sau de ego) nu este însă realizabilă decît dacă webmasterul şi toţi ceilalţi implicaţi în administrarea sitului depun un efort constant pentru a menţine conţinutul şi aspectul sitului cît mai aproape de cerinţele internauţilor. Succesul unui sit, ca de altfel al oricărui produs, se datorează în mare măsură şi modului în care este promovat, cu alte cuvinte marketingul este aproape la fel de important ca şi calitatea unui produs.

În această lume a internetului încă foarte tînără, experţii în crearea de situri Web sau redactorii de articole interesante nu sînt de obicei şi experţi în marketing. Tocmai din această cauză promovarea eficientă a unui sit web este făcută de cele mai multe ori de către profesionişti. Aceştia îşi oferă serviciile contra cost şi la ei apelează companiile care vor să-şi construiască o prezentă importantă pe internet. Sumele investite în marketingul profesional sînt impresionante şi în permanentă creştere de la an la an.

O caracteristică a Internetului este că acesta, în calitatea sa de spaţiu virtual permite oricărui internaut să-şi construiască un sit web, existînd, spre deosebire de spaţiul real, destul loc pentru toată lumea. Mai mult, internautul respectiv nu trebuie să aibă cunoştinţe avansate de limbaj HTML sau să plătească vreun ban pentru locul de pe Internet unde vrea să-şi construiască situl (se exclud bineînţeles cheltuielile legate de conectare şi cele datorate operatorului de telefonie). Există în momentul de faţă poate zeci de milioane de situri în toată lumea, cele mai multe dintre ele aparţinînd unor internauţi obişnuiţi şi nu unor companii sau instituţii.

Siturile mici sînt însă potenţiale surse de cîştig material pentru proprietari, pentru că există companii interesate să cumpere spaţiu publicitar chiar şi pe siturile mici, cu condiţia ca acestea să fie vizitate des. Un sit bine făcut şi care şi-a dobîndit deja o "clientelă" de internauţi constantă poate fi la un moment dat cumpărat pentru o sumă importantă de către o companie mult mai mare, existînd în plus posibilitatea ca administratorii sitului să-şi păstreze locurile de muncă pentru a continua să menţină şi să îmbunătăţească situl.

Ţinînd cont de faptul că internauţii romani care sînt în acelaşi timp şi webmasteri vor să le fie vizitate siturile, ei trebuie să înveţe să-şi facă singuri activitatea de marketing, pentru că nu au mijloacele financiare necesare pentru apelarea la specialişti. Multe firme rumîneşti care vor să aibă situri web de succes sînt în aceeaşi situaţie, din cauza dificultăţilor financiare neputînd fi luată în discuţie cumpărarea de spaţiu publicitar pe internet sau angajarea unor specialişti în marketing. Greul promovării sitului cade astfel pe umerii webmasterului, transformat peste noapte şi în responsabil cu marketingul.

În cele ce urmează vor fi prezentate metodele prin care orice internaut poate să-şi promoveze situl, fără a fi nevoit să apeleze la profesionişti.

Metodele cele mai eficiente de promovare a unui sit sînt următoarele:

1) Optimizarea sitului web pentru indexarea adecvată de către motoarele de căutare
2) Înscrierea sitului în cataloagele de adrese ale portalurilor internaţionale şi rumîneşti
3) Promovarea sitului pe forumurile on-line sau în grupurile de discuţii
4) Participarea la clasamentele siturilor care fac topuri

Să presupunem că dorim să construim un sit pentru firma pe care o deţinem. Aceasta pune în vînzare biciclete (noi şi la mîna a doua) şi piese de schimb, dar în acelaşi timp oferă şi servicii de reparare a unor biciclete care au fost vîndute sau nu de firmă. Dorim să alcătuim un sit care să fie mixt, adică să aibă o parte comercială şi una de informare.

Primul pas este să alegem un domeniu pentru situl firmei. Este indicat să cumpărăm un domeniu cu nume sugestiv, de exemplu putem folosi cuvîntul "biciclete" şi să alegem unul din domeniile http://www.biciclete.ro sau http://www.biciclete.com. Dacă acestea au fost deja cumpărate, putem alege un domeniu care se termină în NET (http://www.biciclete.net), BIZ, etc. În cazul puţin probabil în care toate domeniile au fost deja cumpărate, putem încerca diverse variante de cuvinte compuse, de exemplu "super-biciclete". Numele unui domeniu nu trebuie să conţină spaţii, de aceea dacă vom folosi un cuvînt compus va trebui să folosim o liniuţă pentru a lega părţile sale componente. Al doilea pas care trebuie făcut este să găzduim situl pe un server.

Pentru ambele iniţiative expuse mai sus (înregistrarea domeniului şi găzduirea sitului), cel mai indicat este să apelăm la serviciile unei companii specializate. În general furnizorii de servicii internet (cei care oferă acces la internet) propun şi servicii de înregistrare şi găzduire de situri. Dacă dorim să comparăm ofertele mai multor companii, putem să căutăm pe internet pagini care conţin sintagmele: "înregistrare domenii web" şi "găzduire situri web" sau să vizităm secţiunile de legături ale portalurilor rumîneşti sau ale catalogului ODP. De asemenea putem să căutăm sintagmele "web domain registration rumania" şi "web hosting rumania".

În cazul în care nu dorim să investim mulţi bani în situl web, dar dorim să avem o prezenţă pe internet, putem să apelăm la variantele gratuite de înregistrare a unui domeniu web şi de găzduire de situri. O astfel de variantă este recomandată într-o primă instanţă, pentru a nu investi mulţi bani în ceva (prezenţă pe internet) de care nu sîntem siguri că ne va aduce un profit pe măsura sumelor investite. Totul se rezumă la a ne înregistra la unul din numeroasele situri care propun astfel de servicii.

Serverul - un sistem de gazduire

2012-10-06T13:18:00.002-07:00

Ce inseamna server

Toata lumea stie, probabil, ce inseamna Internet: acea colectie uriasa de echipamente legate intre ele in scopul schimbului de informatii sau al furnizarii de servicii. Daca ar fi sa simplificam mult ideea de internet, am putea considera ca acesta este o retea de calculatoare in care fiecare nod (calculator) gazduieste informatii sau servicii ce pot fi accesate de publicul larg. Aceste calculatoare din internet poarta numele de servere.

In sens larg, un server este un dispozitiv (combinatie de hardware si software) care ofera servicii si/sau informatii utilizatorilor (clientilor).

Odata cu notiunea de server apare si cea de arhitectura client-server, care se refera la un ansamblu format dintr-un dispozitiv server (furnizor de informatii) si un dispozitiv (calculator) client, conectate prin intermediul unei retele si care fac schimb de informatii. Cel mai comun exemplu al acestui ansamblu este dat de functionalitatea de partajare a fisierelor in retea (File Sharing). Spre exemplu, un calculator contine un folder partajat (share-uit) si un alt calculator copiaza folderul prin retea. In aceasta situatie, calculatorul care ofera folderul are functia de server iar cel care preia folderul - pe cea de client. Rolul de client/server nu este statornic in acest scenariu, oricare din cele doua calculatoare putand oricand sa detine oricare din functii. Asadar notiunea de server se aplica in momentul in care dispozitivul din retea (calculatorul) ofera informatii sau servicii.

Server web

Un tip particular de server, este server-ul web. Un server web este un sistem care gazduieste si ofera pagini web prin intermediul unei retele. De cele mai multe ori, termenul de server web desemneaza a aplicatie, un program care ruleaza pe calculatorul-server si care este responsabil cu primirea cerintelor de la utilizatori si transferarea paginilor web catre ei.

Ce inseamna site?

Paginile stocate pe un calculator-server si oferite publicului larg sunt grupate sub denumirea generica de site. Un site (denumit si website) este, asadar, o colectie de pagini web, interconectate, stocate pe un server web.

Deservirea paginilor

In momentul in care un server web primeste o cerinta de la un utilizator pentru o pagina, se verifica mai intai existenta acesteia. Daca pagina exista fizic pe server atunci este transmisa catre utilizator. Paginile returnate de un server web sunt de obicei in format HTML. Navigatoarele web (browserele) sunt capabile sa interpreteze codul HTML si sa afiseze informatiile intr-un mod usor de citit.

In imaginea de mai jos este reprezentata o comunicare tipica intre un server web si un client.

Deservirea unei pagini statice, fara interventia interpretorului
PHP

In lumea reala, paginile deservite de un server web sunt de cele mai multe ori modificate inainte de a fi transmise catre clienti. Exista situatii cand paginile cerute nici nu exista fizic pe calculatorul server si cu toate astea ele sunt construite si deservite la cerere.

Acest lucru este posibil gratie unor module sau aplicatii aditionale care functioneaza impreuna cu aplicatia de server web. Unul din aceste module este PHP.

Informatica , SEO , Optimizare , HTML , pagini web , Internet

Cuvintele Cheie

Cele mai bune practici pentru găsirea unor cuvinte cheie noi

Identificați cuvinte-cheie noi

Faceți publicitate pe blog

Înscrieți-vă la AdSense

Afișați anunțuri între postări

Afișați anunțuri în coloane

Afișați anunțuri de la alte servicii de anunțuri

Consultați raportul privind veniturile din Blogger

Ce trebuie să faceți dacă AdSense nu se activează

Configurați un fișier ads.txt

Python , un limbaj accesibil 1

Tutorialul Python

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

2. Folosirea Interpretului Python

2.1. Invocarea interpretului

2.1.1. Argumentul de trecere

2.1.2. Modul Interactiv

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

2.2.1. Efectuarea erorilor

2.2.2. Șabloane de execuție Python

2.2.3. Codificarea codului sursă

2.2.4. Fișierul de pornire interactivă

2.2.5. Modulele de personalizare

3. O introducere informală în Python

3.1. Utilizarea Python ca Calculator

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

3.1.1. Numere

3.1.2. Stringuri

3.1.3. Liste

3.2. Primii pași spre programare

4. Mai multe instrumente de control al fluxului

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

4.1. dacă Declarațiile

Python un lombaj accesibil

4.2. pentru declarații

4.3. Intervalul () Funcția

4.4. întrerupeți și continuați declarațiile, și altfelClauzele pe buclă

4.5. declarații trecute

4.6. Definirea funcțiilor

4.7. Mai multe despre definirea funcțiilor

De asemenea, este posibil să se definească funcții cu un număr variabil de argumente. Există trei forme care pot fi combinate.

4.7.1. Valori implicite ale argumentelor

4.7.2. Argumentele pentru cuvinte cheie

4.7.3. Liste de argumente libere

4.7.4. Despachetarea listelor de argumente

4.7.5. Expresii Lambda

4.7.6. Structuri de documentare

4.7.7. Annotările funcției

4.8. Intermezzo: Stilul de codificare

Python un limbaj accesibil

Python este un limbaj de programare general, versatil și puternic. Este o limbă maternă excelentă, deoarece este concisă și ușor de citit. Orice vrei să faci, Python o poate face. De la dezvoltarea web la învățarea automată până la știința datelor

Ce să mai citim?

Ne pregătim pentru Marte Robot pe MarteCe să mai citim?Tatăl fondator al Uniunii Europene. Colonizarea de pe Marte ! Ne pregătim pentru MarteColonizarea Marte poate determina umanitatea să-și modifice ADN-ul ?Cine mai urăște să poarte mască?

5.1.1. Utilizarea listelor ca stive

5.1.2. Utilizarea listelor ca Cozile

5.1.3. Lista înțelegerilor

5.1.4. Înțelegeri ale listei încorporate

5.2. Del Declarația

5.3. Tupele și secvențe

5.4. Seturi

5.5. Dicționare

5.6. Tehnici looping

5.7. Mai multe despre condițiile

5.8. Compararea secvențelor și a altor tipuri

Modulele

6.1. Mai multe despre module

6.1.1. Executarea modulelor ca scripturi

6.1.2. Calea de căutare a modulului

6.1.3. „Compilat“ fișiere Python

6.2. Module standard

6.3. Dir () Funcția

6.4. Pachete

6.4.1. Importul * dintr-un pachet

6.4.2. Referințe-pachet intra

6.4.3. Pachete în mai multe directoare

7. Intrări și ieșiri

Există mai multe modalități de prezentare a rezultatelor unui program; datele pot fi tipărite într-o formă ușor de citit de om sau scrise într-un fișier pentru utilizare ulterioară. Acest capitol va discuta câteva posibilități.

7.1. Formatul de ieșire pentru fancier

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

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

4.1. `dacă` Declarațiile

4.2. `pentru` declarații

4.3. `Intervalul ()` Funcția

4.4. `întrerupeți` și `continuați` declarațiile, și `altfel`Clauzele pe buclă

4.5. declarații `trecute`

Ne pregătim pentru Marte
Robot pe Marte

Ce să mai citim?
Tatăl fondator al Uniunii Europene.
Colonizarea de pe Marte !
Ne pregătim pentru Marte
Colonizarea Marte poate determina umanitatea să-și modifice ADN-ul ?
Cine mai urăște să poarte mască?

5.2. `Del` Declarația

6.3. `Dir ()` Funcția

7.2.2. Salvarea datelor structurate cu `json`