List sa Python: mga method, slice, sorting, append, tuple, at set

Ang list sa Python (list) ay maayos na koleksiyon ng anumang halaga sa loob ng mga square bracket, at maaari itong baguhin: magdagdag ng elemento sa dulo, magpasok sa gitna, magtanggal, mag-ayos. Ito ang pinakagamiting koleksiyon ng wika: mga linya ng file, mga gastos sa buong buwan, mga sagot ng API — halos lahat ay nagsisimula sa list. Tatalakayin natin ang python list nang buo: paggawa, mga method, slice, sorting, list comprehension, pagkopya, at sa dulo, tuple at set.

Ano ang list sa Python

Iniimbak ng list ang mga elemento ayon sa pagkakasunod na itinakda mo, at naaabot ang mga ito sa pamamagitan ng index na nagsisimula sa zero. Maaaring magkakaiba ang uri ng mga halaga sa iisang list, bagaman sa praktika ay karaniwang magkakapareho ang datos.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — unang elemento
print(amounts[-1])    # 99 — huling elemento
amounts[1] = 1300     # nababago ang list
print(len(amounts))   # 3 — haba ng list

Ibinabalik ng function na len() ang laki ng list. Kapag tinangka mong i-access ang index na wala, makakakuha ka ng IndexError: list index out of range.

Paggawa ng list

empty = []                       # walang laman na list
also_empty = list()              # pareho, gamit ang function na list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

Ginagawang list ng function na list() ang anumang iterable object: string, range, set, o mga key ng dictionary.

append at iba pang method ng list

Idinadagdag ng method na append ang isang elemento sa dulo ng list — ito ang pinakamadalas gamiting method sa Python. Binabago nito ang list sa mismong lugar at nagbabalik ng None.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # tanggalin ang unang halagang 1200
last = amounts.pop()         # 20 — tanggalin at ibalik ang huli

Karaniwang pagkakamali: ang a.append([10, 20]) ay nagdaragdag ng isang elemento — isang nakapaloob na list, hindi dalawang numero. Para sa maraming elemento, gamitin ang extend.

Maaari ring magtanggal ng elemento sa index o ng buong saklaw gamit ang del na operator: del a[0], del a[1:3]. Kapaki-pakinabang na built-in na function para sa list: len, sum, min, max, sorted, reversed, enumerate, zip.

Mga slice sa Python

Kumukuha ng bahagi ng list ang slice ayon sa anyong a[start:stop:step]: mula sa start na kasama, hanggang sa stop na hindi kasama, na may hakbang na step. Maaaring alisin ang alinmang bahagi. Laging nagbabalik ng bagong list ang slice.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — unang dalawa
print(a[-2:])     # [4, 5] — huling dalawa
print(a[::2])     # [0, 2, 4] — bawat ikalawa
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — baligtad
print(a[:])       # kopya ng buong list

Hindi tulad ng index, hindi nagbibigay ng error ang slice na lumalampas sa list: ang a[10:20] ay magbabalik lang ng []. Maaari ring bigyan ng halaga ang slice at palitan ang bahagi ng list: a[1:3] = ["x", "y", "z"].

Slice ng string

Pareho ang paggana ng slice sa lahat ng sunod-sunod na datos, kasama ang string at tuple:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Hindi mo mababago ang string gamit ang slice — hindi nababago ang string, at gagawa ang slice ng bagong string.

Pag-aayos ng list: sort at sorted

Dito kadalasang nalilito ang mga baguhan. Inililipat ng method na sort ang mga elemento sa mismong list at nagbabalik ng None. Hindi ginagalaw ng function na sorted ang orihinal na list at nagbabalik ng bagong nakaayos na list.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — bagong kopya
print(amounts)             # [250, 1200, 99, 450] — buo pa ang orihinal

result = amounts.sort()    # inaayos sa mismong lugar
print(result, amounts)     # None [99, 250, 450, 1200]

Dito nanggagaling ang klasikong tanong na "bakit None ang nakukuha ko": ang a = a.sort() ay nagpapalit ng list sa halagang None. Isulat alinman sa a.sort() o sa a = sorted(a).

Key at pagkakasunod na pababa

Parehong tumatanggap ang dalawa ng mga parameter na key at reverse. Ang key ay function na ang resulta ang ginagamit sa paghahambing ng mga elemento.

words = ["kape", "Taksi", "abonado"]
print(sorted(words, key=len))               # ['kape', 'Taksi', 'abonado']
print(sorted(words, key=str.lower))         # hindi sensitibo sa letra
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Pagkain", 650), ("Sine", 120), ("Taksi", 300)]
expenses.sort(key=lambda e: e[1])           # ayon sa halaga

Stable ang sorting sa Python: nananatili ang orihinal na pagkakasunod ng mga elementong may parehong key. Iba rin ang sakop ng dalawa: tinatanggap ng sorted ang anumang sunod-sunod na datos (string, dictionary, set), samantalang may sort lang ang list.

