| izdrukāt () |
Parādīt komandas rezultātu |
x = "Sveika pasaule"
drukāt (x)
izeja: Sveika pasaule |
| ievade () |
Vāciet ievadi no lietotājiem |
drukāt (ievade ("kā jūs sauc?"))
izeja: kā tevi sauc? |
| tips () |
Atrodiet mainīgā veidu |
x = "Regulārās izteiksmes"
tips (x)
izeja: |
| len () |
Atrodiet mainīgā vienumu skaitu |
len ([1, 2, 3])
izeja: 3 |
| \ |
Izbēgt no rakstzīmes, kas maina koda rindas nolūku |
drukāt ("Es gribu, lai jūs pievienotu \" \ "")
izvade: Es vēlos, lai jūs pievienotu "" |
| \ n |
Pārtrauciet virknes rakstzīmi, lai sāktu nākamajā rindā |
print ("Šī ir līnija \ n Šī ir otrā rinda")
izeja:
Šī ir līnija
Šī ir otrā rinda |
def function_name (parametrs):
komandas |
Ieslēdziet funkciju ar izvēles parametru |
def yourName (x):
drukāt (x + 1) |
| lambda |
Izsaukt anonīmu funkciju |
add_3_to = lambda y: y + 3
izdrukāt (add_3_to (4))
izeja: 7 |
| atgriešanās |
Atgriež rezultātu no funkcijas |
def yourName (x):
atgriezties x + 1 |
| klasē |
Izveidojiet objektu Python |
klase myClass:
def myFunc (x): |
| def __init__ |
Inicializējiet klases atribūtus |
klase myClass:
def __init __ (sevis, atribūti ...) |
| "__init__.py |
Saglabājiet failu ar moduli, lai tas tiktu veiksmīgi nolasīts citā Python failā |
Pārdēvējiet failu ar moduli kā:
"__init__.py |
| int () |
Pārveidojiet mainīgo par veselu skaitli |
int (1.234)
izeja: 1 |
| str () |
Pārveidojiet mainīgo par virkni |
str (1.234)
izeja: '1.234' |
| pludiņš () |
Pārveidojiet mainīgo uz peldošo |
pludiņš (23)
izeja: 23.0 |
| diktēt (Counter ()) |
Pēc šķirošanas ar Python iebūvēto skaitītāju pārveidojiet sarakstu vai dupleksu vārdnīcā |
no kolekciju importa skaitītājs
diktēt (Skaitītājs ([1,1,2,1,2,3,3,4]))
izvade: {1: 3, 2: 2, 3: 2, 4: 1} |
| raunds() |
Noapaļojiet operācijas rezultātu līdz tuvākajam veselajam skaitlim |
kārta (23.445)
izeja: 23 |
| apaļa (darbība vai skaitlis, aiz komata) |
Darbības rezultātu noapaļo līdz noteiktam skaitlim aiz komata |
kārta (23.4568, 2)
izeja: 23.46 |
| ja: |
Uzsākt nosacītu paziņojumu |
ja 2 <3:
drukāt ("Divi ir mazāki") |
| elifs: |
Veiciet pretstatījumu, ja if apgalvojums ir False |
ja 2 <3:
drukāt ("Divi ir mazāki")
elif 2 == 3:
izdrukāt ("turpināt") |
| cits: |
Ja citi nosacījumi ir nepatiesi, izdariet galīgo pretstatu |
ja 2 <3:
drukāt ("Divi ir mazāki")
elif 2 == 3:
izdrukāt ("turpināt")
cits:
drukāt ("Trīs ir lielāks") |
| Turpināt |
Ignorējiet nosacījumu un izpildiet pārējo cilpu |
a = [1, 4, -10, 6, 8]
attiecībā uz b a:
ja b <= 0:
Turpināt
drukāt (b)
izeja:
1
4
6
8 |
| pārtraukums |
Pārtrauciet cilpa plūsmu ar noteiktu nosacījumu |
a = [1, 4, -10, 6, 8]
attiecībā uz b a:
ja b> = 6:
pārtraukums
drukāt (b)
izeja:
1
4
-10 |
| iziet |
Ignorējiet iepriekšēju instrukciju kopumu |
attiecībā uz b a:
iziet |
mēģiniet, izņemot
|
Izmēģiniet koda bloku, pretējā gadījumā izvirziet noteiktu izņēmumu |
mēģiniet:
druka (a)
izņemot:
print ("Radās kļūda!")
izvade: Radās kļūda! |
| beidzot |
Izpildiet pēdējo kodu, kad mēģinājums un bloki, izņemot blokus, neizdodas |
mēģiniet:
druka (a)
izņemot:
drukāt (d)
visbeidzot:
drukāt ("Jūs nevarat izdrukāt nedefinētu mainīgo")
izvade: Jūs nevarat izdrukāt nedefinētu mainīgo |
| paaugstināt izņēmumu () |
Paaugstiniet izņēmumu, kas aptur komandu, ja izpilde nav iespējama |
a = 7 + 2
ja a <10:
paaugstināt izņēmumu ("Ak! Jūs nesaņēmāt rezultātu 10 ") |
| importēt x |
Importējiet visu moduli vai bibliotēku |
importēt matemātiku |
| no x importa y |
Importējiet bibliotēku x no faila vai klases y |
no scipy.stats importēšanas režīma |
| kā |
Pielāgojiet izteicienu vēlamajam vārdam |
importa pandas kā pd |
| iekšā |
Pārbaudiet, vai mainīgajā ir vērtība |
x = [1, 4, 6, 7]
ja 5 x:
drukāt ("Ir pieci")
cits:
drukāt ("Nav piecu")
izeja: nav piecu |
| ir |
Pārbaudiet, vai divi mainīgie attiecas uz vienu elementu |
x = [1, 4, 6, 7]
x = b
drukāt (x ir b)
Patiesi |
| Nav |
Paziņot par nulles vērtību |
x = nav |
| < |
Pārbaudiet, vai viena vērtība ir mazāka par citu |
5<10
izeja: True |
| > |
Pārbaudiet, vai viena vērtība ir lielāka par citu |
5>10
izeja: Nepatiesa |
| <= |
Pārbaudiet, vai vērtība ir mazāka vai vienāda ar citu |
2*2<=3
izeja: Nepatiesa |
| >= |
Pārbaudiet, vai vērtība ir lielāka vai vienāda ar citu |
2*2>=3
izeja: True |
| "== |
Pārbaudiet, vai vērtība ir tieši vienāda ar otru |
3==4
ouput: Nepatiesa |
| != |
Pārliecinieties, vai vērtība nav vienāda ar otru |
3!=4
ouput: True |
| importa re |
Importējiet Python iebūvētās regulārās izteiksmes |
importa re
re.findall ("virknes", mainīgais) |
| a | b |
Pārbaudiet, vai virknē ir kāds no diviem elementiem |
importa re
someText = "Labdien regulārā izteiksme"
a = re.findall ("regular | Hello", someText)
druka (a)
izvade: ['Sveiki', 'regulāri'] |
| virkne $ |
Pārbaudiet, vai mainīgais beidzas ar virkņu kopu |
importa re
someText = "Labdien regulārā izteiksme"
a = re.findall ("izteiksme $", someText)
izvade: ['izteiksme'] |
| ^ virkne |
Pārbaudiet, vai mainīgais sākas ar virkņu kopu |
importa re
someText = "Labdien regulārā izteiksme"
a = re.findall ("^ Sveiki", someText)
druka (a)
izvade: ['Sveiki'] |
| string.index () |
Pārbaudiet virknes rakstzīmes indeksa pozīciju |
a = "Sveika pasaule"
a. indekss (“H”)
izeja: 0 |
| string.capitalize () |
Sākot ar lielo burtu virkņu virknē |
a = "Sveika pasaule"
a. kapitalizēt ()
izeja: “Sveika pasaule” |
| string.swapcase () |
Izdrukājiet katra vārda pirmo burtu kā mazo un pārējos - kā lielo |
a = "Sveika pasaule"
a. maisiņš ()
izeja:
'Sveika pasaule' |
| string.lower () |
Konvertējiet visas virknes uz mazajiem burtiem |
a = "Sveika pasaule"
a. apakšējā ()
izeja: "sveika pasaule" |
| string.upper () |
Konvertējiet visas virknes uz lielajiem burtiem |
a = "Sveika pasaule"
a.upper ()
izvade: “HELLO WORLD” |
| string.startswith () |
Pārbaudiet, vai virkne sākas ar noteiktu rakstzīmi |
a = "Sveika pasaule"
a. sākums ar 'a'
izeja: Nepatiesa |
| string.endswith () |
Pārbaudiet, vai virkne beidzas ar noteiktu rakstzīmi |
a = "Sveika pasaule"
a. beigas ar ('d')
izeja: True |
| string.split () |
Atdaliet katru vārdu sarakstā |
a = "Sveika pasaule"
a.split ()
izvade: ['Sveiki', 'pasaule'] |
| virknes {} '. format () |
Parādīt izvadi kā virkni |
a = 3 + 4
drukāt ("Atbilde ir {}". formāts (a))
izeja: Atbilde ir 7 |
| nav Neviens |
Pārbaudiet, vai mainīgā vērtība nav tukša |
def checknull (a):
ja a nav Neviens:
atgriezties "pilns!"
cits:
atgriezt "tā tukša!" |
| x% y |
Atrodiet atlikuma (moduļa) dalījumu |
9%4
izeja: 1 |
| x // y |
Atrodiet dalījuma koeficientu |
9//4
izeja: 2 |
| "= |
Piešķirt mainīgajam vērtību |
a = {1: 5, 3: 4} |
| "+ |
Pievienojiet elementus kopā |
["a two"] + ["a one"]
izvade: ['a two', 'a one']
1+3
izeja = 4 |
| "- |
Atrodiet atšķirību starp skaitļu kopu |
3-4
izeja = -1 |
| "* |
Atrodiet skaitļu kopas reizinājumu |
3*4
izeja: 12 |
| a + = x |
Pievienojiet x mainīgajam a, nepiešķirot tā vērtību jaunam mainīgajam |
a = 2
a + = 3
izeja: 5 |
| a- = x |
Atņemiet x no mainīgā a, nepiešķirot to jaunam mainīgajam |
a = 3
a- = 2
izeja: 1 |
| a * = x |
Atrodiet mainīgā a un x reizinājumu, nepiešķirot atkārtotu jaunu mainīgo |
a = [1, 3, 4]
a * = 2
izvade: [1, 3, 4, 1, 3, 4] |
| x ** y |
Paaugstiniet bāzi x līdz jaudai y |
2**3
izeja: 8 |
| pow (x, y) |
Paaugstiniet x līdz y spēkam |
Pow (2, 3)
izeja: 8 |
| abs (x) |
Konvertējiet negatīvo veselu skaitli tā absolūtajā vērtībā |
abs (-5)
izeja: 5 |
| x ** (1 / n) |
Atrodiet skaitļa n-to sakni |
8**(1/3)
izeja: 2 |
| a = b = c = d = x |
Piešķiriet to pašu vērtību vairākiem mainīgajiem |
a = b = c = d = "Sveika pasaule" |
| x, y = y, x |
Mainīt mainīgos |
x = [1, 2]
y = 3
x, y = y, x
drukāt (x, y)
izeja:
3 [1, 2] |
| priekš |
Pārlūkojiet mainīgā elementus |
a = [1, 3, 5]
attiecībā uz b a:
drukāt (b, "x", "2", "=", b * 2)
izeja:
1 x 2 = 2
3 x 2 = 6
5 x 2 = 10 |
| kamēr |
Turpiniet virzīties pa mainīgo, ciktāl konkrēts nosacījums paliek patiess |
a = 4
b = 2
kamēr b <= a:
drukāt (b, "ir mazāks par", a)
b + = 1
izeja:
2 ir mazāks par 4
3 ir mazāks par 4
4 ir mazāks par 4 |
| diapazons () |
Izveidojiet pozitīvu veselu skaitļu diapazonu starp x un y |
x = diapazons (4)
drukāt (x)
diapazons (0, 4)
attiecībā uz b x:
drukāt (b)
izeja:
0
1
2
3 |
| summa () |
Atkārtojiet elementus sarakstā |
drukāt (summa ([1, 2, 3]))
izeja: 6 |
| summa (saraksts, sākums) |
Atgriež saraksta summu ar pievienotu elementu |
drukāt (summa ([1, 2, 3], 3))
izeja: 9 |
| [] |
Izveidojiet elementu sarakstu |
x = ['a', 3, 5, 'h', [1, 3, 3], {'d': 3}] |
| () |
Izveidot tuppletupples nav maināmas |
x = (1, 2, 'g', 5) |
| {} |
Izveidojiet vārdnīcu |
a = {'x': 6, 'y': 8} |
| x [a: b] |
Šķirojiet sarakstu |
x = [1, 3, 5, 6]
x [0: 2]
izeja: [1, 3] |
| x [atslēga] |
Iegūstiet atslēgas vērtību vārdnīcā x |
a = {'x': 6, 'y': 8}
drukāt (a ['x'])
izeja: 6 |
| x.append () |
Pievienojiet vērtību sarakstu tukšam sarakstam |
x = [1]
x.append ([1,2,3])
drukāt (x)
izeja: [1, [1,2,3]] |
| x.extend () |
Pievienojiet vērtību sarakstu, lai turpinātu esošo sarakstu, obligāti neizveidojot ligzdotu sarakstu |
x = [1,2]
x.extend ([3,4,6,2])
drukāt (x)
izeja:
[1, 2, 3, 4, 6, 2] |
| del (x [a: b]) |
Pilnībā izdzēsiet vienumu no saraksta ar noteiktu indeksu |
x = [1,2,3,5]
del (x [0: 2])
drukāt (x)
izeja: [2,3,5]
|
| del (x [taustiņš]) |
Pilnībā izdzēsiet atslēgu un vērtību no vārdnīcas noteiktā rādītājā |
y = {1: 3, 2: 5, 4: 6, 8: 2}
del (y [1], y [8])
drukāt (y)
izvade = {2: 5, 4: 6} |
| dict.pop () |
Atveriet atslēgas vērtību un noņemiet to no vārdnīcas noteiktā rādītājā |
a = {1: 3, 2: 4, 5: 6}
a.pop (1)
izeja: 3 |
| dict.popitem () |
Atveriet pēdējo vienumu no vārdnīcas un izdzēsiet to |
a = {1: 2, 4: 8, 3: 5}
a.popitem ()
izeja: (3, 5)
druka (a)
izvade: {1: 2, 4: 8} |
| list.pop () |
Atveriet norādīto indeksu no saraksta un noņemiet to no saraksta |
a = [1, 3, 2, 4, 1, 6, 6, 4]
a.pop (-2)
izeja: 6
druka (a)
izvade: [1, 3, 2, 4, 1, 6, 4] |
| skaidrs () |
Iztukšojiet saraksta vai vārdnīcas elementus |
x = [1, 3, 5]
x.skaidrs ()
drukāt (x)
izeja: [] |
| noņemt () |
Noņemiet vienumu no saraksta |
x = [1, 5, 6, 7]
x. noņemt (1)
izeja: [5, 6, 7] |
| ievietot () |
Ievietojiet elementus sarakstā |
x = [3, 5, 6]
x. ievietot (1, 4)
drukāt (x)
izeja: [1, 4, 3, 5, 6] |
| kārtot (reverss = nosacījums) |
Reversējiet elementu virzienu sarakstā |
x = [1, 3, 5, 6]
x.sort (reverse = True)
drukāt (x)
izeja: [6, 5, 3, 1] |
| Atjaunināt() |
Atjauniniet vārdnīcu, mainot tās pirmo elementu un tā beigās pievienojot jebkuru citu vienumu |
x = {1: 3, 5: 6}
x.update ({1: 4, 8: 7, 4: 4})
drukāt (x)
izvade: {1: 4, 5: 6, 8: 7, 4: 4} |
| taustiņi () |
Parādīt visus taustiņus vārdnīcā |
a = {1: 2, 4: 8}
a. atslēgas ()
izvade: dict_keys ([1, 4]) |
| vērtības () |
Rādīt visas vērtības vārdnīcā |
a = {1: 2, 4: 8}
a. vērtības ()
izvade: dict_values ([2, 8]) |
| preces () |
Parādiet atslēgas un vērtības vārdnīcā |
a = {1: 2, 4: 8}
a. preces ()
izvade: dict_items ([(1, 2), (4, 8)]) |
| iegūt (atslēga) |
Iegūstiet vārdnīcas vienuma vērtību ar tā taustiņu |
a = {1: 2, 4: 8, 3: 5}
a.get (1)
izeja: 2 |
| setdefault (atslēga) |
Atgrieziet sākotnējo elementa vērtību vārdnīcā |
a. setdefault (2) |
| f = {** a, ** b} |
Apvienojiet divas vārdnīcas |
a = {'x': 6, 'y': 8}
b = {'c': 5, 'd': 3}
f = {** a, ** y}
druka (f)
izvade: {'x': 6, 'y': 8, 'c': 5, 'd': 3} |
| noņemt () |
Noņemiet elementa pirmo atbilstošo vērtību no saraksta, neņemot vērā tā indeksu |
a = [1, 3, 2, 4, 4, 1, 6, 6, 4]
a. noņemt (4)
druka (a)
izeja: [1, 3, 2, 4, 1, 6, 6, 4] |
| atmiņas skats (x) |
Piekļūstiet objekta iekšējiem buferiem |
a = atmiņas skats (objekts) |
| baiti () |
Pārveidojiet atmiņas bufera protokolu baitos |
baiti (a [0: 2]) |
| bytearray () |
Atgrieziet baitu masīvu |
bytearray (objekts) |
| # |
Uzrakstiet vienu komentāru rindiņu vai novērsiet koda rindas izpildi |
# Python regex apkrāptu lapa |
| Uzrakstiet vairāku rindiņu komentāru |
Python regex apkrāptu lapa ir laba iesācējiem
Tas ir vienlīdz liels atsvaidzinājums ekspertiem |
| Komandrinda |
| pip instalēt paketi |
Instalējiet tiešsaistes bibliotēku |
pip instalēt pandas |
| virtualenv nosaukums |
Izmantojiet virtaulenv, lai izveidotu virtuālu vidi |
virtualenv myproject |
| mkvirtualenv nosaukums |
Izmantojiet virtuālās vides iesaiņotāju, lai izveidotu virtuālo vidi |
mkvirtualenv myproject |
| python file.py |
Palaidiet komandas Python failā |
"python my_file.py |
| pip iesaldēt |
Uzskaitiet visas virtuālajā vidē instalētās pakotnes |
pip iesaldēt |
| pip iesaldēt> daži faili |
Kopējiet visas instalētās bibliotēkas vienā failā |
pip iesaldēt> prasības.txt |
| kur |
Atrodiet Python instalācijas ceļu |
kur pitons |
| --versija |
Pārbaudiet pakotnes versiju |
pitons --versija |
| .exe |
Palaidiet Python apvalku |
python.exe |
| ar atvērtu (fails, 'w') |
Rakstiet uz esošu failu un pārrakstiet tā esošo saturu |
ar atvērtu ('regex.txt', 'w') kā wf:
wf.write ("Sveika pasaule!") |
| ar atvērtu (fails, 'r') |
Atveriet failu kā tikai lasāmu |
ar atvērtu ('regex.txt', 'r') kā rf:
drukāt (rf.read () |
| ar atvērtu (fails, 'a') |
Rakstiet failā, nepārrakstot tā esošo saturu |
ar atvērtu ('regex.txt', 'a') kā af:
af.write ("\ nLabdien, jā!") |
| file.close |
Aizveriet failu, ja tas netiek izmantots |
af = atvērts ('regex.txt')
af.slēgt |
| Izeja |
Iziet no Python apvalka |
Izeja() |
