Darbs ar masīviem un vārdnīcām

nosaukums[indekss] - piekļuve masīva elementam pēc indeksa vai vērtības

Apskatīsim dažus piemērus darbam ar masīviem:

Piemērs piekļuvei masīva elementam pēc tā indeksa:

Piemērs pēdējā masīva elementa iegūšanai:

/*Piekļuve pēc indeksa*/
masīvsI = [1, "2", 3, 4, 5]
k=masīvsI[3]
/*Piekļuve pēc indeksa no ligzdota masīva*/
masīvsV = [[1, "2", 4, 5], "2", 3, 4, 5]
v=masīvsV[0][1]

/*Piemērs pēdējā elementa iegūšanai*/
masīvs = [1, "2", 3, 4, 5]
/*Pēdējā masīva elementa iegūšana*/
pēdējais = masīvs[-1]

nosaukums[indekss] = vērtība - masīva elementa aizstāšana pēc dotā indeksa

Piemērs:

Lai aizstātu konkrēta masīva elementa vērtību, izmantojiet šādu sintaksi: masīva_nosaukums[indekss] = vērtība

Atbilde:

masīvs = [1, "2", 3, 4, 5]

/*Aizstāt masīvā/vārdnīcā*/
masīvs[2] = 888

/*Pievienot vārdnīcā   vārdnīcas['atslēga'] = 'VVVVVVVVVVV'*/
vārdnīcas['m']=jauns

/*Aizstāt masīvā/vārdnīcā ar skaitli*/
masīvs[3] = int('888')
vārdnīcas['a'] = int('555')

in_array(masīvs, vērtība) - lai pārbaudītu, vai elements pastāv masīvā.

Parametri: \ ! masīvs - masīvs \ ! vērtība - meklējamā vērtība

Atgriež True vai False atkarībā no tā, vai vērtība tiek atrasta vai nē.

Piemērs:

s = ["Mike", "Peter", "Helen"] 
q = if(in_array(s, 'Ann'), 'Atrasts', 'Cita virkne')

arr_len(masīvs) - lai uzzinātu masīva garumu

Parametrs:\ ! masīvs - masīvs

Rezultāts: Atgriež skaitli - masīva garumu.

Esiet uzmanīgi, nododot parametrus funkcijai! Ja tā tiek izsaukta bez parametriem, tā atgriež 0; ja parametrs nav ne masīvs, ne vārdnīca, tā atgriež -1.

Lietošanas piemērs:

Rezultāts:

s = ["Mike", "Peter", "Helen"] 
q = if(arr_len(s) > 5, 'Grupa ir pilna', 'Pievienojies mūsu komandai!')

append(masīvs, elements, pazīme) - lai ievietotu elementu masīva beigās.

Parametri:

! masīvs - masīvs\ ! elements - ievietojamais elements
pazīme - karodziņš, kas norāda, vai tas ir masīvs vai vārdnīca

Atgriež masīvu ar vērtību, kas pievienota beigās. Lai atjauninātu sākotnējo masīvu, izmantojiet piešķiršanu: masīvs = append(masīvs, elements, pazīme)

Pēc noklusējuma dati tiek ievietoti kā virknes. Ja jums ir jāievieto masīvs vai vārdnīca, nododiet papildu parametru True. Tas norāda, ka ievietojat JSON.

Lietošanas piemērs:

Piemērs pievienošanai un noņemšanai no masīva:

Piemērs masīva izveidei ar masīviem iekšpusē:

Funkcijas izpildes rezultāts:

s = ["Mike", "Peter", "Helen"]
q = append(s, 'Max')

insert(masīvs, indekss, vērtība, pazīme) - lai ievietotu elementu noteiktā masīva pozīcijā.

Parametri: \ ! masīvs - masīvs\ ! indekss - ievietošanas pozīcija\ ! vērtība - vērtība
indikators - Indikators pievienošanai masīvam vai vārdnīcai.