Baligtarin ang list

Tatlong paraan na may magkakaibang kilos:

• a.reverse() — binabaligtad sa mismong lugar, nagbabalik ng None;
• a[::-1] — bagong baligtad na list;
• reversed(a) — lazy iterator, maginhawa sa loop: for x in reversed(a):.

Pagdaan sa list

items = ["kape", "metro", "sine"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 kape, 2 metro, 3 sine

print("sine" in items)      # True — pagsusuri kung nandoon

Huwag magtanggal ng elemento sa list na dinadaanan ng loop — may ilang elementong malalaktawan. Bumuo ng bagong list gamit ang comprehension, o dumaan sa kopya na a[:].

List comprehension

Bumubuo ang list comprehension ng bagong list sa isang linya: ekspresyon, loop, at opsyonal na kondisyon.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" anna ", "oscar"]]

Kadalasang mas mabilis at mas madaling basahin ang list comprehension kaysa sa loop na may append. Pero kung hindi kasya sa isang malinaw na linya ang lohika, mas mabuti ang tahasang loop.

Pagsasama, pagdaragdag, at pagbabawas ng list

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — bagong list
a += b             # katulad ng a.extend(b)
print([*a, *b])    # unpacking sa bagong list

Walang operator na - para sa pagbabawas ng list. Para alisin sa isang list ang mga elemento ng isa pa, gumamit ng comprehension: [x for x in a if x not in set(b)]. Mas madaling hanapin ang intersection ng mga list gamit ang set: set(a) & set(b) (nawawala ang pagkakasunod at mga duplicate sa prosesong ito).

Nested at dalawang-dimensiyong list

Ang list ng mga list ay simpleng paraan para mag-imbak ng talahanayan o matrix:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # tama
bad = [[0] * 3] * 2                  # bitag: dalawang reference sa iisang list
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

Unpacking ng list

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print ng list nang walang bracket

Kapag hindi tugma ang bilang ng variable sa haba ng list, magkakaroon ng ValueError — dito nakatutulong ang asterisk.

Pagkopya ng list

Hindi kinokopya ng b = a ang list; naglalagay lang ito ng pangalawang label sa iisang object: ang pagbabago sa pamamagitan ng b ay makikita sa a. Ang hiwalay na kopya ay tahasang ginagawa: a.copy(), list(a), o a[:]. Para sa nested na datos, hindi sapat ito — mananatiling nakabahagi ang mga panloob na list, kaya kailangan ang copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — nakabahagi ang nested list
c = copy.deepcopy(a)     # ganap na hiwalay na kopya

Tuple: list na hindi nababago

Katulad ng list ang tuple (tuple), pero hindi ito mababago pagkatapos gawin. Malinaw itong senyales sa nagbabasa: isang rekord na may nakapirmeng mga field ang nasa harapan mo, hindi lumalaking koleksiyon. Madaling i-unpack ang tuple, at dito karaniwang ibinabalik ng mga function ang maraming halaga.

expense = (250, "Kape")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Ang tuple na may hindi nababagong halaga ay puwedeng i-hash, kaya maaari itong gamiting key ng dictionary. Ang tuple na may isang elemento ay isinusulat na may kuwit: (5,).

Set: mga natatanging halaga lang

Iniimbak ng set (set) ang mga natatanging halaga lang at hindi inaalala ang pagkakasunod. Ito ang pinakamabilis na paraan para alisin ang mga duplicate at tingnan kung may ganoong elemento, at kaya rin nitong gawin ang intersection, union, at difference.

jan = {"Pagkain", "Taksi", "Sine"}
feb = {"Pagkain", "Subscription"}
print(jan & feb)    # {'Pagkain'}
print(feb - jan)    # {'Subscription'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — walang duplicate, nananatili ang pagkakasunod
empty = set()       # {} — dictionary ito, hindi set!

Aling koleksiyon ang pipiliin

Isa-isang tinitingnan ng x in list ang mga elemento, samantalang halos agad ang x in set. Kung paulit-ulit kang tumitingin ng halaga sa malaking list sa loob ng loop, gawin muna itong set.

Buod

Ang python list ay maayos at mababagong koleksiyon: idinadagdag ng append at extend, tinatanggal ng pop at remove, kinukuha ng slice na a[start:stop:step] ang mga bahagi, inaayos ng sort sa mismong lugar at nagbabalik ng None, at ang sorted ay nagbibigay ng bagong list. Gumawa ng kopya nang tahasan, kumuha ng tuple para sa nakapirmeng rekord, at set para sa mga natatanging halaga. Ang mga list, tuple, dictionary, at set ay tinalakay nang praktikal sa kursong "Python 3.15: mula baguhan hanggang propesyonal".