Bsrgvty

Your code is well-built and covers everything stated in the task, but could be made much shorter by using the .format() function.

str.format() is one of the string formatting methods in Python 3, which
allows multiple substitutions and value formatting. This method lets
us concatenate elements within a string through positional formatting.

Your code can, therefore, be made shorter and more concise this way. Here is what your code might look like -

def list_concatenator(your_list):

 if not your_list:
 return "Your list is empty!"

 elif len(your_list) == 1:
 return str(your_list[0])

 elif len(your_list) == 2:
 return '0 and 1'.format(your_list[0], your_list[1])

 else:
 body = ", ".join(map(str, your_list[:-1]))
 return '0, and 1'.format(body, your_list[-1])

I have used 0 and 1 so that positional arguments can be placed in the order you want them to be in, though it is not necessary to do so.

OR

Another way to format in Python 3 is to use f-strings.

The idea behind f-strings is to make string interpolation simpler. To create an f-string, prefix the string with the letter “ f ”. The string itself can be formatted in much the same way that you would with str.format(). f-strings provide a concise and convenient way to embed python expressions inside string literals for formatting.

Here's how your code would look like with f-strings (much shorter) -

def list_concetenator(your_list):

 if not your_list:
 return "Your list is empty!"

 elif len(your_list) == 1:
 return str(your_list[0])

 elif len(your_list) == 2:
 return f'your_list[0] and your_list[1]'

 else:
 body = ", ".join(map(str, a_list[:-1]))
 return f'body, and your_list[-1]'

Here are some example outputs -

your_list = ['item1', 'item2', 3, 'item4', 'item5', 'item6', 7, 'item8', 9]

print(list_concatenator(['item1', 'item2', 3, 'item4', 'item5', 'item6', 7, 'item8', 9]))
>>> item1, item2, 3, item4, item5, item6, 7, item8, and 9

print(list_concatenator(['item1', 'item2', 3]))
>>> item1, item2, and 3

print(list_concatenator(['item1', 3]))
>>> item1 and 3

print(list_concatenator(['item1']))
>>> item1 

print(list_concatenator([]))
>>> Your list is empty!

The program also takes care of the Oxford comma, where lists with two items do not have commas (e.g. apples and bananas) but lists with more than two items are separated with commas (apples, bananas, and cakes). Here are some useful links that help us understand what Oxford commas really are and when they should be used -

1. https://www.grammarly.com/blog/comma-before-and/




2. https://en.wikipedia.org/wiki/Serial_comma

Overall, I believe formatting was the main problem in your code.

EDIT -

In the comments section above, @Ilmari Karonen correctly mentions that the usage of " ' " in the book is the book's way of writing string literals. Therefore, I have edited my answer to make this change (i.e. remove unnecessary quotes). But if you require these quotes, then you could always wrap the string in double quotes, like this - f"'your_list[0] and your_list[1]'" or this - "'0 and 1'".format(your_list[0], your_list[1]).

Another let-down in your code is the use of inconsistent parentheses here,

(', '.join((map(str,your_list[:-1]))))

which could just be written as -

', '.join(map(str,your_list[:-1])).

To remain concise and immaculate in writing programs, I suggest you have a look at PEP 8, which is Python's official style guide.

Hope this helps!

1. 
   

   If you need to add '' then you should do this outside of the function. This can be fairly easy knowing the output is always a string.

   
   
   

   >>> print(repr(list_concatenator('a')))
   'a'
   

   
   
   

   By default the IDLE prompt does this automatically.

   
   
   

   >>> list_concatenator('a')
   'a'
   

   
   


2. 
   

   Rather than using len(your_list) == 0 you can use not your_list.

   
   
   

   if not your_list:
    return 'Your list is empty'
   

   
   



3. You can use str.join to join the rest of your lists.

def list_concatenator(your_list, comma=', ', conjunction=' and '):
 if not your_list:
 return 'Your list is empty'

 your_list = [str(i) for i in your_list]
 if len(your_list) > 1:
 your_list[:-1] = [comma.join(your_list[:-1])]
 return conjunction.join(your_list)

>>> list_concatenator(['item1', 'item2', 3, 'item4', 'item5', 'item6', 7, 'item8', 9])
'item1, item2, 3, item4, item5, item6, 7, item8 and 9'
>>> list_concatenator('abcde', conjunction=' or ')
'a, b, c, d or e'
>>> list_concatenator('abcde', conjunction=', or ')
'a, b, c, d, or e'
>>> list_concatenator('ab')
'a and b'
>>> list_concatenator('a')
'a'

It should be noted that the challenge says to seperate each value with a ', ', and so you could simplify this by mutating the last value with the conjunction, and just use one str.join.

