pythonsettodict

Ⅰ python dict怎麼實現的

Python中dict對象是表明了其是一個原始的Python數據類型，按照鍵值對的方式存儲，其中文名字翻譯為字典，顧名思義其通過鍵名查找對應的值會有很高的效率，時間復雜度在常數級別O(1).dict底層實現（推薦學習：Python視頻教程）
在Python2中，dict的底層是依靠哈希表(Hash Table)進行實現的，使用開放地址法解決沖突.
所以其查找的時間復雜度會是O(1).
Dict的操作實現原理（包括插入、刪除、以及緩沖池等）
首先介紹：PyDictObject對象的元素搜索策略：
有兩種搜索策略，分別是lookdict和lookdict_string，lookdict_string就是lookdict在對於PyStringObject進行搜索時的特殊形式，那麼通用的搜索策略lookdict的主要邏輯是：
（1）對第一個entry的查找：
a)根據hash值獲得entry的索引
b)若entry處於unused態，則搜索結束；若entry所指向的key與搜索的key相同，則搜索成功
c)若當前entry處於mmy態，則設置freeslot（這里的freeslot是可以返回作為下一個立即可用的地址來存儲entry）
d)檢查Active態的entry，若其key所指向的值與搜索的值相同，則搜索成功
（2）對剩餘的探測鏈中的元素的遍歷查找：
a)根據所採用的探測函數，獲得探測鏈上的下一個待檢查的entry
b)檢查到一個unused態的entry，表明搜索失敗：
如果freeslot不為空，則返回freeslot；否則返回unused態的entry
c)檢查entry的key與所搜索的key的引用是否相同，相同則搜索成功，返回entry
d)檢查entry的key與所搜索的key的值是否相同，相同則搜索成功，返回entry
e)遍歷過程中，發現mmy態的entry，且freeslot未設置，則設置freeslot
接下來是：PyDictObject對象的元素插入與刪除的策略：
需要首先用到搜索策略，搜索成功，則直接將值進行替換，搜索失敗，返回unused態或mmy態的entry，設置key、value和hash值，並且根據目前插入的元素情況進行ma_table的大小的調整（調整的依據就是裝載率，根據是否大於2/3來進行調整）；刪除也是類似，先計算hash值，然後搜索相應的entry，搜索成功，刪除entry中維護的元素，將entry從Active態修改為mmy態

在PyDictObject的實現過程中，會用到緩沖池，在PyDictObject對象被銷毀的時候，才開始接納被緩沖的PyDictObject對象，定義的緩沖池可接納的對象數量是80個，創建新PyDictObject對象的時候，如果緩沖池中有，則可以直接從緩沖池中取出使用
更多Python相關技術文章，請訪問Python教程欄目進行學習！以上就是小編分享的關於python dict怎麼實現的的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！

Ⅱ Python 簡明教程 ---13，Python 集合

目錄

前幾節我們已經介紹了Python 中的 列表list ， 元組tuple 和 字典dict ，本節來介紹Python 中的最後一種數據結構—— 集合set 。

Python 中的 set 與 dict 很像，唯一的不同是， dict 中保存的是 鍵值對 ，而 set 中只保存 鍵 ，沒有 值 。

Python 集合 有如下特點：

Python 集合的聲明有兩種方式：

創建 空集合 時，只能用 set() ，而不能用 {} ：

創建 非空集合 時，可以用 set() ，也可以用 {} ：

由於集合中的元素是唯一的，如果初始化時的 可迭代 數據中有重復的元素，則會自動刪去重復的元素：

使用 len() 函數可以查看集合中元素的個數：

由於Python 集合中的元素的是無序的，所以可不能使用 下標 的方式來訪問集合中的單個元素。

我們可以使用 for 循環 來遍歷集合中的所有元素：

我們可以對兩個集合進行如下運算：

交集與並集

in 運算

使用 dir(set) 查看集合支持的所有方法：

下面一一介紹這些 非魔法方法 ，共17 個。

1. add 方法

由於集合中的元素是唯一的，向集合中添加元素時有兩種情況：

示例：

2. remove 方法

示例：

3. discard 方法

示例：

4. pop 方法

示例：

5. union 方法

示例：

6. update 方法

示例：

7. clear 方法

示例：

8. 方法

示例：

9. difference 方法

示例：

10. difference_update 方法

示例：

11. intersection 方法

示例：

12. intersection_update 方法

示例：

