Sequence of vowels count

This is not a homework question, it is an exam preparation question.

I should define a function syllables(word) that counts the number of syllables in A word in the following way:

• a maximal sequence of vowels is a syllable;

• a final e in a word is not a syllable (or the vowel sequence it is a part Of).

I do not have to deal with any special cases, such as a final e in a One-syllable word (e.g., ’be’ or ’bee’).

>>> syllables(’honour’)
2
>>> syllables(’decode’)
2
>>> syllables(’o开发者_如何学运维iseau’)
2

Should I use regular expression here or just list comprehension ?

---

I find regular expressions natural for this question. (I think a non-regex answer would take more coding. I use two string methods, 'lower' and 'endswith' to make the answer more clear.)

import re
def syllables(word):
    word = word.lower()
    if word.endswith('e'):
        word = word[:-1]
    count = len(re.findall('[aeiou]+', word))
    return count

for word in ('honour', 'decode', 'decodes', 'oiseau', 'pie'):
    print word, syllables(word)

Which prints:

honour 2
decode 2
decodes 3
oiseau 2
pie 1

Note that 'decodes' has one more syllable than 'decode' (which is strange, but fits your definition).

Question. How does this help you? Isn't the point of the study question that you work through it yourself? You may get more benefit in the future by posting a failed attempt in your question, so you can learn exactly where you are lacking.

---

Use regexps - most languages will let you count the number of matches of a regexp in a string.

Then special-case the terminal-e by checking the right-most match group.

---

I don't think regex is the right solution here.

It seems pretty straightforward to write this treating each string as a list.

---

Some pointers:

[abc] matches a, b or c.

A + after a regex token allows the token to match once or more

$ matches the end of the string.

(?<=x) matches the current position only if the previous character is an x.

(?!x) matches the current position only if the next character is not an x.

EDIT:

I just saw your comment that since this is not homework, actual code is requested. Well, then:

[aeiou]+(?!(?<=e)$)

If you don't want to count final vowel sequences that end in e at all (like the u in tongue or the o in toe), then use

[aeiou]+(?=[^aeiou])|[aeiou]*[aiou]$

I'm sure you'll be able to figure out how it works if you read the explanation above.

---

Here's an answer without regular expressions. My real answer (also posted) uses regular expressions. Untested code:

def syllables(word):
    word = word.lower()
    if word.endswith('e'):
        word = word[:-1]
    vowels = 'aeiou'
    in_vowel_group = False
    vowel_groups = 0
    for letter in word:
        if letter in vowels:
            if not in_vowel_group:
                in_vowel_group = True
                vowel_groups += 1
        else:
            in_vowel_group = False
    return vowel_groups

---

Both ways work. You said yourself that it was for exam preparation. Use whichever is going to be on the exam. If they're both on the exam, use which you need more practice for. Just remember:

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems. ~Jamie Zawinski

So in my opinion, don't use regex unless you need the practice.

---

Regular expressions would be way too complex, and a list comprehension probably wouldn't be robust enough. You will probably be able to solve this easily using a grammar lexer like PyParsing. Give it a shot!

---

Use a regex that matches a,e,i,o, or u, convert the string to a list, then iterate through the list... 1 for first true, 1 for next false, 2 for next true, 2 for next false, etc.

To handle the case where the last letter is 'e' following a consonant (as in ate), just check the last two letters of the word before you start. If they match that pattern truncate the final e and process as normal.

---

This pattern works for your definition:

(?!e$)([aeiouy]+)

Just count how many times it occurs.