Home-theater-designers
Användningen av Python för att lösa olika tekniska problem och dess enkla inlärningskurva har gjort det till ett av de mest populära moderna programmeringsspråken. Trots att de är snabba att lära sig kan dess regelbundna uttryck vara knepiga, särskilt för nykomlingar.
roliga saker att göra på din telefon när du är uttråkad
Även om Python har många bibliotek, är det klokt att du känner till dina vanliga syntaxer. Även om du är expert på det finns det en chans att du fortfarande behöver leta upp några Python-kommandon för att uppdatera ditt minne.
Av den anledningen har vi förberett detta fuskblad för Python -reguljära uttryck för att hjälpa dig att få bättre koll på dina syntaxer.
GRATIS NEDLADDNING: Detta fuskblad finns som en nedladdningsbar PDF från vår distributionspartner, TradePub. Du måste fylla i ett kort formulär för att komma åt det för första gången. Ladda ner Python RegEx fuskblad för spirande programmerare .
Python RegEx fuskblad för spirande programmerare
| Uttryck | Handling | Exempel |
|---|---|---|
| skriva ut() | Visa resultatet av ett kommando | x = 'Hej världen' skriva ut (x) utgång: Hej världen |
| inmatning() | Samla in input från användare | print (input ('vad heter du?')) output: vad heter du? |
| typ() | Hitta typen av en variabel | x = 'Vanliga uttryck' typ (x) produktion: |
| len () | Hitta antalet objekt i en variabel | len ([1, 2, 3]) utgång: 3 |
| Undvik ett tecken som ändrar avsikten med en kodrad | print ('Jag vill att du lägger till ' '') output: Jag vill att du lägger till '' | |
| n | Bryt ett strängtecken för att börja på nästa rad | print ('Detta är en rad n Detta är en andra rad') produktion: Detta är en linje Detta är en andra rad |
| def function_name (parameter): kommandon | Starta en funktion med en valfri parameter | def yourName (x): skriva ut (x+1) |
| lambda | Ring en anonym funktion | add_3_to = lambda y: y + 3 print (add_3_to (4)) utgång: 7 |
| lämna tillbaka | Returnera ett resultat från en funktion | def yourName (x): retur x+1 |
| klass | Skapa ett Python -objekt | klass myClass: def myFunc (x): |
| def __init__ | Initiera attributen för en klass | klass myClass: def __init __ (själv, attribut ...) |
| '__init__.py | Spara en fil som innehåller en modul så att den läses framgångsrikt i en annan Python -fil | Byt namn på en fil som innehåller en modul som: '__init__.py |
| int () | Konvertera en variabel till heltal | int (1,234) utgång: 1 |
| str () | Konvertera en variabel till sträng | str (1 234) utgång: '1.234' |
| flyta() | Konvertera en variabel till float | flyta (23) utgång: 23,0 |
| dict (Counter ()) | Konvertera en lista eller en tupple till en ordlista efter sortering med en inbyggd Python-räknare | från samlingar importera räknare dict (Counter ([1,1,2,1,2,3,3,4])) utgång: {1: 3, 2: 2, 3: 2, 4: 1} |
| runda() | Avrunda resultatet av en operation till närmaste heltal | runda (23.445) utgång: 23 |
| rund (operation eller tal, decimaler) | Avrunda resultatet av en operation till ett visst antal decimaler | rund (23.4568, 2) utgång: 23,46 |
| om: | Inleda ett villkorligt uttalande | om 2<3: print ('Två är mindre') |
| älva: | Gör en motstatement när if -påståendet är falskt | om 2<3: print ('Två är mindre') elif 2 == 3: print ('Fortsätt') |
| annan: | Gör en sista motstatement om andra villkor är falska | om 2<3: print ('Två är mindre') elif 2 == 3: print ('Fortsätt') annan: print ('Tre är större') |
| Fortsätta | Ignorera ett villkor och kör resten av slingan | a = [1, 4, -10, 6, 8] för b i a: om b<=0: Fortsätta tryck (b) produktion: 1 4 6 8 |
| ha sönder | Avsluta flödet av en slinga med ett givet villkor | a = [1, 4, -10, 6, 8] för b i a: om b> = 6: ha sönder tryck (b) produktion: 1 4 -10 |
| passera | Ignorera en uppsättning tidigare instruktioner | för b i a: passera |
| försök, förutom | Prova ett kodblock, annars, höj ett definierat undantag | Prova: skriva ut (a) bortsett från: print ('Ett fel uppstod!') output: Ett fel uppstod! |
| till sist | Kör en sista kod när försöket och undantagsblocken misslyckas | Prova: skriva ut (a) bortsett från: tryck (d) till sist: print ('Du kan inte skriva ut en odefinierad variabel') output: Du kan inte skriva ut en odefinierad variabel |
| höja undantag () | Häv ett undantag som stoppar kommandot när körning inte är möjlig | a = 7 + 2 Om en<10: höja undantag ('Åh! Du fick inte poängen 10') |
| importera x | Importera en hel modul eller ett bibliotek | import matematik |
| från x import y | Importera ett bibliotek x från en fil eller en klass y | från scipy.stats importläge |
| som | Anpassa ett uttryck till ditt föredragna namn | importera pandor som pd |
| i | Kontrollera om ett värde finns i en variabel | x = [1, 4, 6, 7] om 5 i x: print ('Det finns en femma') annan: print ('Det finns inga fem') utgång: Det finns inga fem |
| är | Kontrollera om två variabler hänvisar till ett enda element | x = [1, 4, 6, 7] x = b tryck (x är b) Sann |
| Ingen | Deklarera ett nollvärde | x = Inget |
| < | Kontrollera om ett värde är mindre än ett annat | 5<10 utgång: Sant |
| > | Kontrollera om ett värde är mer än ett annat | 5> 10 utgång: Falskt |
| <= | Kontrollera om ett värde är mindre eller lika med ett annat | 2 * 2<=3 utgång: Falskt |
| > = | Kontrollera om ett värde är större eller lika med ett annat | 2 * 2> = 3 utgång: Sant |
| '== | Kontrollera om ett värde är exakt lika med det andra | 3 == 4 ut: Falskt |
| ! = | Kontrollera att ett värde inte är lika med det andra | 3! = 4 ut: Sant |
| importera re | Importera Pythons inbyggda reguljära uttryck | importera re re.findall ('strängar', variabel) |
| a | b | Kontrollera om något av två element finns i en sträng | importera re someText = 'Hej reguljärt uttryck' a = re.findall ('vanlig | Hej', someText) skriva ut (a) output: ['Hej', 'vanlig'] |
| sträng $ | Kontrollera om en variabel slutar med en uppsättning strängar | importera re someText = 'Hej reguljärt uttryck' a = re.findall ('expression $', someText) output: ['expression'] |
| ^sträng | Kontrollera om en variabel börjar med en uppsättning strängar | importera re someText = 'Hej reguljärt uttryck' a = re.findall ('^Hej', someText) skriva ut (a) utmatning: ['Hej'] |
| string.index () | Kontrollera indexpositionen för ett strängtecken | a = 'Hej världen' a.index ('H') utgång: 0 |
| string.capitalize () | Använd det första tecknet i en uppsättning strängar | a = 'Hej världen' a.kapitalisera () output: 'Hej världen' |
| string.swapcase () | Skriv ut den första bokstaven i varje ord som gemener och de andra som versaler | a = 'Hej världen' a.wapcase () produktion: 'Hej världen' |
| string.lower () | Konvertera alla strängar till gemener | a = 'Hej världen' en lägre() output: 'hej världen' |
| string.upper () | Konvertera alla strängar till versaler | a = 'Hej världen' a.upper () utgång: 'HELLO WORLD' |
| string.startswith () | Kontrollera om en sträng börjar med ett visst tecken | a = 'Hej världen' a.startswith ('a') utgång: Falskt |
| string.endswith () | Kontrollera om en sträng slutar med ett visst tecken | a = 'Hej världen' a.endswith ('d') utgång: Sant |
| string.split () | Separera varje ord i en lista | a = 'Hej världen' a.split () output: ['Hej', 'värld'] |
| strings {} '. format () | Visa en utmatning som sträng | a = 3 + 4 print ('Svaret är {}'. format (a)) output: Svaret är 7 |
| är ingen | Kontrollera om värdet på en variabel inte är tomt | def checknull(a): om a inte är Ingen: tillbaka 'det är fullt!' annan: returnera 'det är tomt!' |
| x% y | Hitta resten (modul) av en division | 9% 4 utgång: 1 |
| x // y | Hitta kvoten för en division | 9 // 4 utgång: 2 |
| '= | Tilldela ett värde till en variabel | a = {1: 5, 3: 4} |
| '+ | Lägg till element tillsammans | ['a two'] + ['a one'] output: ['a two', 'a one'] 1 + 3 utgång = 4 |
| '- | Hitta skillnaden mellan en uppsättning siffror | 3-4 utgång = -1 |
| '* | Hitta produkten från en uppsättning siffror | 3 * 4 utgång: 12 |
| a+= x | Lägg till x till variabel a utan att tilldela dess värde till en ny variabel | a = 2 a + = 3 utgång: 5 |
| a- = x | Subtrahera x från variabel a utan att tilldela den en ny variabel | a = 3 a- = 2 utgång: 1 |
| a*= x | Hitta produkten av variabel a och x utan att tilldela resullt till en ny variabel | a = [1, 3, 4] a * = 2 utgång: [1, 3, 4, 1, 3, 4] |
| x ** y | Höj basen x för att driva y | 2 ** 3 utgång: 8 |
| pow (x, y) | Höj x till kraften y | område (2, 3) utgång: 8 |
| abs (x) | Konvertera ett negativt heltal till dess absoluta värde | abs (-5) utgång: 5 |
| x ** (1/nth) | Hitta den n: a roten av ett tal | 8 ** (1/3) utgång: 2 |
| a = b = c = d = x | Tilldela flera värden samma värde | a = b = c = d = 'Hej världen' |
| x, y = y, x | Byt variabler | x = [1, 2] y = 3 x, y = y, x skriva ut (x, y) produktion: 3 [1, 2] |
| för | Gå igenom elementen i en variabel | a = [1, 3, 5] för b i a: print (b, 'x', '2', '=', b*2) produktion: 1 x 2 = 2 3 x 2 = 6 5 x 2 = 10 |
| medan | Fortsätt att gå igenom en variabel så långt ett visst villkor förblir sant | a = 4 b = 2 medan b<=a: tryck (b, 'är mindre än', a) b + = 1 produktion: 2 är mindre än 4 3 är mindre än 4 4 är mindre än 4 |
| räckvidd() | Skapa en rad positiva heltal mellan x och y | x = intervall (4) skriva ut (x) intervall (0, 4) för b i x: tryck (b) produktion: 0 1 2 3 |
| belopp() | Iterera genom elementen i en lista | print (summa ([1, 2, 3])) utgång: 6 |
| summa (lista, start) | Returnera summan av en lista med ett extra element | print (summa ([1, 2, 3], 3)) utgång: 9 |
| [] | Gör en lista med element | x = ['a', 3, 5, 'h', [1, 3, 3], {'d': 3}] |
| () | Skapa en tuppel --- tupplar är oföränderliga | x = (1, 2, 'g', 5) |
| {} | Skapa en ordbok | a = {'x': 6, 'y': 8} |
| x [a: b] | Skär igenom en lista | x = [1, 3, 5, 6] x [0: 2] utgång: [1, 3] |
| x [nyckel] | Få värdet på en nyckel i ordlistan x | a = {'x': 6, 'y': 8} skriva ut (a ['x']) utgång: 6 |
| x.append () | Lägg till en lista med värden i en tom lista | x = [1] x. lägg till ([1,2,3]) skriva ut (x) utgång: [1, [1,2,3]] |
| x.extend () | Lägg till en lista med värden för att fortsätta en befintlig lista utan att nödvändigtvis skapa en kapslad lista | x = [1,2] x.förlänga ([3,4,6,2]) skriva ut (x) produktion: [1, 2, 3, 4, 6, 2] |
| del (x [a: b]) | Ta bort ett objekt helt från en lista vid ett specifikt index | x = [1,2,3,5] del (x [0: 2]) skriva ut (x) utgång: [2,3,5] |
| del (x [nyckel]) | Radera en nyckel och ett värde helt från en ordlista vid ett visst index | y = {1: 3, 2: 5, 4: 6, 8: 2} del (och [1] och [8]) skriva ut (och) output = {2: 5, 4: 6} |
| dict.pop () | Ta fram värdet på en nyckel och ta bort den från en ordlista vid ett visst index | a = {1: 3, 2: 4, 5: 6} a.pop (1) utgång: 3 |
| dict.popitem () | Ta fram det sista objektet från en ordlista och ta bort det | a = {1: 2, 4: 8, 3: 5} a.popitem () utgång: (3, 5) skriva ut (a) utdata: {1: 2, 4: 8} |
| list.pop () | Ta fram ett givet index från en lista och ta bort det från en lista | a = [1, 3, 2, 4, 1, 6, 6, 4] a.pop (-2) utgång: 6 skriva ut (a) utgång: [1, 3, 2, 4, 1, 6, 4] |
| klar() | Töm elementen i en lista eller en ordlista | x = [1, 3, 5] x.clear () skriva ut (x) utgång: [] |
| avlägsna() | Ta bort ett objekt från en lista | x = [1, 5, 6, 7] x. ta bort (1) utgång: [5, 6, 7] |
| Föra in() | Infoga element i en lista | x = [3, 5, 6] x. infoga (1, 4) skriva ut (x) utgång: [1, 4, 3, 5, 6] |
| sortera (omvänd = skick) | Omvänd riktningen för elementen i en lista | x = [1, 3, 5, 6] x.sort (omvänd = sant) skriva ut (x) utgång: [6, 5, 3, 1] |
| uppdatering() | Uppdatera en ordlista genom att ändra dess första element och lägga till andra objekt i slutet | x = {1: 3, 5: 6} x.uppdatering ({1: 4, 8: 7, 4: 4}) skriva ut (x) utgång: {1: 4, 5: 6, 8: 7, 4: 4} |
| nycklar () | Visa alla nycklar i en ordbok | a = {1: 2, 4: 8} a. nycklar () output: dict_keys ([1, 4]) |
| värden () | Visa alla värden i en ordbok | a = {1: 2, 4: 8} a.values () output: dict_values ([2, 8]) |
| objekt () | Visa knapparna och värdena i en ordbok | a = {1: 2, 4: 8} a.items () output: dict_items ([(1, 2), (4, 8)]) |
| få (nyckel) | Få värdet på ett objekt i en ordbok med dess nyckel | a = {1: 2, 4: 8, 3: 5} a.get (1) utgång: 2 |
| setdefault (nyckel) | Returnera det ursprungliga värdet för ett element till en ordlista | a.setdefault (2) |
| f = {** a, ** b} | Slå ihop två ordböcker | a = {'x': 6, 'y': 8} b = {'c': 5, 'd': 3} f = {** a, ** y} tryck (f) utdata: {'x': 6, 'y': 8, 'c': 5, 'd': 3} |
| avlägsna() | Ta bort det första matchningsvärdet för ett element från en lista utan att tänka på dess index | a = [1, 3, 2, 4, 4, 1, 6, 6, 4] a. ta bort (4) skriva ut (a) utgång: [1, 3, 2, 4, 1, 6, 6, 4] |
| memoryview (x) | Få åtkomst till ett intern buffert | a = memoryview (objekt) |
| byte () | Konvertera ett minnesbuffertprotokoll till byte | byte (a [0: 2]) |
| bytearray () | Returnera en rad byte | bytearray (objekt) |
| # | Skriv en enda rad med kommentarer eller förhindra att en kodrad körs | # Python regex fuskblad |
| '' '' '' | Skriv en kommentar med flera rader | '' 'Python regex -fuskbladet är bra för nybörjare Det är lika bra för experter '' |
| Kommandorad | ||
| pip -installationspaket | Installera ett onlinebibliotek | pip installera pandor |
| virtualenv -namn | Använd virtaulenv för att skapa en virtuell miljö | virtualenv mitt projekt |
| mkvirtualenv namn | Använd virtuell miljöomslag för att skapa virtuell miljö | mkvirtualenv mitt projekt |
| python -fil.py | Kör kommandona i en Python -fil | 'python min_fil.py |
| pip fryser | Lista alla installerade paket i en virtuell miljö | pip fryser |
| pipfrysning> några filer | Kopiera alla installerade bibliotek i en enda fil | pipfrysning> krav.txt |
| var | Hitta installationsvägen för Python | där python |
| --version | Kontrollera versionen av ett paket | python -version |
| .exe | Kör ett Python -skal | python.exe |
| med öppen (fil, 'w') | Skriv till en befintlig fil och skriv över dess befintliga innehåll | med öppen ('regex.txt', 'w') som wf: wf.write ('Hej världen!') |
| med öppen (fil, 'r') | Öppna en fil som skrivskyddad | med open ('regex.txt', 'r') som rf: print (rf.read () |
| med öppen (fil, 'a') | Skriv till en fil utan att skriva över dess befintliga innehåll | med öppen ('regex.txt', 'a') som af: af.write (' nHej ja!') |
| file.close | Stäng en fil om den inte används | af = open ('regex.txt') af. stänga |
| utgång | Avsluta Python -skalet | utgång() |
Bli kreativ när du använder Python
Att lära sig Pythons reguljära uttryck är ett stort steg mot att bli en bättre Python -programmerare, men det är bara en av få saker du behöver göra.
Men att leka med sina syntaxer och bli kreativ med dem polerar din kodningsförmåga. Så utöver att lära dig syntaxerna, använd dem i verkliga projekt och du kommer att bli en bättre Python-programmerare.
Dela med sig Dela med sig Tweet E-post Hur man skapar, importerar och återanvänder din egen modul i PythonVi förklarar en viktig grund för återanvändning av kod i Python: moduler.
Läs Nästa Relaterade ämnen
- Programmering
- Fusklapp
- Pytonorm
Idowu brinner för allt smart teknik och produktivitet. På fritiden leker han med kodning och byter till schackbrädet när han har tråkigt, men han älskar också att bryta sig från rutinen då och då. Hans passion för att visa människor vägen kring modern teknik motiverar honom att skriva mer.
Mer från Idowu OmisolaPrenumerera på vårt nyhetsbrev
Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!
Klicka här för att prenumerera