Bekerja dengan tatasusunan dan kamus

nama[indeks] - mengakses elemen tatasusunan mengikut indeks atau mengikut nilai

Mari lihat beberapa contoh bekerja dengan tatasusunan:

Contoh mengakses elemen tatasusunan mengikut indeksnya:

Contoh mendapatkan elemen tatasusunan terakhir:

/*Mengakses mengikut indeks*/
tatasusunanI = [1, "2", 3, 4, 5]
k=tatasusunanI[3]
/*Mengakses mengikut indeks daripada tatasusunan bersarang*/
tatasusunanV = [[1, "2", 4, 5], "2", 3, 4, 5]
v=tatasusunanV[0][1]

/*Contoh mendapatkan elemen terakhir*/
tatasusunan = [1, "2", 3, 4, 5]
/*Mendapatkan elemen terakhir tatasusunan*/
terakhir = tatasusunan[-1]

nama[indeks] = nilai - menggantikan elemen tatasusunan pada indeks yang diberikan

Contoh:

Untuk menggantikan nilai elemen tatasusunan tertentu, gunakan sintaks berikut: nama_tatasusunan[indeks] = nilai

Jawapan:

tatasusunan = [1, "2", 3, 4, 5]

/*Ganti dalam tatasusunan/kamus*/
tatasusunan[2] = 888

/*Tambah dalam kamus   kamus['kunci'] = 'VVVVVVVVVVV'*/
kamus['m']=baru

/*Ganti dalam tatasusunan/kamus kepada nombor*/
tatasusunan[3] = int('888')
kamus['a'] = int('555')

in_array(jisim, nilai) - untuk menyemak sama ada elemen wujud dalam tatasusunan.

Parameter: \ ! jisim - tatasusunan \ ! nilai - nilai untuk carian

Mengembalikan True atau False bergantung pada sama ada nilai ditemui atau tidak.

Contoh:

s = ["Mike", "Peter", "Helen"] 
q = if(in_array(s, 'Ann'), 'Ditemui', 'Rentetan lain')

arr_len(jisim) - untuk mengetahui panjang tatasusunan

Parameter:\ ! jisim - tatasusunan

Hasil: Mengembalikan nombor - panjang tatasusunan.

Berhati-hati semasa menghantar parameter kepada fungsi! Jika dipanggil tanpa parameter, ia mengembalikan 0; jika parameter bukan tatasusunan mahupun kamus, ia mengembalikan -1.

Contoh penggunaan:

Hasil:

s = ["Mike", "Peter", "Helen"] 
q = if(arr_len(s) > 5, 'Kumpulan penuh', 'Sertai pasukan kami!')

append(jisim, elemen, penanda) - untuk memasukkan elemen di hujung tatasusunan.

Parameter:

! jisim - tatasusunan\ ! elemen - elemen untuk dimasukkan
penanda - bendera yang menunjukkan sama ada ia tatasusunan atau kamus

Mengembalikan tatasusunan dengan nilai ditambah di hujung. Untuk mengemas kini tatasusunan asal, gunakan tugasan: jisim = append(jisim, elemen, penanda)

Secara lalai, data dimasukkan sebagai rentetan. Jika anda perlu memasukkan tatasusunan atau kamus, hantar parameter tambahan True. Ini menunjukkan bahawa anda memasukkan JSON.

Contoh penggunaan:

Contoh menambah dan mengalih keluar daripada tatasusunan:

Contoh mencipta tatasusunan dengan tatasusunan di dalam:

Hasil pelaksanaan fungsi:

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

insert(jisim, indeks, nilai, penanda) - untuk memasukkan elemen ke dalam kedudukan tatasusunan tertentu.

Parameter: \ ! jisim - tatasusunan\ ! indeks - kedudukan sisipan\ ! nilai - nilai
penunjuk - Penunjuk penambahan kepada tatasusunan atau kamus.

Hasil:
Mengembalikan tatasusunan dengan nilai ditambah pada kedudukan yang ditentukan. Dalam erti kata lain, untuk menambah nilai pada tatasusunan yang sama, gunakan arahan dalam bentuk berikut: jisim = insert(jisim, indeks, nilai, penunjuk)

Secara lalai, data dimasukkan sebagai rentetan. Jika anda perlu memasukkan tatasusunan atau kamus, hantar parameter tambahan True. Ini menunjukkan bahawa anda memasukkan JSON..

Contoh:

Hasil:

Mari lihat contoh yang lebih kompleks - menambah kamus t ke tatasusunan s:

Dalam fungsi, kami menunjukkan bahawa kami ingin menambah kamus pada kedudukan 1. Mari lihat hasilnya:

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

Mengikut indeks

del(mass, key) - mengalih keluar elemen daripada tatasusunan mengikut indeksnya.

