Trouver les numéros de téléphone de script python

le script python ci me permet de gratter des adresses de courriel à partir d'un fichier à l'aide d'expressions régulières.

Comment pourrais-je ajouter à ce que je puisse également obtenir des numéros de téléphone? Dites, si c'était le 7 chiffres ou 10 chiffres (avec l'indicatif de zone), et également en compte la parenthèse?

Mon script actuel peut être trouvé ci-dessous:

# filename variables
filename = 'file.txt'
newfilename = 'result.txt'

# read the file
if os.path.exists(filename):
        data = open(filename,'r')
        bulkemails = data.read()
else:
        print "File not found."
        raise SystemExit

# regex = [email protected]
r = re.compile(r'(\b[\w.]+@+[\w.]+.+[\w.]\b)')
results = r.findall(bulkemails)
emails = ""
for x in results:
        emails += str(x)+"\n"

# function to write file
def writefile():
        f = open(newfilename, 'w')
        f.write(emails)
        f.close()
        print "File written."

Regex pour les numéros de téléphone:

(\d{3}[-\.\s]\d{3}[-\.\s]\d{4}|\(\d{3}\)\s*\d{3}[-\.\s]\d{4}|\d{3}[-\.\s]\d{4})

Une autre expression régulière pour les numéros de téléphone:

(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?

Comme ceci: stackoverflow.com/questions/3302482/...
Avez-vous une regexp pour les numéros de téléphone pour nous critiquer?
Je viens d'ajouter à mon post ce que j'ai pour les numéros de téléphone. Ayant difficile la détection de 7 ou 10 chiffres qui n'ont pas de traits d'union.
Juste un "pays"/system ou ailleurs dans le monde? Avez-vous besoin de distinguer entre la cellule/mobile et fixe? Avez-vous besoin de distinguer le but spécial de tels chiffres 800 numéros? Possible +<"pays" code> préfixe?
J'espérais garder relativement simple. Donc pas de soucis pour le code du pays. Il devrait être en mesure d'accepter les indicatifs de zone, avec ou sans les parenthèses. Ou tout simplement des 7 chiffres. Il n'est pas nécessaire de distinguer entre les nombres comme 800 numéros.

OriginalL'auteur Aaron | 2010-10-06

python regex

32

Si vous êtes intéressés à en apprendre les Regex, tu pourrais prendre un coup de couteau à l'écrire vous-même. Ce n'est pas tout à fait aussi difficile que cela est fait pour être. Des Sites comme RegexPal vous permettre d'entrer des données de test, puis d'écrire et de tester une Expression Régulière sur ces données. À l'aide de RegexPal, essayez d'ajouter quelques numéros de téléphone dans les différents formats que vous vous attendez à les trouver (avec les crochets, les indicatifs de zone, etc), prenez un Regex triche et de voir dans quelle mesure vous pouvez obtenir. Si rien d'autre, il va les aider à lire les autres peuples Expressions.

Edit:
Voici une version modifiée de votre Regex, qui doit également correspondre 7 et 10-digit numéros de téléphone qui ne sont pas des tirets, des espaces ou des points. J'ai ajouté des points d'interrogation après les classes de caractères ([] s), ce qui rend quelque chose à l'intérieur de leur option. Je l'ai testé en RegexPal, mais comme je suis encore à apprendre Regex, je ne suis pas sûr que c'est parfait. Lui donner un essai.
```
(\d{3}[-\.\s]??\d{3}[-\.\s]??\d{4}|\(\d{3}\)\s*\d{3}[-\.\s]??\d{4}|\d{3}[-\.\s]??\d{4})
```
Qu'il cadre avec les valeurs suivantes dans RegexPal:
```
000-000-0000
000 000 0000
000.000.0000

(000)000-0000
(000)000 0000
(000)000.0000
(000) 000-0000
(000) 000 0000
(000) 000.0000

000-0000
000 0000
000.0000

0000000
0000000000
(000)0000000
```
Merci, j'ai trouvé le RegexPal plutôt utile. J'ai ajouté à mon message et compris ce que j'ai jusqu'à présent pour les numéros de téléphone. Quelque chose que je vais avoir de la difficulté à faire est de détecter les 7 ou 10 chiffres qui n'ont pas de traits d'union.
J'ai pris un coup à la modification de l'expression régulière que vous avez donné pour résoudre votre problème. Il est inclus dans ma réponse, j'ai édité. Essayez-le et voyez si cela fonctionne.
C'est vraiment génial. Je viens de faire quelques tests et semble fonctionner très bien. Ma seule question, comment mettre en œuvre ce afin qu'elle puisse travailler avec mes adresses e-mail? Est-il un moyen de le faire ce qui n'est pas trop de travail? Merci encore
Vous devriez être en mesure de l'appliquer de la même façon que l'e-mail Regex est déjà mis en œuvre; Essayez de modifier une copie de la # regex = [email protected] bloc. Je voudrais prendre un coup, mais je n'ai jamais touché Python avant. Vous voulez tout simplement à la recherche de correspondances au numéro de téléphone Regex dans le fichier que vous ouvrez, et la sortie à result.txt.
Hé, quel est le statut de votre projet? L'avez-vous mis en œuvre?

OriginalL'auteur Auguste
16

C'est le processus de création d'un numéro de téléphone de grattage regex.

Tout d'abord, nous avons besoin de correspondre à une zone de code (3 chiffres), tronc (3 chiffres) et d'une extension (4 chiffres):
```
reg = re.compile("\d{3}\d{3}\d{4}")
```
Maintenant, nous voulons capturer de la correspondance numéro de téléphone, nous avons donc ajouter entre parenthèses les pièces qui nous intéresse dans la capture (tous):
```
reg = re.compile("(\d{3}\d{3}\d{4})")
```
Le code de zone, le tronc, et l'extension peuvent être séparés par jusqu'à 3 caractères qui ne sont pas des chiffres (comme c'est le cas lorsque les espaces sont utilisés avec le trait d'union/dot délimiteur):
```
reg = re.compile("(\d{3}\D{0,3}\d{3}\D{0,3}\d{4})")
```
Maintenant, le numéro de téléphone peut réellement commencer avec un ( personnage (si le code de zone est indiqué entre parenthèses):
```
reg = re.compile("(\(?\d{3}\D{0,3}\d{3}\D{0,3}\d{4}).*?")
```
Maintenant que tout numéro de téléphone est probablement incorporé dans un tas d'autres textes:
```
reg = re.compile(".*?(\(?\d{3}\D{0,3}\d{3}\D{0,3}\d{4}).*?")
```
Maintenant, que d'autres le texte peut inclure des sauts de ligne:
```
reg = re.compile(".*?(\(?\d{3}\D{0,3}\d{3}\D{0,3}\d{4}).*?", re.S)
```
Profitez-en!

Personnellement, j'arrête ici, mais si vous voulez vraiment être sûr que seuls les espaces, tirets et les points sont utilisés comme délimiteurs, alors vous pourriez essayer les suivantes (non testé):
```
reg = re.compile(".*?(\(?\d{3})? ?[\.-]? ?\d{3} ?[\.-]? ?\d{4}).*?", re.S)
```
OriginalL'auteur dotancohen
6

Je pense que cette expression est très simple pour l'analyse des numéros de téléphone
```
re.findall("[(][\d]{3}[)][ ]?[\d]{3}-[\d]{4}", lines)
```
OriginalL'auteur user4959
1

Pour l'espagnol numéros de téléphone-je utiliser cela avec assez de succès:
```
re.findall( r'[697]\d{1,2}.\d{2,3}.\d{2,3}.\d{0,2}',str)
```
OriginalL'auteur Alex Moleiro
0

Plonger Dans Python est un exemple précis de ce que vous cherchez ici:

http://www.diveintopython.net/regular_expressions/phone_numbers.html

OriginalL'auteur Dan McDougall
0

Puisque personne n'a posté cette regex encore, je le ferai. C'est ce que j'utilise pour trouver des numéros de téléphone. Il correspond à tous les numéro de téléphone ordinaire formats que vous voyez dans les États-unis. Je n'ai pas besoin de cette expression régulière pour rechercher des numéros internationaux, alors je n'avais pas de faire des ajustements à la regex.
```
phone_number_regex_pattern = r"\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}"
```
L'utilisation de ce modèle si vous voulez simple les numéros de téléphone et pas de caractères entre les deux match. Un exemple de ceci serait: "4441234567".
```
phone_number_regex_pattern = r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}"
```
OriginalL'auteur Th3Tr1ckst3r
-1

Vous pouvez vérifier : http://regex.inginf.units.it/. Avec de l'entraînement de données et de la cible, il construit appropriés regex. Il n'est pas toujours parfait (case F-score). Faites un essai avec 15 exemples :
```
re.findall("\w\d \w\w \w\w \w\w \w\d|(?<=[^\d][^_][^_] )[^_]\d[^ ]\d[^ ][^ ]+|(?<= [^<]\w\w \w\w[^:]\w[^_][^ ][^,][^_] )(?: *[^<]\d+)+",  
           """Lorem ipsum ©  04-42-00-00-00 dolor 1901 sit amet, consectetur +33 (0)4 42 00 00 00 adipisicing elit. 2016 Sapiente dicta fugit fugiat hic 04 42 00 00 00 aliquam itaque 04.42.00.00.00 facere, 13205 number: 100 000 000 00013 soluta. 4 Totam id dolores!""")
```
retourne ['04 42 00 00 00', '04.42.00.00.00', '04-42-00-00-00', '50498,']
ajouter plus d'exemples de gagner en précision

échoue sur simple "4441234567" nombre
La solution serait mieux avec plus d'exemples (15 est trop court)
Il serait également mieux par specyfing toutes les possibilités

OriginalL'auteur J. Doe

Vous devez vous connecter pour publier un commentaire.