Jangan takut dengan nama- daftar daftar. Itu tidak lain adalah daftar dengan daftar lain sebagai elemen. Dalam tutorial ini, kita akan belajar tentang berbagai cara untuk membuat daftar list dengan Python
Daftar Isi
- Apa itu daftar daftar?
- Menggunakan fungsi append[] untuk membuat daftar daftar dengan Python
- Buat daftar daftar menggunakan penginisialisasi daftar dengan Python
- Menggunakan pemahaman daftar untuk membuat daftar daftar
- Menggunakan for-loop untuk membuat daftar daftar dengan Python
- Menutup pikiran
Apa itu daftar daftar?
Dalam bahasa pemrograman apa pun, daftar digunakan untuk menyimpan lebih dari satu item dalam satu variabel. Dengan Python, kita dapat membuat daftar dengan mengapit semua elemen dengan tanda kurung siku [] dan setiap elemen dipisahkan dengan koma. Ini dapat digunakan untuk menyimpan integer, float, string, dan lainnya
Python menyediakan opsi untuk membuat daftar di dalam daftar. Sederhananya, itu adalah daftar bersarang tetapi dengan satu atau lebih daftar di dalamnya sebagai elemen
Berikut adalah contoh daftar daftar untuk memperjelas semuanya
[[a,b],[c,d],[e,f]]
Di sini, [a,b], [c,d], dan [e,f] adalah daftar terpisah yang diteruskan sebagai elemen untuk membuat daftar baru. Ini adalah daftar daftar
Sekarang kita akan membahas berbagai cara untuk membuat daftar list dengan Python
Menggunakan fungsi append[] untuk membuat daftar daftar dengan Python
Apa yang dilakukan fungsi append[] adalah menggabungkan semua daftar sebagai elemen ke dalam satu daftar. Itu menambahkan daftar di akhir daftarUntuk memiliki pemahaman lengkap tentang cara kerja fungsi ini, kami akan membuat dua daftar dan kemudian menggunakan fungsi append[] kami akan menggabungkannya menjadi satu daftar
Memasukkan
# Create 2 independent lists
list_1 = [a,b,c]
list_2 = [d,e,f]
# Create an empty list
list = []
# Create List of lists
list.append[list_1]
list.append[list_2]
print [list]
_Keluaran
[[a,b,c],[d,e,f]]
Buat daftar daftar menggunakan penginisialisasi daftar dengan Python
Menggunakan penginisialisasi daftar, kami memperlakukan daftar sebagai elemen. Kami membuat daftar daftar dengan meneruskan daftar sebagai elemen. Ini adalah cara termudah untuk membuat daftar daftar
Memasukkan
# Create 2 independent lists
list_1 = [a,b,c]
list_2 = [d,e,f]
# Create List of lists
list = [list1, list2]
# Display result
print[list]
Keluaran
[[a,b,c],[d,e,f]]
Menggunakan pemahaman daftar untuk membuat daftar daftar dengan Python
Pemahaman daftar adalah metode yang agak rumit namun singkat untuk membuat daftar daftar dengan Python
Memasukkan
list_1 = [a,b,c]
list = [l1 for i in range[3]]
print[list]
Keluaran
[[a,b,c],[a,b,c],[a,b,c]]
_Menggunakan for-loop untuk membuat daftar daftar dengan Python
Anda juga dapat menggunakan for-loop untuk membuat daftar daftar. Berikut ini cuplikan kode untuk pemahaman yang lebih baik
Memasukkan
list = []
# Create List of list
for i in range[2]:
list.append[[]]
for j in range[3]:
list[i].append[j]
print[lst]
Keluaran
[[a,b,c],[a,b,c]]
_Menutup pikiran
Daftar daftar adalah daftar di mana setiap elemen adalah daftar dengan sendirinya. Daftar adalah salah satu dari 4 tipe data bawaan di Python. Seseorang dapat mempelajari lebih lanjut tentang tipe data Python lainnya di sini
Daftar adalah kumpulan nilai yang dipesan. Ini dapat berisi berbagai jenis nilai. Daftar adalah wadah yang bisa berubah. Ini berarti bahwa kita dapat menambah nilai, menghapus nilai, atau mengubah nilai yang sudah ada
Daftar Python mewakili konsep matematika dari urutan yang terbatas. Nilai daftar disebut item atau elemen daftar. Daftar dapat berisi nilai yang sama beberapa kali. Setiap kejadian dianggap sebagai item yang berbeda
Daftar sederhana Python
Daftar elemen dapat diakses oleh indeks mereka. Elemen pertama memiliki indeks 0, yang terakhir memiliki indeks -1
#!/usr/bin/python # simple.py nums = [1, 2, 3, 4, 5] print[nums[0]] print[nums[-1]] print[nums]_
Ini adalah daftar sederhana yang memiliki lima elemen. Daftar ini dibatasi oleh tanda kurung siku
nums = [1, 2, 3, 4, 5]51. Elemen daftar dipisahkan dengan karakter koma. Isi daftar dicetak ke konsol
nums = [1, 2, 3, 4, 5]
Sisi kanan tugas adalah daftar literal Python. Itu membuat daftar yang berisi lima elemen
$ ./simple.py 1 5 [1, 2, 3, 4, 5]
Daftar dapat berisi elemen dari berbagai tipe data
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]
Dalam contoh, kami membuat daftar objek. Ini berisi angka, nilai boolean, daftar lain, string, tupel, objek khusus, dan kamus
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]
Terkadang kita perlu menginisialisasi daftar terlebih dahulu untuk memiliki sejumlah elemen tertentu
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]
Dalam contoh ini kami menginisialisasi dua daftar menggunakan pemahaman daftar dan operator *
n1 = [0 for i in range[15]] n2 = [0] * 15
Kedua daftar ini diinisialisasi ke lima belas nol
n1[0:10] = [10] * 10
Sepuluh nilai pertama diganti dengan 10-an
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]
Fungsi daftar python
Fungsi
nums = [1, 2, 3, 4, 5]_52 membuat daftar dari objek iterable. Iterable dapat berupa urutan, wadah yang mendukung iterasi, atau objek iterator. Jika tidak ada parameter yang ditentukan, daftar kosong baru akan dibuat
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]
Dalam contoh, kami membuat daftar kosong, daftar dari tuple, string, dan daftar lainnya
nums = [1, 2, 3, 4, 5]_0
Ini adalah dua cara untuk membuat daftar kosong
nums = [1, 2, 3, 4, 5]_1
Garis mencetak
nums = [1, 2, 3, 4, 5]_53. Ini menegaskan bahwa
nums = [1, 2, 3, 4, 5]_54 dan
nums = [1, 2, 3, 4, 5]55 adalah sama
nums = [1, 2, 3, 4, 5]_2
Kami membuat daftar dari tuple Python
nums = [1, 2, 3, 4, 5]_3
Baris ini menghasilkan daftar dari string
nums = [1, 2, 3, 4, 5]_4
Terakhir, kami membuat salinan daftar string
nums = [1, 2, 3, 4, 5]_5
Kode berikut menunjukkan beberapa operasi daftar dasar
nums = [1, 2, 3, 4, 5]_6
Kami mendefinisikan dua daftar bilangan bulat. Kami menggunakan beberapa operator pada daftar ini
nums = [1, 2, 3, 4, 5]_7
Isi daftar dibandingkan dengan operator
nums = [1, 2, 3, 4, 5]56. Garis mencetak
nums = [1, 2, 3, 4, 5]_57 karena elemennya berbeda
nums = [1, 2, 3, 4, 5]_8
Daftar
nums = [1, 2, 3, 4, 5]_58 dan
nums = [1, 2, 3, 4, 5]59 ditambahkan untuk membentuk daftar baru. Daftar baru memiliki semua elemen dari kedua daftar
nums = [1, 2, 3, 4, 5]_9
Kami menggunakan operator perkalian pada daftar. Itu mengulangi elemen n kali;
$ ./simple.py 1 5 [1, 2, 3, 4, 5]0
Kami menggunakan operator
nums = [1, 2, 3, 4, 5]_60 untuk mengetahui apakah nilainya ada dalam daftar. Ini mengembalikan boolean
nums = [1, 2, 3, 4, 5]_53 atau
nums = [1, 2, 3, 4, 5]57
$ ./simple.py 1 5 [1, 2, 3, 4, 5]1
Fungsi urutan python
Fungsi urutan dapat digunakan pada semua jenis urutan, termasuk daftar
$ ./simple.py 1 5 [1, 2, 3, 4, 5]2
Dalam contoh di atas, kita memiliki empat fungsi.
nums = [1, 2, 3, 4, 5]_63,
nums = [1, 2, 3, 4, 5]64,
nums = [1, 2, 3, 4, 5]65, dan
nums = [1, 2, 3, 4, 5]66
$ ./simple.py 1 5 [1, 2, 3, 4, 5]3
Fungsi
nums = [1, 2, 3, 4, 5]_63 mengembalikan ukuran daftar. Jumlah elemen daftar
$ ./simple.py 1 5 [1, 2, 3, 4, 5]4
Fungsi
nums = [1, 2, 3, 4, 5]_64 dan
nums = [1, 2, 3, 4, 5]65 mengembalikan maksimum dan minimum daftar
$ ./simple.py 1 5 [1, 2, 3, 4, 5]5
Fungsi
nums = [1, 2, 3, 4, 5]_66 menghitung jumlah angka dari daftar
nums = [1, 2, 3, 4, 5]71
$ ./simple.py 1 5 [1, 2, 3, 4, 5]6
Bagian ini akan menunjukkan bagaimana elemen ditambahkan ke daftar Python
$ ./simple.py 1 5 [1, 2, 3, 4, 5]7
Kami memiliki tiga metode untuk menambahkan elemen baru ke daftar.
nums = [1, 2, 3, 4, 5]_72,
nums = [1, 2, 3, 4, 5]73, dan
nums = [1, 2, 3, 4, 5]74
$ ./simple.py 1 5 [1, 2, 3, 4, 5]8
Daftar kosong dibuat
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_9
Metode
nums = [1, 2, 3, 4, 5]_72 menambahkan item di akhir daftar;
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]0
Metode
nums = [1, 2, 3, 4, 5]_73 menempatkan elemen pada posisi tertentu yang ditunjukkan oleh nomor indeks. Senar
nums = [1, 2, 3, 4, 5]_77 dimasukkan di posisi pertama, senar
nums = [1, 2, 3, 4, 5]78 di posisi ketiga. Perhatikan bahwa nomor indeks daftar dimulai dari nol
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]1
Metode
nums = [1, 2, 3, 4, 5]_74 menambahkan urutan nilai ke akhir daftar. Dalam kasus kami, dua string tuple Python ditambahkan di akhir daftar kami
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]2
Daftar Python IndexError
nums = [1, 2, 3, 4, 5]_80 dimunculkan saat subskrip daftar berada di luar jangkauan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]3
Dalam skrip kami telah menetapkan daftar lima bilangan bulat. Elemen-elemen ini memiliki indeks 0, 1, 2, 3, dan 4. Menggunakan indeks yang lebih besar menyebabkan kesalahan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]4
Indeks 6 berada di luar jangkauan daftar kami. Sebuah
nums = [1, 2, 3, 4, 5]_80 dilemparkan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]5
Kami menangkap kesalahan menggunakan klausa ________10______82. Di badan klausa, kami mencetak pesan kesalahan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]6
Jika indeks tuple bukan bilangan bulat biasa,
nums = [1, 2, 3, 4, 5]83 dilemparkan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]7
Contoh ini melempar
nums = [1, 2, 3, 4, 5]_83
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]8
Indeks daftar harus bilangan bulat. Jenis lain berakhir dengan kesalahan
#!/usr/bin/python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", [2, 3], Being[], {}] print[objects]_9
Di blok kecuali, kami mencetak nama file, di mana pengecualian telah terjadi dan string pesan
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_0
Sebelumnya kami telah menambahkan item ke daftar. Sekarang kami menghapusnya dari daftar
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_1
Metode
nums = [1, 2, 3, 4, 5]_85 menghapus dan mengembalikan elemen dengan indeks tertentu atau elemen terakhir jika nomor indeks tidak diberikan. Metode
nums = [1, 2, 3, 4, 5]_86 menghapus item tertentu dari daftar
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_2
Kami mengambil elemen yang memiliki indeks 3. Metode
nums = [1, 2, 3, 4, 5]_85 mengembalikan nama elemen yang dihapus;
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_3
Elemen terakhir dari daftar, yaitu string ________10______88, dihapus dari daftar
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_4
Baris ini menghapus string
nums = [1, 2, 3, 4, 5]_89 dari daftar
nums = [1, 2, 3, 4, 5]90
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_5
Dari output skrip kita dapat melihat efek dari metode yang dijelaskan
Kata kunci
nums = [1, 2, 3, 4, 5]_91 juga dapat digunakan untuk menghapus elemen daftar
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_6
Kami memiliki daftar string. Kami menggunakan kata kunci
nums = [1, 2, 3, 4, 5]_91 untuk menghapus elemen daftar
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_7
Kami menghapus string kedua dari daftar. Ini adalah string
nums = [1, 2, 3, 4, 5]_89
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_8
Kami hanya dapat menghapus elemen yang ada. Jika kami membatalkan komentar pada baris kode, kami menerima pesan
nums = [1, 2, 3, 4, 5]80
$ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', [2, 3], , {}]_9
Di sini kami menghapus semua elemen yang tersisa dari daftar.
nums = [1, 2, 3, 4, 5]_95 karakter mengacu pada semua item dari daftar
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]0
Dalam contoh berikutnya kita akan memodifikasi elemen daftar
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]1
Dalam contoh kami memodifikasi elemen ketiga dari daftar langs dua kali
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]2
Salah satu cara untuk memodifikasi elemen adalah menghapusnya dan menempatkan elemen berbeda pada posisi yang sama
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]_3
Metode lainnya lebih mudah. Kami menetapkan elemen baru pada posisi tertentu. Sekarang ada
nums = [1, 2, 3, 4, 5]_96 string di posisi ketiga lagi
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]4
Ada beberapa cara bagaimana kita bisa menyalin daftar dengan Python. Kami akan menyebutkan beberapa di antaranya
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]5
Kami memiliki daftar tiga string. Kami membuat salinan daftar itu tujuh kali
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]6
Kami mengimpor modul
nums = [1, 2, 3, 4, 5]_97 yang memiliki dua metode untuk menyalin
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]7
Daftar disalin menggunakan sintaks irisan
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]8
Fungsi
nums = [1, 2, 3, 4, 5]_52 membuat salinan daftar saat menggunakan daftar sebagai parameter
#!/usr/bin/python n1 = [0 for i in range[15]] n2 = [0] * 15 print[n1] print[n2] n1[0:10] = [10] * 10 print[n1]_9
Metode
nums = [1, 2, 3, 4, 5]_97 menghasilkan salinan daftar yang dangkal.
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_00 menghasilkan salinan daftar yang dalam
n1 = [0 for i in range[15]] n2 = [0] * 15_0
Salinan string dibuat menggunakan pemahaman daftar
n1 = [0 for i in range[15]] n2 = [0] * 15_1
Salinan yang dibuat oleh
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_01 loop
n1 = [0 for i in range[15]] n2 = [0] * 15_2
Metode
nums = [1, 2, 3, 4, 5]_74 juga dapat digunakan untuk membuat salinan
n1 = [0 for i in range[15]] n2 = [0] * 15_3
Tujuh salinan daftar string dibuat menggunakan teknik yang berbeda
Elemen daftar pengindeksan Python
Elemen dalam daftar Python dapat diakses oleh indeksnya. Nomor indeks adalah bilangan bulat; . Indeks bisa negatif; . Item pertama dalam daftar memiliki indeks 0, item terakhir memiliki -1
n1 = [0 for i in range[15]] n2 = [0] * 15_4
Kami dapat mengakses elemen daftar dengan indeksnya. Indeks ditempatkan di antara tanda kurung siku
nums = [1, 2, 3, 4, 5]51 setelah nama daftar
n1 = [0 for i in range[15]] n2 = [0] * 15_5
Tiga baris ini mencetak item pertama, terakhir, dan terakhir tetapi satu item dari daftar
n1 = [0 for i in range[15]] n2 = [0] * 15_6
Dua baris mencetak elemen keempat dan keenam dari daftar
n1 = [0 for i in range[15]] n2 = [0] * 15_7
Metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_04 mencari elemen tertentu dan mengembalikan indeks terendahnya. Awal dan akhir adalah parameter opsional yang membatasi pencarian ke batas yang diberikan
n1 = [0 for i in range[15]] n2 = [0] * 15_8
Contoh kode dengan metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_05
n1 = [0 for i in range[15]] n2 = [0] * 15_9
Kedua baris ini mencetak indeks nilai 1, 2 paling kiri dari daftar n
n1[0:10] = [10] * 100
Di sini kami mencari nilai 1 dan 2 setelah indeks tertentu
n1[0:10] = [10] * 101
Di sini kita mencari nilai 1 antara nilai dengan indeks 2 dan 5
n1[0:10] = [10] * 102
Pemotongan daftar adalah operasi yang mengekstrak elemen tertentu dari daftar dan membentuknya menjadi daftar lain. Mungkin dengan jumlah indeks yang berbeda dan rentang indeks yang berbeda
Sintaks untuk mengiris daftar adalah sebagai berikut
n1[0:10] = [10] * 103
Bagian awal, akhir, langkah dari sintaks adalah bilangan bulat. Masing-masing adalah opsional. Mereka bisa positif dan negatif. Nilai yang memiliki indeks akhir tidak termasuk dalam irisan
n1[0:10] = [10] * 10_4
Kami membuat empat irisan dari daftar delapan bilangan bulat
n1[0:10] = [10] * 105
Irisan pertama memiliki nilai dengan indeks 1, 2, 3, dan 4. Daftar yang baru dibentuk adalah [2, 3, 4, 5]
n1[0:10] = [10] * 106
Jika indeks awal dihilangkan maka nilai default diasumsikan, yaitu 0. Irisannya adalah [1, 2, 3, 4, 5]
n1[0:10] = [10] * 107
Jika indeks akhir dihilangkan, nilai default -1 diambil. Dalam kasus seperti itu, sebuah slice membawa semua nilai ke akhir daftar
n1[0:10] = [10] * 108
Bahkan kedua indeks bisa ditinggalkan. Sintaks ini membuat salinan daftar
n1[0:10] = [10] * 10_9
Indeks ketiga dalam sintaks slice adalah langkahnya. Ini memungkinkan kita untuk mengambil setiap nilai ke-n dari daftar
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_0
Kami membentuk empat daftar baru menggunakan nilai langkah
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_1
Di sini kita membuat irisan yang memiliki setiap elemen kedua dari daftar n, mulai dari elemen kedua, diakhiri dengan elemen kedelapan. Daftar baru memiliki elemen berikut. [2, 4, 6, 8]
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_2
Di sini kita membangun sebuah irisan dengan mengambil setiap nilai detik dari awal hingga akhir daftar
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_3
Ini membuat salinan daftar
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_4
Irisan memiliki setiap elemen ketiga, mulai dari elemen kedua hingga akhir daftar
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_5
Indeks dapat berupa angka negatif. Indeks negatif mengacu pada nilai dari akhir daftar. Elemen terakhir memiliki indeks -1, yang terakhir memiliki indeks -2 dll. Indeks dengan angka negatif yang lebih rendah harus didahulukan dalam sintaks. Artinya kita menulis [-6, -2] bukan [-2, -6]. Yang terakhir mengembalikan daftar kosong
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_6
Dalam skrip ini, kami membentuk lima daftar. Kami juga menggunakan angka indeks negatif
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_7
Baris pertama mengembalikan [5, 6, 7], baris kedua mengembalikan daftar kosong. Indeks yang lebih rendah harus datang sebelum indeks yang lebih tinggi
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_8
Ini membuat daftar terbalik
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]_9
Sintaks yang disebutkan di atas dapat digunakan dalam penugasan. Harus ada iterable di sisi kanan tugas
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]0
Kami memiliki daftar delapan bilangan bulat. Kami menggunakan sintaks slice untuk mengganti elemen dengan nilai baru
Daftar loop python
Bagian ini akan menunjukkan tiga cara dasar untuk menelusuri daftar dengan Python
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]1
Yang pertama adalah cara paling mudah untuk melintasi daftar
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]2
Kami memiliki daftar numerik. Ada lima bilangan bulat dalam daftar
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]3
Menggunakan loop
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_01, kita menelusuri daftar satu per satu dan mencetak elemen saat ini ke konsol
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]4
Ini adalah output dari skrip. Bilangan bulat dicetak ke terminal
Contoh kedua sedikit lebih bertele-tele
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]5
Kami melintasi daftar menggunakan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]07 loop
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]6
Pertama, kita perlu menentukan penghitung dan mengetahui ukuran daftar
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]7
Dengan bantuan dua angka ini, kami menelusuri daftar dan mencetak setiap elemen ke terminal
Fungsi bawaan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_08 memberi kita indeks dan nilai daftar dalam satu lingkaran
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]8
Dalam contoh, kami mencetak nilai dan indeks nilai
#!/usr/bin/python # list_fun.py a = [] b = list[] print[a == b] print[list[[1, 2, 3]]] print[list["ZetCode"]] print[list[['Ruby', 'Python', 'Perl']]]_9
Terkadang penting untuk menghitung elemen daftar. Untuk ini, Python memiliki metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_09
nums = [1, 2, 3, 4, 5]_00
Dalam contoh ini, kami menghitung jumlah kemunculan beberapa angka dalam daftar
nums = [1, 2, 3, 4, 5]71
nums = [1, 2, 3, 4, 5]_01
Kami memiliki daftar bilangan bulat. Bilangan bulat 1 dan 4 muncul berkali-kali
nums = [1, 2, 3, 4, 5]_02
Dengan menggunakan metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_09, kita mengetahui kemunculan bilangan 4, 1, 2, dan 6
nums = [1, 2, 3, 4, 5]_03
Angka 4 muncul 3 kali, 1 dua kali, 2 satu kali, dan 6 tidak ada dalam daftar
Dimungkinkan untuk menyarangkan daftar ke dalam daftar lain. Dengan daftar bersarang, dimensi baru dibuat. Untuk mengakses daftar bersarang, seseorang memerlukan tanda kurung siku tambahan
nums = [1, 2, 3, 4, 5]51
nums = [1, 2, 3, 4, 5]_04
Dalam contoh, kami memiliki tiga daftar bersarang yang masing-masing memiliki dua elemen
nums = [1, 2, 3, 4, 5]_05
Tiga daftar bersarang dari daftar angka dicetak ke konsol
nums = [1, 2, 3, 4, 5]_06
Di sini kami mencetak dua elemen dari daftar bersarang pertama.
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_13 mengacu pada daftar bersarang pertama;
nums = [1, 2, 3, 4, 5]_07
Garis mencetak 3. Setiap daftar bersarang dihitung sebagai satu elemen. Elemen dalamnya tidak diperhitungkan
nums = [1, 2, 3, 4, 5]_08
Contoh kedua memiliki dimensi tambahan
nums = [1, 2, 3, 4, 5]_09
Dalam contoh, daftar [5, 6] disarangkan ke [3, 4,. ], [3, 4, [4, 6]] disarangkan ke dalam daftar [1, 2,. ] daftar yang akhirnya merupakan elemen dari daftar ________12______15
nums = [1, 2, 3, 4, 5]_10
Tiga baris ini mencetak daftar bersarang ke konsol
nums = [1, 2, 3, 4, 5]_11
Di sini tiga elemen diakses. Tanda kurung siku tambahan
nums = [1, 2, 3, 4, 5]_51 diperlukan saat merujuk ke daftar dalam
nums = [1, 2, 3, 4, 5]_12
Di bagian ini kami mengurutkan elemen daftar. Python memiliki metode daftar bawaan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_17 dan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]18 fungsi untuk melakukan penyortiran
nums = [1, 2, 3, 4, 5]_13
Dalam contoh kode, kami memiliki daftar bilangan bulat yang tidak disortir. Kami mengurutkan elemen menggunakan metode ________12______17. Metode mengurutkan elemen di tempat;
nums = [1, 2, 3, 4, 5]_14
Metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_17 mengurutkan elemen dalam urutan menaik
nums = [1, 2, 3, 4, 5]_15
Dengan parameter terbalik disetel ke
nums = [1, 2, 3, 4, 5]_53, daftar diurutkan dalam urutan menurun
nums = [1, 2, 3, 4, 5]_16
Dalam output kita dapat melihat daftar asli, daftar yang diurutkan dalam urutan menaik dan menurun
Jika kami tidak ingin mengubah daftar asli, kami dapat menggunakan fungsi ________12______18. Fungsi ini membuat daftar terurut baru
nums = [1, 2, 3, 4, 5]_17
Dalam contoh, kami menggunakan fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_18 untuk mengurutkan elemen daftar
nums = [1, 2, 3, 4, 5]_18
Dari output skrip kita dapat melihat bahwa daftar asli tidak diubah
Metode
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_17 memiliki parameter
$ ./simple.py 1 5 [1, 2, 3, 4, 5]25 opsional. Parameter menentukan fungsi yang akan dipanggil pada setiap elemen daftar sebelum membuat perbandingan
nums = [1, 2, 3, 4, 5]_19
Contoh menghasilkan perbandingan string case-sensitive dan case-insensitive
nums = [1, 2, 3, 4, 5]_20
Untuk membuat perbandingan yang tidak peka huruf besar/kecil, kami menambahkan fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]26 ke parameter
$ ./simple.py 1 5 [1, 2, 3, 4, 5]25
nums = [1, 2, 3, 4, 5]_21
Kita perlu melakukan pekerjaan tambahan jika ingin mengurutkan string Unicode
nums = [1, 2, 3, 4, 5]_22
Kami memiliki daftar enam string unicode. Kami mengubah pengaturan lokal untuk mengurutkan string sesuai dengan opsi bahasa saat ini
nums = [1, 2, 3, 4, 5]_23
Kami mengimpor modul
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_28 dan fungsi konversi ________12______29
nums = [1, 2, 3, 4, 5]_24
Ini adalah daftar enam string. Senar dalam bahasa Slovakia dan memiliki beberapa tanda diakritik. Mereka berperan dalam memilah karakter dengan benar
nums = [1, 2, 3, 4, 5]_25
Kami mengatur pengaturan lokal untuk bahasa Slovakia
nums = [1, 2, 3, 4, 5]_26
Kami mengurutkan daftar.
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_30 membandingkan dua string sesuai dengan pengaturan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]31 saat ini. Fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_29 mengubah fungsi perbandingan ________12______33 menjadi fungsi kunci
nums = [1, 2, 3, 4, 5]_27
Kami mencetak kata-kata yang diurutkan ke konsol
nums = [1, 2, 3, 4, 5]_28
Elemen-elemen diurutkan dengan benar. Kekhususan alfabet Slovakia diperhitungkan
Kita dapat membalikkan elemen dalam daftar dengan beberapa cara di Python. Membalikkan elemen tidak boleh disamakan dengan menyortir secara terbalik
nums = [1, 2, 3, 4, 5]_29
Dalam contoh, kami memiliki tiga daftar string yang identik. Kami membalikkan elemen dalam tiga cara berbeda
nums = [1, 2, 3, 4, 5]_30
Cara pertama adalah dengan menggunakan metode ________12______34
nums = [1, 2, 3, 4, 5]_31
Fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_35 mengembalikan iterator terbalik. Kami menggunakan iterator dalam for loop dan membuat daftar terbalik baru
nums = [1, 2, 3, 4, 5]_32
Cara ketiga adalah membalikkan daftar menggunakan sintaks slice, di mana parameter step diatur ke -1
nums = [1, 2, 3, 4, 5]_33
Ketiga daftar itu dibalik OK
Pemahaman daftar python
Pemahaman daftar adalah konstruksi sintaksis yang membuat daftar berdasarkan daftar yang ada. Sintaksnya dipengaruhi oleh notasi matematis himpunan. Sintaks Python terinspirasi oleh bahasa pemrograman Haskell
nums = [1, 2, 3, 4, 5]_34
Kode semu di atas menunjukkan sintaks pemahaman daftar. Pemahaman daftar membuat daftar baru. Itu berdasarkan daftar yang ada. A for loop melewati urutan. Untuk setiap loop, ekspresi dievaluasi jika kondisi terpenuhi. Jika nilainya dihitung, itu ditambahkan ke daftar baru. Kondisinya opsional
Pemahaman daftar memberikan cara yang lebih ringkas untuk membuat daftar dalam situasi di mana
$ ./simple.py 1 5 [1, 2, 3, 4, 5]36 dan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]37 dan/atau loop bersarang dapat digunakan
nums = [1, 2, 3, 4, 5]_35
Dalam contoh kami telah mendefinisikan daftar angka. Dengan bantuan pemahaman daftar, kami membuat daftar angka baru yang tidak dapat dibagi 2 tanpa sisa
nums = [1, 2, 3, 4, 5]_36
nums = [1, 2, 3, 4, 5]37
Di sini kita memiliki pemahaman daftar. Dalam
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_38 loop setiap elemen dari daftar diambil. Kemudian kondisi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_39 diuji. Jika kondisi terpenuhi, ekspresi akan dievaluasi. Dalam kasus kami ekspresinya adalah
$ ./simple.py 1 5 [1, 2, 3, 4, 5]40 murni yang mengambil elemen apa adanya. Terakhir, elemen ditambahkan ke daftar
nums = [1, 2, 3, 4, 5]_38
Angka dalam daftar tidak dapat dibagi dengan 2, tanpa sisa
Dalam contoh kedua, kami membandingkan pemahaman daftar dengan perulangan for tradisional
nums = [1, 2, 3, 4, 5]_39
Dalam contoh kita memiliki string. Kami ingin membuat daftar kode integer ASCII dari huruf string
nums = [1, 2, 3, 4, 5]_40
Kami membuat daftar seperti itu dengan loop for
nums = [1, 2, 3, 4, 5]_41
Di sini hal yang sama diproduksi menggunakan pemahaman daftar. Perhatikan bahwa kondisi if dihilangkan. Itu opsional
nums = [1, 2, 3, 4, 5]_42
Periksa pemahaman daftar Python untuk detail lebih lanjut
Fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_36 dan
$ ./simple.py 1 5 [1, 2, 3, 4, 5]37 adalah fungsi massal yang bekerja pada semua item daftar. Mereka adalah bagian dari pemrograman fungsional yang dibangun ke dalam bahasa Python
Saat ini, disarankan untuk menggunakan pemahaman daftar alih-alih fungsi ini jika memungkinkan
nums = [1, 2, 3, 4, 5]_43
Fungsi
$ ./simple.py 1 5 [1, 2, 3, 4, 5]_36 menerapkan fungsi tertentu ke setiap elemen daftar
nums = [1, 2, 3, 4, 5]_44
Ini adalah definisi fungsi yang digunakan oleh fungsi ________12______37. Ia mengembalikan
nums = [1, 2, 3, 4, 5]_53 atau
nums = [1, 2, 3, 4, 5]57. Fungsi yang mengembalikan nilai boolean disebut predikat