日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

公告：魔扣目錄網為廣大站長提供免費收錄網站服務，提交前請做好本站友鏈：【 網站目錄：http://www.ylptlb.cn 】， 免友鏈快審服務（50元/站），

點擊這里在線咨詢客服
新站提交
  • 網站：51998
  • 待審：31
  • 小程序：12
  • 文章：1030137
  • 會員：747

Python列表去重復項的N種方法方式討論

發布時間：2023-07-03 13:52:25 作者：網友整理

隨著人工智能的發展，Python變得越來越流行了。而Python語言中列表(List)與其他語言的數組(Array)類似，是一種有序的集合數據結構，但Python List可支持各種數據類型，長度也可動態調整，與JS中的數組或JAVA ArrayList很接近。在實際編程中，我們會遇到數組或列表去掉重復項的需求。那么在Python編程中，我們會有很多種方法來實現這個目標，有的新建列表來存儲非重復項，有的則在原有基礎上刪除掉重復的項，有的則利用數據結構來達到去重復的目的。具體哪一種方法更好呢？只能說根據不同場景來選擇一種，以下的N種方式將有助于對于基礎算法和語言學習的理解。

Python列表去重復項的N種方法

 

方式

## 1. 新建列表，如果新列表中不存在，則添加到新列表
def unique(data):
    newList = []
    for item in data:
        if item not in newList:
            newList.Append(item)
    print("for list + not in. data:", newList)

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
unique(data)
print("time:" + str((time.time() - start_time) * 1000) + " ms")

