pythonstringlong

❶ python基本數據類型有哪些

python基本數據類型有哪些？
python基本數據類型有：
● int 整型
● bool 布爾
● strintg 字元串
● pst 列表
● tuple 元組
● dict 字典
數據類型的可變和不可變
● 不可變類型：int， string，tuple
● 可變類型：pst，dict
相關推薦：《Python教程》以上就是小編分享的關於python基本數據類型有哪些的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！

❷ python變數類型有哪些

Python
變數類型
變數存儲在內存中的值。這就意味著在創建變數時會在內存中開辟一個空間。基於變數的數據類型，解釋器會分配指定內存，並決定什麼數據可以被存儲在內存中。因此，變數可以指定不同的數據類型，這些變數可以存儲整數，小數或字元。
1、變數賦值：Python
中的變數賦值不需要類型聲明。
2、多個變數賦值
3、標准數據類型：在內存中存儲的數據可以有多種類型。
4、Python數字：數字數據類型用於存儲數值。
Python支持四種不同的數字類型：int（有符號整型）、long（長整型[也可以代表八進制和十六進制]）、float（浮點型）、complex（復數）
5、Python字元串：字元串或串(String)是由數字、字母、下劃線組成的一串字元。
6、Python列表：List（列表）
是
Python
中使用最頻繁的數據類型。
7、Python元組：元組是另一個數據類型，類似於List（列表）。
8、Python
字典字典(dictionary)是除列表以外python之中最靈活的內置數據結構類型。列表是有序的對象集合，字典是無序的對象集合。
9、Python數據類型轉換：有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。

❸ 寫出python中6種數據類型

Python中的變數不需要聲明。每個變數在使用前都必須賦值，變數賦值以後該變數才會被創建。
Python3中有六個標準的數據類型：Number（數字）+String（字元串）+List（列表）+Tuple（元組）+Sets（集合）+Dictionary（字典）。
Number（數字）數字類型是顧名思義是用來存儲數值的，需要記住的是，有點和Java的字元串味道差不多，如果改變了數字數據類型的值，將重新分配內存空間。
可以使用del語句刪除一些數字對象的引用delvar1[,var2[,var3[....,varN]]]]。Python支持三種不同的數值類型：
1.整型(Int)-通常被稱為是整型或整數，是正或負整數，不帶小數點。
Python3整型是沒有限制大小的，可以當作Long類型使用，所以Python3沒有Python2的Long類型。
2.浮點型(float)-浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2=2.5x102=250）
3.復((complex))-復數由實數部分和虛數部分構成，可以用a+bj,或complex(a,b)表示，復數的實部a和虛部b都是浮點型。數字類型轉換1.int(x)將x轉換為一個整數。
4.complex(x,y)將x和y轉換到一個復數，實數部分為x，虛數部分為y。x和y是數字表達式。

❹ python的數據類型

1、python中有6種標准數據類型： number（數字），string （字元串），list （列表），tuple（元組），set （集合），dictionary （字典）。

2、type()，dtype()，astype()的區別。

用numpy讀入數據，默認的dtype是『float64』，要轉變numpy中數據的類型敏租，不能直接改變原數據的dtype，只能用astype()。橋悶兆

float類型包括『float64』，『float32』和『float16』，默認為'float64'。

int 類型包括『int64』，『int32』，『int16』和『罩嫌int8』，默認為『int64』。

❺ python常見數據類型

一,python整數類型所表示的數據。

1,一般用以表示一類數值:所有正整數,0和負整數;

2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。

3,bool型繼承了int型，他是int的子類。

4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。

5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。

6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)

二，python整數和浮點型支持常規的數值運算

整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）

Python字元型：

python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True

二, 字元串支持的運算方法

1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd

2,casefold() lower():字母轉換為全小寫

3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元

a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格

4,count(sub,star,end) :字母計數：sub要查詢的字元

5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼

Errors :設置錯誤類型

6,endswith(suffix,star,end) : 若以suffix結尾返回True