13. isdisjoint 方法

示例：

14. issubset 方法

示例：

15. issuperset 方法

示例：

16. symmetric_difference 方法

示例：

17. symmetric_difference_update 方法

示例：

（完。）

推薦閱讀：

Python 簡明教程 --- 8，Python 字元串函數
Python 簡明教程 --- 9，Python 編碼
Python 簡明教程 ---10，Python 列表
Python 簡明教程 ---11，Python 元組
Python 簡明教程 ---12，Python 字典

Ⅲ python 中如何將一個list 轉成dict，且將第一個元素作為key,而後四個作為value

mylist=[]
forainrange(0,10000):
	mylist.append((a,a+1,a+2,a+3,a+4))

myDict={}
forkeyinmylist:
	myDict[key[0]]=key[1:]

printmyDict

Ⅳ python 怎麼將字元轉成dict

str_='''{'a':1,'b':2}'''
printtype(str_)
str_to_dict=eval(str_)#使用eval函數直接轉成dict，同樣適用於數組元組。
printtype(str_to_dict)

Ⅳ Python中內置數據類型list，tuple，dict，set的區別和用法

這篇文章主要給大家介紹了Python中內置數據類型list,tuple,dict,set的區別和用法，都是非常基礎的知識，十分的細致全面，有需要的小夥伴可以參考下。

Python語言簡潔明了，可以用較少的代碼實現同樣的功能。這其中Python的四個內置數據類型功不可沒，他們即是list, tuple, dict, set。這里對他們進行一個簡明的總結。
List
字面意思就是一個集合，在Python中List中的元素用中括弧[]來表示，可以這樣定義一個List:
L = [12, 'China', 19.998]

可以看到並不要求元素的類型都是一樣的。當然也可以定義一個空的List:
L = []

Python中的List是有序的，所以要訪問List的話顯然要通過序號來訪問，就像是數組的下標一樣，一樣是下標從0開始：
>>> print L[0]
12

千萬不要越界，否則會報錯
>>> print L[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
IndexError: list index out of range

List也可以倒序訪問，通過「倒數第x個」這樣的下標來表示序號，比如-1這個下標就表示倒數第一個元素：
>>> L = [12, 'China', 19.998]
>>> print L[-1]
19.998

-4的話顯然就越界了
>>> print L[-4]

Traceback (most recent call last):
File "<pyshell#2>", line 1, in <mole>
print L[-4]
IndexError: list index out of range
>>>

List通過內置的append()方法來添加到尾部，通過insert()方法添加到指定位置（下標從0開始）：
>>> L = [12, 'China', 19.998]
>>> L.append('Jack')
>>> print L
[12, 'China', 19.998, 'Jack']
>>> L.insert(1, 3.14)
>>> print L
[12, 3.14, 'China', 19.998, 'Jack']
>>>

通過pop()刪除最後尾部元素，也可以指定一參數刪除指定位置：
>>> L.pop()
'Jack'
>>> print L
[12, 3.14, 'China', 19.998]
>>> L.pop(0)
12
>>> print L
[3.14, 'China', 19.998]

也可以通過下標進行復制替換
>>> L[1] = 'America'
>>> print L
[3.14, 'America', 19.998]

Tuple
Tuple可以看做是一種「不變」的List，訪問也是通過下標，用小括弧（）表示：
>>> t = (3.14, 'China', 'Jason')
>>> print t
(3.14, 'China', 'Jason')

但是不能重新賦值替換：
>>> t[1] = 'America'

Traceback (most recent call last):
File "<pyshell#21>", line 1, in <mole>
t[1] = 'America'
TypeError: 'tuple' object does not support item assignment

也沒有pop和insert、append方法。
可以創建空元素的tuple:
t = ()
或者單元素tuple (比如加一個逗號防止和聲明一個整形歧義):
t = (3.14,)
那麼tuple這個類型到底有什麼用處呢？要知道如果你希望一個函數返回多個返回值，其實只要返回一個tuple就可以了，因為tuple裡面的含有多個值，而且是不可變的（就像是java裡面的final）。當然，tuple也是可變的，比如:
>>> t = (3.14, 'China', 'Jason', ['A', 'B'])
>>> print t
(3.14, 'China', 'Jason', ['A', 'B'])
>>> L = t[3]
>>> L[0] = 122
>>> L[1] = 233
>>> print t
(3.14, 'China', 'Jason', [122, 233])

這是因為Tuple所謂的不可變指的是指向的位置不可變，因為本例子中第四個元素並不是基本類型，而是一個List類型，所以t指向的該List的位置是不變的，但是List本身的內容是可以變化的，因為List本身在內存中的分配並不是連續的。
Dict
Dict是Python中非常重要的數據類型，就像它的字面意思一樣，它是個活字典，其實就是Key-Value鍵值對，類似於HashMap，可以用花括弧{}通過類似於定義一個C語言的結構體那樣去定義它：
>>> d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59,
'Paul': 75
}
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

