❶ 如何創建字典和給字典賦值
創建字典只需要把字典賦值給一個變數，不管這個字典是否包含元素：
>>> dict1 = {}
>>> dict2 = {'name': 'earth', 'port': 80}
>>> dict1, dict2
({}, {'port': 80, 'name': 'earth'})
從Python 2.2 版本起， 可以用工廠方法 dict() 來創建字典。 當我們詳細討論dict()的時候
會看到更多的例子，現在來看一個小例子：
>>> fdict = dict((['x', 1], ['y', 2]))
>>> fdict
{'y': 2, 'x': 1}
從Python 2.3 版本起, 可以用一個很方便的內建方法fromkeys() 來創建一個"默認"字典, 字
典中元素具有相同的值 (如果沒有給出， 默認為None):
>>> ddict = {}.fromkeys(('x', 'y'), -1)
>>> ddict
{'y': -1, 'x': -1}
>>>
>>> edict = {}.fromkeys(('foo', 'bar'))
>>> edict
{'foo': None, 'bar': None}
❷ python 列表內有字典怎麼使用
Python字典是另一種可變容器模型，且可存儲任意類型對象，如字元串、數字、元組等其他容器模型。
一、創建字典
字典由鍵和對應值成對組成。字典也被稱作關聯數組或哈希表。基本語法如下：
復制代碼代碼如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此創建字典：
復制代碼代碼如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
注意：
每個鍵與值用冒號隔開（:），每對用逗號，每對用逗號分割，整體放在花括弧中（{}）。
鍵必須獨一無二，但值則不必。
值可以取任何數據類型，但必須是不可變的，如字元串，數或元組。
二、訪問字典里的值
把相應的鍵放入熟悉的方括弧，如下實例:
復制代碼代碼如下:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
#以上實例輸出結果：
#dict['Name']: Zara
#dict['Age']: 7
如果用字典里沒有的鍵訪問數據，會輸出錯誤如下：
復制代碼代碼如下:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Alice']: ", dict['Alice'];
#以上實例輸出結果：
#dict['Zara']:
#Traceback (most recent call last):
# File "test.py", line 4, in <mole>
# print "dict['Alice']: ", dict['Alice'];
#KeyError: 'Alice'[/code]
三、修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:
復制代碼代碼如下:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#以上實例輸出結果：
#dict['Age']: 8
#dict['School']: DPS School
四、刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：
復制代碼代碼如下:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 刪除詞典
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#但這會引發一個異常，因為用del後字典不再存在：
dict['Age']:
#Traceback (most recent call last):
# File "test.py", line 8, in <mole>
# print "dict['Age']: ", dict['Age'];
#TypeError: 'type' object is unsubscriptable
五、字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，如下實例：
復制代碼代碼如下:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#dict['Name']: Manni
2）鍵必須不可變，所以可以用數，字元串或元組充當，所以用列表就不行，如下實例：
復制代碼代碼如下:
#!/usr/bin/python
dict = {['Name']: 'Zara', 'Age': 7};
print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#Traceback (most recent call last):
# File "test.py", line 3, in <mole>
# dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable
六、字典內置函數&方法
Python字典包含了以下內置函數：
1、cmp(dict1, dict2)：比較兩個字典元素。
2、len(dict)：計算字典元素個數，即鍵的總數。
3、str(dict)：輸出字典可列印的字元串表示。
4、type(variable)：返回輸入的變數類型，如果變數是字典就返回字典類型。
Python字典包含了以下內置方法：
1、radiansdict.clear()：刪除字典內所有元素
2、radiansdict.()：返回一個字典的淺復制
3、radiansdict.fromkeys()：創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
4、radiansdict.get(key, default=None)：返回指定鍵的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果鍵在字典dict里返回true，否則返回false
6、radiansdict.items()：以列表返回可遍歷的(鍵, 值) 元組數組
7、radiansdict.keys()：以列表返回一個字典所有的鍵
8、radiansdict.setdefault(key, default=None)：和get()類似, 但如果鍵不已經存在於字典中，將會添加鍵並將值設為default
9、radiansdict.update(dict2)：把字典dict2的鍵/值對更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值
❸ 在python中怎麼把列表中的元素添加到字典中
1、首先打開python的編輯器。
2、然後在文件中寫上程序的注釋。
3、新建一個字典，名字就叫cellphone。
4、然後為cellphone的字典里添加一個元素，cellphone["oppo"]=189。
5、然後將這個添加了新的內容之後的字典列印出來。
6、在窗口中選擇"run"->"run"。
7、運行這一個程序即可。
❹ python字典中如何創建字典
python---創建字典的方式
1、用{}創建字典
代碼：
x = {"a":"1", "b":"2"}
print x
輸出：
{'a': '1', 'b': '2'}
2、用內置函數dict()
(1)、入參為類似a="1"的鍵值對
代碼：
x = dict(a="1", b="2")
print x
輸出：
{'a': '1', 'b': '2'}
(2)、入參為一個元組，元組內部是一系列包含兩個值的元組，例如(("a", "1"), ("b", "2"))
代碼：
x = dict((("a", "1"), ("b", "2")))
print x
輸出
{'a': '1', 'b': '2'}
(3)、入參為一個元組，元組內部是一系列包含兩個值的列表，例如(["a", "1"], ["b", "2"])
代碼：
x = dict((["a", "1"], ["b", "2"]))
print x
輸出：
{'a': '1', 'b': '2'}
(4)、入參為一個列表，列表內部是一系列包含兩個值的元組，例如[("a", "1"),("b", "2")]
代碼：
x = dict([("a", "1"),("b", "2")])
print x
輸出：
{'a': '1', 'b': '2'}
(5)、入參為一個列表，列表內部是一系列包含兩個值的列表，例如[["a", "1"],["b", "2"]]
代碼：
x = dict([["a", "1"],["b", "2"]])
print x
輸出：
{'a': '1', 'b': '2'}
注意：
對於a="1"的方式初始化字典，字典的key只能為字元串，並且字元串不用加引號
對於dict內置函數初始化當入參是一個元組時，例如1)、2)，元組內部的兩元素元組或者列表至少為兩個，否則會出錯
3、用戶fromkeys方法創建字典
代碼：
dict.fromkeys(("a", "b"), 1)
print x
輸出：
{'a': 1, 'b': 1}
入參可以的第一個參數是一個列表或者元組，里邊的值為key，第二個參數是所有key的value值
❺ 數據結構/字典
1.dictionary字典，是除列表外python最靈活的內置數據結構類型，列表是有序的對象集合，字典是無序的對象集合。字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典用「{}」標識，字典由索引(key),和它對應的值value組成
字典是一種通過名字或者關鍵字引用的數據結構，其鍵可以是數字、字元串、元組，這種結構類型也稱之為映射。字典類型是Python中唯一內 建的映射類型，基本的操作包括如下：
(1)len()：返回字典中鍵—值對的數量；
(2)d[k]:返回關鍵字對於的值；
(3)d[k]=v:將值關聯到鍵值k上；
(4)del d[k]:刪除鍵值為k的項；
(5)key in d:鍵值key是否在d中，是返回True，否則返回False。
2.創建字典
字典由多個鍵及其對應值構成的鍵-值對組成，鍵與值之間用：隔開。
(1) dict1 = {} #創建一個空字典
dict2={'x':5, 'd':4, 's':'dd'} #創建字典 #注意，字典的鍵是唯一的，但值並不唯一
print dict2
運行輸出：{'x':5, 'd':4, 's':'dd'}
(2) dict函數（類型）
items = [('name', 'Gumby'), ('age', 42)]
dict3 =dict(items)
print dict3
運行輸出：{'age': 42, 'name': 'Gumby'} # 轉化為字典形式
(3)也可以通過關鍵字創建字典:
dict4 = dict(name = 'Gumby', age = 42)
print dict4
運行輸出：{'age': 42, 'name': 'Gumby'}
3.d['y'] 返回字典中『y』對應的值 type(y) 求字典的類型
len(c) 返回字典c中鍵值對的數量 print 'x' in d # true/False ，檢查'x'是否在字中， . 查找的是鍵而不是值
dict3 = {'x':4, 'adc':'wewe', 'a':'as'}
print dict3
print dict3['x']
print type(dict3)
print len(dict3)
print '5' in dict3
dict3['adc'] = 4 #將4賦值給adc
print dict3
del dict3['a'] #刪除鍵值為a的項
print dict3
運行輸出：
{'a': 'as', 'x': 4, 'adc': 'wewe'}
4
<type 'dict'>
3
False
{'a': 'as', 'x': 4, 'adc': 4}
{'x': 4, 'adc': 4}
4.字典的方法
(1) clear清除字典的項
d = {'x': 5, 'y': 6, 'z': 1, 'r': 12,'7' :4}
d.clear()
print d
運行後輸出：
{}
(2)formkeys 使用給定的鍵建立新的字典，每個鍵對應的默認值為None
c = {}
a = c.fromkeys(['s','b'])
print c # 仍是空字典
print a # 新的字典a
運行輸出;
{}
{'s': None, 'b': None}
(3)has_key 檢查字典中是否含有特定的鍵，d.has_key(k)相當於k in d
d = {'x': 5, 'y': 6, 'z': 1, 'r': 12,'7' :4}
print d.has_key('x')
print d.has_key('4')
運行輸出：
True
False
(4)get方法：get是個更寬松的訪問字典項的方法
d = {'x': 5, 'y': 6, 'z': 1, 'r': 12,'7' :4}
print d.get('x')
運行輸出：5
(5)方法：返回一個具有相同鍵—值對的新字典，這個方法的是淺復制
d = {'x': 5, 'y': 6, 'z': 1, 'r': 12,'7' :4}
s = d.()
print s
運行輸出：{'y': 6, 'x': 5, 'r': 12, 'z': 1, '7': 4}
(6)items方法將所有的字典項一列表方式返回，這些列表項中的每一項都來自於（鍵，值），但是項在返回時並沒有特殊的順序
d = {'x': 5, 'y': 6, 'z': 1, 'r': 12,'7' :4}
c = d.items()
print c
運行輸出：[('y', 6), ('x', 5), ('r', 12), ('z', 1), ('7', 4)]
Iteritems方法的作用大致相同，但是會返回一個迭代器對象而不是列表
(7)更多方法： http://blog.csdn.net/anhuixinhua66/article/details/49450537
❻ python內置數據類型列表list和字典dict的性能
我們來討論下python的兩種最重要的內置數據類型列表list和字典dict上，各種操作的復雜度。
list列表數據類型常用操作性能：
1、按索引取值和賦值（v=a[i]，a[i]=v）
由於列表的隨機訪問特性，這兩個操作執行時間與列表大小無關，均為O（1）
2、列表的曾長，可以選擇append()和_add_() "+"
list.append(v)的執行時間O(1)
list = list + [v]，執行時間是O(n+k)，因為新增了一個新的列表，其中k是被加的列表長度
舉例：4種生成前n個整數列表的方法
如圖：
我們可以計算一下這四個函數的耗時，如下
執行結果：
我們可以看到，4種方法運行時間差別很大，test1使用列表連接最慢，而test4使用list range最快，速度相差近200倍。
如下圖，我們總結下list基本操作的性能如何：
上圖可知pop()從列表末尾移除元素O(1),但是pop(i)從列表中間移除元素要O(n)，為什麼呢？
因為從中部移除元素，要把移除元素後面的元素全部向前挪一位，才保證了列表按索引取值和賦值很快，達到O(1)。
dict數據類型：
字典和列表不同，dict根據key找到value，而list根據index。
字典最常用的取值get和賦值set，其性能為O(1),而contain(in)操作判斷字典是否存在某個key，其性能也是O(1)
list和dict的in操作對比：
設計一個性能試驗，驗證list中檢索一個值，對比dict中檢索一個值的耗時對比。如下程序：
如果如下：
可見list的in操作復雜度為O(n)
PS：大家可以去python官方的演算法復雜度網站看看：
https://wiki.python.org/moin/TimeComplexity
❼ python字典如何添加字典
python字典添加字典的方法：
1、首先建立一個新的字典
2、調用updata（）函數，把新字典裡面的鍵值對更新到dict里
3、列印dict，字典添加成功。
結果如下
❽ 如何在Excel VBA中使用字典Dictionary對象
以下是 VBA 中使用字典 Dictionary 對象的用法示例：
Dimdict
'創建Dictionary
Setdict=CreateObject("Scripting.Dictionary")
'增加項目
dict.Add"A",300
dict.Add"B",400
dict.Add"C",500
'統計項目數
n=dict.Count
'刪除項目
dict.Remove("A")
'判斷字典中是否包含關鍵字
dict.exists("B")
'取關鍵字對應的值，注意在使用前需要判斷是否存在key，否則dict中會多出一條記錄
Value=dict.Item("B")
'修改關鍵字對應的值,如不存在則創建新的項目
dict.Item("B")=1000
dict.Item("D")=800
'對字典進行循環
k=dict.keys
v=dict.Items
Fori=0Todict.Count-1
key=k(i)
Value=v(i)
MsgBoxkey&Value
Next
'刪除所有項目
dict.Removeall
遍歷字典中的值
Dimkey
ForEachkeyIndict
msgboxdict(key)
Next
❾ python中字典的使用方法怎麼樣的
dict全稱dictionary，使用鍵-值（key-value）存儲，具有極快的查找速度。
舉個例子，假設要根據同學的名字查找對應的成績，如果用list實現，需要兩個list：
names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
給定一個名字，要查找對應的成績，就先要在names中找到對應的位置，再從scores取出對應的成績，list越長，耗時越長。
如果用dict實現，只需要一個「名字」-「成績」的對照表，直接根據名字查找成績，無論這個表有多大，查找速度都不會變慢。用Python寫一個dict如下：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
把數據放入dict的方法，除了初始化時指定外，還可以通過key放入：
>>> d['Adam'] = 67
>>> d['Adam']
67
由於一個key只能對應一個value，所以，多次對一個key放入value，後面的值會把前面的值沖掉：
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88
如果key不存在，dict就會報錯：
>>> d['Thomas']
Traceback (most recent call last):
File "", line 1, in KeyError: 'Thomas'
要避免key不存在的錯誤，有兩種辦法，一是通過in判斷key是否存在：
>>> 'Thomas' in dFalse
二是通過dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
要刪除一個key，用pop(key)方法，對應的value也會從dict中刪除：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
❿ Python.如何向字典dict里加入內容a
1、創建字典
dict={'d':1,'b':2,'c':3}
2、添加內容a
>>>dict['a']=500
>>>a
{'d':1,'b':2,'c':3,'a':500}『
python的設計哲學是「優雅」、「明確」、「簡單」。因此，Perl語言中「總是有多種方法來做同一件事」的理念在Python開發者中通常是難以忍受的。
Python開發者的哲學是「用一種方法，最好是只有一種方法來做一件事」。在設計Python語言時，如果面臨多種選擇，Python開發者一般會拒絕花俏的語法，而選擇明確的沒有或者很少有歧義的語法。
由於這種設計觀念的差異，Python源代碼通常被認為比Perl具備更好的可讀性，並且能夠支撐大規模的軟體開發。這些准則被稱為Python格言。在Python解釋器內運行import this可以獲得完整的列表。
(10)dict表字典如何否配置擴展閱讀：
PYTHON的特點
Python開發人員盡量避開不成熟或者不重要的優化。一些針對非重要部位的加快運行速度的補丁通常不會被合並到Python內。
所以很多人認為Python很慢。不過，根據二八定律，大多數程序對速度要求不高。在某些對運行速度要求很高的情況，Python設計師傾向於使用JIT技術，或者用使用C/C++語言改寫這部分程序。可用的JIT技術是PyPy。
Python是完全面向對象的語言。函數、模塊、數字、字元串都是對象。並且完全支持繼承、重載、派生、多繼承，有益於增強源代碼的復用性。
Python支持重載運算符和動態類型。相對於Lisp這種傳統的函數式編程語言，Python對函數式設計只提供了有限的支持。有兩個標准庫(functools, itertools)提供了Haskell和Standard ML中久經考驗的函數式程序設計工具。
雖然Python可能被粗略地分類為「腳本語言」（script language），但實際上一些大規模軟體開發計劃例如Zope、Mnet及BitTorrent，Google也廣泛地使用它。
Python的支持者較喜歡稱它為一種高級動態編程語言，原因是「腳本語言」泛指僅作簡單程序設計任務的語言，如shellscript、VBScript等只能處理簡單任務的編程語言，並不能與Python相提並論。
Python本身被設計為可擴充的。並非所有的特性和功能都集成到語言核心。Python提供了豐富的API和工具，以便程序員能夠輕松地使用C語言、C++、Cython來編寫擴充模塊。Python編譯器本身也可以被集成到其它需要腳本語言的程序內。
因此，很多人還把Python作為一種「膠水語言」（glue language）使用。使用Python將其他語言編寫的程序進行集成和封裝。在Google內部的很多項目，例如Google Engine使用C++編寫性能要求極高的部分，然後用Python或Java/Go調用相應的模塊。
《Python技術手冊》的作者馬特利（Alex Martelli）說：「這很難講，不過，2004 年，Python 已在Google內部使用，Google 召募許多 Python 高手，但在這之前就已決定使用Python，他們的目的是 Python where we can, C++ where we must，在操控硬體的場合使用 C++，在快速開發時候使用 Python。」
參考資料：python-語言參考