pythonは、反復可能なオブジェクトを例に戻すことができます。

反復可能なオブジェクトの再試行(順序は変更されません)

def filter_multi(items,key=None):
 """
        (      )
 [1,4,7,2,4,7,3,5] ==> [1,4,7,2,3,5]
 """
 its = list()
 for x in items:
 val = x if key is None else key(x)
 if val not in its:
 yield val
 its.append(val)

# :
print list(filter_multi([1,3,5,3,7,2,4,2]))
 
items = [{'a':1,'b':2},{'a':3,'b':4},{'a':1,'b':2},{'a':5,'b':6}]
print list(filter_multi(items,key=lambda k:(k['a'],k['b'])))

補足知識：Python特性学習――反復可能な対象、ローズマリー（再修正）
以前はpythonを勉強していましたが、いい加减なので、多くの特性がまったく使えないということを知っています。
イテレーションオブジェクト(Iterable)
簡単に言えば、すべてのオブジェクトは、リスト、元のグループ、文字列、辞書などの反復可能なオブジェクトです。
オブジェクトが反復可能なオブジェクトかどうかをどう判断しますか？
実际には、実现すればiter_方法のオブジェクトは反復可能なオブジェクトであり、この方法は、サンデー自体を返すために使用される（特に重要な）。
eg:

>>> s = "dasda"
>>> s.__iter__()
<str_iterator object at 0x7f23ebc44470>

pythonは、反復可能なオブジェクトかどうかを判断する方法を提供する。

>>> from collections import Iterable
>>> isinstance(s,Iterable)
True 

ディレクタ(Iterator)
上の概念と似ているようです。実際、すべてが実現しました。next_()方法の対象はすべてシーズマリーです。すべてが実現しましたnext_()同前iter_()方法の対象はすべてローズマリーですので、すべてのローズマリーはforループに入れられます。
pythonの原生のローズマリーは多くなく、iter（）を使って反復可能なオブジェクトをローズマリーに生成することができます。
eg:

>>> s = [1,2,3,4,5]
>>> s.__next__()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute '__next__'
>>> s = iter(s)
>>> type(s)
<class 'list_iterator'>
>>> s.__next__()
1
>>> from collections import Iterator
>>> isinstance(s,Iterator)
True

そして、シーズマリーの判断方法です。
いくつかの区別をする

#coding=utf-8
from collections import Iterable,Iterator

class A:#  __next__  。             
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __next__(self):
  if self.start < self.end:
   i = self.start
   self.start += 1
   return i
  else:
   raise StopIteration()

class B:#  __iter__  ，__iter__        __next__   。      ，     
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __iter__(self):
  return self

class C:#  __iter__  ，__iter__       __next__   。      ，     
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __iter__(self):
  return A(self.start,self.end)

class D:#  __iter__  __next__，__iter__      ， __next__   ，          
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __iter__(self):
  return self

 def __next__(self):
  if self.start < self.end:
   i = self.start
   self.start += 1
   return i
  else:
   raise StopIteration()

class E:#  __iter__  __next__，__iter__       ， __next__   ，          
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __iter__(self):
  return A(self.start,self.end)

 def __next__(self):
  if self.start < self.end:
   i = self.start
   self.start += 1
   return i
  else:
   raise StopIteration()

class F:#  __iter__  __next__，__iter__      __next__   ，          
 def __init__(self,start,end):
  self.start = start
  self.end = end

 def __iter__(self):
  return 1

 def __next__(self):
  if self.start < self.end:
   i = self.start
   self.start += 1
   return i
  else:
   raise StopIteration()

s = A(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))

s = B(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))

s = C(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))

s = D(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))


s = E(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))

s = F(5,10)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))

実行結果

Iterable: False
Iterator: False

Iterable: True
Iterator: False

Iterable: True
Iterator: False

Iterable: True
Iterator: True

Iterable: True
Iterator: True

Iterable: True
Iterator: True

forサイクル
明らかにリストは繰り返し可能なオブジェクトであり、forサイクルに入れることができます。しかし、listはローズマリーではなく、それをローズマリーに変えてもforサイクルに入れることができます。それでは問題が来ました。
forループは、どのようにして、サブジェネレータと反復可能なオブジェクトを処理しますか？
とりあえずA-Fを試してみます。forは使えますか？

s = A(1,4)
for i in s:
 print(i)

->

Traceback (most recent call last):
 File "IteratorZZ.py", line 68, in <module>
 for i in s:
TypeError: 'A' object is not iterable
#           

s = B(1,4)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))
for i in s:
 print(i)

->

Iterable: True
Iterator: False
Traceback (most recent call last):
 File "IteratorZZ.py", line 75, in <module>
 for i in s:
TypeError: iter() returned non-iterator of type 'B'
#  __iter__()          

s = C(1,4)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))
for i in s:
 print(i)

->

Iterable: True
Iterator: False
1
2
3
#  

s = D(1,4)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))
for i in s:
 print(i)

->

Iterable: True
Iterator: True
1
2
3
#  

s = E(1,4)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))
for i in s:
 print(i)

->

Iterable: True
Iterator: True
1
2
3
#  

s = F(1,4)
print('Iterable:',isinstance(s,Iterable))
print('Iterator:',isinstance(s,Iterator))
for i in s:
 print(i)

->
Iterable: True
Iterator: True
Traceback (most recent call last):
 File "IteratorZZ.py", line 115, in <module>
 for i in s:
TypeError: iter() returned non-iterator of type 'int'
#  ，__iter__        

このように、forは反復可能なオブジェクトにのみ作用することができる（注意すると、IterableとIteratorは衝突せず、オブジェクトはIterableであってもよいし、Iteratorであってもよい）。そして、このイテレーションオブジェクトの_u u u uiter_戻ってくるのは一つだけです。next_u.の対象となります。iter_返したのは、ローズマリーではないAクラスです。
だからforのワークフロー：
1.あるかどうかiter_，なければエラーが発生します
2.コールバックiter_
3.戻る対象は常にnext()を停止するまで継続します。
締め括りをつける
反復可能なオブジェクトは__u uiter_方法は、それを制限せずに返さなければなりません。next_u.のオブジェクト
ローズマリーは必ず同時に持っていなければなりません。iter_同前next_，そしてグウiter_帰ってくる相手が必ずしもいない。next_u.メソッド（Fクラス）。
forサイクルは、反復可能なオブジェクトに作用することができる。成功のforは必ず（℃）である。iter_帰ってきますnext_u.メソッドの対象。
疑問
ローズマリーは同時に実現しなければなりません。next_u.同前iter_じゃnon-iteratorは非ローズマリーということですか？でもE類の_u u uiter_戻ってきた対象（A）はディレクタではないが、forはどう解釈されますか？
答えを出す
Pythonには一つの原則があります。アヒルの種類は一つの生物がアヒルに似ているだけで、アヒルだと思います。
以上のこのpythonは繰り返し対象を対象にして、実例を重ねれば、小編集が皆さんに提供した内容の全部です。参考にしていただきたいです。どうぞよろしくお願いします。