可以看到列印出來的結果都是Key:Value的格式，可以通過len函數計算它的長度（List，tuple也可以）：
>>> len(d)
4
可以直接通過鍵值對方式添加dict中的元素：
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
>>> d['Jone'] = 99
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下標來訪問內容，而Dict用Key來訪問： (字元串、整型、浮點型和元組tuple都可以作為dict的key)
>>> print d['Adam']
95

如果Key不存在，會報錯：
>>> print d['Jack']

Traceback (most recent call last):
File "<pyshell#40>", line 1, in <mole>
print d['Jack']
KeyError: 'Jack'

所以訪問之前最好先查詢下key是否存在：
>>> if 'Adam' in d : print 'exist key'

exist key

或者直接用保險的get方法：
>>> print d.get('Adam')
95
>>> print d.get('Jason')
None

至於遍歷一個dict，實際上是在遍歷它的所有的Key的集合，然後用這個Key來獲得對應的Value:
>>> for key in d : print key, ':', d.get(key)

Lisa : 85
Paul : 75
Adam : 95
Bart : 59

Dict具有一些特點：
查找速度快。無論是10個還是10萬個，速度都是一樣的，但是代價是耗費的內存大。List相反，佔用內存小，但是查找速度慢。這就好比是數組和鏈表的區別，數組並不知道要開辟多少空間，所以往往開始就會開辟一個大空間，但是直接通過下標查找速度快；而鏈表佔用的空間小，但是查找的時候必須順序的遍歷導致速度很慢
沒有順序。Dict是無順序的，而List是有序的集合，所以不能用Dict來存儲有序集合
Key不可變，Value可變。一旦一個鍵值對加入dict後，它對應的key就不能再變了，但是Value是可以變化的。所以List不可以當做Dict的Key，但是可以作為Value:

>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}
>>> d['NewList'] = [12, 23, 'Jack']
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}

Key不可重復。（下面例子中添加了一個'Jone':0，但是實際上原來已經有'Jone'這個Key了，所以僅僅是改了原來的value）

>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}
>>> d['Jone'] = 0
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}

Dict的合並，如何將兩個Dict合並為一個，可以用dict函數：
>>> d1 = {'mike':12, 'jack':19}
>>> d2 = {'jone':22, 'ivy':17}
>>> dMerge = dict(d1.items() + d2.items())
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

或者
>>> dMerge2 = dict(d1, **d2)
>>> print dMerge2
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

方法2比方法1速度快很多，方法2等同於：
>>> dMerge3 = dict(d1)
>>> dMerge3.update(d2)
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

set
set就像是把Dict中的key抽出來了一樣，類似於一個List，但是內容又不能重復，通過調用set()方法創建：
>>> s = set(['A', 'B', 'C'])
就像dict是無序的一樣，set也是無序的，也不能包含重復的元素。
對於訪問一個set的意義就僅僅在於查看某個元素是否在這個集合裡面：
>>> print 'A' in s
True
>>> print 'D' in s
False

大小寫是敏感的。
也通過for來遍歷：
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
#tuple
for x in s:
print x[0],':',x[1]

>>>
Lisa : 85
Adam : 95
Bart : 59

通過add和remove來添加、刪除元素（保持不重復），添加元素時，用set的add()方法：
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])

如果添加的元素已經存在於set中，add()不會報錯，但是不會加進去了：
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])

刪除set中的元素時，用set的remove()方法：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])

如果刪除的元素不存在set中，remove()會報錯：
>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
KeyError: 4

所以如果我們要判斷一個元素是否在一些不同的條件內符合，用set是最好的選擇，下面例子：
months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec',])
x1 = 'Feb'
x2 = 'Sun'

if x1 in months:
print 'x1: ok'
else:
print 'x1: error'

if x2 in months:
print 'x2: ok'
else:
print 'x2: error'

>>>
x1: ok
x2: error