การทำงานกับอาร์เรย์และดิกชันนารี

name[index] - การเข้าถึงองค์ประกอบของอาร์เรย์โดยดัชนีหรือโดยค่า

มาดูตัวอย่างการทำงานกับอาร์เรย์กัน:

ตัวอย่างการเข้าถึงองค์ประกอบของอาร์เรย์โดยดัชนี:

ตัวอย่างการรับองค์ประกอบสุดท้ายของอาร์เรย์:

/*การเข้าถึงโดยดัชนี*/
arrayI = [1, "2", 3, 4, 5]
k=arrayI[3]
/*การเข้าถึงโดยดัชนีจากอาร์เรย์ที่ซ้อนกัน*/
arrayV = [[1, "2", 4, 5], "2", 3, 4, 5]
v=arrayV[0][1]

/*ตัวอย่างการรับองค์ประกอบสุดท้าย*/
array = [1, "2", 3, 4, 5]
/*การรับองค์ประกอบสุดท้ายของอาร์เรย์*/
last = array[-1]

name[index] = value - การแทนที่องค์ประกอบของอาร์เรย์ตามดัชนีที่กำหนด

ตัวอย่าง:

ในการแทนที่ค่าขององค์ประกอบอาร์เรย์ที่ระบุ ให้ใช้ไวยากรณ์ต่อไปนี้: array_name[index] = value

คำตอบ:

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

/*แทนที่ในอาร์เรย์/ดิกชันนารี*/
array[2] = 888

/*เพิ่มในดิกชันนารี   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

/*แทนที่ในอาร์เรย์/ดิกชันนารีเป็นตัวเลข*/
array[3] = int('888')
dicts['a'] = int('555')

in_array(mass, value) - เพื่อตรวจสอบว่ามีองค์ประกอบอยู่ในอาร์เรย์หรือไม่

พารามิเตอร์: \ ! mass - อาร์เรย์ \ ! value - ค่าสำหรับค้นหา

คืนค่า True หรือ False ขึ้นอยู่กับว่าพบค่าหรือไม่

ตัวอย่าง:

s = ["Mike", "Peter", "Helen"] 
q = if(in_array(s, 'Ann'), 'Found', 'Another string')

arr_len(mass) - เพื่อหาความยาวของอาร์เรย์

พารามิเตอร์:\ ! mass - อาร์เรย์

ผลลัพธ์: คืนค่าตัวเลข - ความยาวของอาร์เรย์

ระวังเมื่อส่งพารามิเตอร์ไปยังฟังก์ชัน! ถ้าเรียกใช้โดยไม่มีพารามิเตอร์ จะคืนค่า 0; ถ้าพารามิเตอร์ไม่ใช่อาร์เรย์หรือดิกชันนารี จะคืนค่า -1

ตัวอย่างการใช้งาน:

ผลลัพธ์:

s = ["Mike", "Peter", "Helen"] 
q = if(arr_len(s) > 5, 'Group is full', 'Join our team!')

append(mass, element, priznak) - เพื่อแทรกองค์ประกอบที่ส่วนท้ายของอาร์เรย์

พารามิเตอร์:

! mass - อาร์เรย์\ ! element - องค์ประกอบที่จะแทรก
priznak - แฟล็กที่ระบุว่าเป็นอาร์เรย์หรือดิกชันนารี

คืนค่าอาร์เรย์ที่มีค่าเพิ่มที่ส่วนท้าย ในการอัปเดตอาร์เรย์ต้นฉบับ ให้ใช้การกำหนด: mass = append(mass, element, priznak)

โดยค่าเริ่มต้น ข้อมูลจะถูกแทรกเป็นสตริง ถ้าคุณต้องการแทรกอาร์เรย์หรือดิกชันนารี ให้ส่งพารามิเตอร์เพิ่มเติม True ซึ่งบ่งชี้ว่าคุณกำลังแทรก JSON

ตัวอย่างการใช้งาน:

ตัวอย่างการเพิ่มและลบออกจากอาร์เรย์:

ตัวอย่างการสร้างอาร์เรย์ที่มีอาร์เรย์อยู่ภายใน:

ผลลัพธ์ของการดำเนินการฟังก์ชัน:

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

insert(mass, index, value, priznak) - เพื่อแทรกองค์ประกอบลงในตำแหน่งอาร์เรย์ที่ระบุ

พารามิเตอร์: \ ! mass - อาร์เรย์\ ! index - ตำแหน่งแทรก\ ! value - ค่า
indicator - ตัวบ่งชี้การเพิ่มลงในอาร์เรย์หรือดิกชันนารี

ผลลัพธ์:
คืนค่าอาร์เรย์ที่มีค่าเพิ่มที่ตำแหน่งที่ระบุ กล่าวอีกนัยหนึ่ง ในการเพิ่มค่าไปยังอาร์เรย์เดียวกัน ให้ใช้คำสั่งในรูปแบบต่อไปนี้: mass = insert(mass, index, value, indicator)

โดยค่าเริ่มต้น ข้อมูลจะถูกแทรกเป็นสตริง ถ้าคุณต้องการแทรกอาร์เรย์หรือดิกชันนารี ให้ส่งพารามิเตอร์เพิ่มเติม True ซึ่งบ่งชี้ว่าคุณกำลังแทรก JSON

ตัวอย่าง:

ผลลัพธ์:

มาดูตัวอย่างที่ซับซ้อนมากขึ้น - การเพิ่มดิกชันนารี t ลงในอาร์เรย์ s:

ในฟังก์ชัน เราระบุว่าเราต้องการเพิ่มดิกชันนารีที่ตำแหน่ง 1 มาดูผลลัพธ์กัน:

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

ตามดัชนี

del(mass, key) - ลบสมาชิกออกจากอาร์เรย์ตามดัชนีของมัน

พารามิเตอร์: \ ! mass - ชื่ออาร์เรย์;\ ! key - ดัชนีของค่าที่จะถูกลบ

ส่งคืนอาร์เรย์ใหม่ที่ไม่มีสมาชิกที่ถูกลบออกไป อาร์เรย์ต้นฉบับจะไม่มีการเปลี่ยนแปลง หากต้องการลบและอัปเดตอาร์เรย์เดียวกัน ให้ใช้คำสั่งในรูปแบบ:
mass = del(mass, key)

หากอาร์เรย์ของคุณมีตัวเลขและคุณต้องการลบสมาชิกตามค่า ให้ใช้ฟังก์ชัน remove()

del name['index'] - การลบค่าออกจากอาร์เรย์ตามดัชนี

พารามิเตอร์: \ ! name- ชื่ออาร์เรย์;\ ! index- ดัชนีของค่าที่จะถูกลบ

ตามค่า

remove(mass, value) - เพื่อลบค่าออกจาก อาร์เรย์

พารามิเตอร์: \ ! mass - ชื่ออาร์เรย์; \ ! value - ค่าที่จะลบออกจากอาร์เรย์

ผลลัพธ์:
ส่งคืนอาร์เรย์ที่ถูกแก้ไข โดยอาร์เรย์ต้นฉบับจะไม่มีการเปลี่ยนแปลง หากต้องการลบสมาชิกและอัปเดตอาร์เรย์เดียวกัน ให้ใช้คำสั่งในรูปแบบต่อไปนี้:
mass = remove(mass, key)

ตัวอย่างการลบสมาชิกตามดัชนี:

ตัวอย่างการลบสมาชิกอาร์เรย์ตามค่า:

/*Removing an array element by its index:*/
array = ["1",2, 3, "4"]
del array['1']

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


/*Removing an array element by its value:*/
array = ["1",2, 3, "4"]
array=remove(array, '4') 

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

index(mass, value)

พารามิเตอร์: \ ! mass - ชื่ออาร์เรย์ \ !** value -** ค่าที่ต้องการหาตำแหน่ง

หากสมาชิกไม่อยู่ในอาร์เรย์ ฟังก์ชันจะคืนค่า -1

ตัวอย่างการหาตำแหน่งของสมาชิกในอาร์เรย์:

มาดูผลลัพธ์อย่างละเอียด:

