Guida rapida di Python

Python è un linguaggio di scripting di alto livello, interpretato, interattivo e orientato agli oggetti. Python è progettato per essere altamente leggibile. Utilizza frequentemente parole chiave inglesi mentre altre lingue usano la punteggiatura e ha meno costruzioni sintattiche rispetto ad altre lingue.

• Python is Interpreted- Python viene elaborato in fase di esecuzione dall'interprete. Non è necessario compilare il programma prima di eseguirlo. Questo è simile a PERL e PHP.

• Python is Interactive - Puoi effettivamente sederti a un prompt di Python e interagire direttamente con l'interprete per scrivere i tuoi programmi.

• Python is Object-Oriented - Python supporta lo stile o la tecnica di programmazione orientata agli oggetti che incapsula il codice all'interno degli oggetti.

• Python is a Beginner's Language - Python è un ottimo linguaggio per i programmatori di livello principiante e supporta lo sviluppo di un'ampia gamma di applicazioni, dalla semplice elaborazione del testo ai browser WWW ai giochi.

Storia di Python

Python è stato sviluppato da Guido van Rossum tra la fine degli anni Ottanta e l'inizio degli anni Novanta presso il National Research Institute for Mathematics and Computer Science nei Paesi Bassi.

Python è derivato da molti altri linguaggi, tra cui ABC, Modula-3, C, C ++, Algol-68, SmallTalk e Unix shell e altri linguaggi di scripting.

Python è protetto da copyright. Come Perl, il codice sorgente di Python è ora disponibile sotto la GNU General Public License (GPL).

Python è ora mantenuto da un team di sviluppo principale presso l'istituto, sebbene Guido van Rossum abbia ancora un ruolo vitale nel dirigere il suo progresso.

Funzionalità di Python

Le caratteristiche di Python includono:

• Easy-to-learn- Python ha poche parole chiave, una struttura semplice e una sintassi chiaramente definita. Ciò consente allo studente di imparare rapidamente la lingua.

• Easy-to-read - Il codice Python è più chiaramente definito e visibile agli occhi.

• Easy-to-maintain - Il codice sorgente di Python è abbastanza facile da mantenere.

• A broad standard library - La maggior parte della libreria di Python è molto portabile e compatibile multipiattaforma su UNIX, Windows e Macintosh.

• Interactive Mode - Python supporta una modalità interattiva che consente il test interattivo e il debug di frammenti di codice.

• Portable - Python può essere eseguito su un'ampia varietà di piattaforme hardware e ha la stessa interfaccia su tutte le piattaforme.

• Extendable- Puoi aggiungere moduli di basso livello all'interprete Python. Questi moduli consentono ai programmatori di aggiungere o personalizzare i propri strumenti per essere più efficienti.

• Databases - Python fornisce interfacce a tutti i principali database commerciali.

• GUI Programming - Python supporta applicazioni GUI che possono essere create e portate su molte chiamate di sistema, librerie e sistemi Windows, come Windows MFC, Macintosh e il sistema X Window di Unix.

• Scalable - Python fornisce una struttura e un supporto migliori per programmi di grandi dimensioni rispetto allo scripting della shell.

Oltre alle funzionalità sopra menzionate, Python ha un lungo elenco di buone funzionalità, alcune sono elencate di seguito:

• Supporta metodi di programmazione funzionali e strutturati nonché OOP.

• Può essere utilizzato come linguaggio di scripting o può essere compilato in byte-code per la creazione di applicazioni di grandi dimensioni.

• Fornisce tipi di dati dinamici di altissimo livello e supporta il controllo del tipo dinamico.

• Supporta la raccolta automatica dei rifiuti.

• Può essere facilmente integrato con C, C ++, COM, ActiveX, CORBA e Java.

Python è disponibile su un'ampia varietà di piattaforme tra cui Linux e Mac OS X. Comprendiamo come configurare il nostro ambiente Python.

Configurazione dell'ambiente locale

Apri una finestra di terminale e digita "python" per scoprire se è già installato e quale versione è installata.

• Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX, ecc.)
• Win 9x / NT / 2000
• Macintosh (Intel, PPC, 68K)
• OS/2
• DOS (più versioni)
• PalmOS
• Telefoni cellulari Nokia
• Windows CE
• Acorn / RISC OS
• BeOS
• Amiga
• VMS/OpenVMS
• QNX
• VxWorks
• Psion
• Python è stato anche portato su macchine virtuali Java e .NET

Ottenere Python

Il codice sorgente, i binari, la documentazione, le notizie, ecc. Più aggiornati e attuali sono disponibili sul sito Web ufficiale di Python https://www.python.org/

Puoi scaricare la documentazione di Python da https://www.python.org/doc/. La documentazione è disponibile nei formati HTML, PDF e PostScript.

Installazione di Python

La distribuzione Python è disponibile per un'ampia varietà di piattaforme. Devi scaricare solo il codice binario applicabile alla tua piattaforma e installare Python.

Se il codice binario per la tua piattaforma non è disponibile, è necessario un compilatore C per compilare manualmente il codice sorgente. La compilazione del codice sorgente offre una maggiore flessibilità in termini di scelta delle funzionalità richieste durante l'installazione.

Ecco una rapida panoramica dell'installazione di Python su varie piattaforme:

Installazione di Unix e Linux

Ecco i semplici passaggi per installare Python su una macchina Unix / Linux.

• Apri un browser Web e vai a https://www.python.org/downloads/.

• Segui il link per scaricare il codice sorgente zippato disponibile per Unix / Linux.

• Scarica ed estrai file.

• Modificare il file Modules / Setup se si desidera personalizzare alcune opzioni.

• eseguire lo script ./configure

• make

• fare installazione

Questo installa Python nella posizione standard / usr / local / bin e le sue librerie in / usr / local / lib / pythonXX dove XX è la versione di Python.

Installazione di Windows

Ecco i passaggi per installare Python su macchina Windows.

• Apri un browser Web e vai a https://www.python.org/downloads/.

• Segui il collegamento per il file python-XYZ.msi del programma di installazione di Windows in cui XYZ è la versione che devi installare.

• Per utilizzare questo programma di installazione python-XYZ.msi , il sistema Windows deve supportare Microsoft Installer 2.0. Salvare il file di installazione sul computer locale e quindi eseguirlo per scoprire se il computer supporta MSI.

• Esegui il file scaricato. Questo fa apparire la procedura guidata di installazione di Python, che è davvero facile da usare. Accetta le impostazioni predefinite, attendi fino al termine dell'installazione e il gioco è fatto.

Installazione su Macintosh

I Mac recenti vengono forniti con Python installato, ma potrebbe essere obsoleto di diversi anni. Vederehttp://www.python.org/download/mac/per istruzioni su come ottenere la versione corrente insieme a strumenti aggiuntivi per supportare lo sviluppo su Mac. Per i sistemi operativi Mac precedenti a Mac OS X 10.3 (rilasciato nel 2003), è disponibile MacPython.

Jack Jansen lo mantiene e puoi avere pieno accesso all'intera documentazione sul suo sito web - http://www.cwi.nl/~jack/macpython.html. È possibile trovare i dettagli completi dell'installazione per l'installazione di Mac OS.

Configurazione di PATH

Programmi e altri file eseguibili possono trovarsi in molte directory, quindi i sistemi operativi forniscono un percorso di ricerca che elenca le directory in cui il sistema operativo cerca gli eseguibili.

Il percorso è memorizzato in una variabile di ambiente, che è una stringa denominata gestita dal sistema operativo. Questa variabile contiene le informazioni disponibili per la shell dei comandi e altri programmi.

Il path la variabile è denominata PATH in Unix o Path in Windows (Unix fa distinzione tra maiuscole e minuscole; Windows no).

In Mac OS, il programma di installazione gestisce i dettagli del percorso. Per richiamare l'interprete Python da una directory particolare, è necessario aggiungere la directory Python al percorso.

Impostazione del percorso su Unix / Linux

Per aggiungere la directory Python al percorso per una particolare sessione in Unix -

• In the csh shell - digita setenv PATH "$ PATH: / usr / local / bin / python" e premi Invio.

• In the bash shell (Linux) - digita export PATH = "$ PATH: / usr / local / bin / python" e premi Invio.

• In the sh or ksh shell - digita PATH = "$ PATH: / usr / local / bin / python" e premi Invio.

• Note - / usr / local / bin / python è il percorso della directory Python

Impostazione del percorso in Windows

Per aggiungere la directory Python al percorso di una particolare sessione in Windows:

At the command prompt - digita path% path%; C: \ Python e premi Invio.

Note - C: \ Python è il percorso della directory Python

Variabili d'ambiente Python

Qui ci sono importanti variabili d'ambiente, che possono essere riconosciute da Python -

Sr.No.	Variabile e descrizione
1	PYTHONPATH Ha un ruolo simile a PATH. Questa variabile indica all'interprete Python dove individuare i file del modulo importati in un programma. Dovrebbe includere la directory della libreria sorgente Python e le directory contenenti il ​​codice sorgente Python. PYTHONPATH a volte è preimpostato dall'installer di Python.
2	PYTHONSTARTUP Contiene il percorso di un file di inizializzazione contenente il codice sorgente Python. Viene eseguito ogni volta che si avvia l'interprete. È chiamato .pythonrc.py in Unix e contiene comandi che caricano utilità o modificano PYTHONPATH.
3	PYTHONCASEOK Viene utilizzato in Windows per istruire Python a trovare la prima corrispondenza senza distinzione tra maiuscole e minuscole in un'istruzione import. Impostare questa variabile su qualsiasi valore per attivarla.
4	PYTHONHOME È un percorso di ricerca del modulo alternativo. Di solito è incorporato nelle directory PYTHONSTARTUP o PYTHONPATH per rendere facile il cambio delle librerie dei moduli.

Esecuzione di Python

Esistono tre modi diversi per avviare Python:

Interprete interattivo

Puoi avviare Python da Unix, DOS o qualsiasi altro sistema che ti fornisce un interprete della riga di comando o una finestra della shell.

accedere python la riga di comando.

Inizia subito a scrivere codice nell'interprete interattivo.

$python # Unix/Linux
or
python% # Unix/Linux
or
C:> python # Windows/DOS

Ecco l'elenco di tutte le opzioni disponibili della riga di comando:

Sr.No.	Opzione e descrizione
1	-d Fornisce l'output di debug.
2	-O Genera bytecode ottimizzato (risultante in file .pyo).
3	-S Non eseguire il sito di importazione per cercare i percorsi Python all'avvio.
4	-v output dettagliato (traccia dettagliata sulle istruzioni di importazione).
5	-X disabilitare le eccezioni incorporate basate sulla classe (basta usare le stringhe); obsoleto a partire dalla versione 1.6.
6	-c cmd eseguire lo script Python inviato come stringa cmd
7	file eseguire lo script Python da un determinato file

Script dalla riga di comando

Uno script Python può essere eseguito dalla riga di comando invocando l'interprete sulla tua applicazione, come di seguito:

$python script.py # Unix/Linux

or

python% script.py # Unix/Linux

or 

C: >python script.py # Windows/DOS

Note - Assicurati che la modalità di autorizzazione del file consenta l'esecuzione.

Ambiente di sviluppo integrato

Puoi eseguire Python anche da un ambiente GUI (Graphical User Interface), se hai un'applicazione GUI sul tuo sistema che supporta Python.

• Unix - IDLE è il primo IDE Unix per Python.

• Windows - PythonWin è la prima interfaccia Windows per Python ed è un IDE con una GUI.

• Macintosh - La versione Macintosh di Python insieme all'IDE IDE è disponibile dal sito Web principale, scaricabile come file MacBinary o BinHex.

Se non sei in grado di configurare correttamente l'ambiente, puoi chiedere aiuto all'amministratore di sistema. Assicurati che l'ambiente Python sia configurato correttamente e funzioni perfettamente.

Note - Tutti gli esempi forniti nei capitoli successivi vengono eseguiti con la versione Python 2.4.3 disponibile sulla versione CentOS di Linux.

Abbiamo già configurato l'ambiente di programmazione Python online, in modo che tu possa eseguire tutti gli esempi disponibili online contemporaneamente quando stai imparando la teoria. Sentiti libero di modificare qualsiasi esempio ed eseguirlo online.

Il linguaggio Python ha molte somiglianze con Perl, C e Java. Tuttavia, ci sono alcune differenze nette tra le lingue.

Primo programma Python

Cerchiamo di eseguire programmi in diverse modalità di programmazione.

Programmazione in modalità interattiva

Invocare l'interprete senza passare un file di script come parametro fa apparire il seguente prompt:

