Il Cheat Sheet di Python RegEx per programmatori in erba
L'uso di Python per risolvere vari problemi tecnologici 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, soprattutto per i nuovi arrivati.
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 rinfrescare la tua memoria.
Per questo motivo, abbiamo preparato questo cheat sheet sulle espressioni regolari di Python per aiutarti a ottenere una migliore comprensione delle tue sintassi.
DOWNLOAD GRATUITO: questo cheat sheet è disponibile come PDF scaricabile dal nostro partner di distribuzione, TradePub. Dovrai completare un breve modulo per accedervi solo per la prima volta. Scarica il Cheat Sheet Python RegEx per programmatori in erba .
Il Cheat Sheet di Python RegEx per i programmatori in erba
| Espressione | Azione | Esempi |
|---|---|---|
| Stampa() | Visualizza il risultato di un comando | x = "Hello world" stampa (x) output: Hello world |
| ingresso() | Raccogli input dagli utenti | print (input ("come ti chiami?")) output: come ti chiami? |
| genere() | Trova il tipo di variabile | x = "Espressioni regolari" tipo (x) produzione: |
| len () | Trova il numero di elementi in una variabile | len ([1, 2, 3]) uscita: 3 |
| Sfuggire a un carattere che cambia l'intento di una riga di codice | print ("Voglio che tu aggiunga " "") output: voglio che tu aggiunga "" | |
| n | Rompere un carattere stringa per iniziare dalla riga successiva | print ("Questa è una riga n Questa è una seconda riga") produzione: |
| def nome_funzione (parametro): comandi | Avvia una funzione con un parametro opzionale | def yourName (x): stampa (x + 1) |
| lambda | Chiama una funzione anonima | add_3_to = lambda y: y + 3 print (add_3_to (4)) uscita: 7 |
| ritorno | Restituisce un risultato da una funzione | def yourName (x): restituisce x + 1 |
| classe | Crea un oggetto Python | class myClass: def myFunc (x): |
| def __init__ | Inizializza gli attributi di una classe | class myClass: def __init __ (sé, attributi …) |
| "__init__.py | Salva un file contenente un modulo in modo che venga letto correttamente in un altro file Python | Rinomina un file contenente un modulo come: "__init__.py |
| int () | Converti una variabile in numero intero | int (1.234) uscita: 1 |
| str () | Converti una variabile in una stringa | str (1.234) output: "1.234" |
| galleggiante() | Converti una variabile in float | galleggiante (23) uscita: 23.0 |
| dict (Counter ()) | Converti un elenco o un tupple in un dizionario dopo l'ordinamento con un contatore integrato in Python | da collezioni import Counter 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 | tondo (23.445) uscita: 23 |
| round (operazione o numero, posizioni decimali) | Arrotondare l'output di un'operazione a un numero specifico di cifre decimali | rotondo (23.4568, 2) uscita: 23.46 |
| Se: | Avvia una dichiarazione condizionale | se 2 <3: print ("Due è più piccolo") |
| elif: | Fai una controaffermazione quando l'affermazione if è False | se 2 <3: print ("Due è più piccolo") elif 2 == 3: print ("Continua") |
| altro: | Fai un'ultima dichiarazione se le 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: |
| rompere | Termina il flusso di un loop con una determinata condizione | a = [1, 4, -10, 6, 8] per b in a: se b> = 6: rompere stampa (b) produzione: |
| passaggio | Ignora una serie di istruzioni precedenti | per b in a: passaggio |
| prova, tranne | Prova un blocco di codice, altrimenti solleva un'eccezione definita | provare: stampa (a) eccetto: output: si è verificato un errore! |
| infine | Esegui un codice finale quando il tentativo e i blocchi tranne falliscono | provare: stampa (a) eccetto: output: non è possibile stampare una variabile non definita |
| aumentare l'eccezione () | Solleva un'eccezione che interrompe il comando quando l'esecuzione non è possibile | a = 7 + 2 se a <10: alza Eccezione ("Oh! Non hai ottenuto un punteggio di 10") |
| import x | Importa un intero modulo o libreria | importa 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 i panda come pd |
| nel | Controlla se un valore è presente in una variabile | x = [1, 4, 6, 7] se 5 in x: print ("C'è un cinque") altro: print ("Non ci sono cinque") output: non ce ne sono cinque |
| è | Controlla se due variabili si riferiscono a un singolo elemento | x = [1, 4, 6, 7] x = b print (x è b) Vero |
| Nessuna | 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: False |
| <= | Controlla se un valore è minore o uguale a un altro | 2 * 2 <= 3 output: False |
| > = | 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 ouput: Falso |
| ! = | Accertati che un valore non sia uguale all'altro | 3! = 4 ouput: vero |
| import re | Importa le espressioni regolari incorporate di Python | import re re.findall ("stringhe", variabile) |
| a | b | Controlla se uno dei due elementi è presente in una stringa | import re someText = "Ciao espressione regolare" a = re.findall ("regular | Hello", someText) stampa (a) output: ["Hello", "regular"] |
| stringa $ | Controlla se una variabile termina con un insieme di stringhe | import re someText = "Ciao espressione regolare" a = re.findall ("espressione $", someText) output: ["espressione"] |
| ^ stringa | Controlla se una variabile inizia con un insieme di stringhe | import re someText = "Ciao espressione regolare" a = re.findall ("^ Hello", someText) stampa (a) output: ["Hello"] |
| string.index () | Controlla la posizione di indice di un carattere stringa | a = "Hello World" a.index ('H') uscita: 0 |
| string.capitalize () | Scrivi in maiuscolo il primo carattere in una serie di stringhe | a = "Hello World" a. capitalizzare () output: "Hello world" |
| string.swapcase () | Stampa la prima lettera di ogni parola in minuscolo e le altre in maiuscolo | a = "Hello World" a. swapcase () produzione: |
| string.lower () | Converti tutte le stringhe in minuscolo | a = "Hello World" a. inferiore () output: "ciao mondo" |
| string.upper () | Converti tutte le stringhe in maiuscolo | a = "Hello World" a. superiore () uscita: 'HELLO WORLD' |
| string.startswith () | Controlla se una stringa inizia con un carattere particolare | a = "Hello World" a. inizia con ('a') output: False |
| string.endswith () | Controlla se una stringa termina con un carattere particolare | a = "Hello World" a.endswith ('d') output: vero |
| string.split () | Separa ogni parola in un elenco | a = "Hello World" a.split () output: ["Hello", "world"] |
| 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: restituire "è pieno!" altro: restituire "è 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"] + ["uno"] output: ["un due", "uno"] 1 + 3 uscita = 4 |
| "- | Trova la differenza tra un insieme di numeri | 3-4 output = -1 |
| "* | Trova il prodotto di una serie 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 | Sottrae x dalla variabile a senza assegnarla a una nuova variabile | a = 3 a- = 2 uscita: 1 |
| a * = x | Trova il prodotto della variabile aex senza assegnare il risullato a una nuova variabile | a = [1, 3, 4] a * = 2 uscita: [1, 3, 4, 1, 3, 4] |
| x ** y | Alza la base x per alimentare y | 2 ** 3 uscita: 8 |
| pow (x, y) | Elevare x alla potenza di y | pow (2, 3) uscita: 8 |
| abs (x) | Converti un numero intero negativo nel suo valore assoluto | addominali (-5) uscita: 5 |
| x ** (1 / nth) | 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 = "Hello world" |
| x, y = y, x | Scambia le variabili | x = [1, 2] y = 3 x, y = y, x stampa (x, y) produzione: |
| per | Scorri gli elementi in una variabile | a = [1, 3, 5] per b in a: print (b, "x", "2", "=", b * 2) produzione: |
| 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: |
| gamma() | Crea un intervallo di numeri interi positivi tra x e y | x = intervallo (4) stampa (x) intervallo (0, 4) per b in x: stampa (b) produzione: |
| somma() | Scorri gli elementi in un elenco | print (sum ([1, 2, 3])) uscita: 6 |
| somma (elenco, inizio) | Restituisce la somma di una lista con un elemento aggiunto | print (sum ([1, 2, 3], 3)) uscita: 9 |
| [] | Fai un elenco di elementi | x = ['a', 3, 5, 'h', [1, 3, 3], {'d': 3}] |
| () | Crea un tupple — tupple sono immutabili | x = (1, 2, 'g', 5) |
| {} | Crea un dizionario | a = {'x': 6, 'y': 8} |
| x [a: b] | Sfoglia una lista | x = [1, 3, 5, 6] x [0: 2] output: [1, 3] |
| x [chiave] | Ottieni il valore di una chiave nel dizionario x | a = {'x': 6, 'y': 8} print (una ['x']) uscita: 6 |
| x.append () | Aggiungi un elenco di valori a un elenco vuoto | x = [1] x.append ([1,2,3]) stampa (x) output: [1, [1,2,3]] |
| x.extend () | Aggiungi un elenco di valori per continuare un elenco esistente senza necessariamente creare un elenco nidificato | x = [1,2] x.extend ([3,4,6,2]) stampa (x) produzione: |
| 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 [chiave]) | 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 (y [1], y [8]) stampa (y) output = {2: 5, 4: 6} |
| dict.pop () | Estrarre il valore di una chiave e rimuoverlo da un dizionario in un indice specifico | a = {1: 3, 2: 4, 5: 6} a.pop (1) uscita: 3 |
| dict.popitem () | Estrarre l'ultimo elemento da un dizionario ed eliminarlo | a = {1: 2, 4: 8, 3: 5} a.popitem () uscita: (3, 5) |
| list.pop () | Estrarre un dato indice da un elenco e rimuoverlo da un elenco | a = [1, 3, 2, 4, 1, 6, 6, 4] a.pop (-2) uscita: 6 |
| chiaro() | Svuota gli elementi di una lista o di un dizionario | x = [1, 3, 5] x.clear () stampa (x) produzione: [] |
| rimuovere() | Rimuovi un elemento da un elenco | x = [1, 5, 6, 7] x.remove (1) uscita: [5, 6, 7] |
| inserire() | Inserisce elementi in una lista | x = [3, 5, 6] x.insert (1, 4) stampa (x) uscita: [1, 4, 3, 5, 6] |
| sort (reverse = condition) | Invertire la direzione degli elementi in un elenco | x = [1, 3, 5, 6] x.sort (reverse = True) stampa (x) uscita: [6, 5, 3, 1] |
| aggiornare() | Aggiorna un dizionario modificando 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) output: {1: 4, 5: 6, 8: 7, 4: 4} |
| chiavi () | Mostra tutte le chiavi in un dizionario | a = {1: 2, 4: 8} a.keys () 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]) |
| elementi() | Visualizza le chiavi e i valori in un dizionario | a = {1: 2, 4: 8} a.items () output: dict_items ([(1, 2), (4, 8)]) |
| ottenere (chiave) | Ottieni il valore di un elemento in un dizionario dalla sua chiave | a = {1: 2, 4: 8, 3: 5} a.get (1) uscita: 2 |
| setdefault (chiave) | Restituisce 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() | Rimuove il primo valore corrispondente di un elemento da un elenco senza preoccuparsi del suo indice | a = [1, 3, 2, 4, 4, 1, 6, 6, 4] a.remove (4) stampa (a) uscita: [1, 3, 2, 4, 1, 6, 6, 4] |
| memoryview (x) | Accedi ai buffer interni di un oggetto | a = memoryview (oggetto) |
| byte () | Converte un protocollo di buffer di memoria in byte | byte (a [0: 2]) |
| bytearray () | Restituisce un array di byte | bytearray (oggetto) |
| # | Scrivere una singola riga di commento o impedire l'esecuzione di una riga di codice | # Cheat sheet di Python regex |
| "" "" "" | Scrivi un commento su più righe | "" "Il cheat di Python regex è buono per i principianti È anche un ottimo ripasso per gli esperti "" " |
| Riga di comando | ||
| pacchetto di installazione pip | Installa una libreria in linea | pip installa i panda |
| nome virtualenv | Usa virtaulenv per creare un ambiente virtuale | virtualenv myproject |
| mkvirtualenv nome | Usa il wrapper dell'ambiente virtuale per creare l'ambiente virtuale | mkvirtualenv myproject |
| python file.py | Esegui i comandi in un file Python | "python mio_file.py |
| pip congelamento | Elenca tutti i pacchetti installati in un ambiente virtuale | pip congelamento |
| pip freeze> alcuni file | Copia tutte le librerie installate in un unico file | pip freeze> requirements.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 ("Hello World!") |
| 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.close | Chiudi un file se non è in uso | af = open ('regex.txt') af.close |
| 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 creativi con loro raffina la tua abilità di codifica. Quindi, oltre ad imparare le sintassi, usale in progetti di vita reale e diventerai un programmatore Python migliore.