Parameter: \ ! mass - nama tatasusunan;\ ! key - indeks nilai yang akan dialih keluar

Mengembalikan tatasusunan baharu dengan elemen yang dialih keluar; tatasusunan asal kekal tidak berubah. Untuk memadam dan mengemas kini tatasusunan yang sama, gunakan arahan seperti:
mass = del(mass, key)

Jika tatasusunan anda mengandungi nombor dan anda ingin mengalih keluar elemen mengikut nilai, gunakan fungsi remove().

del name['index'] - mengalih keluar nilai daripada tatasusunan mengikut indeks

Parameter: \ ! name- nama tatasusunan;\ ! index- indeks nilai yang akan dialih keluar

Mengikut nilai

remove(mass, value) - untuk memadam nilai daripada tatasusunan.

Parameter: \ ! mass - nama tatasusunan; \ ! value - nilai yang akan dialih keluar daripada tatasusunan

Hasil:
Mengembalikan tatasusunan yang diubah suai, meninggalkan tatasusunan asal tidak berubah. Untuk mengalih keluar elemen dan mengemas kini tatasusunan yang sama, gunakan arahan dalam bentuk berikut:
mass = remove(mass, key)

Contoh mengalih keluar elemen mengikut indeks:

Contoh mengalih keluar elemen tatasusunan mengikut nilainya:

/*Mengalih keluar elemen tatasusunan mengikut indeksnya:*/
array = ["1",2, 3, "4"]
del array['1']

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


/*Mengalih keluar elemen tatasusunan mengikut nilainya:*/
array = ["1",2, 3, "4"]
array=remove(array, '4') 

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

index(mass, value)

Parameter: \ ! mass - nama tatasusunan \ ! value - nilai yang kedudukannya perlu ditentukan.

Jika elemen tidak berada dalam tatasusunan, fungsi akan mengembalikan -1.

Contoh menentukan kedudukan elemen dalam tatasusunan:

Mari kita lihat dengan lebih dekat hasilnya secara terperinci:

Seperti yang kita lihat, memandangkan nombor 5 tidak berada dalam tatasusunan, fungsi mengembalikan -1.

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

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

Parameter:

! massive – tatasusunan yang akan dipaparkan,
header – tajuk yang akan muncul pada permulaan output
numbered – jika sebarang nilai diluluskan, elemen tatasusunan akan dinomborkan
delimiter1 – aksara yang diletakkan di hujung setiap baris elemen (lalai ialah ‘;’),
delimiter2 – aksara yang digunakan selepas nombor item apabila penomboran diaktifkan (lalai ialah ‘)’)

Contoh mudah:

Hasilnya, tatasusunan akan dipaparkan sebagai senarai bernombor:

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

except_arr(mas1, mas2)

Parameter:

! mas1 - tatasusunan dari mana elemen akan dikecualikan,\ ! mas2 - tatasusunan yang mengandungi elemen yang akan dikecualikan

Mari lihat contoh:

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

cross_arr(mas1, mas2)

Parameter:

! mas1 - tatasusunan untuk dicari\ ! mas2 - tatasusunan yang mengandungi elemen yang perlu dicari

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)

Tiada fungsi terbina dalam khusus untuk menggabungkan tatasusunan, tetapi ia boleh dilakukan dengan mudah:

Untuk menggabungkan tatasusunan, lakukan penggabungan rentetan, kemudian gantikan '][' dengan koma ','

Ini adalah contoh dalam medan Kalkulator

Ini adalah contoh bot berfungsi

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

sum_array(array)

Parameter:

array - tatasusunan yang elemennya perlu dijumlahkan

Perhatian! Fungsi berfungsi dengan tatasusunan format tertentu.

Format yang diterima: - [1,2,3,4] atau ‘[1,2,3,4]’.
Jika tatasusunan mengandungi nombor yang diwakili sebagai rentetan, ia perlu disertakan dalam tanda petikan berganda—contohnya, [1,2,3,”-4”].
Jika tatasusunan mengandungi rentetan abjad, pengiraan akan gagal.

Contoh penggunaan yang salah:
mas = [1,2,3,"a"]
result = sum_array(mas)

Ini akan mengakibatkan ralat: array has unsupported elements

Hasil:

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

shuffle_massive(massive)

Parameter:

massive - tatasusunan yang elemennya perlu dikocok.

Keputusan pelaksanaan fungsi:

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

Mengisih dalam tatasusunan atau kamus

sort(mass, b) - mengisih tatasusunan mengikut nilai, dan kamus mengikut kunci

Parameter:

! mass - tatasusunan/kamus
b - susunan isihan (False – menaik (lalai), True – menurun)

Mengisih kamus mengikut nilainya

sort_by_value(dict, b) - mengisih kamus mengikut nilai.

Parameter:\ ! dict- kamus
b - susunan isihan (False – menaik (lalai), True – menurun)