$ python
Python 2.4.3 (#1, Nov 11 2010, 13:34:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Digita il testo seguente al prompt di Python e premi Invio -

>>> print "Hello, Python!"

Se stai eseguendo una nuova versione di Python, dovresti usare l'istruzione print con parentesi come in print ("Hello, Python!");. Tuttavia nella versione 2.4.3 di Python, questo produce il seguente risultato:

Hello, Python!

Programmazione in modalità script

Invocando l'interprete con un parametro di script inizia l'esecuzione dello script e continua fino al termine dello script. Quando lo script è finito, l'interprete non è più attivo.

Scriviamo un semplice programma Python in uno script. I file Python hanno estensione.py. Digita il seguente codice sorgente in un file test.py -

print "Hello, Python!"

Supponiamo che tu abbia l'interprete Python impostato nella variabile PATH. Ora, prova a eseguire questo programma come segue:

$ python test.py

Questo produce il seguente risultato:

Hello, Python!

Proviamo un altro modo per eseguire uno script Python. Ecco il file test.py modificato -

#!/usr/bin/python

print "Hello, Python!"

Supponiamo che tu abbia un interprete Python disponibile nella directory / usr / bin. Ora, prova a eseguire questo programma come segue:

$ chmod +x test.py     # This is to make file executable
$./test.py

Questo produce il seguente risultato:

Hello, Python!

Identificatori Python

Un identificatore Python è un nome utilizzato per identificare una variabile, una funzione, una classe, un modulo o un altro oggetto. Un identificatore inizia con una lettera dalla A alla Z o dalla aaz o un trattino basso (_) seguito da zero o più lettere, trattini bassi e cifre (da 0 a 9).

Python non consente caratteri di punteggiatura come @, $ e% all'interno degli identificatori. Python è un linguaggio di programmazione case sensitive. Quindi,Manpower e manpower sono due diversi identificatori in Python.

Ecco le convenzioni di denominazione per gli identificatori Python:

• I nomi delle classi iniziano con una lettera maiuscola. Tutti gli altri identificatori iniziano con una lettera minuscola.

• L'avvio di un identificatore con un singolo trattino basso iniziale indica che l'identificatore è privato.

• L'inizio di un identificatore con due trattini bassi iniziali indica un identificatore fortemente privato.

• Se l'identificatore termina anche con due trattini bassi finali, l'identificatore è un nome speciale definito dalla lingua.

Parole riservate

Il seguente elenco mostra le parole chiave Python. Queste sono parole riservate e non è possibile utilizzarle come costanti o variabili o altri nomi di identificatori. Tutte le parole chiave Python contengono solo lettere minuscole.

e	exec	non
asserire	finalmente	o
rompere	per	passaggio
classe	a partire dal	Stampa
Continua	globale	aumentare
def	Se	ritorno
del	importare	provare
elif	in	mentre
altro	è	con
tranne	lambda	dare la precedenza

Linee e rientro

Python non fornisce parentesi graffe per indicare blocchi di codice per definizioni di classi e funzioni o controllo di flusso. I blocchi di codice sono indicati dall'indentazione della riga, che viene applicata in modo rigido.

Il numero di spazi nell'indentazione è variabile, ma tutte le istruzioni all'interno del blocco devono essere rientrate della stessa quantità. Ad esempio:

if True:
   print "True"
else:
   print "False"

Tuttavia, il blocco seguente genera un errore:

if True:
print "Answer"
print "True"
else:
print "Answer"
print "False"

Quindi, in Python tutte le linee continue rientrate con lo stesso numero di spazi formerebbero un blocco. L'esempio seguente ha vari blocchi di istruzioni:

Note- Non cercare di capire la logica in questo momento. Assicurati solo di aver compreso i vari blocchi anche se sono senza parentesi graffe.

#!/usr/bin/python

import sys

try:
   # open file stream
   file = open(file_name, "w")
except IOError:
   print "There was an error writing to", file_name
   sys.exit()
print "Enter '", file_finish,
print "' When finished"
while file_text != file_finish:
   file_text = raw_input("Enter text: ")
   if file_text == file_finish:
      # close the file
      file.close
      break
   file.write(file_text)
   file.write("\n")
file.close()
file_name = raw_input("Enter filename: ")
if len(file_name) == 0:
   print "Next time please enter something"
   sys.exit()
try:
   file = open(file_name, "r")
except IOError:
   print "There was an error reading file"
   sys.exit()
file_text = file.read()
file.close()
print file_text

Dichiarazioni su più righe

Le dichiarazioni in Python tipicamente terminano con una nuova riga. Python, tuttavia, consente l'uso del carattere di continuazione della riga (\) per indicare che la riga deve continuare. Ad esempio:

total = item_one + \
        item_two + \
        item_three

Le istruzioni contenute tra le parentesi [], {} o () non devono utilizzare il carattere di continuazione della riga. Ad esempio:

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

Citazione in Python

Python accetta virgolette singole ('), doppie (") e triple (' '' o" "") per denotare stringhe letterali, purché lo stesso tipo di virgolette inizi e termini la stringa.

Le virgolette triple vengono utilizzate per estendere la stringa su più righe. Ad esempio, tutti i seguenti sono legali:

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

Commenti in Python

Un cancelletto (#) che non si trova all'interno di una stringa letterale inizia un commento. Tutti i caratteri dopo il # e fino alla fine della riga fisica fanno parte del commento e l'interprete Python li ignora.

#!/usr/bin/python

# First comment
print "Hello, Python!" # second comment

Questo produce il seguente risultato:

Hello, Python!

Puoi digitare un commento sulla stessa riga dopo un'istruzione o un'espressione:

name = "Madisetti" # This is again comment

Puoi commentare più righe come segue:

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

Utilizzo di righe vuote

Una riga contenente solo spazi bianchi, possibilmente con un commento, è nota come riga vuota e Python la ignora completamente.

In una sessione di interprete interattiva, è necessario immettere una riga fisica vuota per terminare un'istruzione su più righe.

Aspettando l'utente

La riga seguente del programma visualizza il prompt, l'istruzione che dice "Premere il tasto Invio per uscire" e attende che l'utente agisca -

#!/usr/bin/python

raw_input("\n\nPress the enter key to exit.")

Qui, "\ n \ n" viene utilizzato per creare due nuove righe prima di visualizzare la riga effettiva. Una volta che l'utente preme il tasto, il programma termina. Questo è un bel trucco per tenere aperta una finestra della console finché l'utente non ha finito con un'applicazione.

Affermazioni multiple su una singola riga

Il punto e virgola (;) consente più istruzioni sulla singola riga, dato che nessuna delle due istruzioni avvia un nuovo blocco di codice. Ecco un esempio di cattura utilizzando il punto e virgola:

import sys; x = 'foo'; sys.stdout.write(x + '\n')

Gruppi di istruzioni multiple come suite

Viene chiamato un gruppo di singole istruzioni, che formano un singolo blocco di codice suitesin Python. Istruzioni composte o complesse, come if, while, def e class richiedono una riga di intestazione e una suite.

Le righe di intestazione iniziano l'istruzione (con la parola chiave) e terminano con due punti (:) e sono seguite da una o più righe che compongono la suite. Ad esempio:

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Argomenti della riga di comando

Molti programmi possono essere eseguiti per fornire alcune informazioni di base su come dovrebbero essere eseguiti. Python ti consente di farlo con -h -

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

You can also program your script in such a way that it should accept various options. Command Line Arguments is an advanced topic and should be studied a bit later once you have gone through rest of the Python concepts.

Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.

Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals or characters in these variables.

Assigning Values to Variables

Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. The equal sign (=) is used to assign values to variables.

The operand to the left of the = operator is the name of the variable and the operand to the right of the = operator is the value stored in the variable. For example −

#!/usr/bin/python

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print counter
print miles
print name

Here, 100, 1000.0 and "John" are the values assigned to counter, miles, and name variables, respectively. This produces the following result −

100
1000.0
John

Multiple Assignment

Python allows you to assign a single value to several variables simultaneously. For example −

a = b = c = 1

Here, an integer object is created with the value 1, and all three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables. For example −

a,b,c = 1,2,"john"

Here, two integer objects with values 1 and 2 are assigned to variables a and b respectively, and one string object with the value "john" is assigned to the variable c.

Standard Data Types

The data stored in memory can be of many types. For example, a person's age is stored as a numeric value and his or her address is stored as alphanumeric characters. Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.

Python has five standard data types −

• Numbers
• String
• List
• Tuple
• Dictionary

Python Numbers

Number data types store numeric values. Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10

You can also delete the reference to a number object by using the del statement. The syntax of the del statement is −

del var1[,var2[,var3[....,varN]]]]

You can delete a single object or multiple objects by using the del statement. For example −

del var
del var_a, var_b

Python supports four different numerical types −

• int (signed integers)
• long (long integers, they can also be represented in octal and hexadecimal)
• float (floating point real values)
• complex (complex numbers)

Examples

Here are some examples of numbers −

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Python allows you to use a lowercase l with long, but it is recommended that you use only an uppercase L to avoid confusion with the number 1. Python displays long integers with an uppercase L.

• A complex number consists of an ordered pair of real floating-point numbers denoted by x + yj, where x and y are the real numbers and j is the imaginary unit.

Python Strings

Strings in Python are identified as a contiguous set of characters represented in the quotation marks. Python allows for either pairs of single or double quotes. Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 at the end.

The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator. For example −

#!/usr/bin/python

str = 'Hello World!'

print str          # Prints complete string
print str[0]       # Prints first character of the string
print str[2:5]     # Prints characters starting from 3rd to 5th
print str[2:]      # Prints string starting from 3rd character
print str * 2      # Prints string two times
print str + "TEST" # Prints concatenated string

This will produce the following result −

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Python Lists

Lists are the most versatile of Python's compound data types. A list contains items separated by commas and enclosed within square brackets ([]). To some extent, lists are similar to arrays in C. One difference between them is that all the items belonging to a list can be of different data type.

The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list concatenation operator, and the asterisk (*) is the repetition operator. For example −

#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list          # Prints complete list
print list[0]       # Prints first element of the list
print list[1:3]     # Prints elements starting from 2nd till 3rd 
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists

This produce the following result −

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Python Tuples

A tuple is another sequence data type that is similar to the list. A tuple consists of a number of values separated by commas. Unlike lists, however, tuples are enclosed within parentheses.

The main differences between lists and tuples are: Lists are enclosed in brackets ( [ ] ) and their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and cannot be updated. Tuples can be thought of as read-only lists. For example −

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print tuple               # Prints the complete tuple
print tuple[0]            # Prints first element of the tuple
print tuple[1:3]          # Prints elements of the tuple starting from 2nd till 3rd 
print tuple[2:]           # Prints elements of the tuple starting from 3rd element
print tinytuple * 2       # Prints the contents of the tuple twice
print tuple + tinytuple   # Prints concatenated tuples

This produce the following result −

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

The following code is invalid with tuple, because we attempted to update a tuple, which is not allowed. Similar case is possible with lists −

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Python Dictionary

Python's dictionaries are kind of hash table type. They work like associative arrays or hashes found in Perl and consist of key-value pairs. A dictionary key can be almost any Python type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.

Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square braces ([]). For example −

#!/usr/bin/python

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

This produce the following result −

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Dictionaries have no concept of order among elements. It is incorrect to say that the elements are "out of order"; they are simply unordered.

Data Type Conversion

Sometimes, you may need to perform conversions between the built-in types. To convert between types, you simply use the type name as a function.

There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value.

Sr.No.	Function & Description
1	int(x [,base]) Converts x to an integer. base specifies the base if x is a string.
2	long(x [,base] ) Converts x to a long integer. base specifies the base if x is a string.
3	float(x) Converts x to a floating-point number.
4	complex(real [,imag]) Creates a complex number.
5	str(x) Converts object x to a string representation.
6	repr(x) Converts object x to an expression string.
7	eval(str) Evaluates a string and returns an object.
8	tuple(s) Converts s to a tuple.
9	list(s) Converts s to a list.
10	set(s) Converts s to a set.
11	dict(d) Creates a dictionary. d must be a sequence of (key,value) tuples.
12	frozenset(s) Converts s to a frozen set.
13	chr(x) Converts an integer to a character.
14	unichr(x) Converts an integer to a Unicode character.
15	ord(x) Converts a single character to its integer value.
16	hex(x) Converts an integer to a hexadecimal string.
17	oct(x) Converts an integer to an octal string.

Operators are the constructs which can manipulate the value of operands.

Consider the expression 4 + 5 = 9. Here, 4 and 5 are called operands and + is called operator.

Types of Operator

Python language supports the following types of operators.

• Arithmetic Operators
• Comparison (Relational) Operators
• Assignment Operators
• Logical Operators
• Bitwise Operators
• Membership Operators
• Identity Operators

Let us have a look on all operators one by one.

Python Arithmetic Operators

Assume variable a holds 10 and variable b holds 20, then −

[ Show Example ]

Operator	Description	Example
+ Addition	Adds values on either side of the operator.	a + b = 30
- Subtraction	Subtracts right hand operand from left hand operand.	a – b = -10
* Multiplication	Multiplies values on either side of the operator	a * b = 200
/ Division	Divides left hand operand by right hand operand	b / a = 2
% Modulus	Divides left hand operand by right hand operand and returns remainder	b % a = 0
** Exponent	Performs exponential (power) calculation on operators	a**b =10 to the power 20
//	Floor Division - The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity) −	9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

Python Comparison Operators

These operators compare the values on either sides of them and decide the relation among them. They are also called Relational operators.

Assume variable a holds 10 and variable b holds 20, then −

[ Show Example ]

Operator	Description	Example
==	If the values of two operands are equal, then the condition becomes true.	(a == b) is not true.
!=	If values of two operands are not equal, then condition becomes true.	(a != b) is true.
<>	If values of two operands are not equal, then condition becomes true.	(a <> b) is true. This is similar to != operator.
>	If the value of left operand is greater than the value of right operand, then condition becomes true.	(a > b) is not true.
<	If the value of left operand is less than the value of right operand, then condition becomes true.	(a < b) is true.
>=	If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.	(a >= b) is not true.
<=	If the value of left operand is less than or equal to the value of right operand, then condition becomes true.	(a <= b) is true.

Python Assignment Operators

Assume variable a holds 10 and variable b holds 20, then −

[ Show Example ]

Operator	Description	Example
=	Assigns values from right side operands to left side operand	c = a + b assigns value of a + b into c
+= Add AND	It adds right operand to the left operand and assign the result to left operand	c += a is equivalent to c = c + a
-= Subtract AND	It subtracts right operand from the left operand and assign the result to left operand	c -= a is equivalent to c = c - a
*= Multiply AND	It multiplies right operand with the left operand and assign the result to left operand	c *= a is equivalent to c = c * a
/= Divide AND	It divides left operand with the right operand and assign the result to left operand	c /= a is equivalent to c = c / a
%= Modulus AND	It takes modulus using two operands and assign the result to left operand	c %= a is equivalent to c = c % a
**= Exponent AND	Performs exponential (power) calculation on operators and assign value to the left operand	c **= a is equivalent to c = c ** a
//= Floor Division	It performs floor division on operators and assign value to the left operand	c //= a is equivalent to c = c // a

Python Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Assume if a = 60; and b = 13; Now in the binary format their values will be 0011 1100 and 0000 1101 respectively. Following table lists out the bitwise operators supported by Python language with an example each in those, we use the above two variables (a and b) as operands −

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

There are following Bitwise operators supported by Python language

[ Show Example ]

Operator	Description	Example
& Binary AND	Operator copies a bit to the result if it exists in both operands	(a & b) (means 0000 1100)
| Binary OR	It copies a bit if it exists in either operand.	(a | b) = 61 (means 0011 1101)
^ Binary XOR	It copies the bit if it is set in one operand but not both.	(a ^ b) = 49 (means 0011 0001)
~ Binary Ones Complement	It is unary and has the effect of 'flipping' bits.	(~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift	The left operands value is moved left by the number of bits specified by the right operand.	a << 2 = 240 (means 1111 0000)
>> Binary Right Shift	The left operands value is moved right by the number of bits specified by the right operand.	a >> 2 = 15 (means 0000 1111)

Python Logical Operators

There are following logical operators supported by Python language. Assume variable a holds 10 and variable b holds 20 then

[ Show Example ]

Operator	Description	Example
and Logical AND	If both the operands are true then condition becomes true.	(a and b) is true.
or Logical OR	If any of the two operands are non-zero then condition becomes true.	(a or b) is true.
not Logical NOT	Used to reverse the logical state of its operand.	Not(a and b) is false.

Python Membership Operators

Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples. There are two membership operators as explained below −

[ Show Example ]

Operator	Description	Example
in	Evaluates to true if it finds a variable in the specified sequence and false otherwise.	x in y, here in results in a 1 if x is a member of sequence y.
not in	Evaluates to true if it does not finds a variable in the specified sequence and false otherwise.	x not in y, here not in results in a 1 if x is not a member of sequence y.

Python Identity Operators

Identity operators compare the memory locations of two objects. There are two Identity operators explained below −

[ Show Example ]

Operator	Description	Example
is	Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.	x is y, here is results in 1 if id(x) equals id(y).
is not	Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.	x is not y, here is not results in 1 if id(x) is not equal to id(y).

Python Operators Precedence

The following table lists all operators from highest precedence to lowest.

[ Show Example ]

Sr.No.	Operator & Description
1	** Exponentiation (raise to the power)
2	~ + - Complement, unary plus and minus (method names for the last two are +@ and -@)
3	* / % // Multiply, divide, modulo and floor division
4	+ - Addition and subtraction
5	>> << Right and left bitwise shift
6	& Bitwise 'AND'
7	^ | Bitwise exclusive `OR' and regular `OR'
8	<= < > >= Comparison operators
9	<> == != Equality operators
10	= %= /= //= -= += *= **= Assignment operators
11	is is not Identity operators
12	in not in Membership operators
13	not or and Logical operators

Decision making is anticipation of conditions occurring while execution of the program and specifying actions taken according to the conditions.

Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome. You need to determine which action to take and which statements to execute if outcome is TRUE or FALSE otherwise.

Following is the general form of a typical decision making structure found in most of the programming languages −

Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value.

Python programming language provides following types of decision making statements. Click the following links to check their detail.

Sr.No.	Statement & Description
1	if statements An if statement consists of a boolean expression followed by one or more statements.
2	if...else statements An if statement can be followed by an optional else statement, which executes when the boolean expression is FALSE.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).

Let us go through each decision making briefly −

Single Statement Suites

If the suite of an if clause consists only of a single line, it may go on the same line as the header statement.

Here is an example of a one-line if clause −

#!/usr/bin/python

var = 100
if ( var == 100 ) : print "Value of expression is 100"
print "Good bye!"

When the above code is executed, it produces the following result −

Value of expression is 100
Good bye!

In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. The following diagram illustrates a loop statement −

Python programming language provides following types of loops to handle looping requirements.

Sr.No.	Loop Type & Description
1	while loop Repeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.
2	for loop Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
3	nested loops You can use one or more loop inside any another while, for or do..while loop.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Python supports the following control statements. Click the following links to check their detail.

Let us go through the loop control statements briefly

Sr.No.	Control Statement & Description
1	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
2	continue statement Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	pass statement The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.

Number data types store numeric values. They are immutable data types, means that changing the value of a number data type results in a newly allocated object.

Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10

È inoltre possibile eliminare il riferimento a un oggetto numero utilizzando il deldichiarazione. La sintassi dell'istruzione del è:

del var1[,var2[,var3[....,varN]]]]

È possibile eliminare un singolo oggetto o più oggetti utilizzando il file deldichiarazione. Ad esempio:

del var
del var_a, var_b

Python supporta quattro diversi tipi numerici:

• int (signed integers) - Sono spesso chiamati solo numeri interi o interi, sono numeri interi positivi o negativi senza punto decimale.

• long (long integers ) - Chiamati anche lunghi, sono numeri interi di dimensione illimitata, scritti come numeri interi e seguiti da una L maiuscola o minuscola.

• float (floating point real values)- Chiamati anche float, rappresentano numeri reali e sono scritti con un punto decimale che divide le parti intere e frazionarie. I galleggianti possono anche essere in notazione scientifica, con E o e che indicano la potenza di 10 (2.5e2 = 2.5 x 10 ² = 250).

• complex (complex numbers)- sono della forma a + bJ, dove aeb sono float e J (oj) rappresenta la radice quadrata di -1 (che è un numero immaginario). La parte reale del numero è a e la parte immaginaria è b. I numeri complessi non sono usati molto nella programmazione Python.

Esempi

Ecco alcuni esempi di numeri

int	lungo	galleggiante	complesso
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEL	32,3 + e18	.876j
-0490	535633629843L	-90.	-.6545 + 0J
-0x260	-052318172735L	-32.54e100	3e + 26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Python consente di utilizzare una L minuscola con long, ma si consiglia di utilizzare solo una L maiuscola per evitare confusione con il numero 1. Python visualizza interi lunghi con una L. maiuscola

• Un numero complesso è costituito da una coppia ordinata di numeri reali in virgola mobile indicati da a + bj, dove a è la parte reale eb è la parte immaginaria del numero complesso.

Conversione del tipo di numero

Python converte i numeri internamente in un'espressione contenente tipi misti in un tipo comune per la valutazione. Ma a volte, è necessario forzare un numero esplicitamente da un tipo a un altro per soddisfare i requisiti di un operatore o di un parametro di funzione.

• genere int(x) per convertire x in un intero normale.

• genere long(x) per convertire x in un intero lungo.

• genere float(x) per convertire x in un numero in virgola mobile.

• genere complex(x) per convertire x in un numero complesso con parte reale x e parte immaginaria zero.

• genere complex(x, y)per convertire xey in un numero complesso con la parte reale x e la parte immaginaria y. x e y sono espressioni numeriche

Funzioni matematiche

Python include le seguenti funzioni che eseguono calcoli matematici.

Sr.No.	Funzione e ritorni (descrizione)
1	abs (x) Il valore assoluto di x: la distanza (positiva) tra x e zero.
2	ceil (x) Il soffitto di x: il più piccolo intero non inferiore a x
3	cmp (x, y) -1 se x <y, 0 se x == y o 1 se x> y
4	exp (x) L'esponenziale di x: e x
5	fabs (x) Il valore assoluto di x.
6	pavimento (x) Il minimo di x: il numero intero più grande non maggiore di x
7	log (x) Il logaritmo naturale di x, per x> 0
8	log10 (x) Il logaritmo in base 10 di x per x> 0.
9	max (x1, x2, ...) Il più grande dei suoi argomenti: il valore più vicino all'infinito positivo
10	min (x1, x2, ...) Il più piccolo dei suoi argomenti: il valore più vicino all'infinito negativo
11	modf (x) Le parti frazionarie e intere di x in una tupla a due elementi. Entrambe le parti hanno lo stesso segno di x. La parte intera viene restituita come float.
12	pow (x, y) Il valore di x ** y.
13	rotondo (x [, n]) xarrotondato a n cifre dal punto decimale. Python arrotonda lontano da zero come un pareggio: round (0,5) è 1,0 e round (-0,5) è -1,0.
14	sqrt (x) La radice quadrata di x per x> 0

Funzioni di numeri casuali

I numeri casuali vengono utilizzati per giochi, simulazioni, test, applicazioni di sicurezza e privacy. Python include le seguenti funzioni comunemente usate.

Sr.No.	Descrizione della funzione
1	scelta (seq) Un elemento casuale da un elenco, tupla o stringa.
2	randrange ([start,] stop [, step]) Un elemento selezionato casualmente dall'intervallo (inizio, fine, passo)
3	casuale() Un float casuale r, tale che 0 sia minore o uguale a r e r sia minore di 1
4	seme ([x]) Imposta il valore iniziale intero utilizzato nella generazione di numeri casuali. Chiamare questa funzione prima di chiamare qualsiasi altra funzione del modulo casuale. Restituisce Nessuno.
5	shuffle (lst) Rende casuale gli elementi di un elenco in posizione. Restituisce Nessuno.
6	uniforme (x, y) Un float casuale r, tale che x è minore o uguale a r e r è minore di y

Funzioni trigonometriche

Python include le seguenti funzioni che eseguono calcoli trigonometrici.

Sr.No.	Descrizione della funzione
1	acos (x) Restituisce l'arcocoseno di x, in radianti.
2	asin (x) Restituisce l'arcoseno di x, in radianti.
3	atan (x) Restituisce l'arcotangente di x, in radianti.
4	atan2 (y, x) Restituisce atan (y / x), in radianti.
5	cos (x) Restituisce il coseno di x radianti.
6	ipot (x, y) Restituisce la norma euclidea, sqrt (x * x + y * y).
7	peccato (x) Restituisce il seno di x radianti.
8	tan (x) Restituisce la tangente di x radianti.
9	gradi (x) Converte l'angolo x da radianti a gradi.
10	radianti (x) Converte l'angolo x da gradi a radianti.

Costanti matematiche

Il modulo definisce anche due costanti matematiche:

Sr.No.	Costanti e descrizione
1	pi La costante matematica pi greco.
2	e La costante matematica e.

Le stringhe sono tra i tipi più popolari in Python. Possiamo crearli semplicemente racchiudendo i caratteri tra virgolette. Python tratta le virgolette singole come le virgolette doppie. La creazione di stringhe è semplice come assegnare un valore a una variabile. Ad esempio:

var1 = 'Hello World!'
var2 = "Python Programming"

Accesso ai valori nelle stringhe

Python non supporta un tipo di carattere; queste sono trattate come stringhe di lunghezza uno, quindi considerate anche una sottostringa.

Per accedere alle sottostringhe, utilizza le parentesi quadre per affettare insieme all'indice o agli indici per ottenere la sottostringa. Ad esempio:

#!/usr/bin/python

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

Quando il codice sopra viene eseguito, produce il seguente risultato:

var1[0]:  H
var2[1:5]:  ytho

Aggiornamento delle stringhe

È possibile "aggiornare" una stringa esistente (ri) assegnando una variabile a un'altra stringa. Il nuovo valore può essere correlato al valore precedente oa una stringa completamente diversa. Ad esempio:

#!/usr/bin/python

var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python'

Quando il codice sopra viene eseguito, produce il seguente risultato:

Updated String :-  Hello Python

Caratteri di fuga

La tabella seguente è un elenco di caratteri di escape o non stampabili che possono essere rappresentati con la notazione backslash.

Un carattere di fuga viene interpretato; in stringhe con virgolette singole e doppie virgolette.

Notazione backslash	Carattere esadecimale	Descrizione
\un	0x07	Campanello o avviso
\ b	0x08	Backspace
\ cx		Control-x
\ Cx		Control-x
\ e	0x1b	Fuga
\ f	0x0c	Formfeed
\ M- \ Cx		Meta-Control-x
\ n	0x0a	Nuova linea
\ nnn		Notazione ottale, dove n è compreso tra 0,7
\ r	0x0d	Ritorno in carrozza
\S	0x20	Spazio
\ t	0x09	Tab
\ v	0x0b	Scheda verticale
\X		Carattere x
\ xnn		Notazione esadecimale, dove n è compreso tra 0,9, af o AF

Operatori speciali di stringa

Assumi una variabile stringa a contiene "Hello" e una variabile b contiene "Python", quindi -

Operatore	Descrizione	Esempio
+	Concatenazione: aggiunge valori su entrambi i lati dell'operatore	a + b darà HelloPython
*	Ripetizione: crea nuove stringhe, concatenando più copie della stessa stringa	a * 2 darà -HelloHello
[]	Slice - Fornisce il carattere dall'indice dato	a [1] darà e
[:]	Sezione intervallo: fornisce i caratteri dell'intervallo specificato	a [1: 4] darà ell
in	Appartenenza: restituisce vero se esiste un carattere nella stringa data	H in a darà 1
Non in	Appartenenza: restituisce vero se un carattere non esiste nella stringa data	M non in a darà 1
r / R	Stringa non elaborata: sopprime il significato effettivo dei caratteri di escape. La sintassi per le stringhe non elaborate è esattamente la stessa delle stringhe normali con l'eccezione dell'operatore di stringa non elaborata, la lettera "r", che precede le virgolette. La "r" può essere minuscola (r) o maiuscola (R) e deve essere posta immediatamente prima della prima virgoletta.	print r '\ n' stampa \ ne print R '\ n'prints \ n
%	Formato: esegue la formattazione delle stringhe	Vedere nella sezione successiva

Operatore di formattazione delle stringhe

Una delle caratteristiche più interessanti di Python è l'operatore di formato stringa%. Questo operatore è unico per le stringhe e compensa il pacchetto di funzioni della famiglia printf () di C. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)

Quando il codice sopra viene eseguito, produce il seguente risultato:

My name is Zara and weight is 21 kg!

Ecco l'elenco del set completo di simboli che possono essere utilizzati insieme a% -

Simbolo di formato	Conversione
% c	personaggio
%S	conversione di stringhe tramite str () prima della formattazione
%io	intero decimale con segno
% d	intero decimale con segno
% u	numero intero decimale senza segno
% o	numero intero ottale
%X	intero esadecimale (lettere minuscole)
%X	intero esadecimale (lettere MAIUSCOLE)
% e	notazione esponenziale (con 'e' minuscola)
% E	notazione esponenziale (con MAIUSCOLA 'E')
% f	numero reale in virgola mobile
% g	il più corto tra% f e% e
% G	il più corto tra% f e% E

Altri simboli e funzionalità supportati sono elencati nella tabella seguente:

Simbolo	Funzionalità
*	l'argomento specifica la larghezza o la precisione
-	giustificazione a sinistra
+	visualizzare il segno
<sp>	lasciare uno spazio vuoto prima di un numero positivo
#	aggiungere lo zero iniziale ottale ("0") o "0x" o "0X" iniziale esadecimale, a seconda che siano stati utilizzati "x" o "X".
0	pad da sinistra con zeri (invece di spazi)
%	"%%" ti lascia con un singolo "%" letterale
(var)	variabile di mappatura (argomenti del dizionario)
mn	m è la larghezza totale minima en è il numero di cifre da visualizzare dopo il punto decimale (se appl.)

Citazioni triple

Le virgolette triple di Python vengono in soccorso consentendo alle stringhe di estendersi su più righe, inclusi NEWLINE letterali, TAB e qualsiasi altro carattere speciale.

La sintassi per le virgolette triple consiste di tre consecutive single or double citazioni.

#!/usr/bin/python

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str

Quando il codice precedente viene eseguito, produce il seguente risultato. Nota come ogni singolo carattere speciale è stato convertito nella sua forma stampata, fino all'ultimo NEWLINE alla fine della stringa tra "su". e chiusura di virgolette triple. Nota inoltre che le NEWLINE si verificano con un ritorno a capo esplicito alla fine di una riga o con il suo codice di escape (\ n) -

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

Le stringhe grezze non trattano affatto il backslash come un carattere speciale. Ogni carattere che inserisci in una stringa grezza rimane come l'hai scritto -

#!/usr/bin/python

print 'C:\\nowhere'

Quando il codice sopra viene eseguito, produce il seguente risultato:

C:\nowhere

Ora usiamo la stringa grezza. Metteremmo espressioner'expression' come segue -

#!/usr/bin/python

print r'C:\\nowhere'

Quando il codice sopra viene eseguito, produce il seguente risultato:

C:\\nowhere

Stringa Unicode

Le stringhe normali in Python vengono archiviate internamente come ASCII a 8 bit, mentre le stringhe Unicode vengono archiviate come Unicode a 16 bit. Ciò consente un set di caratteri più vario, inclusi caratteri speciali della maggior parte delle lingue del mondo. Limiterò il mio trattamento delle stringhe Unicode a quanto segue:

#!/usr/bin/python

print u'Hello, world!'

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello, world!

Come puoi vedere, le stringhe Unicode usano il prefisso u, proprio come le stringhe grezze usano il prefisso r.

Metodi di stringa incorporati

Python include i seguenti metodi integrati per manipolare le stringhe:

Sr.No.	Metodi con descrizione
1	capitalizzare() Capitalizza la prima lettera della stringa
2	centro (larghezza, carattere di riempimento) Restituisce una stringa riempita di spazio con la stringa originale centrata su un totale di colonne di larghezza.
3	count (str, beg = 0, end = len (string)) Conta quante volte str si verifica in string o in una sottostringa di string se vengono forniti l'indice iniziale beg e l'indice finale finale.
4	decodifica (codifica = 'UTF-8', errori = 'rigoroso') Decodifica la stringa utilizzando il codec registrato per la codifica. encoding ha come impostazione predefinita la codifica stringa predefinita.
5	codifica (codifica = 'UTF-8', errori = 'rigoroso') Restituisce la versione stringa codificata della stringa; in caso di errore, l'impostazione predefinita è sollevare un'eccezione ValueError a meno che gli errori non vengano forniti con "ignora" o "sostituisci".
6	Endswith (suffisso, beg = 0, end = len (stringa)) Determina se stringa o una sottostringa di stringa (se vengono forniti l'indice iniziale beg e l'indice finale end) finisce con suffisso; restituisce true se è così e false in caso contrario.
7	expandtabs (tabsize = 8) Espande le tabulazioni nella stringa in più spazi; il valore predefinito è 8 spazi per tabulazione se tabsize non è fornito.
8	trova (str, beg = 0 end = len (string)) Determina se str ricorre in una stringa o in una sottostringa di stringa se l'indice iniziale beg e l'indice finale sono dati alla fine restituisce l'indice se trovato e -1 altrimenti.
9	index (str, beg = 0, end = len (stringa)) Uguale a find (), ma solleva un'eccezione se str non viene trovato.
10	isalnum () Restituisce vero se la stringa contiene almeno 1 carattere e tutti i caratteri sono alfanumerici e falso in caso contrario.
11	isalpha () Restituisce vero se la stringa contiene almeno 1 carattere e tutti i caratteri sono alfabetici e falso in caso contrario.
12	isdigit () Restituisce true se la stringa contiene solo cifre e false in caso contrario.
13	è più basso() Restituisce vero se la stringa contiene almeno 1 carattere maiuscolo e tutti i caratteri maiuscoli sono in minuscolo e falso in caso contrario.
14	isnumeric () Restituisce true se una stringa Unicode contiene solo caratteri numerici e false in caso contrario.
15	isspace () Restituisce true se la stringa contiene solo spazi vuoti e false in caso contrario.
16	istitle () Restituisce true se la stringa è correttamente "titlecased" e false in caso contrario.
17	isupper () Restituisce vero se la stringa contiene almeno un carattere maiuscolo e tutti i caratteri maiuscoli sono in maiuscolo e false in caso contrario.
18	join (seq) Unisce (concatena) le rappresentazioni di stringa degli elementi in sequenza seq in una stringa, con una stringa di separazione.
19	len (stringa) Restituisce la lunghezza della stringa
20	ljust (larghezza [, fillchar]) Restituisce una stringa riempita di spazio con la stringa originale giustificata a sinistra per un totale di colonne di larghezza.
21	inferiore() Converte tutte le lettere maiuscole nella stringa in minuscolo.
22	lstrip () Rimuove tutti gli spazi bianchi iniziali nella stringa.
23	maketrans () Restituisce una tabella di traduzione da utilizzare nella funzione di traduzione.
24	max (str) Restituisce il numero massimo di caratteri alfabetici dalla stringa str.
25	min (str) Restituisce il carattere alfabetico minimo dalla stringa str.
26	sostituire (vecchio, nuovo [, max]) Sostituisce tutte le occorrenze del vecchio nella stringa con nuove o al massimo il numero massimo di occorrenze se il numero massimo specificato.
27	rfind (str, beg = 0, end = len (stringa)) Uguale a find (), ma cerca all'indietro nella stringa.
28	rindex (str, beg = 0, end = len (stringa)) Come index (), ma cerca all'indietro nella stringa.
29	rjust (width, [, fillchar]) Restituisce una stringa riempita di spazio con la stringa originale giustificata a destra per un totale di colonne di larghezza.
30	rstrip () Rimuove tutti gli spazi vuoti finali della stringa.
31	split (str = "", num = string.count (str)) Divide la stringa in base al delimitatore str (spazio se non fornito) e restituisce l'elenco delle sottostringhe; diviso in al massimo num sottostringhe se fornite.
32	splitlines (num = string.count ('\ n')) Divide la stringa in tutte (o num) le NEWLINE e restituisce un elenco di ogni riga con le NEWLINE rimosse.
33	inizia con (str, beg = 0, end = len (stringa)) Determina se stringa o una sottostringa di stringa (se vengono forniti l'indice iniziale beg e l'indice finale finale) inizia con sottostringa str; restituisce true se è così e false in caso contrario.
34	striscia ([chars]) Esegue sia lstrip () che rstrip () su string.
35	swapcase () Inverte maiuscole e minuscole per tutte le lettere nella stringa.
36	titolo() Restituisce la versione "titlecased" della stringa, ovvero tutte le parole iniziano in maiuscolo e il resto è in minuscolo.
37	translate (tabella, deletechars = "") Traduce la stringa in base alla tabella di traduzione str (256 caratteri), rimuovendo quelli nella stringa del.
38	superiore() Converte le lettere minuscole nella stringa in maiuscolo.
39	zfill (larghezza) Restituisce la stringa originale riempita con zeri a sinistra per un totale di caratteri di larghezza; inteso per i numeri, zfill () mantiene qualsiasi segno dato (meno uno zero).
40	isdecimal () Restituisce true se una stringa Unicode contiene solo caratteri decimali e false in caso contrario.

La struttura dati più basilare in Python è sequence. A ogni elemento di una sequenza viene assegnato un numero: la sua posizione o indice. Il primo indice è zero, il secondo indice è uno e così via.

Python ha sei tipi di sequenze incorporate, ma i più comuni sono elenchi e tuple, che vedremmo in questo tutorial.

Ci sono alcune cose che puoi fare con tutti i tipi di sequenza. Queste operazioni includono indicizzazione, sezionamento, aggiunta, moltiplicazione e controllo dell'appartenenza. Inoltre, Python ha funzioni incorporate per trovare la lunghezza di una sequenza e per trovare i suoi elementi più grandi e più piccoli.

Elenchi di Python

L'elenco è un tipo di dati più versatile disponibile in Python che può essere scritto come un elenco di valori (elementi) separati da virgole tra parentesi quadre. La cosa importante di un elenco è che gli elementi in un elenco non devono essere dello stesso tipo.

Creare un elenco è semplice come inserire diversi valori separati da virgole tra parentesi quadre. Ad esempio:

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]

