導航:首頁 > 編程語言 > pythondict聲明

pythondict聲明

發布時間:2022-11-27 12:15:16

python怎麼聲明一個字典數組,每一個數組元素是字典dict

1、新建testdict.py文件;

Ⅱ 【python-C相互調用】python里的dict如何作為參數傳入.so中的c語言函數

#include<stdio.h>
#include<stdlib.h>
#include<Python.h>

staticPyObject*
wmf_reverse(PyObject*self,PyObject*args,PyObject*kwargs){
staticchar*kwlist[]={"name",NULL};
char*name=NULL;
PyObject*retval=NULL;

//問題1:只取一個字元串,format應該是"s"
//>>>if(PyArg_ParseTupleAndKeywords(args,keyds,"isi",kwlist,&name))
if(PyArg_ParseTupleAndKeywords(args,kwargs,"s",kwlist,&name)){
retval=(PyObject*)Py_BuildValue("i",1);
printf("%s ",name);
//問題2:不要釋放
//>>>free(name);
}else{
retval=(PyObject*)Py_BuildValue("i",0);
}
returnretval;
}

staticPyMethodDef
wmf_methods[]={
{"reverse",(PyCFunction)wmf_reverse,METH_VARARGS|METH_KEYWORDS,"reverse"},
//問題3:方法定義表,應該用一條空記錄來表示結束。
{NULL,NULL,0,NULL},
};

//問題4:沒有定義mole
staticstructPyMoleDef
wmf_mole={
PyMoleDef_HEAD_INIT,
"wmf",/*nameofmole*/
NULL,/*moledocumentation,maybeNULL*/
-1,/*sizeofper-interpreterstateofthemole,
or-.*/
wmf_methods,
};

//問題5:入口函數要聲明為:PyMODINIT_FUNC
PyMODINIT_FUNC
PyInit_wmf(void){
//問題6:Py_InitMole要初始化的是模塊,不是方法。所以傳方法定義是錯誤的。
//另外,python2.x是用Py_Init_mole,python3.x改用PyMole_Create了。
//兩者略有差別,自己注意一下吧。這里我用的是python3.x。
//Py_InitMole("wmf",ExtestMethods);
PyObject*m;
m=PyMole_Create(&wmf_mole);
if(m==NULL){
returnNULL;
}
returnm;
}

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

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

Ⅳ 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

Ⅳ 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() 返回一個字典所有的鍵。

Ⅵ 問個python的數組問題

把DataDic={}放進第一個循環的裡面就可以了。
之所以輸出時候都是最後一次的數值,是因為你從始至終就只有一個dict,聲明在了循環外面,所以你循環裡面的前四行代碼起到的作用就是修改這個dict的值,第五行就是把這個dict一遍又一遍加進了那個list裡面。
而如果你把dict聲明在循環裡面的話,每一次循環都會新建一個新的dict,這樣你循環最後一行就可以往list裡面添加進不同的dict了。

Ⅶ python dict 實現原理 2019-04-17

dict對象是Python中一個原始的數據類型,按照鍵值對的方式存儲,中文名為字典,其通過鍵名查找對應的值有很高的效率,時間復雜度在常數級別O(1)。Python dict的底層是依靠哈希表(Hash Table)進行實現的,使用開放地址法解決沖突。所以其查找的時間復雜度會是O(1),why?

哈希表是key-value類型的數據結構,通過關鍵碼值直接進行訪問。通過散列函數進行鍵和數組的下標映射從而決定該鍵值應該放在哪個位置,哈希表可以理解為一個鍵值需要按一定規則存放的數組,而哈希函數就是這個規則。

演算法中時間和空間是不能兼得的,哈希表就是一種用合理的時間消耗去減少大量空間消耗的操作,這取決於具體的功能要求。

創建一個數組,數組下標是索引號,數組中的值是要獲得的數據,這樣只需要O(1)的時間復雜度就可以完成操作,但是擴展性不強,有以下兩個方面的考慮:
-1- 新添加的元素超出數組索引范圍,這就需要重新申請數組進行遷移操作。
-2- 假設一種極端的情況:只存在兩個元素,索引號分別是1和100000000001,按照先前的設計思路,會浪費很大的存儲空間。
會不會存在一個方法,為已有的索引創建新的索引,通過壓縮位數,讓新索引可以和原有的大范圍的稀疏索引進行一一對應,新索引所需要的存儲空間要大大減小,這就是哈希思想。

上面的例子中哈希函數的設計很隨意,但是從這個例子中我們也可以得到信息:
哈希函數就是一個映射,因此哈希函數的設定很靈活,只要使得任何關鍵字由此所得的哈希函數值都落在表長允許的范圍之內即可;
因為新的索引對舊的索引進行了空間上的壓縮,所以不可能所有的輸入都只對應唯一一個輸出,也就是哈希函數式有可能發生沖突的,哈希函數不可能做成一對一的映射關系,其本質是一個多對一的映射。

直接定址法:很容易理解,key=Value+C; 這個「C」是常量。Value+C其實就是一個簡單的哈希函數。
除法取余法: 很容易理解, key=value%C;解釋同上。
數字分析法:這種蠻有意思,比如有一組value1=112233,value2=112633,value3=119033,針對這樣的數我們分析數中間兩個數比較波動,其他數不變。那麼我們取key的值就可以是key1=22,key2=26,key3=90。
平方取中法。此處忽略,見名識意。
折疊法:這種蠻有意思,比如value=135790,要求key是2位數的散列值。那麼我們將value變為13+57+90=160,然後去掉高位「1」,此時key=60,哈哈,這就是他們的哈希關系,這樣做的目的就是key與每一位value都相關,來做到「散列地址」盡可能分散的目地。