อย่างที่เห็น เนื่องจากเลข 5 ไม่ได้อยู่ในอาร์เรย์ ฟังก์ชันจึงคืนค่า -1

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

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

พารามิเตอร์:

!** massive** – อาร์เรย์ที่จะแสดง,
header – หัวเรื่องที่จะปรากฏที่จุดเริ่มต้นของผลลัพธ์
numbered – หากมีการส่งค่าใดๆ สมาชิกอาร์เรย์จะถูกกำหนดหมายเลข
delimiter1 – อักขระที่วางไว้ที่ท้ายแต่ละบรรทัดของสมาชิก (ค่าเริ่มต้นคือ ';'),
delimiter2 – อักขระที่ใช้หลังหมายเลขรายการเมื่อเปิดใช้งานการกำหนดหมายเลข (ค่าเริ่มต้นคือ ')')

ตัวอย่างง่ายๆ:

เป็นผลลัพธ์ อาร์เรย์จะแสดงเป็นรายการที่มีหมายเลข:

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

except_arr(mas1, mas2)

พารามิเตอร์:

!** mas1** - อาร์เรย์ที่จะแยกสมาชิกออก,\ !** mas2** - อาร์เรย์ที่มีสมาชิกที่จะถูกแยกออก

มาดูตัวอย่าง:

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

cross_arr(mas1, mas2)

พารามิเตอร์:

!** mas1** - อาร์เรย์ที่จะค้นหา\ !** mas2** - อาร์เรย์ที่มีสมาชิกที่จะค้นหา

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)

ไม่มีฟังก์ชันในตัวสำหรับการรวมอาร์เรย์โดยเฉพาะ แต่สามารถทำได้ง่ายๆ:

ในการรวมอาร์เรย์ ให้ทำการต่อสตริง จากนั้นแทนที่ '][' ด้วยเครื่องหมายจุลภาค ','

นี่คือตัวอย่างในฟิลด์ Calculator

นี่คือตัวอย่างการทำงานของบอท

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

sum_array(array)

พารามิเตอร์:

array - อาร์เรย์ที่ต้องการรวมสมาชิก

ข้อควรระวัง!** ฟังก์ชันนี้ทำงานกับอาร์เรย์ในรูปแบบเฉพาะ**

รูปแบบที่ยอมรับได้: - [1,2,3,4] หรือ '[1,2,3,4]'
หากอาร์เรย์มีตัวเลขที่แสดงเป็นสตริง จะต้องใส่ไว้ในเครื่องหมายคำพูดคู่ เช่น [1,2,3,"-4"]
หากอาร์เรย์มีสตริงที่เป็นตัวอักษร การคำนวณจะล้มเหลว

ตัวอย่างการใช้งานที่ไม่ถูกต้อง:
mas = [1,2,3,"a"]
result = sum_array(mas)

ซึ่งจะทำให้เกิดข้อผิดพลาด: array has unsupported elements

ผลลัพธ์:

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

shuffle_massive(massive)

พารามิเตอร์:

massive - อาร์เรย์ที่ต้องการสลับสมาชิก

ผลลัพธ์การทำงานของฟังก์ชัน:

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

การเรียงลำดับในอาร์เรย์หรือดิกชันนารี

sort(mass, b) - เรียงลำดับอาร์เรย์ตามค่า และดิกชันนารีตามคีย์

พารามิเตอร์:

!** mass** - อาร์เรย์/ดิกชันนารี
b - ลำดับการเรียง (False – จากน้อยไปมาก (ค่าเริ่มต้น), True – จากมากไปน้อย)

การเรียงลำดับดิกชันนารีตามค่า

sort_by_value(dict, b) - เรียงลำดับดิกชันนารีตามค่า

พารามิเตอร์:\ !** dict**- ดิกชันนารี
b - ลำดับการเรียง (False – จากน้อยไปมาก (ค่าเริ่มต้น), True – จากมากไปน้อย)

ตัวอย่างการเรียงลำดับอาร์เรย์จากมากไปน้อยและดิกชันนารีจากน้อยไปมาก:

การเรียงลำดับดิกชันนารีตามค่า:

การแปลงอาร์เรย์/ดิกชันนารีเป็นปุ่ม

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

