Python Language Tutorial
Iniziare con Python Language

Osservazioni

Versioni

Iniziare

Python è un linguaggio di programmazione di alto livello ampiamente utilizzato per la programmazione generica, creato da Guido van Rossum e rilasciato per la prima volta nel 1991. Python dispone di un sistema di tipo dinamico e gestione automatica della memoria e supporta molteplici paradigmi di programmazione, incluso l'imperativo orientato agli oggetti programmazione funzionale e stili procedurali. Ha una libreria standard ampia e completa.

Due versioni principali di Python sono attualmente in uso:

• Python 3.x è la versione corrente ed è in fase di sviluppo attivo.
• Python 2.x è la versione legacy e riceverà solo aggiornamenti di sicurezza fino al 2020. Non saranno implementate nuove funzionalità. Nota che molti progetti usano ancora Python 2, anche se la migrazione a Python 3 sta diventando più semplice.

Puoi scaricare e installare entrambe le versioni di Python qui . Vedi Python 3 vs Python 2 per un confronto tra di loro. Inoltre, alcune terze parti offrono versioni re-pacchettizzate di Python che aggiungono librerie e altre funzionalità di uso comune per semplificare l'installazione per casi di uso comune, come matematica, analisi dei dati o uso scientifico. Vedi la lista sul sito ufficiale .

Verifica se Python è installato

Per verificare che Python sia stato installato correttamente, è possibile verificarlo eseguendo il seguente comando nel terminale preferito (se si utilizza il sistema operativo Windows, è necessario aggiungere il percorso di python alla variabile di ambiente prima di utilizzarlo nel prompt dei comandi):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Se hai installato Python 3, ma $ python --version restituisce una versione di Python 2, hai anche Python 2 installato. Questo è spesso il caso di MacOS e di molte distribuzioni Linux. Usa $ python3 invece di usare esplicitamente l'interprete Python 3.

Ciao, World in Python usando IDLE

IDLE è un semplice editor per Python, che viene fornito in bundle con Python.

Come creare il programma Hello, World in IDLE

• Apri IDLE sul tuo sistema preferito.
  • Nelle versioni precedenti di Windows, può essere trovato in All Programs dal menu di Windows.
  • In Windows 8+, cerca IDLE o IDLE nelle app presenti nel tuo sistema.
  • Sui sistemi basati su Unix (incluso Mac) è possibile aprirlo dalla shell digitando $ idle python_file.py .
• Si aprirà una shell con opzioni lungo la parte superiore.

Nella shell, vi è un prompt di tre parentesi angolari:

>>>

Ora scrivi il seguente codice nel prompt:

>>> print("Hello, World")

Premi Invio .

>>> print("Hello, World")
Hello, World

Ciao file World Python

Crea un nuovo file hello.py che contiene la seguente riga:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

Nel tuo terminale, vai alla directory contenente il file hello.py .

python hello.py , quindi premi il tasto Invio .

$ python hello.py
Hello, World

Dovresti vedere Hello, World stampato sulla console.

Puoi anche sostituire hello.py con il percorso del tuo file. Ad esempio, se hai il file nella tua home directory e il tuo utente è "utente" su Linux, puoi digitare python /home/user/hello.py .

Avvia una shell Python interattiva

Eseguendo (eseguendo) il comando python nel tuo terminale, ti viene presentata una shell Python interattiva. Questo è anche noto come Interprete Python o REPL (per 'Read Evaluate Print Loop').

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

Se vuoi eseguire Python 3 dal tuo terminale, esegui il comando python3 .

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

In alternativa, avviare il prompt interattivo e caricare il file con python -i <file.py> .

Nella riga di comando, esegui:

$ python -i hello.py
"Hello World"
>>>

Esistono diversi modi per chiudere la shell Python:

>>> exit()

o

>>> quit()

In alternativa, CTRL + D chiuderà la shell e ti rimetterà sulla riga di comando del tuo terminale.

Se vuoi annullare un comando sei nel bel mezzo della digitazione e tornare a un prompt dei comandi pulito, mentre stai all'interno della shell Interpreter, usa CTRL + C.

Prova una shell Python interattiva online .

Altre conchiglie online

Vari siti web forniscono accesso online alle shell Python.

Le shell online possono essere utili per i seguenti scopi:

• Esegui un piccolo snippet di codice da una macchina che manca dell'installazione python (smartphone, tablet, ecc.).
• Impara o insegna Basic Python.
• Risolvi i problemi del giudice online.

Esempi:

Dichiarazione di non responsabilità: gli autori della documentazione non sono affiliati con le risorse elencate di seguito.

• https://www.python.org/shell/ - La shell Python online ospitata dal sito Web ufficiale di Python.
• https://ideone.com/ - Ampiamente utilizzato in rete per illustrare il comportamento del frammento di codice.
• https://repl.it/languages/python3 - Compilatore, IDE e interprete online potente e semplice. Codice, compilazione ed esecuzione di codice in Python.
• https://www.tutorialspoint.com/execute_python_online.php - Una shell UNIX completa e un esploratore di progetti user-friendly.
• http://rextester.com/l/python3_online_compiler - IDE semplice e facile da usare che mostra il tempo di esecuzione

