python3dict

Ⅰ python3 判斷dict是否含有某元素

list = [1,'a','b',{'key':'value'}]
for i in range(0, list.__len__()):
#遍歷list的元素，print其類型
print type(list[i])
#判斷類型為str的元素，並輸出
print '類型為string的有：'
for i in range(0, list.__len__()):
if isinstance(list[i], str):
print type(list[i])
結果：
<type 'int'>
<type 'str'>
<type 'str'>
<type 'dict'>
類型為string的有：
<type 'str'>
<type 'str'>

Ⅱ 如何使用Python3實現Dict字典的倒序輸出

dict是哈希實現的，不存在有序無序
想要實驗有序輸出，按list就行
ATLst = sorted(ATDict.items(),key=lambda x:x[0],reverse=True)
for item in ATLst:
print(items[0],items[1])

Ⅲ python3在函數聲明裡如何設置參數的類型 dict

dict[]和dict.get兩個方法的區別吧 dict[key]：當key不存在的時候，會拋出異常 dict.get(key, defaut_value=None) 當key不存在的時候，不會拋出異常，而且會返回默認值

Ⅳ python3 defaultdict 和 dict的區別

yangyzh
Python中dict詳解

python3.0以上，print函數應為print（），不存在dict.iteritems()這個函數。

在python中寫中文注釋會報錯，這時只要在頭部加上# coding=gbk即可

#字典的添加、刪除、修改操作
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
dict["w"] = "watermelon"
del(dict["a"])
dict["g"] = "grapefruit"
print dict.pop("b")
print dict
dict.clear()
print dict
#字典的遍歷
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for k in dict:
print "dict[%s] =" % k,dict[k]
#字典items()的使用
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#每個元素是一個key和value組成的元組，以列表的方式輸出
print dict.items()
#調用items()實現字典的遍歷
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for (k, v) in dict.items():
print "dict[%s] =" % k, v
#調用iteritems()實現字典的遍歷
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict.iteritems()
for k, v in dict.iteritems():
print "dict[%s] =" % k, v
for (k, v) in zip(dict.iterkeys(), dict.itervalues()):
print "dict[%s] =" % k, v