Simile agli indici di stringa, gli indici di elenco iniziano da 0 e gli elenchi possono essere suddivisi, concatenati e così via.

Accesso ai valori negli elenchi

Per accedere ai valori negli elenchi, utilizzare le parentesi quadre per affettare insieme all'indice o agli indici per ottenere il valore disponibile in quell'indice. Ad esempio:

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

Quando il codice sopra viene eseguito, produce il seguente risultato:

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

Aggiornamento degli elenchi

È possibile aggiornare uno o più elementi di elenchi assegnando la sezione a sinistra dell'operatore di assegnazione e aggiungendo elementi a un elenco con il metodo append (). Ad esempio:

#!/usr/bin/python

list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2]
list[2] = 2001;
print "New value available at index 2 : "
print list[2]

Note - Il metodo append () è discusso nella sezione successiva.

Quando il codice sopra viene eseguito, produce il seguente risultato:

Value available at index 2 :
1997
New value available at index 2 :
2001

Elimina elementi dell'elenco

Per rimuovere un elemento della lista, puoi usare l'istruzione del se sai esattamente quali elementi stai cancellando o il metodo remove () se non lo sai. Ad esempio:

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
print list1
del list1[2];
print "After deleting value at index 2 : "
print list1

Quando il codice sopra viene eseguito, produce il seguente risultato:

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

Note - Il metodo remove () è discusso nella sezione successiva.

Operazioni di base sugli elenchi

Le liste rispondono agli operatori + e * in modo molto simile alle stringhe; significano anche qui concatenazione e ripetizione, tranne per il fatto che il risultato è un nuovo elenco, non una stringa.

In effetti, le liste rispondono a tutte le operazioni di sequenza generali che abbiamo usato sulle stringhe nel capitolo precedente.

Espressione Python	Risultati	Descrizione
len ([1, 2, 3])	3	Lunghezza
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Concatenazione
["Ciao!"] * 4	["Ciao!", "Ciao!", "Ciao!", "Ciao!"]	Ripetizione
3 in [1, 2, 3]	Vero	Appartenenza
for x in [1, 2, 3]: print x,	1 2 3	Iterazione

Indicizzazione, suddivisione in sezioni e matrici

Poiché gli elenchi sono sequenze, l'indicizzazione e la suddivisione in porzioni funzionano allo stesso modo per gli elenchi come per le stringhe.

Supponendo il seguente input:

L = ['spam', 'Spam', 'SPAM!']

Espressione Python	Risultati	Descrizione
L [2]	SPAM!	Gli offset iniziano da zero
L [-2]	Spam	Negativo: conta da destra
L [1:]	["Spam", "SPAM!"]	Il sezionamento recupera le sezioni

Funzioni e metodi di elenco incorporati

Python include le seguenti funzioni di elenco:

Sr.No.	Funzione con descrizione
1	cmp (list1, list2) Confronta gli elementi di entrambi gli elenchi.
2	len (elenco) Fornisce la lunghezza totale dell'elenco.
3	max (elenco) Restituisce l'elemento dalla lista con il valore massimo.
4	min (elenco) Restituisce l'elemento dall'elenco con il valore minimo.
5	elenco (seq) Converte una tupla in una lista.

Python include i seguenti metodi di elenco

Sr.No.	Metodi con descrizione
1	list.append (obj) Aggiunge object obj alla lista
2	list.count (obj) Restituisce il conteggio di quante volte obj compare nell'elenco
3	list.extend (seq) Aggiunge il contenuto di seq all'elenco
4	list.index (obj) Restituisce l'indice più basso nell'elenco visualizzato da obj
5	list.insert (index, obj) Inserisce l'oggetto obj nell'elenco all'indice di offset
6	list.pop (obj = list [-1]) Rimuove e restituisce l'ultimo oggetto o oggetto dalla lista
7	list.remove (obj) Rimuove l'oggetto obj dall'elenco
8	list.reverse () Inverte gli oggetti della lista in posizione
9	list.sort ([func]) Ordina gli oggetti della lista, usa la funzione di confronto se fornita

Una tupla è una sequenza immutabile di oggetti Python. Le tuple sono sequenze, proprio come le liste. Le differenze tra le tuple e le liste sono che le tuple non possono essere modificate a differenza delle liste e le tuple usano le parentesi, mentre le liste usano le parentesi quadre.

Creare una tupla è semplice come inserire diversi valori separati da virgole. Facoltativamente è possibile inserire anche questi valori separati da virgole tra parentesi. Ad esempio:

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

La tupla vuota è scritta come due parentesi che non contengono nulla -

tup1 = ();

Per scrivere una tupla contenente un singolo valore devi includere una virgola, anche se c'è un solo valore -

tup1 = (50,);

Come gli indici di stringa, gli indici di tupla iniziano da 0 e possono essere suddivisi, concatenati e così via.

Accesso ai valori nelle tuple

Per accedere ai valori in tupla, utilizzare le parentesi quadre per affettare insieme all'indice o agli indici per ottenere il valore disponibile in quell'indice. Ad esempio:

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0];
print "tup2[1:5]: ", tup2[1:5];

Quando il codice sopra viene eseguito, produce il seguente risultato:

tup1[0]:  physics
tup2[1:5]:  [2, 3, 4, 5]

Aggiornamento delle tuple

Le tuple sono immutabili, il che significa che non è possibile aggiornare o modificare i valori degli elementi della tupla. Puoi prendere porzioni di tuple esistenti per creare nuove tuple come dimostra il seguente esempio:

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3;

Quando il codice sopra viene eseguito, produce il seguente risultato:

(12, 34.56, 'abc', 'xyz')

Elimina elementi tupla

Non è possibile rimuovere singoli elementi della tupla. Non c'è, ovviamente, niente di sbagliato nel mettere insieme un'altra tupla con gli elementi indesiderati scartati.

Per rimuovere esplicitamente un'intera tupla, è sufficiente utilizzare il deldichiarazione. Ad esempio:

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : ";
print tup;

Questo produce il seguente risultato. Notare un'eccezione sollevata, questo perché afterdel tup la tupla non esiste più -

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print tup;
NameError: name 'tup' is not defined

Operazioni di base sulle tuple

Le tuple rispondono agli operatori + e * in modo molto simile alle stringhe; significano anche qui concatenazione e ripetizione, tranne per il fatto che il risultato è una nuova tupla, non una stringa.

In effetti, le tuple rispondono a tutte le operazioni di sequenza generali che abbiamo usato sulle stringhe nel capitolo precedente -

Espressione Python	Risultati	Descrizione
len ((1, 2, 3))	3	Lunghezza
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Concatenazione
("Ciao!",) * 4	("Ciao!", "Ciao!", "Ciao!", "Ciao!")	Ripetizione
3 pollici (1, 2, 3)	Vero	Appartenenza
for x in (1, 2, 3): print x,	1 2 3	Iterazione

Indicizzazione, suddivisione in sezioni e matrici

Poiché le tuple sono sequenze, l'indicizzazione e l'affettatura funzionano allo stesso modo per le tuple come per le stringhe. Supponendo il seguente input:

L = ('spam', 'Spam', 'SPAM!')

 

Espressione Python	Risultati	Descrizione
L [2]	'SPAM!'	Gli offset iniziano da zero
L [-2]	'Spam'	Negativo: conta da destra
L [1:]	["Spam", "SPAM!"]	Il sezionamento recupera le sezioni

Nessun delimitatore di inclusione

Qualsiasi insieme di più oggetti, separati da virgole, scritti senza simboli identificativi, cioè parentesi per elenchi, parentesi per tuple, ecc., Di default sono tuple, come indicato in questi brevi esempi -

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

Quando il codice sopra viene eseguito, produce il seguente risultato:

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

Funzioni di tupla incorporate

Python include le seguenti funzioni di tupla:

Sr.No.	Funzione con descrizione
1	cmp (tuple1, tuple2) Confronta gli elementi di entrambe le tuple.
2	len (tupla) Fornisce la lunghezza totale della tupla.
3	max (tupla) Restituisce l'elemento dalla tupla con il valore massimo.
4	min (tupla) Restituisce l'elemento dalla tupla con il valore minimo.
5	tupla (seq) Converte un elenco in tupla.

Ogni chiave è separata dal suo valore da due punti (:), gli elementi sono separati da virgole e il tutto è racchiuso tra parentesi graffe. Un dizionario vuoto senza elementi viene scritto con solo due parentesi graffe, in questo modo: {}.

Le chiavi sono univoche all'interno di un dizionario mentre i valori potrebbero non esserlo. I valori di un dizionario possono essere di qualsiasi tipo, ma le chiavi devono essere di un tipo di dati immutabile come stringhe, numeri o tuple.

Accesso ai valori nel dizionario

Per accedere agli elementi del dizionario, puoi usare le familiari parentesi quadre insieme alla chiave per ottenere il suo valore. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']

Quando il codice sopra viene eseguito, produce il seguente risultato:

dict['Name']:  Zara
dict['Age']:  7

Se tentiamo di accedere a un elemento di dati con una chiave, che non fa parte del dizionario, otteniamo un errore come segue:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Alice']: ", dict['Alice']

Quando il codice sopra viene eseguito, produce il seguente risultato:

dict['Alice']:
Traceback (most recent call last):
   File "test.py", line 4, in <module>
      print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

Aggiornamento del dizionario

Puoi aggiornare un dizionario aggiungendo una nuova voce o una coppia chiave-valore, modificando una voce esistente o eliminando una voce esistente come mostrato di seguito nel semplice esempio:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Quando il codice sopra viene eseguito, produce il seguente risultato:

dict['Age']:  8
dict['School']:  DPS School

Elimina elementi del dizionario

È possibile rimuovere singoli elementi del dizionario o cancellare l'intero contenuto di un dizionario. È inoltre possibile eliminare l'intero dizionario in un'unica operazione.

Per rimuovere esplicitamente un intero dizionario, è sufficiente utilizzare il deldichiarazione. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name']; # remove entry with key 'Name'
dict.clear();     # remove all entries in dict
del dict ;        # delete entire dictionary

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Questo produce il seguente risultato. Notare che viene sollevata un'eccezione perché afterdel dict il dizionario non esiste più -

dict['Age']:
Traceback (most recent call last):
   File "test.py", line 8, in <module>
      print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

Note - Il metodo del () è discusso nella sezione successiva.

Proprietà delle chiavi del dizionario

I valori del dizionario non hanno restrizioni. Possono essere qualsiasi oggetto Python arbitrario, sia oggetti standard che oggetti definiti dall'utente. Tuttavia, lo stesso non vale per le chiavi.

Ci sono due punti importanti da ricordare sulle chiavi del dizionario:

(a)Non sono consentite più voci per chiave. Ciò significa che non sono consentite chiavi duplicate. Quando si incontrano chiavi duplicate durante l'assegnazione, vince l'ultima assegnazione. Ad esempio:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print "dict['Name']: ", dict['Name']

Quando il codice sopra viene eseguito, produce il seguente risultato:

dict['Name']:  Manni

(b)Le chiavi devono essere immutabili. Ciò significa che puoi usare stringhe, numeri o tuple come chiavi del dizionario, ma qualcosa come ['chiave'] non è consentito. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']

Quando il codice sopra viene eseguito, produce il seguente risultato:

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {['Name']: 'Zara', 'Age': 7};
TypeError: unhashable type: 'list'

Funzioni e metodi del dizionario incorporati

Python include le seguenti funzioni di dizionario:

Sr.No.	Funzione con descrizione
1	cmp (dict1, dict2) Confronta gli elementi di entrambi i dict.
2	len (dict) Fornisce la lunghezza totale del dizionario. Questo sarebbe uguale al numero di elementi nel dizionario.
3	str (dict) Produce una rappresentazione di stringa stampabile di un dizionario
4	tipo (variabile) Restituisce il tipo di variabile passata. Se la variabile passata è dizionario, restituirà un tipo di dizionario.

Python include i seguenti metodi di dizionario:

Sr.No.	Metodi con descrizione
1	dict.clear () Rimuove tutti gli elementi del dizionario dict
2	dict.copy () Restituisce una copia superficiale del dizionario dict
3	dict.fromkeys () Crea un nuovo dizionario con chiavi da seq e valori impostati su valore .
4	dict.get (key, default = None) Per chiave chiave, restituisce il valore o il valore predefinito se la chiave non è nel dizionario
5	dict.has_key (chiave) Restituisce true se la chiave nel dizionario dict , false in caso contrario
6	dict.items () Restituisce un elenco di coppie di tupla di dict (chiave, valore)
7	dict.keys () Restituisce l'elenco delle chiavi del dizionario dict
8	dict.setdefault (key, default = None) Simile a get (), ma imposterà dict [key] = default se key non è già in dict
9	dict.update (dict2) Aggiunge le coppie chiave-valore del dizionario dict2 a dict
10	dict.values ​​() Restituisce l'elenco dei valori di dict del dizionario

Un programma Python può gestire la data e l'ora in diversi modi. La conversione tra i formati di data è un compito comune per i computer. I moduli ora e calendario di Python aiutano a tenere traccia di date e orari.

Cos'è Tick?

Gli intervalli di tempo sono numeri in virgola mobile in unità di secondi. Particolari istanti di tempo sono espressi in secondi a partire dalle ore 00:00:00 del 1 gennaio 1970 (epoca).

C'è un popolare timemodulo disponibile in Python che fornisce funzioni per lavorare con i tempi e per convertire tra rappresentazioni. La funzione time.time () restituisce l'ora del sistema corrente in tick dalle ore 00:00:00 del 1 gennaio 1970 (epoca).

Esempio

#!/usr/bin/python
import time;  # This is required to include time module.

ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

Ciò produrrebbe un risultato come segue:

Number of ticks since 12:00am, January 1, 1970: 7186862.73399

L'aritmetica della data è facile da eseguire con i tick. Tuttavia, le date precedenti all'epoca non possono essere rappresentate in questa forma. Anche le date nel lontano futuro non possono essere rappresentate in questo modo: il punto di interruzione è nel 2038 per UNIX e Windows.

Cos'è TimeTuple?

Molte delle funzioni temporali di Python gestiscono il tempo come una tupla di 9 numeri, come mostrato di seguito:

Indice	Campo	Valori
0	Anno a 4 cifre	2008
1	Mese	Da 1 a 12
2	Giorno	Da 1 a 31
3	Ora	Da 0 a 23
4	Minuto	Da 0 a 59
5	Secondo	Da 0 a 61 (60 o 61 sono secondi intercalari)
6	Giorno della settimana	Da 0 a 6 (0 è lunedì)
7	Giorno dell'anno	Da 1 a 366 (giorno giuliano)
8	Risparmio di luce diurna	-1, 0, 1, -1 significa che la libreria determina l'ora legale

La tupla sopra è equivalente a struct_timestruttura. Questa struttura ha i seguenti attributi:

Indice	Attributi	Valori
0	tm_year	2008
1	tm_mon	Da 1 a 12
2	tm_mday	Da 1 a 31
3	tm_hour	Da 0 a 23
4	tm_min	Da 0 a 59
5	tm_sec	Da 0 a 61 (60 o 61 sono secondi intercalari)
6	tm_wday	Da 0 a 6 (0 è lunedì)
7	tm_yday	Da 1 a 366 (giorno giuliano)
8	tm_isdst	-1, 0, 1, -1 significa che la libreria determina l'ora legale

Ottenere l'ora corrente

Per tradurre un istante di tempo da un secondo dal valore a virgola mobile di epoch in una tupla di tempo, passare il valore a virgola mobile a una funzione (ad esempio, localtime) che restituisce una tupla di tempo con tutti e nove gli elementi validi.

#!/usr/bin/python
import time;

localtime = time.localtime(time.time())
print "Local current time :", localtime

Ciò produrrebbe il seguente risultato, che potrebbe essere formattato in qualsiasi altra forma presentabile:

Local current time : time.struct_time(tm_year=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Ottenere l'ora formattata

Puoi formattare in qualsiasi momento secondo le tue esigenze, ma un metodo semplice per ottenere l'ora in un formato leggibile è asctime () -

#!/usr/bin/python
import time;

localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

Ciò produrrebbe il seguente risultato:

Local current time : Tue Jan 13 10:17:09 2009

Ottenere il calendario per un mese

Il modulo calendario offre un'ampia gamma di metodi per giocare con calendari annuali e mensili. Qui stampiamo un calendario per un determinato mese (gennaio 2008) -

#!/usr/bin/python
import calendar

cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

Ciò produrrebbe il seguente risultato:

Here is the calendar:
   January 2008
Mo Tu We Th Fr Sa Su
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

Il modulo tempo

C'è un popolare timemodulo disponibile in Python che fornisce funzioni per lavorare con i tempi e per convertire tra rappresentazioni. Ecco l'elenco di tutti i metodi disponibili:

Sr.No.	Funzione con descrizione
1	time.altzone L'offset del fuso orario dell'ora legale locale, in secondi a ovest di UTC, se definito. Questo è negativo se il fuso orario dell'ora legale locale è a est di UTC (come nell'Europa occidentale, incluso il Regno Unito). Usalo solo se la luce del giorno è diversa da zero.
2	time.asctime ([tupletime]) Accetta una tupla ora e restituisce una stringa di 24 caratteri leggibile come "Tue Dec 11 18:07:14 2008".
3	time.clock () Restituisce il tempo della CPU corrente come numero di secondi a virgola mobile. Per misurare i costi computazionali di diversi approcci, il valore di time.clock è più utile di quello di time.time ().
4	time.ctime ([secs]) Come asctime (localtime (secs)) e senza argomenti è come asctime ()
5	time.gmtime ([secs]) Accetta un istante espresso in secondi dall'epoca e restituisce una tupla temporale t con l'ora UTC. Nota: t.tm_isdst è sempre 0
6	time.localtime ([secs]) Accetta un istante espresso in secondi dall'epoca e restituisce una tupla temporale t con l'ora locale (t.tm_isdst è 0 o 1, a seconda che l'ora legale si applichi agli istanti secondi dalle regole locali).
7	time.mktime (tupletime) Accetta un istante espresso come tupla temporale nell'ora locale e restituisce un valore in virgola mobile con l'istante espresso in secondi dall'epoca.
8	time.sleep (sec) Sospende il thread chiamante per secondi secondi.
9	time.strftime (fmt [, tupletime]) Accetta un istante espresso come una tupla temporale nell'ora locale e restituisce una stringa che rappresenta l'istante come specificato dalla stringa fmt.
10	time.strptime (str, fmt = '% a% b% d% H:% M:% S% Y') Analizza str in base alla stringa di formato fmt e restituisce l'istante in formato tupla ora.
11	time.time () Restituisce l'istante di tempo corrente, un numero in virgola mobile di secondi trascorsi dall'epoca.
12	time.tzset () Reimposta le regole di conversione dell'ora utilizzate dalle routine della libreria. La variabile d'ambiente TZ specifica come questo viene fatto.

Esaminiamo brevemente le funzioni:

Ci sono due importanti attributi disponibili con il modulo ora:

Sr.No.	Attributo con descrizione
1	time.timezone L'attributo time.timezone è lo scostamento in secondi del fuso orario locale (senza ora legale) dall'UTC (> 0 nelle Americhe; <= 0 nella maggior parte dell'Europa, Asia, Africa).
2	time.tzname L'attributo time.tzname è una coppia di stringhe dipendenti dalla locale, che sono i nomi del fuso orario locale senza e con l'ora legale, rispettivamente.

Il modulo calendario

Il modulo calendario fornisce funzioni relative al calendario, comprese le funzioni per stampare un calendario di testo per un determinato mese o anno.

Per impostazione predefinita, il calendario utilizza il lunedì come primo giorno della settimana e la domenica come ultimo. Per cambiarlo, chiama la funzione calendar.setfirstweekday ().

Ecco un elenco delle funzioni disponibili con il modulo calendario :

Sr.No.	Funzione con descrizione
1	calendar.calendar(year,w=2,l=1,c=6) Restituisce una stringa su più righe con un calendario per anno anno formattato in tre colonne separate da spazi c. w è la larghezza in caratteri di ciascuna data; ogni riga ha lunghezza 21 * w + 18 + 2 * c. l è il numero di righe per ogni settimana.
2	calendar.firstweekday( ) Restituisce l'impostazione corrente per il giorno della settimana che inizia ogni settimana. Per impostazione predefinita, quando il calendario viene importato per la prima volta, questo è 0, che significa lunedì.
3	calendar.isleap(year) Restituisce True se year è un anno bisestile; in caso contrario, False.
4	calendar.leapdays(y1,y2) Restituisce il numero totale di giorni bisestili negli anni compresi nell'intervallo (y1, y2).
5	calendar.month(year,month,w=2,l=1) Restituisce una stringa su più righe con un calendario per mese mese dell'anno anno, una riga alla settimana più due righe di intestazione. w è la larghezza in caratteri di ciascuna data; ogni riga ha lunghezza 7 * w + 6. l è il numero di righe per ogni settimana.
6	calendar.monthcalendar(year,month) Restituisce un elenco di elenchi di int. Ogni sottolista indica una settimana. I giorni al di fuori del mese mese dell'anno anno sono impostati su 0; i giorni del mese vengono impostati sul loro giorno del mese, 1 e oltre.
7	calendar.monthrange(year,month) Restituisce due numeri interi. Il primo è il codice del giorno della settimana per il primo giorno del mese mese dell'anno anno; il secondo è il numero di giorni del mese. I codici dei giorni feriali vanno da 0 (lunedì) a 6 (domenica); i numeri dei mesi vanno da 1 a 12.
8	calendar.prcal(year,w=2,l=1,c=6) Come stampare il calendario calendario (anno, w, l, c).
9	calendar.prmonth(year,month,w=2,l=1) Come stampare calendar.month (anno, mese, w, l).
10	calendar.setfirstweekday(weekday) Imposta il primo giorno di ogni settimana sul codice della settimana della settimana. I codici dei giorni feriali vanno da 0 (lunedì) a 6 (domenica).
11	calendar.timegm(tupletime) L'inverso di time.gmtime: accetta un istante di tempo in forma di tupla temporale e restituisce lo stesso istante di un numero in virgola mobile di secondi dall'epoca.
12	calendar.weekday(year,month,day) Restituisce il codice del giorno della settimana per la data specificata. I codici dei giorni feriali vanno da 0 (lunedì) a 6 (domenica); i numeri dei mesi vanno da 1 (gennaio) a 12 (dicembre).

Altri moduli e funzioni

Se sei interessato, qui troverai un elenco di altri importanti moduli e funzioni per giocare con data e ora in Python -

• Il modulo datetime

• Il modulo pytz

• Il modulo dateutil

Una funzione è un blocco di codice organizzato e riutilizzabile che viene utilizzato per eseguire una singola azione correlata. Le funzioni forniscono una migliore modularità per la tua applicazione e un elevato grado di riutilizzo del codice.

Come già saprai, Python ti offre molte funzioni incorporate come print (), ecc. Ma puoi anche creare le tue funzioni. Queste funzioni sono chiamate funzioni definite dall'utente.

Definizione di una funzione

È possibile definire funzioni per fornire la funzionalità richiesta. Ecco semplici regole per definire una funzione in Python.

• I blocchi funzione iniziano con la parola chiave def seguito dal nome della funzione e dalle parentesi (()).

• Qualsiasi parametro o argomento di input deve essere inserito tra queste parentesi. È inoltre possibile definire parametri all'interno di queste parentesi.

• La prima istruzione di una funzione può essere un'istruzione opzionale: la stringa di documentazione della funzione o docstring .

• Il blocco di codice all'interno di ogni funzione inizia con due punti (:) ed è rientrato.

• L'istruzione return [espressione] esce da una funzione, facoltativamente restituendo un'espressione al chiamante. Un'istruzione return senza argomenti è uguale a return None.

Sintassi

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Per impostazione predefinita, i parametri hanno un comportamento posizionale ed è necessario informarli nello stesso ordine in cui sono stati definiti.

Esempio

La seguente funzione prende una stringa come parametro di input e la stampa sullo schermo standard.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Chiamare una funzione

La definizione di una funzione le dà solo un nome, specifica i parametri che devono essere inclusi nella funzione e struttura i blocchi di codice.

Una volta finalizzata la struttura di base di una funzione, è possibile eseguirla richiamandola da un'altra funzione o direttamente dal prompt di Python. Di seguito è riportato l'esempio per chiamare la funzione printme () -

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Quando il codice sopra viene eseguito, produce il seguente risultato:

I'm first call to user defined function!
Again second call to the same function

Passa per riferimento vs valore

Tutti i parametri (argomenti) nel linguaggio Python vengono passati per riferimento. Significa che se si modifica ciò a cui si riferisce un parametro all'interno di una funzione, la modifica si riflette anche nella funzione chiamante. Ad esempio:

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Qui, stiamo mantenendo il riferimento dell'oggetto passato e aggiungendo valori nello stesso oggetto. Quindi, questo produrrebbe il seguente risultato:

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

C'è un altro esempio in cui l'argomento viene passato per riferimento e il riferimento viene sovrascritto all'interno della funzione chiamata.

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Il parametro mylist è locale per la funzione changeme. La modifica della mia lista all'interno della funzione non influisce sulla mia lista . La funzione non realizza nulla e alla fine questo produrrebbe il seguente risultato:

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

Argomenti della funzione

È possibile chiamare una funzione utilizzando i seguenti tipi di argomenti formali:

• Argomenti obbligatori
• Argomenti delle parole chiave
• Argomenti predefiniti
• Argomenti a lunghezza variabile

Argomenti obbligatori

Gli argomenti obbligatori sono gli argomenti passati a una funzione nell'ordine posizionale corretto. Qui, il numero di argomenti nella chiamata di funzione dovrebbe corrispondere esattamente alla definizione della funzione.

Per chiamare la funzione printme () , devi assolutamente passare un argomento, altrimenti dà un errore di sintassi come segue:

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme()

Quando il codice sopra viene eseguito, produce il seguente risultato:

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Argomenti delle parole chiave

Gli argomenti delle parole chiave sono correlati alle chiamate di funzione. Quando si utilizzano argomenti di parole chiave in una chiamata di funzione, il chiamante identifica gli argomenti in base al nome del parametro.

Ciò consente di saltare gli argomenti o metterli fuori ordine perché l'interprete Python è in grado di utilizzare le parole chiave fornite per abbinare i valori ai parametri. Puoi anche effettuare chiamate con parole chiave alla funzione printme () nei seguenti modi:

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme( str = "My string")

Quando il codice sopra viene eseguito, produce il seguente risultato:

My string

L'esempio seguente fornisce un'immagine più chiara. Notare che l'ordine dei parametri non ha importanza.

#!/usr/bin/python

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )

Quando il codice sopra viene eseguito, produce il seguente risultato:

Name:  miki
Age  50

Argomenti predefiniti

Un argomento predefinito è un argomento che assume un valore predefinito se non viene fornito un valore nella chiamata di funzione per tale argomento. L'esempio seguente fornisce un'idea sugli argomenti predefiniti, stampa l'età predefinita se non viene passata -

#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Quando il codice sopra viene eseguito, produce il seguente risultato:

Name:  miki
Age  50
Name:  miki
Age  35

Argomenti a lunghezza variabile

Potrebbe essere necessario elaborare una funzione per più argomenti di quelli specificati durante la definizione della funzione. Questi argomenti sono chiamati argomenti di lunghezza variabile e non sono nominati nella definizione della funzione, a differenza degli argomenti obbligatori e predefiniti.

La sintassi per una funzione con argomenti di variabili senza parole chiave è questa:

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

Un asterisco (*) viene inserito prima del nome della variabile che contiene i valori di tutti gli argomenti della variabile non parola chiave. Questa tupla rimane vuota se non vengono specificati argomenti aggiuntivi durante la chiamata alla funzione. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

Quando il codice sopra viene eseguito, produce il seguente risultato:

Output is:
10
Output is:
70
60
50

Le funzioni anonime

Queste funzioni sono chiamate anonime perché non vengono dichiarate in modo standard utilizzando la parola chiave def . È possibile utilizzare la parola chiave lambda per creare piccole funzioni anonime.

• I moduli Lambda possono accettare un numero qualsiasi di argomenti ma restituiscono un solo valore sotto forma di espressione. Non possono contenere comandi o più espressioni.

• Una funzione anonima non può essere una chiamata diretta a print perché lambda richiede un'espressione

• Le funzioni Lambda hanno il proprio spazio dei nomi locale e non possono accedere a variabili diverse da quelle nel loro elenco di parametri e da quelle nello spazio dei nomi globale.

• Sebbene sembri che le lambda siano una versione di una riga di una funzione, non sono equivalenti alle istruzioni inline in C o C ++, il cui scopo è passare l'allocazione dello stack di funzioni durante l'invocazione per motivi di prestazioni.

Sintassi

La sintassi delle funzioni lambda contiene solo una singola istruzione, che è la seguente:

lambda [arg1 [,arg2,.....argn]]:expression

Di seguito è riportato l'esempio per mostrare come funziona la forma lambda della funzione:

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

Quando il codice sopra viene eseguito, produce il seguente risultato:

Value of total :  30
Value of total :  40

La dichiarazione di ritorno

L'istruzione return [espressione] esce da una funzione, facoltativamente restituendo un'espressione al chiamante. Un'istruzione return senza argomenti è uguale a return None.

Tutti gli esempi precedenti non restituiscono alcun valore. È possibile restituire un valore da una funzione come segue:

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total

Quando il codice sopra viene eseguito, produce il seguente risultato:

Inside the function :  30
Outside the function :  30

Ambito delle variabili

Tutte le variabili in un programma potrebbero non essere accessibili in tutte le posizioni in quel programma. Dipende da dove hai dichiarato una variabile.

L'ambito di una variabile determina la parte del programma in cui è possibile accedere a un particolare identificatore. Ci sono due ambiti di base delle variabili in Python:

• Variabili globali
• Variabili locali

Variabili globali e locali

Le variabili definite all'interno del corpo di una funzione hanno un ambito locale e quelle definite all'esterno hanno un ambito globale.

Ciò significa che è possibile accedere alle variabili locali solo all'interno della funzione in cui sono dichiarate, mentre è possibile accedere alle variabili globali in tutto il corpo del programma da tutte le funzioni. Quando chiamate una funzione, le variabili dichiarate al suo interno vengono portate nell'ambito. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total

Quando il codice sopra viene eseguito, produce il seguente risultato:

Inside the function local total :  30
Outside the function global total :  0

Un modulo ti consente di organizzare logicamente il tuo codice Python. Il raggruppamento del codice correlato in un modulo rende il codice più facile da capire e utilizzare. Un modulo è un oggetto Python con attributi con nomi arbitrari che puoi associare e fare riferimento.

Semplicemente, un modulo è un file costituito da codice Python. Un modulo può definire funzioni, classi e variabili. Un modulo può anche includere codice eseguibile.

Esempio

Il codice Python per un modulo denominato aname normalmente risiede in un file denominato aname.py . Ecco un esempio di un semplice modulo, support.py

def print_func( par ):
   print "Hello : ", par
   return

La dichiarazione di importazione

È possibile utilizzare qualsiasi file sorgente Python come modulo eseguendo un'istruzione di importazione in un altro file sorgente Python. L' importazione ha la seguente sintassi:

import module1[, module2[,... moduleN]

Quando l'interprete incontra un'istruzione import, importa il modulo se il modulo è presente nel percorso di ricerca. Un percorso di ricerca è un elenco di directory che l'interprete cerca prima di importare un modulo. Ad esempio, per importare il modulo support.py, è necessario inserire il seguente comando all'inizio dello script:

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello : Zara

Un modulo viene caricato una sola volta, indipendentemente dal numero di volte in cui viene importato. Ciò impedisce l'esecuzione del modulo più e più volte se si verificano più importazioni.

L' istruzione from ... import

L' istruzione from di Python consente di importare attributi specifici da un modulo nello spazio dei nomi corrente. L' importazione da ... ha la seguente sintassi:

from modname import name1[, name2[, ... nameN]]

Ad esempio, per importare la funzione fibonacci dal modulo fib, utilizzare la seguente dichiarazione:

from fib import fibonacci

Questa istruzione non importa l'intero modulo fib nello spazio dei nomi corrente; introduce semplicemente l'elemento fibonacci dal modulo fib nella tabella dei simboli globale del modulo di importazione.

L' istruzione from ... import *

È anche possibile importare tutti i nomi da un modulo nello spazio dei nomi corrente utilizzando la seguente istruzione di importazione:

from modname import *

Ciò fornisce un modo semplice per importare tutti gli elementi da un modulo nello spazio dei nomi corrente; tuttavia, questa istruzione dovrebbe essere usata con parsimonia.

Individuazione dei moduli

Quando importi un modulo, l'interprete Python cerca il modulo nelle seguenti sequenze:

• La directory corrente.

• Se il modulo non viene trovato, Python cerca quindi ogni directory nella variabile di shell PYTHONPATH.

• Se tutto il resto fallisce, Python controlla il percorso predefinito. Su UNIX, questo percorso predefinito è normalmente / usr / local / lib / python /.

Il percorso di ricerca del modulo è memorizzato nel modulo di sistema sys come file sys.pathvariabile. La variabile sys.path contiene la directory corrente, PYTHONPATH e il valore predefinito dipendente dall'installazione.

La variabile PYTHONPATH

PYTHONPATH è una variabile d'ambiente, costituita da un elenco di directory. La sintassi di PYTHONPATH è la stessa della variabile di shell PATH.

Ecco un tipico PYTHONPATH da un sistema Windows:

set PYTHONPATH = c:\python20\lib;

Ed ecco un tipico PYTHONPATH da un sistema UNIX -

set PYTHONPATH = /usr/local/lib/python

Spazi dei nomi e ambito

Le variabili sono nomi (identificatori) associati agli oggetti. Uno spazio dei nomi è un dizionario di nomi di variabili (chiavi) e dei loro oggetti (valori) corrispondenti.

Un'istruzione Python può accedere alle variabili in uno spazio dei nomi locale e nello spazio dei nomi globale . Se una variabile locale e una globale hanno lo stesso nome, la variabile locale ombreggia la variabile globale.

Ogni funzione ha il proprio spazio dei nomi locale. I metodi di classe seguono la stessa regola di scoping delle funzioni ordinarie.

Python fa ipotesi plausibili sul fatto che le variabili siano locali o globali. Si presuppone che qualsiasi variabile a cui è stato assegnato un valore in una funzione sia locale.

Pertanto, per assegnare un valore a una variabile globale all'interno di una funzione, è necessario prima utilizzare l'istruzione globale.

L'istruzione global VarName dice a Python che VarName è una variabile globale. Python smette di cercare la variabile nello spazio dei nomi locale.

Ad esempio, definiamo una variabile Money nello spazio dei nomi globale. All'interno della funzione Money , assegniamo a Money un valore, quindi Python assume Money come variabile locale. Tuttavia, abbiamo avuto accesso al valore della variabile locale Money prima di impostarla, quindi il risultato è UnboundLocalError. Rimuovere il commento dall'istruzione globale risolve il problema.

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

La funzione dir ()

La funzione built-in dir () restituisce un elenco ordinato di stringhe contenenti i nomi definiti da un modulo.

L'elenco contiene i nomi di tutti i moduli, variabili e funzioni definiti in un modulo. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Quando il codice sopra viene eseguito, produce il seguente risultato:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Qui, la variabile stringa speciale __name__ è il nome del modulo e __file__ è il nome del file da cui è stato caricato il modulo.

Le funzioni globals () e locals ()

Le funzioni globals () e locals () possono essere utilizzate per restituire i nomi negli spazi dei nomi globale e locale a seconda della posizione da cui vengono chiamati.

Se locals () viene chiamato dall'interno di una funzione, restituirà tutti i nomi a cui è possibile accedere localmente da quella funzione.

Se globals () viene chiamato dall'interno di una funzione, restituirà tutti i nomi a cui è possibile accedere globalmente da quella funzione.

Il tipo restituito da entrambe queste funzioni è dizionario. Pertanto, i nomi possono essere estratti utilizzando la funzione keys ().

Il reload () Funzione

Quando il modulo viene importato in uno script, il codice nella parte di primo livello di un modulo viene eseguito solo una volta.

Pertanto, se si desidera rieseguire il codice di primo livello in un modulo, è possibile utilizzare la funzione reload () . La funzione reload () importa di nuovo un modulo importato in precedenza. La sintassi della funzione reload () è questa:

reload(module_name)

Qui, module_name è il nome del modulo che vuoi ricaricare e non la stringa che contiene il nome del modulo. Ad esempio, per ricaricare il modulo hello , procedi come segue:

reload(hello)

Pacchetti in Python

Un pacchetto è una struttura gerarchica di directory di file che definisce un unico ambiente applicativo Python costituito da moduli e sottopacchetti e sottopacchetti e così via.

Considera un file Pots.py disponibile nella directory del telefono . Questo file ha la seguente riga di codice sorgente:

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

In modo simile, abbiamo altri due file con funzioni diverse con lo stesso nome di cui sopra -

• File Phone / Isdn.py con funzione Isdn ()

• File Phone / G3.py con funzione G3 ()

Ora crea un altro file __init__.py nella directory del telefono -

• Phone/__init__.py

Per rendere disponibili tutte le tue funzioni quando hai importato il telefono, devi inserire istruzioni di importazione esplicite in __init__.py come segue:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Dopo aver aggiunto queste righe a __init__.py, tutte queste classi saranno disponibili quando importi il ​​pacchetto Telefono.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Quando il codice sopra viene eseguito, produce il seguente risultato:

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Nell'esempio sopra, abbiamo preso esempio di una singola funzione in ogni file, ma puoi mantenere più funzioni nei tuoi file. Puoi anche definire diverse classi Python in quei file e quindi puoi creare i tuoi pacchetti da quelle classi.

Questo capitolo copre tutte le funzioni di I / O di base disponibili in Python. Per ulteriori funzioni, fare riferimento alla documentazione standard di Python.

Stampa sullo schermo

Il modo più semplice per produrre output è utilizzare l' istruzione print in cui è possibile passare zero o più espressioni separate da virgole. Questa funzione converte le espressioni che passi in una stringa e scrive il risultato sullo standard output come segue:

#!/usr/bin/python

print "Python is really a great language,", "isn't it?"

Questo produce il seguente risultato sullo schermo standard:

Python is really a great language, isn't it?

Lettura dell'input da tastiera

Python fornisce due funzioni integrate per leggere una riga di testo dallo standard input, che per impostazione predefinita proviene dalla tastiera. Queste funzioni sono:

• raw_input
• input

La funzione raw_input

La funzione raw_input ([prompt]) legge una riga dallo standard input e la restituisce come una stringa (rimuovendo la nuova riga finale).

#!/usr/bin/python

str = raw_input("Enter your input: ")
print "Received input is : ", str

Questo ti chiede di inserire qualsiasi stringa e visualizzerà la stessa stringa sullo schermo. Quando ho digitato "Hello Python!", Il suo output è come questo -

Enter your input: Hello Python
Received input is :  Hello Python

La funzione di input

La funzione input ([prompt]) è equivalente a raw_input, tranne per il fatto che presume che l'input sia un'espressione Python valida e restituisce il risultato valutato.

#!/usr/bin/python

str = input("Enter your input: ")
print "Received input is : ", str

Ciò produrrebbe il seguente risultato rispetto all'input inserito:

Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is :  [10, 20, 30, 40]

Apertura e chiusura di file

Fino ad ora, hai letto e scritto sullo standard input e output. Ora vedremo come utilizzare i file di dati effettivi.

Python fornisce funzioni e metodi di base necessari per manipolare i file per impostazione predefinita. Puoi eseguire la maggior parte della manipolazione dei file utilizzando un filefile oggetto.

La funzione aperta

Prima di poter leggere o scrivere un file, devi aprirlo utilizzando la funzione open () incorporata di Python . Questa funzione crea un filefile oggetto, che verrebbe utilizzato per chiamare altri metodi di supporto ad esso associati.

Sintassi

file object = open(file_name [, access_mode][, buffering])

Ecco i dettagli dei parametri:

• file_name - L'argomento file_name è un valore stringa che contiene il nome del file a cui si desidera accedere.

• access_mode- La modalità access_mode determina la modalità in cui il file deve essere aperto, cioè leggere, scrivere, aggiungere, ecc. Un elenco completo dei possibili valori è fornito di seguito nella tabella. Questo è un parametro opzionale e la modalità di accesso ai file predefinita è read (r).

• buffering- Se il valore di buffering è impostato su 0, non viene eseguito alcun buffering. Se il valore di buffering è 1, il buffer di riga viene eseguito durante l'accesso a un file. Se si specifica il valore del buffer come un numero intero maggiore di 1, l'azione di buffer viene eseguita con la dimensione del buffer indicata. Se negativo, la dimensione del buffer è l'impostazione predefinita del sistema (comportamento predefinito).

Di seguito è riportato un elenco delle diverse modalità di apertura di un file:

Sr.No.	Modalità e descrizione
1	r Apre un file di sola lettura. Il puntatore del file viene posizionato all'inizio del file. Questa è la modalità di default.
2	rb Apre un file per la sola lettura in formato binario. Il puntatore del file viene posizionato all'inizio del file. Questa è la modalità di default.
3	r+ Apre un file sia in lettura che in scrittura. Il puntatore del file posizionato all'inizio del file.
4	rb+ Apre un file sia in lettura che in scrittura in formato binario. Il puntatore del file posizionato all'inizio del file.
5	w Apre un file di sola scrittura. Sovrascrive il file se il file esiste. Se il file non esiste, crea un nuovo file per la scrittura.
6	wb Apre un file per la scrittura solo in formato binario. Sovrascrive il file se il file esiste. Se il file non esiste, crea un nuovo file per la scrittura.
7	w+ Apre un file sia in scrittura che in lettura. Sovrascrive il file esistente se il file esiste. Se il file non esiste, crea un nuovo file per la lettura e la scrittura.
8	wb+ Apre un file sia in scrittura che in lettura in formato binario. Sovrascrive il file esistente se il file esiste. Se il file non esiste, crea un nuovo file per la lettura e la scrittura.
9	a Apre un file da aggiungere. Il puntatore del file si trova alla fine del file se il file esiste. Cioè, il file è in modalità di aggiunta. Se il file non esiste, crea un nuovo file per la scrittura.
10	ab Apre un file da aggiungere in formato binario. Il puntatore del file si trova alla fine del file se il file esiste. Cioè, il file è in modalità di aggiunta. Se il file non esiste, crea un nuovo file per la scrittura.
11	a+ Apre un file sia per l'aggiunta che per la lettura. Il puntatore del file si trova alla fine del file se il file esiste. Il file si apre in modalità di aggiunta. Se il file non esiste, crea un nuovo file per la lettura e la scrittura.
12	ab+ Apre un file sia per l'aggiunta che per la lettura in formato binario. Il puntatore del file si trova alla fine del file se il file esiste. Il file si apre in modalità di aggiunta. Se il file non esiste, crea un nuovo file per la lettura e la scrittura.

Il file Object Attributes

Una volta che un file è stato aperto e hai un oggetto file , puoi ottenere varie informazioni relative a quel file.

Ecco un elenco di tutti gli attributi relativi all'oggetto file:

Sr.No.	Attributo e descrizione
1	file.closed Restituisce vero se il file è chiuso, falso in caso contrario.
2	file.mode Restituisce la modalità di accesso con la quale il file è stato aperto.
3	file.name Restituisce il nome del file.
4	file.softspace Restituisce false se lo spazio è esplicitamente richiesto con print, altrimenti true.

Esempio

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name
print "Closed or not : ", fo.closed
print "Opening mode : ", fo.mode
print "Softspace flag : ", fo.softspace

Questo produce il seguente risultato:

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb
Softspace flag :  0

Il metodo close ()

Il metodo close () di un oggetto file scarica tutte le informazioni non scritte e chiude l'oggetto file, dopodiché non è più possibile scrivere.

Python chiude automaticamente un file quando l'oggetto di riferimento di un file viene riassegnato a un altro file. È buona norma utilizzare il metodo close () per chiudere un file.

Sintassi

fileObject.close()

Esempio

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name

# Close opend file
fo.close()

Questo produce il seguente risultato:

Name of the file:  foo.txt

Lettura e scrittura di file

L' oggetto file fornisce una serie di metodi di accesso per semplificarci la vita. Vedremo come usare i metodi read () e write () per leggere e scrivere file.

Il metodo write ()

Il metodo write () scrive qualsiasi stringa in un file aperto. È importante notare che le stringhe Python possono avere dati binari e non solo testo.

Il metodo write () non aggiunge un carattere di nuova riga ('\ n') alla fine della stringa -

Sintassi

fileObject.write(string)

Qui, il parametro passato è il contenuto da scrivere nel file aperto.

Esempio

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

Il metodo sopra creerebbe il file foo.txt e scriverà il contenuto dato in quel file e alla fine chiuderà quel file. Se aprissi questo file, avrebbe il seguente contenuto.

Python is a great language.
Yeah its great!!

Il metodo read ()

Il metodo read () legge una stringa da un file aperto. È importante notare che le stringhe Python possono avere dati binari. oltre ai dati di testo.

Sintassi

fileObject.read([count])

Qui, il parametro passato è il numero di byte da leggere dal file aperto. Questo metodo inizia a leggere dall'inizio del file e se il conteggio manca, cerca di leggere il più possibile, forse fino alla fine del file.

Esempio

Prendiamo un file foo.txt , che abbiamo creato sopra.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend file
fo.close()

Questo produce il seguente risultato:

Read String is :  Python is

Posizioni dei file

Il metodo tell () ti dice la posizione corrente all'interno del file; in altre parole, la successiva lettura o scrittura avverrà a quel numero di byte dall'inizio del file.

Il metodo seek (offset [, from]) cambia la posizione del file corrente. L' argomento offset indica il numero di byte da spostare. L' argomento from specifica la posizione di riferimento da cui devono essere spostati i byte.

Se from è impostato a 0, significa usa l'inizio del file come posizione di riferimento e 1 significa usa la posizione corrente come posizione di riferimento e se è impostato a 2 allora la fine del file sarà presa come posizione di riferimento .

Esempio

Prendiamo un file foo.txt , che abbiamo creato sopra.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print "Read String is : ", str

# Check current position
position = fo.tell()
print "Current file position : ", position

# Reposition pointer at the beginning once again
position = fo.seek(0, 0);
str = fo.read(10)
print "Again read String is : ", str
# Close opend file
fo.close()

Questo produce il seguente risultato:

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

Ridenominazione ed eliminazione di file

Pitone os Il modulo fornisce metodi che aiutano a eseguire operazioni di elaborazione dei file, come la ridenominazione e l'eliminazione di file.

Per usare questo modulo devi prima importarlo e poi puoi chiamare tutte le funzioni correlate.

Il metodo rename ()

Il metodo rename () accetta due argomenti, il nome del file corrente e il nuovo nome del file.

Sintassi

os.rename(current_file_name, new_file_name)

Esempio

Di seguito è riportato l'esempio per rinominare un file esistente test1.txt -

#!/usr/bin/python
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

Il metodo remove ()

È possibile utilizzare il metodo remove () per eliminare i file fornendo il nome del file da eliminare come argomento.

Sintassi

os.remove(file_name)

Esempio

Di seguito è riportato l'esempio per eliminare un file esistente test2.txt -

#!/usr/bin/python
import os

# Delete file test2.txt
os.remove("text2.txt")

Directory in Python

Tutti i file sono contenuti in varie directory e Python non ha problemi a gestirli. Ilos Il modulo ha diversi metodi che ti aiutano a creare, rimuovere e cambiare directory.

Il metodo mkdir ()

Puoi usare il metodo mkdir () diosmodulo per creare directory nella directory corrente. È necessario fornire un argomento a questo metodo che contiene il nome della directory da creare.

Sintassi

os.mkdir("newdir")

Esempio

Di seguito è riportato l'esempio per creare un test di directory nella directory corrente:

#!/usr/bin/python
import os

# Create a directory "test"
os.mkdir("test")

Il metodo chdir ()

Puoi usare il metodo chdir () per cambiare la directory corrente. Il metodo chdir () accetta un argomento, che è il nome della directory che vuoi rendere la directory corrente.

Sintassi

os.chdir("newdir")

Esempio

Di seguito è riportato l'esempio per entrare nella directory "/ home / newdir" -

#!/usr/bin/python
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

Il metodo getcwd ()

Il metodo getcwd () mostra la directory di lavoro corrente.

Sintassi

os.getcwd()

Esempio

Di seguito è riportato l'esempio per fornire la directory corrente:

#!/usr/bin/python
import os

# This would give location of the current directory
os.getcwd()

Il metodo rmdir ()

Il metodo rmdir () cancella la directory, che viene passata come argomento nel metodo.

Prima di rimuovere una directory, è necessario rimuovere tutto il contenuto in essa.

Sintassi

os.rmdir('dirname')

Esempio

Di seguito è riportato l'esempio per rimuovere la directory "/ tmp / test". È necessario fornire il nome completo della directory, altrimenti cercherà quella directory nella directory corrente.

#!/usr/bin/python
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

Metodi relativi a file e directory

Ci sono tre fonti importanti, che forniscono un'ampia gamma di metodi di utilità per gestire e manipolare file e directory sui sistemi operativi Windows e Unix. Sono i seguenti:

• Metodi dell'oggetto file : l' oggetto file fornisce funzioni per manipolare i file.

• Metodi degli oggetti del sistema operativo : fornisce metodi per elaborare file e directory.

Python fornisce due funzionalità molto importanti per gestire qualsiasi errore imprevisto nei programmi Python e per aggiungere funzionalità di debug in essi:

• Exception Handling- Questo sarà trattato in questo tutorial. Ecco un elenco di eccezioni standard disponibili in Python: Eccezioni standard .

• Assertions- Questo sarebbe trattato in Asserzioni nel tutorial di Python .

Elenco delle eccezioni standard -

Sr.No.	Nome e descrizione dell'eccezione
1	Exception Classe base per tutte le eccezioni
2	StopIteration Generato quando il metodo next () di un iteratore non punta a nessun oggetto.
3	SystemExit Generato dalla funzione sys.exit ().
4	StandardError Classe base per tutte le eccezioni incorporate eccetto StopIteration e SystemExit.
5	ArithmeticError Classe di base per tutti gli errori che si verificano per il calcolo numerico.
6	OverflowError Generato quando un calcolo supera il limite massimo per un tipo numerico.
7	FloatingPointError Generato quando un calcolo in virgola mobile fallisce.
8	ZeroDivisionError Generato quando si verifica una divisione o un modulo per zero per tutti i tipi numerici.
9	AssertionError Generato in caso di fallimento dell'istruzione Assert.
10	AttributeError Generato in caso di errore nel riferimento o nell'assegnazione dell'attributo.
11	EOFError Sollevato quando non c'è alcun input dalla funzione raw_input () o input () e viene raggiunta la fine del file.
12	ImportError Generato quando un'istruzione import fallisce.
13	KeyboardInterrupt Generato quando l'utente interrompe l'esecuzione del programma, di solito premendo Ctrl + c.
14	LookupError Classe base per tutti gli errori di ricerca.
15	IndexError Generato quando un indice non viene trovato in una sequenza.
16	KeyError Generato quando la chiave specificata non viene trovata nel dizionario.
17	NameError Generato quando un identificatore non viene trovato nello spazio dei nomi locale o globale.
18	UnboundLocalError Generato quando si tenta di accedere a una variabile locale in una funzione o in un metodo ma non è stato assegnato alcun valore.
19	EnvironmentError Classe base per tutte le eccezioni che si verificano al di fuori dell'ambiente Python.
20	IOError Generato quando un'operazione di input / output fallisce, come l'istruzione print o la funzione open () quando si tenta di aprire un file che non esiste.
21	IOError Generato per errori relativi al sistema operativo.
22	SyntaxError Generato quando si verifica un errore nella sintassi di Python.
23	IndentationError Generato quando il rientro non è specificato correttamente.
24	SystemError Sollevato quando l'interprete trova un problema interno, ma quando si verifica questo errore l'interprete Python non esce.
25	SystemExit Generato quando l'interprete Python viene chiuso usando la funzione sys.exit (). Se non gestito nel codice, fa uscire l'interprete.
26	TypeError Generato quando viene tentata un'operazione o una funzione non valida per il tipo di dati specificato.
27	ValueError Generato quando la funzione incorporata per un tipo di dati ha il tipo di argomenti valido, ma gli argomenti hanno valori non validi specificati.
28	RuntimeError Generato quando un errore generato non rientra in nessuna categoria.
29	NotImplementedError Generato quando un metodo astratto che deve essere implementato in una classe ereditata non è effettivamente implementato.

Asserzioni in Python

Un'asserzione è un controllo di integrità che puoi attivare o disattivare quando hai finito di testare il programma.

Il modo più semplice per pensare a un'affermazione è paragonarla a un file raise-ifdichiarazione (o per essere più precisi, un'istruzione raise-if-not). Viene verificata un'espressione e se il risultato risulta falso, viene sollevata un'eccezione.

Le asserzioni vengono eseguite dall'istruzione assert, la più recente parola chiave di Python, introdotta nella versione 1.5.

I programmatori spesso inseriscono asserzioni all'inizio di una funzione per verificare l'input valido e dopo una chiamata di funzione per verificare l'output valido.

La dichiarazione di asserzione

Quando incontra un'istruzione assert, Python valuta l'espressione di accompagnamento, che si spera sia vera. Se l'espressione è falsa, Python solleva un'eccezione AssertionError .

La sintassi per assert è:

assert Expression[, Arguments]

Se l'asserzione fallisce, Python usa ArgumentExpression come argomento per AssertionError. Le eccezioni di AssertionError possono essere rilevate e gestite come qualsiasi altra eccezione utilizzando l'istruzione try-tranne, ma se non gestite, termineranno il programma e produrranno un traceback.

Esempio

Ecco una funzione che converte una temperatura da gradi Kelvin a gradi Fahrenheit. Dal momento che zero gradi Kelvin è freddo come diventa, la funzione si interrompe se vede una temperatura negativa -

#!/usr/bin/python
def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

Quando il codice sopra viene eseguito, produce il seguente risultato:

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

Cos'è l'eccezione?

Un'eccezione è un evento, che si verifica durante l'esecuzione di un programma che interrompe il normale flusso delle istruzioni del programma. In generale, quando uno script Python incontra una situazione che non può affrontare, solleva un'eccezione. Un'eccezione è un oggetto Python che rappresenta un errore.

Quando uno script Python solleva un'eccezione, deve gestire l'eccezione immediatamente altrimenti termina e si chiude.

Gestire un'eccezione

Se hai del codice sospetto che potrebbe sollevare un'eccezione, puoi difendere il tuo programma inserendo il codice sospetto in un filetry:bloccare. Dopo il try: block, includi un fileexcept: istruzione, seguita da un blocco di codice che gestisce il problema nel modo più elegante possibile.

Sintassi

Ecco la semplice sintassi di try .... tranne ... else blocks -

try:
   You do your operations here;
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Ecco alcuni punti importanti sulla sintassi sopra menzionata:

• Una singola istruzione try può avere più istruzioni tranne. Ciò è utile quando il blocco try contiene istruzioni che possono generare diversi tipi di eccezioni.

• È inoltre possibile fornire una clausola tranne generica, che gestisce qualsiasi eccezione.

• Dopo le clausole tranne, puoi includere una clausola else. Il codice nel blocco else viene eseguito se il codice nel blocco try: non solleva un'eccezione.

• Il blocco else è un buon posto per il codice che non ha bisogno della protezione try: block.

Esempio

Questo esempio apre un file, scrive il contenuto nel file, e ne esce con garbo perché non c'è alcun problema -

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"
   fh.close()

Questo produce il seguente risultato:

Written content in the file successfully

Esempio

Questo esempio tenta di aprire un file in cui non si dispone dell'autorizzazione di scrittura, quindi solleva un'eccezione:

#!/usr/bin/python

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"

Questo produce il seguente risultato:

Error: can't find file or read data

La clausola tranne senza eccezioni

È inoltre possibile utilizzare l'istruzione tranne senza eccezioni definite come segue:

try:
   You do your operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Questo tipo di a try-exceptdichiarazione cattura tutte le eccezioni che si verificano. Tuttavia, l'utilizzo di questo tipo di istruzione try-tranne non è considerato una buona pratica di programmazione, perché cattura tutte le eccezioni ma non obbliga il programmatore a identificare la causa principale del problema che può verificarsi.

La clausola tranne con più eccezioni

È inoltre possibile utilizzare la stessa istruzione tranne per gestire più eccezioni come segue:

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

La clausola di prova finale

Puoi usare un file finally: blocco insieme a un file try:bloccare. Il blocco finalmente è un posto dove mettere qualsiasi codice che deve essere eseguito, indipendentemente dal fatto che il blocco try abbia sollevato un'eccezione o meno. La sintassi dell'istruzione try-latest è questa:

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Non puoi usare la clausola else insieme a una clausola finalmente.

Esempio

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print "Error: can\'t find file or read data"

Se non si dispone dell'autorizzazione per aprire il file in modalità di scrittura, questo produrrà il seguente risultato:

Error: can't find file or read data

Lo stesso esempio può essere scritto in modo più pulito come segue:

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print "Going to close the file"
      fh.close()
except IOError:
   print "Error: can\'t find file or read data"

Quando viene generata un'eccezione nel blocco try , l'esecuzione passa immediatamente al blocco finalmente . Dopo che tutte le istruzioni nel blocco finalmente sono state eseguite, l'eccezione viene sollevata di nuovo e viene gestita nelle istruzioni tranne se presente nel successivo livello superiore dell'istruzione try-tranne .

Argomento di un'eccezione

Un'eccezione può avere un argomento , che è un valore che fornisce ulteriori informazioni sul problema. Il contenuto dell'argomento varia in base all'eccezione. Catturi l'argomento di un'eccezione fornendo una variabile nella clausola tranne come segue:

try:
   You do your operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

Se scrivi il codice per gestire una singola eccezione, puoi fare in modo che una variabile segua il nome dell'eccezione nell'istruzione tranne. Se stai intercettando più eccezioni, puoi fare in modo che una variabile segua la tupla dell'eccezione.

Questa variabile riceve il valore dell'eccezione che contiene principalmente la causa dell'eccezione. La variabile può ricevere un valore singolo o più valori sotto forma di tupla. Questa tupla di solito contiene la stringa di errore, il numero di errore e una posizione dell'errore.

Esempio

Di seguito è riportato un esempio per una singola eccezione:

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError, Argument:
      print "The argument does not contain numbers\n", Argument

# Call above function here.
temp_convert("xyz");

Questo produce il seguente risultato:

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Sollevare un'eccezione

Puoi sollevare eccezioni in diversi modi usando l'istruzione raise. La sintassi generale perraise la dichiarazione è la seguente.

Sintassi

raise [Exception [, args [, traceback]]]

Qui, Exception è il tipo di eccezione (ad esempio, NameError) e l' argomento è un valore per l'argomento dell'eccezione. L'argomento è facoltativo; se non fornito, l'argomento dell'eccezione è Nessuno.

L'argomento finale, traceback, è anch'esso opzionale (e usato raramente nella pratica) e, se presente, è l'oggetto traceback usato per l'eccezione.

Esempio

Un'eccezione può essere una stringa, una classe o un oggetto. La maggior parte delle eccezioni sollevate dal core di Python sono classi, con un argomento che è un'istanza della classe. La definizione di nuove eccezioni è abbastanza semplice e può essere eseguita come segue:

def functionName( level ):
   if level < 1:
      raise "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

Note:Per catturare un'eccezione, una clausola "tranne" deve fare riferimento alla stessa eccezione generata o oggetto di classe o stringa semplice. Ad esempio, per catturare l'eccezione sopra, dobbiamo scrivere la clausola tranne come segue:

try:
   Business Logic here...
except "Invalid level!":
   Exception handling here...
else:
   Rest of the code here...

Eccezioni definite dall'utente

Python consente anche di creare le proprie eccezioni derivando le classi dalle eccezioni incorporate standard.

Ecco un esempio relativo a RuntimeError . Qui viene creata una classe sottoclasse da RuntimeError . Ciò è utile quando è necessario visualizzare informazioni più specifiche quando viene rilevata un'eccezione.

Nel blocco try, l'eccezione definita dall'utente viene sollevata e catturata nel blocco tranne. La variabile e viene utilizzata per creare un'istanza della classe Networkerror .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Quindi, una volta definita la classe sopra, puoi sollevare l'eccezione come segue:

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

Python è stato un linguaggio orientato agli oggetti da quando esisteva. Per questo motivo, creare e utilizzare classi e oggetti è decisamente facile. Questo capitolo ti aiuta a diventare un esperto nell'uso del supporto per la programmazione orientata agli oggetti di Python.

Se non hai alcuna esperienza precedente con la programmazione orientata agli oggetti (OO), potresti consultare un corso introduttivo su di esso o almeno un tutorial di qualche tipo in modo da avere una comprensione dei concetti di base.

Tuttavia, ecco una piccola introduzione della programmazione orientata agli oggetti (OOP) per portarti alla velocità:

Panoramica della terminologia OOP

• Class- Un prototipo definito dall'utente per un oggetto che definisce un insieme di attributi che caratterizzano qualsiasi oggetto della classe. Gli attributi sono membri di dati (variabili di classe e variabili di istanza) e metodi, accessibili tramite notazione a punti.

• Class variable- Una variabile condivisa da tutte le istanze di una classe. Le variabili di classe sono definite all'interno di una classe ma al di fuori di qualsiasi metodo della classe. Le variabili di classe non vengono utilizzate così frequentemente come le variabili di istanza.

• Data member - Una variabile di classe o una variabile di istanza che contiene i dati associati a una classe e ai suoi oggetti.

• Function overloading- L'assegnazione di più di un comportamento a una particolare funzione. L'operazione eseguita varia in base ai tipi di oggetti o argomenti coinvolti.

• Instance variable - Una variabile definita all'interno di un metodo e che appartiene solo all'istanza corrente di una classe.

• Inheritance - Il trasferimento delle caratteristiche di una classe ad altre classi che ne derivano.

• Instance- Un oggetto individuale di una certa classe. Un oggetto obj che appartiene a una classe Circle, ad esempio, è un'istanza della classe Circle.

• Instantiation - La creazione di un'istanza di una classe.

• Method - Un tipo speciale di funzione definita in una definizione di classe.

• Object- Un'istanza univoca di una struttura dati definita dalla sua classe. Un oggetto comprende sia membri di dati (variabili di classe e variabili di istanza) che metodi.

• Operator overloading - L'assegnazione di più di una funzione a un particolare operatore.

Creazione di classi

L' istruzione class crea una nuova definizione di classe. Il nome della classe segue immediatamente la parola chiave class seguita da due punti come segue:

class ClassName:
   'Optional class documentation string'
   class_suite

• La classe ha una stringa di documentazione, a cui è possibile accedere tramite ClassName .__ doc__ .

• La class_suite consiste di tutte le dichiarazioni componenti che definiscono i membri della classe, attributi di dati e funzioni.

Esempio

Di seguito è riportato l'esempio di una semplice classe Python:

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• La variabile empCount è una variabile di classe il cui valore è condiviso tra tutte le istanze di questa classe. È possibile accedervi come Employee.empCount dall'interno o dall'esterno della classe.

• Il primo metodo __init __ () è un metodo speciale, chiamato costruttore di classi o metodo di inizializzazione che Python chiama quando crei una nuova istanza di questa classe.

• Dichiari altri metodi di classe come funzioni normali con l'eccezione che il primo argomento di ogni metodo è self . Python aggiunge l' argomento self alla lista per te; non è necessario includerlo quando si chiamano i metodi.

Creazione di oggetti istanza

Per creare istanze di una classe, chiamate la classe usando il nome della classe e passate gli argomenti che il suo metodo __init__ accetta.

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

Accesso agli attributi

Si accede agli attributi dell'oggetto utilizzando l'operatore punto con oggetto. È possibile accedere alla variabile di classe utilizzando il nome della classe come segue:

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Ora, mettendo insieme tutti i concetti -

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Quando il codice sopra viene eseguito, produce il seguente risultato:

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Puoi aggiungere, rimuovere o modificare attributi di classi e oggetti in qualsiasi momento:

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

Invece di utilizzare le normali istruzioni per accedere agli attributi, è possibile utilizzare le seguenti funzioni:

• Il getattr(obj, name[, default]) - per accedere all'attributo dell'oggetto.

• Il hasattr(obj,name) - per verificare se un attributo esiste o meno.

• Il setattr(obj,name,value)- per impostare un attributo. Se l'attributo non esiste, verrebbe creato.

• Il delattr(obj, name) - per eliminare un attributo.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

Attributi di classe incorporati

Ogni classe Python continua a seguire gli attributi incorporati ed è possibile accedervi utilizzando l'operatore punto come qualsiasi altro attributo -

• __dict__ - Dizionario contenente lo spazio dei nomi della classe.

• __doc__ - Stringa di documentazione della classe o nessuna, se non definita.

• __name__ - Nome della classe.

• __module__- Nome del modulo in cui è definita la classe. Questo attributo è "__main__" in modalità interattiva.

• __bases__ - Una tupla possibilmente vuota contenente le classi di base, nell'ordine in cui si verificano nell'elenco delle classi di base.

Per la classe precedente proviamo ad accedere a tutti questi attributi:

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Quando il codice sopra viene eseguito, produce il seguente risultato:

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

Distruzione di oggetti (raccolta dei rifiuti)

Python elimina automaticamente gli oggetti non necessari (tipi incorporati o istanze di classe) per liberare lo spazio di memoria. Il processo mediante il quale Python recupera periodicamente i blocchi di memoria che non sono più in uso è chiamato Garbage Collection.

Il garbage collector di Python viene eseguito durante l'esecuzione del programma e viene attivato quando il conteggio dei riferimenti di un oggetto raggiunge lo zero. Il conteggio dei riferimenti di un oggetto cambia al variare del numero di alias che puntano a esso.

Il conteggio dei riferimenti a un oggetto aumenta quando gli viene assegnato un nuovo nome o viene inserito in un contenitore (elenco, tupla o dizionario). Il conteggio dei riferimenti dell'oggetto diminuisce quando viene eliminato con del , il suo riferimento viene riassegnato o il suo riferimento esce dall'ambito. Quando il conteggio dei riferimenti di un oggetto raggiunge lo zero, Python lo raccoglie automaticamente.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

Normalmente non noterai quando il garbage collector distrugge un'istanza orfana e ne recupera lo spazio. Ma una classe può implementare il metodo speciale __del __ () , chiamato distruttore, che viene invocato quando l'istanza sta per essere distrutta. Questo metodo può essere utilizzato per pulire le risorse non di memoria utilizzate da un'istanza.

Esempio

Questo distruttore __del __ () stampa il nome della classe di un'istanza che sta per essere distrutta -

#!/usr/bin/python

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3

Quando il codice sopra viene eseguito, produce il seguente risultato:

3083401324 3083401324 3083401324
Point destroyed

Note- Idealmente, dovresti definire le tue classi in un file separato, quindi dovresti importarle nel tuo file di programma principale usando l' istruzione import .

Ereditarietà di classe

Invece di iniziare da zero, puoi creare una classe derivandola da una classe preesistente elencando la classe genitore tra parentesi dopo il nome della nuova classe.

La classe figlia eredita gli attributi della sua classe genitore e puoi usare quegli attributi come se fossero definiti nella classe figlia. Una classe figlia può anche sovrascrivere i membri dei dati e i metodi del genitore.

Sintassi

Le classi derivate sono dichiarate in modo molto simile alla loro classe genitore; tuttavia, dopo il nome della classe viene fornito un elenco di classi base da cui ereditare:

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Esempio

#!/usr/bin/python

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print "Calling parent constructor"

   def parentMethod(self):
      print 'Calling parent method'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print "Calling child constructor"

   def childMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

Quando il codice sopra viene eseguito, produce il seguente risultato:

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

In modo simile, puoi guidare una classe da più classi genitore come segue:

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

È possibile utilizzare le funzioni issubclass () o isinstance () per controllare le relazioni di due classi e istanze.

• Il issubclass(sub, sup) La funzione booleana restituisce vero se la sottoclasse data sub è effettivamente una sottoclasse della superclasse sup.

• Il isinstance(obj, Class)La funzione booleana restituisce true se obj è un'istanza della classe Class o è un'istanza di una sottoclasse di Class

Metodi di sostituzione

Puoi sempre sovrascrivere i metodi della tua classe genitore. Una ragione per sovrascrivere i metodi del genitore è perché potresti volere funzionalità speciali o diverse nella tua sottoclasse.

Esempio

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Quando il codice sopra viene eseguito, produce il seguente risultato:

Calling child method

Metodi di sovraccarico di base

La tabella seguente elenca alcune funzionalità generiche che puoi sovrascrivere nelle tue classi:

Sr.No.	Metodo, descrizione e chiamata di esempio
1	__init__ ( self [,args...] ) Costruttore (con eventuali argomenti opzionali) Chiamata di esempio: obj = className (args)
2	__del__( self ) Distruttore, elimina un oggetto Chiamata di esempio: del obj
3	__repr__( self ) Rappresentazione di stringa valutabile Chiamata di esempio: repr (obj)
4	__str__( self ) Rappresentazione di stringa stampabile Chiamata di esempio: str (obj)
5	__cmp__ ( self, x ) Confronto di oggetti Chiamata di esempio: cmp (obj, x)

Operatori di sovraccarico

Supponi di aver creato una classe Vector per rappresentare vettori bidimensionali, cosa succede quando usi l'operatore più per aggiungerli? Molto probabilmente Python ti sgriderà.

Tuttavia, potresti definire il metodo __add__ nella tua classe per eseguire l'addizione vettoriale e quindi l'operatore più si comporterebbe come previsto -

Esempio

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

Quando il codice sopra viene eseguito, produce il seguente risultato:

Vector(7,8)

Dati nascosti

Gli attributi di un oggetto possono o meno essere visibili al di fuori della definizione della classe. È necessario denominare gli attributi con un doppio carattere di sottolineatura prefisso e quegli attributi quindi non saranno direttamente visibili agli estranei.

Esempio

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

Quando il codice sopra viene eseguito, produce il seguente risultato:

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python protegge questi membri modificando internamente il nome per includere il nome della classe. È possibile accedere ad attributi come object._className__attrName . Se sostituisci l'ultima riga come segue, allora funziona per te -

.........................
print counter._JustCounter__secretCount

Quando il codice sopra viene eseguito, produce il seguente risultato:

1
2
2

Un'espressione regolare è una sequenza di caratteri speciale che consente di abbinare o trovare altre stringhe o insiemi di stringhe, utilizzando una sintassi specializzata, impartita in un modello. Le espressioni regolari sono ampiamente utilizzate nel mondo UNIX.

Il modulo refornisce il supporto completo per le espressioni regolari simili a Perl in Python. Il modulo re solleva l'eccezione re.error se si verifica un errore durante la compilazione o l'utilizzo di un'espressione regolare.

Copriremo due importanti funzioni, che verrebbero utilizzate per gestire le espressioni regolari. Ma prima una piccola cosa: ci sono vari caratteri, che avrebbero un significato speciale quando vengono usati nelle espressioni regolari. Per evitare qualsiasi confusione mentre si ha a che fare con le espressioni regolari, useremmo Raw Strings comer'expression'.

La funzione match

Questa funzione tenta di abbinare il pattern RE alla stringa con flag opzionali .

Ecco la sintassi per questa funzione:

re.match(pattern, string, flags=0)

Ecco la descrizione dei parametri:

Sr.No.	Parametro e descrizione
1	pattern Questa è l'espressione regolare da abbinare.
2	string Questa è la stringa, che dovrebbe essere cercata per abbinare il modello all'inizio della stringa.
3	flags È possibile specificare flag diversi utilizzando OR bit per bit (|). Questi sono modificatori, elencati nella tabella seguente.

La funzione re.match restituisce un filematch oggetto sul successo, Nonein caso di fallimento. Usiamo la funzione group (num) o groups () dimatch oggetto per ottenere l'espressione corrispondente.

Sr.No.	Corrispondenza metodo oggetto e descrizione
1	group(num=0) Questo metodo restituisce l'intera corrispondenza (o il numero di sottogruppo specifico)
2	groups() Questo metodo restituisce tutti i sottogruppi corrispondenti in una tupla (vuoto se non ce n'erano)

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

La funzione di ricerca

Questa funzione cerca la prima occorrenza del pattern RE all'interno di una stringa con flag opzionali .

Ecco la sintassi per questa funzione:

re.search(pattern, string, flags=0)

Ecco la descrizione dei parametri:

Sr.No.	Parametro e descrizione
1	pattern Questa è l'espressione regolare da abbinare.
2	string Questa è la stringa, che dovrebbe essere ricercata in modo che corrisponda al modello in qualsiasi punto della stringa.
3	flags È possibile specificare flag diversi utilizzando OR bit per bit (|). Questi sono modificatori, elencati nella tabella seguente.

La funzione re.search restituisce un filematch oggetto sul successo, nonein caso di fallimento. Usiamo la funzione group (num) o groups () dimatch oggetto per ottenere l'espressione corrispondente.

Sr.No.	Corrispondenza metodi oggetto e descrizione
1	group(num=0) Questo metodo restituisce l'intera corrispondenza (o il numero di sottogruppo specifico)
2	groups() Questo metodo restituisce tutti i sottogruppi corrispondenti in una tupla (vuoto se non ce n'erano)

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

Confronto tra ricerca e corrispondenza

Python offre due diverse operazioni primitive basate su espressioni regolari: match verifica la presenza di una corrispondenza solo all'inizio della stringa, mentre search cerca una corrispondenza in qualsiasi punto della stringa (questo è ciò che Perl fa di default).

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

No match!!
search --> searchObj.group() :  dogs

Cerca e sostituisci

Uno dei più importanti re metodi che utilizzano espressioni regolari è sub.

Sintassi

re.sub(pattern, repl, string, max=0)

Questo metodo sostituisce tutte le occorrenze del modello RE nella stringa con repl , sostituendo tutte le occorrenze a meno che non venga fornito max . Questo metodo restituisce una stringa modificata.

Esempio

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Quando il codice sopra viene eseguito, produce il seguente risultato:

Phone Num :  2004-959-559
Phone Num :  2004959559

Modificatori di espressioni regolari: flag di opzione

I letterali delle espressioni regolari possono includere un modificatore opzionale per controllare vari aspetti della corrispondenza. I modificatori sono specificati come flag opzionale. Puoi fornire più modificatori utilizzando OR esclusivo (|), come mostrato in precedenza e può essere rappresentato da uno di questi -

Sr.No.	Modificatore e descrizione
1	re.I Esegue la corrispondenza senza distinzione tra maiuscole e minuscole.
2	re.L Interpreta le parole in base alla locale corrente. Questa interpretazione influisce sul gruppo alfabetico (\ w e \ W), così come sul comportamento dei confini delle parole (\ be \ B).
3	re.M Fa corrispondere $ alla fine di una riga (non solo alla fine della stringa) e fa corrispondere ^ l'inizio di qualsiasi riga (non solo l'inizio della stringa).
4	re.S Fa corrispondere un punto (punto) a qualsiasi carattere, inclusa una nuova riga.
5	re.U Interpreta le lettere in base al set di caratteri Unicode. Questo flag influenza il comportamento di \ w, \ W, \ b, \ B.
6	re.X Consente la sintassi delle espressioni regolari "più carina". Ignora gli spazi (eccetto all'interno di un set [] o quando è preceduto da una barra rovesciata) e tratta # senza caratteri di escape come un marcatore di commento.

Modelli di espressioni regolari

Fatta eccezione per i personaggi di controllo, (+ ? . * ^ $ ( ) [ ] { } | \), tutti i personaggi corrispondono a se stessi. È possibile eseguire l'escape di un carattere di controllo precedendolo con una barra rovesciata.

La tabella seguente elenca la sintassi delle espressioni regolari disponibile in Python:

Sr.No.	Modello e descrizione
1	^ Corrisponde all'inizio della riga.
2	$ Corrisponde alla fine della riga.
3	. Corrisponde a qualsiasi carattere singolo tranne la nuova riga. L'uso dell'opzione m consente anche di abbinare la nuova riga.
4	[...] Corrisponde a qualsiasi singolo carattere tra parentesi.
5	[^...] Corrisponde a qualsiasi carattere singolo non tra parentesi
6	re* Corrisponde a 0 o più occorrenze dell'espressione precedente.
7	re+ Corrisponde a 1 o più occorrenze dell'espressione precedente.
8	re? Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
9	re{ n} Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
10	re{ n,} Corrisponde a n o più occorrenze dell'espressione precedente.
11	re{ n, m} Corrisponde ad almeno n e al massimo m occorrenze dell'espressione precedente.
12	a| b Corrisponde a a o b.
13	(re) Raggruppa le espressioni regolari e ricorda il testo corrispondente.
14	(?imx) Attiva temporaneamente le opzioni i, m o x all'interno di un'espressione regolare. Se tra parentesi, viene interessata solo quell'area.
15	(?-imx) Disattiva temporaneamente le opzioni i, m o x all'interno di un'espressione regolare. Se tra parentesi, viene interessata solo quell'area.
16	(?: re) Raggruppa le espressioni regolari senza ricordare il testo corrispondente.
17	(?imx: re) Attiva temporaneamente le opzioni i, m o x tra parentesi.
18	(?-imx: re) Disattiva temporaneamente le opzioni i, m o x tra parentesi.
19	(?#...) Commento.
20	(?= re) Specifica la posizione utilizzando un modello. Non ha una gamma.
21	(?! re) Specifica la posizione utilizzando la negazione del modello. Non ha una gamma.
22	(?> re) Corrisponde a pattern indipendenti senza backtracking.
23	\w Corrisponde ai caratteri delle parole.
24	\W Corrisponde a caratteri non di parole.
25	\s Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
26	\S Corrisponde a spazi non bianchi.
27	\d Corrisponde alle cifre. Equivalente a [0-9].
28	\D Corrisponde a non cifre.
29	\A Corrisponde all'inizio della stringa.
30	\Z Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
31	\z Corrisponde alla fine della stringa.
32	\G Punto delle partite in cui è finita l'ultima partita.
33	\b Corrisponde ai confini delle parole quando sono al di fuori delle parentesi. Corrisponde a backspace (0x08) quando è racchiuso tra parentesi.
34	\B Corrisponde ai confini non di parole.
35	\n, \t, etc. Trova nuove righe, ritorni a capo, tabulazioni, ecc.
36	\1...\9 Corrisponde all'ennesima sottoespressione raggruppata.
37	\10 Corrisponde all'ennesima sottoespressione raggruppata se corrisponde già. Altrimenti si riferisce alla rappresentazione ottale di un codice carattere.

Esempi di espressioni regolari

Caratteri letterali

Sr.No.	Esempio e descrizione
1	python Trova "python".

Classi di personaggi

Sr.No.	Esempio e descrizione
1	[Pp]ython Trova "Python" o "python"
2	rub[ye] Trova "ruby" o "rube"
3	[aeiou] Trova la corrispondenza di una vocale minuscola
4	[0-9] Trova qualsiasi cifra; uguale a [0123456789]
5	[a-z] Trova qualsiasi lettera ASCII minuscola
6	[A-Z] Trova qualsiasi lettera ASCII maiuscola
7	[a-zA-Z0-9] Abbina uno dei precedenti
8	[^aeiou] Trova qualsiasi cosa diversa da una vocale minuscola
9	[^0-9] Trova qualsiasi cosa diversa da una cifra

Classi di caratteri speciali

Sr.No.	Esempio e descrizione
1	. Trova qualsiasi carattere tranne la nuova riga
2	\d Trova una cifra: [0-9]
3	\D Trova una non cifra: [^ 0-9]
4	\s Trova uno spazio vuoto: [\ t \ r \ n \ f]
5	\S Trova spazio non bianco: [^ \ t \ r \ n \ f]
6	\w Trova il carattere di una singola parola: [A-Za-z0-9_]
7	\W Trova un carattere diverso da una parola: [^ A-Za-z0-9_]

Casi di ripetizione

Sr.No.	Esempio e descrizione
1	ruby? Trova "rub" o "ruby": la y è facoltativa
2	ruby* Trova "strofina" più 0 o più anni
3	ruby+ Corrisponde a "strofinare" più 1 o più anni
4	\d{3} Trova esattamente 3 cifre
5	\d{3,} Corrisponde a 3 o più cifre
6	\d{3,5} Trova la corrispondenza di 3, 4 o 5 cifre

Ripetizione non soddisfacente

Corrisponde al minor numero di ripetizioni -

Sr.No.	Esempio e descrizione
1	<.*> Ripetizione avida: corrisponde a "<python> perl>"
2	<.*?> Nongreedy: trova "<python>" in "<python> perl>"

Raggruppamento con parentesi

Sr.No.	Esempio e descrizione
1	\D\d+ Nessun gruppo: + si ripete \ d
2	(\D\d)+ Raggruppato: + ripete la coppia \ D \ d
3	([Pp]ython(, )?)+ Trova "Python", "Python, python, python", ecc.

Backreferences

Questo corrisponde di nuovo a un gruppo precedentemente abbinato -

Sr.No.	Esempio e descrizione
1	([Pp])ython&\1ails Abbina Python e Pails o Python e Pails
2	(['"])[^\1]*\1 Stringa tra virgolette singole o doppie. \ 1 corrisponde a qualsiasi corrispondenza del primo gruppo. \ 2 corrisponde a qualunque sia il 2 ° gruppo abbinato, ecc.

Alternative

Sr.No.	Esempio e descrizione
1	python|perl Trova "python" o "perl"
2	rub(y|le)) Abbina "rubino" o "rublo"
3	Python(!+|\?) "Python" seguito da uno o più! o uno?

Ancore

Questo deve specificare la posizione della partita.

Sr.No.	Esempio e descrizione
1	^Python Trova "Python" all'inizio di una stringa o di una riga interna
2	Python$ Trova "Python" alla fine di una stringa o di una riga
3	\APython Trova "Python" all'inizio di una stringa
4	Python\Z Trova "Python" alla fine di una stringa
5	\bPython\b Trova "Python" in corrispondenza del confine di una parola
6	\brub\B \ B è un confine non di parole: trova "rub" in "rube" e "ruby" ma non da solo
7	Python(?=!) Trova "Python", se seguito da un punto esclamativo.
8	Python(?!!) Trova "Python", se non seguito da un punto esclamativo.

Sintassi speciale con parentesi

Sr.No.	Esempio e descrizione
1	R(?#comment) Corrisponde a "R". Tutto il resto è un commento
2	R(?i)uby Non distingue tra maiuscole e minuscole durante la corrispondenza di "uby"
3	R(?i:uby) Come sopra
4	rub(?:y|le)) Raggruppa solo senza creare \ 1 backreference

Common Gateway Interface, o CGI, è un insieme di standard che definiscono il modo in cui le informazioni vengono scambiate tra il server Web e uno script personalizzato. Le specifiche CGI sono attualmente mantenute dall'NCSA.

Cos'è la CGI?

• Common Gateway Interface, o CGI, è uno standard per i programmi gateway esterni per interfacciarsi con i server di informazioni come i server HTTP.

• La versione corrente è CGI / 1.1 e CGI / 1.2 è in fase di elaborazione.

Navigare su Internet

Per comprendere il concetto di CGI, vediamo cosa succede quando facciamo clic su un collegamento ipertestuale per navigare in una particolare pagina web o URL.

• Il browser contatta il server Web HTTP e richiede l'URL, ovvero il nome del file.

• Il server Web analizza l'URL e cerca il nome del file. Se trova quel file, lo rimanda al browser, altrimenti invia un messaggio di errore che indica che hai richiesto un file sbagliato.

• Il browser Web riceve la risposta dal server Web e visualizza il file ricevuto o il messaggio di errore.

Tuttavia, è possibile impostare il server HTTP in modo che ogni volta che viene richiesto un file in una determinata directory, quel file non viene restituito; invece viene eseguito come un programma e tutto ciò che il programma emette viene rispedito al browser per visualizzarlo. Questa funzione è chiamata Common Gateway Interface o CGI ei programmi sono chiamati script CGI. Questi programmi CGI possono essere uno script Python, uno script PERL, uno script shell, un programma C o C ++, ecc.

Diagramma di architettura CGI

Supporto e configurazione del server Web

Prima di procedere con la programmazione CGI, assicurati che il tuo server Web supporti CGI e che sia configurato per gestire i programmi CGI. Tutti i programmi CGI che devono essere eseguiti dal server HTTP sono conservati in una directory preconfigurata. Questa directory è chiamata CGI Directory e per convenzione è chiamata / var / www / cgi-bin. Per convenzione, i file CGI hanno l'estensione come.cgi, ma puoi mantenere i tuoi file con estensione python .py anche.

Per impostazione predefinita, il server Linux è configurato per eseguire solo gli script nella directory cgi-bin in / var / www. Se vuoi specificare qualsiasi altra directory per eseguire i tuoi script CGI, commenta le seguenti righe nel file httpd.conf -

<Directory "/var/www/cgi-bin">
   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all
</Directory>

<Directory "/var/www/cgi-bin">
Options All
</Directory>

Qui, assumiamo che tu abbia il server Web attivo e funzionante con successo e che tu sia in grado di eseguire qualsiasi altro programma CGI come Perl o Shell, ecc.

Primo programma CGI

Ecco un semplice collegamento, che è collegato a uno script CGI chiamato hello.py . Questo file è conservato nella directory / var / www / cgi-bin e ha il seguente contenuto. Prima di eseguire il programma CGI, assicurati di aver cambiato la modalità di utilizzo del filechmod 755 hello.py Comando UNIX per rendere eseguibile il file.

#!/usr/bin/python

print "Content-type:text/html\r\n\r\n"
print '<html>'
print '<head>'
print '<title>Hello World - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello World! This is my first CGI program</h2>'
print '</body>'
print '</html>'

Se fai clic su hello.py, questo produce il seguente output:

Ciao mondo! Questo è il mio primo programma CGI

Questo script hello.py è un semplice script Python, che scrive il suo output sul file STDOUT, cioè schermo. C'è una caratteristica importante ed extra disponibile che è la prima riga da stampareContent-type:text/html\r\n\r\n. Questa riga viene rinviata al browser e specifica il tipo di contenuto da visualizzare sullo schermo del browser.

Ormai devi aver compreso il concetto di base di CGI e puoi scrivere molti programmi CGI complicati usando Python. Questo script può interagire con qualsiasi altro sistema esterno anche per scambiare informazioni come RDBMS.

Intestazione HTTP

La linea Content-type:text/html\r\n\r\nfa parte dell'intestazione HTTP che viene inviata al browser per comprendere il contenuto. Tutta l'intestazione HTTP avrà la seguente forma:

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

Ci sono poche altre importanti intestazioni HTTP, che userete frequentemente nella vostra programmazione CGI.

Sr.No.	Intestazione e descrizione
1	Content-type: Una stringa MIME che definisce il formato del file restituito. L'esempio è Content-type: text / html
2	Expires: Date La data in cui le informazioni diventano non valide. Viene utilizzato dal browser per decidere quando una pagina deve essere aggiornata. Una stringa di data valida è nel formato 01 gen 1998 12:00:00 GMT.
3	Location: URL L'URL restituito al posto dell'URL richiesto. È possibile utilizzare questo campo per reindirizzare una richiesta a qualsiasi file.
4	Last-modified: Date La data dell'ultima modifica della risorsa.
5	Content-length: N La lunghezza, in byte, dei dati restituiti. Il browser utilizza questo valore per segnalare il tempo di download stimato per un file.
6	Set-Cookie: String Imposta il cookie passato attraverso la stringa

Variabili d'ambiente CGI

Tutti i programmi CGI hanno accesso alle seguenti variabili d'ambiente. Queste variabili giocano un ruolo importante durante la scrittura di qualsiasi programma CGI.

Sr.No.	Nome e descrizione della variabile
1	CONTENT_TYPE Il tipo di dati del contenuto. Utilizzato quando il client invia il contenuto allegato al server. Ad esempio, caricamento di file.
2	CONTENT_LENGTH La lunghezza delle informazioni sulla query. È disponibile solo per richieste POST.
3	HTTP_COOKIE Restituisce i cookie impostati sotto forma di coppia chiave e valore.
4	HTTP_USER_AGENT Il campo dell'intestazione della richiesta dell'agente utente contiene informazioni sull'agente utente che ha originato la richiesta. È il nome del browser web.
5	PATH_INFO Il percorso per lo script CGI.
6	QUERY_STRING Le informazioni con codifica URL inviate con la richiesta del metodo GET.
7	REMOTE_ADDR L'indirizzo IP dell'host remoto che effettua la richiesta. Ciò è utile per la registrazione o per l'autenticazione.
8	REMOTE_HOST Il nome completo dell'host che effettua la richiesta. Se queste informazioni non sono disponibili, è possibile utilizzare REMOTE_ADDR per ottenere l'indirizzo IR.
9	REQUEST_METHOD Il metodo utilizzato per effettuare la richiesta. I metodi più comuni sono GET e POST.
10	SCRIPT_FILENAME Il percorso completo dello script CGI.
11	SCRIPT_NAME Il nome dello script CGI.
12	SERVER_NAME Il nome host o l'indirizzo IP del server
13	SERVER_SOFTWARE Il nome e la versione del software in esecuzione sul server.

Ecco un piccolo programma CGI per elencare tutte le variabili CGI. Fare clic su questo collegamento per visualizzare il risultato Ottieni ambiente

#!/usr/bin/python

import os

print "Content-type: text/html\r\n\r\n";
print "<font size=+1>Environment</font><\br>";
for param in os.environ.keys():
   print "<b>%20s</b>: %s<\br>" % (param, os.environ[param])

Metodi GET e POST

Devi esserti imbattuto in molte situazioni in cui hai bisogno di passare alcune informazioni dal tuo browser al server web e, infine, al tuo programma CGI. Il più delle volte, il browser utilizza due metodi, due trasmettono queste informazioni al server web. Questi metodi sono il metodo GET e il metodo POST.

Passaggio di informazioni utilizzando il metodo GET

Il metodo GET invia le informazioni utente codificate aggiunte alla richiesta della pagina. La pagina e le informazioni codificate sono separate dal? carattere come segue -

http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2

Il metodo GET è il metodo predefinito per passare le informazioni dal browser al server web e produce una lunga stringa che appare nella casella Posizione: del browser. Non utilizzare mai il metodo GET se si dispone di password o altre informazioni sensibili da passare al server. Il metodo GET ha limitazioni di dimensione: solo 1024 caratteri possono essere inviati in una stringa di richiesta. Il metodo GET invia le informazioni utilizzando l'intestazione QUERY_STRING e sarà accessibile nel programma CGI tramite la variabile di ambiente QUERY_STRING.

È possibile passare informazioni semplicemente concatenando coppie di chiavi e valori con qualsiasi URL oppure è possibile utilizzare i tag HTML <FORM> per passare le informazioni utilizzando il metodo GET.

Esempio di URL semplice: metodo Get

Ecco un semplice URL, che passa due valori al programma hello_get.py utilizzando il metodo GET.

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

Sotto è hello_get.pyscript per gestire l'input fornito dal browser web. Useremocgi modulo, che rende molto facile accedere alle informazioni passate -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Ciò genererebbe il seguente risultato:

Ciao ZARA ALI

Esempio di FORM semplice: metodo GET

Questo esempio passa due valori utilizzando HTML FORM e il pulsante di invio. Usiamo lo stesso script CGI hello_get.py per gestire questo input.

<form action = "/cgi-bin/hello_get.py" method = "get">
First Name: <input type = "text" name = "first_name">  <br />

Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>

Ecco l'output effettivo del modulo sopra, inserisci Nome e Cognome e quindi fai clic sul pulsante Invia per vedere il risultato.

Passaggio di informazioni utilizzando il metodo POST

Un metodo generalmente più affidabile per passare informazioni a un programma CGI è il metodo POST. Questo impacchetta le informazioni esattamente allo stesso modo dei metodi GET, ma invece di inviarle come stringa di testo dopo un? nell'URL lo invia come messaggio separato. Questo messaggio arriva nello script CGI sotto forma di input standard.

Di seguito è riportato lo stesso script hello_get.py che gestisce GET e il metodo POST.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Riprendiamo lo stesso esempio di cui sopra che trasmette due valori utilizzando HTML FORM e il pulsante di invio. Usiamo lo stesso script CGI hello_get.py per gestire questo input.

<form action = "/cgi-bin/hello_get.py" method = "post">
First Name: <input type = "text" name = "first_name"><br />
Last Name: <input type = "text" name = "last_name" />

<input type = "submit" value = "Submit" />
</form>

Ecco l'output effettivo del modulo sopra. Immettere Nome e Cognome e quindi fare clic sul pulsante Invia per vedere il risultato.

Passaggio dei dati della casella di controllo al programma CGI

Le caselle di controllo vengono utilizzate quando è necessario selezionare più di un'opzione.

Ecco un esempio di codice HTML per un modulo con due caselle di controllo:

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on" /> Maths
<input type = "checkbox" name = "physics" value = "on" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato lo script checkbox.cgi per gestire l'input fornito dal browser Web per il pulsante della casella di controllo.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('maths'):
   math_flag = "ON"
else:
   math_flag = "OFF"

if form.getvalue('physics'):
   physics_flag = "ON"
else:
   physics_flag = "OFF"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"

Passaggio dei dati del pulsante di opzione al programma CGI

I pulsanti di opzione vengono utilizzati quando è necessario selezionare una sola opzione.

Ecco un esempio di codice HTML per un modulo con due pulsanti di opzione:

<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">
<input type = "radio" name = "subject" value = "maths" /> Maths
<input type = "radio" name = "subject" value = "physics" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato lo script radiobutton.py per gestire l'input fornito dal browser Web per il pulsante di opzione -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('subject'):
   subject = form.getvalue('subject')
else:
   subject = "Not set"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Passaggio dei dati dell'area di testo al programma CGI

L'elemento TEXTAREA viene utilizzato quando è necessario passare del testo su più righe al programma CGI.

Ecco un esempio di codice HTML per un modulo con una casella TEXTAREA -

<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">
<textarea name = "textcontent" cols = "40" rows = "4">
Type your text here...
</textarea>
<input type = "submit" value = "Submit" />
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato lo script textarea.cgi per gestire l'input fornito dal browser web -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('textcontent'):
   text_content = form.getvalue('textcontent')
else:
   text_content = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"

Passaggio dei dati della casella a discesa al programma CGI

La casella a discesa viene utilizzata quando abbiamo molte opzioni disponibili ma ne verranno selezionate solo una o due.

Ecco un esempio di codice HTML per un modulo con una casella a discesa:

<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit"/>
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato lo script dropdown.py per gestire l'input fornito dal browser web.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('dropdown'):
   subject = form.getvalue('dropdown')
else:
   subject = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Utilizzo dei cookie in CGI

Il protocollo HTTP è un protocollo senza stato. Per un sito web commerciale, è necessario mantenere le informazioni sulla sessione tra le diverse pagine. Ad esempio, la registrazione di un utente termina dopo aver completato molte pagine. Come conservare le informazioni sulla sessione dell'utente in tutte le pagine web?

In molte situazioni, l'utilizzo dei cookie è il metodo più efficiente per ricordare e tracciare preferenze, acquisti, commissioni e altre informazioni necessarie per una migliore esperienza dei visitatori o statistiche del sito.

Come funziona?

Il tuo server invia alcuni dati al browser del visitatore sotto forma di cookie. Il browser può accettare il cookie. In caso affermativo, viene archiviato come record di testo normale sul disco rigido del visitatore. Ora, quando il visitatore arriva a un'altra pagina del tuo sito, il cookie è disponibile per il recupero. Una volta recuperato, il tuo server sa / ricorda cosa è stato memorizzato.

I cookie sono un record di dati di testo semplice di 5 campi di lunghezza variabile -

• Expires- La data in cui scadrà il cookie. Se questo è vuoto, il cookie scadrà quando il visitatore chiude il browser.

• Domain - Il nome di dominio del tuo sito.

• Path- Il percorso della directory o della pagina web che imposta il cookie. Questo può essere vuoto se desideri recuperare il cookie da qualsiasi directory o pagina.

• Secure- Se questo campo contiene la parola "secure", il cookie può essere recuperato solo con un server sicuro. Se questo campo è vuoto, non esiste alcuna restrizione di questo tipo.

• Name=Value - I cookie vengono impostati e recuperati sotto forma di coppie chiave e valore.

Configurazione dei cookie

È molto semplice inviare cookie al browser. Questi cookie vengono inviati insieme all'intestazione HTTP prima del campo Tipo di contenuto. Supponendo che si desideri impostare UserID e Password come cookie. L'impostazione dei cookie avviene come segue:

#!/usr/bin/python

print "Set-Cookie:UserID = XYZ;\r\n"
print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\r\n"
print "Set-Cookie:Domain = www.tutorialspoint.com;\r\n"
print "Set-Cookie:Path = /perl;\n"
print "Content-type:text/html\r\n\r\n"
...........Rest of the HTML Content....

Da questo esempio, devi aver capito come impostare i cookie. Noi usiamoSet-Cookie Intestazione HTTP per impostare i cookie.

È facoltativo impostare gli attributi dei cookie come Expires, Domain e Path. È da notare che i cookie vengono impostati prima dell'invio di magic line"Content-type:text/html\r\n\r\n.

Recupero dei cookie

È molto facile recuperare tutti i cookie impostati. I cookie sono memorizzati nella variabile d'ambiente CGI HTTP_COOKIE e avranno la seguente forma:

key1 = value1;key2 = value2;key3 = value3....

Ecco un esempio di come recuperare i cookie.

#!/usr/bin/python

# Import modules for CGI handling 
from os import environ
import cgi, cgitb

if environ.has_key('HTTP_COOKIE'):
   for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
      (key, value ) = split(cookie, '=');
      if key == "UserID":
         user_id = value

      if key == "Password":
         password = value

print "User ID  = %s" % user_id
print "Password = %s" % password

Questo produce il seguente risultato per i cookie impostati dallo script precedente:

User ID = XYZ
Password = XYZ123

Esempio di caricamento di file

Per caricare un file, il modulo HTML deve avere l'attributo enctype impostato su multipart/form-data. Il tag di input con il tipo di file crea un pulsante "Sfoglia".

<html>
<body>
   <form enctype = "multipart/form-data" 
                     action = "save_file.py" method = "post">
   <p>File: <input type = "file" name = "filename" /></p>
   <p><input type = "submit" value = "Upload" /></p>
   </form>
</body>
</html>

Il risultato di questo codice è il seguente modulo:

L'esempio sopra è stato disabilitato intenzionalmente per salvare le persone che caricano file sul nostro server, ma puoi provare il codice sopra con il tuo server.

Ecco il copione save_file.py per gestire il caricamento dei file -

#!/usr/bin/python

import cgi, os
import cgitb; cgitb.enable()

form = cgi.FieldStorage()

# Get filename here.
fileitem = form['filename']

# Test if the file was uploaded
if fileitem.filename:
   # strip leading path from file name to avoid 
   # directory traversal attacks
   fn = os.path.basename(fileitem.filename)
   open('/tmp/' + fn, 'wb').write(fileitem.file.read())

   message = 'The file "' + fn + '" was uploaded successfully'
   
else:
   message = 'No file was uploaded'
   
print """\
Content-Type: text/html\n
<html>
<body>
   <p>%s</p>
</body>
</html>
""" % (message,)

Se esegui lo script sopra su Unix / Linux, devi occuparti di sostituire il separatore di file come segue, altrimenti sulla tua macchina Windows sopra l'istruzione open () dovrebbe funzionare bene.

fn = os.path.basename(fileitem.filename.replace("\\", "/" ))

Come aprire una finestra di dialogo "Download file"?

A volte, si desidera fornire un'opzione in cui un utente può fare clic su un collegamento e verrà visualizzata una finestra di dialogo "Download file" per l'utente invece di visualizzare il contenuto effettivo. Questo è molto semplice e può essere ottenuto tramite l'intestazione HTTP. Questa intestazione HTTP è diversa dall'intestazione menzionata nella sezione precedente.

Ad esempio, se vuoi creare un file FileName file scaricabile da un determinato collegamento, la sua sintassi è la seguente:

#!/usr/bin/python

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go here.
fo = open("foo.txt", "rb")

str = fo.read();
print str

# Close opend file
fo.close()

Spero ti sia piaciuto questo tutorial. Se sì, inviami il tuo feedback a: Contattaci

Lo standard Python per le interfacce di database è l'API DB Python. La maggior parte delle interfacce di database Python aderisce a questo standard.

Puoi scegliere il database giusto per la tua applicazione. Python Database API supporta un'ampia gamma di server database come:

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

Ecco l'elenco delle interfacce di database Python disponibili: Interfacce di database Python e API . Devi scaricare un modulo API DB separato per ogni database a cui devi accedere. Ad esempio, se è necessario accedere a un database Oracle nonché a un database MySQL, è necessario scaricare sia i moduli di database Oracle che MySQL.

L'API DB fornisce uno standard minimo per lavorare con i database utilizzando strutture e sintassi Python ove possibile. Questa API include quanto segue:

• Importazione del modulo API.
• Acquisizione di una connessione con il database.
• Emissione di istruzioni SQL e stored procedure.
• Chiusura della connessione

Impareremmo tutti i concetti usando MySQL, quindi parliamo del modulo MySQLdb.

Cos'è MySQLdb?

MySQLdb è un'interfaccia per la connessione a un server di database MySQL da Python. Implementa l'API del database Python v2.0 ed è basata sull'API C di MySQL.

Come installo MySQLdb?

Prima di procedere, assicurati di avere MySQLdb installato sulla tua macchina. Basta digitare quanto segue nel tuo script Python ed eseguirlo -

#!/usr/bin/python

import MySQLdb

Se produce il seguente risultato, significa che il modulo MySQLdb non è installato -

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      import MySQLdb
ImportError: No module named MySQLdb

Per installare il modulo MySQLdb, usa il seguente comando:

For Ubuntu, use the following command -
$ sudo apt-get install python-pip python-dev libmysqlclient-dev For Fedora, use the following command - $ sudo dnf install python python-devel mysql-devel redhat-rpm-config gcc
For Python command prompt, use the following command -
pip install MySQL-python

Note - Assicurati di avere i privilegi di root per installare il modulo sopra.

Connessione al database

Prima di connetterti a un database MySQL, assicurati di quanto segue:

• Hai creato un database TESTDB.

• Hai creato una tabella EMPLOYEE in TESTDB.

• Questa tabella ha i campi FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

• L'ID utente "testuser" e la password "test123" sono impostati per accedere a TESTDB.

• Il modulo Python MySQLdb è installato correttamente sulla tua macchina.

• Hai seguito il tutorial di MySQL per comprendere le basi di MySQL.

Esempio

Di seguito è riportato l'esempio di connessione con il database MySQL "TESTDB"

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print "Database version : %s " % data

# disconnect from server
db.close()

Durante l'esecuzione di questo script, produce il seguente risultato nella mia macchina Linux.

Database version : 5.0.45

Se viene stabilita una connessione con l'origine dati, viene restituito e salvato un oggetto connessione in db per un ulteriore utilizzo, altrimenti dbè impostato su Nessuno. Il prossimo,db oggetto viene utilizzato per creare un file cursoroggetto, che a sua volta viene utilizzato per eseguire query SQL. Infine, prima di uscire, assicura che la connessione al database sia chiusa e le risorse vengano rilasciate.

Creazione della tabella del database

Una volta stabilita una connessione al database, siamo pronti per creare tabelle o record nelle tabelle del database utilizzando execute metodo del cursore creato.

Esempio

Creiamo la tabella del database DIPENDENTE -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

Operazione INSERT

È necessario quando si desidera creare i record in una tabella di database.

Esempio

Il seguente esempio, esegue l' istruzione SQL INSERT per creare un record nella tabella EMPLOYEE -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

L'esempio sopra può essere scritto come segue per creare query SQL dinamicamente:

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Esempio

Il seguente segmento di codice è un'altra forma di esecuzione in cui è possibile passare direttamente i parametri -

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

Operazione READ

READ Operare su qualsiasi database significa prelevare alcune informazioni utili dal database.

Una volta stabilita la connessione al database, sei pronto per eseguire una query in questo database. Puoi usare entrambifetchone() metodo per recuperare un singolo record o fetchall() metodo per fetech più valori da una tabella di database.

• fetchone()- Recupera la riga successiva di un set di risultati di query. Un set di risultati è un oggetto restituito quando un oggetto cursore viene utilizzato per interrogare una tabella.

• fetchall()- Recupera tutte le righe in un set di risultati. Se alcune righe sono già state estratte dal set di risultati, recupera le righe rimanenti dal set di risultati.

• rowcount - Questo è un attributo di sola lettura e restituisce il numero di righe che sono state influenzate da un metodo execute ().

Esempio

La seguente procedura interroga tutti i record dalla tabella DIPENDENTE con stipendio superiore a 1000 -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
             (fname, lname, age, sex, income )
except:
   print "Error: unable to fecth data"

# disconnect from server
db.close()

Questo produrrà il seguente risultato:

fname=Mac, lname=Mohan, age=20, sex=M, income=2000

Operazione di aggiornamento

AGGIORNAMENTO Operare su qualsiasi database significa aggiornare uno o più record, già disponibili nel database.

La seguente procedura aggiorna tutti i record con SEX come 'M'. Qui, aumentiamo l'ETÀ di tutti i maschi di un anno.

Esempio

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Operazione DELETE

L'operazione DELETE è necessaria quando si desidera eliminare alcuni record dal database. Di seguito è riportata la procedura per eliminare tutti i record da DIPENDENTE in cui ETÀ è superiore a 20 -

Esempio

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Esecuzione di transazioni

Le transazioni sono un meccanismo che garantisce la coerenza dei dati. Le transazioni hanno le seguenti quattro proprietà:

• Atomicity - O una transazione viene completata o non accade nulla.

• Consistency - Una transazione deve iniziare in uno stato coerente e lasciare il sistema in uno stato coerente.

• Isolation - I risultati intermedi di una transazione non sono visibili al di fuori della transazione corrente.

• Durability - Una volta che una transazione è stata confermata, gli effetti sono persistenti, anche dopo un errore di sistema.

Python DB API 2.0 fornisce due metodi per eseguire il commit o il rollback di una transazione.

Esempio

Sai già come implementare le transazioni. Ecco di nuovo un esempio simile:

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

Operazione COMMIT

Commit è l'operazione, che dà un segnale verde al database per finalizzare le modifiche e, dopo questa operazione, nessuna modifica può essere ripristinata.

Ecco un semplice esempio da chiamare commit metodo.

db.commit()

Operazione ROLLBACK

Se non sei soddisfatto di una o più modifiche e desideri ripristinare completamente tali modifiche, utilizza rollback() metodo.

Ecco un semplice esempio da chiamare rollback() metodo.

db.rollback()

Disconnessione del database

Per disconnettere la connessione al database, utilizzare il metodo close ().

db.close()

Se la connessione a un database viene chiusa dall'utente con il metodo close (), tutte le transazioni in sospeso vengono annullate dal DB. Tuttavia, invece di dipendere da uno qualsiasi dei dettagli di implementazione di livello inferiore di DB, l'applicazione farebbe meglio a chiamare esplicitamente il commit o il rollback.

Gestione degli errori

Esistono molte fonti di errore. Alcuni esempi sono un errore di sintassi in un'istruzione SQL eseguita, un errore di connessione o la chiamata del metodo fetch per un handle di istruzione già annullato o terminato.

L'API DB definisce una serie di errori che devono esistere in ogni modulo di database. La tabella seguente elenca queste eccezioni.

Sr.No.	Eccezione e descrizione
1	Warning Utilizzato per problemi non fatali. Deve essere sottoclasse StandardError.
2	Error Classe base per errori. Deve essere sottoclasse StandardError.
3	InterfaceError Utilizzato per errori nel modulo database, non nel database stesso. Errore di sottoclasse.
4	DatabaseError Utilizzato per errori nel database. Errore di sottoclasse.
5	DataError Sottoclasse di DatabaseError che fa riferimento a errori nei dati.
6	OperationalError Sottoclasse di DatabaseError che fa riferimento a errori come la perdita di una connessione al database. Questi errori sono generalmente fuori dal controllo dello scripter Python.
7	IntegrityError Sottoclasse di DatabaseError per situazioni che danneggerebbero l'integrità relazionale, come vincoli di unicità o chiavi esterne.
8	InternalError Sottoclasse di DatabaseError che fa riferimento a errori interni al modulo database, come ad esempio un cursore non più attivo.
9	ProgrammingError Sottoclasse di DatabaseError che fa riferimento a errori come un nome di tabella errato e altre cose che possono essere tranquillamente incolpate su di te.
10	NotSupportedError Sottoclasse di DatabaseError che si riferisce al tentativo di chiamare funzionalità non supportate.

I tuoi script Python dovrebbero gestire questi errori, ma prima di usare una qualsiasi delle eccezioni precedenti, assicurati che il tuo MySQLdb abbia il supporto per quell'eccezione. Puoi ottenere maggiori informazioni su di loro leggendo la specifica DB API 2.0.

Python fornisce due livelli di accesso ai servizi di rete. A un livello basso, è possibile accedere al supporto socket di base nel sistema operativo sottostante, che consente di implementare client e server per protocolli orientati alla connessione e senza connessione.

Python dispone anche di librerie che forniscono un accesso di livello superiore a specifici protocolli di rete a livello di applicazione, come FTP, HTTP e così via.

Questo capitolo fornisce informazioni sui concetti più famosi di Networking - Socket Programming.

Cosa sono i socket?

I socket sono gli endpoint di un canale di comunicazione bidirezionale. I socket possono comunicare all'interno di un processo, tra processi sulla stessa macchina o tra processi su continenti diversi.

I socket possono essere implementati su diversi tipi di canali: socket di dominio Unix, TCP, UDP e così via. La libreria socket fornisce classi specifiche per la gestione dei trasporti comuni, nonché un'interfaccia generica per la gestione del resto.

Le prese hanno il loro vocabolario -

Sr.No.	Termine e descrizione
1	Domain La famiglia di protocolli utilizzata come meccanismo di trasporto. Questi valori sono costanti come AF_INET, PF_INET, PF_UNIX, PF_X25 e così via.
2	type Il tipo di comunicazione tra i due endpoint, in genere SOCK_STREAM per i protocolli orientati alla connessione e SOCK_DGRAM per i protocolli senza connessione.
3	protocol Tipicamente zero, può essere utilizzato per identificare una variante di un protocollo all'interno di un dominio e tipo.
4	hostname L'identificatore di un'interfaccia di rete - Una stringa, che può essere un nome host, un indirizzo con quattro punti o un indirizzo IPV6 in notazione con due punti (e possibilmente con un punto) Una stringa "<broadcast>", che specifica un indirizzo INADDR_BROADCAST. Una stringa di lunghezza zero, che specifica INADDR_ANY o Un numero intero, interpretato come un indirizzo binario nell'ordine dei byte dell'host.
5	port Ogni server ascolta i client che chiamano su una o più porte. Una porta può essere un numero di porta Fixnum, una stringa contenente un numero di porta o il nome di un servizio.

Il modulo socket

Per creare un socket, è necessario utilizzare la funzione socket.socket () disponibile nel modulo socket , che ha la sintassi generale -

s = socket.socket (socket_family, socket_type, protocol=0)

Ecco la descrizione dei parametri:

• socket_family - Questo è AF_UNIX o AF_INET, come spiegato in precedenza.

• socket_type - Questo è SOCK_STREAM o SOCK_DGRAM.

• protocol - Questo di solito viene omesso, il valore predefinito è 0.

Dopo aver ottenuto l' oggetto socket , è possibile utilizzare le funzioni richieste per creare il programma client o server. Di seguito è riportato l'elenco delle funzioni richieste:

Metodi socket server

Sr.No.	Metodo e descrizione
1	s.bind() Questo metodo associa l'indirizzo (nome host, coppia di numeri di porta) al socket.
2	s.listen() Questo metodo imposta e avvia il listener TCP.
3	s.accept() Questo accetta passivamente la connessione client TCP, in attesa dell'arrivo della connessione (blocco).

Metodi socket client

Sr.No.	Metodo e descrizione
1	s.connect() Questo metodo avvia attivamente la connessione al server TCP.

Metodi socket generali

Sr.No.	Metodo e descrizione
1	s.recv() Questo metodo riceve il messaggio TCP
2	s.send() Questo metodo trasmette il messaggio TCP
3	s.recvfrom() Questo metodo riceve il messaggio UDP
4	s.sendto() Questo metodo trasmette il messaggio UDP
5	s.close() Questo metodo chiude il socket
6	socket.gethostname() Restituisce il nome host.

Un semplice server

Per scrivere server Internet, utilizziamo il socketfunzione disponibile nel modulo socket per creare un oggetto socket. Un oggetto socket viene quindi utilizzato per chiamare altre funzioni per configurare un server socket.

Adesso chiama bind(hostname, port)funzione per specificare una porta per il servizio sull'host specificato.

Quindi, chiama il metodo di accettazione dell'oggetto restituito. Questo metodo attende che un client si connetta alla porta specificata, quindi restituisce un oggetto di connessione che rappresenta la connessione a quel client.

#!/usr/bin/python           # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

Un semplice cliente

Scriviamo un programma client molto semplice che apra una connessione a una data porta 12345 e un determinato host. È molto semplice creare un client socket utilizzando la funzione del modulo socket di Python .

Il socket.connect(hosname, port )apre una connessione TCP al nome host sulla porta . Una volta aperto un socket, puoi leggere da esso come qualsiasi oggetto IO. Quando hai finito, ricordati di chiuderlo, come faresti per chiudere un file.

Il codice seguente è un client molto semplice che si connette a un determinato host e porta, legge tutti i dati disponibili dal socket e quindi esce:

#!/usr/bin/python           # This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close()                  # Close the socket when done

Ora esegui questo server.py in background e poi esegui sopra client.py per vedere il risultato.

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

Ciò produrrebbe il seguente risultato:

Got connection from ('127.0.0.1', 48437)
Thank you for connecting

Moduli Internet Python

Un elenco di alcuni moduli importanti nella programmazione di rete / Internet Python.

Protocollo	Funzione comune	Porta n	Modulo Python
HTTP	pagine web	80	httplib, urllib, xmlrpclib
NNTP	Notizie Usenet	119	nntplib
FTP	Trasferimenti di file	20	ftplib, urllib
SMTP	Invio di e-mail	25	smtplib
POP3	Recupero email	110	poplib
IMAP4	Recupero email	143	imaplib
Telnet	Righe di comando	23	telnetlib
Gopher	Trasferimenti di documenti	70	gopherlib, urllib

Controlla tutte le librerie sopra menzionate per funzionare con i protocolli FTP, SMTP, POP e IMAP.

Ulteriori letture

Questo è stato un rapido inizio con Socket Programming. È un argomento vasto. Si consiglia di passare attraverso il seguente collegamento per trovare maggiori dettagli:

• Programmazione socket Unix .

• Libreria e moduli Python Socket .

Il protocollo SMTP (Simple Mail Transfer Protocol) è un protocollo che gestisce l'invio di posta elettronica e il routing della posta tra i server di posta.

Python fornisce smtplib modulo, che definisce un oggetto di sessione client SMTP che può essere utilizzato per inviare posta a qualsiasi macchina Internet con un daemon listener SMTP o ESMTP.

Ecco una semplice sintassi per creare un oggetto SMTP, che può essere successivamente utilizzato per inviare un'e-mail:

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

Ecco il dettaglio dei parametri -

• host- Questo è l'host che esegue il tuo server SMTP. Puoi specificare l'indirizzo IP dell'host o un nome di dominio come tutorialspoint.com. Questo è un argomento opzionale.

• port- Se si fornisce l' argomento host , è necessario specificare una porta su cui è in ascolto il server SMTP. Di solito questa porta sarebbe 25.

• local_hostname- Se il tuo server SMTP è in esecuzione sulla tua macchina locale, puoi specificare solo localhost a partire da questa opzione.

Un oggetto SMTP dispone di un metodo di istanza chiamato sendmail, che viene generalmente utilizzato per eseguire il lavoro di spedizione di un messaggio. Ci vogliono tre parametri:

• Il mittente : una stringa con l'indirizzo del mittente.

• I destinatari : un elenco di stringhe, una per ogni destinatario.

• Il messaggio - Un messaggio sotto forma di stringa formattata come specificato nelle varie RFC.

Esempio

Ecco un modo semplice per inviare un'e-mail utilizzando lo script Python. Provalo una volta -

#!/usr/bin/python

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Qui, hai inserito una semplice e-mail nel messaggio, usando una virgoletta tripla, avendo cura di formattare correttamente le intestazioni. Un'e-mail richiede unFrom, To, e Subject intestazione, separata dal corpo dell'e-mail con una riga vuota.

Per inviare la posta si utilizza smtpObj per connettersi al server SMTP sulla macchina locale e quindi utilizzare il metodo sendmail insieme al messaggio, l'indirizzo del mittente e l'indirizzo di destinazione come parametri (anche se gli indirizzi da e a sono all'interno del -mail stessa, questi non sono sempre usati per instradare la posta).

Se non si esegue un server SMTP sulla macchina locale, è possibile utilizzare il client smtplib per comunicare con un server SMTP remoto. A meno che tu non stia utilizzando un servizio di webmail (come Hotmail o Yahoo! Mail), il tuo provider di posta elettronica deve averti fornito i dettagli del server di posta in uscita che puoi fornire, come segue:

smtplib.SMTP('mail.your-domain.com', 25)

Invio di un'e-mail HTML utilizzando Python

Quando invii un messaggio di testo utilizzando Python, tutto il contenuto viene trattato come testo semplice. Anche se includi tag HTML in un messaggio di testo, questo viene visualizzato come testo semplice ei tag HTML non verranno formattati secondo la sintassi HTML. Ma Python fornisce l'opzione per inviare un messaggio HTML come messaggio HTML effettivo.

Durante l'invio di un messaggio di posta elettronica, è possibile specificare una versione Mime, un tipo di contenuto e un set di caratteri per inviare un messaggio di posta elettronica HTML.

Esempio

Di seguito è riportato l'esempio per inviare contenuto HTML come posta elettronica. Provalo una volta -

#!/usr/bin/python

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Invio di allegati come e-mail

Per inviare un'e-mail con contenuto misto è necessario impostare Content-type intestazione a multipart/mixed. Quindi, le sezioni di testo e allegato possono essere specificate all'internoboundaries.

Un confine inizia con due trattini seguiti da un numero univoco, che non può comparire nella parte del messaggio del messaggio di posta elettronica. Anche un confine finale che denota la sezione finale del messaggio di posta elettronica deve terminare con due trattini.

I file allegati dovrebbero essere codificati con l'estensione pack("m") funzione per avere la codifica base64 prima della trasmissione.

Esempio

Di seguito è riportato l'esempio, che invia un file /tmp/test.txtcome un allegato. Provalo una volta -

#!/usr/bin/python

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print "Error: unable to send email"

L'esecuzione di più thread è simile all'esecuzione di più programmi diversi contemporaneamente, ma con i seguenti vantaggi:

• Più thread all'interno di un processo condividono lo stesso spazio dati con il thread principale e possono quindi condividere informazioni o comunicare tra loro più facilmente rispetto a se fossero processi separati.

• I thread a volte vengono chiamati processi leggeri e non richiedono molto overhead di memoria; sono più economici dei processi.

Un thread ha un inizio, una sequenza di esecuzione e una conclusione. Ha un puntatore di istruzioni che tiene traccia di dove è attualmente in esecuzione nel suo contesto.

• Può essere anticipato (interrotto)

• Può essere temporaneamente messo in attesa (noto anche come sleep) mentre altri thread sono in esecuzione - questo è chiamato cedimento.

Avvio di una nuova discussione

Per generare un altro thread, è necessario chiamare il seguente metodo disponibile nel modulo thread :

thread.start_new_thread ( function, args[, kwargs] )

Questa chiamata al metodo consente un modo rapido ed efficiente per creare nuovi thread sia in Linux che in Windows.

La chiamata al metodo ritorna immediatamente e il thread figlio si avvia e chiama la funzione con l'elenco passato di argomenti . Quando la funzione ritorna, il thread termina.

Qui, args è una tupla di argomenti; usa una tupla vuota per chiamare la funzione senza passare alcun argomento. kwargs è un dizionario opzionale di argomenti di parole chiave.

Esempio

#!/usr/bin/python

import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"

while 1:
   pass

Quando il codice sopra viene eseguito, produce il seguente risultato:

Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

Sebbene sia molto efficace per il threading di basso livello, il modulo thread è molto limitato rispetto al modulo di threading più recente.

Il modulo di filettatura

Il nuovo modulo di threading incluso con Python 2.4 fornisce un supporto molto più potente e di alto livello per i thread rispetto al modulo thread discusso nella sezione precedente.

Il modulo threading espone tutti i metodi del modulo thread e fornisce alcuni metodi aggiuntivi -

• threading.activeCount() - Restituisce il numero di oggetti thread attivi.

• threading.currentThread() - Restituisce il numero di oggetti thread nel controllo thread del chiamante.

• threading.enumerate() - Restituisce un elenco di tutti gli oggetti thread attualmente attivi.

Oltre ai metodi, il modulo threading ha la classe Thread che implementa il threading. I metodi forniti dalla classe Thread sono i seguenti:

• run() - Il metodo run () è il punto di ingresso per un thread.

• start() - Il metodo start () avvia un thread chiamando il metodo run.

• join([time]) - Il join () attende che i thread terminino.

• isAlive() - Il metodo isAlive () controlla se un thread è ancora in esecuzione.

• getName() - Il metodo getName () restituisce il nome di un thread.

• setName() - Il metodo setName () imposta il nome di un thread.

Creazione di thread utilizzando il modulo di threading

Per implementare un nuovo thread utilizzando il modulo threading, devi fare quanto segue:

• Definisci una nuova sottoclasse della classe Thread .

• Sostituisci il metodo __init __ (self [, args]) per aggiungere ulteriori argomenti.

• Quindi, sovrascrivi il metodo run (self [, args]) per implementare ciò che il thread dovrebbe fare all'avvio.

Dopo aver creato la nuova sottoclasse Thread , è possibile crearne un'istanza e quindi avviare un nuovo thread invocando start () , che a sua volta chiama il metodo run () .

Esempio

#!/usr/bin/python

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      print_time(self.name, self.counter, 5)
      print "Exiting " + self.name

def print_time(threadName, counter, delay):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

print "Exiting Main Thread"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2

Sincronizzazione dei thread

Il modulo di threading fornito con Python include un meccanismo di blocco semplice da implementare che consente di sincronizzare i thread. Viene creato un nuovo blocco chiamando il metodo Lock () , che restituisce il nuovo blocco.

Il metodo di acquisizione (blocco) del nuovo oggetto blocco viene utilizzato per forzare l'esecuzione dei thread in modo sincrono. Il parametro di blocco facoltativo consente di controllare se il thread attende di acquisire il blocco.

Se il blocco è impostato a 0, il thread ritorna immediatamente con un valore 0 se il blocco non può essere acquisito e con un 1 se il blocco è stato acquisito. Se il blocco è impostato su 1, il thread si blocca e attende che il blocco venga rilasciato.

Il metodo release () del nuovo oggetto lock viene utilizzato per rilasciare il lock quando non è più necessario.

Esempio

#!/usr/bin/python

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

Coda prioritaria multithread

Il modulo Coda consente di creare un nuovo oggetto coda che può contenere un numero specifico di elementi. Esistono i seguenti metodi per controllare la coda:

• get() - Il get () rimuove e restituisce un elemento dalla coda.

• put() - Il put aggiunge l'elemento a una coda.

• qsize() - Il qsize () restituisce il numero di elementi attualmente in coda.

• empty()- Il empty () restituisce True se la coda è vuota; in caso contrario, False.

• full()- full () restituisce True se la coda è piena; in caso contrario, False.

Esempio

#!/usr/bin/python

import Queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print "Starting " + self.name
      process_data(self.name, self.q)
      print "Exiting " + self.name

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
         if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
         else:
            queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print "Exiting Main Thread"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

XML è un linguaggio portatile e open source che consente ai programmatori di sviluppare applicazioni che possono essere lette da altre applicazioni, indipendentemente dal sistema operativo e / o dal linguaggio di sviluppo.

Cos'è l'XML?

L'Extensible Markup Language (XML) è un linguaggio di markup molto simile a HTML o SGML. Questo è consigliato dal World Wide Web Consortium e disponibile come standard aperto.

XML è estremamente utile per tenere traccia di piccole e medie quantità di dati senza richiedere un backbone basato su SQL.

API e architetture di parser XML

La libreria standard Python fornisce un insieme minimo ma utile di interfacce per lavorare con XML.

Le due API più semplici e ampiamente utilizzate per i dati XML sono le interfacce SAX e DOM.

• Simple API for XML (SAX)- Qui si registrano i callback per gli eventi di interesse e quindi si lascia che il parser proceda attraverso il documento. Questo è utile quando i tuoi documenti sono grandi o hai limitazioni di memoria, analizza il file mentre lo legge dal disco e l'intero file non viene mai archiviato in memoria.

• Document Object Model (DOM) API - Questa è una raccomandazione del World Wide Web Consortium in cui l'intero file viene letto in memoria e archiviato in una forma gerarchica (basata su albero) per rappresentare tutte le caratteristiche di un documento XML.

Ovviamente SAX non può elaborare le informazioni alla velocità di DOM quando si lavora con file di grandi dimensioni. D'altra parte, l'uso esclusivo di DOM può davvero uccidere le tue risorse, specialmente se usato su molti piccoli file.

SAX è di sola lettura, mentre DOM consente modifiche al file XML. Poiché queste due API diverse si completano letteralmente a vicenda, non c'è motivo per cui non puoi usarle entrambe per progetti di grandi dimensioni.

Per tutti i nostri esempi di codice XML, utilizziamo un semplice file XML movies.xml come input -

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

Analisi XML con API SAX

SAX è un'interfaccia standard per l'analisi XML guidata dagli eventi. L'analisi di XML con SAX generalmente richiede di creare il proprio ContentHandler sottoclassando xml.sax.ContentHandler.

Il tuo ContentHandler gestisce i tag e gli attributi particolari delle tue versioni di XML. Un oggetto ContentHandler fornisce metodi per gestire vari eventi di analisi. Il suo parser di proprietà chiama i metodi ContentHandler mentre analizza il file XML.

I metodi startDocument e endDocument vengono chiamati all'inizio e alla fine del file XML. I caratteri del metodo (testo) vengono passati ai dati dei caratteri del file XML tramite il testo del parametro.

ContentHandler viene chiamato all'inizio e alla fine di ogni elemento. Se il parser non è in modalità spazio dei nomi, vengono chiamati i metodi startElement (tag, attributi) e endElement (tag) ; in caso contrario, vengono chiamati i metodi corrispondenti startElementNS e endElementNS . In questo caso, tag è il tag dell'elemento e attributes è un oggetto Attributes.

Ecco altri metodi importanti da capire prima di procedere:

Il metodo make_parser

Il metodo seguente crea un nuovo oggetto parser e lo restituisce. L'oggetto parser creato sarà del primo tipo di parser trovato dal sistema.

xml.sax.make_parser( [parser_list] )

Ecco il dettaglio dei parametri -

• parser_list - L'argomento opzionale costituito da un elenco di parser da utilizzare che devono implementare tutti il ​​metodo make_parser.

Il metodo di analisi

Il seguente metodo crea un parser SAX e lo utilizza per analizzare un documento.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

Ecco il dettaglio dei parametri -

• xmlfile - Questo è il nome del file XML da cui leggere.

• contenthandler - Deve essere un oggetto ContentHandler.

• errorhandler - Se specificato, il gestore degli errori deve essere un oggetto SAX ErrorHandler.

Il metodo parseString

C'è un altro metodo per creare un parser SAX e per analizzare il file specificato XML string.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

Ecco il dettaglio dei parametri -

• xmlstring - Questo è il nome della stringa XML da cui leggere.

• contenthandler - Deve essere un oggetto ContentHandler.

• errorhandler - Se specificato, il gestore degli errori deve essere un oggetto SAX ErrorHandler.

Esempio

#!/usr/bin/python

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print "*****Movie*****"
         title = attributes["title"]
         print "Title:", title

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print "Type:", self.type
      elif self.CurrentData == "format":
         print "Format:", self.format
      elif self.CurrentData == "year":
         print "Year:", self.year
      elif self.CurrentData == "rating":
         print "Rating:", self.rating
      elif self.CurrentData == "stars":
         print "Stars:", self.stars
      elif self.CurrentData == "description":
         print "Description:", self.description
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

Ciò produrrebbe il seguente risultato:

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

Per un dettaglio completo sulla documentazione dell'API SAX, fare riferimento alle API SAX Python standard .

Analisi XML con API DOM

Il Document Object Model ("DOM") è un'API cross-language del World Wide Web Consortium (W3C) per l'accesso e la modifica di documenti XML.

Il DOM è estremamente utile per le applicazioni ad accesso casuale. SAX consente solo una visualizzazione di un bit del documento alla volta. Se stai guardando un elemento SAX, non hai accesso a un altro.

Ecco il modo più semplice per caricare rapidamente un documento XML e creare un oggetto minidom utilizzando il modulo xml.dom. L'oggetto minidom fornisce un semplice metodo parser che crea rapidamente un albero DOM dal file XML.

La frase di esempio chiama la funzione parse (file [, parser]) dell'oggetto minidom per analizzare il file XML designato da file in un oggetto albero DOM.

#!/usr/bin/python

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print "Root element : %s" % collection.getAttribute("shelf")

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print "*****Movie*****"
   if movie.hasAttribute("title"):
      print "Title: %s" % movie.getAttribute("title")

   type = movie.getElementsByTagName('type')[0]
   print "Type: %s" % type.childNodes[0].data
   format = movie.getElementsByTagName('format')[0]
   print "Format: %s" % format.childNodes[0].data
   rating = movie.getElementsByTagName('rating')[0]
   print "Rating: %s" % rating.childNodes[0].data
   description = movie.getElementsByTagName('description')[0]
   print "Description: %s" % description.childNodes[0].data

Ciò produrrebbe il seguente risultato:

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Per un dettaglio completo sulla documentazione dell'API DOM, fare riferimento alle API DOM Python standard .

Python fornisce varie opzioni per lo sviluppo di interfacce utente grafiche (GUI). I più importanti sono elencati di seguito.

• Tkinter- Tkinter è l'interfaccia Python per il toolkit GUI Tk fornito con Python. Guarderemo questa opzione in questo capitolo.

• wxPython - Questa è un'interfaccia Python open source per wxWindows http://wxpython.org.

• JPython - JPython è una porta Python per Java che fornisce agli script Python un accesso senza interruzioni alle librerie di classi Java sulla macchina locale http://www.jython.org.

Sono disponibili molte altre interfacce, che puoi trovare in rete.

Programmazione Tkinter

Tkinter è la libreria GUI standard per Python. Python, se combinato con Tkinter, fornisce un modo semplice e veloce per creare applicazioni GUI. Tkinter fornisce una potente interfaccia orientata agli oggetti al toolkit della GUI di Tk.

La creazione di un'applicazione GUI utilizzando Tkinter è un'operazione facile. Tutto quello che devi fare è eseguire i seguenti passaggi:

• Importa il modulo Tkinter .

• Crea la finestra principale dell'applicazione GUI.

• Aggiungere uno o più dei widget sopra menzionati all'applicazione GUI.

• Immettere il ciclo di eventi principale per intraprendere un'azione contro ogni evento attivato dall'utente.

Esempio

#!/usr/bin/python

import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

Questo creerebbe una finestra seguente:

Widget di Tkinter

Tkinter fornisce vari controlli, come pulsanti, etichette e caselle di testo utilizzate in un'applicazione GUI. Questi controlli sono comunemente chiamati widget.

Attualmente ci sono 15 tipi di widget in Tkinter. Presentiamo questi widget e una breve descrizione nella tabella seguente:

Sr.No.	Operatore e descrizione
1	Pulsante Il widget Button viene utilizzato per visualizzare i pulsanti nell'applicazione.
2	Tela Il widget Canvas viene utilizzato per disegnare forme, come linee, ovali, poligoni e rettangoli, nell'applicazione.
3	Pulsante di spunta Il widget Checkbutton viene utilizzato per visualizzare una serie di opzioni come caselle di controllo. L'utente può selezionare più opzioni alla volta.
4	Iscrizione Il widget Voce viene utilizzato per visualizzare un campo di testo a riga singola per accettare valori da un utente.
5	Telaio Il widget Frame viene utilizzato come widget contenitore per organizzare altri widget.
6	Etichetta Il widget Etichetta viene utilizzato per fornire una didascalia a riga singola per altri widget. Può anche contenere immagini.
7	Listbox Il widget Listbox viene utilizzato per fornire un elenco di opzioni a un utente.
8	Menubutton Il widget Menubutton viene utilizzato per visualizzare i menu nell'applicazione.
9	Menù Il widget Menu viene utilizzato per fornire vari comandi a un utente. Questi comandi sono contenuti all'interno di Menubutton.
10	Messaggio Il widget Messaggio viene utilizzato per visualizzare campi di testo multilinea per accettare valori da un utente.
11	Radiobutton Il widget Radiobutton viene utilizzato per visualizzare una serie di opzioni come pulsanti radio. L'utente può selezionare solo un'opzione alla volta.
12	Scala Il widget Scala viene utilizzato per fornire un widget di scorrimento.
13	Barra di scorrimento Il widget Barra di scorrimento viene utilizzato per aggiungere funzionalità di scorrimento a vari widget, come le caselle di riepilogo.
14	Testo Il widget Testo viene utilizzato per visualizzare il testo su più righe.
15	Toplevel Il widget Toplevel viene utilizzato per fornire un contenitore di finestre separato.
16	Spinbox Il widget Spinbox è una variante del widget standard Tkinter Entry, che può essere utilizzato per selezionare da un numero fisso di valori.
17	PanedWindow Una PanedWindow è un widget contenitore che può contenere un numero qualsiasi di riquadri, disposti orizzontalmente o verticalmente.
18	LabelFrame Un labelframe è un semplice widget contenitore. Il suo scopo principale è agire come spaziatore o contenitore per layout di finestre complessi.
19	tkMessageBox Questo modulo viene utilizzato per visualizzare le finestre di messaggio nelle applicazioni.

Studiamo questi widget in dettaglio -

Attributi standard

Diamo un'occhiata a come vengono specificati alcuni dei loro attributi comuni, come dimensioni, colori e caratteri.

• Dimensions

• Colors

• Fonts

• Anchors

• Stili in rilievo

• Bitmaps

• Cursors

Studiamoli brevemente:

Gestione della geometria

Tutti i widget di Tkinter hanno accesso a metodi di gestione della geometria specifici, che hanno lo scopo di organizzare i widget in tutta l'area del widget principale. Tkinter espone le seguenti classi di gestione della geometria: pack, grid e place.

• Il metodo pack () - Questo gestore di geometrie organizza i widget in blocchi prima di posizionarli nel widget genitore.

• Il metodo grid () - Questo gestore della geometria organizza i widget in una struttura simile a una tabella nel widget genitore.

• Il metodo place () - Questo gestore della geometria organizza i widget posizionandoli in una posizione specifica nel widget genitore.

Studiamo brevemente i metodi di gestione della geometria:

Qualsiasi codice che scrivi utilizzando qualsiasi linguaggio compilato come C, C ++ o Java può essere integrato o importato in un altro script Python. Questo codice è considerato come una "estensione".

Un modulo di estensione Python non è altro che una normale libreria C. Sulle macchine Unix, queste librerie di solito terminano con.so(per oggetto condiviso). Sulle macchine Windows, in genere vedi.dll (per libreria collegata dinamicamente).

Prerequisiti per la scrittura di estensioni

Per iniziare a scrivere la tua estensione, avrai bisogno dei file di intestazione Python.

• Su macchine Unix, questo di solito richiede l'installazione di un pacchetto specifico per lo sviluppatore come python2.5-dev .

• Gli utenti Windows ottengono queste intestazioni come parte del pacchetto quando usano il programma di installazione binario di Python.

Inoltre, si presume che tu abbia una buona conoscenza di C o C ++ per scrivere qualsiasi estensione Python utilizzando la programmazione C.

Primo sguardo a un'estensione Python

Per il tuo primo sguardo a un modulo di estensione Python, devi raggruppare il tuo codice in quattro parti:

• Il file di intestazione Python.h .

• Le funzioni C che vuoi esporre come interfaccia dal tuo modulo.

• Una tabella che mappa i nomi delle tue funzioni come gli sviluppatori Python li vedono in funzioni C all'interno del modulo di estensione.

• Una funzione di inizializzazione.

Il file di intestazione Python.h

È necessario includere il file di intestazione Python.h nel file sorgente C, che consente di accedere all'API Python interna utilizzata per collegare il modulo all'interprete.

Assicurati di includere Python.h prima di qualsiasi altra intestazione di cui potresti aver bisogno. Devi seguire gli include con le funzioni che vuoi chiamare da Python.

Le funzioni C.

Le firme dell'implementazione C delle tue funzioni assumono sempre una delle tre forme seguenti:

static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

Ciascuna delle dichiarazioni precedenti restituisce un oggetto Python. Non esiste una funzione void in Python come in C.Se non vuoi che le tue funzioni restituiscano un valore, restituisci l'equivalente in C di PythonNonevalore. Le intestazioni Python definiscono una macro, Py_RETURN_NONE, che fa questo per noi.

I nomi delle tue funzioni C possono essere quelli che ti piacciono poiché non sono mai visti al di fuori del modulo di estensione. Sono definiti come funzione statica .

Le tue funzioni C di solito vengono nominate combinando insieme il modulo Python e i nomi delle funzioni, come mostrato qui -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

Questa è una funzione Python chiamata func all'interno del modulo del modulo . Inserirai i puntatori alle tue funzioni C nella tabella dei metodi per il modulo che di solito viene dopo nel tuo codice sorgente.

La tabella di mappatura dei metodi

Questa tabella dei metodi è un semplice array di strutture PyMethodDef. Quella struttura assomiglia a questa -

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

Ecco la descrizione dei membri di questa struttura -

• ml_name - Questo è il nome della funzione che l'interprete Python presenta quando viene utilizzato nei programmi Python.

• ml_meth - Deve essere l'indirizzo di una funzione che ha una delle firme descritte nella sezione precedente.

• ml_flags - Questo dice all'interprete quale delle tre firme ml_meth sta usando.

  • Questo flag ha solitamente un valore di METH_VARARGS.

  • Questo flag può essere impostato con OR bit per bit con METH_KEYWORDS se si desidera consentire argomenti di parole chiave nella funzione.

  • Può anche avere un valore di METH_NOARGS che indica che non si desidera accettare alcun argomento.

• ml_doc - Questa è la docstring per la funzione, che potrebbe essere NULL se non hai voglia di scriverne una.

Questa tabella deve essere terminata con una sentinella composta da valori NULL e 0 per i membri appropriati.

Esempio

Per la funzione sopra definita, abbiamo la seguente tabella di mappatura dei metodi:

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

La funzione di inizializzazione

L'ultima parte del modulo di estensione è la funzione di inizializzazione. Questa funzione viene chiamata dall'interprete Python quando il modulo viene caricato. È necessario che la funzione sia denominatainitModule, dove Module è il nome del modulo.

La funzione di inizializzazione deve essere esportata dalla libreria che stai costruendo. Le intestazioni Python definiscono PyMODINIT_FUNC per includere gli incantesimi appropriati affinché ciò avvenga per il particolare ambiente in cui stiamo compilando. Tutto quello che devi fare è usarlo per definire la funzione.

La tua funzione di inizializzazione C ha generalmente la seguente struttura generale:

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Ecco la descrizione della funzione Py_InitModule3 -

• func - Questa è la funzione da esportare.

• module_methods - Questo è il nome della tabella di mappatura definito sopra.

• docstring - Questo è il commento che vuoi dare nella tua estensione.

Mettere tutto insieme sembra il seguente:

#include <Python.h>

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Esempio

Un semplice esempio che fa uso di tutti i concetti di cui sopra:

#include <Python.h>

static PyObject* helloworld(PyObject* self) {
   return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
   "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
   {"helloworld", (PyCFunction)helloworld, 
      METH_NOARGS, helloworld_docs},
      {NULL}
};

void inithelloworld(void) {
   Py_InitModule3("helloworld", helloworld_funcs,
                  "Extension module example!");
}

Qui la funzione Py_BuildValue viene utilizzata per creare un valore Python. Salva il codice sopra nel file hello.c. Vedremmo come compilare e installare questo modulo da richiamare dallo script Python.

Creazione e installazione di estensioni

Il pacchetto distutils rende molto semplice distribuire moduli Python, sia Python puro che moduli di estensione, in modo standard. I moduli sono distribuiti in formato sorgente e costruiti e installati tramite uno script di installazione solitamente chiamato setup.py come segue.

Per il modulo sopra, è necessario preparare il seguente script setup.py -

from distutils.core import setup, Extension
setup(name='helloworld', version='1.0',  \
      ext_modules=[Extension('helloworld', ['hello.c'])])

Ora, usa il seguente comando, che eseguirà tutti i passaggi necessari di compilazione e collegamento, con i giusti comandi e flag di compilatore e linker, e copia la libreria dinamica risultante in una directory appropriata -

$ python setup.py install

Su sistemi basati su Unix, molto probabilmente sarà necessario eseguire questo comando come root per avere i permessi per scrivere nella directory dei pacchetti del sito. Questo di solito non è un problema su Windows.

Importazione di estensioni

Una volta installata l'estensione, sarai in grado di importare e chiamare quell'estensione nel tuo script Python come segue:

#!/usr/bin/python
import helloworld

print helloworld.helloworld()

Ciò produrrebbe il seguente risultato:

Hello, Python extensions!!

Passaggio di parametri di funzione

Poiché molto probabilmente vorrai definire funzioni che accettano argomenti, puoi usare una delle altre firme per le tue funzioni C. Ad esempio, la seguente funzione, che accetta un certo numero di parametri, sarebbe definita in questo modo:

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Parse args and do something interesting here. */
   Py_RETURN_NONE;
}

La tabella dei metodi contenente una voce per la nuova funzione sarebbe simile a questa:

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};

È possibile utilizzare la funzione API PyArg_ParseTuple per estrarre gli argomenti dall'unico puntatore PyObject passato alla funzione C.

Il primo argomento di PyArg_ParseTuple è l'argomento args. Questo è l'oggetto verrà parsing . Il secondo argomento è una stringa di formato che descrive gli argomenti come ci si aspetta che appaiano. Ogni argomento è rappresentato da uno o più caratteri nella stringa di formato come segue.

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }
   
   /* Do something interesting here. */
   Py_RETURN_NONE;
}

La compilazione della nuova versione del modulo e l'importazione consente di invocare la nuova funzione con un numero qualsiasi di argomenti di qualsiasi tipo -

module.func(1, s="three", d=2.0)
module.func(i=1, d=2.0, s="three")
module.func(s="three", d=2.0, i=1)

Probabilmente puoi inventare ancora più varianti.

La funzione PyArg_ParseTuple

Ecco la firma standard per PyArg_ParseTuple funzione -

int PyArg_ParseTuple(PyObject* tuple,char* format,...)

Questa funzione restituisce 0 per gli errori e un valore diverso da 0 per l'esito positivo. tuple è il PyObject * che era il secondo argomento della funzione C. Qui il formato è una stringa C che descrive argomenti obbligatori e facoltativi.

Di seguito è riportato un elenco di codici di formato per PyArg_ParseTuple funzione -

Codice	Tipo C.	Senso
c	char	Una stringa Python di lunghezza 1 diventa un carattere C.
d	Doppio	Un float Python diventa un C double.
f	galleggiante	Un float Python diventa un float C.
io	int	Un Python int diventa un C int.
l	lungo	Un int Python diventa un C long.
L	lungo lungo	Un int Python diventa un C long long
O	PyObject *	Ottiene un riferimento preso in prestito non NULL all'argomento Python.
S	char *	Stringa Python senza null incorporati in C char *.
S#	char * + int	Qualsiasi stringa Python in C indirizzo e lunghezza.
t #	char * + int	Buffer a segmento singolo di sola lettura per indirizzo e lunghezza C.
u	Py_UNICODE *	Python Unicode senza null incorporati in C.
u #	Py_UNICODE * + int	Qualsiasi indirizzo e lunghezza Python Unicode C.
w #	char * + int	Lettura / scrittura del buffer a segmento singolo nell'indirizzo e nella lunghezza C.
z	char *	Come s, accetta anche None (imposta C char * su NULL).
z #	char * + int	Come s #, accetta anche None (imposta C char * su NULL).
(...)	come da ...	Una sequenza Python viene trattata come un argomento per elemento.
|		I seguenti argomenti sono facoltativi.
:		Fine del formato, seguito dal nome della funzione per i messaggi di errore.
;		Fine del formato, seguito dall'intero testo del messaggio di errore.

Valori restituiti

Py_BuildValue accetta una stringa di formato molto simile a PyArg_ParseTuple . Invece di passare gli indirizzi dei valori che stai costruendo, passi i valori effettivi. Ecco un esempio che mostra come implementare una funzione di aggiunta:

static PyObject *foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

Questo è come sarebbe se implementato in Python -

def add(a, b):
   return (a + b)

Puoi restituire due valori dalla tua funzione come segue, ciò sarebbe causato usando un elenco in Python.

static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("ii", a + b, a - b);
}

Questo è come sarebbe se implementato in Python -

def add_subtract(a, b):
   return (a + b, a - b)

La funzione Py_BuildValue

Ecco la firma standard per Py_BuildValue funzione -

PyObject* Py_BuildValue(char* format,...)

Il formato qui è una stringa C che descrive l'oggetto Python da costruire. I seguenti argomenti di Py_BuildValue sono valori C da cui viene creato il risultato. Il risultato di PyObject * è un nuovo riferimento.

La tabella seguente elenca le stringhe di codice comunemente utilizzate, di cui zero o più vengono unite in formato stringa.

Codice	Tipo C.	Senso
c	char	AC char diventa una stringa Python di lunghezza 1.
d	Doppio	AC double diventa un float Python.
f	galleggiante	AC float diventa un Python float.
io	int	AC int diventa un Python int.
l	lungo	AC long diventa un int Python.
N	PyObject *	Passa un oggetto Python e ruba un riferimento.
O	PyObject *	Passa un oggetto Python e lo INCREF normalmente.
O &	converti + void *	Conversione arbitraria
S	char *	C 0-terminated char * to Python string, or NULL to None.
S#	char * + int	Carattere C * e lunghezza alla stringa Python o NULL a Nessuno.
u	Py_UNICODE *	Stringa C-wide, con terminazione null in Python Unicode o NULL in None.
u #	Py_UNICODE * + int	Stringa C-wide e lunghezza su Python Unicode o NULL su None.
w #	char * + int	Lettura / scrittura del buffer a segmento singolo nell'indirizzo e nella lunghezza C.
z	char *	Come s, accetta anche None (imposta C char * su NULL).
z #	char * + int	Come s #, accetta anche None (imposta C char * su NULL).
(...)	come da ...	Compila la tupla Python dai valori C.
[...]	come da ...	Crea un elenco Python da valori C.
{...}	come da ...	Costruisce il dizionario Python da valori C, alternando chiavi e valori.

Il codice {...} crea dizionari da un numero pari di valori C, alternativamente chiavi e valori. Ad esempio, Py_BuildValue ("{issi}", 23, "zig", "zag", 42) restituisce un dizionario come {23: 'zig', 'zag': 42} di Python.