Contoh mengisih tatasusunan dalam susunan menurun dan kamus dalam susunan menaik:

Mengisih kamus mengikut nilai:

Menukar tatasusunan/kamus kepada butang

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

Parameter:

! values_list - tatasusunan rentetan atau kamus yang datanya akan digunakan untuk membina papan kekunci atau senarai bernombor

key - kunci yang mana pemilihan akan dibuat daripada tatasusunan kamus

in_line - bilangan butang setiap baris (lalai: 1)

button_type - jenis butang (lalai: papan kekunci balasan).
Nilai yang mungkin:
0 - papan kekunci balasan,
1 - papan kekunci sebaris (butang dalam teks)

checker_with_numbers - sama ada untuk menambah nombor butang pada tatasusunan "pemeriksa".
Nilai yang mungkin:
0 - jangan tambah nombor,
1 - tambah nombor (lalai: 1 – tambah nombor)

Hasil fungsi — kamus dalam bentuk:

{"numbered_list":"1. T-shirts\n2. Shorts\n3. Socks\n4. Caps\n","buttons":[{"type":"inline","text":"T-shirts","line":0,"index_in_line":0},{"type":"inline","text":"Shorts","line":0,"index_in_line":1},{"type":"inline","text":"Socks","line":1,"index_in_line":0},{"type":"inline","text":"Caps","line":1,"index_in_line":1}],"checker":"T-shirts;1;Shorts;2;Socks;3;Caps;4;"}

Nilai kamus kemudiannya boleh dimasukkan ke dalam medan dalam pembina:

Mendapatkan nilai kamus berdasarkan pilihan pelanggan

tools_check_user_input(values_list, user_input, key, return_key)

Parameter:

! values_list - tatasusunan rentetan atau kamus yang datanya akan digunakan untuk membina papan kekunci atau senarai bernombor\ Contoh kamus: [{"text":"T-shirts","price":100},{"text":"Shorts","price":150},{"text":"Socks","price":20},{"text":"Caps","price":50}]\ ! user_input - nilai yang dimasukkan oleh pengguna daripada salah satu nilai dalam values_list\ Contoh nilai: Caps
key - kunci yang digunakan untuk pemilihan daripada tatasusunan kamus values_list\ Contoh kunci: text
return_key - nilai yang dikembalikan untuk kunci yang ditentukan daripada values_list\ Contoh nilai pulangan: price

Mari kita huraikan penggunaan fungsi dengan contoh troli beli-belah:

1.Tentukan tatasusunan dan tukarkannya kepada senarai bernombor, butang, dan senarai nilai yang mungkin (untuk utusan tanpa butang) menggunakan fungsi tools_make_button_str_checker().

2.Gunakan butang yang diperoleh dan nilai numbered_list untuk membolehkan pemilihan produk:

3.Gunakan senarai nilai yang mungkin checker untuk mengesahkan input pelanggan:

4.Akhir sekali, paparkan harga produk yang dipilih kepada pelanggan. Ini mudah dilakukan menggunakan fungsi 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) 

Parameter:

!** array** - tatasusunan \ !** start_index** - permulaan hirisan
end_index - akhir hirisan (lalai: sehingga akhir)

Mari pilih sub-tatasusunan bermula dari elemen pertama:

 res akan menjadi ["Shorts", "Socks", "Caps"] 

Contoh lain memilih sub-tatasusunan dari elemen ke-0 hingga ke-2 tatasusunan:

 res akan menjadi ["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) - kaedah ini mengulangi tatasusunan dan mencipta pembolehubah berasingan untuk setiap elemen dalam tatasusunan dengan nama seperti var1, var2, var3 dan seterusnya. 

! array - parameter wajib, tatasusunan elemen

var_name - parameter pilihan, rentetan. Jika disediakan, ia digunakan untuk menamakan elemen yang dibongkar. Contoh:

Jika var_name disediakan, nama pembolehubah dibentuk menggunakan var_name

var_name mesti mengikut peraturan penamaan pembolehubah.

Contoh 1:

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

ans1 = unpack_list(array1)

Hasil - pembolehubah urusan yang dicipta:

var1 = 'one'

var2 = 'two'

var3 = 'three'

Contoh 2:

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

var_name = 'custom'

ans2 = unpack_list(array2, var_name)

Hasil - pembolehubah urusan yang dicipta:

custom1 = 'one'

custom2 = 'two'

custom3 = 'three'

remove_duplicates(array) - mengembalikan senarai tanpa elemen pendua.

! array - parameter wajib. Senarai asal elemen dengan pendua.

Contoh:

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

new_arr = remove_duplicates(arr)

Hasil - senarai [1, 2, 5, 3] akan diberikan kepada pembolehubah new_arr.

Mencipta kamus - mengisytiharkan kamus

name_dictionary = {}

Mengosongkan - tidak lebih daripada mengisytiharkan kamus kosong.

name_dictionary = {}

name[key] - mendapatkan elemen kamus mengikut kunci

Contoh bekerja dengan kamus:

 Dalam kes khusus ini, kita mengakses nilai dengan kunci "a". Untuk mendapatkan semula nilai daripada kamus menggunakan kunci tertentu, gunakan format berikut: name_dictionary["key"]

Jawapan:

dicts = {"a": "11", "d": "hi"}
/*mendapatkan daripada kamus*/
aa = dicts["a"]

dict_keys_to_array(data) - untuk mendapatkan senarai kunci kamus data

Contoh: Dapatkan senarai semua kunci kamus

Jawapan: 

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) - untuk mendapatkan senarai nilai daripada kamus

