1. ProgrammingPythonKā lietot Lambda funkcijas Python

Autori Alans Šovics, Džons Šovics

Python atbalsta anonīmo funkciju jēdzienu, ko sauc arī par lambda funkcijām. Nosaukuma anonīmā daļa ir balstīta uz faktu, ka funkcijai nav jābūt nosaukumam (bet var būt, ja vēlaties). Lambda daļas pamatā ir atslēgvārda lambda izmantošana, lai tās definētu Python. Lambda ir arī grieķu alfabēta 11. burts.

Bet galvenais iemesls, kāpēc nosaukums tiek izmantots Python, ir tas, ka termins lambda tiek izmantots, lai aprakstītu anonīmas funkcijas kalkulā. Tagad, kad esam to noskaidrojuši, varat izmantot šo informāciju, lai rosinātu aizraujošu sarunu biroja ballītēs.

Minimālā sintakse lambda izteiksmes (bez nosaukuma) noteikšanai ar Python ir:

Lambda argumenti: izteiksme

Lietojot to:

  • Aizstāt argumentus ar datiem, kas tiek nodoti izteiksmē. Aizstājiet izteiksmi ar izteiksmi (formulu), kas nosaka to, ko vēlaties, lai lambda atgrieztos.

Diezgan izplatīts šīs sintakse izmantošanas piemērs ir mēģinājums kārtot teksta virknes, kur daži nosaukumi sākas ar lielajiem burtiem, bet daži sākas ar mazajiem burtiem, kā šie nosaukumi:

Adams, Ma, diMeola, Zandusky

Pieņemsim, ka jūs uzrakstāt šo kodu, lai nosaukumus ievietotu sarakstā, kārtotu to un pēc tam izdrukātu sarakstu šādi:

nosaukumi = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort ()
drukāt (vārdi)

Rezultāts no tā ir:

['Adams', 'Ma', 'Zandusky', 'diMeola']

Tas, ka diMeola nāk pēc Zandusky, dažiem iesācējiem šķiet nepareizs. Bet datori ne vienmēr redz lietas tā, kā mēs. (Patiesībā viņi neko “neredz”, jo viņiem nav acu vai smadzeņu… bet tas ir pilnīgi bezjēdzīgi.) Iemesls, kāpēc diMeola nāk pēc Zandusky, ir tas, ka veida pamatā ir ASCII, kas ir sistēma, kurā katrs rakstzīmi attēlo cipars.

Visiem mazajiem burtiem ir skaitļi, kas ir lielāki nekā lielie burti. Tātad, šķirojot, visi vārdi, kas sākas ar mazajiem burtiem, nāk aiz vārdiem, kas sākas ar lielajiem burtiem. Ja nekas cits, tas vismaz attaisno nepilngadīgu hmm.

Lai palīdzētu šajos jautājumos, Python kārtošanas () metode ļauj iekavās ietvert atslēgu = izteiksmi, kur jūs varat pateikt, kā kārtot. Sintakse ir:

.sort (atslēga = pārveidot)

Pārveidošanas daļa ir dažas variācijas par šķirotajiem datiem. Ja jums ir paveicies un viena no iebūvētajām funkcijām, piemēram, len (ilgumam), jums noderēs, pārveidošanas vietā varat to izmantot tikai šādi:

names.sort (atslēga = len)

Mums diemžēl virknes garums nepalīdz alfabētiskā secībā. Tātad, kad jūs to izpildāt, secība izrādās:

['Ma', 'Adams', 'diMeola', 'Zandusky']

Kārtošana notiek no īsākās virknes (tā, kurai ir mazāk rakstzīmju) līdz garākajai virknei. Pašlaik nav noderīga.

Jūs nevarat rakstīt taustiņu = mazāku vai taustiņu = augšējo, lai kārtotu arī ar visiem mazajiem burtiem vai visiem lielajiem burtiem, jo ​​mazie un augšējie nav iebūvētas funkcijas (kuras diezgan ātri varat pārbaudīt, izmantojot iebūvēto googling python 3.7 funkcijas).

Iebūvētas funkcijas vietā varat izmantot pielāgotu funkciju, kuru pats definējat, izmantojot def. Piemēram, jūs varat izveidot funkciju ar zemāku (), kas pieņem virkni un atgriež šo virkni ar visiem tās burtiem, kas pārveidoti par mazajiem. Šī ir funkcija:

def zemāks (anystring):
"" "Pārveido virkni uz visiem mazajiem burtiem" ""
atgriezties anystring.lower ()

Nosaukums zemāks ir veidots, un anystring ir vietturis jebkurai virknei, kuru jūs tai nodosit nākotnē. Atgriešanās anystring.lower () atgriež šo virkni, kas pārveidota par visiem mazajiem burtiem, izmantojot str (virknes) objekta metodi .lower (). (Plašāku informāciju lasiet par Python virkņu metodēm.)

