Automatiser les trucs ennuyeux avec Python: par des Virgules Code

Utilisation str.join() à se joindre à une séquence de chaînes de caractères avec un délimiteur. Si vous le faites pour tous les mots sauf pour la dernière, vous pouvez insérer ' and ' il ya lieu:

def list_thing(words):
    if len(words) == 1:
        return words[0]
    return '{}, and {}'.format(', '.join(words[:-1]), words[-1])

Faire:

• words[-1] prend le dernier élément d'une liste. words[:-1] tranches la liste de produire une nouvelle liste avec tous les mots sauf le dernier.

• ', '.join() produit une nouvelle chaîne, avec toutes les cordes de l'argument de str.join() rejoint avec ', '. S'il y a un élément dans la liste d'entrée, qu'un élément est retourné, non.

• '{}, and {}'.format() insère la virgule-joint mots et le dernier mot dans un modèle (avec Oxford comma).

Si vous passez dans une liste vide, la fonction ci-dessus génère une IndexError exception; vous pouvez tester plus précisément pour ce cas dans la fonction si vous vous sentez d'une liste vide est valable de cas d'utilisation pour la fonction.

La rejoint tous les mots sauf le dernier avec ', ', puis ajoute le dernier mot à la suite avec ' and '.

Noter que si il n'y a qu'un seul mot, vous obtenez ce seul mot; il n'y a rien à se joindre dans ce cas. Si il y a deux, vous obtenez 'word1 and word 2'. Plus de mots produit 'word1, word2, ... and lastword'.

Démo:

>>> def list_thing(words):
...     if len(words) == 1:
...         return words[0]
...     return '{}, and {}'.format(', '.join(words[:-1]), words[-1])
...
>>> spam = ['apples', 'bananas', 'tofu', 'cats']
>>> list_thing(spam[:1])
'apples'
>>> list_thing(spam[:2])
'apples, and bananas'
>>> list_thing(spam[:3])
'apples, bananas, and tofu'
>>> list_thing(spam)
'apples, bananas, tofu, and cats'

J'ai essayé cela, l'espoir, c'est ce que vous cherchez :-

spam= ['apples', 'bananas', 'tofu', 'cats']

def list_thing(list):

#creating a string then splitting it as list with two items, second being last word
    new_string=', '.join(list).rsplit(',', 1)    

#Using the same method used above to recreate string by replacing the separator.

    new_string=' and'.join(new_string)
    return new_string

print(list_thing(spam))

D'autres ont donné d'excellents one-liner solutions, mais une bonne façon d'améliorer votre implémentation réelle, et de corriger le fait qu'il ne fonctionne pas lorsque les éléments sont répétés - est d'utiliser des enumerate dans la boucle for pour garder une trace de l'indice, plutôt que d'utiliser index, qui trouve toujours de la première apparition de la cible.

for counter, element in enumerate(list):
    new_string = new_string + str(element)
    if counter == (len(list)-2):
        ...

Mon interprétation de la question est telle qu'un seul élément de la liste sera aussi le dernier élément de la liste, et en tant que tel aurait besoin de l' " et "inséré avant, ainsi que deux de la liste des items renvoyant à la fois à' , and " entre eux. Donc aucun besoin de traiter avec un seul ou de deux listes d'objets séparément, seulement les n premiers éléments, et le dernier élément.
Je voudrais aussi noter que, bien que bonne, beaucoup d'autres articles d'utiliser des modules et des fonctions qui ne sont pas enseignées dans les Automatiser les Trucs Ennuyeux texte par le temps, l'étudiant est confronté à cette question (un étudiant comme moi avait vu join et .format ailleurs, mais a tenté d'utiliser uniquement ce qui a été enseigné dans le texte).

def commacode(passedlist):
    stringy = ''
    for i in range(len(passedlist)-1):
        stringy += str(passedlist[i]) + ', '
        # adds all except last item to str
    stringy += 'and ' + str(passedlist[len(passedlist)-1])
    # adds last item to string, after 'and'
    return stringy