Rezultāts:
Atgriež masīvu ar vērtību, kas pievienota norādītajā pozīcijā. Citiem vārdiem sakot, lai pievienotu vērtību tam pašam masīvam, izmantojiet komandu šādā formā: masīvs = insert(masīvs, indekss, vērtība, indikators)

Pēc noklusējuma dati tiek ievietoti kā virknes. Ja jums ir jāievieto masīvs vai vārdnīca, nododiet papildu parametru True. Tas norāda, ka ievietojat JSON.

Piemērs:

Rezultāts:

Apskatīsim sarežģītāku piemēru - vārdnīcas t pievienošana masīvam s:

Funkcijā mēs norādījām, ka vēlamies pievienot vārdnīcu pozīcijā 1. Apskatīsim rezultātu:

s = ["Mike", "Peter", "Helen"]
q = insert(s, 1, 'Max')

Pēc indeksa

del(mass, key) - noņem elementu no masīva pēc tā indeksa.

Parametri: \ ! mass - masīva nosaukums;\ ! key - noņemamās vērtības indekss

Atgriež jaunu masīvu ar noņemto elementu; sākotnējais masīvs paliek nemainīgs. Lai izdzēstu un atjauninātu to pašu masīvu, izmantojiet komandu šādā formā:
mass = del(mass, key)

Ja jūsu masīvs satur skaitļus un vēlaties noņemt elementu pēc vērtības, izmantojiet funkciju remove().

del name['index'] - vērtības noņemšana no masīva pēc indeksa

Parametri: \ ! name- masīva nosaukums;\ ! index- noņemamās vērtības indekss

Pēc vērtības

remove(mass, value) - lai izdzēstu vērtību no masīva.

Parametri: \ ! mass - masīva nosaukums; \ ! value - vērtība, kas jānoņem no masīva

Rezultāts:
Atgriež modificētu masīvu, atstājot sākotnējo masīvu nemainīgu. Lai noņemtu elementu un atjauninātu to pašu masīvu, izmantojiet komandu šādā formā:
mass = remove(mass, key)

Piemērs elementa noņemšanai pēc indeksa:

Piemērs masīva elementa noņemšanai pēc tā vērtības:

/*Masīva elementa noņemšana pēc tā indeksa:*/
array = ["1",2, 3, "4"]
del array['1']

array1 = ["1",2, 3, "4"]
array1=del(array1,0)


/*Masīva elementa noņemšana pēc tā vērtības:*/
array = ["1",2, 3, "4"]
array=remove(array, '4') 

array1 = ["1",2, 3, "4"]
array1=remove(array1, 2) 

index(mass, value)

Parametri: \ ! mass - masīva nosaukums \ ! value - vērtība, kuras pozīcija ir jānosaka.

Ja elements nav masīvā, funkcija atgriezīs -1.

Piemērs elementa pozīcijas noteikšanai masīvā:

Apskatīsim rezultātu tuvāk:

Kā redzam, tā kā skaitļa 5 nav masīvā, funkcija atgrieza -1.

array = ["1",2, 3, "4"]
search1=index(array,"1")
search2=index(array,5)

massive_to_text(massive, header, numbered,delimiter1,delimiter2)

Parametri:

! massive – attēlojamais masīvs,
header – virsraksts, kas parādīsies izvades sākumā
numbered – ja tiek nodota jebkāda vērtība, masīva elementi tiks numurēti
delimiter1 – rakstzīme, kas tiek novietota katras elementa rindas beigās (noklusējums ir ‘;’)
delimiter2 – rakstzīme, kas tiek izmantota aiz vienuma numura, kad numerācija ir ieslēgta (noklusējums ir ‘)’)

Vienkāršs piemērs:

Rezultātā masīvs tiks attēlots kā numurēts saraksts:

Array1 = [1, 2, 3, "a", "b", "c"] 
text = array_to_text(Array1, 'title', 1) 