# result
$ python -V
Python 2.7.16
$ python unique.py 
('for list + not in. data:', ['a', 1, 2, 'b'])
time:0.0441074371338 ms
## 2. 新建列表。根據下標判斷是否存在新列表中，如果新列表中不存在則添加到新列表
def unique(data):
    newList = []
    for i in range(len(data)):
        if data[i] not in newList:
            newList.append(data[i])
    return newList

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("for range + not in. data:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 3. 通過index找不到該項，則追加到新列表中。index找不到會報錯，因此放在異常處理里
def unique(data):
    newList = []
    for i in range(len(data)):
        item = data[i]
        try:
            if (newList.index(item) < 0):
                print('newList:', newList)
        except ValueError:
            newList.append(item)
    return newList

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("list index + except:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 4. 新建列表，兩個循環。如果內循環與外循環項相同，且下標相同就添加到新列表，其余忽略
def unique(data):
    newList = []
    for i in range(len(data)):
        j = 0
        while j < i:
            j += 1
            if data[i] == data[j]:
                if (i == j):
                    newList.append(data[i])
                break
    return newList

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("new list + for. newList:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 5. 在原有列表上移除重復項目。自后往前遍歷，逐個與前面項比較，如果值相同且下標相同，則移除當前項。
def unique(data):
    l = len(data)
    while (l > 0):
        l -= 1
        i = l
        while i > 0:
            i -= 1
            if data[i] == data[l]:
                del data[l]
                break
    return data

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("one list while. last -> first result. data:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 6. 在原有列表上移除重復項目。自前往后遍歷，逐個與后面項比較，如果值相同且下標相同，則移除當前項。
def unique(data):
    l = len(data)
    i = 0
    while i < l:
        j = i + 1
        while j < l:
            if data[i] == data[j]:
                del data[j]
                l -= 1
                i -= 1
                break
            j += 1
        i += 1
    return data

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("one list while. first -> last result. data:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 7. 新建列表。遍歷列表，利用index比較出現的位置，如果出現在第一次的位置則追加到新數組
def unique(data):
    newList = []
    for i in range(len(data)):
        if i == data.index(data[i]):
            newList.append(data[i])
    return newList

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("for range + index. data:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 8. 利用字典屬性唯一性來實現去重復。
def unique(data):
    obj = {}
    for item in data:
        obj[item] = item
    return obj.values()

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("list + dict:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 9. 利用filter函數，即把不符合條件的過濾掉。這里filter不支持下標，因此需要借助外部列表存儲不重復項
def uniq(item):
    i = data.index(item)
    if (item not in newList):
        newList.append(item)
        return True
    return False


# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
newList = []
print('filter + list + not in: ', filter(uniq, data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 10. 利用字典結合過濾來實現去重復。
def unique(item):
    if obj.get(item) == None:
        obj[item] = item
        return True
    return False

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
obj = {}
print("filter + dict + get:", filter(unique, data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 11. 利用map來實現去重復。與map與filter類似，是一個高階函數。可以針對其中項逐個修改操作。
## 與filter不同map會保留原有項目，并不會刪除，因此值可以改為None，然后再過濾掉。
def unique(item):
    if item not in newList:
        newList.append(item)
        return item
    return None


# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
newList = []
start_time = time.time()

print("list from Map:", filter(lambda item: item != None, map(unique, data)))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 12. 利用set數據結構里key的唯一性來去重復
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
print("from Set:", set(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 13. 提前排序，從后向前遍歷，將當前項與前一項對比，如果重復則移除當前項
def unique(data):
    data.sort()
    l = len(data)
    while (l > 0):
        l -= 1
        if (data[l] == data[l - 1]):
            data.remove(data[l])
    return data

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("sort + remove:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 14. 提前排序，自前往后遍歷，將當前項與后一項對比，如果重復則移除當前項
def unique(data):
    """
     in python 3: TypeError: '<' not supported between instances of 'int' and 'str'
     need to keep the same Type of member in List
    """
    data.sort()
    l = len(data) - 1
    i = 0
    while i < l:
        if (data[i] == data[i + 1]):
            del data[i]
            i -= 1
            l -= 1
        i += 1
    return data

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("sort+del ASE:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 15. 利用reduce函數來去重復。reduce具有累計的作用，判斷如果不在累計結果中出現，則追加到結果中。
import functools
def unique(data):
    newList = []

    def foo(result, item):
        if isinstance(result, list) == False:
            result = [result]
        return result if item in result else result + [item]

    return functools.reduce(foo, data)

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("functools.reduce:", unique(data))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 16. 利用遞歸調用來去重復。遞歸自后往前逐個調用，當長度為1時終止。
## 當后一項與前任一項相同說明有重復，則刪除當前項。相當于利用自我調用來替換循環
def recursionUnique(data, len):
    if (len <= 1):
        return data

    l = len
    last = l - 1
    isRepeat = False

    while (l > 1):
        l -= 1
        if (data[last] == data[l - 1]):
            isRepeat = True
            break

    if (isRepeat):
        del data[last]

    return recursionUnique(data, len - 1)

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("recursionUnique:", recursionUnique(data, len(data)))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
## 17. 利用遞歸調用來去重復的另外一種方式。遞歸自后往前逐個調用，當長度為1時終止。
## 與上一個遞歸不同，這里將不重復的項目作為結果拼接起來
def recursionUniqueNew(data, len):
    if (len <= 1):
        return data

    l = len
    last = l - 1
    isRepeat = False
    while (l > 1):
        l -= 1
        if (data[last] == data[l - 1]):
            isRepeat = True
            break

    if (isRepeat):
        del data[last:]
        result = []
    else:
        result = [data[last]]

    return recursionUniqueNew(data, len - 1) + result

# test
data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]
start_time = time.time()
print("recursionUniqueNew:", recursionUniqueNew(data, len(data)))
print("time:" + str((time.time() - start_time) * 1000) + " ms")
Python列表去重復項的N種方法

 

討論

從以上例子上可以看出，相對來講，Python比起其它語言要靈活得多，與JS并列最流行的腳本類語言，這也就是為何Python如此流行的原因吧。

哪一種方式更適合呢？你常用那種方式來實現去重復項？新建數組、非新建、借助DIct或Set等結構，亦或是其它方式？

Python列表去重復項的N種方法

 

分享到：
標簽：列表 Python
用戶無頭像

網友整理

注冊時間：

網站：5 個   小程序：0 個  文章：12 篇

  • 51998

    網站

  • 12

    小程序

  • 1030137

    文章

  • 747

    會員

趕快注冊賬號，推廣您的網站吧！
最新入駐小程序

數獨大挑戰2018-06-03

數獨一種數學游戲，玩家需要根據9

答題星2018-06-03

您可以通過答題星輕松地創建試卷

全階人生考試2018-06-03

各種考試題，題庫，初中，高中，大學四六

運動步數有氧達人2018-06-03

記錄運動步數，積累氧氣值。還可偷

每日養生app2018-06-03

每日養生,天天健康

體育訓練成績評定2018-06-03

通用課目體育訓練成績評定