7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』

8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1

9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常

10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合

11，isalpha() :判斷是否全是字母

12，isdecimal() :判斷字元串是否是十進制數值

13，isdigit() :判斷字元串是否是數字

14，isidentifier() :判斷字元串中是否包含關鍵字

15，islower() :判斷是否全小寫

16，isnumeric() :判斷全是數字

17，isspace() :判斷是否是空格

18，isupper() 判斷是否大寫

19，istitle() :判斷是否首字母大寫

20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)

21,ljust(width,fillchar);rjust() :左對齊右對齊

22, upper() :將字元串改為大寫

23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除

『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]

三，字元串格式化：按照規格輸出字元串

format(*args,**kwargs) :args位置參數，kwargs關鍵字參數

『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入

四，字元串操作符%

1，%s :格式化字元串 『abcd%sdef』%』dddd』

2，%d:格式化整數

3，%o格式化無符號八進制

4，%x格式化無符號十六進制

5，%f格式化定點數

6, %e: 科學計數法格式化定點數

7，%g 根據值大小自動選%f,%e

8, %G E X :大寫形式

五，格式化輔助命令：

m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789

六，轉義字元：字元串前r避免轉義：r』\nhello\thi』

\n:換行符

\t:橫向製表符

\':'

\":"

\b:退格符

\r:回車

\v:縱向製表符

\f:換頁符

\o,\x:八進制和十六進制

\0:空字元串

Python列表list

一，Python的列表list類型表示的數據：

Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。

列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)

2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素

remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)

8, 淺拷貝一個新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默認升序

排序函數：sorted(list)

10，reverse: 原地翻轉：list.reverse()

11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)

列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新列表：l1+ l2

3, 重復操作符：* ,多個列表拼接

成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序

Python元組tuple

一，Python元組tuple數據類型表示的數據：

元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元組常用方法

1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)

2,count(value) ：值出現次數

三，支持運算：

1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新元組：l1+ l2

3, 重復操作符：* ,多個元組拼接

4成員關系操作符：in/ not in

邏輯運算符：and not or
四，元組的訪問

下標操作；
For循環遍歷訪問。

Python字典類型

一,Python字典dict表示的數據：{key:value}

可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的訪問：

通過key：k[『key』]

修改key對應的值：K[『key』] = value

For循環遍歷出來的是key；

For循環鍵值對：for I in d.items():

For 循環enumerate: for k,v in enumerate(k1):

In/not in 成員關系查詢鍵不支持查值

三，字典常用方法

get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在則生成一個鍵值對

k.setdefault(『keyword』)

Python 集合set

集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復

常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象

Frozenset(iterable):

S = frozenset(iterable)

Python序列類型共同特性

一,序列類型共同特性

python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：

len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]

sorted(s,key=lambda s:s[1]) //按照數字排序

reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列類型的切片操作：

Slice:

L[index]; 訪問某個元素；

L[1:4]; 區間

L[star:stop:step]; 設置步長取區間元素

❻ Python中的幾種數據類型