Contoh:

Jawapan:

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) - membolehkan anda mendapatkan nilai daripada senarai kamus mengikut kunci yang ditentukan. Mengembalikan senarai nilai.

Contoh: Dapatkan nilai daripada senarai kamus mengikut kunci

Jawapan:

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

name['key'] = value - menggantikan nilai elemen kamus mengikut kunci yang ditentukan. Jika kunci yang tidak wujud ditentukan, elemen kamus baharu akan ditambah.

Contoh:

Untuk menggantikan nilai elemen tatasusunan tertentu, tulis tugasan seperti array_name[index] = value atau dictionary_name[key] = value

Jawapan: 

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

/*Ganti dalam kamus*/
dicts['d'] = AAAAA

/*Tambah dalam kamus   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

/*Ganti dalam kamus dengan nombor*/
dicts['a'] = int('555')

dictionary_name***['key'] = 'value'** -* menambah nilai baharu pada kamus. 

Jika kunci tidak wujud sebelum ini, pasangan kunci-nilai baharu akan ditambah; jika tidak, nilai untuk kunci yang ditentukan akan diganti.

Ini adalah contoh kod dalam medan kalkulator

Jawapan

/*menambah nilai baharu pada kamus dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

exist_key(mass, key) - untuk menyemak sama ada kunci wujud dalam kamus.

Parameter: 

mass - kamus 

key - kunci untuk dicari

Mengembalikan True atau False bergantung pada sama ada kunci ditemui.

Contoh penggunaan:

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

key_index(mass, key) - untuk menyemak kedudukan kunci dalam kamus.

Parameter:
mass - kamus
key - Kunci untuk dicari.

Kedudukan dalam kamus dikira dari 0. Oleh itu, elemen pertama ialah 0, elemen kedua ialah 1, dan seterusnya.

Contoh penggunaan:

Hasil:

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

arr_len(mass) - untuk menentukan panjang kamus. 

Parameter:
mass - kamus 

Hasil: Mengembalikan nombor – panjang kamus.

Berhati-hati Apabila menghantar parameter kepada fungsi: jika fungsi dipanggil tanpa parameter, ia mengembalikan 0; jika parameter bukan senarai atau kamus, ia mengembalikan -1.

Contoh penggunaan:

Jawapan:

Mengikut indeks atau kunci

del(mass, key) - untuk memadam elemen daripada senarai mengikut indeks atau daripada kamus mengikut kunci.
Ia mengambil dua parameter: senarai/kamus dan indeks/kunci untuk dipadam.
Mengembalikan kamus atau senarai yang diubah suai tanpa mengubah objek asal.

Jika nilai dalam senarai atau kamus adalah nombor, gunakan fungsi remove() untuk memadam elemen.

Contoh dengan kamus

Hasil

Contoh dengan tatasusunan

Hasil

Contoh dengan kamus

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

q=del(s,'q')

Contoh dengan tatasusunan

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

q=del(s, 1)

humanize(dict, delimiter, from_i, to_i) 

Parameter:

dict - nama kamus
delimiter - pemisah antara baris
from_i - indeks elemen untuk memulakan output (berasaskan 0)
to_i - indeks elemen untuk menamatkan output (tidak termasuk)

Mari lihat contoh:

Jawapan

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

Pengisihan kamus

sort(dict, b) - Mengisih senarai mengikut nilai, dan kamus mengikut kunci

Parameter:

!** dict**- kamus

b - arah pengisihan (False – menaik secara lalai, True – menurun)

Pengisihan kamus mengikut nilai

sort_by_value(dict, b) - Mengisih kamus mengikut nilai.

Parameter:

!** dict**- kamus

b - arah pengisihan (False – menaik secara lalai, True – menurun)

Contoh: mengisih senarai dalam tertib menurun dan kamus dalam tertib menaik:

Mengisih kamus mengikut nilainya:

Contoh: mengisih senarai dalam tertib menurun dan kamus dalam tertib menaik:

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)

Mengisih kamus mengikut nilainya:

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

dict=sort_by_value(dict)