พารามิเตอร์:

! values_list - อาร์เรย์ของสตริงหรือดิกชันนารีที่จะใช้ข้อมูลในการสร้างคีย์บอร์ดหรือรายการที่มีหมายเลข

key - คีย์ที่จะใช้ในการเลือกจากอาร์เรย์ของดิกชันนารี

in_line - จำนวนปุ่มต่อแถว (ค่าเริ่มต้น: 1)

button_type - ประเภทของปุ่ม (ค่าเริ่มต้น: reply keyboard)
ค่าที่เป็นไปได้:
0 - reply keyboard,
1 - inline keyboard (ปุ่มในข้อความ)

checker_with_numbers - ว่าจะเพิ่มหมายเลขปุ่มลงในอาร์เรย์ "checker" หรือไม่
ค่าที่เป็นไปได้:
0 - ไม่เพิ่มหมายเลข,
1 - เพิ่มหมายเลข (ค่าเริ่มต้น: 1 – เพิ่มหมายเลข)

ผลลัพธ์ของฟังก์ชัน — ดิกชันนารีในรูปแบบ:

{"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;"}

จากนั้นสามารถแทรกค่าดิกชันนารีลงในฟิลด์ในตัวสร้าง:

การรับค่าดิกชันนารีตามการเลือกของลูกค้า

tools_check_user_input(values_list, user_input, key, return_key)

พารามิเตอร์:

!** values_list** - อาร์เรย์ของสตริงหรือดิกชันนารีที่จะใช้ข้อมูลในการสร้างคีย์บอร์ดหรือรายการที่มีหมายเลข\ ตัวอย่างดิกชันนารี: [{"text":"T-shirts","price":100},{"text":"Shorts","price":150},{"text":"Socks","price":20},{"text":"Caps","price":50}]\ !** user_input** - ค่าที่ผู้ใช้ป้อนจากค่าใดค่าหนึ่งใน values_list\ ตัวอย่างค่า: Caps
key - คีย์ที่ใช้ในการเลือกจากอาร์เรย์ของดิกชันนารี values_list\ ตัวอย่างคีย์: text
return_key - ค่าที่ส่งคืนสำหรับคีย์ที่ระบุจาก values_list\ ตัวอย่างค่าที่ส่งคืน: price

มาวิเคราะห์การใช้งานฟังก์ชันด้วยตัวอย่างตะกร้าสินค้า:

1.กำหนดอาร์เรย์และแปลงเป็นรายการที่มีหมายเลข ปุ่ม และรายการค่าที่เป็นไปได้ (สำหรับเมสเซนเจอร์ที่ไม่มีปุ่ม) โดยใช้ฟังก์ชัน tools_make_button_str_checker()

2.ใช้ปุ่มและค่า numbered_list ที่ได้เพื่อเปิดใช้งานการเลือกสินค้า:

3.ใช้รายการค่าที่เป็นไปได้ checker เพื่อตรวจสอบอินพุตของลูกค้า:

4.สุดท้าย แสดงราคาของสินค้าที่เลือกให้ลูกค้าเห็น สะดวกในการทำเช่นนี้โดยใช้ฟังก์ชัน 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)

พารามิเตอร์:

! array - อาร์เรย์ \ ! start_index - จุดเริ่มต้นของชิ้นส่วน
end_index - จุดสิ้นสุดของชิ้นส่วน (ค่าเริ่มต้น: จนถึงจุดสิ้นสุด)

มาเลือกอาร์เรย์ย่อยโดยเริ่มจากองค์ประกอบที่ 1:

res จะเป็น ["Shorts", "Socks", "Caps"]

อีกตัวอย่างหนึ่งของการเลือกอาร์เรย์ย่อยจากองค์ประกอบที่ 0 ถึงองค์ประกอบที่ 2 ของอาร์เรย์:

res จะเป็น ["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) - เมธอดนี้จะวนซ้ำอาร์เรย์และสร้างตัวแปรแยกต่างหากสำหรับแต่ละองค์ประกอบในอาร์เรย์โดยมีชื่อเช่น var1, var2, var3 และอื่นๆ

! array - พารามิเตอร์ที่จำเป็น, อาร์เรย์ขององค์ประกอบ

var_name - พารามิเตอร์ที่ไม่บังคับ, สตริง หากระบุไว้ จะใช้สำหรับการตั้งชื่อองค์ประกอบที่ถูกแยก ตัวอย่าง:

หากระบุ var_name ชื่อตัวแปรจะถูกสร้างขึ้นโดยใช้ var_name

var_name ต้องเป็นไปตามกฎการตั้งชื่อตัวแปร

ตัวอย่างที่ 1:

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

ans1 = unpack_list(array1)

ผลลัพธ์ - ตัวแปรดีลที่ถูกสร้างขึ้น:

var1 = 'one'

var2 = 'two'

var3 = 'three'

ตัวอย่างที่ 2:

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

var_name = 'custom'

ans2 = unpack_list(array2, var_name)

ผลลัพธ์ - ตัวแปรดีลที่ถูกสร้างขึ้น:

custom1 = 'one'

custom2 = 'two'

custom3 = 'three'

remove_duplicates(array) - คืนค่ารายการโดยไม่มีองค์ประกอบที่ซ้ำกัน

! array - พารามิเตอร์ที่จำเป็น รายการองค์ประกอบดั้งเดิมที่มีรายการซ้ำ

ตัวอย่าง:

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

new_arr = remove_duplicates(arr)

ผลลัพธ์ - รายการ [1, 2, 5, 3] จะถูกกำหนดให้กับตัวแปร new_arr

การสร้างดิกชันนารี - การประกาศดิกชันนารี

name_dictionary = {}

การล้าง - ไม่มีอะไรมากไปกว่าการประกาศดิกชันนารีว่าง

name_dictionary = {}

name[key] - การรับองค์ประกอบดิกชันนารีตามคีย์

ตัวอย่างการทำงานกับดิกชันนารี:

ในกรณีนี้ เรากำลังเข้าถึงค่าตามคีย์ "a" หากต้องการดึงค่าจากดิกชันนารีโดยใช้คีย์เฉพาะ ให้ใช้รูปแบบต่อไปนี้: name_dictionary["key"]

คำตอบ:

dicts = {"a": "11", "d": "hi"}
/*getting from dictionary*/
aa = dicts["a"]

dict_keys_to_array(data) - เพื่อรับรายการคีย์ของดิกชันนารีข้อมูล

ตัวอย่าง: รับรายการคีย์ทั้งหมดของดิกชันนารี

คำตอบ:

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) - เพื่อรับรายการค่าจากดิกชันนารี

ตัวอย่าง:

คำตอบ:

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) - ช่วยให้คุณได้รับค่าจากรายการดิกชันนารีตามคีย์ที่ระบุ คืนค่ารายการของค่า

ตัวอย่าง: รับค่าจากรายการดิกชันนารีตามคีย์

คำตอบ:

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

name['key'] = value - การแทนที่ค่าองค์ประกอบดิกชันนารีตามคีย์ที่ระบุ หากระบุคีย์ที่ไม่มีอยู่ องค์ประกอบดิกชันนารีใหม่จะถูกเพิ่ม

ตัวอย่าง:

หากต้องการแทนที่ค่าขององค์ประกอบอาร์เรย์เฉพาะ ให้เขียนการกำหนดเช่น array_name[index] = value หรือ dictionary_name[key] = value

คำตอบ:

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

/*Replace in a dictionary*/
dicts['d'] = AAAAA

/*Add in a dictionary   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

/*Replace in a dictionary with a number*/
dicts['a'] = int('555')

dictionary_name***['key'] = 'value'** -* การเพิ่มค่าใหม่ลงในดิกชันนารี

หากคีย์ไม่มีอยู่ก่อนหน้านี้ คู่คีย์-ค่าใหม่จะถูกเพิ่ม มิฉะนั้น ค่าสำหรับคีย์ที่ระบุจะถูกแทนที่

นี่คือตัวอย่างโค้ดในฟิลด์เครื่องคิดเลข

คำตอบ

