Bagaimana cara menghapus nol dari daftar bersarang di python?

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]

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),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

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]

#!/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]

Ini adalah dua cara untuk membuat daftar kosong

nums = [1, 2, 3, 4, 5]

Garis mencetak

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Kami membuat daftar dari tuple Python

nums = [1, 2, 3, 4, 5]

Baris ini menghasilkan daftar dari string

nums = [1, 2, 3, 4, 5]

Terakhir, kami membuat salinan daftar string

nums = [1, 2, 3, 4, 5]

Kode berikut menunjukkan beberapa operasi daftar dasar

nums = [1, 2, 3, 4, 5]

Kami mendefinisikan dua daftar bilangan bulat. Kami menggunakan beberapa operator pada daftar ini

nums = [1, 2, 3, 4, 5]

Isi daftar dibandingkan dengan operator

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Daftar

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Kami menggunakan operator perkalian pada daftar. Itu mengulangi elemen n kali;

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Kami menggunakan operator

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Fungsi urutan python

Fungsi urutan dapat digunakan pada semua jenis urutan, termasuk daftar

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Dalam contoh di atas, kita memiliki empat fungsi.

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Fungsi

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Fungsi

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Fungsi

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Bagian ini akan menunjukkan bagaimana elemen ditambahkan ke daftar Python

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Kami memiliki tiga metode untuk menambahkan elemen baru ke daftar.

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Daftar kosong dibuat

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Metode

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Metode

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Metode

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Daftar Python IndexError

nums = [1, 2, 3, 4, 5]

#!/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 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)

Indeks 6 berada di luar jangkauan daftar kami. Sebuah

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Kami menangkap kesalahan menggunakan klausa

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Jika indeks tuple bukan bilangan bulat biasa,

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Contoh ini melempar

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

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)

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),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

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),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Metode

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Kami mengambil elemen yang memiliki indeks 3. Metode

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Elemen terakhir dari daftar, yaitu

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Baris ini menghapus string

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Dari output skrip kita dapat melihat efek dari metode yang dijelaskan

Kata kunci

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Kami memiliki daftar string. Kami menggunakan kata kunci

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Kami menghapus string kedua dari daftar. Ini adalah string

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Kami hanya dapat menghapus elemen yang ada. Jika kami membatalkan komentar pada baris kode, kami menerima pesan

nums = [1, 2, 3, 4, 5]

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Di sini kami menghapus semua elemen yang tersisa dari daftar.

nums = [1, 2, 3, 4, 5]

#!/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 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)

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)

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)

Metode lainnya lebih mudah. Kami menetapkan elemen baru pada posisi tertentu. Sekarang ada

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

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)

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)

Kami mengimpor modul

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

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)

Fungsi

nums = [1, 2, 3, 4, 5]

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

Metode

nums = [1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

Salinan string dibuat menggunakan pemahaman daftar

n1 = [0 for i in range(15)]
n2 = [0] * 15

Salinan yang dibuat oleh

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

Metode

nums = [1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

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

Kami dapat mengakses elemen daftar dengan indeksnya. Indeks ditempatkan di antara tanda kurung siku

nums = [1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

Tiga baris ini mencetak item pertama, terakhir, dan terakhir tetapi satu item dari daftar

n1 = [0 for i in range(15)]
n2 = [0] * 15

Dua baris mencetak elemen keempat dan keenam dari daftar

n1 = [0 for i in range(15)]
n2 = [0] * 15

Metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

Contoh kode dengan metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

n1 = [0 for i in range(15)]
n2 = [0] * 15

Kedua baris ini mencetak indeks nilai 1, 2 paling kiri dari daftar n

n1[0:10] = [10] * 10

Di sini kami mencari nilai 1 dan 2 setelah indeks tertentu

n1[0:10] = [10] * 10

Di sini kita mencari nilai 1 antara nilai dengan indeks 2 dan 5

n1[0:10] = [10] * 10

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] * 10

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

Kami membuat empat irisan dari daftar delapan bilangan bulat

n1[0:10] = [10] * 10

Irisan pertama memiliki nilai dengan indeks 1, 2, 3, dan 4. Daftar yang baru dibentuk adalah [2, 3, 4, 5]

n1[0:10] = [10] * 10

Jika indeks awal dihilangkan maka nilai default diasumsikan, yaitu 0. Irisannya adalah [1, 2, 3, 4, 5]

n1[0:10] = [10] * 10

Jika indeks akhir dihilangkan, nilai default -1 diambil. Dalam kasus seperti itu, sebuah slice membawa semua nilai ke akhir daftar

n1[0:10] = [10] * 10

Bahkan kedua indeks bisa ditinggalkan. Sintaks ini membuat salinan daftar

n1[0:10] = [10] * 10

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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']))

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']))

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']))

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']))

Menggunakan loop

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

#!/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']))

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']))

Kami melintasi daftar menggunakan

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

#!/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']))

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']))

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]

#!/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 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']))

Terkadang penting untuk menghitung elemen daftar. Untuk ini, Python memiliki metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Dalam contoh ini, kami menghitung jumlah kemunculan beberapa angka dalam daftar

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Kami memiliki daftar bilangan bulat. Bilangan bulat 1 dan 4 muncul berkali-kali

nums = [1, 2, 3, 4, 5]

Dengan menggunakan metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

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]