大體上把Python中的數據類型分為如下幾類：
Number(數字) 包括int,long,float,complex
String(字元串) 例如：hello,hello,hello
List(列表) 例如：[1,2,3],[1,2,3,[1,2,3],4]
Dictionary(字典) 例如：{1:nihao,2:hello}
Tuple(元組) 例如：(1,2,3,abc)
Bool(布爾) 包括True、False
由於Python中認為所有的東西都是對象，所以Python不用像其它一些高級語言那樣主動聲缺慎豎明一個變數的類型。
例如我要給一個變數i賦值100，python的實現 ：
i=100
C#的實現：
int i = 100;
下面一一簡單介紹這幾種數據類型
數字類型
int和long
之所以要把int和long放在一起的原因是python3.x之後已經不區分int和long,統一用int。python2.x還是區分的。下面我以Python2.7為例：
i = 10
type(i)
i=10000000000
type(i)
那麼為什麼10就是int,10000000000就是long呢，當然這就和int的最大值有關了，int類孝毀型的最大值為231-1，即2147483647，也可以用sys.maxint。
2**31-1
2147483647L
sys.maxint
2147483647
為什麼用上面的方法求的值就是long型的呢(數字後面加『L』表示是long型)，因為2**31的值為2147483648,這個值是一個long型，用一個long型減去1，結果還是一個long,但實際上int型的最大值就是2147483647
type(2147483647)
type(2147483648)
float類型
float類型和其它語言的float基本一致，浮點數，說白了，就是帶小數點的數，精度與機器相關。例如：
i = 10000.1212
type(i)
complex：復數類型，具體含義及用法可自行查看相關文檔。
字元串類型
字元串的聲明有三種方式：單引號、雙引號和三引號(包括三個單引號或三個雙引號)。例如：
str1 = hello world
str2 = hello world
str3 = hello world
str4 = hello world
print str1
hello world
print str2
hello world
print str3
hello world
print str4
hello world
Python中的字元串有兩種數據類型：str類型和unicode類型。str類型採用的ASCII編碼，也就是說它無法表示中文。unicode類型採用unicode編碼，能夠表示任意字元，包括中文及其它語言。並且python中不存在像c語言中的char類型，就算是單個字元也是字元串類型。字元串默認採用的ASCII編碼，如果要顯示聲明為unicode類型的話，需要在字伏大符串前面加上u或者U。例如：
str1 = hello
print str1
hello
str2 = u中國
print str2
中國
由於項目中經常出現對字元串的操作，而且由於字元串編碼問題出現的問題很多，下面，來說一下關於字元串的編碼問題。在與python打交道的過程中經常會碰到ASCII、Unicode和UTF-8三種編碼。具體的介紹請參見這篇文章。我簡單的理解就是，ASCII編碼適用英文字元，Unicode適用於非英文字元(例如中文、韓文等)，而utf-8則是一種儲存和傳送的格式，是對Uncode字元的再編碼(以8位為單位編碼)。例如：
u = u漢
print repr(u) # uu6c49
s = u.encode(UTF-8)
print repr(s) # xe6xb1x89
u2 = s.decode(UTF-8)
print repr(u2) # uu6c49
解釋：聲明unicode字元串」漢「，它的unicode編碼為」u6c49「，經過utf-8編碼轉換後，它的編碼變成」xe6xb1x89「。
對於編碼的經驗總結：
1.在python文件頭聲明編碼格式 ;
#-*- coding: utf-8 -*-
2.將字元串統一聲明為unicode類型，即在字元串前加u或者U;
3.對於文件讀寫的操作，建議適用codecs.open()代替內置的open()，遵循一個原則，用哪種格式寫，就用哪種格式讀;
假設在一個以ANSI格式保存的文本文件中有「中國漢字」幾個字，如果直接用以下代碼，並且要在GUI上或者在一個IDE中列印出來(例如在sublime text中，或者在pydev中列印)，就會出現亂碼或者異常，因為codecs會依據文本本身的編碼格式讀取內容：
f = codecs.open(d:/test.txt)
content = f.read()
f.close()
print content
改用如下方法即可(只對中文起作用)：
# -*- coding: utf-8 -*-
import codecs
f = codecs.open(d:/test.txt)
content = f.read()
f.close()
if isinstance(content,unicode):
print content.encode(utf-8)
print utf-8
else:
print content.decode(gbk).encode(utf-8)
列表類型
列表是一種可修改的集合類型，其元素可以是數字、string等基本類型，也可以是列表、元組、字典等集合對象，甚至可以是自定義的類型。其定義方式如下：
nums = [1,2,3,4]
type(nums)
print nums
[1, 2, 3, 4]
strs = [hello,world]
print strs
[hello, world]
lst = [1,hello,False,nums,strs]
type(lst)
print lst
[1, hello, False, [1, 2, 3, 4], [hello, world]]
用索引的方式訪問列表元素，索引從0開始,支持負數索引，-1為最後一個.
lst = [1,2,3,4,5]
print lst[0]
1
print lst[-1]
5
print lst[-2]
4
支持分片操作，可訪問一個區間內的元素，支持不同的步長，可利用分片進行數據插入與復制操作
nums = [1,2,3,4,5]
print nums[0:3] #[1, 2, 3] #前三個元素
print nums[3:] #[4, 5] #後兩個元素
print nums[-3:] #[3, 4, 5] #後三個元素 不支持nums[-3:0]
numsclone = nums[:]
print numsclone #[1, 2, 3, 4, 5] 復制操作
print nums[0:4:2] #[1, 3] 步長為2
nums[3:3] = [three,four] #[1, 2, 3, three, four, 4, 5] 在3和4之間插入
nums[3:5] = [] #[1, 2, 3, 4, 5] 將第4和第5個元素替換為[] 即刪除[three,four]
支持加法和乘法操作
lst1 = [hello,world]
lst2 = [good,time]
print lst1+lst2 #[hello, world, good, time]
print lst1*5 #[hello, world, hello, world, hello, world, hello, world, hello, world]
列表所支持的方法，可以用如下方式查看列表支持的公共方法：
[x for x in dir([]) if not x.startswith(__)]
[append, count, extend, index, insert, pop, remove, reverse, sort]
def compare(x,y):
return 1 if xy else -1
#【append】 在列表末尾插入元素
lst = [1,2,3,4,5]
lst.append(6)
print lst #[1, 2, 3, 4, 5, 6]
lst.append(hello)
print lst #[1, 2, 3, 4, 5, 6]
#【pop】 刪除一個元素，並返回此元素的值 支持索引 默認為最後一個
x = lst.pop()
print x,lst #hello [1, 2, 3, 4, 5, 6] #默認刪除最後一個元素
x = lst.pop(0)
print x,lst #1 [2, 3, 4, 5, 6] 刪除第一個元素
#【count】 返回一個元素出現的次數
print lst.count(2) #1
#【extend】 擴展列表 此方法與「+」操作的不同在於此方法改變原有列表，而「+」操作會產生一個新列表
lstextend = [hello,world]
lst.extend(lstextend)
print lst #[2, 3, 4, 5, 6, hello, world] 在lst的基礎上擴展了lstextend進來
#【index】 返回某個值第一次出現的索引位置，如果未找到會拋出異常
print lst.index(hello) #5
#print lst.index(kitty) #ValueError: kitty is not in list 出現異常
#【remove】 移除列表中的某個元素，如果待移除的項不存在，會拋出異常 無返回值
lst.remove(hello)
print lst #[2, 3, 4, 5, 6, world] hello 被移除
#lst.remove(kitty) #ValueError: list.remove(x): x not in list
#【reverse】 意為反轉 沒錯 就是將列表元素倒序排列,無返回值
print lst #[2, 3, 4, 5, 6, world]
lst.reverse()
print lst #[2, 3, 4, 5, 6, world]
#【sort】 排序
print lst #由於上面的反轉 目前排序為 [world, 6, 5, 4, 3, 2]
lst.sort()
print lst #排序後 [2, 3, 4, 5, 6, world]
nums = [10,5,4,2,3]
print nums #[10,5,4,2,3]
nums.sort(compare)
print nums #[2, 3, 4, 5, 10]
列表轉換為迭代器。
所謂的迭代器就是具有next方法(這個方法在調用時不需要任何參數)的對象。在調用next方法時，迭代器會返回它的下一個值。如果next方法被調用，但迭代器沒有值可以返回，就會引發一個StopIteration異常。迭代器相對於列表的優勢在於，使用迭代器不必一次性將列表加入內存，而可以依次訪問列表的數據。
依然用上面的方法查看迭代器的公共方法：
lst = [1,2,3,4,5]
lstiter = iter(lst)
print [x for x in dir(numiter) if not x.startswith(__)]
[next]
沒錯，只有next一個方法，對於一個迭代器，可以這樣操作：
lst = [1,2,3,4,5]
lstiter = iter(lst)
for i in range(len(lst)):
print lstiter.next() #依次列印
1
2
3
4
5
元組類型
元組類型和列表一樣，也是一種序列，與列表不同的是，元組是不可修改的。元組的聲明如下：
lst = (0,1,2,2,2)
lst1=(hello,)
lst2 = (hello)
print type(lst1) # 只有一個元素的情況下後面要加逗號 否則就是str類型
print type(lst2) #
字典類型
字典類型是一種鍵值對的集合，類似於C#中的Dictionary
dict1 = {}
print type(dict1) # 聲明一個空字典
dict2 = {name:kitty,age:18} #直接聲明字典類型
dict3 = dict([(name,kitty),(age,18)]) #利用dict函數將列表轉換成字典
dict4 = dict(name=kitty,age=18) #利用dict函數通過關鍵字參數轉換為字典
dict5 = {}.fromkeys([name,age]) #利用fromkeys函數將key值列表生成字典，對應的值為None {age: None, name: None}
字典基本的操作方法：
#【添加元素】
dict1 = {}
dict1[mykey] = hello world #直接給一個不存在的鍵值對賦值 即時添加新元素
dict1[(my,key)] = this key is a tuple #字典的鍵可以是任何一中不可變類型，例如數字、字元串、元組等
#【鍵值對個數】
print len(dict1)
#【檢查是否含有鍵】
print mykey in dict1 #True 檢查是否含有鍵為mykey的鍵值對
print hello in dict1 #False
#【刪除】
del dict1[mykey] #刪除鍵為mykey的鍵值對
繼續利用上面的方法查看字典的所有公共方法：
[x for x in dir({}) if not x.startswith(__)]
[clear, , fromkeys, get, has_key, items, iteritems, iterkeys, itervalues,
keys, pop, popitem, setdefault, update, values, viewitems, viewkeys, viewvalues]
dict.clear() 刪除字典中所有元素
dict.() 返回字典(淺復制)的一個副本
dict.get(key,default=None) 對字典dict 中的鍵key,返回它對應的值value，如果字典中不存在此鍵，則返回default 的值(注意，參數default 的默認值為None)
dict.has_key(key) 如果鍵(key)在字典中存在，返回True，否則返回False. 在Python2.2版本引入in 和not in 後，此方法幾乎已廢棄不用了，但仍提供一個 可工作的介面。
dict.items() 返回一個包含字典中(鍵, 值)對元組的列表
dict.keys() 返回一個包含字典中鍵的列表
dict.values() 返回一個包含字典中所有值的列表
dict.iter() 方法iteritems(), iterkeys(), itervalues()與它們對應的非迭代方法一樣，不同的是它們返回一個迭代器，而不是一個列表。
dict.pop(key[, default]) 和方法get()相似，如果字典中key 鍵存在，刪除並返回dict[key]，如果key 鍵不存在，且沒有給出default 的值，引發KeyError 異常。
dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 鍵，由dict[key]=default 為它賦值。
dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 鍵，由dict[key]=default 為它賦值。
布爾類型
布爾類型即True和False,和其它語言中的布爾類型基本一致。下面列出典型的布爾值
print bool(0) #False
print bool(1) #True
print bool(-1) #True
print bool([]) #False
print bool(()) #False
print bool({}) #False
print bool() #False
print bool(None) #False

