python sum 函数中可以使用条件语句吗

Question

我在学习协同过滤，遇到这样一段代码

def sim_distance(prefs,person1,person2):
  # Get the list of shared_items
  si={}
  for item in prefs[person1]: 
    if item in prefs[person2]: si[item]=1

  # if they have no ratings in common, return 0
  if len(si)==0: return 0

  # Add up the squares of all the differences
  sum_of_squares=sum([pow(prefs[person1][item]-prefs[person2][item],2) 
                      for item in prefs[person1] if item in prefs[person2]])

  return 1/(1+sum_of_squares)

比较困惑的是下面这段代码，为什么sum里面可以写for 循环呢，这个是什么意思，为什么我写了个类似的函数就会报错

sum([pow(prefs[person1][item]-prefs[person2][item],2) 
                          for item in prefs[person1] if item in prefs[person2]])

Answer 1

Le premier paramètre accepté par sum est un itérable. Si vous voulez connaître la signification de cette boucle for, vous devez vérifier le générateur et le sucre syntaxique lié au générateur. Voici un exemple simple pour l'affiche [i for i in range(5)] # 结果为[0,1,2,3,4]

.

Answer 2

Le for ou if ici n'ont rien à voir avec sum lui-même. Comme @大quail l'a dit, sum accepte un objet itérable comme paramètre Quant à l'itérable dans cet exemple, l'objet est simplement. une liste générée en utilisant la compréhension de liste.

---

Présentons brièvement la compréhension de liste (production en série).

Il s'agit d'une syntaxe au goût de

programmation fonctionnelle, intuitive et élégante.

Comme son nom l'indique, il sert à générer des

séries.

Il y a donc un principe important :

Lorsque le but du code d'aujourd'hui est de générer une liste, alors nous devrions envisager de l'utiliser, sinon nous ne devrions pas l'utiliser du tout

---

Jetons un coup d'œil à l'utilisation. C'est très simple Pour générer une liste, nous utilisons littéralement deux paires de crochets

(la syntaxe de génération littérale de liste), prenant en sandwich une itération [], The. les éléments visités à l'aide de for...in... seront utilisés pour créer chaque élément de la liste dans l'ordre. for

Regardons un exemple. Supposons qu'aujourd'hui nous ayons une liste d'entiers

et que nous voulions créer une autre liste lst dans laquelle chaque élément est le carré de l'élément dans lst2 : lst

lst = [1, 2, 3, 4]
lst2 = []

for i in lst:
    lst2.append(i**2)

Nous avons utilisé une boucle

standard pour ce faire, mais la même chose peut être faite de manière plus concise et élégante en utilisant la for...in...compréhension de liste :

lst = [1, 2, 3, 4]
lst2 = [i**2 for i in lst]

Dans cet exemple,

supprimera séquentiellement les éléments de for i in lst et effectuera une opération carrée pour devenir le nouvel élément de lst. Cela rappelle la fonction lst2, on peut aussi utiliser le map mapping pour obtenir des effets similaires :

lst = [1, 2, 3, 4]
lst2 = map(lambda x:x**2, lst)  # Python2
lst2 = list(map(lambda x:x**2, lst))  # Python3

visitera les éléments de son deuxième paramètre (un objet itérable) dans l'ordre et utilisera l'élément comme paramètre pour appeler son premier paramètre (une fonction à paramètre unique), c'est-à-dire qu'il retirera séquentiellement 1, 2, 3, 4 et utilisez-les comme paramètres map pour appeler la fonction anonyme x. lambda x:x**2

Mais nous pouvons constater que la compréhension de liste est plus intuitive, et nous pouvons dire que l'instruction

dans la compréhension de liste est un bon substitut à for. map

---

Quand vous penserez à

, vous penserez à map, qui effectue des actions de filtrage sur les objets itérables. filter

Par exemple, je souhaite que seuls les nombres impairs apparaissent dans

 :lst2

lst = [1, 2, 3, 4]
lst2 = filter(lambda x:x%2!=0, map(lambda x:x**2, lst))  # Python2
lst2 = list(filter(lambda x:x%2!=0, map(lambda x:x**2, lst)))  # Python3

visitera également son deuxième paramètre (un objet itérable), le retirera comme arguments dans l'ordre et appellera son premier paramètre (une fonction à paramètre unique si le résultat de l'opération est vrai ( <🎜). > ), la valeur de retour sera conservée en tant que nouvel élément, sinon ( filter ) sera filtrée. True FalseEt maintenant

a également un remplacement, qui est la compréhension de liste. Nous pouvons écrire comme ceci :

lst = [1, 2, 3, 4]
lst2 = [i**2 for i in lst if i%2!=0]

est également beaucoup plus simple ! On peut dire que l'instruction if en compréhension de liste est un bon substitut à filter.

---

Après avoir vu ça, je crois que vous avez déjà compris :

sum([pow(prefs[person1][item]-prefs[person2][item],2) 
                          for item in prefs[person1] if item in prefs[person2]])

Ce code exécute d'abord une compréhension de liste contenant l'instruction for...in... et l'instruction if pour générer une liste, puis utilise la liste comme argument pour appeler la fonction sum.

---

Conclusion :

1. for...in... et if ne sont pas directement liés à sum.

2. for...in... et if sont la syntaxe clé de la compréhension des listes.

3. La compréhension de liste peut nous aider à générer des listes à l'aide d'objets itérables.

4. la compréhension de liste est un bon remplacement pour map et filter.