python字典去重

Ⅰ python如何列表去重取最大值

list=[('小王','第一次考試','5'),('小陳','第二次考試','7'),('小陳','第一次考試','1'),('小王','第六次考試','20')]

dic={}

list1=[]

forpersoninlist:

ifperson[0]notindic.keys():

dic[person[0]]=person

elifint(dic[person[0]][2])<int(person[2]):

dic[person[0]]=person

forvalueindic.values():

list1.append(value)

print(list1)

*.你看到的代碼應該是沒有縮進了，你可以右鍵>檢查，從相應的源碼中能看到相關的縮進

---------

稍等我給你寫下思路：

總體的思路就是動態的改變字典dic,字典中的鍵是tuple的第1個元素，即人名，相應的鍵值就是整個tuple,如dic={'小王':('小王','第一次考試','5')};而a.這個字典中的鍵值對是不斷增加的，b.鍵值是不斷改變的.這里的a,b兩點要怎麼理解呢?

先說a.這個字典中的鍵值對是不斷增加的?

比如說我一開始的字典是空的，然後我遍歷字典的時候，我會拿每次取到的列表中的元素(即元素)的第1個元素作為鍵，去dic中找，看看當前dic中是否有這個鍵，如果沒有，則我會在dic中新增一個鍵值對，這個鍵值對的鍵即tuple的第1個元素，相應的鍵值為整個tuple,舉例：

當前dic為{'小王':('小王','第一次考試','5')}，假如我遍歷到list中的第2個元素，即('小陳','第二次考試','7')，我會取這個tuple的第1個元素,即'小陳'，看看dic字典的鍵中是否有'小陳'，結果一看dic中只有一個鍵'小王'，沒有'小陳'，則我會在dic中新增一個鍵值對，最後得到新的dic:{'小王':('小王','第一次考試','5'),'小陳':('小陳','第二次考試','7')}.

再一看b點:鍵值是不斷變化的：

接上面說，此時字典dic的值為{'小王':('小王','第一次考試','5'),'小陳':('小陳','第二次考試','7')}，然後列表我遍歷到了第3個元素，即('小陳','第一次考試','1')。此時前面的處理邏輯還是一樣的，取tuple中的第1個元素去dic的鍵中找，看看是否存在，一找存在，字典dic中有'小陳'這個鍵了，則繼續第2步，用dic中'小陳'鍵值tuple中的第3個元素和當前從列表中取的第1個元素為'小陳'的tuple的第3個元素相比較，如果字典中的那個大，則字典中'小陳'的鍵值不變，如果從列表中拿到的這個tuple中第3個值大，則將字典中'小陳'的鍵值整個替換為從列表中取的這個當前tuple.

最終我們得到了一個鍵唯一，且相應鍵值為首個元素相同tuples中第3個值最大的這么一個字典。

因為你要求最終得到的類型是字典，所以接下來就是如果將這個字典dic轉化為你要的字典，dic.alues()得到的是dic中所有值的這么一個迭代器，然後使用for循環遍歷這個迭代器，把每次迭代器中取的值都追加到列表list1中。

最終列印的list1,符合題目要求

Ⅱ python去重（漢字一樣，裡面的編碼不一樣）

• 這是一個字元串的全形和半形的問題，可以導入unicodedata中的normalize函數先把全形轉換為半形，然後再用set對列表去重，參考代碼如下：

list3=['熱菜','凉菜','冷盤','硬菜']

set(map(lambdas:normalize('NFKC',s),list3))

輸出：

{'硬菜','熱菜','冷盤'}

• 擴展：

「NFKC」代表「NormalizationFormKC[CompatibilityDecomposition,]」，並將全形字元替換為半形字元，這些半形字元與Unicode等價。

Ⅲ python中對list去重的多種方法

python中對list去重的多種方法
今天遇到一個問題，在同事隨意的提示下，用了 itertools.groupby 這個函數。不過這個東西最終還是沒用上。
問題就是對一個list中的新聞id進行去重，去重之後要保證順序不變。
直觀方法
最簡單的思路就是：

