python中items
⑴ python中的argv.items()代表什麼意思呢
sys.argv[0]表示代碼本身文件路徑。sys.argv[]說白了就是一個從程序外部獲取參數的橋梁，這個「外部」很關鍵，因為從外部取得的參數可以是多個，所以獲得的是一個列表（list)，也就是說sys.argv其實可以看作是一個列表。
所以才能用[]提取其中的元素。其第一個元素是程序本身，隨後才依次是外部給予的參數。
Sys.argv[ ]其實就是一個列表，里邊的項為用戶輸入的參數，關鍵就是要明白這參數是從程序外部輸入的，而非代碼本身的什麼地方，要想看到它的效果就應該將程序保存了，從外部來運行程序並給出參數。
(1)python中items擴展閱讀
Python的字典的items(), keys(), values()都返回一個list
argc,argv 用命令行編譯程序時有用。
主函數main中變數(int argc,char *argv[ ])的含義
有些編譯器允許將main()的返回類型聲明為void，這已不再是合法的C++
main(int argc, char *argv[ ], char **env)才是UNIX和Linux中的標准寫法。
argc: 整數,用來統計你運行程序時送給main函數的命令行參數的個數
⑵ Python初學（十九）
「鍵值對」是組織數據的一種重要方式，廣泛應用在Web系統中。鍵值對的基本思想是將「值」信息關聯一個「鍵」信息，進而通過鍵信息查找對應值信息，這個過程叫映射。Python語言中通過字典類型實現映射。
Python語言中的字典使用大括弧{}建立，每個元素是一個鍵值對，使用方式如下:
{<鍵1>:<值1>, <鍵2>:<值2>, ... , <鍵n>:<值n>}
其中，鍵和值通過冒號連接，不同鍵值對通過逗號隔開。字典類型也具有和集合類似的性質，即鍵值對之間沒有順序且不能重復。
列表類型採用元素順序的位置進行索引。由於字典元素「鍵值對」中鍵是值的索引，因此，可以直接利用鍵值對關系索引元素。
字典中鍵值對的索引模式如下，採用中括弧格式:
<值> = <字典變數>[<鍵>]
print(d[『201801』])
輸出的也就是: 小明
使用大括弧可以創建字典。通過索引和賦值配合，可以向字典中增加元素。
字典是存儲可變數量鍵值對的數據結構，鍵和值可以是任意數據類型，通過鍵索引值，並可以通過鍵修改值。
字典類型有一些通用的操作函數
dict()函數用於生成一個空字典，作用和{}一致
字典類型存在一些操作方法，使用語法形式是:
<字典變數>.<方法名稱>(<方法參數>)
d.keys()返回字典中的所有鍵信息，返回結果是Python的一種內部數據類型dict_keys，專用於表示字典的鍵。如果希望更好的使用返回結果，可以將其轉換為列表類型。
d.values()返回字典中的所有值信息，返回結果是Python的一種內部數據類型dict_values。如果希望更好的使用返回結果，也可以將其轉換為列表類型。
d.items()返回字典中的所有鍵值對信息，返回結果是Python的一種內部數據類型dict_items。當然也可以轉成列表類型 即: list(d.items())
d.get(key, default)根據鍵信息查找並返回值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。 例如: 就拿上邊的數組d 來說 d.get(『201801』,「不存在」) 相當於一個if語句 如果key 201801 存在 就返回201801 values 不存在就返回 默認值 不存在
d.pop(key, default)根據鍵信息查找並取出值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。相比d.get()方法，d.pop()在取出相應值後，將從字典中刪除對應的鍵值對。 和d.get方法類似
d.popitem()隨機從字典中取出一個鍵值對，以元組(key,value)形式返回。取出後從字典中刪除這個鍵值對。
d.clear()刪除字典中所有鍵值對。
此外，如果希望刪除字典中某一個元素，可以使用Python保留字del。 即: del d[key]
字典類型也支持保留字in，用來判斷一個鍵是否在字典中。如果在則返回True，否則返回False。
與其他組合類型一樣，字典可以遍歷循環對其元素進行遍歷，基本語法結構如下:
for <變數名> in <字典名>
<語句塊>
for循環返回的變數名是字典的索引值。如果需要獲得鍵對應的值，可以在語句塊中通過get()方法獲得。
以上就是本章的所有內容,感謝大家.
Python 學習的基礎（持續更新中......）
⑶ python 20：取字典中的全部元素的方法
一共三個，分別取所有的鍵（keys()），值(values())和鍵值對(items())。
返回的類似於列表，但不是列表。其類型分別為dict_keys，dict_values和dict_items。
>>>count={'a': 1, 'b': 0, 'c': 99, 'd': 0}
>>> s=count.keys()
>>> s
dict_keys(['a', 'b', 'c', 'd'])
>>> t=count.values()
>>> t
dict_values([1, 0, 99, 0])
>>> x=count.items()
>>> x
dict_items([('a', 1), ('b', 0), ('c', 99), ('d', 0)])
取出後，它們都可以直接用於遍歷，如：
for k in count.keys():
for v in count.values():
for k,v in count.items():
它們也都可以通過list()函數轉換為列表使用：
>>> ls=list(s)
>>> ls
['a', 'b', 'c', 'd']
>>> lt=list(t)
>>> lt
[1, 0, 99, 0]
>>> lx=list(x)
>>> lx
[('a', 1), ('b', 0), ('c', 99), ('d', 0)]
⑷ 請問python中 items = re.findall(reg,html)括弧內的怎麼理解
括弧裡面的兩個是參數，位置不能調換。
findall是re對象里的一個方法，這個方法需要2個參數：reg，html。這兩個參數應該在上面的代碼有定義。
你可以把「方法」理解成一個生產機器，「參數」就是原材料。那麼方法的返回值就是生產機器生產出來的產品。
⑸ python中for循環的用法
python中for循環常用於遍歷字元串、列表、元組、字典、集合等序列類型，逐個獲取序列中的各個元素。在使用 for 循環時，最基本的應用就是進行數值循環。在使用 for 循環遍歷字典時，經常會用到和字典相關的 3 個方法，即 items()、keys() 以及 values()。
(5)python中items擴展閱讀
python中for循環常用於遍歷字元串、列表、元組、字典、集合等序列類型，逐個獲取序列中的各個元素。在使用 for 循環時，最基本的.應用就是進行數值循環。在使用 for 循環遍歷字典時，經常會用到和字典相關的 3 個方法，即 items()、keys() 以及 values()。⑹ python的items得到的就是列表么
items是一個dict的類不是真正的列表，不能像列表一樣使用
list是轉換為列表，你可以用type（）進行測試
⑺ python字典中items和iteritems的區別
items()返回的是列表對象，而iteritems()返回的是iterator對象。例如：
print dic.items() #[('a', 'hello'), ('c', 'you'), ('b', 'how')]
print dic.iteritems() #<dictionary-itemiterator object at 0x020E9A50>
深究：iteritor是迭代器的意思，一次反悔一個數據項，知道沒有為止
for i in dic.iteritems():
print i
結果：('a', 'hello')
('c', 'you')
('b', 'how')
⑻ python字典操作函數
字典是一種通過名字或者關鍵字引用的得數據結構，其鍵可以是數字、字元串、元組，這種結構類型也稱之為映射。字典類型是Python中唯一內建的映射類型，基本的操作包括如下：
(1)len()：返回字典中鍵—值對的數量；
(2)d[k]:返回關鍵字對於的值；
(3)d[k]=v:將值關聯到鍵值k上；
(4)del d[k]:刪除鍵值為k的項；
(5)key in d:鍵值key是否在d中，是返回True，否則返回False。
(6)clear函數：清除字典中的所有項
(7)函數：返回一個具有相同鍵值的新字典；deep()函數使用深復制，復制其包含所有的值，這個方法可以解決由於副本修改而使原始字典也變化的問題
(8)fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None
(9)get函數：訪問字典成員
(10)has_key函數：檢查字典中是否含有給出的鍵
(11)items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表
(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器
(13)pop函數：刪除字典中對應的鍵
(14)popitem函數：移出字典中的項
(15)setdefault函數：類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值
(16)update函數：用一個字典更新另外一個字典
(17) values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由於在字典中值不是唯一的，所以列表中可以包含重復的元素
一、字典的創建
1.1 直接創建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
>>>
1.2 通過dict創建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的內容:'
printitems
printu'利用dict創建字典，輸出字典內容:'
d=dict(items)
printd
printu'查詢字典中的內容:'
printd['one']
printd['three']
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的內容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict創建字典，輸出字典內容:
{'four':4,'three':3,'two':2,'one':1}
查詢字典中的內容:
>>>
或者通過關鍵字創建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'輸出字典內容:'
printd
printu'查詢字典中的內容:'
printd['one']
printd['three']
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出字典內容:
{'three':3,'two':2,'one':1}
查詢字典中的內容:
>>>
二、字典的格式化字元串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
>>>
三、字典方法
3.1 clear函數：清除字典中的所有項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
>>>
請看下面兩個例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{'two':2,'one':1}
>>>
3.1.2
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d.clear()
printd
printdd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
>>>
3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關聯到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空後，字典dd裡面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內容，clear是一個原地操作的方法，使得d中的內容全部被置空，這樣dd所指向的空間也被置空。
3.2 函數：返回一個具有相同鍵值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典：'
printx
printu'X復制到Y：'
y=x.()
printu'Y字典：'
printy
y['three']=33
printu'修改Y中的值，觀察輸出：'
printy
printx
printu'刪除Y中的值，觀察輸出'
y['test'].remove('c')
printy
printx
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典：
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X復制到Y：
Y字典：
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值，觀察輸出：
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
刪除Y中的值，觀察輸出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}
>>>
註：在復制的副本中對值進行替換後，對原來的字典不產生影響，但是如果修改了副本，原始的字典也會被修改。deep函數使用深復制，復制其包含所有的值，這個方法可以解決由於副本修改而使原始字典也變化的問題。
# _*_ coding:utf-8 _*_
fromimportdeep
x={}
x['test']=['a','b','c','d']
y=x.()
z=deep(x)
printu'輸出：'
printy
printz
printu'修改後輸出：'
x['test'].append('e')
printy
printz
運算輸出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出：
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改後輸出：
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}
>>>
3.3 fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
運算輸出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
>>>
或者指定默認的對應值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
>>>
3.4 get函數：訪問字典成員
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
>>>
註：get函數可以訪問字典中不存在的鍵，當該鍵不存在是返回None
3.5 has_key函數：檢查字典中是否含有給出的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
>>>
3.6 items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
three :3
two :2
one :1
>>>
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
it=d.iteritems()
fork,vinit:
print"d[%s]="%k,v
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1
>>>
3.7 keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printu'keys方法：'
list=d.keys()
printlist
printu'\niterkeys方法：'
it=d.iterkeys()
forxinit:
printx
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
keys方法：
['three','two','one']
iterkeys方法：
three
two
one
>>>
3.8 pop函數：刪除字典中對應的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
>>>
3.9 popitem函數：移出字典中的項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
>>>
3.10 setdefault函數：類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
運算結果：
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
>>>
3.11 update函數：用一個字典更新另外一個字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
>>>
3.12 values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由於在字典中值不是唯一的，所以列表中可以包含重復的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
運算結果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
>>>
⑼ python items()是怎麼排序的
在Python中，當你排序一個元組時，如下所示：
>>> items = [(1, 'B'), (1, 'A'), (2, 'A'), (0, 'B'), (0, 'a')]
>>> sorted(items)
[(0, 'B'), (0, 'a'), (1, 'A'), (1, 'B'), (2, 'A')]
默認情況下，sort和sorted內建函數會優先排序第一個元素，然後再排序第二個元素，大寫字母會排在小寫字母前面。當你想要不區分大小寫排序時，可能會按如下寫代碼：
>>> sorted(items, key=str.lower)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: descriptor 'lower' requires a 'str' object but received a 'tuple'
出現了錯誤，lower需要的是字元串對象，但是接收到了元組。下面的應用lamdba，返回一個元組：
>>> sorted(items, key=lambda x: (x[0], x[1].lower()))
[(0, 'a'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A')]
我確定你知道可以通過 sorted(items, reverse=True, ...) 將其反轉，但是如果你想要依賴你提供的key來獲得不同的排序順序時，該怎麼辦呢？使用lambda函數返回一個元組可以實現，下面是一個更高級的結構排序
>>> peeps = [{'name': 'Bill', 'salary': 1000}, {'name': 'Bill', 'salary': 500}, {'name': 'Ted', 'salary': 500}]
>>> sorted(peeps, key=lambda x: (x['name'], x['salary']))
[{'salary': 500, 'name': 'Bill'}, {'salary': 1000, 'name': 'Bill'}, {'salary': 500, 'name': 'Ted'}]
如果你想要使salary逆序，只需要如下改動：
>>> sorted(peeps, key=lambda x: (x['name'], -x['salary']))
[{'salary': 1000, 'name': 'Bill'}, {'salary': 500, 'name': 'Bill'}, {'salary': 500, 'name': 'Ted'}]
⑽ Python 中 stuinfo . items ()是什麼怎麼用
stuinfo這個變數應該是一個字典(dict)
dict.items() 這個方法可以獲取到一個由各個key+value組合的元組的列表，
經常在for循環迭代的時候經常這樣使用