Kārtošanas () iekavās nevar izmantot taustiņu = zemāks, jo zemāks () nav iebūvēta funkcija. Tā ir metode ... nav tā pati. Tas ir kaitinoši ar visiem šiem vārdiem.

Pieņemsim, ka jūs rakstāt šo funkciju Jupyter šūnā vai .py failā. Tad jūs izsaucat funkciju ar kaut ko līdzīgu drukāšanai (mazais burts ('Zandusky')). Kā izvadi tiek iegūta virkne, kas pārveidota par visiem mazajiem burtiem, kā redzat zemāk.

pielāgota funkcija zemāka () Python

Labi, tāpēc tagad jums ir pielāgota funkcija, lai pārveidotu jebkuru virkni visiem mazajiem burtiem. Kā jūs to izmantojat kā kārtošanas atslēgu? Viegli, izmantojiet taustiņu = pārveidojiet tāpat kā iepriekš, bet aizstājiet pārveidi ar savu pielāgoto funkcijas nosaukumu. Funkcija tiek nosaukta par mazajiem burtiem, tāpēc jūs izmantosit .sort (taustiņš = mazais burts), kā parādīts tālāk.

def mazie burti (anystring):
"" "Pārveido virkni uz visiem mazajiem burtiem" ""
atgriezties anystring.lower ()
 
nosaukumi = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort (atslēga = mazie burti)

Palaižot šo kodu, lai parādītu vārdu sarakstu, tie tiek nodoti pareizajā secībā, jo tas kārtoja šķiršanu uz stīgām, kuras visas ir ar mazajiem burtiem. Izvade ir tāda pati kā iepriekš, jo tikai šķirošanā, kas notika aiz ainas, tika izmantoti mazie burti. Sākotnējie dati joprojām ir sākotnējie lielie un mazie burti.

'Adams', 'diMeola', 'Ma', 'Zandusky'

Ja pēc tam, kad esat izlasījis visu, jūs joprojām esat nomodā un esat apzināts, iespējams, domājat: “Labi, jūs atrisinājāt šķirošanas problēmu. Bet es domāju, ka mēs šeit runājam par lambda funkcijām. Kur ir lambda funkcija? ”Pagaidām nav lambda funkcijas.

Bet tas ir lielisks piemērs tam, kur jūs varētu izmantot lambda funkciju, jo Python funkcija, kurai jūs zvanāt, mazie burti () visu savu darbu veic tikai ar vienu koda rindu: return anystring.lower ().

Kad jūsu funkcija var paveikt savu darbību ar vienkāršu vienrindas izteiksmi, jūs varat izlaist def un funkcijas nosaukumu un vienkārši izmantot šo sintakse:

lambda parametri: izteiksme

Aizstājiet parametrus ar vienu vai vairākiem parametru nosaukumiem, kurus jūs pats izveidojat (nosaukumi iekavās aiz def un funkcijas nosaukums parastajā funkcijā). Aizstājiet izteiksmi ar to, kurai vēlaties, lai funkcija atgrieztos bez vārda atgriešanās. Tātad šajā piemērā atslēga, izmantojot izteiksmi lambda, būtu šāda:

lambda anystring: anystring.lower ()

Tagad jūs varat redzēt, kāpēc tā ir anonīma funkcija. Visa pirmā rinda ar funkcijas nosaukumu mazajiem burtiem () ir noņemta. Tāpēc lambda izteiksmes izmantošanas priekšrocība ir tā, ka jums nemaz nav vajadzīga ārējā pielāgotā funkcija. Jums vienkārši nepieciešams parametrs, kam seko kols, un izteiciens, kas pasaka, ko atgriezt.

Zemāk redzamais attēls parāda pilnu kodu un tā palaišanas rezultātu. Jūs saņemat pareizu kārtošanas pasūtījumu, nepieprasot klienta ārēju funkciju, piemēram, mazo burtu (). Kā šķirošanas taustiņu jūs vienkārši izmantojat anystring: anystring.lower () (aiz vārda lambda).

Python lambda izteiksme

Piebildīsim arī, ka anystring ir garāks parametru nosaukums, nekā vairums Pythonistas izmantotu. Pūtona ļaudīm patīk īsie vārdi, pat viena burta vārdi. Piemēram, antistringus var aizstāt ar s (vai jebkuru citu burtu), kā norādīts tālāk, un kods darbosies tieši tāpat:

nosaukumi = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort (taustiņš = lambda s: s.lower ())
drukāt (vārdi)

Ceļā atpakaļ šīs tirādes sākumā tika minēts, ka lambda funkcijai nav jābūt anonīmai. Jūs varat dot viņiem vārdus un piezvanīt viņiem tāpat kā citām funkcijām.

Piemēram, šeit ir lambda funkcija ar nosaukumu valūta, kas ņem jebkuru skaitli un atgriež virkni valūtas formātā (tas ir, ar vadošu dolāra zīmi, komatu starp tūkstošiem un diviem cipariem pensiem):

valūta = lambda n: f "$ {n:,. 2f}"

