Python: Imparare Python

Una guida completa su Python

👋 Benvenuti nella documentazione di Stackhero!

Stackhero offre una soluzione cloud Python pronta all'uso che fornisce numerosi vantaggi, tra cui:

  • Distribuisci la tua applicazione in pochi secondi con un semplice git push.
  • Usa il tuo nome di dominio e beneficia della configurazione automatica dei certificati HTTPS per una sicurezza migliorata.
  • Goditi la tranquillità con backup automatici, aggiornamenti con un clic, e una tariffazione semplice, trasparente e prevedibile.
  • Ottieni prestazioni ottimali e una sicurezza robusta grazie a una VM privata e dedicata.

Risparmia tempo e semplificati la vita: ci vogliono solo 5 minuti per provare la soluzione di hosting cloud Python di Stackhero!

Questa guida offre una panoramica dei concetti e della sintassi essenziali di Python. Serve come rapido promemoria per sviluppatori esperti e come introduzione amichevole per i principianti. Coprendo tutto, dai tipi di dati di base alle funzionalità avanzate, questo cheatsheet include argomenti come il controllo del flusso, le funzioni, le classi, gli oggetti e i moduli comuni. Tienilo a portata di mano come riferimento rapido mentre lavori su progetti Python. Tieni presente che Python ha un vasto ecosistema di librerie e framework, quindi esplorare risorse e documentazione aggiuntive ti aiuterà ad approfondire argomenti specializzati.

Buon coding!

Introduzione a Python

Python è un linguaggio di programmazione versatile e di alto livello creato da Guido van Rossum e rilasciato per la prima volta nel 1991. È popolare per la sua leggibilità e semplicità, rendendolo una scelta eccellente sia per i principianti che per gli sviluppatori esperti. Python è ampiamente utilizzato nello sviluppo web, nell'analisi dei dati, nell'intelligenza artificiale, nel machine learning e nell'automazione, tra molti altri settori.

Alcuni casi d'uso comuni per Python includono la creazione di applicazioni web utilizzando framework come Django o Flask, l'analisi e la visualizzazione dei dati con librerie come pandas e matplotlib, e lo sviluppo di modelli di machine learning con strumenti come TensorFlow e scikit-learn.

La vasta libreria standard di Python e il suo fiorente ecosistema di pacchetti di terze parti lo rendono un linguaggio potente e flessibile per affrontare una vasta gamma di compiti di programmazione.

Tipi di dati di base

I tipi di dati di base di Python includono interi (numeri interi), numeri a virgola mobile (numeri con decimali), booleani (valori vero/falso) e stringhe (sequenze di caratteri):

  • int: Intero, es. 42
  • float: Numero a virgola mobile, es. 3.14
  • bool: Booleano, es. True o False
  • str: Stringa, es. "hello"

Esempio:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Strutture dati comuni

Python fornisce diverse strutture dati per aiutarti a organizzare, memorizzare e manipolare i dati in modo efficiente. Le più comunemente usate sono liste, tuple, dizionari e set. Le liste e le tuple mantengono una sequenza ordinata di elementi, i dizionari memorizzano coppie chiave-valore e i set memorizzano elementi unici. Ogni struttura offre una gamma di metodi adatti a casi d'uso specifici.

  • Lista: my_list = [1, 2, 3, 4]
  • Tupla: my_tuple = (1, 2, 3, 4)
  • Dizionario: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Set: my_set = {1, 2, 3, 4}

Liste

Le liste sono collezioni mutabili e ordinate di elementi. Consentono duplicati e possono contenere elementi di vari tipi di dati, inclusi altre liste, tuple, dizionari o set. Puoi facilmente aggiungere, aggiornare e rimuovere elementi. Le liste sono definite tra parentesi quadre [] con elementi separati da virgole.

Punti chiave sulle liste:

  1. Mutabili e ordinate
  2. Consentono elementi duplicati
  3. Mantengono l'ordine in cui gli elementi sono aggiunti
  4. Supportano più tipi di dati
  5. Forniscono operazioni per aggiungere, aggiornare e eliminare elementi

Le liste sono comunemente usate quando hai bisogno di una collezione dinamica e ridimensionabile di elementi.

Esempi:

# Creare una lista
my_list = [1, 2, 3, 4, 5]

# Accedere agli elementi
print(my_list[0])  # Output: 1
print(my_list[-1])  # Output: 5

# Aggiungere elementi
my_list.append(6)
print(my_list)  # Output: [1, 2, 3, 4, 5, 6]

# Aggiornare elementi
my_list[0] = 0
print(my_list)  # Output: [0, 2, 3, 4, 5, 6]

# Eliminare elementi
del my_list[0]
print(my_list)  # Output: [2, 3, 4, 5, 6]

Dizionari

I dizionari sono collezioni mutabili e non ordinate di coppie chiave-valore. Ogni chiave deve essere unica e puoi usare queste chiavi per accedere ai loro valori associati. Come le liste, i dizionari possono memorizzare elementi di vari tipi di dati, incluse collezioni annidate. Sono definiti tra parentesi graffe {} con coppie chiave-valore separate da virgole e chiavi e valori separati da due punti.