Esegui i comandi come una stringa

Python può essere passato codice arbitrario come una stringa nella shell:

$ python -c 'print("Hello, World")'
Hello, World

Questo può essere utile quando si concatenano i risultati degli script insieme nella shell.

Conchiglie e oltre

Gestione dei pacchetti - Lo strumento consigliato da PyPA per installare i pacchetti Python è PIP . Per installare, nella riga di comando eseguire pip install <the package name> . Ad esempio, pip install numpy . (Nota: su Windows è necessario aggiungere pip alle variabili di ambiente PATH. Per evitare ciò, utilizzare python -m pip install <the package name> )

Conchiglie - Finora, abbiamo discusso diversi modi per eseguire codice usando la shell interattiva nativa di Python. I gusci usano il potere interpretativo di Python per sperimentare il codice in tempo reale. Le shell alternative includono IDLE , una GUI preconnessa , IPython , nota per l'estensione dell'esperienza interattiva e così via.

Programmi : per la memorizzazione a lungo termine è possibile salvare il contenuto in file .py e modificarli / eseguirli come script o programmi con strumenti esterni, ad esempio shell, IDE (come PyCharm ), quaderni Jupyter , ecc. Gli utenti intermedi possono utilizzare questi strumenti; tuttavia, i metodi discussi qui sono sufficienti per iniziare.

Il tutor Python ti consente di scorrere il codice Python in modo da poter visualizzare il flusso del programma e aiutarti a capire dove il programma è andato storto.

PEP8 definisce le linee guida per la formattazione del codice Python. La formattazione del codice è importante per poter leggere rapidamente ciò che fa il codice.

Creazione di variabili e assegnazione di valori

Per creare una variabile in Python, tutto ciò che devi fare è specificare il nome della variabile, e quindi assegnargli un valore.

<variable name> = <value>

Python usa = per assegnare valori alle variabili. Non è necessario dichiarare una variabile in anticipo (o assegnargli un tipo di dati), assegnare un valore a una variabile stessa dichiara e inizializza la variabile con quel valore. Non c'è modo di dichiarare una variabile senza assegnargli un valore iniziale.

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

L'assegnazione variabile funziona da sinistra a destra. Quindi il seguente ti darà un errore di sintassi.

0 = x
=> Output: SyntaxError: can't assign to literal

Non è possibile utilizzare le parole chiave di python come nome di una variabile valida. Puoi vedere l'elenco delle parole chiave per:

import keyword
print(keyword.kwlist)

Regole per la denominazione delle variabili:

1. I nomi delle variabili devono iniziare con una lettera o un trattino basso.

 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

2. Il resto del nome della variabile può essere composto da lettere, numeri e caratteri di sottolineatura.

has_0_in_it = "Still Valid" 

3. I nomi sono case sensitive.

x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Anche se non c'è bisogno di specificare un tipo di dati quando si dichiara una variabile in Python, mentre assegnando lo spazio necessario in memoria per la variabile, l'interprete Python preleva automaticamente il più adatto tipo incorporato per esso:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

Ora conosci le basi del compito, prendi questa sottigliezza sull'assegnazione in python.

Quando si usa = per eseguire un'operazione di assegnazione, ciò che si trova a sinistra di = è un nome per l' oggetto sulla destra. Infine, what = does assegna il riferimento dell'oggetto a destra al nome a sinistra.

Questo è:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

Quindi, da molti esempi di assegnazione sopra, se selezioniamo pi = 3.14 , allora pi è un nome (non il nome, poiché un oggetto può avere più nomi) per l'oggetto 3.14 . Se non capisci qualcosa di seguito, torna a questo punto e rileggilo! Inoltre, puoi dare un'occhiata a questo per una migliore comprensione.

È possibile assegnare più valori a più variabili in una riga. Si noti che ci deve essere lo stesso numero di argomenti sui lati destro e sinistro dell'operatore = :

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

L'errore nell'ultimo esempio può essere eliminato assegnando i valori rimanenti a un numero uguale di variabili arbitrarie. Questa variabile fittizia può avere qualsiasi nome, ma è normale utilizzare il carattere di sottolineatura ( _ ) per l'assegnazione di valori indesiderati:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

Si noti che il numero di _ e il numero di valori rimanenti devono essere uguali. Altrimenti 'troppi valori per decomprimere l'errore' vengono lanciati come sopra:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

È anche possibile assegnare un singolo valore a più variabili contemporaneamente.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

Quando si utilizza tale assegnazione a cascata, è importante notare che tutte e tre le variabili a , b e c riferiscono allo stesso oggetto in memoria, un oggetto int con il valore di 1. In altre parole, a , b e c sono tre nomi diversi dato allo stesso oggetto int. Assegnare un oggetto diverso a uno di essi in seguito non cambia gli altri, proprio come previsto:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

