m-lamonaca/dev-notes
1
0
Fork 0
mirror of https://github.com/m-lamonaca/dev-notes.git synced 2025-04-06 10:56:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

translate python std lib notes

Browse source
This commit is contained in:
Marcello 2022-05-01 21:31:57 +02:00
parent 78cefcee9a
commit 3b85a1e944
5 changed files with 297 additions and 340 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

156
Python/Standard Library/collections.md
View file

@ -1,78 +1,78 @@
# Collections Module # Collections Module
```py ``` py
# COUNTER() # COUNTER ()
# sottoclasse dizionario per contare oggetti hash-abili # subclass dictionary for counting hash-capable objects
from collections import Counter from collections import Counter
Counter(sequenza) # -> oggetto Counter Counter (sequence) # -> Counter object
# {item: num comprese in sequenza, ...} # {item: num included in sequence, ...}
var = Counter(sequenza) var = Counter (sequence)
var.most_common(n) # produce lista degli elementi più comuni (n più comuni) var.most_common (n) # produce list of most common elements (most common n)
sum(var.values()) # totale di tutti i conteggi sum (var.values ​​()) # total of all counts
var.clear() #reset tutti i conteggi var.clear () #reset all counts
list(var) # elenca elementi unici list (var) # list unique items
set(var) # converte in un set set (var) # convert to a set
dict(var) # converte in un dizionario regolare dict (var) # convert to regular dictionary
var.items() # converte in una lista di coppie (elemento, conteggio) var.items () # convert to a list of pairs (element, count)
Counter(dict(list_of_pairs)) # converte da una lista di coppie Counter (dict (list_of_pairs)) # convert from a list of pairs
var.most_common[:-n-1:-1] # n elementi meno comuni var.most_common [: - n-1: -1] # n less common elements
var += Counter() # rimuove zero e conteggi negativi var + = Counter () # remove zero and negative counts
# DEFAULTDICT() # DEFAULTDICT ()
# oggetto simil-dizionario che come primo argomento prende un tipo di default # dictionary-like object that takes a default type as its first argument
# defaultdict non solleverà mai un eccezione KeyError. # defaultdict will never raise a KeyError exception.
# le chiavi non esistenti ritornano un valore di default (default_factory) # non-existent keys return a default value (default_factory)
from collections import defaultdict from collections import defaultdict
var = defaultdict(default_factory) var = defaultdict (default_factory)
var.popitem() # rimuove e restituisce primo elemento var.popitem () # remove and return first element
var.popitem(last=True) # rimuove e restituisce ultimo elemento var.popitem (last = True) # remove and return last item
# OREDERDDICT() # OREDERDDICT ()
# sottoclasse dizionario che "ricorda" l'ordine in cui vengono inseriti i contenuti # subclass dictionary that "remembers" the order in which the contents are entered
# dizionari normali hanno ordinamento casuale # Normal dictionaries have random order
nome_dict = OrderedDict() name_dict = OrderedDict ()
# OrderedDict con stessi elementi ma ordine diverso sono considerati diversi # OrderedDict with same elements but different order are considered different
# USERDICT() # USERDICT ()
# implementazione pura in pythondi una mappa che funziona come un normale dizionario. # pure implementation in pythondi a map that works like a normal dictionary.
# Designata per creare sottoclassi # Designated to create subclasses
UserDict.data # recipiente del contenuto di UserDict UserDict.data # recipient of UserDict content
# NAMEDTUPLE() # NAMEDTUPLE ()
# ogni namedtuple è rappresentata dalla propria classe # each namedtuple is represented by its own class
from collections import namedtuple from collections import namedtuple
NomeClasse = namedtuple(NomeClasse, parametri_separati_da_spazio) NomeClasse = namedtuple (NomeClasse, parameters_separated_from_space)
var = NomeClasse(parametri) var = ClassName (parameters)
var.attributo # accesso agli attributi var.attribute # access to attributes
var[index] # accesso agli attributi var [index] # access to attributes
var._fields # accesso ad elenco attributi var._fields # access to attribute list
var = classe._make(iterabile) # trasformain namedtuple var = class._make (iterable) # transformain namedtuple
var._asdict() # restituisce oggetto OrderedDict a partire dalla namedtuple var._asdict () # Return OrderedDict object starting from namedtuple
# DEQUE() # DEQUE ()
# double ended queue (pronunciato "deck") # double ended queue (pronounced "deck")
# lista modificabuile da entrambi i "lati" # list editable on both "sides"
from collections import deque from collections import deque
var = deque(iterabile, maxlen=num) # -> oggetto deque var = deque (iterable, maxlen = num) # -> deque object
var.append(item) # aggiunge item al fondo var.append (item) # add item to the bottom
var.appendleft(item) # aggiunge item all'inizio var.appendleft (item) # add item to the beginning
var.clear() # rimuove tutti gli elementi var.clear () # remove all elements
var.extend(iterabile) # aggiunge iterabile al fondo var.extend (iterable) # add iterable to the bottom
var.extendleft(iterabile) # aggiunge iterabile all'inizio' var.extendleft (iterable) # add iterable to the beginning '
var.insert(index, item) # inserisce in posizione index var.insert (index, item) # insert index position
var.index(item, start, stop) # restituisce posizione di item var.index (item, start, stop) # returns position of item
var.count(item) var.count (item)
var.pop() var.pop ()
var.popleft() var.popleft ()
var.remove(valore) var.remove (value)
var.reverse() # inverte ordine elementi var.reverse () # reverse element order
var.rotate(n) # sposta gli elementi di n step (dx se n > 0, sx se n < 0) var.rotate (n) # move the elements of n steps (dx if n> 0, sx if n <0)
var.sort() var.sort ()
``` ```