Punti chiave sui dizionari:

  1. Collezione mutabile e non ordinata
  2. Composta da coppie chiave-valore con chiavi uniche
  3. Accesso ai valori usando le chiavi
  4. Memorizzano vari tipi di dati

I dizionari sono ideali per compiti in cui è necessario eseguire ricerche, come impostazioni di configurazione o conteggi di frequenza.

Esempi:

# Creare un dizionario
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Accedere agli elementi
print(my_dictionary['a'])  # Output: 1

# Aggiungere elementi
my_dictionary['d'] = 4
print(my_dictionary)  # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Aggiornare elementi
my_dictionary['a'] = 0
print(my_dictionary)  # Output: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Eliminare elementi
del my_dictionary['a']
print(my_dictionary)  # Output: {'b': 2, 'c': 3, 'd': 4}

Tuple

Le tuple sono collezioni immutabili e ordinate di elementi. Funzionano come le liste, tranne che una volta creata una tupla, i suoi elementi non possono essere modificati, aggiunti o rimossi. Le tuple sono definite usando parentesi tonde () con elementi separati da virgole.

Punti chiave sulle tuple:

  1. Collezione immutabile e ordinata
  2. Supportano più tipi di dati
  3. Struttura a dimensione fissa

Le tuple sono utili quando hai bisogno di una collezione immodificabile o quando vuoi usare la collezione come chiave di un dizionario.

Esempio:

# Creare una tupla
my_tuple = (1, 2, 3, 4, 5)

# Accedere agli elementi
print(my_tuple[0])  # Output: 1
print(my_tuple[-1])  # Output: 5

# Nota: Le tuple sono immutabili

Set

I set sono collezioni mutabili e non ordinate che memorizzano elementi unici. Rimuovono automaticamente i duplicati e non mantengono un ordine. I set possono contenere elementi di vari tipi di dati, escludendo tipi mutabili come liste e dizionari. Possono essere definiti usando parentesi graffe {} o il costruttore set().

Punti chiave sui set:

  1. Mutabili e non ordinati
  2. Memorizzano solo elementi unici, rimuovendo automaticamente i duplicati
  3. Escludono tipi mutabili (come liste e dizionari)

I set sono ideali per test di appartenenza, deduplicazione e operazioni di insieme come unione, intersezione e differenza.

# Creare un set
my_set = {1, 2, 3, 4, 5}

# Verificare l'appartenenza
print(1 in my_set)  # Output: True

# Aggiungere un elemento
my_set.add(6)
print(my_set)  # Output: {1, 2, 3, 4, 5, 6}

# Aggiornare rimuovendo un elemento e aggiungendone un altro
my_set.remove(1)
my_set.add(0)
print(my_set)  # Output: {0, 2, 3, 4, 5, 6}

# Eliminare un elemento
my_set.remove(0)
print(my_set)  # Output: {2, 3, 4, 5, 6}

Istruzioni condizionali: if, elif, else

Le istruzioni condizionali ti permettono di eseguire codice in base al fatto che una condizione sia vera o falsa.

if condition1:
  # fare qualcosa
elif condition2:
  # fare qualcos'altro
else:
  # fare un'altra cosa

Esempio:

x = 42

if x > 50:
  print("x è maggiore di 50")
elif x < 50:
  print("x è minore di 50")
else:
  print("x è uguale a 50")

Ciclo for

I cicli for iterano su una sequenza, come una lista o un intervallo, eseguendo un blocco di codice per ogni elemento.

Esempio:

for i in range(5):
  print(i)

Ciclo while

I cicli while eseguono un blocco di codice finché una condizione specificata è vera.

Esempio:

i = 0
while i < 5:
  print(i)
  i += 1

Funzioni

Le funzioni incapsulano codice in blocchi riutilizzabili che possono accettare input (argomenti) e restituire output. Sono definite usando la parola chiave def e possono essere chiamate per nome.

def function_name(argument1, argument2=default_value):
  # fare qualcosa
  return result

Esempio:

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Output: 7

Funzioni lambda

Le funzioni lambda, anche conosciute come funzioni anonime, sono funzioni concise a singola espressione create usando la parola chiave lambda. Sono comunemente usate per operazioni brevi, spesso come argomenti per funzioni come map(), filter(), o sorted().

lambda arguments: expression

Esempio:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Output: 7

Comprensioni di lista

Le comprensioni di lista ti permettono di creare liste in una singola riga leggibile combinando un'espressione con un ciclo e una condizione opzionale. Sono eccellenti per trasformare o filtrare dati.

new_list = [expression for item in iterable if condition]

Esempio:

squares = [x * x for x in range(1, 6)]
print(squares)  # Output: [1, 4, 9, 16, 25]

Gestione delle eccezioni

La gestione delle eccezioni consente al tuo programma di gestire gli errori di runtime in modo elegante. Python fornisce i blocchi try, except, e finally per catturare e gestire le eccezioni, garantendo che il tuo programma continui o si chiuda senza problemi.

