Comma Code (project from "Automate the Boring Stuff with Python")

Question

I'm currently learning Python using the book mentioned in the title. I just finished reading about lists, tuples, functions and methods, and one of the projects following this chapter is to create a program which takes in a list as an input and outputs a corresponding string, as the following example showcases:

Input: ['apples', 'bananas', 'tofu', 'cats']

Output: apples, bananas, tofu, and cats

This should of course work for any list. So I've come up with the following code:

def listToString(someList):
    for i in range(len(someList)):
        newString = str(someList[i])

        if i == (len(someList)-1):
            print('and ' + str(someList[i]))
        else:
            print(newString, end=', ')

someList = ['apples','bananas','tofu','cats']
listToString(someList)

I feel like I haven't used everything (for example, some methods) which were taught in the chapter to solve the problem. Is there a more efficient way to code this project?

Answer 1

You could have used various methods with a bit of list slicing.

I don't know if you had learned the .join() and .format() methods in your book, but those I will use.

A few remarks:

• Functions and variables should be snake_case instead of CamelCase
• List-to-string should return a string instead of printing it because that is what the name says

---

def list_to_string(a_list):
    return '{0} and {1}'.format(', '.join(a_list[:-1]), a_list[-1])

some_list = ['apples','bananas','tofu','cats']
print(list_to_string(some_list))

How does it work?

With .format() you can make clean string concatenations. The {0} is replaced by the ', '.join(a_list[:-1]) which joins the list until the last item [:-1] together with a comma and a space. The {1} is replaced by the last item in the list a_list[-1].

Answer 2

Ludisposed's answer is already a great improvement, however it fails to take into account some cornercases:

1. It only works with lists of strings.
2. For lists of length 1, like ["foo"], it returns " and foo" (your code has the same problem).
3. It raises an IndexError on an empty list.

This code avoids these problems:

def list_to_string(a_list):
    if not a_list:
        return ""
    elif len(a_list) == 1:
        return str(a_list[0])
    else:
        body = ", ".join(map(str, a_list[:-1]))
        return '{0} and {1}'.format(body, a_list[-1])

This does not currently have the Oxford comma, like your code. But you can easily add it as another special case (don't add it when len(a_list) == 2 and add it otherwise). Thanks to @DavidK for pointing this out in the comments.

Answer 3

Fundamental Problems

Considering you're learning, I would like to comment on what I see are fundamental problems with the function, not just how concise you can make the code.

No return value

A very big part of programming is making your functions modular, and we usually do this by breaking down the task into pieces which can be repeated. Using print statements like you did will print out to the console and might even make sense for your current problem, but what happens when you want to use this elsewhere? What if you want to save the fancy string to disk?

The answer to this is to return the string as the other answers have done. Then when you have the string you can do what you want with it like printing it or writing it to disk.

You should get into the habit of returning values from your functions.

Misleading Names

The function name implies that it returns a string from a list. Imagine you come back to your code four months from now and try to use this function to write to a file you would be justified into writing something like this:

fancy_string = list_to_string(groceries)
with open('groceries.txt', 'w') as groceries_file:
    groceries_file.write(fancy_string)

However, this will not work, because there is no return value here.

Naming is a seriously hard thing to do in programming, so consider your names carefully.

Python Style

Now into more minor things I'd like to point out to make the code more pythonic.

enumerate is your friend

This loop fragment:

for i in range(len(someList)):
    newString = str(someList[i])

can be replaced with:

for i, newString in enumerate(someList):

Also now replace instances of someList[i] with newString:

def listToString(someList):
    for i, newString in enumerate(someList):
        if i == (len(someList)-1):
            print('and ' + str(newString))
        else:
            print(newString, end=', ')

Even though in this case you should be using answers more along the line of the other posts it's good to know about enumerate for cases where you need the index along with the element of a list. I encourage you to use the Python for-loop construct without indexing things as much as possible.

PEP 8

As others have pointed out, the code is not to the Python standard PEP 8. While I'm not aware of code that strictly follows PEP 8 you should take a look at it to see what it looks like.

Answer 4

Some of the other answers give great instruction but the code examples introduce some readability issues that I would not recommend.

Compare this example to some of the others:

def list_to_string(list_object):
    # corner case 1: not a list object
    if not isinstance(list_object, list):
        raise ValueError('function parameter is not a list')

    # corner case 2: list object has 0 element
    if not list_object:
        raise ValueError('list is empty aka evaluated as false')

    # corner case 3: list object has 1 element
    if len(list_object)==1:
        return str(list_object[0])

    # actual use case
    else:
        # convert list elements to string
        str_list = [str(x) for x in list_object]
        bulk, last = str_list[:-1], str_list[-1]
        bulk_str = ', '.join(bulk)
        new_string = bulk_str + ' and ' + last
        return new_string

This covers most of the corner cases mentioned above.

alist = ['apples', 'bananas', 'tofus', 'cats']

list_to_string(alist)
# 'apples, bananas, tofus, and cats'

list_to_string(['apples'])
# 'apples'

list_to_string(10)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-30-8eea34c27d99> in <module>()
----> 1 list_to_string(10)

<ipython-input-27-37b4b95abce9> in list_to_string(list_object)
      3 def list_to_string(list_object):
      4     if not isinstance(list_object, list):
----> 5         raise ValueError('function parameter is not a list')
      6     if len(list_object)==1:
      7         return list_object[0]

ValueError: function parameter is not a list

blist = [2, 4, 5, 6]
list_to_string(blist)
# '2, 4, 5 and 6'

clist = []
list_to_string(clist)
# ---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-27-149a45f1b560> in <module>()
      1 clist = []
----> 2 list_to_string(clist)

<ipython-input-24-70c66e3078ce> in list_to_string(list_object)
      6     # corner case 2: list object has 0 element
      7     if not list_object:
----> 8         raise ValueError('list is empty aka evaluated as false')
      9 
     10     # corner case 3: list object has 1 element

ValueError: list is empty aka evaluated as false

Answer 5

You could have simply broken this problem in two parts, where first part would be printing the list items just before where and starts and then print last two items of the list (and included).

spam = ['apples', 'bananas', 'tofu', 'cats', 'mewoeto']
def andInsertedList(spamList):
    for i in range(len(spamList)-1):
        print(spamList[i], end=', ')  #First Part
    print('and ' + spamList[len(spamList)-1])  #Second Part  

andInsertedList(spam)