except_arr(mas1, mas2)

Parametri:

! mas1 - masīvs, no kura elementi tiks izslēgti,\ ! mas2 - masīvs, kas satur izslēdzamos elementus

Apskatīsim piemēru:

s1 = [1, 2, 3]
s2 = [2, 3]
s3 = except_arr(s1, s2)

cross_arr(mas1, mas2)

Parametri:

! mas1 - masīvs, kurā meklēt\ ! mas2 - masīvs, kas satur meklējamos elementus

s1 = [1, 2, 3]
s2 = [2, 3]
s3 = cross_arr(s1, s2)

mas1 = ["didn't", "except,", "that", "everything", "is", "so", "simple.", "thanks"]
mas2 = ["everything", "thanks"]
mas3 = cross_arr(mas1, mas2)

Nav īpašas iebūvētas funkcijas masīvu apvienošanai, bet to var viegli izdarīt:

Lai apvienotu masīvus, veiciet virkņu savienošanu, pēc tam aizstājiet '][' ar komatu ','

Šis ir piemērs laukā "Kalkulators"

Šis ir piemērs, kā darbojas bots

a = [1,2,3,4] 
b = [5,6,7] 
sum = a + b 
answer = replace(sum, '][', ',') 

sum_array(array)

Parametri:

array - masīvs, kura elementi ir jāsummē

Uzmanību! Funkcija darbojas ar noteikta formāta masīviem.

Pieņemtie formāti: - [1,2,3,4] vai ‘[1,2,3,4]’.
Ja masīvs satur skaitļus, kas attēloti kā virknes, tie ir jāieliek dubultpēdiņās — piemēram, [1,2,3,”-4”].
Ja masīvs satur alfabētiskas virknes, aprēķins neizdosies.

Nepareizas lietošanas piemērs:
mas = [1,2,3,"a"]
result = sum_array(mas)

Tā rezultātā radīsies kļūda: masīvā ir neatbalstīti elementi

Rezultāts:

mas = [1,2,3,4] 
result = sum_array(mas) 

