Adolescenza in Python

Prima che passi troppo tempo da quando sono diventato novizio Python, è bene che scriva 2 righe. Per memoria mia e per aiutare altri novizi.

Per due motivi principali mi sono accostato a Python:

- un esame universitario (la mia laurea UniPd è un po' datata, m'ero iscritto ad un corso di laurea ad UniVe, ma era troppo impegnativa la frequenza, così ho seguito degli esami di UniNettuno) di Intelligenza Artificiale col professor Fabrizio Davide (che ringrazio per l'estrema generosità del voto e saluto)

- la necessità di effettuare web scraping nel mondo lavorativo, con la limitazione economica (prodotti open source), browser Edge in modalità Internet Explorer, linguaggio Python estremamente gradito nella Azienda.

Quindi: full immersion.

Adesso, un paio di mesi dopo, posso tirare 2 somme.

Python è un linguaggio semplicissimo... un po' come imparare un nuovo stile di nuoto, sapendo già nuotare.

Queste poche righe non sono dirette a chi ha conoscenza nulla di Python... per quello ci sono n corsi in rete, facilissimi, con video, eccetera... quindi parlerò a chi ha già scritto print("Hello, world") e l'ha pure eseguito in una installazione Python (la mia è la 3.9.9 64bit, stabile e senza problemi su qualsiasi OS supporti Python).

Se Python ha dei difetti, questi sono 3:

- l'indentazione (se scrivete dei periodi troppo lunghi vi "perdete", se aggiungete dei brani, occhio che facciano parte dei periodi corretti... è un attimo sbagliare ed alterare completamente il significato del codice)

- l'enorme numero di librerie da conoscere (potreste fare tanto di quel lavoro inutile perchè è già stato scritto... più librerie padroneggiate, meno codice scrivete: il che non vuol dire che diventate più bravi, ma potete permettervi di essere più pigri)

- la tipizzazione nulla delle sue variabili (è un attimo "scivolare", ad esempio, da una serie pandas ad una lista... e manco ve ne siete accorti: prendete l'abitudine, quando effettuate dei passaggi da un tipo all'altro, di effettuare dei test sul type dal quale partite, altrimenti potreste sbattere la testa inutilmente).

Detto ciò, quand'è che diventate "adolescenti" da "infanti"? Quando cominciate a scrivere le vostre proprie classi.

Le classi hanno 2 pregi:

- potete scrivere in maniera oggettizzata delle soluzioni (esempio: una finestra con un led verde che simula l'evoluzione di un ciclo), così che non dovete ripetere la scrittura di un codice

- la "scienza infusa" necessaria per scrivere quella soluzione non viene dispersa in mille rivoli, ma si trova tutta là, a disposizione e facilmente modificabile in un unico punto.

Cosa serve, per scrivere ed utilizzare una classe?

- la classe, scritta in un file .py, strutturata in questo modo (esempio)

<Python inizio>

# librerie importate

import os

from datetime import date, timedelta, datetime

# definizione della classe

class BR60_StringManagement:

# Variabili di istanza

strInstanceThis = os.path.basename(__file__)

# definizione di una delle funzioni (i commenti iniziali sono importanti, se avete un editor intelligente)

def BR60_SM_SubstringEstract(self, strTxt, strFrom, strTo, blnOnVerboseDebug=False):

"""

Estrae una substring da una stringa, con la possibilità di specificare i delimitatori sinistro e destro.

strTxt è una stringa testo. Le due variabili chiamate strFrom e strTo sono due stringhe che possono essere None oppure no.

Se sono valorizzate, richiedono di estrarre dalla stringa strTxt una stringa delimitata a destra dalla stringa in strFrom,

a sinistra dalla stringa in strTo. Se la stringa in strFrom è None, si intende di estrarre dall'inizio di txt,

se la stringa in strTo è None, si intende di estrarre fino alla fine di txt.

Se la stringa in strFrom non è ritrovata in strTxt, si ritorna una stringa a None e si segnala.

Se la stringa in strTo non è ritrovata in strTxt, si segnala e si estrae dalla delimitazione di strTo in avanti.

Args:

strTxt: La stringa da cui estrarre la substring.

strFrom: Il delimitatore sinistro (opzionale).

strTo: Il delimitatore destro (opzionale).

blnOnVerboseDebug: richieste stampe di debug

Returns:

La substring estratta.

Un booleano con lo stato dell'operazione

Un messaggio sul risultato dell'operazione

"""

if blnOnVerboseDebug:

print(self.strInstanceThis + f" BR60_SM_SubstringEstract(self, '{str(strTxt)}', '{str(strFrom)}', '{str(strTo)}', {str(blnOnVerboseDebug)}):")

<Python eccetera>

- per scrivere la classe, le funzioni possono essere richiamate da ogni altra funzione della classe ponendo self. come prefisso

- per scrivere la classe, le variabili di istanza possono essere richiamate e condivise da ogni funzione della classe ponendo self. come prefisso (non possono essere "viste" esternamente alla classe: per leggerle o modificarle, bisogna scrivere delle funzioni che effettuino tali azioni)

- per scrivere la classe, ogni funzione della classe ha una prima (o unica) variabile self (variabile che non va "passata" al momento del richiamo)

- una cartella my_package che contiene le classi da voi scritte e con un file "__"init"__".py (ho messo tra apici gli underscore, altrimenti l'editor di Linkedin effettua un'interpretazione) che può essere anche vuoto

- una vostra variabile Windows (per esempio BR60_PYTHON_my_package) che contenga la stringa identificativa del path della vostra cartella my_package (vedi passo sotto a cosa serve)

- una serie di istruzioni che richiami, dal vostro main, le classi... ecco un esempio:

<Python inizio>

# librerie importate

import os

from pathlib import Path

import importlib.util

# Variabili globali

strThis = os.path.basename(__file__)

strPathClasses = os.getenv("BR60_PYTHON_my_package")

strBackslash = "\\"

strClassSH = "BR60_SeleniumHusk.py"

strClassFS = "BR60_FileSystem.py"

strClassDL = "BR60_Dialogs.py"

strClassSM = "BR60_StringManagement.py"

strClassLD = "BR60_ListAndDataframeHusk.py"

# Carica il modulo BR60_Dialogs (classe BR60_Dialogs nel file BR60_Dialogs.py) specificando il path completo

pthClassPath = Path(strPathClasses + strBackslash + strClassDL)

clsSpecFromPath = importlib.util.spec_from_file_location(strClassDL, pthClassPath)

clsModFromSpec = importlib.util.module_from_spec(clsSpecFromPath)

clsSpecFromPath.loader.exec_module(clsModFromSpec)

# Accedi alla classe dal modulo caricato

BR60_Dialogs = clsModFromSpec.BR60_Dialogs

if clsModFromSpec:

print(strThis + f" Classe importata: {clsModFromSpec.BR60_Dialogs}")

else:

print(strThis + f" Errore: impossibile importare la classe '{pthClassPath}'")

# creo un'istanza della classe BR60_Dialogs di nome Dlgs

Dlgs = BR60_Dialogs()

<Python continua>

... a questo punto posso richiamare ogni funzione della classe con Dlgs.funzione() (fatta esclusione per le funzioni che iniziano per "_", visibili solo internamente alla classe).

Ecco: gustatevi la vostra adolescenza Python!

Enjoy!