Šeit ir viens nosaukts procents, kas reizina jebkuru jums nosūtītu numuru ar 100 un parāda to ar divu procentu zīmi beigās:

procenti = lambda n: f "{n: .2%}"

Šajā attēlā ir parādīti abu funkciju piemēri, kas definēti Jupyter šūnas augšdaļā. Pēc tam dažos drukātajos paziņojumos funkcijas tiek izsauktas pēc nosaukuma un tām nodoti daži datu dati. Katrā drukāšanas () paziņojumā tiek parādīts numurs vēlamajā formātā.

Python formatēšanas skaitļi

Iemesls, kāpēc jūs tos varat definēt kā vienas līnijas lambdas, ir tāpēc, ka jūs varat visu darbu veikt vienā rindā, f "$ {n:,. 2f}" pirmajai un f "{n: .2%}" - otrais. Bet tikai tāpēc, ka varat to izdarīt šādi, nenozīmē, ka jums tas ir jādara. Jūs varētu izmantot arī parastās funkcijas:

# Rādīt numuru valūtas formātā.
def valūta (n):
atgriezt f "$ {n:,. 2f}"
 
def procenti (n):
# Rādīt numuru procentos.
atgriezt f "{n: .2%}"

Izmantojot šo garāko sintakse, jūs varētu ievadīt arī vairāk informācijas. Piemēram, jums var būt noklusējuma iestatījums formātā, kas izlīdzināts pa labi noteiktā platumā (teiksim, 15 rakstzīmes), tāpēc visi skaitļi iznāca pa labi, izlīdzināti vienā platumā. Attēlā parādīta šī abu funkciju variācija.

Python formatēšanas funkcijas fiksētais platums

Iepriekš redzamajā attēlā otrais parametrs nav obligāts un noklusējuma vērtība ir 15, ja tas netiek izlaists. Tātad, ja jūs to saucat šādi:

drukāt (valūta (9999))

… Jūs saņemat USD 9 999,00 polsterējumu ar pietiekami daudz atstarpes kreisajā pusē, lai tas būtu 15 rakstzīmju platumā. Ja tā vietā jūs to saucat:

drukāt (valūta (9999,20)

… Jūs joprojām saņemat USD 9 999,00, bet kreisajā pusē ir pietiekami daudz vietu, lai tā būtu 20 rakstzīmes plata.

Iepriekš izmantotā .ljust () ir Python iebūvēta virknes metode, kas virknes kreiso pusi aizpilda ar pietiekamām atstarpēm, lai tā būtu norādītajā platumā. Ir arī metode rjust (), lai noregulētu labo pusi. Varat arī norādīt rakstzīmi, kas nav atstarpe. Google python 3 veiciet pareizību, ja jums nepieciešama papildu informācija.

Tātad jums tas ir, spēja izveidot savas pielāgotās funkcijas Python. Reālajā dzīvē tas, ko vēlaties darīt, ir tāds, ka vienmēr, kad konstatējat, ka lietotnē atkal un atkal ir jāpiekļūst vienam un tam pašam koda fragmentam - tai pašai pieteikšanās daļai, nekopējiet / ielīmējiet to kods atkal un atkal. Tā vietā ielieciet visu šo kodu funkcijā, kurai varat piezvanīt pēc nosaukuma.

Tādā veidā, ja jūs nolemjat mainīt Python virknes kodu, jums nav jāmeklē jūsu lietotne, lai atrastu visas vietas, kuras jāmaina. Vienkārši nomainiet to funkcijā, kur tas viss ir definēts vienā vietā.

  1. ProgrammingPythonKā definēt un izmantot Python sarakstus

Autori Alans Šovics, Džons Šovics

Vienkāršākais Python datu apkopojums ir saraksts. Saraksts ir jebkurš datu vienumu saraksts, kas atdalīts ar komatiem, kvadrātiekavās. Parasti Python sarakstam jūs piešķirat vārdu, izmantojot zīmi =, tāpat kā ar mainīgajiem. Ja sarakstā ir skaitļi, nelietojiet pēdiņas ap tiem. Piemēram, šeit ir pārbaudījumu rezultātu saraksts:

rādītāji = [88., 92., 78., 90., 98., 84.]

Ja sarakstā ir virknes, tad, piemēram, šīs virknes, kā vienmēr, ir jāiekļauj pēdiņās ar vienreizēju vai divkāršu rakstzīmi, kā šajā piemērā:

Lai ekrānā parādītu saraksta saturu, varat to izdrukāt tāpat kā jebkuru parasto mainīgo. Piemēram, displeja (studentu) veikšana kodā pēc šī saraksta noteikšanas to parāda uz ekrāna.

['Marks', 'Amber', 'Todd', 'Anita', 'Sandy']

Tas var nebūt tieši tas, kas jums bija prātā. Bet neuztraucieties, Python piedāvā daudz lielisku iespēju piekļūt datiem sarakstos un parādīt tos, cik vien vēlaties.

Atsauces uz Python saraksta vienumiem pēc pozīcijas

Katram saraksta vienumam ir pozīcijas numurs, kas sākas ar nulli, kaut arī jūs neredzat nevienu numuru. Uz jebkuru saraksta vienumu var atsaukties pēc tā numura, izmantojot saraksta nosaukumu, kam seko numurs kvadrātiekavās. Citiem vārdiem sakot, izmantojiet šo sintakse:

saraksta nosaukums [x]

Aizstājiet saraksta nosaukumu ar tā saraksta nosaukumu, kuram piekļūstat, un aizstājiet x ar vajadzīgā vienuma pozīcijas numuru. Atcerieties, ka pirmais vienums vienmēr ir nulle, nevis viens. Piemēram, zemāk esošajā pirmajā rindā es definēju sarakstu ar studentiem un pēc tam no šī saraksta izdrukāju vienuma numuru nulle. Izpildot kodu, rezultāts ir tāds, ka tiek parādīts nosaukums Mark.
studenti = ["Marks", "Amber", "Todd", "Anita", "Sandy"]
drukāt (studenti [0])
Marks

Lasot piekļuves saraksta elementus, profesionāļi pirms numura lieto vārdu sub. Piemēram, par studentiem [0] runā kā studentiem, kuri ir zem nulles.

Šis nākamais piemērs parāda sarakstu ar nosaukumiem. Funkcija print () izdrukā pēdējā rādītāja pozīcijas numuru sarakstā, kas ir 4 (jo pirmais vienmēr ir nulle).

rezultāti = [88., 92., 78., 90., 84.]
drukāt (partitūras [4])
84

Mēģinot piekļūt saraksta vienumam, kas neeksistē, tiek parādīta kļūda “indekss ārpus diapazona”. Indeksa daļa ir atsauce uz numuru kvadrātiekavās. Piemēram, zemāk redzamais attēls parāda nelielu eksperimentu Jupyter piezīmju grāmatiņā, kur tika izveidots punktu skaits un pēc tam mēģināts izdrukāt punktu skaitu [5].

Tas neizdevās un radīja kļūdu, jo nav punktu skaita [5]. Ir tikai punktu skaits [0], punktu skaits [1], punktu skaits [2], punktu skaits [3] un punktu skaits [4], jo skaitīšana vienmēr sākas ar nulli ar pirmo sarakstā.

Python indeksa diapazons

Virkne Python saraksta

Lai piekļūtu katram saraksta vienumam, vienkārši izmantojiet cilpu for a ar šo sintakse:

x sarakstā:

Aizstājiet x ar mainīgu nosaukumu, kuru izvēlējāties. Aizstāt sarakstu ar saraksta nosaukumu. Vienkāršs veids, kā padarīt kodu lasāmu, saraksta nosaukumam vienmēr jāizmanto daudzskaitlis (piemēram, studenti, partitūras). Tad mainīgā nosaukumam varat izmantot vienskaitļa vārdu (students, rezultāts). Arī šai pieejai nav jāizmanto indeksu numuri (skaitļi kvadrātiekavās). Piemēram, šāds kods izdrukā katru punktu skaitu punktu sarakstā:

par punktu skaitu:
drukāt (partitūra)

Atcerieties vienmēr atkāpties kods, kas jāizpilda cilpā. Šajā attēlā parādīts pilnīgāks piemērs, kur Jupyter piezīmju grāmatiņā varat redzēt koda palaišanas rezultātu.

Virkne Python saraksta

Skatīšana, vai Python sarakstā ir kāds vienums

Ja vēlaties, lai jūsu kods pārbaudītu saraksta saturu, lai redzētu, vai tajā jau ir kāds vienums, izmantojiet saraksta nosaukumā if if vai mainīgā uzdevumā.

Piemēram, kods zemāk redzamajā attēlā izveido vārdu sarakstu. Tad divi mainīgie lielumi glabā vārdu meklēšanas Anita un Boba meklēšanas rezultātus. Drukājot katra mainīgā saturu, tiek parādīts True tam, kura sarakstā ir vārds (Anita). Pārbaude, lai redzētu, vai Bobs ir sarakstā, pierāda nepatiesu.

Skatīšana, vai vienums ir Python sarakstā

Python saraksta garuma iegūšana

Lai noteiktu, cik vienību ir sarakstā, izmantojiet funkciju len () (īss garums). Iekavās ielieciet saraksta nosaukumu. Piemēram, ierakstiet šo kodu Jupyter piezīmjdatorā vai Python uzvednē vai kādā citā:

studenti = ["Marks", "Amber", "Todd", "Anita", "Sandy"]
drukāt (len (studenti))

Palaižot šo kodu, tiek iegūta šāda izvade:

5

Sarakstā patiešām ir pieci vienumi, lai gan pēdējais vienmēr ir par vienu mazāks par skaitli, jo Python sāk skaitīt pie nulles. Tātad pēdējais Sandy faktiski attiecas uz studentiem [4], nevis studentiem [5].

Vienuma pievienošana Python saraksta beigām

Ja vēlaties, lai Python kods saraksta beigās pievienotu jaunu vienumu, izmantojiet .append () metodi ar vērtību, kuru vēlaties pievienot iekavās. Pēdiņās varat izmantot mainīgu nosaukumu vai burtisku vērtību.

Piemēram, šajā attēlā rinda, kas skan students.append ("Goober"), sarakstam pievieno vārdu Goober. Rinda, kas skan students.append (new_student), sarakstam pievieno jebkuru vārdu, kas tiek saglabāts mainīgajā ar nosaukumu new_student. .Append () metode vienmēr tiek pievienota saraksta beigām. Tātad, drukājot sarakstu, beigās redzat šos divus jaunos vārdus.

Python pielikumu saraksts

Varat izmantot testu, lai noskaidrotu, vai kāds elements ir sarakstā, un pēc tam to pievienot tikai tad, kad vienuma vēl nav. Piemēram, zemāk esošais kods sarakstam nepievienos vārdu Dzintars, jo šis vārds jau ir sarakstā:

students_name = "Amanda"

# Pievienojiet studenta_vārdu, bet tikai tad, ja tas vēl nav sarakstā.
ja studenta_vārds studentos:
    drukāt (studenta_vārds + "jau ir sarakstā")
cits:
    students.append (studenta_vārds)
    print (students_name + "pievienots sarakstam")

Vienuma ievietošana Python sarakstā

Lai gan metode append () ļauj pievienot vienumu saraksta beigām, metode insert () ļauj pievienot elementu sarakstam jebkurā pozīcijā. Ievietot () sintakse ir

saraksta nosaukums.ielikums (pozīcija, prece)

Aizstājiet saraksta nosaukumu ar saraksta nosaukumu, pozīciju ar pozīciju, kurā vēlaties ievietot priekšmetu (piemēram, 0, lai tas būtu pirmais vienums, 1, lai padarītu to par otro vienumu, un tā tālāk). Vienumu aizstājiet ar vērtību vai mainīgā nosaukumu, kas satur vērtību, kuru vēlaties ievietot sarakstā.

Piemēram, šis kods padara Lupe par pirmo vienumu sarakstā:

# Izveidojiet virkņu (vārdu) sarakstu.
studenti = ["Marks", "Amber", "Todd", "Anita", "Sandy"]

students_name = "Lupe"
# Pievienojiet studenta vārdu saraksta priekšā.
students.insert (0, students_name)

# Parādiet man jauno sarakstu.
drukāt (studenti)

Ja palaižat kodu, print (studenti) pēc jaunā vārda ievietošanas parādīs sarakstu šādi:

['Lupe', 'Marks', 'Amber', 'Todd', 'Anita', 'Sandy']

Vienuma maiņa Python sarakstā

Jūs varat mainīt vienumu sarakstā, izmantojot = piešķīruma operatoru (pārbaudiet šos parastos Python operatorus) tāpat kā jūs ar mainīgajiem. Tikai pārliecinieties, ka indeksa numuru iekļaujat maināmā objekta kvadrātiekavās. Sintakse ir:

saraksta nosaukums [indekss] = newvalue

Aizstāt saraksta nosaukumu ar saraksta nosaukumu; aizstāt indeksu ar maināmā vienuma apakšindeksu (indeksa numuru); un aizstājiet jauno vērtību ar visu, ko vēlaties ievietot saraksta vienībā. Piemēram, apskatiet šo kodu:

# Izveidojiet virkņu (vārdu) sarakstu.
studenti = ["Marks", "Amber", "Todd", "Anita", "Sandy"]
studenti [3] = "Hobārta"
drukāt (studenti)

Palaižot šo kodu, izvade ir šāda, jo Anitas vārds ir mainīts uz Hobartu.

['Marks', 'Amber', 'Todd', 'Hobart', 'Sandy']

Apvienojot Python sarakstus

Ja jums ir divi saraksti, kurus vēlaties apvienot vienā sarakstā, izmantojiet paplašināšanas () funkciju ar sintakse:

original_list.extend (papildu_items_list)

Kodā aizstājiet original_list ar tā saraksta nosaukumu, kuram pievienosit jaunus saraksta vienumus. Aizvietojiet papildu_items_list ar tā saraksta nosaukumu, kurā ir vienumi, kurus vēlaties pievienot pirmajam sarakstam. Šeit ir vienkāršs piemērs, izmantojot sarakstus ar nosaukumiem list1 un list2. Pēc saraksta1 paplašināšanas (saraksta2) izpildes pirmajā sarakstā ir elementi no abiem sarakstiem, kā jūs varat redzēt paziņojuma print () izvadē beigās.

# Izveidojiet divus vārdu sarakstus.
list1 = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
list2 = ["Huey", "Dewey", "Louie", "Nader", "Bubba"]

# Pievienojiet 1. sarakstam vārdus 1. sarakstam.
saraksts1.izvērst (saraksts2)

# Drukas saraksts 1.
drukāt (saraksts1)

['Zara', 'Lupe', 'Hong', 'Alberto', 'Jake', 'Huey', 'Dewey', 'Louie', 'Nader', 'Bubba']

Viegli Parcheesi, nē?

Python saraksta vienumu noņemšana

Python piedāvā noņemšanas () metodi, lai jūs varētu no saraksta noņemt jebkuru vērtību. Ja vienums ir sarakstā vairākas reizes, tiek noņemts tikai pirmais gadījums. Piemēram, šis kods parāda burtu sarakstu ar burtu C, kas atkārtots pāris reizes. Tad kods izmanto letters.remove ("C"), lai no saraksta noņemtu C burtu:

# Noņemiet "C" no saraksta.
letters.remove (“C”)

# Parādiet man jauno sarakstu.
drukāt (burti)

Faktiski izpildot šo kodu un pēc tam izdrukājot sarakstu, redzēsit, ka ir noņemts tikai pirmais C burts:

['A', 'B', 'D', 'C', 'E', 'C']

Ja jums jānoņem viss vienums, varat izmantot laiku cilpu, lai atkārtotu. Noņemšanu, kamēr vienums joprojām ir sarakstā. Piemēram, šis kods atkārto .remove, kamēr “C” joprojām ir sarakstā.

# Izveidojiet virkņu sarakstu.
burti = ["A", "B", "C", "D", "C", "E", "C"]

Ja vēlaties noņemt vienumu, pamatojoties uz tā atrašanās vietu sarakstā, izmantojiet pop () ar indeksa numuru, nevis noņemiet () ar vērtību. Ja vēlaties noņemt no saraksta pēdējo vienumu, izmantojiet pop () bez indeksa numura.

Piemēram, ar šo kodu tiek izveidots saraksts, vienā rindā tiek noņemts pirmais vienums (0), bet otrā tiek noņemts pēdējais vienums (pop (), iekavās nekas nav norādīts). Drukājot sarakstu, tiek parādīts, ka šie divi vienumi ir noņemti:

# Izveidojiet virkņu sarakstu.
burti = ["A", "B", "C", "D", "E", "F", "G"]
 
#Noņemiet pirmo vienumu.
vēstules.pop (0)
#Noņemiet pēdējo vienumu.
vēstules.pop ()
 
# Parādiet man jauno sarakstu.
drukāt (burti)

Koda palaišana parāda, ka pirmā un pēdējā vienuma parādīšana patiešām darbojās:

['B', 'C', 'D', 'E', 'F']

Atverot () vienumu no saraksta, šīs vērtības kopiju var saglabāt kādā mainīgajā. Piemēram, šajā attēlā redzams tāds pats kods kā iepriekš. Tomēr tajā tiek noņemtas noņemtās kopijas mainīgajos ar nosaukumu first_removed un last_removed. Beigās tas izdrukā Python sarakstu un parāda, kuri burti tika noņemti.

noņemt vienumus no Python saraksta

Python piedāvā arī del (saīsinātu dzēšanas) komandu, kas izdzēš jebkuru vienumu no saraksta, pamatojoties uz tā indeksa numuru (pozīciju). Bet atkal jums ir jāatceras, ka pirmais vienums ir nulle. Tātad, pieņemsim, ka, lai izdzēstu 2. vienumu no saraksta, palaižat šo kodu:

# Izveidojiet virkņu sarakstu.
burti = ["A", "B", "C", "D", "E", "F", "G"]
 
# Noņemiet 2. apakšiedaļu.
del burti [2]
 
drukāt (burti)

Palaižot šo kodu, saraksts tiek parādīts no jauna. C burts ir izdzēsts, un tas ir pareizais izdzēšamais vienums, jo burti ir numurēti kā 0, 1, 2, 3 un tā tālāk.

['A', 'B', 'D', 'E', 'F', 'G']

Varat arī izmantot del, lai izdzēstu visu sarakstu. Nelietojiet kvadrātiekavas un indeksa numuru. Piemēram, zemāk redzamais kods izveido sarakstu un pēc tam to izdzēš. Mēģinot izdrukāt sarakstu pēc dzēšanas, rodas kļūda, jo saraksts vairs nepastāv, kad tiek izpildīts paziņojums print ().

izdzēst Python sarakstu

Python saraksta noskaidrošana

Ja vēlaties izdzēst saraksta saturu, bet ne pašu sarakstu, izmantojiet .clear (). Saraksts joprojām pastāv; tomēr tajā nav priekšmetu. Citiem vārdiem sakot, tas ir tukšs saraksts. Šis kods parāda, kā jūs varētu to pārbaudīt. Palaižot kodu, beigās tiek parādīts [], kas ļauj zināt, ka saraksts ir tukšs:

# Izveidojiet virkņu sarakstu.
burti = ["A", "B", "C", "D", "E", "F", "G"]
 
# Notīriet visu ierakstu sarakstu.
letters.clear ()
 
# Parādiet man jauno sarakstu.
drukāt (burti)

[]

Saskaitot to, cik reizes vienums parādās Python sarakstā

Varat izmantot Python count () metodi, lai uzskaitītu, cik reizes vienums parādās sarakstā. Tāpat kā citās saraksta metodēs, sintakse ir vienkārša:

listname.count (x)

Aizstājiet saraksta nosaukumu ar sava saraksta nosaukumu un x ar meklēto vērtību (vai mainīgā nosaukumu, kas satur šo vērtību).

Kods zemāk redzamajā attēlā saskaita, cik reizes burts B parādās sarakstā, izmantojot burtu B burtu .count () iekavās. Šis pats kods arī skaita C klašu skaitu, bet šī vērtība tika saglabāta mainīgajā tikai tāpēc, lai parādītu sintakses atšķirības. Abas skaitīšanas strādāja, kā jūs varat redzēt programmas izvadē apakšā. Viens tika pievienots, lai saskaitītu F, neizmantojot nevienu mainīgo. F ir skaitīti tieši kodā, kas parāda ziņojumu. Nav F pakāpes, tāpēc tā tiek atgriezta nulle, kā jūs varat redzēt izejā.

skaita Python saraksta vienības

Mēģinot kombinēt numurus un virknes, lai izveidotu ziņojumu, atcerieties, ka skaitļi ir jāpārveido virknēs, izmantojot funkciju str (). Pretējā gadījumā jūs saņemat kļūdu, kurā lasāms kaut kas līdzīgs, kas var tikai salikt str (nevis "int") līdz str. Šajā ziņojumā int ir īss skaitlis un str ir īss.

Python saraksta vienības indeksa atrašana

Python piedāvā .index () metodi, kas atgriež skaitli, kas norāda saraksta vienības pozīciju, pamatojoties uz indeksa numuru. Sintakse ir:

listname.index (x)

Kā vienmēr, aizstājiet saraksta nosaukumu ar tā saraksta nosaukumu, kurā vēlaties meklēt. Aizstāt x to, ko jūs meklējat (kā burtisku, vai kā mainīgu vārdu, kā vienmēr). Protams, nav garantijas, ka prece ir sarakstā, un pat ja tā ir, tad netiek garantēta, ka prece ir sarakstā tikai vienreiz. Ja prece nav sarakstā, rodas kļūda. Ja prece ir sarakstā vairākas reizes, tiek atgriezts pirmā atbilstošā vienuma indekss.

Šajā attēlā parādīts piemērs, kurā programma avarē rindā f_index = grade.index (meklēt_for), jo sarakstā nav F.

Python saraksta vienumu indekss

Vienkāršs veids, kā izvairīties no šīs problēmas, ir izmantot if paziņojumu, lai redzētu, vai postenis ir sarakstā pirms mēģināt iegūt tā indeksa numuru. Ja prece nav sarakstā, parādiet ziņojumu, kurā teikts. Pretējā gadījumā iegūstiet indeksa numuru un parādiet to ziņojumā. Šis kods ir šāds:

# Izveidojiet virkņu sarakstu.
pakāpes = ["C", "B", "A", "D", "C", "B", "C"]
# Izlemiet, ko meklēt
look_for = "F"
# Skatiet, vai vienums ir sarakstā.
ja izskatās_klasē:
    # Ja tas ir sarakstā, iegūstiet un parādiet indeksu.
    print (str (meklēt_for) + "atrodas indeksā" + str (grade.index (look_for)))
cits:
    # Ja tā nav sarakstā, pat nemēģiniet meklēt indeksa numuru.
    print (str (meklēt_for) + "nav sarakstā.")

Python sarakstu alfabētēšana un šķirošana

Python piedāvā sakārtošanas sarakstu sakārtošanas metodi. Vienkāršākajā formā tas alfabētizē saraksta elementus (ja tie ir stīgas). Ja sarakstā ir skaitļi, tie tiek sakārtoti no mazākā līdz lielākajam. Tādai vienkāršai kārtošanai vienkārši izmantojiet sort () ar tukšām iekavām:

listname.sort ()

Aizstājiet saraksta nosaukumu ar sava saraksta nosaukumu. Šajā attēlā parādīts piemērs, izmantojot virkņu sarakstu un numuru sarakstu. Piemērā katram no tiem tika izveidots jauns saraksts, vienkārši piešķirot katram sakārtotajam sarakstam jaunu saraksta nosaukumu. Pēc tam kods izdrukā katra sakārtotā saraksta saturu.

kārtot Python sarakstu

Ja jūsu sarakstā ir virknes ar lieliem un maziem burtiem, un ja šķirošanas rezultāti neizskatās pareizi, mēģiniet aizstāt .sort () ar .sort (taustiņš = lambda s: s.lower ()) un pēc tam atkal palaist kodu.

Datumi ir nedaudz sarežģītāki, jo tos nevar vienkārši ierakstīt kā virknes, piemēram, “12/12/2020”. Lai pareizi kārtotu, tiem jābūt datuma datu tipam. Tas nozīmē, ka katra datuma noteikšanai jāizmanto dienas laika modulis un datuma () metode. Datumus sarakstam varat pievienot tāpat kā jebkuru citu sarakstu. Piemēram, nākamajā rindiņā kods izveido četru datumu sarakstu, un kods ir pilnīgi precīzs.

datumi = [datums (2020,12,31), datums (2019,1,31), datums (2018,2,28), datums (2020,1,1)]

Dators noteikti neiebildīs, ja izveidosit sarakstu šādā veidā. Bet, ja vēlaties padarīt kodu lasāmāku sev vai citiem izstrādātājiem, iespējams, vēlēsities izveidot un pievienot katru datumu pa vienam, tāpēc vienkārši ir mazliet vieglāk redzēt, kas notiek, un tā jums nav lai vienā koda rindā apstrādātu tik daudz komatu. Zemāk redzamajā attēlā parādīts piemērs, kurā tika izveidots tukšs saraksts ar datēšanas sarakstu:

datētājs = []
parādīt datumus Python

Pēc tam sarakstam tika pievienots viens datums vienlaicīgi, izmantojot dt.date (gads, mēnesis, diena) sintakse.

Pēc saraksta izveidošanas kods datelist.sort () izmanto, lai tos sakārtotu hronoloģiskā secībā (agrākais līdz pēdējam). Šajā kodā jums nav jāizmanto drukāšana (datlapu saraksts), jo šī metode parāda datumus ar iekļauto datu veida informāciju, piemēram:

[datetime.date (2018, 2, 28), datetime.date (2019, 1, 31), datetime.date (2020, 1, 1), datetime.date (2020, 12, 31)]]