這樣也可行，但是看起來不夠爽。

用set

另外一個解決方案就是用set：
代碼如下:

ids = [1,4,3,3,4,2,3,4,5,6,1]
ids = list(set(ids))

這樣的結果是沒有保持原來的順序。

按照索引再次排序

最後通過這種方式解決：
代碼如下:

ids = [1,4,3,3,4,2,3,4,5,6,1]
news_ids = list(set(ids))
news_ids.sort(ids.index)

使用itertools.grouby

文章一開始就提到itertools.grouby, 如果不考慮列表順序的話可用這個：
代碼如下:

ids = [1,4,3,3,4,2,3,4,5,6,1]
ids.sort()
it = itertools.groupby(ids)

for k, g in it:
print k

關於itertools.groupby的原理可以看這里：http://docs.python.org/2/library/itertools.html#itertools.groupby

網友補充：用rece

網友reatlk留言給了另外的解決方案。我補充並解釋到這里：
代碼如下:

In [5]: ids = [1,4,3,3,4,2,3,4,5,6,1]

In [6]: func = lambda x,y:x if y in x else x + [y]

In [7]: rece(func, [[], ] + ids)
Out[7]: [1, 4, 3, 2, 5, 6]

上面是我在ipython中運行的代碼，其中的 lambda x,y:x if y in x else x + [y] 等價於 lambda x,y: y in x and x or x+[y] 。

Ⅳ Python中字典為什麼比列錶快

1、為什麼Python中字典比列錶快？
因為字典中是鍵-值對（key-value），且字典無順序、自動去重、佔用內存多，用內存換取速度。最重要的是因為字典是hash類型的。
2、那什麼是hash呢？
哈希演算法將任意長度的二進制值映射為較短的固定長度的二進制值，這個小的二進制值稱為哈希值。哈希值是一段數據唯一且極其緊湊的數值表示形式。
如果散列一段明文而且哪怕只更改該段落的一個字母，隨後的哈希都將產生不同的值。要找到散列為同一個值的兩個不同的輸入，在計算上是不可能的，所以數據的哈希值可以檢驗數據的完整性。一般用於快速查找和加密演算法。
3、dict會把所有的key變成hash 表，然後將這個表進行排序。
你通過data[key]去查data字典中一個key的時候，python會先把這個key hash成一個數字，然後拿這個數字到hash表中看沒有這個數字， 如果有，拿到這個key在hash表中的索引，拿到這個索引去與此key對應的value的內存地址那取值就可以了。

Ⅳ python如何實現列表嵌套字典，字典內相同key去重，字典內另外一個key的value相加

按照你的要求編寫的字典內相同key合並的Python程序如下

l=[{'a':1,'b':'haha'},{'a':3,'b':'haha'},{'a':2,'b':'xiaoming'}]

result=[]

temp=[]

for i in range(len(l)):

flag=False

suma=l[i]['a']

b=l[i]['b']

for j in range(i+1,len(l)):

if l[i]['b']==l[j]['b'] and (j not in temp):

flag=True

temp.append(i)

temp.append(j)

suma=suma+l[j]['a']

if i not in temp or flag==True:

result.append({'a':suma,'b':b})

print(result)

源代碼(注意源代碼的縮進)

Ⅵ 求教， Python 怎麼去掉重復的詞， 下面有例子。

1.如果你的txt 文件不大的話 可以直接 tmp = open('**.txt').readlines() #把內容一次性全部讀取出來 是一個列表set(tmp) #這個就是把列表 去重復 然後 你可以把 這個去重後的tmp 寫入到新的文件2.txt很大，那麼只能一行一行的讀取去重了#!/usr/bin/env python# coding=utf-8# python 2.7outfile = open('result-readline.txt', 'w') #新的文件list_1=[]for line in open('test.txt'): #老文件 tmp = line.strip() if tmp not in list_1: list_1.append(tmp) outfile.write(line)outfile.close()

Ⅶ Python數字列表去重，如何簡單的既去重還能按原來的順序輸出

Python數字列表去重,還能按原來的順序輸出.

第一種方法

