Persediaan Temu Duga Pengaturcaraan · Pelajaran

Senarai, Tuple dan Pemotongan

Kuasai operasi senarai Python, sintaks pemotongan dan ketidakbolehubahan tuple melalui contoh praktikal daripada cabaran pengekodan klasik.

Pelajaran 1 daripada 413 langkah

Senarai, Tuple dan Pemotongan ialah pelajaran Persediaan Temu Duga Pengaturcaraan percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Persediaan Temu Duga Pengaturcaraan, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Persediaan Temu Duga Pengaturcaraan merangkumi sejumlah 4 pelajaran.

Senarai Python: Tatasusunan Dinamik

Senarai Python ialah tatasusunan dinamik yang boleh menyimpan apa-apa sahaja dan berkembang sendiri. Senarai adalah tersusun, boleh diubah, dan memberikan akses serta-merta O(1) berdasarkan indeks. Kod ini menunjukkan asasnya.

nums = [3, 1, 4, 1, 5]
print(nums[0])   # 3
print(nums[-1])  # 5  (last element)
nums.append(9)
print(len(nums)) # 6

Operasi Senarai Biasa

Hafalkan perkara ini: append dan pop pada hujung mengambil masa O(1), tetapi insert pada permulaan mengambil masa O(n). Elakkan remove dalam gelung yang ketat — operasi itu mengimbas semula setiap kali.

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop())   # 3  O(1)
print(stack)         # [1, 2]

# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack)         # [0, 1, 2]

Sintaks Penghirisan Diterangkan

Penghirisan ditulis sebagai lst[start:stop:step] dan berhenti tepat sebelum stop. Helah klasik: step bernilai -1 membalikkan senarai tanpa mengubahnya. Kod ini menerangkan setiap bentuk.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])    # [1, 2, 3]
print(a[:3])     # [0, 1, 2]
print(a[3:])     # [3, 4, 5]
print(a[::2])    # [0, 2, 4]  every other
print(a[::-1])   # [5, 4, 3, 2, 1, 0]  reversed

Penghirisan Mencipta Salinan Cetek

Perangkap yang berguna: penghirisan sentiasa menghasilkan senarai baharu, jadi pengeditan pada hasil hirisan tidak menjejaskan senarai asal. Namun, salinan itu cetek, jadi senarai bersarang di dalamnya masih dikongsi. Berhati-hatilah.

original = [1, 2, 3]
copy = original[:]  # shallow copy
copy[0] = 99
print(original)  # [1, 2, 3]  unchanged

# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested)    # [[99, 2], [3, 4]]  changed!

Tupel: Jujukan Tidak Berubah

Tupel menggunakan tanda kurung dan tidak boleh diubah selepas dicipta. Oleh sebab tupel boleh dicincang, ia boleh menjadi kunci kamus atau ahli set — sesuai untuk pasangan (baris, lajur) dalam masalah grid.

point = (3, 7)
print(point[0])   # 3

# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)])  # start

# Unpacking
x, y = point
print(x, y)  # 3 7

Bila Perlu Menggunakan Tupel Berbanding Senarai

Pilih tupel apabila data tidak sepatutnya berubah, dan senarai apabila data itu boleh berubah. Tupel juga menggunakan sedikit kurang memori, yang boleh memberi kesan besar dalam timbunan besar bagi Dijkstra.

import sys
a_list  = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list))   # e.g. 104 bytes
print(sys.getsizeof(a_tuple))  # e.g. 80 bytes

# Tuple returned from function
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi)  # 1 5

Ralat Satu Beza dalam Penghirisan

Ralat satu beza ialah perangkap utama dalam masalah tatasusunan. Ingat bahawa lst[i:j] memberikan tepat j-i item. Untuk membahagi pada bahagian tengah, sebelah kiri ialah lst[:mid] dan sebelah kanan ialah lst[mid:].

lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2    # 3
left  = lst[:mid]      # [1, 2, 3]
right = lst[mid:]      # [4, 5, 6]
print(left, right)

# How many elements?
print(len(lst[2:5]))   # 3  (indices 2,3,4)

Indeks Negatif dalam Temu Duga

Python mempunyai indeks negatif: lst[-1] ialah item terakhir, manakala lst[-2] ialah item sebelumnya. Utamakan lst[-1] berbanding lst[len(lst)-1] — penemuduga akan menghargai versi yang lebih kemas.

s = 'abcde'
print(s[-1])    # 'e'
print(s[-3:])   # 'cde'
print(s[:-2])   # 'abc'  (all except last 2)

nums = [10, 20, 30, 40]
print(nums[-2])   # 30
nums[-1] = 99
print(nums)       # [10, 20, 30, 99]

Pengisihan dan Perbandingan Senarai

Pengisihan Python menggunakan Timsort (O(n log n), stabil). lst.sort() mengubah senarai di tempatnya; sorted(lst) mengembalikan senarai baharu. Gunakan pilihan key untuk susunan tersuai. Lihat kodnya.

words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words)  # ['fig', 'kiwi', 'apple', 'banana']

nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True))  # [5, 4, 3, 1, 1]
print(nums)  # unchanged: [3, 1, 4, 1, 5]

Mengubah Senarai Semasa Lelaran

Perangkap klasik: jangan sesekali menambah atau membuang item semasa menggelung melalui senarai — anda mungkin melangkau elemen atau menyebabkan program terhenti. Sebaliknya, bina senarai baharu menggunakan pemahaman senarai.

# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)  # skips 4!
print(nums)  # [1, 3, 5]... but 4 got skipped? Actually removes 2,4

# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums)  # [1, 3, 5]

Pembongkaran Tupel dalam Gelung

Pembongkaran tupel menjadikan gelung lebih kemas: enumerate memberikan (indeks, nilai) dan zip mengendalikan dua senarai secara bersama. Sintaks *rest mengumpulkan bahagian akhir ke dalam pemboleh ubahnya sendiri. Lihat kodnya.

nums = [10, 20, 30]
for i, v in enumerate(nums):
    print(i, v)
# 0 10 / 1 20 / 2 30

a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
    print(x, y)

first, *rest = [1, 2, 3, 4]
print(first, rest)  # 1 [2, 3, 4]

Semakan Pantas

Semakan pantas — tunjukkan perkara yang telah anda fahami tentang senarai, tupel dan penghirisan Python. Anda pasti boleh melakukannya. 💪

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Imbas kembali: senarai ialah tatasusunan dinamik dengan append O(1), penghirisan sentiasa mengembalikan salinan baharu, dan tupel tidak berubah serta boleh dicincang. Seterusnya: kamus dan set.

Percuma untuk bermula

Pelajari Persediaan Temu Duga Pengaturcaraan dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 90
Pelajaran: 360

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Senarai, Tuple dan Pemotongan” percuma?

Ya — teks penuh “Senarai, Tuple dan Pemotongan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Persediaan Temu Duga Pengaturcaraan, tingkat taraf kepada CoddyKit PRO. Kursus Persediaan Temu Duga Pengaturcaraan merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Senarai, Tuple dan Pemotongan”?

Kuasai operasi senarai Python, sintaks pemotongan dan ketidakbolehubahan tuple melalui contoh praktikal daripada cabaran pengekodan klasik. Anda berlatih Persediaan Temu Duga Pengaturcaraan menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Persediaan Temu Duga Pengaturcaraan?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Persediaan Temu Duga Pengaturcaraan di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Senarai, Tuple dan Pemotongan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Persediaan Temu Duga Pengaturcaraan ini?

Ya. Setiap pelajaran Persediaan Temu Duga Pengaturcaraan menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Persediaan Temu Duga Pengaturcaraan