Nav vieglākais saraksts, ko lasīt. Tā vietā, lai visu sarakstu drukātu ar vienu print () paziņojumu, jūs varat izsvītrot katru datumu sarakstā un katru izdrukāt, formatējot to ar f-virkni% m /% d /% Y. Katrs datums tiek parādīts atsevišķā rindiņā, mm / dd / gggg

Ja vēlaties kārtot preces apgrieztā secībā, iekavās Sort () ielieciet reverse = True (un neaizmirstiet izveidot pirmo burtu ar lielajiem burtiem). Zemāk redzamajā attēlā ir parādīti visu trīs sarakstu kārtošanas piemēri dilstošā (apgrieztā) secībā, izmantojot reverse = True.

kārtot informāciju Python sarakstā apgrieztā secībā

Python saraksta mainīšana

Jūs varat arī mainīt elementu secību sarakstā, izmantojot .reverse metodi. Tas nav tas pats, kas šķirošana apgrieztā secībā, jo, šķirojot apgrieztā secībā, jūs joprojām kārtojat: Z – A virknēm, skaitļiem no lielākās līdz mazākajai, skaitļiem no jaunākās līdz agrākajai. Apgriežot sarakstu, jūs vienkārši apgriežat vienumus sarakstā neatkarīgi no to secības, nekādā veidā nemēģinot tos kārtot.