try:
    # codice che può sollevare un'eccezione
except ExceptionType as error_variable:
    # gestire l'eccezione
finally:
    # codice da eseguire indipendentemente dal fatto che si sia verificata un'eccezione

Esempio:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Impossibile dividere per zero!")

Classi e oggetti

Le classi definiscono modelli per creare oggetti nella programmazione orientata agli oggetti (OOP). Gli oggetti sono istanze di una classe con attributi (dati) e metodi (funzioni) che eseguono compiti specifici. L'OOP promuove codice strutturato, riutilizzabile e manutenibile.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # fare qualcosa
    return result

Esempio:

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woof!")

# Creare un'istanza di Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Output: Woof!

Importazione di moduli

I moduli sono file separati contenenti codice Python come funzioni, classi o variabili. Importare moduli ti consente di estendere la funzionalità del tuo programma utilizzando librerie e framework esterni.

import module_name
from module_name import specific_function_or_class

Esempio:

import math
print(math.sqrt(16))  # Output: 4.0

Input/Output di file

L'input/output (I/O) di file copre la lettura e la scrittura di file in Python. Questo è essenziale quando si lavora con l'archiviazione e il recupero dei dati.

Lettura di un file

with open('filename.txt', 'r') as file:
  content = file.read()

Scrittura in un file

with open('filename.txt', 'w') as file:
  file.write('contenuto da scrivere nel file')

Gestori di contesto

I gestori di contesto aiutano a gestire le risorse, come file o connessioni di rete, assicurandosi che siano correttamente acquisite e rilasciate. Usare un gestore di contesto garantisce che il tuo codice sia più pulito e più tollerante agli errori.

with resource as alias:
  # usare resource come alias

Esempio:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Output: Hello, World!

Decoratori

I decoratori ti permettono di estendere o modificare il comportamento di funzioni o classi senza cambiare il loro codice sorgente. Avvolgono un'altra funzione e aggiungono funzionalità prima o dopo l'esecuzione della funzione avvolta.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # fare qualcosa prima di chiamare la funzione
    result = func(*args, **kwargs)
    # fare qualcosa dopo aver chiamato la funzione
    return result
  return wrapper

@decorator_function
def my_function():
  # fare qualcosa

Esempi:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Output: Hello, John!

Modulo Itertools

Il modulo itertools fornisce funzioni per creare e lavorare con iteratori. Include iteratori infiniti (come count, cycle e repeat), iteratori finiti (come accumulate, chain, compress), e iteratori combinatori (come product, permutations e combinations).

Esempio:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Output: 5, 10, 15, 20

Modulo Collections

Il modulo collections offre tipi di contenitori specializzati che possono migliorare i tuoi programmi.

from collections import namedtuple, defaultdict, Counter, deque

Esempi:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Output: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Output: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Output: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Output: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Output: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Espressioni regolari

Le espressioni regolari consentono un potente trattamento e manipolazione del testo. Il modulo re fornisce funzioni come match, search, findall, finditer, split e sub.

Esempio:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Output: ['10', '5']

Date e orari

Lavorare con date e orari è un requisito comune, specialmente per l'analisi dei dati o compiti di pianificazione. Il modulo datetime fornisce classi e funzioni per lavorare con date, orari e intervalli.

import datetime

# datetime, date, time, timedelta, timezone

Esempi:

from datetime import datetime, timedelta

# Data e ora attuali
current_time = datetime.now()
print("Data e ora attuali:", current_time)

# Data e ora personalizzate
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Data e ora personalizzate:", custom_date)

# Convertire stringa in datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("Stringa in datetime:", date_obj)

# Convertire datetime in stringa
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime in stringa:", date_str2)

# Aritmetica delle date e orari
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Ieri:", yesterday)
print("Domani:", tomorrow)

Slicing di lista

Lo slicing di lista ti permette di estrarre una porzione di una lista o di un altro tipo di sequenza specificando valori di inizio, fine e passo opzionale. Questa funzionalità è molto utile per estrarre sotto-sequenze.

my_list[start:end:step]

Esempio:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Output: [1, 2, 3]

Formattazione di stringhe

La formattazione di stringhe è il processo di combinazione di testo statico con valori dinamici. Python offre diversi metodi di formattazione, inclusi il formattazione con %, il metodo str.format(), e le f-strings (Python 3.6+), che ti permettono di generare facilmente stringhe formattate.

Formattazione con %

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Esempio:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Output: My name is John and I am 30 years old.

Argomenti da riga di comando

Gli argomenti da riga di comando ti permettono di passare valori di input a uno script Python quando lo esegui dalla riga di comando. La lista sys.argv fornisce accesso a questi argomenti, rendendo facile analizzarli e usarli all'interno del tuo script.

import sys

arguments = sys.argv

Esempio:

# Salva questo codice in un file chiamato "cmd_args.py"
# Esegui con: python cmd_args.py Alice
# Output previsto: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Nessun argomento fornito.")

Other articles for Python