165
Python/Standard Library/csv.md
View file

@ -1,82 +1,83 @@
# CSV Module Cheat Sheet
# CSV Module Cheat Sheet
```python
# itera linee di csvfile ``` python
.reader(csvfile, dialect, **fmtparams) --> oggetto reader # iterate lines of csvfile
.reader (csvfile, dialect, ** fmtparams) -> reader object
# METODI READER
.__next__() # restituisce prossima riga dell'oggetto iterabile come una lista o un dizionario # READER METHODS
.__ next __ () # returns next iterable object line as a list or dictionary
# ATTRIBUTI READER
dialect # descrizione read-only del dialec usato # READER ATTRIBUTES
line_num # numero di linee dall'inizio dell'iteratore dialect # read-only description of the dialec used
fieldnames line_num # number of lines from the beginning of the iterator
fieldnames
# converte data in stringhe delimitate
# csvfile deve supportare .write() # convert data to delimited strings
#tipo None convertito a stringa vuota (semplifica dump di SQL NULL) # csvfile must support .write ()
.writer(csvfile, dialect, **fmtparams) --> oggetto writer #type None converted to empty string (simplify SQL NULL dump)
.writer (csvfile, dialect, ** fmtparams) -> writer object
# METODI WRITER
# row deve essere iterabile di stringhe o numeri oppure dei dizionari # WRITER METHODS
.writerow(row) # scrive row formattata secondo il dialect corrente # row must be iterable of strings or numbers or of dictionaries
.writerows(rows) # scrive tutti gli elementi in rows formattati secondo il dialect corrente. rows è iterdabile di row .writerow (row) # write row formatted according to the current dialect
.writerows (rows) # write all elements in rows formatted according to the current dialect. rows is iterable of row
# METODI CSV
# associa dialect a name (name deve essere stringa) # CSV METHODS
.register_dialect(name, dialect, **fmtparams) # associate dialect to name (name must be string)
.register_dialect (name, dialect, ** fmtparams)
# elimina il dialect associato a name
.unregister_dialect() # delete the dialect associated with name
.unregister_dialect ()
# restituisce il dialetto associato a name
.get_dialect(name) # returns the dialect associated with name
.get_dialect (name)
# elenco dialetti associati a name
.list_dialect(name) # list of dialects associated with name
.list_dialect (name)
# restituisce (se vuoto) o setta il limite del campo del csv
.field_size_limit(new_limit) # returns (if empty) or sets the limit of the csv field
.field_size_limit (new_limit)
'''
csvfile --oggetto iterabile restituente una string ad ogni chiamata di __next__() '''
se csv è un file deve essere aperto con newline='' (newline universale) csvfile - iterable object returning a string on each __next __ () call
dialect --specifica il dialetto del csv (Excel, ...) (OPZIONALE) if csv is a file it must be opened with newline = '' (universal newline)
dialect - specify the dialect of csv (Excel, ...) (OPTIONAL)
fmtparams --override parametri di formattazione (OPZIONALE) https://docs.python.org/3/library/csv.html#csv-fmt-params
''' fmtparams --override formatting parameters (OPTIONAL) https://docs.python.org/3/library/csv.html#csv-fmt-params
'''
# oggetto operante come reader ma mappa le info in ogni riga in un OrderedDict le cui chiavi sono opzionali e passate tramite fieldnames
class csv.Dictreader(f, fieldnames=None, restket=none, restval=None, dialect, *args, **kwargs) # object operating as a reader but maps the info in each row into an OrderedDict whose keys are optional and passed through fieldnames
''' class csv.Dictreader (f, fieldnames = None, restket = none, restval = None, dialect, * args, ** kwargs)
f --file da leggere '''
fieldnames --sequenza, definisce i nomi dei campi del csv. se omesso usa la prima linea di f f - files to read
restval, restkey --se len(row) > fieldnames dati in eccesso memorizzati in restval e restkey fieldnames --sequence, defines the names of the csv fields. if omitted use the first line of f
restval, restkey --se len (row)> fieldnames excess data stored in restval and restkey
parametri aggiuntivi passati a istanza reader sottostante
''' additional parameters passed to the underlying reader instance
'''
class csv.DictWriter(f, fieldnames, restval='', extrasaction, dialect, *args, **kwargs)
''' class csv.DictWriter (f, fieldnames, restval = '', extrasaction, dialect, * args, ** kwargs)
f --file da leggere '''
fieldnames --sequenza, definisce i nomi dei campi del csv. (NECESSARIO) f - files to read
restval --se len(row) > fieldnames dati in eccesso memorizzati in restval e restkey fieldnames --sequence, defines the names of the csv fields. (NECESSARY)
extrasaction --se il dizionario passato a writerow() contiene key non presente in fieldnames extrasaction decide azione da intraprendere (raise causa valueError, ignore ignora le key aggiuntive) restval --se len (row)> fieldnames excess data stored in restval and restkey
extrasaction - if the dictionary passed to writerow () contains key not present in fieldnames extrasaction decides action to be taken (raise cause valueError, ignore ignores additional keys)
parametri aggiuntivi passati a istanza writer sottostante
''' additional parameters passed to the underlying writer instance
'''
# METODI DICTREADER
.writeheader() # scrive una riga di intestazione di campi come specificato da fieldnames # DICTREADER METHODS
.writeheader () # write a header line of fields as specified by fieldnames
# classe usata per dedurre il formato del CSV
class csv.Sniffer # class used to infer the format of the CSV
.sniff(campione, delimiters=None) #analizza il campione e restituisce una classe Dialect. delimiter è sequenza di possibili delimitatori di caselle class csv.Sniffer
.has_header(campione) --> bool # True se prima riga è una serie di intestazioni di colonna .sniff (sample, delimiters = None) #parse the sample and return a Dialect class. delimiter is a sequence of possible box delimiters
.has_header (sample) -> bool # True if first row is a series of column headings
#COSTANTI
csv.QUOTE_ALL # indica a writer di citare (" ") tutti i campi #CONSTANTS
csv.QUOTE_MINIMAL # indica a write di citare solo i campi contenenti caratteri speciali come delimiter, quote char ... csv.QUOTE_ALL # instructs writer to quote ("") all fields
csv.QUOTE_NONNUMERIC # indica al writer di citare tutti i campi non numerici csv.QUOTE_MINIMAL # instructs write to quote only fields containing special characters such as delimiter, quote char ...
csv.QUOTE_NONE # indica a write di non citare mai i campi csv.QUOTE_NONNUMERIC # instructs the writer to quote all non-numeric fields
``` csv.QUOTE_NONE # instructs write to never quote fields
```