shuffle_massive(massive

Parametri:

massive - masīvs, kura elementi ir jāsajauc.

Funkcijas izpildes rezultāti:

Massive1 = [1, 2, 3, "a", "b", "c"]
Massive2 = shuffle_massive(Massive1) 

Kārtošana masīvā vai vārdnīcā

sort(mass, b) - kārto masīvu pēc vērtības un vārdnīcu pēc atslēgas

Parametri:

! mass - masīvs/vārdnīca
b - kārtošanas secība (False – augoša (noklusējums), True – dilstoša)

Vārdnīcas kārtošana pēc tās vērtības

sort_by_value(dict, b) - kārto vārdnīcu pēc vērtībām.

Parametri:\ ! dict- vārdnīca
b - kārtošanas secība (False – augoša (noklusējums), True – dilstoša)

Piemērs masīva kārtošanai dilstošā secībā un vārdnīcas kārtošanai augošā secībā:

Vārdnīcas kārtošana pēc vērtībām:

Masīva/vārdnīcas pārveidošana pogās

tools_make_button_str_checker(values_list, key, in_line, button_type, checker_with_numbers)

Parametri:

! values_list - virkņu vai vārdnīcu masīvs, kura dati tiks izmantoti tastatūras vai numurēta saraksta izveidei

key - atslēga, pēc kuras tiks veikta atlase no vārdnīcu masīva

in_line - pogu skaits rindā (noklusējums: 1)

button_type - pogu veids (noklusējums: atbildes tastatūra).
Iespējamās vērtības:
0 - atbildes tastatūra,
1 - iekļautā tastatūra (pogas tekstā)

checker_with_numbers - vai pievienot pogu numurus "pārbaudītāja" masīvam.
Iespējamās vērtības:
0 - nepievienot numurus,
1 - pievienot numurus (noklusējums: 1 – pievienot numurus)

Funkcijas rezultāts — vārdnīca šādā formā:

{"numbered_list":"1. T-krekli\n2. Šorti\n3. Zeķes\n4. Cepures\n","buttons":[{"type":"inline","text":"T-krekli","line":0,"index_in_line":0},{"type":"inline","text":"Šorti","line":0,"index_in_line":1},{"type":"inline","text":"Zeķes","line":1,"index_in_line":0},{"type":"inline","text":"Cepures","line":1,"index_in_line":1}],"checker":"T-krekli;1;Šorti;2;Zeķes;3;Cepures;4;"}

Pēc tam vārdnīcas vērtības var ievietot konstruktora laukos:

Vārdnīcas vērtības iegūšana, pamatojoties uz klienta izvēli

tools_check_user_input(values_list, user_input, key, return_key)**

Parametri:

! values_list - virkņu vai vārdnīcu masīvs, kura dati tiks izmantoti tastatūras vai numurēta saraksta izveidei\ Vārdnīcas piemērs: [{"text":"T-krekli","price":100},{"text":"Šorti","price":150},{"text":"Zeķes","price":20},{"text":"Cepures","price":50}]\ ! user_input - lietotāja ievadītā vērtība no vienas no values_list vērtībām\ Vērtības piemērs: Cepures
key - atslēga, kas tiek izmantota atlasei no values_list vārdnīcu masīva\ Atslēgas piemērs: text
return_key - vērtība, kas tiek atgriezta norādītajai atslēgai no values_list\ Atgrieztās vērtības piemērs: price

Apskatīsim funkcijas lietošanu ar iepirkumu groza piemēru:

1.Definējiet masīvu un pārveidojiet to par numurētu sarakstu, pogām un iespējamo vērtību sarakstu (messengeriem bez pogām), izmantojot funkciju tools_make_button_str_checker().

2.Izmantojiet iegūtās pogas un numbered_list vērtības, lai iespējotu preces izvēli:

3.Izmantojiet iespējamo vērtību saraksta pārbaudītāju, lai validētu klienta ievadi:

4.Visbeidzot, parādiet klientam izvēlētās preces cenu. To ir ērti izdarīt, izmantojot funkciju tools_check_user_input()

list = [{"text":"T-shirts","price":100},{"text":"Shorts","price":150},{"text":"Socks","price":20},{"text":"Caps","price":50}]
res = tools_make_button_str_checker(list, "text", "2", "1")
numbered_list = res['numbered_list']
buttons = res['buttons']
checker = res['checker']

res_check = tools_check_user_input(list, user_input, 'text', 'price')

**array_slice(array, start_index, end_index)**​

Parametri:

****!****​array - masīvs \ ****!****​start_index - šķēles sākums
end_index - šķēles beigas (noklusējums: līdz beigām)

Izvēlēsimies apakšmasīvu, sākot no 1. elementa:

​res būs ["Shorts", "Socks", "Caps"]​

Vēl viens piemērs apakšmasīva izvēlei no 0. līdz 2. masīva elementam:

​res būs ["T-shirts", "Shorts"]

list = ["T-shirts", "Shorts", "Socks", "Caps"] 
res = array_slice(list, 1)

res = array_slice(list, 0, 2)

unpack_list(array, var_name) - šī metode iterē cauri masīvam un izveido atsevišķu mainīgo katram masīva elementam ar nosaukumiem, piemēram, var1, var2, var3 utt.​

! array - obligāts parametrs, elementu masīvs

var_name - neobligāts parametrs, virkne. Ja norādīts, to izmanto izpakoto elementu nosaukšanai. Piemēri:

Ja ir norādīts var_name, mainīgo nosaukumi tiek veidoti, izmantojot var_name

var_name ir jāievēro mainīgo nosaukšanas noteikumi.

1. piemērs:

array1 = ["one", "two", "three"]

ans1 = unpack_list(array1)

Rezultāts - izveidotie darījuma mainīgie:

var1 = 'one'

var2 = 'two'

var3 = 'three'

2. piemērs:

array2 = ["one", "two", "three"]

var_name = 'custom'

ans2 = unpack_list(array2, var_name)

Rezultāts - izveidotie darījuma mainīgie:

custom1 = 'one'

custom2 = 'two'

custom3 = 'three'

remove_duplicates(array) - atgriež sarakstu bez dublētiem elementiem.

! array - obligāts parametrs. Sākotnējais elementu saraksts ar dublikātiem.

Piemērs:

arr = [1, 2, 5, 1, 5, 3]

new_arr = remove_duplicates(arr)

Rezultāts - mainīgajam new_arr tiks piešķirts saraksts [1, 2, 5, 3].

Vārdnīcas izveide - vārdnīcas deklarēšana

name_dictionary = {}

Notīrīšana - nav nekas vairāk kā tukšas vārdnīcas deklarēšana.

name_dictionary = {}

name[key] - vārdnīcas elementa iegūšana pēc atslēgas

Piemērs darbam ar vārdnīcu:

​Šajā konkrētajā gadījumā mēs piekļūstam vērtībai pēc atslēgas "a". Lai iegūtu vērtību no vārdnīcas, izmantojot konkrētu atslēgu, izmantojiet šādu formātu: name_dictionary["key"]

Atbilde:

dicts = {"a": "11", "d": "hi"}
/*iegūšana no vārdnīcas*/
aa = dicts["a"]

dict_keys_to_array(data) - lai iegūtu datu vārdnīcas atslēgu sarakstu

Piemērs: Iegūt visu vārdnīcas atslēgu sarakstu

**Atbilde:**​

v={"A1":"orange","A2":"apricot","A3":"tangerine","A4":"apple","A5":"pear","A6":"kiwi","A7":"banana","A8":"peach"} 
key= dict_keys_to_array(v)

dict_values_to_array(data) - lai iegūtu vērtību sarakstu no vārdnīcas

Piemērs:

Atbilde:

v={"A1":"orange","A2":"apricot","A3":"tangerine","A4":"apple","A5":"pear","A6":"kiwi","A7":"banana","A8":"peach"}
value= dict_values_to_array(v)

get_values_by_key(data, key) - ļauj iegūt vērtības no vārdnīcu saraksta pēc norādītās atslēgas. Atgriež vērtību sarakstu.

Piemērs: Iegūt vērtības no vārdnīcu saraksta pēc atslēgas

Atbilde:

data = [{"Product": "Product№1", "Price": 1500}, {"Product": "Product№2", "Price": 6000}]
key = "Product"
result = get_values_by_key(data, key)

name**['key'] = value** - vārdnīcas elementa vērtības aizstāšana pēc norādītās atslēgas. Ja tiek norādīta neesoša atslēga, tiks pievienots jauns vārdnīcas elements.

Piemērs:

Lai aizstātu konkrēta masīva elementa vērtību, ierakstiet piešķiršanu kā array*_name[index] = value vai dictionary_name*[key] = value

Atbilde:​

dicts = {"a": "11", "d": "hi"}

/*Aizstāt vārdnīcā*/
dicts['d'] = AAAAA

/*Pievienot vārdnīcā   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

/*Aizstāt vārdnīcā ar skaitli*/
dicts['a'] = int('555')

dictionary_name***['key'] = 'value'** -* jaunas vērtības pievienošana vārdnīcai.​

Ja atslēga iepriekš nepastāvēja, tiks pievienots jauns atslēgas–vērtības pāris; pretējā gadījumā vērtība norādītajai atslēgai tiks aizstāta.

Šis ir piemērs kods kalkulatora laukā

Atbilde

/*jaunas vērtības pievienošana vārdnīcai dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

exist_key(mass, key) - lai pārbaudītu, vai vārdnīcā pastāv atslēga.

Parametri:​

mass - vārdnīca​

key - meklējamā atslēga

Atgriež True vai False atkarībā no tā, vai atslēga tika atrasta.

Lietošanas piemērs:

s = {"1": 123, "2": 234, "q": {"w": "e"}} 
q = if(exist_key(s, 'q'), 'Found', 'Another line')

key_index(mass, key) - lai pārbaudītu atslēgas pozīciju vārdnīcā.

Parametri:
mass - vārdnīca
key - Meklējamā atslēga.

Pozīcija vārdnīcā tiek skaitīta no 0. Tādējādi pirmais elements ir 0, otrais elements ir 1 utt.

Lietošanas piemērs:

Rezultāts:

s = {"1": 123, "2": 234, "q": {"w": "e"}} 
q = key_index(s, 'q')

arr_len(mass) - lai noteiktu vārdnīcas garumu.​

Parametrs:
mass - vārdnīca​

Rezultāts: Atgriež skaitli – vārdnīcas garumu.

Esiet uzmanīgi Nododot parametru funkcijai: ja funkcija tiek izsaukta bez parametriem, tā atgriež 0; ja parametrs nav saraksts vai vārdnīca, tā atgriež -1.

Lietošanas piemērs:

Atbilde:

Pēc indeksa vai atslēgas

del(mass, key) - lai izdzēstu elementu no saraksta pēc indeksa vai no vārdnīcas pēc atslēgas.
Tas pieņem divus parametrus: sarakstu/vārdnīcu un dzēšamo indeksu/atslēgu.
Atgriež modificēto vārdnīcu vai sarakstu, nemainot sākotnējo objektu.

Ja vērtības sarakstā vai vārdnīcā ir skaitļi, izmantojiet funkciju remove(), lai izdzēstu elementu.

Piemērs ar vārdnīcu

Rezultāts

Piemērs ar masīvu

Rezultāts

Piemērs ar vārdnīcu

s={"1":123, "2":234, "q":{"w":"e"}}

q=del(s,'q')

Piemērs ar masīvu

s=["John", "Ann", "Sophie"]\

q=del(s, 1)

humanize(dict, delimiter, from_i, to_i)

Parametri:

dict - vārdnīcas nosaukums
delimiter - atdalītājs starp rindām
from_i - elementa indekss, no kura sākt izvadi (0-bāzēts)
to_i - elementa indekss, līdz kuram beigt izvadi (neieskaitot)

Apskatīsim piemēru:

Atbilde

dict = {"[id146467928|Alex]":"6","[id145255525|Маx]":"20"}
r = humanize(dict, ': ')

Vārdnīcas kārtošana

sort(dict, b) - Kārto sarakstu pēc vērtības, bet vārdnīcu pēc atslēgas

Parametri:

! dict- vārdnīca

b - kārtošanas virziens (False – augošs pēc noklusējuma, True – dilstošs)

Vārdnīcas kārtošana pēc vērtības

sort_by_value(dict, b) - Vārdnīcas kārtošana pēc vērtībām.

Parametri:

! dict- vārdnīca

b - kārtošanas virziens (False – augošs pēc noklusējuma, True – dilstošs)

Piemērs: saraksta kārtošana dilstošā secībā un vārdnīcas kārtošana augošā secībā:

Vārdnīcas kārtošana pēc tās vērtībām:

Piemērs: saraksta kārtošana dilstošā secībā un vārdnīcas kārtošana augošā secībā:

array1=[5,4,0,6,3,0]

array1=sort(array1, True)

dict={"Ann":5, "John":4, "Sophie":0, "Alex":6, "Kate":3, "Harry":0}

dict=sort(dict)

Vārdnīcas kārtošana pēc tās vērtībām:

dict={"Ann":5, "John":4, "Sophie":0, "Alex":6, "Kate":3, "Harry":0}

dict=sort_by_value(dict)