核心數字類型：

數字：int，long，float，complex，bool

字符：str，unicode

列表：list

字典：dict

元組：tuple

文件：file

其他類型：集合(set),frozenset,類型，None

其他文件類工具：pipes，fifos，sockets.

類型轉換：

str(),repr()或format():將非字符型數據轉換成字符；

int():轉換為整數

float():轉換為浮點數

list(x):可以把字符串x轉換為列表，

tuple(x):將字符串x轉換為元組；

set(x):將字符串轉換為集合.

dict(d):創建字典，其d必須是[(key,value),(key,value)]的元組序列：

chr(x):將整數轉為字符.

ord(x):將字符轉換為整數值.

hex(x):將整數轉換為16進制字符.

bin(x):將整數轉換為2進制字符.

數字類型：

Python的數字字面量：布爾型，整數，浮點數，復數

True:1

False:0

序列類型：

字符類型：

字符串字面量：把文本放入單引號、雙引號或三引號中：

如果要使用unicode編碼，則在字符之前使用字符u進行表示，如u"xxx"

適用于所有序列的操作和方法：

s[i]:索引運算符

s[i:j]:為切片運算符，s[i:j:stride]為擴展切片運算符

min(s)和max(s)只適用于能夠對元素排序的序列

sum(s)只適用于數字序列

all(s)檢查s中的所有項是否為True

any(s)檢查s中的任意項是否為False>>>?str="9876544531"

>>>?min(str)

‘1‘

>>>?max(str)

‘9‘

用于字符串的操作：

Python2 提供兩種字符串對象類型：

字節字符串：字節序列

unicode字符串：Unicode字符序列

Python可以使用32bit整數保存Unicode字符，但此為可選特性.>>>?str2="hellow"

>>>?str2.islower()

True

>>>?str2.isupper()

False

>>>?str2.upper()

‘HELLOW‘

capitalize 字符串的首字母大寫s.capitalize()

s.index(sub[,start[,end]]) 找到指定字符串sub首次出現的位置，否則報錯

s.join(t) 使用s作為分隔符連接序列t中的字符串

s.lower() 轉換為小寫形式

s.split([sep[,maxsplit]]) 使用sep作為分隔符對一個字符串進行劃分。maxsplit是劃分的最大次數

s.strip 刪掉chrs開頭和結尾的空白或字符

s.upper()將一個字符串轉換為大寫形式

replace(‘old‘,‘new‘) 將所有舊的字符串替換為新的字符串

str="hello?world"

l2=list(str)

print?l2

str3=‘‘.join(l2)#使用空白作為分隔符將list列表組合起來.

print?str3str="hello?world"

print?str.replace(‘hello‘,‘HELLO‘)

split 以.為分隔符，對字符串進行操作.str="www.baidu.com"

print?str.split(‘.‘)

[‘www‘,?‘baidu‘,?‘com‘]

s.strip()用來刪除s字符串左右兩邊的空白字符的.str="???hello????"

print?str.strip()

hello

列表：

容器類型：

任意對象的有序集合，通過索引訪問其中的元素，可變對象，

異構，任意嵌套

支持在原處修改：

修改指定的索引

del() 刪除列表中的元素

append() 新增列表中的元素str=[‘1‘,‘a‘,‘b‘,‘7‘]

del(str[1:])

print?str

結果:[1]

str=[‘1‘,‘a‘,‘b‘,‘7‘]

str.append("hello")

print?str

結果:[‘1‘,?‘a‘,?‘b‘,?‘7‘,?‘hello‘]

count() 獲取指定列表中元素出現的次數str=[‘1‘,‘a‘,‘b‘,‘7‘]

print?str.count(‘a‘)

結果:1

extend() 列表擴充，將原先列表中的元素擴充進來.str=[‘1‘,‘a‘,‘b‘,‘7‘]

l1=[‘x‘,‘y‘,‘z‘]

str.extend(l1)

print?str

結果：[‘1‘,?‘a‘,?‘b‘,?‘7‘,?‘x‘,?‘y‘,?‘z‘]

append() 新增列表元素元素str=[‘1‘,‘a‘,‘b‘,‘7‘]

l1=[‘x‘,‘y‘,‘z‘]

str.append(l1)

print?str

結果：[‘1‘,?‘a‘,?‘b‘,?‘7‘,?[‘x‘,?‘y‘,?‘z‘]]

打印列表中某元素索引的位置.>>>?print?str

[‘1‘,?‘a‘,?‘b‘,?‘7‘,?‘x‘,?‘y‘,?‘z‘]

>>>?str.index(‘a‘)

1

s.insert 在索引的位置添加新的字符串.>>>?str.insert(1,"ccc")

>>>?print?str

[‘1‘,?‘ccc‘,?‘a‘,?‘b‘,?‘7‘,?‘x‘,?‘y‘,?‘z‘]

s.pop彈出某個索引對應的元素，默認為彈出最后一個列表的元素.

彈出以后將返回這個元素.>>>?print?str

