pythondictionary添加

㈠ python中如何動態往列表中添加字典

>>>keys=['a','b','c']
>>>values=[1,2,3]
>>>dictionary=dict(zip(keys,values))
>>>print(dictionary)
{'a':1,'b':2,'c':3}

㈡ python字典如何添加字典

python字典添加字典的方法：
1、首先建立一個新的字典
2、調用updata（）函數，把新字典裡面的鍵值對更新到dict里
3、列印dict，字典添加成功。
結果如下

㈢ python 怎麼給字典添加一對值

如果只是添加一次，
>>>
l
=
['01',
'張三']
>>>
dic
=
{}
>>>
dic[l[0]]
=
l[1]
如果有大量的這種二元列表要添加到字典中，那麼
>>>
data
=
[['01',
'張三'],
['02',
'李四'],
['03',
'None']]
>>>
dic
=
dict(data)
輸入
>>>help(dict)
可以看到如下解釋：
dict(iterable)
->
new
dictionary
initialized
as
if
via:
|
d
=
{}
|
for
k,
v
in
iterable:
|
d[k]
=
v
傳入參數是二元可迭代對象(二元元組、列表等)時，形成對應鍵值對

㈣ python如何往空字典添加鍵值對

題主你好,

看例子吧:

我先定義一個空字典dic:

dic = {}

向字典中添加鍵值對是通過:

字典名['鍵名'] = '值'

這種形式, 下面我向字典中添加一個鍵為'name', 值為'hello kitty'的這么一個鍵值對:

dic['name'] = 'hello kitty'

此時字典dic的值就內{}, 變為了{'name': 'hello kitty'}

---

測試截圖:

希望可以幫到題主, 歡迎追問

㈤ python 在字典里添加元素的問題

因為你在while循環裡面，每次循環都重新定義了這個list1，把list1放循環外面就能滿足你的要求

㈥ 如何成功地使用 dictionary

本文研究 Python 類型層次結構並介紹 dictionary 容器類型。與前面文章中討論的 Python tuple、string 和 list 容器類型不同，dictionary 類型是一個無序的容器，依賴於鍵-值映射。因此，要根據鍵值訪問 dictionary 中的元素，而不是根據它們在序列中的位置。dictionary 類型的獨特特性看起來可能不同尋常，但是如果使用得當，它們可以提供強大的能力。

dictionary

我們都曾經使用過語言詞典來查找不認識的單詞的定義。語言詞典針對給定的單詞（比如 python）提供一組標準的信息。這種系統將定義和其他信息與實際的單詞關聯（映射）起來。使用單詞作為鍵定位器來尋找感興趣的信息。這種概念延伸到 Python 編程語言中，就成了特殊的容器類型，稱為 dictionary。

dictionary 數據類型在許多語言中都存在。它有時候稱為關聯 數組（因為數據與一個鍵值相關聯），或者作為散列表。但是在 Python 中，dictionary 是一個很好的對象，因此即使是編程新手也很容易在自己的程序中使用它。按照正式的說法，Python 中的 dictionary 是一種異構的、易變的映射容器數據類型。

創建 dictionary

本系列中前面的文章介紹了 Python 編程語言中的一些容器數據類型，包括 tuple、string 和 list（參見 參考資料）。這些容器的相似之處是它們都是基於序列的。這意味著要根據元素在序列中的位置訪問這些集合中的元素。所以，給定一個名為 a 的序列，就可以使用數字索引（比如 a[0] ）或片段（比如 a[1:5]）來訪問元素。Python 中的 dictionary 容器類型與這三種容器類型的不同之處在於，它是一個無序的集合。不是按照索引號，而是使用鍵值來訪問集合中的元素。這意味著構造 dictionary 容器比 tuple、string 或 list 要復雜一些，因為必須同時提供鍵和相應的值，如清單 1 所示。

清單 1. 在 Python 中創建 dictionary，第 1 部分