#使用列表、字典作為字典的值
dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}
print dict["a"]
print dict["a"][0]
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#輸出key的列表
print dict.keys()
#輸出value的列表
print dict.values()
#每個元素是一個key和value組成的元組，以列表的方式輸出
print dict.items()
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
it = dict.iteritems()
print it
#字典中元素的獲取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict
print dict.get("c", "apple")
print dict.get("e", "apple")
#get()的等價語句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
print D["key1"]
else:
print "None"
#字典的更新
dict = {"a" : "apple", "b" : "banana"}
print dict
dict2 = {"c" : "grape", "d" : "orange"}
dict.update(dict2)
print dict
#udpate()的等價語句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#字典E中含有字典D中的key
D = {"key1" : "value1", "key2" : "value2"}
E = {"key2" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#設置默認值
dict = {}
dict.setdefault("a")
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict
#調用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
#字典的淺拷貝
dict = {"a" : "apple", "b" : "grape"}
dict2 = {"c" : "orange", "d" : "banana"}
dict2 = dict.()
print dict2

#字典的深拷貝
import
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = .deep(dict)
dict3 = .(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict

補充：
1 初始化
>>> d = dict(name='visaya', age=20)
>>> d = dict(zip(['name', 'age'], ['visaya', 20]))

#dict.fromkeys(listkeys, default=0) 把listkeys中的元素作為key均賦值為value，默認為0
>>> d = dict.fromkeys(['a', 'b'], 1)
>>> d
{'a': 1, 'b': 1}
2 字典視圖和幾何
dict.keys()類似信使可以進行交集和並集等集合操作（類似集合，因為不存在重復的項），但dict.values()不可以進行如上操作。

>>> k = d.keys()
>>> k
dict_keys(['a', 'b'])
>>> list(k)
['a', 'b']
>>> k | {'x': 3}
{'a', 'x', 'b'}
>>> k | {'x'}
{'a', 'x', 'b'}
>>> k | {'x', 'y'}
{'a', 'y', 'b', 'x'}
>>> k & {'x'}
set()
>>> v = d.values()
>>> v
dict_values([1, 2])
>>> v | {'x'}
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'
3 排序字典鍵
兩種方法:
3.1 sort:
>>> Ks = list(d.keys())
>>> Ks.sort()
>>> for k in Ks:
... print(k, d[k])
...
a 1
b 2
3.2 sorted:
>>> for k in sorted(d.keys()):
... print(k, d[k])
...
a 1
b 2

3.3 注意
>>> for k in list(d.keys()).sort():
... print(k, d[k])
...
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: 'NoneType' object is not iterable

出錯原因：
list.sort() list.append()函數都是對自身的操作，沒有返回值，故需先將list(d.keys())的結果保存下來，在結果上進行sort()
4 常用函數
4.1 get()
D.get(k[, d]) => D[k] if k in D else d. d defaults to none.
4.2 pop()
D.pop(value[, d]) => Remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised.
4.3 udpate()
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]

>>> d = dict(name='visaya', age=21)
>>> d1= {'age': 20, 'sex': 'male'}
>>> d2 = zip(['a', 'b'], [1, 2])

>>> d.update(d1)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for k in d1: d[k] = d1[k]

>>> d.update(d2)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for (k, v) in d2: d[k] = v
4.4 del()
del D[key]
4.5 clear()
4.6 ()
Python中的dict
初始化
構造方法創建
Python代碼
d = dict()
d = dict(name="nico", age=23)
d = dict((['name', "nico"], ['age', 23]))
當然還有更方便，簡單的
Python代碼
d = {}
d = {"name":"nico", "age":23}

遍歷
通過對key的遍歷，遍歷整個dict

Python代碼
d = {"name":"nico", "age":23}
for key in d:
print "key=%s, value=%s" % (key, d[key])

for key in d.iterkeys():
print "key=%s, value=%s" % (key, d[key])

for key in d.keys():
print "key=%s, value=%s" % (key, d[key])

for key in iter(d):
print "key=%s, value=%s" % (key, d[key])

for key,item in d.items():
print "key=%s, value=%s" % (key, item)

當然也可以直接遍歷value

Python代碼
d = {"name":"nico", "age":23}
for value in d.values():
print value

for key,value in d.viewitems():
print "key=%s, value=%s" % (key, value)

for value in d.viewvalues():
print "value=%s" % (value)
這里values和viewvalues的區別

後者返回的是該字典的一個view對象，類似資料庫中的view，當dict改變時，該view對象也跟著改變

常用方法

Python代碼
d = {"name":"nico", "age":23}
d["name"] = "aaaa"
d["address"] = "abcdefg...."
print d #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}

獲取dict值
Python代碼
print d["name"] #nico
print d.get("name") #nico

如果key不在dict中，返回default，沒有為None
Python代碼
print d.get("namex", "aaa") #aaa
print d.get("namex") #None

排序sorted()
Python代碼
d = {"name":"nico", "age":23}
for key in sorted(d):
print "key=%s, value=%s" % (key, d[key])
#key=age, value=23
#key=name, value=nico

刪除del
Python代碼
d = {"name":"nico", "age":23}
Python代碼
del d["name"]
#如果key不在dict中，拋出KeyError
del d["names"]
Python代碼
Traceback (most recent call last):
File "F:\workspace\project\pydev\src\ddd\ddddd.py", line 64, in <mole>
del d["names"]
KeyError: 'names'

清空clear()
Python代碼
d = {"name":"nico", "age":23}
d.clear()
print d #{}

()
Python代碼
d1 = d.() #{'age': 23, 'name': 'nico'}
#使用返回view對象
d2 = d1.viewitems() #dict_items([('age', 23), ('name', 'nico')])
#修改字典d1，新增元素
d1["cc"] = "aaaaaa"
print d2
#dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])

pop(key[, default])
如果key在dict中，返回，不在返回default
Python代碼
#如果key在dict中，返回，不在返回default
print d.pop("name", "niccco") #nico
print d.pop("namezzz", "niccco") #niccco
#key不在dict中，且default值也沒有，拋出KeyError
print d.pop("namezzz") #此處拋出KeyError

popitem()
刪除並返回dict中任意的一個(key,value)隊，如果字典為空會拋出KeyError
Python代碼
d = {"name":"nico", "age":23}
print d.popitem() #('age', 23)
print d.popitem() #('name', 'nico')
#此時字典d已為空
print d.popitem() #此處會拋出KeyError

update([other])
將字典other中的元素加到dict中，key重復時將用other中的值覆蓋
Python代碼
d = {"name":"nico", "age":23}
d2 = {"name":"jack", "abcd":123}
d.update(d2)
print d #{'abcd': 123, 'age': 23, 'name': 'jack'}

Ⅳ python dict用法

dic= {key1 : value1, key2 : value2 }

字典也被稱作關聯數組或哈希表。下面是幾種常見的字典屬性：

1、dict.clear()

clear() 用於清空字典中所有元素（鍵-值對），對一個字典執行 clear() 方法之後，該字典就會變成一個空字典。

2、dict.()

() 用於返回一個字典的淺拷貝。

3、dict.fromkeys()

fromkeys() 使用給定的多個鍵創建一個新字典，值默認都是 None，也可以傳入一個參數作為默認的值。

4、dict.get()

get() 用於返回指定鍵的值，也就是根據鍵來獲取值，在鍵不存在的情況下，返回 None，也可以指定返回值。

5、dict.items()

items() 獲取字典中的所有鍵-值對，一般情況下可以將結果轉化為列表再進行後續處理。

6、dict.keys()

keys() 返回一個字典所有的鍵。

Ⅵ python3 對象 |字典|json|yaml|字元串 相互轉化

在研究 k8s 的yaml 配置文件的時候，我總擔心自己一不小心 會寫錯，所以我嚮往 使用將對象 序列化 yaml 的形式，

其實 python object 可以 直接 轉 yaml ，甚至也可以 直接 轉成yaml文件！！！

這里 會經常用到幾個 函數 vars() ast.

我們先嘗試用最笨的方法 實現 object到yaml 的轉化
在python對象 convert to dict 的形式，使用 vars()函數

然後 dict convert to json 使用 json.mps(dict)函數

然後 json converte to yaml 使用 ya= yaml.load(json.mps(dict)) 然後
再 yaml.safe_mp(ya,default_flow_style=False)

至此我們看到 從 python Object ---> dict ----> json ---> yaml 的轉化

其中 obj dict json yaml 轉 string ，只要 str()函數即可,或者 str(vars())結合

yaml 格式 寫入到文件 ,需要注意的是， open()函數 的mode 一定要是 'w' ,不能是』wb', b代表是二進制寫入
yaml 寫入的是dict str，使用 『wb' 會報錯，[yaml TypeError: a bytes-like object is required, not 'str']
【出現該錯誤往往是通過open()函數打開文本文件時，使用了『rb』屬性，如：fileHandle=open(filename,'rb'),則此時是通過二進制方式打開文件的，所以在後面處理時如果使用了str()函數，就會出現該錯誤，該錯誤不會再python2中出現。

具體解決方法有以下兩種：

第一種，在open()函數中使用『r』屬性，即文本方式讀取，而不是『rb』,以二進制文件方式讀取，可以直接解決問題。

第二種,在open()函數中使用『rb』,可以在使用之前進行轉換，有以下實例，來自： http://stackoverflow.com/questions/33054527/python-3-5-typeerror-a-bytes-like-object-is-required-not-str 】

其實 python object 可以 直接 轉 yaml ，甚至也可以 直接 轉成yaml文件！！！
比如我已經定義了一個 Dog python class,他有 好幾個屬性 並已經賦值初始化了

另外生成 yaml 對象

生成yaml文件

結果是

反過來 yaml ----> json ---> 持久化 json 文件 indent=1屬性是為了讓 json 不以單行展示，而是展開
注意的是 python 的 dict 和set 很相似 ，都是 { }， set 里是list， dict 是鍵值對
【# set object is not JSON serializable [plicate]
】

打開 demo.json

yaml ---> dict

yaml ---> python object

json --> dict
json.loads()

dict--> json
json.jumps()

str ---> dict
newdict=dict(str)

json -- > python object

一個python object無法直接與json轉化，只能先將對象轉化成dictionary，再轉化成json；對json，也只能先轉換成dictionary，再轉化成object，通過實踐，源碼如下：

yaml --> python object
對yaml，也只能先轉換成json --->dictionary，再轉化成object，通過實踐，源碼如下：

dict -- ->python object

python對象 默認都有一個 私有的屬性 dict 取值 就是 object的 字典形式， 賦值就就可以給對象屬性對應賦值

例如json 轉 對象

對象 轉 json

Python之dict(或對象)與json之間的互相轉化
在Python語言中，json數據與dict字典以及對象之間的轉化，是必不可少的操作。

dict字典轉json數據

對象轉json數據

json數據轉成dict字典

json數據轉成對象

json的load()與mp()方法的使用
mp()方法的使用

Ⅶ 請問python3中「構造函數 dict() 可以直接從鍵值對序列中構建字典如下」什麼意思

意思是可以這樣創建字典:

dict([('key1','value1'),('key2','value2')])
#等於下面
{
'key1':'value1',
'key2':'value2',
}