Terkadang ekspresi reguler memberikan solusi tercepat bahkan dalam kasus di mana penerapannya sama sekali tidak jelas. Khususnya, metode Show # requires Python 2.1 or later from _ _future_ _ import nested_scopes import re # the simplest, lambda-based implementation def multiple_replace(adict, text): # Create a regular expression from all of the dictionary keys regex = re.compile("|".join(map(re.escape, adict.keys( )))) # For each match, look up the corresponding value in the dictionary return regex.sub(lambda match: adict[match.group(0)], text) Pendekatan yang lebih kuat dan fleksibel adalah membungkus kamus menjadi objek yang dapat dipanggil yang secara langsung mendukung ide pencarian dan penggantian, yang dapat Anda gunakan secara langsung sebagai panggilan balik dalam metode try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)0 memungkinkan kita dengan mudah menulis kode yang bekerja secara optimal pada versi Python lama dan baru try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)_ Resep ini menunjukkan cara menggunakan modul try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)_2 untuk setiap pasangan kunci/nilai dalam kamus, sehingga memproses dan membuat salinan baru dari keseluruhan teks beberapa kali, tetapi jelas lebih baik melakukan semua perubahan dalam sekali jalan, memproses dan membuat . Untungnya, fasilitas callback try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)_2 membuat pendekatan yang lebih baik ini cukup mudah Pertama, kita harus membuat ekspresi reguler dari kumpulan kunci yang ingin kita cocokkan. Ekspresi reguler seperti itu adalah pola dari bentuk “a1. a2. an" dan dapat dengan mudah dihasilkan menggunakan one-liner, seperti yang ditunjukkan pada resep. Kemudian, alih-alih memberikan try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)_2 string pengganti, kami menyebutnya dengan argumen callback. try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)2 memanggil objek ini untuk setiap kecocokan, dengan try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)6 sebagai satu-satunya argumen, dan mengharapkan string pengganti sebagai hasil panggilan. Dalam kasus kami, panggilan balik hanya perlu mencari teks yang cocok di kamus dan mengembalikan nilai yang sesuai Resepnya memiliki dua implementasi. satu berbasis try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)_7, dan yang lainnya menggunakan objek mirip kamus yang dapat dipanggil. Opsi kedua lebih baik jika Anda ingin melakukan pemrosesan tambahan pada setiap pertandingan (mis. g. , buat histogram berapa kali setiap kemungkinan penggantian benar-benar dilakukan) atau jika Anda tidak suka try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)7. Keuntungan potensial lain dari pendekatan berbasis kelas adalah kinerja. Jika Anda mengetahui bahwa kamus terjemahan bersifat statis, dan Anda harus menerapkan terjemahan yang sama ke beberapa string input, Anda dapat memindahkan panggilan try: dict except: from UserDict import UserDict as dict class Xlator(dict): """ All-in-one multiple-string-substitution class """ def _make_regex(self): """ Build re object based on the keys of the current dictionary """ return re.compile("|".join(map(re.escape, self.keys( )))) def _ _call_ _(self, match): """ Handler invoked for each regex match """ return self[match.group(0)] def xlat(self, text): """ Translate text, returns the modified text. """ return self._make_regex( ).sub(self, text)9 dari metode if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)0, yang saat ini sedang dilakukan, ke metode if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)1, untuk menghindari persiapan dan kompilasi berulang kali Berikut adalah contoh penggunaan untuk setiap bagian dari resep ini. Kami biasanya memilikinya sebagai bagian dari file sumber if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)2 yang sama dengan fungsi dan kelas yang ditampilkan dalam resep, sehingga dijaga oleh idiom Python tradisional yang menjalankannya jika dan hanya jika modul disebut sebagai skrip utama if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text) Pergantian seperti yang dilakukan oleh resep ini sering dimaksudkan untuk beroperasi pada seluruh kata, bukan pada substring yang berubah-ubah. Ekspresi reguler pandai mengambil awal dan akhir kata, berkat urutan khusus if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)3. Dengan demikian, kita dapat dengan mudah membuat versi kelas if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)4 yang dibatasi hanya untuk mengganti seluruh kata class WordXlator(Xlator): """ An Xlator version to substitute only entire words """ def _make_regex(self): return re.compile( r'\b'+r'\b|\b'.join(map(re.escape, self.keys( )))+r'\b') Perhatikan betapa lebih mudahnya menyesuaikan if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)_4 daripada menyesuaikan fungsi if _ _name_ _ == "_ _main_ _": text = "Larry Wall is the creator of Perl" adict = { "Larry Wall" : "Guido van Rossum", "creator" : "Benevolent Dictator for Life", "Perl" : "Python", } print multiple_replace(adict, text) xlat = Xlator(adict) print xlat.xlat(text)6. Kemudahan kustomisasi dengan subklasifikasi dan penggantian membantu Anda menghindari pengkodean salin dan tempel, dan ini adalah alasan bagus lainnya untuk memilih struktur berorientasi objek daripada struktur prosedural yang lebih sederhana. Tentu saja, hanya karena beberapa fungsionalitas dikemas sebagai sebuah kelas tidak secara ajaib membuatnya dapat disesuaikan seperti yang Anda inginkan. Kemampuan penyesuaian juga memerlukan pandangan jauh ke depan dalam membagi fungsionalitas menjadi metode yang dapat diganti secara terpisah yang sesuai dengan bagian yang tepat dari fungsionalitas keseluruhan. Untungnya, Anda tidak harus melakukannya dengan benar pada kali pertama; . g. , gunakan kembali dengan subklasifikasi dan penimpaan selektif), Anda dapat dan harus memfaktorkan ulang kode sehingga struktur internalnya sesuai dengan kebutuhan Anda. Pastikan Anda memiliki rangkaian pengujian yang sesuai yang siap dijalankan untuk memastikan bahwa pemfaktoran ulang Anda tidak merusak apa pun, dan kemudian Anda dapat melakukan pemfaktoran ulang sesuai isi hati Anda. Lihat http. // www. pemfaktoran ulang. com untuk informasi lebih lanjut tentang seni dan praktik penting refactoring Bagaimana Anda mengubah semua kata menjadi kata lain dengan Python?Sintaksis dari replace() . Sintaksis. rangkaian. ganti (lama, baru, hitung) Parameter Nilai Pengembalian. Ini mengembalikan salinan string di mana semua kemunculan substring diganti dengan substring lain Bagaimana Anda mengganti banyak nilai dalam sebuah string?Jawaban Terbaik. . Jika Anda ingin SEMUA string yang diberikan diganti, bukan hanya yang pertama, tambahkan bendera g. "const result1 = arrayOfObjects. kurangi((f, s) => ${f}. ganti (RegExp baru (Object. kunci(s)[0],'g'), s[Objek. kunci(s)[0]]), kalimat1)" Bagaimana Anda mengganti banyak kata dalam sebuah string dengan Python?01) Menggunakan metode replace()
. Metode ganti mengembalikan objek baru (string) menggantikan bidang tertentu (karakter) dengan nilai baru.
Bagaimana Anda mengganti banyak elemen dalam daftar Python?Salah satu cara yang dapat kita lakukan adalah dengan menggunakan perulangan for. Salah satu atribut kunci dari daftar Python adalah daftar tersebut dapat berisi nilai duplikat. Karena itu, kita dapat mengulangi setiap item dalam daftar dan memeriksa nilainya. Jika nilainya satu yang ingin kita ganti, maka kita ganti |