Untuk menjana senarai baharu daripada senarai (tatasusunan) yang elemennya adalah rentetan, dengan mengekstrak hanya elemen rentetan yang memenuhi syarat tertentu, atau dengan melakukan penggantian, penukaran, dsb., gunakan pemahaman senarai.
Selepas penerangan ringkas tentang pemahaman senarai, kandungan berikut diterangkan dengan kod sampel.
- Pengekstrakan berdasarkan sama ada rentetan tertentu disertakan atau tidak (separa padanan)
- Gantikan rentetan tertentu
- Ekstrak dengan memulakan atau tidak bermula dengan rentetan tertentu
- Ekstrak dengan menamatkan atau tidak berakhir dengan rentetan tertentu
- Diadili dan diekstrak mengikut kes
- Tukar huruf besar dan huruf kecil
- Tentukan sama ada aksara abjad atau angka digunakan dan mengekstraknya
- Pelbagai syarat
- (komputer) ungkapan biasa
Ambil perhatian bahawa senarai boleh menyimpan jenis data yang berbeza dan berbeza daripada tatasusunan. Jika anda ingin mengendalikan tatasusunan dalam proses yang memerlukan saiz memori dan alamat memori atau pemprosesan berangka data besar, gunakan tatasusunan (pustaka standard) atau NumPy.
- senarai notasi kemasukan
- Mengandungi rentetan tertentu (separa padanan) \ Tidak mengandungi:in
- Gantikan rentetan tertentu
- Bermula dengan rentetan tertentu \ tidak bermula:startswith()
- Berakhir dengan rentetan aksara tertentu \ tidak berakhir:endswith()
- Diadili dan diekstrak mengikut kes
- Tukar huruf besar dan huruf kecil
- Tentukan sama ada aksara abjad atau angka digunakan dan mengekstraknya
- Pelbagai syarat
- (komputer) ungkapan biasa
senarai notasi kemasukan
Apabila menjana senarai baharu daripada senarai, pemahaman senarai adalah lebih mudah untuk ditulis berbanding untuk gelung.
[expression for any variable name in iterable object if conditional expression]
Jika elemen hanya untuk dipilih dengan ungkapan bersyarat, ia tidak diproses oleh ungkapan, jadi ia mengambil bentuk berikut
[variable name for variable name in original list if conditional expression]
Jika ungkapan bersyarat jika dijadikan ungkapan jika tidak bersyarat, ia menjadi penafian dan unsur-unsur yang tidak memenuhi ungkapan bersyarat boleh diekstrak.
Mengandungi rentetan tertentu (separa padanan) \ Tidak mengandungi:in
Dalam “rentetan khusus dalam rentetan asal”, mengembalikan True jika rentetan asal mengandungi rentetan tertentu. Ini adalah ungkapan bersyarat.
Penafian dalam dilakukan dengan tidak masuk.
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']
l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']
Gantikan rentetan tertentu
Jika anda ingin menggantikan rentetan elemen senarai, gunakan kaedah rentetan replace() untuk setiap elemen dalam tatatanda pemahaman senarai.
Jika tiada rentetan untuk diganti, tidak perlu memilih elemen dalam ungkapan bersyarat if kerana ia tidak akan diubah dengan menggunakan replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Jika anda ingin menggantikan keseluruhan elemen yang mengandungi rentetan tertentu, ekstrak dengan masuk dan proseskannya dengan pengendali ternary. Operator ternary ditulis dalam bentuk berikut.True Value if Conditional Expression else False Value
Tidak mengapa jika bahagian ungkapan notasi pemahaman senarai ialah pengendali ternary.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Berikut ialah ringkasan keputusan, disertakan dalam kurungan. Jika anda tidak biasa menggunakan kurungan, mungkin lebih mudah untuk memahami dan mengelakkan kesilapan. Dari segi tatabahasa, tiada masalah walaupun anda menulis kurungan.
[('ZZZ' if ('XXX' in s) else s) for s in l]
Penggunaan dalam sebagai syarat mengelirukan dengan tatatanda pemahaman senarai dalam, tetapi tidak sukar jika anda mengetahui bentuk sintaksis tatatanda pemahaman senarai dan pengendali ternari.
Bermula dengan rentetan tertentu \ tidak bermula:startswith()
Kaedah rentetan bermula dengan() mengembalikan benar jika rentetan bermula dengan rentetan yang ditentukan dalam hujah.
l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']
l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']
Berakhir dengan rentetan aksara tertentu \ tidak berakhir:endswith()
Kaedah rentetan endswith() mengembalikan benar jika rentetan berakhir dengan rentetan yang ditentukan dalam hujah.
l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']
l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']
Diadili dan diekstrak mengikut kes
Kaedah rentetan isupper(),islower() boleh digunakan untuk menentukan sama ada rentetan adalah semua huruf besar atau semua huruf kecil.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Tukar huruf besar dan huruf kecil
Jika anda ingin menukar semua aksara kepada huruf besar atau kecil, gunakan kaedah rentetan upper() dan lower(). Kaedah lain termasuk capitalize(), yang menggunakan huruf besar hanya huruf pertama, dan swapcase(), yang menukar huruf besar dan kecil.
Seperti dalam contoh penggantian di atas, gunakan operator ternary jika anda ingin memproses hanya elemen yang memenuhi syarat.
l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']
l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']
Tentukan sama ada aksara abjad atau angka digunakan dan mengekstraknya
Kaedah rentetan isalpha() dan isnumeric() boleh digunakan untuk menentukan sama ada rentetan adalah semua abjad, angka, dsb.
l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']
l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']
Pelbagai syarat
Bahagian ungkapan bersyarat bagi pemahaman senarai boleh terdiri daripada berbilang syarat. Keadaan negatif “tidak” juga boleh digunakan.
Apabila menggunakan tiga atau lebih ungkapan bersyarat, adalah lebih selamat untuk melampirkan setiap kumpulan dalam kurungan () kerana hasilnya akan berbeza-beza bergantung pada susunan.
l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']
l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']
(komputer) ungkapan biasa
Ekspresi biasa membenarkan pemprosesan yang sangat fleksibel.
Objek padanan yang dikembalikan oleh re.match() apabila ia sepadan sentiasa ditentukan sebagai benar apabila dinilai dengan ungkapan bersyarat. Jika ia tidak sepadan, ia mengembalikan Tiada, yang palsu dalam ungkapan bersyarat. Jadi, jika anda ingin mengekstrak hanya elemen yang sepadan dengan ungkapan biasa, hanya gunakan re.match() pada bahagian ungkapan bersyarat bagi ungkapan pemahaman senarai seperti sebelum ini.
import re
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']
re.sub(), yang menggantikan bahagian yang dipadankan pada ungkapan biasa, juga berguna. Untuk mengekstrak dan menggantikan hanya elemen yang dipadankan, cuma tambah “jika ungkapan bersyarat”.
l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']
l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']