Quanto sopra vale anche per i tipi mutabili (come list , dict , ecc.) Così come è vero per i tipi immutabili (come int , string , tuple , ecc.):

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

Fin qui tutto bene. Le cose sono un po 'diverse quando si tratta di modificare l'oggetto (diversamente dall'assegnazione del nome a un oggetto diverso, che abbiamo fatto sopra) quando l'assegnazione a cascata è usata per i tipi mutabili. Dai uno sguardo qui sotto e lo vedrai in prima persona:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

Gli elenchi annidati sono validi anche in python. Ciò significa che un elenco può contenere un altro elenco come elemento.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

Infine, le variabili in Python non devono rimanere dello stesso tipo di quelle per cui sono state definite per la prima volta: puoi semplicemente usare = per assegnare un nuovo valore a una variabile, anche se quel valore è di un tipo diverso.

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

Se questo ti infastidisce, pensa al fatto che ciò che è a sinistra di = è solo un nome per un oggetto. Prima si chiama l'oggetto int con valore 2 a , quindi si cambia idea e si decide di assegnare il nome a a un oggetto string , con valore 'Nuovo valore'. Semplice, vero?

Input dell'utente

Input interattivo

Per ottenere input dall'utente, utilizzare la funzione di input ( nota : in Python 2.x, la funzione è chiamata raw_input , sebbene Python 2.x abbia una propria versione di input completamente diversa):

name = raw_input("What is your name? ")
# Out: What is your name? _

name = input("What is your name? ")
# Out: What is your name? _

Il resto di questo esempio userà la sintassi di Python 3.

La funzione accetta un argomento stringa, che lo mostra come un prompt e restituisce una stringa. Il codice precedente fornisce un prompt, in attesa che l'utente inserisca.

name = input("What is your name? ")
# Out: What is your name?

Se l'utente digita "Bob" e gli hit entrano, il name della variabile verrà assegnato alla stringa "Bob" :

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

Si noti che l' input è sempre di tipo str , che è importante se si desidera che l'utente inserisca numeri. Pertanto, è necessario convertire lo str prima di provare ad usarlo come numero:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: Si consiglia di utilizzare try / except blocks per rilevare le eccezioni quando si gestiscono gli input dell'utente . Ad esempio, se il tuo codice vuole lanciare raw_input in un int , e ciò che l'utente scrive è invalicabile, solleva un'eccezione ValueError .

IDLE - GUI Python

IDLE è l'ambiente di sviluppo e apprendimento integrato di Python ed è un'alternativa alla linea di comando. Come suggerisce il nome, IDLE è molto utile per lo sviluppo di un nuovo codice o per l'apprendimento di python. Su Windows viene fornito con l'interprete Python, ma in altri sistemi operativi potrebbe essere necessario installarlo tramite il gestore pacchetti.

Gli scopi principali di IDLE sono:

• Editor di testo multi-finestra con evidenziazione della sintassi, completamento automatico e rientro intelligente
• Shell Python con evidenziazione della sintassi
• Debugger integrato con stepping, punti di interruzione persistenti e visibilità dello stack delle chiamate
• Indentazione automatica (utile per i principianti che apprendono il rientro di Python)
• Salvare il programma Python come file .py ed eseguirli e modificarli successivamente in qualsiasi momento usando IDLE.

In IDLE, premi F5 o run Python Shell per lanciare un interprete. L'utilizzo di IDLE può essere un'esperienza di apprendimento migliore per i nuovi utenti perché il codice viene interpretato come l'utente scrive.

Nota che ci sono molte alternative, vedi ad esempio questa discussione o questo elenco .

Risoluzione dei problemi

• finestre

  Se sei su Windows, il comando predefinito è python . Se si riceve un errore "'python' is not recognized" , la causa più probabile è che la posizione di Python non si trova nella variabile di ambiente PATH del sistema. È possibile accedervi facendo clic con il pulsante destro del mouse su "Risorse del computer" e selezionando "Proprietà" o spostandosi su "Sistema" tramite "Pannello di controllo". Fare clic su "Impostazioni di sistema avanzate" e quindi su "Variabili d'ambiente ...". Modifica la variabile PATH per includere la directory della tua installazione Python, così come la cartella Script (solitamente C:\Python27;C:\Python27\Scripts ). Ciò richiede privilegi amministrativi e potrebbe richiedere un riavvio.

  Quando si utilizzano più versioni di Python sulla stessa macchina, una possibile soluzione è rinominare uno dei file python.exe . Ad esempio, nominare una versione python27.exe potrebbe far diventare python27 il comando Python per quella versione.

  Puoi anche utilizzare Python Launcher per Windows, che è disponibile tramite il programma di installazione e viene fornito per impostazione predefinita. Permette di selezionare la versione di Python da eseguire usando py -[xy] invece di python[xy] . Puoi usare l'ultima versione di Python 2 eseguendo script con py -2 e l'ultima versione di Python 3 eseguendo script con py -3 .

• Debian / Ubuntu / MacOS

  Questa sezione presuppone che la posizione dell'eseguibile python sia stata aggiunta alla variabile d'ambiente PATH .

  Se sei su Debian / Ubuntu / MacOS, apri il terminale e digita python per Python 2.xo python3 per Python 3.x.

  Digita which python per vedere quale interprete Python verrà usato.

• Arch Linux

  Il predefinito Python su Arch Linux (e discendenti) è Python 3, quindi usa python o python3 per Python 3.xe python2 per Python 2.x.

• Altri sistemi

  Python 3 è talvolta associato a python anziché a python3 . Per usare Python 2 su questi sistemi su cui è installato, puoi usare python2 .

Tipi di dati

Tipi incorporati

booleani

bool : un valore booleano di True o False . Le operazioni logiche come and , or , not possono essere eseguite sui booleani.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

In Python 2.xe in Python 3.x, un booleano è anche un int . Il tipo di bool è una sottoclasse del tipo int e True e False sono le sue uniche istanze:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Se i valori booleani vengono utilizzati nelle operazioni aritmetiche, i loro valori interi ( 1 e 0 per True e False ) verranno utilizzati per restituire un risultato intero:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Numeri

• int : numero intero

  a = 2
  b = 100
  c = 123456789
  d = 38563846326424324
  

  Gli interi in Python hanno dimensioni arbitrarie.

  Nota: nelle versioni precedenti di Python era disponibile un tipo long diverso da int . I due sono stati unificati.

• float : numero in virgola mobile; la precisione dipende dall'implementazione e dall'architettura di sistema, per CPython il tipo di dati float corrisponde a un doppio C.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : numeri complessi

  a = 2 + 1j
  b = 100 + 10j
  

Gli operatori < , <= , > e >= TypeError un'eccezione TypeError quando qualsiasi operando è un numero complesso.

stringhe

Sequenze e collezioni

Python distingue tra sequenze ordinate e raccolte non ordinate (come set e dict ).

• le stringhe ( str , bytes , unicode ) sono sequenze

• reversed : un ordine inverso di str con funzione reversed

  a = reversed('hello')
  

• tuple : una raccolta ordinata di n valori di qualsiasi tipo ( n >= 0 ).

  a = (1, 2, 3)
  b = ('a', 1, 'python', (1, 2))
  b[2] = 'something else' # returns a TypeError
  

  Supporta l'indicizzazione; immutabile; lavabile se tutti i suoi membri sono lavabili

• list : una raccolta ordinata di n valori ( n >= 0 )

  a = [1, 2, 3]
  b = ['a', 1, 'python', (1, 2), [1, 2]]
  b[2] = 'something else' # allowed
  

  Non lavabile; mutevole.

• set : una collezione non ordinata di valori unici. Gli articoli devono essere lavabili .

  a = {1, 2, 'a'}
  

• dict : una collezione non ordinata di coppie chiave-valore uniche; le chiavi devono essere lavabili

  a = {1: 'one',
       2: 'two'}
  
  b = {'a': [1, 2, 3],
       'b': 'a string'}
  

Un oggetto è lavabile se ha un valore di hash che non cambia mai durante la sua vita (ha bisogno di un __hash__() ) e può essere paragonato ad altri oggetti (ha bisogno di un __eq__() ). Gli oggetti lavabili che confrontano l'uguaglianza devono avere lo stesso valore di hash.

Costanti incorporate

In combinazione con i tipi di dati incorporati c'è un piccolo numero di costanti incorporate nello spazio dei nomi integrato:

• True : il vero valore del bool
• False : il valore falso del tipo built-in bool
• None : un oggetto singleton utilizzato per segnalare che un valore è assente.
• Ellipsis o ... : utilizzato in core Python3 + ovunque e limitato l'uso in Python2.7 + come parte della notazione array. numpy e pacchetti correlati usano questo come riferimento "include tutto" nelle matrici.
• NotImplemented : un singleton utilizzato per indicare a Python che un metodo speciale non supporta gli argomenti specifici e Python proverà delle alternative se disponibili.

a = None # No value will be assigned. Any valid datatype can be assigned later

Test del tipo di variabili

In python, possiamo controllare il tipo di dati di un oggetto usando il type funzione built-in.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

Nelle istruzioni condizionali è possibile testare il tipo di dati con isinstance . Tuttavia, di solito non è incoraggiato a fare affidamento sul tipo di variabile.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Per informazioni sulle differenze tra type() e isinstance() leggi: Differenze tra isinstance e type in Python

Per verificare se qualcosa è di NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Conversione tra tipi di dati

È possibile eseguire la conversione del tipo di dati esplicita.

Ad esempio, '123' è di tipo str e può essere convertito in intero usando la funzione int .

a = '123'
b = int(a)

La conversione da una stringa mobile come "123.456" può essere eseguita usando la funzione float .

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

Puoi anche convertire i tipi di sequenza o raccolta

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Tipo di stringa esplicito alla definizione di valori letterali

Con le etichette di una sola lettera di fronte alle virgolette puoi dire quale tipo di corda vuoi definire.

• b'foo bar' : risultati bytes in Python 3, str in Python 2
• u'foo bar' : risultati str in Python 3, unicode in Python 2
• 'foo bar' : risultati str
• r'foo bar' : i risultati della cosiddetta stringa raw, in cui non sono necessari caratteri speciali di escape, tutto è preso alla lettera mentre hai digitato

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Tipi di dati mutevoli e immutabili

Un oggetto è chiamato mutevole se può essere cambiato. Ad esempio, quando si passa una lista a una funzione, l'elenco può essere modificato:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Un oggetto è chiamato immutabile se non può essere modificato in alcun modo. Ad esempio, gli interi sono immutabili, poiché non c'è modo di cambiarli:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Nota che le variabili stesse sono mutabili, quindi possiamo riassegnare la variabile x , ma questo non cambia l'oggetto che x aveva precedentemente indicato. Ha fatto solo x puntare a un nuovo oggetto.

I tipi di dati le cui istanze sono mutabili sono chiamati tipi di dati mutabili e, analogamente, per oggetti e tipi di dati immutabili.

Esempi di tipi di dati immutabili:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

Esempi di tipi di dati mutabili:

• bytearray
• list
• set
• dict

Moduli e funzioni integrati

Un modulo è un file contenente definizioni e definizioni Python. La funzione è un pezzo di codice che esegue una logica.

>>> pow(2,3)    #8

Per controllare la funzione integrata in python possiamo usare dir(). Se chiamato senza un argomento, restituisce i nomi nell'ambito corrente. Altrimenti, restituisci un elenco alfabetico di nomi che comprende (alcuni) l'attributo dell'oggetto dato e degli attributi raggiungibili da esso.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

Per conoscere la funzionalità di qualsiasi funzione, siamo in grado di utilizzare costruito in funzione di help .

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

I moduli integrati contengono funzionalità aggiuntive. Ad esempio, per ottenere la radice quadrata di un numero, è necessario includere il modulo math .

>>> import math
>>> math.sqrt(16) # 4.0

Per conoscere tutte le funzioni di un modulo, è possibile assegnare l'elenco delle funzioni a una variabile, quindi stampare la variabile.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

sembra che __doc__ sia utile per fornire documentazione, ad esempio, sulle funzioni

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

Oltre alle funzioni, la documentazione può essere fornita anche in moduli. Quindi, se hai un file chiamato helloWorld.py questo modo:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

Puoi accedere alle sue docstring in questo modo:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• Per qualsiasi tipo definito dall'utente, i suoi attributi, gli attributi della sua classe e in modo ricorsivo gli attributi delle classi base della sua classe possono essere recuperati usando dir ()

>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

Qualsiasi tipo di dati può essere semplicemente convertito in stringa usando una funzione incorporata chiamata str . Questa funzione è chiamata per impostazione predefinita quando viene passato un tipo di dati per la print

>>> str(123)    # "123"

Blocco indentazione

Python utilizza il rientro per definire i costrutti di controllo e di loop. Ciò contribuisce alla leggibilità di Python, tuttavia richiede al programmatore di prestare molta attenzione all'uso degli spazi bianchi. Pertanto, l'errata taratura dell'editor potrebbe comportare un codice che si comporta in modi imprevisti.

Python utilizza il simbolo due punti ( : ) e rientro per mostrare dove blocchi di codice iniziano e finiscono (Se si proviene da un'altra lingua, non confondere questo con qualche modo essere legato alla operatore ternario ). Cioè, i blocchi in Python, come le funzioni, i cicli, le clausole if e altri costrutti, non hanno identificatori finali. Tutti i blocchi iniziano con due punti e quindi contengono le linee rientrate sotto di esso.

Per esempio:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

o

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

I blocchi che contengono esattamente un'istruzione a riga singola possono essere messi sulla stessa riga, sebbene questo modulo non sia generalmente considerato di buon livello:

if a > b: print(a)
else: print(b)  

Il tentativo di eseguire questa operazione con più di una singola istruzione non funzionerà:

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

Un blocco vuoto causa un IndentationError . Usa pass (un comando che non fa nulla) quando hai un blocco senza contenuto:

def will_be_implemented_later():
    pass

Spazi contro schede

In breve: usa sempre 4 spazi per il rientro.

L'uso esclusivo delle schede è possibile ma PEP 8 , la guida di stile per il codice Python, afferma che gli spazi sono preferiti.

Molti editor hanno la configurazione "tabs to spaces". Quando si configura l'editor, è necessario distinguere tra il carattere di tabulazione ('\ t') e il tasto Tab .

• Il carattere di tabulazione deve essere configurato per mostrare 8 spazi, in modo che corrispondano alla semantica della lingua, almeno nei casi in cui è possibile indentazione mista (accidentale). Gli editor possono anche convertire automaticamente il carattere di tabulazione in spazi.
• Tuttavia, potrebbe essere utile configurare l'editor in modo che premendo il tasto Tab si inseriscano 4 spazi, invece di inserire un carattere di tabulazione.

Il codice sorgente Python scritto con una combinazione di schede e spazi o con un numero non standard di spazi di indentazione può essere reso conforme a pep8 usando autopep8 . (Un'alternativa meno potente viene fornita con la maggior parte delle installazioni Python: reindent.py )

Tipi di raccolta

Esistono numerosi tipi di raccolta in Python. Mentre tipi come int e str mantengono un singolo valore, i tipi di raccolta contengono più valori.

elenchi

Il tipo di list è probabilmente il tipo di raccolta più comunemente utilizzato in Python. Nonostante il suo nome, una lista è più simile a un array in altre lingue, principalmente JavaScript. In Python, una lista è semplicemente una raccolta ordinata di valori Python validi. Un elenco può essere creato racchiudendo valori, separati da virgole, tra parentesi quadre:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Una lista può essere vuota:

empty_list = []

Gli elementi di un elenco non sono limitati a un singolo tipo di dati, il che ha senso dato che Python è un linguaggio dinamico:

mixed_list = [1, 'abc', True, 2.34, None]

Una lista può contenere un altro elenco come suo elemento:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

Gli elementi di una lista sono accessibili tramite un indice o una rappresentazione numerica della loro posizione. Gli elenchi in Python sono indicizzati a zero, ovvero il primo elemento nell'elenco è all'indice 0, il secondo elemento è all'indice 1 e così via:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

Gli indici possono anche essere negativi, il che significa contare dalla fine della lista ( -1 è l'indice dell'ultimo elemento). Quindi, usando l'elenco dell'esempio precedente:

print(names[-1]) # Eric
print(names[-4]) # Bob

Le liste sono mutabili, quindi puoi cambiare i valori in una lista:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Inoltre, è possibile aggiungere e / o rimuovere elementi da una lista:

Aggiungi oggetto alla fine della lista con L.append(object) , restituisce None .

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Aggiungi un nuovo elemento da elencare in un indice specifico. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Rimuovi la prima occorrenza di un valore con L.remove(value) , restituisce None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Ottieni l'indice nell'elenco del primo elemento il cui valore è x. Mostrerà un errore se non esiste tale elemento.

name.index("Alice")
0

Conta la lunghezza della lista

len(names)
6

conta il verificarsi di qualsiasi elemento nell'elenco

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Invertire la lista

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Rimuovi e restituisci l'oggetto all'indice (predefinito all'ultima voce) con L.pop([index]) , restituisce l'elemento

names.pop() # Outputs 'Sia'

Puoi scorrere gli elementi dell'elenco come di seguito:

for element in my_list:
    print (element)

Le tuple

Una tuple è simile a una lista tranne che è a lunghezza fissa e immutabile. Pertanto, i valori nella tupla non possono essere modificati, né i valori possono essere aggiunti o rimossi dalla tupla. Le tuple vengono comunemente utilizzate per piccole raccolte di valori che non dovranno essere modificate, ad esempio un indirizzo IP e una porta. Le tuple sono rappresentate con parentesi invece di parentesi quadre:

ip_address = ('10.20.30.40', 8080)

Le stesse regole di indicizzazione per le liste si applicano anche alle tuple. Le tuple possono anche essere annidate e i valori possono essere validi per qualsiasi Python valido.

Una tupla con un solo membro deve essere definita (notare la virgola) in questo modo:

one_member_tuple = ('Only member',)

o

one_member_tuple = 'Only member',   # No brackets

o semplicemente usando la sintassi della tuple

one_member_tuple = tuple(['Only member'])

dizionari

Un dictionary in Python è una raccolta di coppie chiave-valore. Il dizionario è circondato da parentesi graffe. Ogni coppia è separata da una virgola e la chiave e il valore sono separati da due punti. Ecco un esempio:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Per ottenere un valore, fare riferimento ad esso con la sua chiave:

ca_capital = state_capitals['California']

Puoi anche ottenere tutte le chiavi in ​​un dizionario e poi scorrere su di esse:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

I dizionari assomigliano molto alla sintassi JSON. Il modulo json nativo nella libreria standard Python può essere usato per convertire tra JSON e dizionari.

impostato

Un set è una raccolta di elementi senza ripetizioni e senza ordine di inserimento ma ordine ordinato. Sono utilizzati in situazioni in cui è importante solo che alcune cose siano raggruppate insieme e non in quale ordine siano state incluse. Per gruppi di dati di grandi dimensioni, è molto più veloce verificare se un elemento è presente in un set piuttosto che fare lo stesso per un list .

Definire un set è molto simile alla definizione di un dictionary :

first_names = {'Adam', 'Beth', 'Charlie'}

Oppure puoi costruire un set usando un list esistente:

my_list = [1,2,3]
my_set = set(my_list)

Controlla l'appartenenza al set usando in :

if name in first_names:
    print(name)

È possibile scorrere su un set esattamente come un elenco, ma ricorda: i valori saranno in un ordine arbitrario definito dall'implementazione.

defaultdict

Un defaultdict è un dizionario con un valore predefinito per le chiavi, in modo che le chiavi per le quali non è stato definito alcun valore siano accessibili senza errori. defaultdict è particolarmente utile quando i valori nel dizionario sono raccolte (elenchi, dict, ecc.) nel senso che non è necessario inizializzarli ogni volta che si utilizza una nuova chiave.

Un defaultdict non genererà mai un KeyError. Qualsiasi chiave che non esiste ottiene il valore predefinito restituito.

Ad esempio, considera il seguente dizionario

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Se proviamo ad accedere a una chiave inesistente, python ci restituisce un errore come segue

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

Proviamo con un defaultdict . Può essere trovato nel modulo delle collezioni.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

Quello che abbiamo fatto qui è di impostare un valore predefinito ( Boston ) nel caso in cui la chiave give non esiste. Ora compila il ditt come prima:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

Se proviamo ad accedere al dict con una chiave inesistente, python ci restituirà il valore predefinito, ovvero Boston

>>> state_capitals['Alabama']
'Boston'

e restituisce i valori creati per la chiave esistente proprio come un normale dictionary

>>> state_capitals['Arkansas']
'Little Rock'

Aiuto Utility

Python ha diverse funzioni integrate nell'interprete. Se si desidera ottenere informazioni su parole chiave, funzioni, moduli o argomenti incorporati, aprire una console Python e immettere:

>>> help()

Riceverai informazioni inserendo le parole chiave direttamente:

>>> help(help)

o all'interno dell'utilità:

help> help

che mostrerà una spiegazione:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

Puoi anche richiedere sottoclassi di moduli:

help(pymysql.connections)

Puoi utilizzare la guida per accedere alle docstring dei diversi moduli che hai importato, ad esempio, prova quanto segue:

>>> help(math)

e avrai un errore

>>> import math
>>> help(math)

E ora riceverai un elenco dei metodi disponibili nel modulo, ma solo DOPO averlo importato.

Chiudete l'aiutante con quit

Creare un modulo

Un modulo è un file importabile contenente definizioni e istruzioni.

Un modulo può essere creato creando un file .py .

# hello.py
def say_hello():
    print("Hello!")

Le funzioni di un modulo possono essere utilizzate importando il modulo.

Per i moduli che hai creato, dovranno essere nella stessa directory del file in cui li stai importando. (Tuttavia, è anche possibile inserirli nella directory lib Python con i moduli pre-inclusi, ma se possibile dovrebbe essere evitato.)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

I moduli possono essere importati da altri moduli.

# greet.py
import hello
hello.say_hello()

È possibile importare funzioni specifiche di un modulo.

# greet.py
from hello import say_hello
say_hello()

I moduli possono essere di tipo alias.

# greet.py
import hello as ai
ai.say_hello()

Un modulo può essere uno script eseguibile autonomo.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

Eseguirlo!

$ python run_hello.py
=> "Hello!"

Se il modulo si trova in una directory e deve essere rilevato da python, la directory deve contenere un file denominato __init__.py .

Funzione stringa - str () e repr ()

Esistono due funzioni che possono essere utilizzate per ottenere una rappresentazione leggibile di un oggetto.

repr(x) chiama x.__repr__() : una rappresentazione di x . eval solito converte il risultato di questa funzione nell'oggetto originale.

str(x) chiama x.__str__() : una stringa leggibile dall'uomo che descrive l'oggetto. Questo può escludere alcuni dettagli tecnici.

repr ()

Per molti tipi, questa funzione fa un tentativo di restituire una stringa che produce un oggetto con lo stesso valore quando viene passato a eval() . Altrimenti, la rappresentazione è una stringa racchiusa tra parentesi angolari che contiene il nome del tipo dell'oggetto insieme a informazioni aggiuntive. Questo spesso include il nome e l'indirizzo dell'oggetto.

str ()

Per le stringhe, restituisce la stringa stessa. La differenza tra questo e repr(object) è che str(object) non tenta sempre di restituire una stringa accettabile da eval() . Piuttosto, il suo obiettivo è restituire una stringa stampabile o 'leggibile dall'uomo'. Se non viene fornito alcun argomento, restituisce la stringa vuota, '' .

Esempio 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

Esempio 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

Quando scrivi un corso, puoi sovrascrivere questi metodi per fare quello che vuoi:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

Usando la classe sopra possiamo vedere i risultati:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

Installazione di moduli esterni tramite pip

pip è tuo amico quando hai bisogno di installare qualsiasi pacchetto dalla pletora di scelte disponibili nel python package index (PyPI). pip è già installato se usi Python 2> = 2.7.9 o Python 3> = 3.4 scaricato da python.org. Per i computer che eseguono Linux o un altro * nix con un gestore di pacchetti nativo, i pip devono spesso essere installati manualmente.

Nelle istanze con Python 2 e Python 3 installati, pip fa spesso riferimento a Python 2 e pip3 a Python 3. Utilizzando pip verranno installati solo pacchetti per Python 2 e pip3 installerà solo pacchetti per Python 3.

Trovare / installare un pacchetto

Cercare un pacchetto è semplice come digitare

$ pip search <query>
# Searches for packages whose name or summary contains <query>

Installare un pacchetto è semplice come digitare (in un terminale / prompt dei comandi, non nell'interprete Python)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

dove xxx è il numero di versione del pacchetto che si desidera installare.

Quando il tuo server è dietro proxy, puoi installare il pacchetto usando il seguente comando:

$ pip --proxy http://<server address>:<port> install

Aggiornamento dei pacchetti installati

Quando vengono visualizzate nuove versioni dei pacchetti installati, non vengono installati automaticamente sul sistema. Per avere una panoramica di quali dei tuoi pacchetti installati sono diventati obsoleti, esegui:

$ pip list --outdated

Per aggiornare un pacchetto specifico utilizzare

$ pip install [package_name] --upgrade

L'aggiornamento di tutti i pacchetti obsoleti non è una funzionalità standard di pip .

Aggiornamento pip

È possibile aggiornare l'installazione del pip esistente utilizzando i seguenti comandi

• Su Linux o macOS X:

  $ pip install -U pip
  

  Potrebbe essere necessario utilizzare sudo con pip su alcuni sistemi Linux

• Su Windows:

  py -m pip install -U pip
  

  o

  python -m pip install -U pip
  

Per maggiori informazioni riguardo pip leggi qui .

Installazione di Python 2.7.xe 3.x

Nota : le seguenti istruzioni sono scritte per Python 2.7 (se non specificato): le istruzioni per Python 3.x sono simili.

FINESTRE

Innanzitutto, scarica l'ultima versione di Python 2.7 dal sito web ufficiale ( https://www.python.org/downloads/) . La versione è fornita come pacchetto MSI. Per installarlo manualmente, basta fare doppio clic sul file.

Di default, Python si installa in una directory:

 C:\Python27\

Attenzione: l'installazione non modifica automaticamente la variabile d'ambiente PATH.

Supponendo che la tua installazione Python sia in C: \ Python27, aggiungi questo al tuo PATH:

C:\Python27\;C:\Python27\Scripts\

Ora per verificare se l'installazione di Python è valida scrivi in ​​cmd:

python --version

Python 2.xe 3.x Side-by-Side

Per installare e utilizzare sia Python 2.x che 3.x side-by-side su una macchina Windows:

1. Installa Python 2.x utilizzando il programma di installazione MSI.

   • Assicurati che Python sia installato per tutti gli utenti.
   • Opzionale: aggiungi Python a PATH per rendere Python 2.x callable dalla riga di comando usando python .

2. Installa Python 3.x utilizzando il rispettivo programma di installazione.

   • Di nuovo, assicurati che Python sia installato per tutti gli utenti.
   • Opzionale: aggiungi Python a PATH per rendere Python 3.x callable dalla riga di comando usando python . Ciò potrebbe ignorare le impostazioni del PATH Python 2.x, quindi ricontrolla il PATH e assicurati che sia configurato in base alle tue preferenze.
   • Assicurati di installare py launcher per tutti gli utenti.

Python 3 installerà il launcher Python che può essere usato per lanciare Python 2.xe Python 3.x in modo intercambiabile dalla riga di comando:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Per utilizzare la versione corrispondente di pip per una specifica versione di Python, utilizzare:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

Le ultime versioni di CentOS, Fedora, RedHat Enterprise (RHEL) e Ubuntu sono fornite con Python 2.7.

Per installare Python 2.7 su Linux manualmente, basta effettuare le seguenti operazioni nel terminale:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

Aggiungete anche il percorso di new python nella variabile d'ambiente PATH. Se new python è in /root/python-2.7.X allora esegui export PATH = $PATH:/root/python-2.7.X

Ora per verificare se l'installazione di Python è valida, scrivi nel terminale:

python --version

Ubuntu (dalla sorgente)

Se hai bisogno di Python 3.6 puoi installarlo dal sorgente come mostrato di seguito (Ubuntu 16.10 e 17.04 hanno versione 3.6 nel repository universale). Di seguito i passaggi da seguire per Ubuntu 16.04 e versioni precedenti:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

Mac OS

Mentre parliamo, macOS viene installato con Python 2.7.10, ma questa versione è obsoleta e leggermente modificata dal normale Python.

La versione di Python fornita con OS X è ottima per l'apprendimento ma non va bene per lo sviluppo. La versione fornita con OS X potrebbe non essere aggiornata rispetto all'attuale versione ufficiale di Python, che è considerata la versione di produzione stabile. ( fonte )

Installa Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Installa Python 2.7:

brew install python

Per Python 3.x, usa invece il comando brew install python3 .