❼ python數據類型都有哪些

數據類型是每種編程語言必備的屬性，只有給數據賦予明確的數據類型，計算機才能對數據進行處理運算，因此，使用正確的數據類型是十分有必要的，以下是Python編程常用的數據類型：
一、數字型
Python數字類型主要包括int(整型)、long(長整型)和float(浮點型)，但是在Python3中就不再有long類型了。
1、int(整型)
在32位機器上，整數的位數是32位，取值范圍是-231~231-1，即-2147483648~214748364;在64位系統上，整數的位數為64位，取值范圍為-263~263-1，即9223372036854775808~9223372036854775807。
2、long(長整型)
Python長整型沒有指定位寬，但是由於機器內存有限，使用長的長整數數值也不可能無限大。
3、float(浮點型)
浮點型也就是帶有小數點的數，其精度和機器有關。
4、complex(復數)
Python還支持復數，復數由實數部分和虛數部分構成，可以用 a + bj,或者 complex(a,b) 表示， 復數的實部 a 和虛部 b
都是浮點型。
二、字元串
在Python中，加了引號的字元都被認為是字元串，其聲明有三種方式，分別是：單引號、雙引號和三引號;Python中的字元串有兩種數據類型，分別是str類型和unicode類型，str類型採用的ASCII編碼，無法表示中文，unicode類型採用unicode編碼，能夠表示任意字元，包括中文和其他語言。
三、布爾型
和其他編程語言一樣，Python布爾類型也是用於邏輯運算，有兩個值：True(真)和False(假)。
四、列表
列表是Python中使用最頻繁的數據類型，集合中可以放任何數據類型，可對集合進行創建、查找、切片、增加、修改、刪除、循環和排序操作。
五、元組
元組和列表一樣，也是一種序列，與列表不同的是，元組是不可修改的，元組用」()」標識，內部元素用逗號隔開。
六、字典
字典是一種鍵值對的集合，是除列表以外Python之中最靈活的內置數據結構類型，列表是有序的對象集合，字典是無序的對象集合。
七、集合
集合是一個無序的、不重復的數據組合，它的主要作用有兩個，分別是去重和關系測試。