Et vous pourriez gérer la liste vide au cas par:

def commacode(passedlist):
    stringy = ''
    try:
        for i in range(len(passedlist)-1):
            stringy += str(passedlist[i]) + ', '
            # adds all except last item to str
        stringy += 'and ' + str(passedlist[len(passedlist)-1])
        # adds last item to string, after 'and'
        return stringy
    except IndexError:
        return '' 
        #handles the list out of range error for an empty list by returning ''

Juste un simple code. Je pense que nous n'avons pas besoin d'utiliser toute la fantaisie de trucs ici. :p

def getList(list):
    value = ''
    for i in range(len(list)):
        if i == len(list) - 1:
            value += 'and '+list[i]
        else:
            value += list[i] + ', '
    return value

spam = ['apples', 'bananas', 'tofu', 'cats']

print('### TEST ###')
print(getList(spam))

Je suis assez nouveau pythonista. Dans la question, il a été demandé que le retour de la fonction, le contenu de la liste comme une chaîne de caractères dans le format que les autres solutions de ce forum ont "imprimé" il. La suite est (à mon avis) un nettoyeur de solution à ce problème.

Ce qui illustre bien la virgule solution de code du chapitre 4 [Listes] dans Automatiser Les Trucs Ennuyeux.

def comma_code(argument):

    argument_in_string = ''
    argument_len = len(argument)
    for i in range(argument_len):
        if i == (argument_len - 1):
            argument_in_string = argument_in_string + 'and ' + argument[i]
            return argument_in_string

        argument_in_string = argument_in_string + argument[i] + ', '

spam = ['apples', 'bananas', 'tofu', 'cats']
return_value = comma_code(spam)
print(return_value)"

Comme il n'a pas été mentionné, voici une réponse avec f de la ficelle, pour référence:

def list_things(my_list):
    print(f'{", ".join(my_list[:-1])} and {my_list[-1]}.')

Un exemple interpolant un message personnalisé et en acceptant aussi une chaîne de caractères comme argument:

def like(my_animals = None):
    message = 'The animals I like the most are'
    if my_animals == None or my_animals == '' or len(my_animals) == 0:
        return 'I don\'t like any animals.'
    elif len(my_animals) <= 1 or type(my_animals) == str:
        return f'{message} {my_animals if type(my_animals) == str else my_animals[0]}.'
    return f'{message} {", ".join(my_animals[:-1])} and {my_animals[-1]}.'


>>> like()
>>> like('')
>>> like([])
# 'I don't like any animals.'

>>> like('unicorns') 
>>> like(['unicorns']) 
# 'The animals I like the most are unicorns.'

>>> animals = ['unicorns', 'dogs', 'rabbits', 'dragons']
>>> like(animals) 
# 'The animals I like the most are unicorns, dogs, rabbits and dragons.'

Pas de boucles, pas de joint, à seulement deux instructions d'impression:

def commalist(listname):
    print(*listname[:-1], sep = ', ',end=", "),
    print('and',listname[-1])

Pourquoi tout le monde est à mettre alors les codes complexes.

Voir mon code ci-dessous. C'est le plus simple et le plus facile à comprendre d'un seul coup, même pour un débutant.

import random

def comma_code(subject):

     a = (len(list(subject)) - 1)

     for i in range(0, len(list(subject))):

          if i != a:
               print(str(subject[i]) + ', ', end="")

          else:
              print('and '+ str(subject[i]))            


spam = ['apples','banana','tofu','cats']

après le codage ci-dessus, il suffit de taper comma_code(spam) dans le python shell et vous êtes bon pour aller. Profitez de

spam=['apples','bananas','tofu','cats']
print("'",end="")
def val(some_parameter):

for i in range(0,len(spam)):
if i!=(len(spam)-1):
print(spam[i]+', ',end="")
else:
print('and '+spam[-1]+"'")
val(spam)

spam=['apple', 'banana', 'tofu','cats']
spam[-1]= 'and'+' '+ spam[-1]
print (', '.join((spam)))