Šis kods parāda piemēru, kurā jūs maināt nosaukumu secību sarakstā un pēc tam izdrukājat sarakstu. Rezultātā tiek parādīti saraksta vienumi, kas mainīti no sākotnējā pasūtījuma:

# Izveidojiet virkņu sarakstu.
nosaukumi = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
# Apgrieziet sarakstu
names.reverse ()
# Izdrukājiet sarakstu
drukāt (vārdi)
 
['Džeiks', 'Alberto', 'Hong', 'Lupe', 'Zara']

Python saraksta kopēšana

Ja jums kādreiz vajadzēja strādāt ar saraksta kopiju, izmantojiet .copy () metodi, lai nemainītu sākotnējo sarakstu. Piemēram, šis kods ir līdzīgs iepriekšējam kodam, izņemot to, ka tā vietā, lai mainītu sākotnējā saraksta secību, jūs sastādāt saraksta kopiju un apvēršat šo. Izdrukājot katra saraksta saturu, tiek parādīts, kā pirmais saraksts joprojām ir sākotnējā secībā, bet otrais - apgriezts:

# Izveidojiet virkņu sarakstu.
nosaukumi = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
 
# Izveidojiet saraksta kopiju
atpakaļejoši_vārdi = nosaukumi.kopija ()
# Apgrieziet kopiju
backward_names.reverse ()
 
# Izdrukājiet sarakstu
drukāt (vārdi)
drukāt (atpakaļvārdi)
 
['Zara', 'Lupe', 'Hong', 'Alberto', 'Jake']
['Džeiks', 'Alberto', 'Hong', 'Lupe', 'Zara']

Turpmāk sniegtajā tabulā apkopotas metodes, par kurām esat uzzinājis.