❽ python數據類型有哪些

Python基本數據類型一般分為：數字、字元串、列表、元組、字典、集合這六種基本數據類型。

其中數字又包含整型(整型又包括標准整型、長整型(Python2.7及之前版本有)）、浮點型、復數類型、布爾型(布爾型就是只有兩個值的整型)、這幾種數字類型。列表、元組、字元串都是序列。

1、數字

數字類型是不可更改的對象。對變數改變數字值就是生成/創建新的對象。Python支持多種數字類型：

整型(標准整型和長整型(Python2.7及之前的有這種類型))、布爾型、雙精度浮點型、十進制浮點型、復數。

2、標准整型

int，標准整型，在大多數32位機器上標准整型取值范圍是-2^31到2^31-1，也就是-2147483648~2147483647，如果在64位機器使用64位編譯器，那麼這個系統的標准整型將是64位。

3、布爾型

bool，從Python2.3開始Python中添加了布爾類型。布爾類型有兩種True和False。對於沒有__nozero__方法的對象默認是True。

對於值為0的數字、空集（空列表、空元組、空字典等）在Python中的布爾類型中都是False。

>>>bool(1)
True
>>>bool('a')
True
>>>bool(0)
False
>>>bool('')
False

4、浮點型

float，每個浮點型佔8個位元組（64位），完全遵守IEEE754號規范（52M/11E/1S）,其中52個位用於表示底，11個位用於表示指數（可表示的范圍大約是±10**308.25），剩下的一個位表示符號。這看上去相當完美，然而，實際精度依賴於機器架構和創建Python解釋器的編譯器。

浮點型值通常都有一個小數點和一個可選的後綴e（大寫或小寫，表示科學計數法）。在e和指數之間可以用正（+）或負（-）表示指數的正負（正數的話可以省略符號）。

以上是Python核心編程的對浮點型(雙精度浮點型)的說明。經過Python實測浮點型默認長度是24位元組如果超出這個范圍會自動

5、復數類型

complex，在復數中虛數不能單獨存在，它們總是和一個值為0.0的實數部分一起來構成一個復數。復數由實數部分和虛數部分構成。表示虛數的語法：real+imagj。

實數部分和虛數部分都是浮點型。虛數部分必須有後綴j或J。

❾ python怎麼將string轉換成bigint

用long函數進行轉換。如：

s='123456789123456789'
y=long(s)
printy+100