OO Python - Inheritance Quiz - Combiner function - which is more pythonic?

Question

Hi All,
Just completed one of the code challenges:
Make a function called 'combiner' which takes a list as an argument. This can contain strings and ints/floats. return a string that concatenates the string items and sums the numbers. The task asked us to use 'isinstance()' to check stuff.
I was able to complete the task successfully with the code below:
```python
def combiner(thelist):
    innerlist = thelist
    finalstring = ""
    finalsum = 0
for item in innerlist:
    if isinstance(item, str):
        finalstring += item

elif isinstance(item, (int, float)):
        finalsum += item

return str(finalstring) + str(finalsum)
```
However, as I like to do, I re-read and see how I can make it into less lines. Ultimately I removed many intermediate variables etc + used list comprehension to get it to this:
```python
def combiner(thelist):
combinedlist = str(''.join([item for item in thelist if isinstance(item, str)])) \
                + \
                str(sum([item for item in thelist if isinstance(item, (int, float))]))
return combinedlist
```
infact i didn't even need the 'combinedlist' variable and could have just used return for the 2 list comprehensions.
The first is easier to read ( i think ), the second is much less lines.
Which is more Pythonic? Should i be 'optimising' my code like this?

gyorgyandorka · Accepted Answer

Hi Sebastiaan!
Readability is what counts most. I think it's a good idea to replace the loop with list comprehensions, because it's denser and it can make the code more readable, but don't overdo the shortening. If a list comprehension is too complex, then it's much better to expand it to a regular for loop. Don't write any line on which you have to linger for more than a couple of seconds in order to comprehend - ideally, the reader of your code should understand it at a glance. Having said that, using comprehensions is fine, but I suggest doing it separately, and assigning them to named variables. An important part of the "clean code" paradigm is to make the code self-documenting, i.e. creating variables, methods with long, descriptive names, and use comments sparingly (only document why your code does what it does). The golden mean might be something like:
```python
clear and compact, with just the right amount of information to absorb on every line
def combiner(mylist):
    stringitems = [item for item in mylist if isinstance(item, str)]
    numericitems = [item for item in mylist if isinstance(item, (int, float))]
    return ''.join(stringitems) + str(sum(numeric_items))
```
Note: these are not objective truths by any means, just what I've learned so far. Coding style/standards are open for debate.
Also, check out the Zen of Python (https://www.python.org/dev/peps/pep-0020/)!
Sidenote 1: the innerlist variable was unnecessary even in the first version
Sidenote 2: it's higly recommended to use underscores when a variable name is a compound word (again, for readability)
An additional, off-topic note, this time about performance: since we're only interested in the sum of certain elements, it is a bit of an overkill to create two additional lists in memory with comprehensions - a so-called generator expression (https://www.python.org/dev/peps/pep-0289/) could come in handy in such situations. The syntax is the same as the list comprehension's, but we use parentheses instead of square brackets. I just mentioned it for the sake of completeness, this would matter only in case of very large data sets.

Sebastiaan Stoffels · Answer

Thanks for your answer Gyorgy. I do like your 'in between' version! :)

Welcome to the Treehouse Community

Looking to learn something new?

Sebastiaan Stoffels

Sebastiaan Stoffels

OO Python - Inheritance Quiz - Combiner function - which is more pythonic?

2 Answers

gyorgyandorka

gyorgyandorka

Assma Al-Adawi

Assma Al-Adawi

Sebastiaan Stoffels

Sebastiaan Stoffels