Python ganti beberapa string dalam file

Saya harus mengganti string statis dari satu file (File 1) dengan string dinamis dari file lain (File2). Saya telah menulis skrip shell untuk ini. Di bawah ini isinya

Table of Contents Show

Bagaimana Anda mengganti banyak item dengan Python?
Bagaimana Anda mengganti banyak substring dengan satu string di Python?
Bagaimana Anda mengganti daftar string dengan Python?

 while read line
do
 field[0]=`echo $line | awk '{print $1}'`
 field[1]=`echo $line | awk '{print $2}'`
 field[2]=`echo $line | awk '{print $3}'`
  sed -e "s/Contact_FirstName/`echo ${field[0]}`/g;s/Contact_LastName/`echo ${field[1]}`/g;s/Email_ID/`echo ${field[2]}`/g" File1 > File3
done < File2
~

Saya menggunakan awk dan sed untuk memenuhi tujuan saya dan skrip berfungsi seperti yang diharapkan

Saya hanya ingin tahu apakah ada cara yang lebih baik untuk mencapai ini

Tolong sarankan

Terima kasih,
Chandan Singh

Terkadang ekspresi reguler memberikan solusi tercepat bahkan dalam kasus di mana penerapannya sama sekali tidak jelas. Khususnya, metode sub dari objek re menjadikan ekspresi reguler sebagai cara yang baik untuk melakukan penggantian string. Inilah cara Anda dapat menghasilkan string hasil dari string input di mana setiap kemunculan kunci apa pun dalam kamus yang diberikan diganti dengan nilai yang sesuai dalam kamus

# 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 sub. Pendekatan berorientasi objek ini lebih fleksibel karena objek yang dapat dipanggil dapat mempertahankan statusnya sendiri dan oleh karena itu dapat dengan mudah diperluas ke tugas lain. Dalam Python2. 2 dan yang lebih baru, Anda dapat membuat kelas untuk objek ini dengan memperluas dict tipe bawaan, sementara di versi Python yang lebih lama Anda harus menggunakan UserDict.UserDict (tipe bawaan tidak dapat disubklasifikasikan di versi yang lebih lama). try/

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 re standar Python untuk melakukan substitusi multi-string single-pass menggunakan kamus. Katakanlah Anda memiliki pemetaan satu-ke-satu berbasis kamus antar string. Kuncinya adalah kumpulan string (atau pola ekspresi reguler) yang ingin Anda ganti, dan nilai yang sesuai adalah string yang akan digunakan untuk menggantinya. Anda dapat melakukan substitusi dengan memanggil

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 panggilan balik

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 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 saja 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 mengganti banyak item dengan Python?

replace() berfungsi beberapa kali untuk mengganti banyak nilai, Anda dapat menggunakan daftar untuk memetakan elemen yang ingin Anda ganti satu per satu dengan elemen yang ingin Anda ganti.

Bagaimana Anda mengganti banyak substring dengan satu string di Python?

subn() untuk mengganti banyak substring dalam sebuah string. sub() - Ini menggantikan isi string berdasarkan pola. Dibutuhkan pola atau string sebagai argumen pertama. Argumen kedua adalah fungsi lambda yang mengekstrak sub-string yang cocok kemudian mengembalikan nilai yang terkait dengannya dari kamus.

Bagaimana Anda mengganti daftar string dengan Python?

Ganti string tertentu dalam daftar. Jika Anda ingin mengganti rangkaian elemen daftar, gunakan metode string replace() untuk setiap elemen dengan pemahaman daftar . Jika tidak ada string yang akan diganti, penerapan replace() tidak akan mengubahnya, jadi Anda tidak perlu memilih elemen dengan kondisi if.