List Comprehension

Ακρώνυμο
Ακρώνυμο στη διαδρομή Python 
def abbreviate(to_abbreviate):
    phrase = to_abbreviate.replace("-", " ").replace("_", " ").upper().split()
    
    return "".join([word[0] for word in phrase])
  • This approach begins by using str.replace() on to_abbreviate to convert non-letter characters such as - and _ into spaces.
  • The phrase is then upper-cased by calling str.upper().
  • Finally, the phrase is turned into a list of words by calling str.split().

The three methods above are all chained together, with each method operating on the output of the method before it in the "chain". This works because both replace() and upper() operate on strings (as they are str methods) and return strings. If split() was called first, replace() and upper() would fail, since they cannot operate on the list returned by split().

Note

re.findall() or re.finditer() can also be used to clean to_abbreviate. These two methods from the re module will return a list or a lazy iterator of results, respectively. As of this writing, both of these methods benchmark slower than using str.replace() for cleaning.

A list comprehension is then used to iterate through the phrase and select the first letters of each word via bracket notation. This comprehension is passed into str.join(), which unpacks the list of first letters and joins them together using an empty string — the acronym. Other "separator" strings besides an empty string can be used with str.join() — see string-methods for some additional examples. Since the comprehension and join() are fairly succinct, they are put directly on the return line, rather than assigning and returning an intermediate variable for the acronym.

The weakness of this solution is that it is taking up extra space with the list comprehension, which is creating and saving a list in memory — only to have that list immediately unpacked by the str.join() method. While this is trivial for the inputs this problem is tested against, it could become a problem if the inputs get longer. It could also be an issue if the code were deployed in a memory-constrained environment. A generator expression here would be more memory-efficient, though there are speed tradeoffs. See the generator expression approach for more details.

Translation missing: el.number.nth.ordinalized Sep 2026 · Σου φάνηκε χρήσιμη;

Άλλες προσεγγίσεις για την άσκηση Ακρώνυμο στη διαδρομή Python

Άλλοι τρόποι με τους οποίους η κοινότητά μας έλυσε αυτή την άσκηση
from functools import reduce

def abbreviate(to_abbreviate):
    phrase = to_abbreviate.replace("-", " ").replace("_", " ").upper().split()

    return reduce(lambda start, word: start + word[0], phrase, "")
Functools Reduce

Use functools.reduce() to form an acronym from text cleaned using str.replace(). 

def abbreviate(to_abbreviate):
    phrase = to_abbreviate.replace("-", " ").replace("_", " ").upper().split()

    # Note the lack of square brackets around the comprehension.
    return "".join(word[0] for word in phrase)
Generator Expression

Use a generator expression with str.join() to form an acronym from text cleaned using str.replace(). 

def abbreviate(to_abbreviate):
    phrase = to_abbreviate.replace("-", " ").replace("_", " ").upper().split()
    acronym = ""

    for word in phrase:
        acronym += word[0]

    return acronym
Loop

Use str.replace() to clean the input string and a loop with string concatenation to form the acronym. 

def abbreviate(to_abbreviate):
    phrase = to_abbreviate.replace("-", " ").replace("_", " ").upper().split()
    
    return "".join(map(lambda word: word[0], phrase))
Map Built-in

Use the built-in map() function to form an acronym after cleaning the input string with str.replace(). 

import re

def abbreviate(phrase):
    removed = re.findall(r"[a-zA-Z']+", phrase)

    return "".join(word[0] for word in removed).upper()
Regex join

Use regex to clean the input string and form the acronym with str.join(). 

import re

def abbreviate_regex_sub(to_abbreviate):
    pattern = re.compile(r"(?<!_)\B[\w']+|[ ,\-_]")

    return re.sub(pattern, "", to_abbreviate.upper())
Regex Sub

Use re.sub() to clean the input string and create the acronym in one step. 

VALID_CHARS = {" ", "-"} | set(ascii_letters)

def abbreviate(to_abbreviate):
    to_abbreviate = "".join(" " if char == "-" else char
                            for char in to_abbreviate
                            if char in VALID_CHARS)

    return "".join(word[0] for word in to_abbreviate.split()).upper()
Double Generator Expression

Use generator expressions for both cleaning and joining the input.