Home-theater-designers
L'uso di Python per risolvere vari problemi tecnici e la sua facile curva di apprendimento lo hanno reso uno dei linguaggi di programmazione moderni più popolari. Nonostante sia veloce da imparare, le sue espressioni regolari possono essere complicate, specialmente per i nuovi arrivati.
puoi eseguire un server minecraft su un lampone pi
Sebbene Python abbia molte librerie, è saggio che tu sappia come aggirare le sue normali sintassi. Anche se sei un esperto, c'è la possibilità che tu abbia ancora bisogno di cercare occasionalmente alcuni comandi Python per rinfrescarti la memoria.
Per questo motivo, abbiamo preparato questo cheat sheet sulle espressioni regolari Python per aiutarti a ottenere una migliore padronanza delle tue sintassi.
DOWNLOAD GRATUITO: Questo cheat sheet è disponibile come a PDF scaricabile dal nostro partner di distribuzione, TradePub. Dovrai compilare un breve modulo per accedervi solo per la prima volta. Scarica il Foglio informativo Python RegEx per programmatori in erba .
Il cheat sheet di Python RegEx per programmatori in erba
| Espressione | Azione | Esempi |
|---|---|---|
| Stampa() | Visualizza il risultato di un comando | x='Ciao mondo' stampa(x) output: Ciao mondo |
| ingresso() | Raccogli input dagli utenti | print(input('come ti chiami?')) uscita: come ti chiami? |
| genere() | Trova il tipo di una variabile | x='Espressioni regolari' tipo(x) produzione: |
| len () | Trova il numero di elementi in una variabile | len ([1, 2, 3]) uscita: 3 |
| Sfuggi a un carattere che cambia l'intento di una riga di codice | print('Voglio che tu aggiunga''') output: voglio che tu aggiunga'' | |
| Rompi un carattere di stringa per iniziare sulla riga successiva | print('Questa è una riga
Questa è una seconda riga') produzione: Questa è una linea Questa è una seconda riga | |
| def nome_funzione (parametro): comandi | Avvia una funzione con un parametro opzionale | def tuoNome(x): stampa(x+1) |
| lambda | Chiama una funzione anonima | add_3_to = lambda y: y + 3 print(add_3_to(4)) uscita: 7 |
| Restituzione | Restituisce un risultato da una funzione | def tuoNome(x): ritorna x+1 |
| classe | Crea un oggetto Python | classe miaClasse: def miaFunc(x): |
| def __init__ | Inizializzare gli attributi di una classe | classe miaClasse: def __init__(self, attributi...) |
| '__init__.py | Salva un file contenente un modulo in modo che venga letto correttamente in un altro file Python | Rinominare un file contenente un modulo come: '__init__.py |
| intero() | Converti una variabile in intero | intero(1.234) uscita: 1 |
| str() | Converti una variabile in stringa | via (1,234) uscita: '1.234' |
| galleggiante() | Converti una variabile in float | galleggiante(23) uscita: 23.0 |
| dict(Contatore()) | Converti un elenco o una tupple in un dizionario dopo l'ordinamento con un contatore integrato in Python | dall'importazione di collezioni Contatore dict(Contatore([1,1,2,1,2,3,3,4])) uscita: {1: 3, 2: 2, 3: 2, 4: 1} |
| il giro() | Arrotondare l'output di un'operazione al numero intero più vicino | rotondo (23.445) uscita: 23 |
| round (operazione o numero, cifre decimali) | Arrotondare l'output di un'operazione a un numero specifico di cifre decimali | tondo(23.4568, 2) uscita: 23,46 |
| Se: | Avviare un'istruzione condizionale | se 2<3: print('Due è più piccolo') |
| elfo: | Fai una controaffermazione quando l'istruzione if è False | se 2<3: print('Due è più piccolo') elif 2==3: print('Continua') |
| altro: | Fai una controaffermazione finale se altre condizioni sono false | se 2<3: print('Due è più piccolo') elif 2==3: print('Continua') altro: print('Tre è maggiore') |
| Continua | Ignora una condizione ed esegui il resto del ciclo | a = [1, 4, -10, 6, 8] per b in a: se b<=0: Continua stampa(b) produzione: 1 4 6 8 |
| rottura | Termina il flusso di un ciclo con una data condizione | a = [1, 4, -10, 6, 8] per b in a: se b>=6: rottura stampa(b) produzione: 1 4 -10 |
| passaggio | Ignora una serie di istruzioni precedenti | per b in a: passaggio |
| prova, tranne | Prova un blocco di codice, altrimenti solleva un'eccezione definita | Tentativo: stampa(a) tranne: print('Si è verificato un errore!') output: si è verificato un errore! |
| finalmente | Esegui un codice finale quando i blocchi try e allow falliscono | Tentativo: stampa(a) tranne: stampa(d) finalmente: print('Non puoi stampare una variabile indefinita') output: non puoi stampare una variabile indefinita |
| solleva eccezione() | Solleva un'eccezione che interrompe il comando quando l'esecuzione non è possibile | a = 7 + 2 se un<10: raise Exception('Oh! Non hai ottenuto un punteggio di 10') |
| importa x | Importa un intero modulo o libreria | importare matematica |
| da x importa y | Importa una libreria x da un file o una classe y | dalla modalità di importazione di scipy.stats |
| come | Personalizza un'espressione con il tuo nome preferito | importa panda come pd |
| in | Controlla se un valore è presente in una variabile | x = [1, 4, 6, 7] se 5 in x: print('C'è un cinque') altro: print('Non ce ne sono cinque') output: non ci sono cinque |
| è | Controlla se due variabili fanno riferimento a un singolo elemento | x = [1, 4, 6, 7] x=b stampa(x è b) Vero |
| Nessuno | Dichiara un valore nullo | x=Nessuno |
| < | Controlla se un valore è minore di un altro | 5<10 output: Vero |
| > | Controlla se un valore è più di un altro | 5> 10 output: falso |
| <= | Controlla se un valore è minore o uguale a un altro | 2 * 2<=3 output: falso |
| > = | Controlla se un valore è maggiore o uguale a un altro | 2 * 2> = 3 output: Vero |
| '== | Controlla se un valore è esattamente uguale all'altro | 3 == 4 output: Falso |
| ! = | Accertati che un valore non sia uguale all'altro | 3! = 4 output: True |
| importare re | Importa le espressioni regolari integrate di Python | importare re re.findall('stringhe', variabile) |
| a|b | Controlla se uno dei due elementi è presente in una stringa | importare re someText = 'Ciao espressione regolare' a=re.findall('regular|Hello', someText) stampa(a) output: ['Ciao', 'normale'] |
| stringa$ | Controlla se una variabile finisce con un insieme di stringhe | importare re someText = 'Ciao espressione regolare' a=re.findall('expression$', someText) output: ['espressione'] |
| ^stringa | Controlla se una variabile inizia con un insieme di stringhe | importare re someText = 'Ciao espressione regolare' a=re.findall('^Hello', someText) stampa(a) uscita: ['Ciao'] |
| stringa.indice() | Controlla la posizione dell'indice di un carattere di stringa | a= 'Ciao mondo' a.index('H') uscita: 0 |
| string.capitalize() | Mettere in maiuscolo il primo carattere in un insieme di stringhe | a= 'Ciao mondo' a.capitalize() uscita: 'Ciao mondo' |
| string.swapcase() | Stampa la prima lettera di ogni parola in minuscolo e le altre in maiuscolo | a= 'Ciao mondo' a.swapcase() produzione: 'Ciao mondo' |
| stringa.inferiore() | Converti tutte le stringhe in minuscolo | a= 'Ciao mondo' a.inferiore() uscita: 'ciao mondo' |
| stringa.superiore() | Converti tutte le stringhe in maiuscolo | a= 'Ciao mondo' a.superiore() uscita: 'CIAO MONDO' |
| string.inizia con() | Controlla se una stringa inizia con un carattere particolare | a= 'Ciao mondo' a.inizia con('a') output: falso |
| string.endswith() | Controlla se una stringa finisce con un carattere particolare | a= 'Ciao mondo' a.endswith('d') output: Vero |
| stringa.split() | Separa ogni parola in una lista | a= 'Ciao mondo' a.split() output: ['Ciao', 'mondo'] |
| stringhe {}'.format() | Visualizza un output come stringa | a = 3 + 4 print('La risposta è {}'.format(a)) output: La risposta è 7 |
| non è Nessuno | Controlla se il valore di una variabile non è vuoto | def checknull (a): se a non è Nessuno: restituisce 'è pieno!' altro: restituisce 'è vuoto!' |
| x% y | Trova il resto (modulo) di una divisione | 9% 4 uscita: 1 |
| x // y | Trova il quoziente di una divisione | 9 // 4 uscita: 2 |
| '= | Assegna un valore a una variabile | a = {1: 5, 3: 4} |
| '+ | Aggiungi elementi insieme | ['un due'] + ['un uno'] output: ['un due', 'uno'] 1 + 3 uscita=4 |
| '- | Trova la differenza tra un insieme di numeri | 3-4 uscita=-1 |
| '* | Trova il prodotto di un insieme di numeri | 3 * 4 uscita: 12 |
| a+=x | Aggiungi x alla variabile a senza assegnarne il valore a una nuova variabile | a = 2 a + = 3 uscita: 5 |
| a-=x | Sottrai x dalla variabile a senza assegnarla a una nuova variabile | a = 3 a- = 2 uscita: 1 |
| a*=x | Trova il prodotto della variabile a e x senza assegnare il risultato a una nuova variabile | a = [1, 3, 4] a * = 2 uscita: [1, 3, 4, 1, 3, 4] |
| x ** y | Alza la base x alla potenza y | 2 ** 3 uscita: 8 |
| pow (x, y) | Eleva x alla potenza di y | zona (2, 3) uscita: 8 |
| addominali(x) | Converti un intero negativo nel suo valore assoluto | addominali (-5) uscita: 5 |
| x**(1/nesimo) | Trova l'ennesima radice di un numero | 8 ** (1/3) uscita: 2 |
| a=b=c=d=x | Assegna lo stesso valore a più variabili | a=b=c=d='Ciao mondo' |
| x, y = y, x | Scambia variabili | x = [1, 2] y = 3 x, y = y, x stampa (x, y) produzione: 3 [1], 2] |
| per | Ciclo attraverso gli elementi in una variabile | a = [1, 3, 5] per b in a: print(b, 'x', '2', '=', b*2) produzione: 1 x 2 = 2 3 x 2 = 6 5 x 2 = 10 |
| mentre | Continua a scorrere una variabile, fino a quando una particolare condizione rimane True | a = 4 b = 2 mentre b<=a: print(b, 'è minore di', a) b + = 1 produzione: 2 è minore di 4 3 è minore di 4 4 è minore di 4 |
| gamma() | Crea un intervallo di numeri interi positivi tra x e y | x=intervallo(4) stampa(x) gamma(0, 4) per b in x: stampa(b) produzione: 0 1 2 3 |
| somma() | Iterare attraverso gli elementi in una lista | print(somma([1, 2, 3])) uscita: 6 |
| somma(lista, inizio) | Restituisce la somma di una lista con un elemento aggiunto | print(somma([1, 2, 3], 3)) uscita: 9 |
| [] | Crea un elenco di elementi | x=['a', 3, 5, 'h', [1, 3, 3], {'d':3}] |
| () | Crea una tupple --- le tupple sono immutabili | x=(1, 2, 'g', 5) |
| {} | Crea un dizionario | a = {'x': 6, 'y': 8} |
| x[a:b] | Taglia una lista | x = [1, 3, 5, 6] x [0: 2] uscita: [1, 3] |
| x[chiave] | Ottieni il valore di una chiave nel dizionario x | a = {'x': 6, 'y': 8} print(a['x']) uscita: 6 |
| x.append() | Aggiungi un elenco di valori a un elenco vuoto | x = [1] x.append([1,2,3]) stampa(x) uscita: [1, [1,2,3]] |
| x.estendere() | Aggiungi un elenco di valori per continuare un elenco esistente senza necessariamente creare un elenco annidato | x = [1,2] x.estendere([3,4,6,2]) stampa(x) produzione: [1, 2, 3, 4, 6, 2] |
| del (x [a: b]) | Elimina completamente un elemento da un elenco in un indice specifico | x = [1,2,3,5] del (x [0: 2]) stampa(x) uscita: [2,3,5] |
| del (x [tasto]) | Elimina completamente una chiave e un valore da un dizionario in corrispondenza di un indice specifico | y = {1: 3, 2: 5, 4: 6, 8: 2} del (e [1], e [8]) stampa (e) uscita= {2:5, 4:6} |
| dict.pop() | Estrarre il valore di una chiave e rimuoverlo da un dizionario in corrispondenza di un indice specifico | a = {1: 3, 2: 4, 5: 6} a.pop(1) uscita: 3 |
| dict.popitem() | Estrai l'ultimo elemento da un dizionario ed eliminalo | a = {1: 2, 4: 8, 3: 5} a.popitem() uscita: (3, 5) stampa(a) uscita: {1:2, 4:8} |
| lista.pop() | Estrarre un determinato indice da un elenco e rimuoverlo da un elenco | a = [1, 3, 2, 4, 1, 6, 6, 4] a.pop(-2) uscita: 6 stampa(a) uscita: [1, 3, 2, 4, 1, 6, 4] |
| chiaro() | Svuota gli elementi di una lista o di un dizionario | x = [1, 3, 5] x.clear() stampa(x) produzione: [] |
| rimuovere() | Rimuovere un elemento da un elenco | x = [1, 5, 6, 7] x.rimuovi(1) uscita: [5, 6, 7] |
| inserire() | Inserisci elementi in una lista | x = [3, 5, 6] x.inserisci(1, 4) stampa(x) uscita: [1, 4, 3, 5, 6] |
| sort(inverso=condizione) | Invertire la direzione degli elementi in una lista | x = [1, 3, 5, 6] x.sort(reverse=True) stampa(x) uscita: [6, 5, 3, 1] |
| aggiornare() | Aggiorna un dizionario cambiando il suo primo elemento e aggiungendo qualsiasi altro elemento alla sua fine | x = {1: 3, 5: 6} x.update({1:4, 8:7, 4:4}) stampa(x) uscita: {1: 4, 5: 6, 8: 7, 4: 4} |
| chiavi() | Mostra tutte le chiavi in un dizionario | a = {1: 2, 4: 8} a.chiavi() output: dict_keys([1, 4]) |
| valori() | Mostra tutti i valori in un dizionario | a = {1: 2, 4: 8} a.valori() output: dict_values([2, 8]) |
| Oggetti() | Visualizza le chiavi e i valori in un dizionario | a = {1: 2, 4: 8} a.oggetti() output: dict_items([(1, 2), (4, 8)]) |
| ottieni (chiave) | Ottieni il valore di un elemento in un dizionario tramite la sua chiave | a = {1: 2, 4: 8, 3: 5} a.get(1) uscita: 2 |
| setdefault(chiave) | Restituire il valore originale di un elemento a un dizionario | a.setdefault(2) |
| f={**a, **b} | Unisci due dizionari | a = {'x': 6, 'y': 8} b={'c':5, 'd':3} f = {** a, ** y} stampa(f) output:{'x': 6, 'y': 8, 'c': 5, 'd': 3} |
| rimuovere() | Rimuovi il primo valore corrispondente di un elemento da un elenco senza preoccuparti del suo indice | a = [1, 3, 2, 4, 4, 1, 6, 6, 4] a.rimuovi(4) stampa(a) uscita: [1, 3, 2, 4, 1, 6, 6, 4] |
| vista memoria(x) | Accedi ai buffer interni di un oggetto | a=memoryview(oggetto) |
| byte () | Converti un protocollo buffer di memoria in byte | byte(a[0:2]) |
| bytearray() | Restituisce un array di byte | bytearray (oggetto) |
| # | Scrivi una singola riga di commento o impedisci l'esecuzione di una riga di codice | # Cheat sheet regex Python |
| '' '' '' | Scrivi un commento su più righe | '''Il cheat sheet di Python regex è buono per i principianti È ugualmente un ottimo ripasso per esperti''' |
| Riga di comando | ||
| pacchetto di installazione pip | Installa una libreria online | pip installa panda |
| nome virtualenv | Usa virtaulenv per creare un ambiente virtuale | virtualenv mioprogetto |
| mkvirtualenv nome | Usa il wrapper dell'ambiente virtuale per creare un ambiente virtuale | mkvirtualenv mioprogetto |
| file pitone.py | Esegui i comandi in un file Python | 'python mio_file.py |
| pip congelare | Elenca tutti i pacchetti installati in un ambiente virtuale | pip congelare |
| pip freeze > alcuni file | Copia tutte le librerie installate in un unico file | blocco dei pip > requisiti.txt |
| dove | Trova il percorso di installazione di Python | dove pitone? |
| --versione | Controlla la versione di un pacchetto | python --versione |
| .EXE | Esegui una shell Python | python.exe |
| con open(file, 'w') | Scrivi su un file esistente e sovrascrivi il suo contenuto esistente | con open('regex.txt', 'w') come wf: wf.write('Ciao mondo!') |
| con open(file, 'r') | Apri un file in sola lettura | con open('regex.txt', 'r') come rf: print(rf.read() |
| con open(file, 'a') | Scrivi su un file senza sovrascrivere il suo contenuto esistente | con open('regex.txt', 'a') come af: af.write (' nCiao Sì!') |
| file.chiudi | Chiudi un file se non è in uso | af=open('regex.txt') af.chiudi |
| Uscita | Esci dalla shell Python | Uscita() |
Diventa creativo quando usi Python
Imparare le espressioni regolari di Python è un grande passo per diventare un programmatore Python migliore, ma questa è solo una delle poche cose che devi fare.
Tuttavia, giocare con le sue sintassi e diventare creativo con esse perfeziona le tue abilità di codifica. Quindi, oltre ad apprendere le sintassi, usale in progetti di vita reale e diventerai un programmatore Python migliore.
Condividere Condividere Tweet E-mail Come creare, importare e riutilizzare il proprio modulo in PythonSpieghiamo un importante fondamento della riusabilità del codice in Python: i moduli.
Leggi Avanti Argomenti correlati
- Programmazione
- Foglio informativo
- Pitone
Idowu è appassionato di qualsiasi tecnologia intelligente e produttività. Nel tempo libero gioca con la programmazione e quando si annoia passa alla scacchiera, ma ama anche staccare ogni tanto dalla routine. La sua passione per mostrare alle persone la tecnologia moderna lo motiva a scrivere di più.
Altro da Idowu OmisolaIscriviti alla nostra Newsletter
Iscriviti alla nostra newsletter per consigli tecnici, recensioni, ebook gratuiti e offerte esclusive!
Clicca qui per iscriverti