/*adding a new value to the dictionary dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

exist_key(mass, key) - เพื่อตรวจสอบว่ามีคีย์อยู่ในดิกชันนารีหรือไม่

พารามิเตอร์:

mass - ดิกชันนารี

key - คีย์ที่จะค้นหา

คืนค่า True หรือ False ขึ้นอยู่กับว่าพบคีย์หรือไม่

ตัวอย่างการใช้งาน:

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

key_index(mass, key) - เพื่อตรวจสอบตำแหน่งของคีย์ในดิกชันนารี

พารามิเตอร์:
mass - ดิกชันนารี
key - คีย์ที่จะค้นหา

ตำแหน่งในดิกชันนารีนับจาก 0 ดังนั้น องค์ประกอบแรกคือ 0 องค์ประกอบที่สองคือ 1 และอื่นๆ

ตัวอย่างการใช้งาน:

ผลลัพธ์:

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

arr_len(mass) - เพื่อกำหนดความยาวของดิกชันนารี

พารามิเตอร์:
mass - ดิกชันนารี

ผลลัพธ์: คืนค่าตัวเลข – ความยาวของดิกชันนารี

โปรดใช้ความระมัดระวังเมื่อส่งพารามิเตอร์ไปยังฟังก์ชัน: หากเรียกใช้ฟังก์ชันโดยไม่มีพารามิเตอร์ ฟังก์ชันจะคืนค่า 0 หากพารามิเตอร์ไม่ใช่รายการหรือดิกชันนารี ฟังก์ชันจะคืนค่า -1

ตัวอย่างการใช้งาน:

คำตอบ:

ตามดัชนีหรือคีย์

del(mass, key) - เพื่อลบองค์ประกอบออกจากรายการตามดัชนีหรือจากดิกชันนารีตามคีย์
ใช้พารามิเตอร์สองตัว: รายการ/ดิกชันนารีและดัชนี/คีย์ที่จะลบ
คืนค่าดิกชันนารีหรือรายการที่แก้ไขโดยไม่เปลี่ยนแปลงออบเจกต์ต้นฉบับ

หากค่าในรายการหรือดิกชันนารีเป็นตัวเลข ให้ใช้ฟังก์ชัน remove() เพื่อลบองค์ประกอบ

ตัวอย่างกับดิกชันนารี

ผลลัพธ์

ตัวอย่างกับอาร์เรย์

ผลลัพธ์

ตัวอย่างกับดิกชันนารี

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

q=del(s,'q')

ตัวอย่างกับอาร์เรย์

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

q=del(s, 1)

humanize(dict, delimiter, from_i, to_i)

พารามิเตอร์:

dict - ชื่อดิกชันนารี
delimiter - ตัวคั่นระหว่างบรรทัด
from_i - ดัชนีขององค์ประกอบที่จะเริ่มแสดงผล (นับจาก 0)
to_i - ดัชนีขององค์ประกอบที่จะสิ้นสุดการแสดงผล (ไม่รวม)

มาดูตัวอย่าง:

คำตอบ

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

การเรียงลำดับดิกชันนารี

sort(dict, b) - เรียงลำดับรายการตามค่า และดิกชันนารีตามคีย์

พารามิเตอร์:

! dict- ดิกชันนารี

b - ทิศทางการเรียงลำดับ (False – จากน้อยไปมากตามค่าเริ่มต้น, True – จากมากไปน้อย)

การเรียงลำดับดิกชันนารีตามค่า

sort_by_value(dict, b) - การเรียงลำดับดิกชันนารีตามค่า

พารามิเตอร์:

! dict- ดิกชันนารี

b - ทิศทางการเรียงลำดับ (False – จากน้อยไปมากตามค่าเริ่มต้น, True – จากมากไปน้อย)

ตัวอย่าง: การเรียงลำดับรายการจากมากไปน้อยและดิกชันนารีจากน้อยไปมาก:

การเรียงลำดับดิกชันนารีตามค่า:

ตัวอย่าง: การเรียงลำดับรายการจากมากไปน้อยและดิกชันนารีจากน้อยไปมาก:

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)

การเรียงลำดับดิกชันนารีตามค่า:

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

dict=sort_by_value(dict)