Am'm încercarea de a elimina anumite caractere dintr-un string folosind Python. Acesta este codul I'm, folosind chiar acum. Din păcate, pare să facă nimic de-a șirul.
for char in line:
if char in " ?.!/;:":
line.replace(char,'')
Cum pot face acest lucru în mod corespunzător?
Siruri de caractere în Python sunt imuabil (poate't fi schimbat). Din aceasta cauza, efectul de linie.înlocui (...) este doar pentru a crea un nou șir de caractere, mai degrabă decât schimbarea celui vechi. Ai nevoie de a rebind (atribuie) la "linie", în scopul de a fi care variabila ia valoarea nouă, cu acele personaje eliminat.
De asemenea, modul în care se face ea este de gând să fie un fel de lentă, relativ. L's, de asemenea, susceptibile de a fi un pic confuz pentru a experimentat pythonators, care vor vedea un dublu-imbricate structura și cred că pentru un moment că ceva mai complicat se întâmplă.
Începând din Python 2.6 și mai noi Python 2.x versiuni *, puteți folosi în loc de str.traduceți
, (dar citiți mai departe pentru Python 3 diferențe):
line = line.translate(None, '!@#$')
sau expresie regulată înlocuirea cu re.sub
import re
line = re.sub('[!@#$]', '', line)
Personajele închise în paranteze constituie o clasa de caracter. Orice caractere în "linie" care sunt în acea clasă sunt înlocuite cu cel de-al doilea parametru sub
: un șir gol.
În Python 3, siruri de caractere sunt Unicode. Te'll trebuie să traducă un pic diferit. kevpie menționează acest lucru într-un comentariu pe unul dintre răspunsurile, și-l's a remarcat în documentația pentru str.traduceți
.
Atunci când de asteptare "traduce" metoda de un șir Unicode, nu puteți trece cel de-al doilea parametru care am folosit-o mai sus. Ai, de asemenea, poate't pass "Nici unul" ca primul parametru, sau chiar o masă traducere din șir.maketrans. În schimb, te trece un dicționar ca singurul parametru. Acest dicționar hărți *ordinal valori* de caractere (de exemplu, rezultatul de asteptare [
ord`](https://docs.python.org/2/library/functions.html#ord) pe ele), la ordinal valori de caractere care ar trebui să le înlocuiască, sau—în mod util pentru noi— "Niciuna" pentru a indica faptul că acestea ar trebui să fie șterse.
Deci, pentru a face cele de mai sus dans cu un șir Unicode te-ar suna ceva de genul
translation_table = dict.fromkeys(map(ord, '!@#$'), None)
unicode_line = unicode_line.translate(translation_table)
Aici dict.fromkeys
și hartă sunt folosite pentru a succint genera un dicționar care conține
{ord('!'): None, ord('@'): None, ...}
Chiar mai simplu, ca un alt răspuns pune it, de a crea dicționar în loc:
unicode_line = unicode_line.translate({ord(c): None for c in '!@#$'})
* pentru compatibilitatea cu mai devreme Pitoni, puteți crea un "nul" traducere de masă pentru a trece în loc de "Nici unul":
import string
line = line.translate(string.maketrans('', ''), '!@#$')
Aici șir de caractere.maketrans
este folosit pentru a crea o traducere de masă, care este doar un șir de caractere care conține caracterele cu ordinal valori de la 0 la 255.
Am deviat de la subiect, sau este doar următoarele:
``python string = "ab1cd1ef" șir.înlocui("1","")
șirul de imprimare
``
Pune-l într-o buclă:
``puthon o = "o!b@c#d$" b = "!@#$" pentru char în b: a = un.replace(char,"")
imprimați o
``
re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)
>>> import re
>>> line = 'Q: Do I write ;/.??? No!!!'
>>> re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)
'QDoIwriteNo'
În expresii regulate (regex), |
este o logică SAU și \
scapă spații și caractere speciale care ar putea fi reale regex comenzi. Întrucât sub standuri pentru substituție, în acest caz, cu un șir gol''
.
Pentru inversul cerința de numai permite anumite personaje într-un șir de caractere, puteți utiliza expresii regulate cu un set completa operator [^ABCabc]
. De exemplu, pentru a elimina totul, cu excepția ascii litere, cifre, și cratima:
>>> import string
>>> import re
>>>
>>> phrase = ' There were "nine" (9) chick-peas in my pocket!!! '
>>> allow = string.letters + string.digits + '-'
>>> re.sub('[^%s]' % allow, '', phrase)
'Therewerenine9chick-peasinmypocket'
De python expresie regulată documentația:
Caractere care nu sunt într-un interval poate fi compensată prin completarea set. Dacă primul caracter din setul este
'^'
, toate personajele , care nu sunt în set va fi compensată. De exemplu,[^5]
se va potrivi orice caracter, cu excepția '5', iar[^^]
se va potrivi cu orice caracter, cu excepția'^'
.^
nu are nici o semnificație specială, dacă nu este primul personaj din set.
The asker aproape. Ca cele mai multe lucruri în Python, răspunsul este mai simplu decât crezi.
>>> line = "H E?.LL!/;O:: "
>>> for char in ' ?.!/;:':
... line = line.replace(char,'')
...
>>> print line
HELLO
Nu't au de a face imbricate dacă/buclă de lucru, dar ai nevoie pentru a verifica fiecare caracter individual.
Am fost surprins de faptul că nimeni nu a avut încă recomandată utilizarea interna filtru funcția.
import operator
import string # only for the example you could use a custom string
s = "1212edjaq"
Spunem că vrem să filtreze tot ce e't un număr. Folosind filtrul interna metoda "...este echivalent cu un generator de exprimare (element de articol în iterable dacă funcția(poziția))" [Python 3 Builtins: Filtru]
sList = list(s)
intsList = list(string.digits)
obj = filter(lambda x: operator.contains(intsList, x), sList)))
În Python 3 prezenta se întoarce
>> <filter object @ hex>
Pentru a obține imprimat un șir de caractere,
nums = "".join(list(obj))
print(nums)
>> "1212"
Eu nu sunt sigur cum filtru rândurile în termeni de eficiență, dar acesta este un lucru bun să știi cum să folosești atunci când faci list comprehensions și astfel.
UPDATE
În mod logic, din moment ce filtru de lucrări ai putea folosi, de asemenea, lista de înțelegere și din ceea ce am citit ar trebui sa fie mai eficient, deoarece lambda sunt de pe wall street manageri de fonduri de hedging din funcția de programare lume. Un alt plus este faptul că acesta este un one-liner care nu necesită importuri. De exemplu, folosind același șir 's' este definit mai sus,
num = "".join([i for i in s if i.isdigit()])
Ca's a. Revenirea va fi un șir de toate personajele care sunt cifre din șirul inițial.
Dacă aveți o listă specifică de acceptabil/inacceptabil caractere ai nevoie doar de a regla 'daca' parte din lista de înțelegere.
target_chars = "".join([i for i in s if i in some_list])
sau, alternativ,
target_chars = "".join([i for i in s if i not in some_list])
Folosind filtru
, ai'd nevoie doar de o singură linie
line = filter(lambda char: char not in " ?.!/;:", line)
Aceasta tratează șir ca un iterable și verifică fiecare personaj dacă "lambda" returnează "Adevărat":
ajutor(filtru) Ajuta pe built-in funcția de filtru în modulul builtin:
filtru(...) filtru(funcția sau Nici unul, secvență) -> listă, tuplu, sau string
Returna acele elemente de secvență pentru care funcția(poziția) este adevărat. Dacă funcția este Nici unul, a reveni elementele care sunt adevărate. Dacă secvența este un tuplu sau șir, a reveni la același tip, altfel întoarce o listă.
Aici's câteva posibile moduri de a realiza această sarcină:
def attempt1(string):
return "".join([v for v in string if v not in ("a", "e", "i", "o", "u")])
def attempt2(string):
for v in ("a", "e", "i", "o", "u"):
string = string.replace(v, "")
return string
def attempt3(string):
import re
for v in ("a", "e", "i", "o", "u"):
string = re.sub(v, "", string)
return string
def attempt4(string):
return string.replace("a", "").replace("e", "").replace("i", "").replace("o", "").replace("u", "")
for attempt in [attempt1, attempt2, attempt3, attempt4]:
print(attempt("murcielago"))
PS: în Loc folosind " ?.!/;:" exemple de utilizare vocalele... și da, "murcielago" este cuvântul spaniol pentru a spune bat... amuzant cuvânt ca acesta contine toate vocalele :)
PS2: Daca're interesat pe performanță ai putea măsura aceste încercări, cu un simplu cod de genul:
import timeit
K = 1000000
for i in range(1,5):
t = timeit.Timer(
f"attempt{i}('murcielago')",
setup=f"from __main__ import attempt{i}"
).repeat(1, K)
print(f"attempt{i}",min(t))
În cutia mea te'd obține:
attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465
Deci, se pare attempt4 este cel mai rapid pentru acest special de intrare.
Aici's Pitonul meu 2/3 versiune compatibilă. Deoarece traduce api-au schimbat.
def remove(str_, chars):
"""Removes each char in `chars` from `str_`.
Args:
str_: String to remove characters from
chars: String of to-be removed characters
Returns:
A copy of str_ with `chars` removed
Example:
remove("What?!?: darn;", " ?.!:;") => 'Whatdarn'
"""
try:
# Python2.x
return str_.translate(None, chars)
except TypeError:
# Python 3.x
table = {ord(char): None for char in chars}
return str_.translate(table)
Puteți folosi, de asemenea, o funcție pentru a înlocui alt fel de expresie regulată sau alt model cu utilizarea de o listă. Cu care, puteți amestecat expresie regulată, caracter de clasă, și într-adevăr de bază model de text. L's foarte util atunci când aveți nevoie pentru a înlocui o mulțime de elemente, cum ar fi HTML altele.
*NB: lucrări cu Python 3.x
import re # Regular expression library
def string_cleanup(x, notwanted):
for item in notwanted:
x = re.sub(item, '', x)
return x
line = "<title>My example: <strong>A text %very% $clean!!</strong></title>"
print("Uncleaned: ", line)
# Get rid of html elements
html_elements = ["<title>", "</title>", "<strong>", "</strong>"]
line = string_cleanup(line, html_elements)
print("1st clean: ", line)
# Get rid of special characters
special_chars = ["[!@#$]", "%"]
line = string_cleanup(line, special_chars)
print("2nd clean: ", line)
În funcție string_cleanup, este nevoie de șirul x și lista notwanted ca argumente. Pentru fiecare element din lista de elemente sau model, dacă un substitut este nevoie de-l va fi făcut.
Ieșire:
Uncleaned: <title>My example: <strong>A text %very% $clean!!</strong></title>
1st clean: My example: A text %very% $clean!!
2nd clean: My example: A text very clean
Metoda mea am'd folosi, probabil, ar't lucra la fel de eficient, dar este extrem de simplu. Pot elimina mai multe caractere în diferite poziții, toate dintr-o dată, folosind feliere și de formatare. Aici's un exemplu:
words = "things"
removed = "%s%s" % (words[:3], words[-1:])
Acest lucru va duce la 'eliminat' exploatație cuvântul 'asta'.
Formatare poate fi foarte util pentru imprimarea variabile la mijloc printr-un șir de imprimare. Se poate introduce orice tip de date folosind un %, urmată de variabila's tip de date; toate tipurile de date pot folosi %s, și plutește (aka zecimale) și pot folosi numere întregi %d.
Feliere poate fi folosit pentru un control complicat peste siruri de caractere. Când am pus cuvinte[:3], permite-mi pentru a selecta toate caracterele din șirul de la început (colon este înainte de număr, acest lucru va însemna 'de la început la') la al 4-lea personaj (include 4 caractere). Motivul 3 este egal cu până la poziția a 4-a este pentru că Python începe de la 0. Apoi, când mi-am pus word[-1:], înseamnă a 2-a ultimul caracter la sfârșitul (colon este în spatele număr). Punerea -1 va face Python număra de la ultimul caracter, mai degrabă decât prima. Din nou, Python va începe de la 0. Deci, word[-1:] înseamnă, practic 'de la cea de-a doua ultimul caracter la sfârșitul șirului.
Deci, prin tăierea de caractere înainte de personaj pe care nu doriți să o eliminați și personajele după ce și sandwich-le împreună, pot elimina nedorite caracter. Cred că de ea ca un cârnat. În mijlocul it's murdare, așa că vreau să scap de ea. Eu pur și simplu taie cele două capete vreau apoi le-a pus împreună, fără nedorite partea din mijloc.
Dacă vreau pentru a șterge mai multe caractere consecutive, eu pur și simplu schimba numerele în jurul valorii de în [] (feliere parte). Sau daca vreau sa scot mai multe personaje din diferite poziții, nu pot pur și simplu sandwich împreună mai multe felii dintr-o dată.
Exemple:
words = "control"
removed = "%s%s" % (words[:2], words[-2:])
scos este egal cu 'rece'.
words = "impacts"
removed = "%s%s%s" % (words[1], words[3:5], words[-1])
scos este egal cu 'mac-uri'.
În acest caz, [3:5] înseamnă caracter la poziția 3 prin caracter la poziția 5 (excluzând caracterul la poziția finală).
Amintiți-vă, Python începe numărătoarea de la 0, deci va trebui să fel de bine.
#!/usr/bin/python
import re
strs = "how^ much for{} the maple syrup? $20.99? That's[] ricidulous!!!"
print strs
nstr = re.sub(r'[?|$|.|!|a|b]',r' ',strs)#i have taken special character to remove but any #character can be added here
print nstr
nestr = re.sub(r'[^a-zA-Z0-9 ]',r'',nstr)#for removing special character
print nestr
Șirul metoda "înlocuiți" nu modifică șirul original. Se lasă originale singur și returnează o copie modificată.
Ce vrei tu e ceva de genul: linie = linie.replace(char,'')
def replace_all(line, )for char in line:
if char in " ?.!/;:":
line = line.replace(char,'')
return line
Cu toate acestea, crearea unui nou șir de fiecare și de fiecare dată când un personaj este eliminat, este foarte ineficient. Vă recomandăm următoarele:
def replace_all(line, baddies, *):
"""
The following is documentation on how to use the class,
without reference to the implementation details:
For implementation notes, please see comments begining with `#`
in the source file.
[*crickets chirp*]
"""
is_bad = lambda ch, baddies=baddies: return ch in baddies
filter_baddies = lambda ch, *, is_bad=is_bad: "" if is_bad(ch) else ch
mahp = replace_all.map(filter_baddies, line)
return replace_all.join('', join(mahp))
# -------------------------------------------------
# WHY `baddies=baddies`?!?
# `is_bad=is_bad`
# -------------------------------------------------
# Default arguments to a lambda function are evaluated
# at the same time as when a lambda function is
# **defined**.
#
# global variables of a lambda function
# are evaluated when the lambda function is
# **called**
#
# The following prints "as yellow as snow"
#
# fleece_color = "white"
# little_lamb = lambda end: return "as " + fleece_color + end
#
# # sometime later...
#
# fleece_color = "yellow"
# print(little_lamb(" as snow"))
# --------------------------------------------------
replace_all.map = map
replace_all.join = str.join