nums = [1, 2, 3, 4, 5]

Dalam contoh, kami memiliki tiga daftar bersarang yang masing-masing memiliki dua elemen

nums = [1, 2, 3, 4, 5]

Tiga daftar bersarang dari daftar angka dicetak ke konsol

nums = [1, 2, 3, 4, 5]

Di sini kami mencetak dua elemen dari daftar bersarang pertama.

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Garis mencetak 3. Setiap daftar bersarang dihitung sebagai satu elemen. Elemen dalamnya tidak diperhitungkan

nums = [1, 2, 3, 4, 5]

Contoh kedua memiliki dimensi tambahan

nums = [1, 2, 3, 4, 5]

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

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Tiga baris ini mencetak daftar bersarang ke konsol

nums = [1, 2, 3, 4, 5]

Di sini tiga elemen diakses. Tanda kurung siku tambahan

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Di bagian ini kami mengurutkan elemen daftar. Python memiliki metode daftar bawaan

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Dalam contoh kode, kami memiliki daftar bilangan bulat yang tidak disortir. Kami mengurutkan elemen menggunakan metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Dengan parameter terbalik disetel ke

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

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

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Dalam contoh, kami menggunakan fungsi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Dari output skrip kita dapat melihat bahwa daftar asli tidak diubah

Metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Contoh menghasilkan perbandingan string case-sensitive dan case-insensitive

nums = [1, 2, 3, 4, 5]

Untuk membuat perbandingan yang tidak peka huruf besar kecil, kami menambahkan fungsi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Kita perlu melakukan pekerjaan tambahan jika ingin mengurutkan string Unicode

nums = [1, 2, 3, 4, 5]

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]

Kami mengimpor modul

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

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]

Kami mengatur pengaturan lokal untuk bahasa Slovakia

nums = [1, 2, 3, 4, 5]

Kami mengurutkan daftar.

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Kami mencetak kata-kata yang diurutkan ke konsol

nums = [1, 2, 3, 4, 5]

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]

Dalam contoh, kami memiliki tiga daftar string yang identik. Kami membalikkan elemen dalam tiga cara berbeda

nums = [1, 2, 3, 4, 5]

Cara pertama adalah dengan menggunakan metode

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Fungsi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Cara ketiga adalah membalikkan daftar menggunakan sintaks slice, di mana parameter step diatur ke -1

nums = [1, 2, 3, 4, 5]

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]

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]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

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]

nums = [1, 2, 3, 4, 5]

Di sini kita memiliki pemahaman daftar. Dalam

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

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]

Dalam contoh kita memiliki string. Kami ingin membuat daftar kode integer ASCII dari huruf string

nums = [1, 2, 3, 4, 5]

Kami membuat daftar seperti itu dengan loop for

nums = [1, 2, 3, 4, 5]

Di sini hal yang sama diproduksi menggunakan pemahaman daftar. Perhatikan bahwa kondisi if dihilangkan. Itu opsional

nums = [1, 2, 3, 4, 5]

Periksa pemahaman daftar Python untuk detail lebih lanjut

Fungsi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Saat ini, disarankan untuk menggunakan pemahaman daftar alih-alih fungsi ini jika memungkinkan

nums = [1, 2, 3, 4, 5]

Fungsi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Ini adalah definisi fungsi yang digunakan oleh fungsi ________3______37. Ia mengembalikan

nums = [1, 2, 3, 4, 5]

nums = [1, 2, 3, 4, 5]

Bagaimana cara menghapus nilai dari daftar bersarang di Python?

Bagaimana Anda menghapus set bersarang di Python?

Bagaimana Anda menghapus elemen dari sublist dengan Python?