在一个单词中找到连续的辅音

Question

I need code that will show me the consecutive consonants in a word. For example, for "concertation" I need to obtain ["c","nc","rt","t","n"] .

Here is my code:

def SuiteConsonnes(mot):
    consonnes=[]
    for x in mot:
        if x in "bcdfghjklmnprstvyz":
           consonnes += x + ''
    return consonnes

I manage to find the consonants, but I don't see how to find them consecutively. Can anybody tell me what I need to do?

Answer 1

You can use regular expressions, implemented in the re module

Better solution

>>> re.findall(r'[bcdfghjklmnpqrstvwxyz]+', "concertation", re.IGNORECASE)
['c', 'nc', 'rt', 't', 'n']

• [bcdfghjklmnprstvyz]+ matches any sequence of one or more characters from the character class

• re.IGNORECASE enables a case in sensitive match on the characters. That is

   >>> re.findall(r'[bcdfghjklmnpqrstvwxyz]+', "CONCERTATION", re.IGNORECASE) ['C', 'NC', 'RT', 'T', 'N'] 

---

Another Solution

>>> import re
>>> re.findall(r'[^aeiou]+', "concertation",)
['c', 'nc', 'rt', 't', 'n']

• [^aeiou] Negated character class. Matches anything character other than the one in this character class. That is in short Matches consonents in the string

• + quantifer + matches one or more occurence of the pattern in the string

Note This will also find the non alphabetic, adjacent characters in the solution. As the character class is anything other than vowels

Example

>>> re.findall(r'[^aeiou]+', "123concertation",)
['123c', 'nc', 'rt', 't', 'n']

If you are sure that the input always contain alphabets, this solution is ok

---

 re.findall(pattern, string, flags=0)

    Return all non-overlapping matches of pattern in string, as a list of strings. 
    The string is scanned left-to-right, and matches are returned in the order found. 

---

If you are curious about how the result is obtained for

re.findall(r'[bcdfghjklmnpqrstvwxyz]+', "concertation")

concertation
|
c

concertation
 |
 # o is not present in the character class. Matching ends here. Adds match, 'c' to ouput list


concertation
  |
  n

concertation
   |
   c


concertation
    |
     # Match ends again. Adds match 'nc' to list 
     # And so on

Answer 2

You could do this with regular expressions and the re module's split function:

>>> import re
>>> re.split(r"[aeiou]+", "concertation", flags=re.I)
['c', 'nc', 'rt', 't', 'n']

This method splits the string whenever one or more consecutive vowels are matched.

To explain the regular expression "[aeiou]+" : here the vowels have been collected into a class [aeiou] while the + indicates that one or more occurrence of any character in this class can be matched. Hence the string "concertation" is split at o , e , a and io .

The re.I flag means that the case of the letters will be ignored, effectively making the character class equal to [aAeEiIoOuU] .

Edit : One thing to keep in mind is that this method implicitly assumes that the word contains only vowels and consonants. Numbers and punctuation will be treated as non-vowels/consonants. To match only consecutive consonants, instead use re.findall with the consonants listed in the character class (as noted in other answers).

One useful shortcut to typing out all the consonants is to use the third-party regex module instead of re .

This module supports set operations, so the character class containing the consonants can be neatly written as the entire alphabet minus the vowels:

[[a-z]--[aeiou]] # equal to [bcdefghjklmnpqrstvwxyz]

Where [az] is the entire alphabet, -- is set difference and [aeiou] are the vowels.

Answer 3

If you are up for a non-regex solution, itertools.groupby would work perfectly fine here, like this

>>> from itertools import groupby
>>> is_vowel = lambda char: char in "aAeEiIoOuU"
>>> def suiteConsonnes(in_str):
...     return ["".join(g) for v, g in groupby(in_str, key=is_vowel) if not v]
... 
>>> suiteConsonnes("concertation")
['c', 'nc', 'rt', 't', 'n']

Answer 4

A really, really simple solution without importing anything is to replace the vowels with a single thing, then split on that thing:

def SuiteConsonnes(mot):
    consonnes = ''.join([l if l not in "aeiou" else "0" for l in mot])
    return [c for c in consonnes.split("0") if c is not '']

To keep it really similar to your code - and to add generators - we get this:

def SuiteConsonnes(mot):
    consonnes=[]
    for x in mot:
        if x in "bcdfghjklmnprstvyz":
            consonnes.append(x)
        elif consonnes:
            yield ''.join(consonnes)
            consonnes = []
    if consonnes: yield ''.join(consonnes)

Answer 5

def SuiteConsonnes(mot):
    consonnes=[]
    consecutive = '' # initialize consecutive string of consonants
    for x in mot:
        if x in "aeiou":   # checks if x is not a consonant
           if consecutive:  # checks if consecutive string is not empty
              consonnes.append(consecutive)  # append consecutive string to consonnes
              consecutive = ''  # reinitialize consecutive for another consecutive string of consonants
        else:
           consecutive += x   # add x to consecutive string if x is a consonant or not a vowel
    if consecutive: # checks if consecutive string is not empty
        consonnes.append(consecutive)  # append last consecutive string of consonants  
    return consonnes

SuiteConsonnes('concertation')
#['c', 'nc', 'rt', 't', 'n']

Answer 6

Not that I'd recommend it for readability, but a one-line solution is:

In [250]: q = "concertation"
In [251]: [s for s in ''.join([l if l not in 'aeiou' else ' ' for l in q]).split()]
Out[251]: ['c', 'nc', 'rt', 't', 'n']

That is: join the non-vowels with spaces and split again on whitespace.

Answer 7

Use regular expressions from re built-in module:

import re

def find_consonants(string):
    # find all non-vovels occuring 1 or more times: 
    return re.findall(r'[^aeiou]+', string)

Answer 8

虽然我认为您应该使用@ nu11p01n73R的答案，但这也可以工作：

re.sub('[AaEeIiOoUu]+',' ','concertation').split()