[‘1‘,?‘ccc‘,?‘a‘,?‘b‘,?‘7‘,?‘x‘,?‘y‘,?‘z‘]

>>>?str.pop(2)

‘a‘

>>>?str.pop()

‘z‘

s.remove()刪除列表中指定元素的值>>>?str.remove(‘y‘)

>>>?print?str

[‘1‘,?‘ccc‘,?‘b‘,?‘7‘,?‘x‘]

>>>?str.remove(‘b‘)

>>>?print?str

[‘1‘,?‘ccc‘,?‘7‘,?‘x‘]

s.sort排序,正序；在原處修改，沒人任何返回.>>>?print?str

[‘1‘,?‘ccc‘,?‘7‘,?‘x‘]

>>>?str.sort()

>>>?print?str

[‘1‘,?‘7‘,?‘ccc‘,?‘x‘]

s.reserse 逆序，倒序>>>?print?str

[‘1‘,?‘7‘,?‘ccc‘,?‘x‘]

>>>?str.reverse()

>>>?print?str

[‘x‘,?‘ccc‘,?‘7‘,?‘1‘]

l1+l2：合并兩個列表，返回一個新的列表，不會修改原列表.>>>?l1=[1,2,3]

>>>?l2=[7,8,10]

>>>?l1+l2

[1,?2,?3,?7,?8,?10]

l1 * N：把l1重復N次，返回一個新列表.>>>?l1=[1,2,3]

>>>?l1?*?3

[1,?2,?3,?1,?2,?3,?1,?2,?3]

in:成員關系判斷字符

用法：某個元素in 某個容器>>>?2?in?l1

True

>>>?2?in?l2

False

not in ：判斷某個元素不在某個列表中.

列表解析：[]

深度復制列表中的元素,內存中所引用的對象發生變化。

copy.deepcopy()

實例：import?copy

l1=[1,2,3]

l2=copy.deepcopy(l1)

print?l2

l1.append(4)

print?l1

print?l2

l2等于l1列表中的所有元素.

l2=l1[:]

元組：

表達式符號:()

容器類型

任意對象的有序集合，通過索引訪問其中的元素，不可變對象，長度固定.

雖然元組本身不可變，但如果元組內嵌套了可變類型的元素，那么此類元素的修改不會返回新元組.

列子：l1=(1,2,3,[‘a‘,‘b‘,‘c‘])

print?l1

print?l1[3]

l1[3].pop()

print?l1

字典：dict

字典在其他編程語言中又稱作關聯數組或散列表；

通過鍵實現元素存取;無序集合;可變類容器，長度可變，異構，嵌套.

{key:value1，key2:value2}

{}空字典

l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print l1["x"]

結果為：[‘a‘, ‘b‘, ‘c‘]

對于字典的引用，需要使用key調用對應的值;

字典也支持切片:l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1["x"][1:]

[‘b‘,?‘c‘]

len()返回字典中元素的個數

l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print len(l1)

結果為：2

字典支持修改，元素可變：l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?id(l1)

print?l1["y"]

l1["y"]?=?504

print?l1

print?id(l1)

dicr.copy()復制copy，相當于完全copyl1l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1

l2=l1.copy()

print?l2

dict.get()獲取指定key的value值.l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1.get("x")

查看字典中有沒有x這個keyl1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1.get("x")

print?l1.has_key("x")

dict.get()和dict[s]區別在于：

dict.get()獲取字典中就算沒有這個值也不會報錯，但是要是dict[]這個值就會直接報錯.

dict.items將字典中的key:value以列表元組的形式拆開.l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1.items()

結果：[(‘y‘,?32),?(‘x‘,?[‘a‘,?‘b‘,?‘c‘])]

l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}

print?l1.items()

變量解包，元組支持解包，字典直接不支持解包.t1,t2=l1.items()

print?t1,t2

[(‘y‘,?32),?(‘x‘,?[‘a‘,?‘b‘,?‘c‘])]

(‘y‘,?32)?(‘x‘,?[‘a‘,?‘b‘,?‘c‘])

m1,m2={‘x‘:1,‘y‘:2}

print?m1,m2

結果：y?x??可以看到字典時無序的，不支持直接解包.

dict.keys()是key組成的列表，dict.values()字典值組成的列表.l1={‘x‘:21,‘y‘:5}

print?l1.keys()

print?l1.values()

dict.update()合并字典l1={‘x‘:21,‘y‘:5}

l2={‘a‘:21,‘b‘:7,‘x‘:32}

l1.update(l2)

print?l1

dict.next()迭代.l1={‘x‘:21,‘y‘:5}

i1=l1.iteritems()

print?i1.next()

zip函數：快速構建字典的方式print?zip(‘abcd‘,‘123‘)

print?dict(zip(‘abcd‘,‘123‘))

結果：

[(‘a‘,?‘1‘),?(‘b‘,?‘2‘),?(‘c‘,?‘3‘)]

{‘a‘:?‘1‘,?‘c‘:?‘3‘,?‘b‘:?‘2‘}

總結

以上是生活随笔為你收集整理的python内置类型_Python内置对象类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。