當兩個不同的數據元素的哈希值相同時,就會發生沖突。解決沖突常用的手法有2種:
開放地址法:
如果兩個數據元素的哈希值相同,則在哈希表中為後插入的數據元素另外選擇一個表項。當程序查找哈希表時,如果沒有在第一個對應的哈希表項中找到符合查找要求的數據元素,程序就會繼續往後查找,直到找到一個符合查找要求的數據元素,或者遇到一個空的表項。
鏈接法:
將哈希值相同的數據元素存放在一個鏈表中,在查找哈希表的過程中,當查找到這個鏈表時,必須採用線性查找方法。

python的dict採用了哈希表,最低能在 O(1)時間內完成搜索,在發生哈希沖突的時候採用的是開放定址法。java的HashMap也是採用了哈希表實現,但是在發生哈希沖突的時候採用的是鏈接法。

Ⅷ python怎麼定義多個字典

Python的數據不需要聲明, 使用的時候就定義了

mydict={}
mydict2={}

隨用隨定義, 不需要糾結這個問題

Ⅸ 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中的dict作為參數傳入c函數中用c做相關的處理

#先上代碼再解釋
staticPyObject*keywdarg_parrot(PyObject*self,PyObject*args,PyObject*keywds)
{
intvoltage;
char*state="astiff";
char*action="voom";
char*type="NorwegianBlue";

staticchar*kwlist[]={"voltage","state","action","type",NULL};

if(!PyArg_ParseTupleAndKeywords(args,keywds,"i|sss",kwlist,
&voltage,&state,&action,&type))
returnNULL;

printf("--Thisparrotwouldn't%sifyouput%iVoltsthroughit. ",
action,voltage);
printf("--Lovelyplumage,the%s--It's%s! ",type,state);

Py_INCREF(Py_None);

returnPy_None;
}

staticPyMethodDefkeywdarg_methods[]={
/*
*onlytaketwoPyObject*parameters,andkeywdarg_parrot()takes
*three.
*/
{"parrot",(PyCFunction)keywdarg_parrot,METH_VARARGS|METH_KEYWORDS,
"."},
{NULL,NULL,0,NULL}/*sentinel*/
};

PyObject*initkeywdarg(void)
{
/**/
returnPy_InitMole("keywdarg",keywdarg_methods);
}

這是一個函數(keywdarg_parrot)即使用了元組參數,也使用了字典參數的例子。例子出自Python2.7.2的文檔。具體在:

Python v2.7.2 documentation &#187;Extending and Embedding the Python
Interpreter

這個頁面下。文檔裡面有一些關於C/C++與Python交互的介紹和例子,還是比較詳細的。傳遞字典參量要注意,

{"parrot",(PyCFunction)keywdarg_parrot,METH_VARARGS|METH_KEYWORDS,
"."},

這里的METH_VARARGS | METH_KEYWORDS,與普通的不同。解析用:

PyArg_ParseTupleAndKeywords(args,keywds,"i|sss",kwlist,
&voltage,&state,&action,&type)

其中的四個變數要提前聲明好,這里分別是int,str,str,str類型的。int對應的是args接受到的值。string的都是keywds裡面的,它們都是有初始值的。kwlist是變數的名字,就是在python里調用的時候使用的keyword名稱。照著例子的模式可以改成其它的,能用的。具體是怎麼工作的,其實我也太明白。

Python代碼是這樣的調用的時候:

printkeywdarg.parrot(10,"LHJ",'HKJ','ER')
printkeywdarg.parrot(10,"LHJ",'HKJ')
printkeywdarg.parrot(10,"LHJ",type='KJ')

輸出分別是:

-- This parrot wouldn't HKJ if you put 10 Volts through it.

-- Lovely plumage, the ER -- It's LHJ!

None

-- This parrot wouldn't HKJ if you put 10 Volts through it.

-- Lovely plumage, the Norwegian Blue -- It's LHJ!

None

-- This parrot wouldn't voom if you put 10 Volts through it.

-- Lovely plumage, the KJ -- It's LHJ!

None

第二次調用省略掉了變數,也能正常執行。第三次調用,變數type本來是第四位的,現在變成了keyword並寫在了第三位,是python代碼里調用的常見形式:keyword不講順序,省略掉的keyword使用了默認值。

就這些了,其它的你再看一下Python的文檔吧。

閱讀全文

與pythondict聲明相關的資料

熱點內容
伺服器光碟機線怎麼插 瀏覽:12
新生兒下載哪個app好 瀏覽:487
摩托車壓縮比96 瀏覽:410
linux查看mysql內存 瀏覽:242
福建ca認證伺服器地址 瀏覽:567
三星安全文件夾怎麼取消應用程序 瀏覽:169
偶像來了哪個app能看 瀏覽:252
破解分銷源碼 瀏覽:184
androidudp服務端 瀏覽:771
電腦伺服器和內存有什麼區別 瀏覽:308
下載海爾哪個app可以查詢信息 瀏覽:385
暴風文件夾怎麼刪除 瀏覽:163
我的世界緩存文件在哪個文件夾 瀏覽:359
簡歷發壓縮包還是文件夾 瀏覽:85
mes系統用什麼伺服器5885v5 瀏覽:486
郵件伺服器可以怎麼查詢 瀏覽:727
啟動linux的sftp 瀏覽:66
asp防紅系統源碼模板 瀏覽:240
雙手握住文件夾 瀏覽:47
php分析html 瀏覽:623