144
Python/Standard Library/itertools.md
View file

@ -1,72 +1,72 @@
# Itertools Module # Itertools Module
```py ``` py
# accumulate([1,2,3,4,5]) -> 1, 3(1+2), 6(1+2+3), 10(1+2+3+6), 15(1+2+3+4+5) # accumulate ([1,2,3,4,5]) -> 1, 3 (1 + 2), 6 (1 + 2 + 3), 10 (1 + 2 + 3 + 6), 15 (1+ 2 + 3 + 4 + 5)
# accumulate(iter, func( , )) -> iter[0], func(iter[0] + iter[1]) + func(prev + iter[2]), ... # accumulate (iter, func (,)) -> iter [0], func (iter [0] + iter [1]) + func (prev + iter [2]), ...
accumulate(iterable, func(_, _)) accumulate (iterable, func (_, _))
# iteratore restituisce elementi dal primo iterable, # iterator returns elements from the first iterable,
# poi procede al successivo fino alla fine degli iterabili # then proceeds to the next until the end of the iterables
# non funziona se l'iterable è uno solo # does not work if there is only one iterable
chain(*iterabili) chain (* iterable)
# concatena elementi del singolo iterable anche se contiene sequenze # concatenates elements of the single iterable even if it contains sequences
chain.from_iterable(iterable) chain.from_iterable (iterable)
# restituisce sequenze di lunghezza r a partire dall'iterable # returns sequences of length r starting from the iterable
# elementi trattati come unici in base al loro valore # items treated as unique based on their value
combinations(iterable, r) combinations (iterable, r)
# # restituisce sequenze di lunghezza r a partire dall'iterable permettendo la ripetizione degli elementi # # returns sequences of length r starting from the iterable allowing the repetition of the elements
combinations_with_replacement(iterable, r) combinations_with_replacement (iterable, r)
# iteratore filtra elementi di data restituendo solo quelli che hanno # iterator filters date elements returning only those that have
# un corrispondente elemento in selectors che ha valore vero # a corresponding element in selectors that is true
compress(data, selectors) compress (data, selectors)
count(start, step) count (start, step)
# iteratore restituente valori in sequenza infinita # iterator returning values ​​in infinite sequence
cycle(iterable) cycle (iterable)
# iteratore scarta elementi dell'iterable finché il predicato è vero # iterator discards elements of the iterable as long as the predicate is true
dropwhile(predicato, iterable) dropwhile (predicate, iterable)
# iteratore restituente valori se il predicato è falso # iterator returning values ​​if predicate is false
filterfalse(predicato, iterable) filterfalse (predicate, iterable)
# iteratore restituisce tuple (key, group) # iterator returns tuple (key, group)
# key è il criterio di raggruppamento # key is the grouping criterion
# group è un generatore restituente i membri del gruppo # group is a generator returning group members
groupby(iterable, key=None) groupby (iterable, key = None)
# iteratore restituisce slice dell'iterable # iterator returns slices of the iterable
isslice(iterable, stop) isslice (iterable, stop)
isslice(iterable, start, stop, step) isslice (iterable, start, stop, step)
# restituisce tutte le permutazioni di lunghezza r dell'iterable # returns all permutations of length r of the iterable
permutations(iterable, r=None) permutations (iterable, r = None)
# prodotto cartesiano degli iterabili # Cartesian product of iterables
# cicla iterabili in ordine di input # loops iterables in order of input
# [product('ABCD', 'xy') -> Ax Ay Bx By Cx Cy Dx Dy] # [product ('ABCD', 'xy') -> Ax Ay Bx By Cx Cy Dx Dy]
# [product('ABCD', repeat=2) -> AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD] # [product ('ABCD', repeat = 2) -> AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD]
product(*iterabili, ripetizioni=1) product (* iterable, repetitions = 1)
# restituisce un oggetto infinite volte se ripetizioni non viene specificato # returns an object infinite times if repetition is not specified
repeat(oggetto, ripetizioni) repeat (object, repetitions)
# iteratore computa func(iterable) # iterator compute func (iterable)
# usato se iterable è sequenza pre-zipped (seq di tuple raggruppanti elementi) # used if iterable is pre-zipped sequence (seq of tuples grouping elements)
starmap(func, iterable) starmap (func, iterable)
# iteratore restituente valori da iterable finché predicato è vero # iterator returning values ​​from iterable as long as predicate is true
takewhile(predicato, iterable) takewhile (predicate, iterable)
# restituisce n iteratori indipendenti dal singolo iterable # returns n independent iterators from the single iterable
tee(iterable, n=2) tee (iterable, n = 2)
# produce un iteratore che aggrega elementi da ogni iterable # produces an iterator that aggregates elements from each iterable
# se gli iterabili hanno lunghezze differenti i valori mancanti sono riempiti secondo fillervalue # if the iterables have different lengths the missing values ​​are filled according to fillervalue
zip_longest(*iterable, fillvalue=None) zip_longest (* iterable, fillvalue = None)
``` ```