>>> d = {0: 『zero』, 1: 『one』, 2 : 『two』, 3 : 『three』, 4 : 『four』, 5: 『five』}
>>> d
{0: 『zero』, 1: 『one』, 2: 『two』, 3: 『three』, 4: 『four』, 5: 『five』}
>>> len(d)
>>> type(d) # Base object is the dict class
<type 『dict』>
>>> d = {} # Create an empty dictionary
>>> len(d)
>>> d = {1 : 『one』} # Create a single item dictionary
>>> d
{1: 『one』}
>>> len(d)
>>> d = {『one』 : 1} # The key value can be non-numeric
>>> d
{『one』: 1}
>>> d = {『one』: [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]}
>>> d
{『one』: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
復制代碼

如這個例子所示，在 Python 中創建 dictionary 要使用花括弧和以冒號分隔的鍵-值組合。如果沒有提供鍵-值組合，那麼就會創建一個空的 dictionary。使用一個鍵-值組合，就會創建具有一個元素的 dictionary，以此類推，直至您需要的任何規模。與任何容器類型一樣，可以使用內置的 len 方法查明集合中元素的數量。

前面的示例還演示了關於 dictionary 容器的另一個重要問題。鍵並不限制為整數；它可以是任何不易變的數據類型，包括 integer、float、tuple 或 string。因為 list 是易變的，所以它不能作為 dictionary 中的鍵。但是 dictionary 中的值可以是任何數據類型的。

最後，這個示例說明了 Python 中 dictionary 的底層數據類型是 dict 對象。要進一步了解如何使用 Python 中的 dictionary，可以使用內置的幫助解釋器來了解 dict 類，如清單 2 所示。

清單 2. 獲得關於 dictionary 的幫助

>>> help(dict)on class dict in mole __builtin__:
dict(object)
| dict() -> new empty dictionary.
| dict(mapping) -> new dictionary initialized from a mapping object』s
| (key, value) pairs.
| dict(seq) -> new dictionary initialized as if via:
| d = {}
| for k, v in seq：
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __cmp__(…)
| x.__cmp__(y) <==> cmp(x,y)
|
| __contains__(…)
| x.__contains__(y) <==> y in x
|
| __delitem__(…)
| x.__delitem__(y) <==> del x[y]
…[/code]關於 dict 類的幫助指出，可以使用構造函數直接創建 dictionary，而不使用花括弧。既然與其他容器數據類型相比，在創建 dictionary 時必須提供更多的數據，那麼這些創建方法比較復雜也就不足為奇了。但是，在實踐中使用 dictionary 並不難，如清單 3 所示。

清單 3. 在 Python 中創建 dictionary，第 2 部分

>>> l = [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]
>>> d = dict(l)(most recent call last):
File "<stdin>", line 1, in ?: can't convert dictionary
update sequence element #0 to a sequence
>>> l = [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> l = [[0, 'zero'], [1, 'one'], [2, 'two'], [3, 'three']]
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(zero=0, one=1, two=2, three=3)
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d = dict(0=zero, 1=one, 2=two, 3=three): keyword can't be an expression
復制代碼

可以看到，創建 dictionary 需要鍵值和數據值。第一次從 list 創建 dictionary 的嘗試失敗了，這是因為沒有匹配的鍵-數據值對。第二個和第三個示例演示了如何正確地創建 dictionary：在第一種情況下，使用一個 list，其中的每個元素都是一個 tuple；在第二種情況下，也使用一個 list，但是其中的每個元素是另一個 list。在這兩種情況下，內層容器都用於獲得鍵到數據值的映射。

直接創建 dict 容器的另一個方法是直接提供鍵到數據值的映射。這種技術允許顯式地定義鍵和與其對應的值。這個方法其實用處不大，因為可以使用花括弧完成相同的任務。另外，如前面的例子所示，在採用這種方式時對於鍵不能使用數字，否則會導致拋出一個異常。

訪問和修改 dictionary

創建了 dictionary 之後，需要訪問其中包含的數據。訪問方式與訪問任何 Python 容器數據類型中的數據相似，如清單 4 所示。

清單 4. 訪問 dictionary 中的元素

>>> d = dict(zero=0, one=1, two=2, three=3)
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d['zero']
>>> d['three']
>>> d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
>>> d[0]
'zero'
>>> d[4]
'four'
>>> d[6](most recent call last):
File "<stdin>", line 1, in ?: 6
>>> d[:-1](most recent call last):
File "<stdin>", line 1, in ?: unhashable type
復制代碼

可以看到，從 dictionary 中獲取數據值的過程幾乎與從任何容器類型中獲取數據完全一樣。在容器名後面的方括弧中放上鍵值。當然，dictionary 可以具有非數字的鍵值，如果您以前沒有使用過這種數據類型，那麼適應這一點需要些時間。因為在 dictionary 中次序是不重要的（dictionary 中數據的次序是任意的），所以可以對其他容器數據類型使用的片段功能，對於 dictionary 是不可用的。試圖使用片段或者試圖從不存在的鍵訪問數據就會拋出異常，指出相關的錯誤。

Python 中的 dictionary 容器也是易變的數據類型，這意味著在創建它之後可以修改它。如清單 5 所示，可以添加新的鍵到數據值的映射，可以修改現有的映射，還可以刪除映射。

清單 5. 修改 dictionary

>>> d = {0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[0]
'zero'
>>> d[0] = 'Zero'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[4] = 'four'
>>> d[5] = 'five'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> del d[0]
>>> d
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> d[0] = 'zero'
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
復制代碼

清單 5 演示了幾個重點。首先，修改數據值是很簡單的：將新的值分配給適當的鍵。其次，添加新的鍵到數據值的映射也很簡單：將相關數據分配給新的鍵值。Python 自動進行所有處理。不需要調用 append 這樣的特殊方法。對於 dictionary 容器，次序是不重要的，所以這應該好理解，因為不是在 dictionary 後面附加映射，而是將它添加到容器中。最後，刪除映射的辦法是使用 del 操作符以及應該從容器中刪除的鍵。

在清單 5 中有一個情況看起來有點兒怪，鍵值是按照數字次序顯示的，而且這個次序與插入映射的次序相同。不要誤解 —— 情況不總是這樣的。Python dictionary 中映射的次序是任意的，對於不同的 Python 安裝可能會有變化，甚至多次使用同一 Python 解釋器運行相同代碼也會有變化。如果在一個 dictionary 中使用不同類型的鍵和數據值，那麼就很容易看出這一點，如清單 6 所示。

清單 6. 異構的容器

>>> d = {0: 'zero', 'one': 1}
>>> d
{0: 'zero', 'one': 1}
>>> d[0]
'zero'
>>> type(d[0])
<type 'str'>
>>> d['one']
>>> type(d['one'])
<type 'int'>
>>> d['two'] = [0, 1, 2]
>>> d
{0: 'zero', 'two': [0, 1, 2], 'one': 1}
>>> d[3] = (0, 1, 2, 3)
>>> d
{0: 'zero', 3: (0, 1, 2, 3), 'two': [0, 1, 2], 'one': 1}
>>> d[3] = 'a tuple'
>>> d
{0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
復制代碼

如這個例子所示，可以在一個 dictionary 中使用不同數據類型的鍵和數據值。還可以通過修改 dictionary 添加新的類型。最後，產生的 dictionary 的次序並不與插入數據的次序匹配。本質上，dictionary 中元素的次序是由 Python dictionary 數據類型的實際實現控制的。新的 Python 解釋器很容易改變這一次序，所以一定不要依賴於元素在 dictionary 中的特定次序。

用 dictionary 進行編程

作為正式的 Python 數據類型，dictionary 支持其他較簡單數據類型所支持的大多數操作。這些操作包括一般的關系操作符，比如 <、> 和 ==，如清單 7 所示。

清單 7. 一般關系操作符

>>> d1 = {0: 'zero'}
>>> d2 = {'zero':0}
>>> d1 < d2
>>> d2 = d1
>>> d1 < d2
>>> d1 == d2
>>> id(d1)
>>> id(d2)
>>> d2 = d1.()
>>> d1 == d2
>>> id(d1)
>>> id(d2)
復制代碼

前面的示例創建兩個 dictionary 並使用它們測試 < 關系操作符。盡管很少以這種方式比較兩個 dictionary；但是如果需要，可以這樣做。

然後，這個示例將賦值給變數 d1 的 dictionary 賦值給另一個變數 d2。注意，內置的 id() 方法對於 d1 和 d2 返回相同的標識符值，這說明這不是復制操作。要想復制 dictionary ，可以使用 () 方法。從這個示例中的最後幾行可以看出，副本與原來的 dictionary 完全相同，但是容納這個 dictionary 的變數具有不同的標識符。

在 Python 程序中使用 dictionary 時，很可能希望檢查 dictionary 中是否包含特定的鍵或值。如清單 8 所示，這些檢查很容易執行。

清單 8. 條件測試和 dictionary

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> d.keys()
[0, 3, 'two', 'one']
>>> if 0 in d.keys():
... print 'True'
...
>>> if 'one' in d:
... print 'True'
...
>>> if 'four' in d:
... print 'Dictionary contains four'
... elif 'two' in d:
... print 'Dictionary contains two'
... contains two
復制代碼

測試 dictionary 中鍵或數據值的成員關系是很簡單的。dictionary 容器數據類型提供幾個內置方法，包括 keys() 方法和 values() 方法（這里沒有演示）。這些方法返回一個列表，其中分別包含進行調用的 dictionary 中的鍵或數據值。

因此，要判斷某個值是否是 dictionary 中的鍵，應該使用 in 操作符檢查這個值是否在調用 keys() 方法所返回的鍵值列表中。可以使用相似的操作檢查某個值是否在調用 values() 方法所返回的數據值列表中。但是，可以使用 dictionary 名作為簡寫表示法。這是有意義的，因為一般希望知道某個數據值（而不是鍵值）是否在 dictionary 中。

在 「Discover Python, Part 6」 中，您看到了使用 for 循環遍歷容器中的元素是多麼容易。同樣的技術也適用於 Python dictionary，如清單 9 所示。

清單 9. 迭代和 dictionary

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> for k in d.iterkeys():
... print d[k]
... tuple
[0, 1, 2]
>>> for v in d.itervalues():
... print v
... tuple
[0, 1, 2]
>>> for k, v in d.iteritems():
... print 'd[',k,'] = ',v
... [ 0 ] = zero[ 3 ] = a tuple[ two ] = [0, 1, 2][ one ] = 1
復制代碼

這個示例演示了遍歷 dictionary 的三種方式：使用從 iterkeys()、itervalues() 或 iteritems() 方法返回的 Python 迭代器。（順便說一下，可以通過在 dictionary 上直接調用適當方法，比如 d.iterkeys()，從而檢查這些方法是否返回一個迭代器而不是容器數據類型。）iterkeys() 方法允許遍歷 dictionary 的鍵，而 itervalues() 方法允許遍歷 dictionary 包含的數據值。另一方面，iteritems() 方法允許同時遍歷鍵到數據值的映射。

dictionary：另一種強大的 Python 容器

本文討論了 Python dictionary 數據類型。dictionary 是一種異構的、易變的容器，依賴鍵到數據值的映射（而不是特定的數字次序）來訪問容器中的元素。訪問、添加和刪除 dictionary 中的元素都很簡單，而且 dictionary 很容易用於復合語句，比如 if 語句或 for 循環。可以在 dictionary 中存儲所有不同類型的數據，可以按照名稱或其他復合鍵值（比如 tuple）訪問這些數據，所以 Python dictionary 使開發人員能夠編寫簡潔而又強大的編程語句。

㈦ python中怎樣在dict的一個key下新添加一個value

只要不弄成集合就可以賦值，來給你舉例

dict_1={'key_1'}

這樣得到的dict_1是set集合類型的，如果你想新建個字典dict_2讓key的值為key_1，讓value的值為value_1，則可以這樣寫

dict_2={}
dict_2['key_1']='value_1'

這是一種方法，更多方法自行了解

㈧ python 怎麼設置dictionary變數的默認值

在調用函數的時候重寫了默認值，那麼這個存儲的值就不會被使用。當你不重寫默認值的時候，那麼Python就會讓默認值引用存儲的值（這個例子里的numbers）。
它並不是將存儲的值拷貝來為這個變數賦值。

㈨ 在python中怎麼把列表中的元素添加到字典中

1、首先打開python的編輯器。

㈩ 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)pythondictionary添加擴展閱讀：

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-語言參考