def list_concatenator(your_list, comma=', ', conjunction='and'):
 if not your_list:
 return 'Your list is empty'

 your_list = [str(i) for i in your_list]
 if len(your_list) > 1:
 your_list[-1] = conjunction + ' ' + your_list[-1]
 return comma.join(your_list)

>>> list_concatenator(['item1', 'item2', 3, 'item4', 'item5', 'item6', 7, 'item8', 9])
'item1, item2, 3, item4, item5, item6, 7, item8, and 9'
>>> list_concatenator('abcde', conjunction='or')
'a, b, c, d, or e'
>>> list_concatenator('ab')
'a, and b'
>>> list_concatenator('a')
'a'

I used the following function for achieving the task. I am new here, so please feel free to comment anything you feel is wrong!

In the function, firstly, I check if the given list is empty or not.

If it is, then I return an empty string.

Otherwise, I first store the length of string in a variable. Then, I use list comprehension to convert all the elements in the list to string format, because some of them may be non-string and cause an error while using join function. Then, I join the strings in the list, separated by a comma and space, by using the join function on all elements of the list except the last. Then, I add an 'and' if the list has three or more elements. I have added the Oxford comma and a space before 'and' because the question has mentioned it.

Here is the function:

>>> def list_concatenator(your_list):
 if not your_list:
 return ''
 your_list = [str(i) for i in your_list]
 p = len(your_list)
 return ', '.join(your_list[:-1]) + (',' if p>2 else '') + (' and ' if p>1 else '') + your_list[-1]

Here are some outputs:

>>> li = []
>>> print(list_concatenator(li))


>>> li2 = ['apples']
>>> print(list_concatenator(li2))
apples

>>> li3 = ['apples', 'bananas']
>>> print(list_concatenator(li3))
apples and bananas

>>> li4 = ['apples', 'bananas', 'tofu', 'cats']
>>> print(list_concatenator(li4))
apples, bananas, tofu, and cats

>>> li5 = ['item1', 'item2', 3, 'item4', 'item5', 'item6', 7, 'item8', 9]
>>> print(list_concatenator(li5))
item1, item2, 3, item4, item5, item6, 7, item8, and 9

P.S: I have noticed that the outputs in Peilonrayz's answer have single quotes for every element of the input list, which is not the desired output. As I don't have 150 reputation, I can't comment :( But if someone who has 150 reputation notices this, please inform them! Thanks!

Here are a few mostly stylistic points.

 def list_concatenator(your_list):

"list_concatenator" is a poor choice for a function name. I'd rather expect "concatenator" to be a class that provides concatenation. A function name is, more commonly, a verb, that tells what the function does (e.g. sort) or a noun describing what the function returns (e.g. sqrt). Besides, "concatenate a list" is a very vague description of the task at hand. Therefore I'd suggest to name your function like "join_with_serial_comma" or "oxford_comma_concat" or even "oxfordize" ;)

"your_list" is bad too (who's this "you" exactly?). It's just some list, so name it "some_list" or "a_list" or "lst". Moreover, since you're only using len and [] in your code, there's no reason to restrict your function to lists specifically, just make it accept any sequence and name your argument like "sequence" or "seq"

 items = len(your_list)

Again, poor variable naming. items is what the list contains (cf. dict.items), what you mean here is length, size, number_of_items and so on.

 if items == 0:
 return 'Your list is empty'

An empty list is an exceptional situation for your function, and you can't and shouldn't return any value in this case. Much better option would be to raise an exception (ValueError would be a good choice), better yet, just remove this condition, the rest of the code is going to break anyways if the argument is empty (or not a sequence at all, for that matter). Ask forgiveness, not permission.

 elif items == 1:
 return "'" + str(your_list[0]) + "'"

If the previous condition ends with return or raise, there's no need for elif, just if would be more readable.

 elif items == 2:
 return "'" + str(your_list[0]) + ' and ' + str(your_list[1]) + "'"

As said in other posts, format or f-strings are usually more readable than concatenation.

 else:
 your_list_split1 = (', '.join((map(str,your_list[:-1]))))
 return "'" + your_list_split1 + ', and ' + str(your_list[-1]) + "'"

Yet again, your_list_split1 is a weird variable name, and doesn't reflect what the variable actually contains.

Since you always return from other branches, you can remove else here and reduce the indentation.

Comprehensions are usually more readable in python than map:

 head = ', '.join(str(item) for item in sequence[:-1])

A more "pythonic" alternative to -1 indexing would be an unpacking assignment:

 *head, tail = seq
 head_joined = ', '.join(str(p) for p in head)
 return f'head_joined, and tail'

Hope this helps.

Slicing the list would allow you to get all except the last element. Testing the list length will indicate what needs to go before the final element.

if len(your_list) > 0:
 if len(your_list) > 2: ander = ',' # if passive comma needed
 if len(your_list) > 1: ander += ' and '
 ', '.join(your_list[0:-1]) + ander + thelist[-1]