44
Python/Standard Library/operator.md
View file

@ -1,44 +0,0 @@
# Operator Module Cheat Sheet
```py
# OPERATORI CONFRONTO
__lt__(a, b), lt(a, b) # a < b
__le__(a, b), le(a, b) # a <= b
__eq__(a, b), eq(a, b) # a == b
__ne__(a, b), ne(a, b) # a != b
__ge__(a, b), ge(a, b) # a >= b
__gt__(a, b), gt(a, b) # a > b
not_(obj)
truth(obj)
is_(a, b)
is_not(a, b)
__abs__(a, b), abs(obj)
__add__(a, b), add(a, b) # a + b
__sub__(a, b), sub(a, b) # a - b
__mul__(a,b), mul(a,b) # a * b
__mul__(a, b), pow(a,b) # a ** b
__truediv__(a, b), truediv(a, b) # a / b
__floordiv__(a, b), floordiv(a, b) # return a // b
__mod__(a, b), mod(a, b) # a % b
__neg__(obj), neg(obj) # -obj
__index__(a), index(a)
__and__(a, b), and_(a, b) # a & b
__or__(a, b), or_(a, b) # a | b
__xor__(a, b), xor(a, b) # a ^ b
__inv__(obj), inv(obj), __inverse__(obj), inverse(obj) # ~obj
__lshift__(obj), lshift(a, b)
__concat__(a, b), concat(a, b)
__contains__(a, b), contains(a, b)
countOf(a, b)
indexOf(a, b)
__delitem__(a, b), delitem(a, b)
__getitem__(a, b), getitem(a, b)
__setitem__(a, b), setitem(a, b)

128
Python/Standard Library/time_datetime.md
View file

@ -1,64 +1,64 @@
# Time & Datetime # Time & Datetime
## Time ## Time
```py ```py
# epoch: tempo in secondi trascorso (in UNIX parte da 01-010-1970) # epoch: elapsed time in seconds (in UNIX starts from 01-010-1970)
import time # UNIX time import time # UNIX time
variabile = time.time() # restituisce il tempo (In secondi) trascorso da 01-01-1970 variable = time.time () # returns the time (in seconds) elapsed since 01-01-1970
variabile = time.ctime(epochseconds) # trasforma l'epoca in data variable = time.ctime (epochseconds) # transform epoch into date
var = time.perf_counter() # ritorna il tempo di esecuzione attuale var = time.perf_counter () # returns the current running time
# tempo di esecuzione = tempo inizio - tempo fine # execution time = start time - end time
``` ```
### time.srtfrime() format ### time.srtfrime() format
| Format | Data | | Format | Data |
|--------|------------------------------------------------------------------------------------------------------------| |--------|------------------------------------------------------------------------------------------------------------|
| `%a` | Locale's abbreviated weekday name. | | `%a` | Locale's abbreviated weekday name. |
| `%A` | Locale's full weekday name. | | `%A` | Locale's full weekday name. |
| `%b` | Locale's abbreviated month name. | | `%b` | Locale's abbreviated month name. |
| `%B` | Locale's full month name. | | `%B` | Locale's full month name. |
| `%c` | Locale's appropriate date and time representation. | | `%c` | Locale's appropriate date and time representation. |
| `%d` | Day of the month as a decimal number `[01,31]`. | | `%d` | Day of the month as a decimal number `[01,31]`. |
| `%H` | Hour (24-hour clock) as a decimal number `[00,23]`. | | `%H` | Hour (24-hour clock) as a decimal number `[00,23]`. |
| `%I` | Hour (12-hour clock) as a decimal number `[01,12]`. | | `%I` | Hour (12-hour clock) as a decimal number `[01,12]`. |
| `%j` | Day of the year as a decimal number `[001,366]`. | | `%j` | Day of the year as a decimal number `[001,366]`. |
| `%m` | Month as a decimal number `[01,12]`. | | `%m` | Month as a decimal number `[01,12]`. |
| `%M` | Minute as a decimal number `[00,59]`. | | `%M` | Minute as a decimal number `[00,59]`. |
| `%p` | Locale's equivalent of either AM or PM. | | `%p` | Locale's equivalent of either AM or PM. |
| `%S` | Second as a decimal number `[00,61]`. | | `%S` | Second as a decimal number `[00,61]`. |
| `%U` | Week number of the year (Sunday as the first day of the week) as a decimal number `[00,53]`. | | `%U` | Week number of the year (Sunday as the first day of the week) as a decimal number `[00,53]`. |
| `%w` | Weekday as a decimal number `[0(Sunday),6]`. | | `%w` | Weekday as a decimal number `[0(Sunday),6]`. |
| `%W` | Week number of the year (Monday as the first day of the week) as a decimal number `[00,53]`. | | `%W` | Week number of the year (Monday as the first day of the week) as a decimal number `[00,53]`. |
| `%x` | Locale's appropriate date representation. | | `%x` | Locale's appropriate date representation. |
| `%X` | Locale's appropriate time representation. | | `%X` | Locale's appropriate time representation. |
| `%y` | Year without century as a decimal number `[00,99]`. | | `%y` | Year without century as a decimal number `[00,99]`. |
| `%Y` | Year with century as a decimal number. | | `%Y` | Year with century as a decimal number. |
| `%z` | Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM | | `%z` | Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM |
| `%Z` | Time zone name (no characters if no time zone exists). | | `%Z` | Time zone name (no characters if no time zone exists). |
| `%%` | A literal `%` character. | | `%%` | A literal `%` character. |
## Datetime ## Datetime
```py ```py
import datetime import datetime
today = datetime.date.today() # restituisce data corrente today = datetime.date.today () # returns current date
today = datetime.datetime.today() # restituisce la data e l'ora corrente today = datetime.datetime.today () # returns the current date and time
# esempio di formattazione # formatting example
print('Current Date: {}-{}-{}' .format(today.day, today.month, today.year)) print ('Current Date: {} - {} - {}' .format (today.day, today.month, today.year))
print('Current Time: {}:{}.{}' .format(today.hour, today.minute, today.second)) print ('Current Time: {}: {}. {}' .format (today.hour, today.minute, today.second))
var_1 = datetime.date(anno, mese, giorno) # crea oggetto data var_1 = datetime.date (year, month, day) # create date object
var_2 = datetime.time(ora, minuti, secondi, micro-secondi) # crea oggetto tempo var_2 = datetime.time (hour, minute, second, micro-second) # create time object
dt = datetime.combine(var_1, var_2) # combina gli oggetti data e tempo in un unico oggetto dt = datetime.combine (var_1, var_2) # combine date and time objects into one object
date_1 = datetime.date('year', 'month', 'day') date_1 = datetime.date ('year', 'month', 'day')
date_2 = date_1.replace(year = 'new_year') date_2 = date_1.replace (year = 'new_year')
#DATETIME ARITHMETIC #DATETIME ARITHMETIC
date_1 - date_2 # -> datetime.timedelta(num_of_days) date_1 - date_2 # -> datetime.timedelta (num_of_days)
datetime.timedelta # durata esprimente differenza tra due oggetti date, time o datetime datetime.timedelta # duration expressing the difference between two date, time or datetime objects
``` ```