alist = [1, 2, 2, 4, 4, 6, 7]

b = []

for i in alist:

if i not in b:

b.append(i)

print(b)

源代碼(注意源代碼的縮進)

Ⅷ python常見數據類型

一,python整數類型所表示的數據。

1,一般用以表示一類數值:所有正整數,0和負整數;

2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。

3,bool型繼承了int型，他是int的子類。

4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。

5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。

6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)

二，python整數和浮點型支持常規的數值運算

整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）

Python字元型：

python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True

二, 字元串支持的運算方法

1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd

2,casefold() lower():字母轉換為全小寫

3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元

a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格

4,count(sub,star,end) :字母計數：sub要查詢的字元

5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼

Errors :設置錯誤類型

6,endswith(suffix,star,end) : 若以suffix結尾返回True

7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』

8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1

9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常

10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合

11，isalpha() :判斷是否全是字母

12，isdecimal() :判斷字元串是否是十進制數值

13，isdigit() :判斷字元串是否是數字

14，isidentifier() :判斷字元串中是否包含關鍵字

15，islower() :判斷是否全小寫

16，isnumeric() :判斷全是數字

17，isspace() :判斷是否是空格

18，isupper() 判斷是否大寫

19，istitle() :判斷是否首字母大寫

20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)

21,ljust(width,fillchar);rjust() :左對齊右對齊

22, upper() :將字元串改為大寫

23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除

『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]

三，字元串格式化：按照規格輸出字元串

format(*args,**kwargs) :args位置參數，kwargs關鍵字參數

『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入

四，字元串操作符%

1，%s :格式化字元串 『abcd%sdef』%』dddd』

2，%d:格式化整數

3，%o格式化無符號八進制

4，%x格式化無符號十六進制

5，%f格式化定點數

6, %e: 科學計數法格式化定點數

7，%g 根據值大小自動選%f,%e

8, %G E X :大寫形式

五，格式化輔助命令：

m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789

六，轉義字元：字元串前r避免轉義：r』\nhello\thi』

\n:換行符

\t:橫向製表符

\':'

\":"

\b:退格符

\r:回車

\v:縱向製表符

\f:換頁符

\o,\x:八進制和十六進制

\0:空字元串

Python列表list

一，Python的列表list類型表示的數據：

Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。

列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)

2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素

remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)

8, 淺拷貝一個新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默認升序

排序函數：sorted(list)

10，reverse: 原地翻轉：list.reverse()

11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)

列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新列表：l1+ l2

3, 重復操作符：* ,多個列表拼接

成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序

Python元組tuple

一，Python元組tuple數據類型表示的數據：

元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元組常用方法

1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)

2,count(value) ：值出現次數

三，支持運算：

1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新元組：l1+ l2

3, 重復操作符：* ,多個元組拼接

4成員關系操作符：in/ not in

邏輯運算符：and not or
四，元組的訪問

下標操作；
For循環遍歷訪問。

Python字典類型

一,Python字典dict表示的數據：{key:value}

可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的訪問：

通過key：k[『key』]

修改key對應的值：K[『key』] = value

For循環遍歷出來的是key；

For循環鍵值對：for I in d.items():

For 循環enumerate: for k,v in enumerate(k1):

In/not in 成員關系查詢鍵不支持查值

三，字典常用方法

get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在則生成一個鍵值對

k.setdefault(『keyword』)

Python 集合set

集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復

常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象

Frozenset(iterable):

S = frozenset(iterable)

Python序列類型共同特性

一,序列類型共同特性

python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：

len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]

sorted(s,key=lambda s:s[1]) //按照數字排序

reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列類型的切片操作：

Slice:

L[index]; 訪問某個元素；

L[1:4]; 區間

L[star:stop:step]; 設置步長取區間元素

Ⅸ python中列表如何去重

可以利用set去重

代碼如下:

#coding=utf-8

li=[1,2,3,4,2,1,3,0]#列表
li2=set(li)
print(li2)

Ⅹ python列表裡的字典元素合並去重

b={}
fordicin[each.items()foreachina]:
forkey,valueindic:
b[key]=value