標準數據類型

Python 3中有六種標準的數據類型。

一、不可變數據類型

數字(Number)
字符串(String)
元組(Tuple)

1.數字(Number)

1. int(整型)

在64位系統上，整數的位數爲64位，取值範圍爲-2⁶³~2⁶³-1, 即-9223372036854775808 至 9223372036854775807

注意：在Python 3中不再有long類型了，全都是int

2. float(浮點型) ，即小數

注意：在混合運算中，Python會把整型轉換成浮點型。

3. bool(布爾類型)

注意：在 Python 2 中是沒有布爾型的，它用數字 0 表示 False，用 1 表示 True。到 Python 3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加。

4. complex(複數)

複數由實部和虛部構成，可以用a + bj,或者complex(a,b)表示，複數的實部a和虛部b都是浮點型。

內置函數type()可以用來查看數據類型

>>> a = 64
>>> type(a)
<class 'int'>

>>> a = 2**80
>>> type(a)
<class 'int'>			#整型

>>> b = 3.1415926535
>>> type(b)
<class 'float'>			#浮點型

>>> c = True
>>> type(c)
<class 'bool'>			#布爾型

>>> b + c
4.1415926535			#布爾型可以和數字相加

>>> d = complex(a,b)
>>> d
(1.2089258196146292e+24+3.1415926535j)
>>> type(d)
<class 'complex'>			#複數

2.字符串(String)

加了引號的字符都被認爲是字符串，同時使用反斜槓 \ 轉義特殊字符。

轉義字符

轉義字符	描述
\(在行尾時)	續行符
\\	反斜槓符號
\’	單引號
\"	雙引號
\a	響鈴
\b	退格
\e	轉義
\000	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁

單引號、雙引號無區別

可以在單引號內使用雙引號，也可以在雙引號內使用單引號。

如：hello_word = "Hi, I'm a boy."

多引號：

作用一：

多行註釋
作用二：格式化打印

msg = """
-------------------用戶登錄------------------
User_name = %s
Password = %s
-------------------%s------------------------
""" % (User_name, Password , Result)

字符串能跟字符串之間相加，即字符串的連接，跟數字相乘，即複製。

>>> given_name = 'Javier'
>>> family_name = ' Ji'
>>> given_name  + family_name
'Javier Ji'

>>> family_name * 3
' Ji Ji Ji'

特徵

字符串按照從左到右的順序定義字符集合，下標從0開始(與列表等類似)，有序
可以進行切片

>>> a = 'Javier Ji'
>>> a[::-1]
'iJ reivaJ'
>>> a[1:5]
'avie'

不可以對字符串中的某個字母進行修改，只能對該字符串整體進行重新賦值！

>>> a = 'Javier Ji'
>>> a
'Javier Ji'
>>> a[0]
'J'
>>> a[4]
'e'
>>> a[4] = 'b'


Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> a = 'Chica'
>>> a
'Chica'

取消轉義字符
方法一：在字符串引號前加r

>>> b = 'apple\tbanana'
>>> b
'apple\tbanana'
>>> print(b)
apple   banana
>>> c = r'apple\tbanana'
>>> c
'apple\\tbanana'
>>> print(c)
apple\tbanana

方法二：在轉義字符前加\

>>> d = 'apple\\tbanana'
>>> d
'apple\\tbanana'
>>> print(d)
apple\tbanana

字符串常用操作指令

names.capitalize(self)—>首字母大寫，其他字母小寫

>>> names = 'apple'
>>> print(names.capitalize())
Apple

names.casefold(self)—>字符串全變小寫，所有語言都適用

>>> names = 'APPLE'
>>> names.casefold()
'apple'

names.center(self,width,fillchar=None)—>字符串居中顯示，兩邊填充單一字符

>>> names.center(50,'*')
'**********************APPLE***********************'

names.count(self,sub,start=None,end=None)—>返回個數，顧頭不顧尾

>>> names.count('p')
0
>>> names.count('P',1,-1)
2
>>> names.count('P',1,-3)
1
>>> names.count('P',1,2)
1

names.endswith(self, suffix, start=None, end=None)—>判斷以什麼結尾

>>> names.endswith('P',-1)
False
>>> names.endswith('E',-1)
True
>>> names.endswith('P',2,4)
False
>>> names.endswith('P',2,3)
True

names.find(self, sub, start=None, end=None)—>查詢是否有該字符，有返回0，無返回-1

>>> names.find('A')
0
>>> names.find('a')
-1
>>> names.find('AP')
0
>>> names.find('AE')
-1

names.format()—>格式化輸出

>>> s = 'Hello {0}, I like {1}.'
>>> s.format('Jone','Chica')
'Hello Jone, I like Chica.'
>>> s1 = 'Hello {q}, I like {p}.'
>>> print(s1)
Hello {q}, I like {p}.
>>> s1.format(q='Jone',p='Chica')
'Hello Jone, I like Chica.'

names.index(self, sub, start=None, end=None)—>返回第一個sub的索引值

>>> names = "hello everyone, I'm Javier.001"
>>> names.index('e')
1

names.isdigit(self)—>若字符串中全是數字則返回True，否則返回False

>>> a = '1234657'
>>> a.isdigit()
True
>>> b = '1234567ji'
>>> b.isdigit()
False

names.islower(self)—>判斷字符串中的字母是否都爲小寫，若無字母或含有大寫字母，則返回False

>>> a = '1234657'
>>> a.islower()
False
>>> b = '1234567ji'
>>> b.islower()
True
>>> c = '   '
>>> c.islower()
False
>>> d = 'javier'
>>> d.islower()
True
>>> e = 'Javier'
>>> e.islower()
False
>>> f = 'javie r'
>>> f.islower()
True
>>> f = 'javie r1'
>>> f.islower()
True

names.isspace(self)—>若字符串中全是空格則返回True，否則返回False

>>> b = '1 2'
>>> b.isspace()
False
>>> c = '   '
>>> c.isspace()
True

names.isupper(self)—>判斷字符串中的字母是否都爲大寫

>>> e = 'Javier'
>>> e.isupper()
False
>>> g = 'JAVIER'
>>> g.isupper()
True

names.lower(self)—>將字符串中的大寫字母都轉換爲小寫，並返回。只對ASCII有效！！！

>>> g.lower()
'javier'
>>> e.lower()
'javier'

names.upper(self)—>將字符串中的小寫字母都轉換爲大寫，並返回。只對ASCII有效！！！

names.split(self,sep=None,maxsplit=-1)—>返回將字符串分隔後的列表

>>> names = 'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split()		#sep默認分割','
['Javier_Ji,Chica_Chen,Jone_Ji']
>>> names
'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split('_')	#sep增加參數後，以設定的參數分割
['Javier', 'Ji,Chica', 'Chen,Jone', 'Ji']

names.zfill(self,width)—>填充字符串至width長度，字符串左邊補0

>>> b
'1234567ji'
>>> b.zfill(15)
'0000001234567ji'

3.元組(Tuple)

元組又被稱爲只讀列表，不能修改元組內的元素

特徵

可存放多個值
元組內元素不可變
按照從左到右的順序定義元組元素，下標從0開始順序訪問，有序

元組的創建

>>> a = ('Javier','Chica',1,2,3)
>>> a
('Javier', 'Chica', 1, 2, 3)
>>> b = tuple(('Chica','Jone',5,8,6,9,7))
>>> b
('Chica', 'Jone', 5, 8, 6, 9, 7)

常用操作

索引、切片、循環輸出元組元素、計算元組長度、查詢是否包含某元素

注意：元組本身不可變，如果元組中包含其他可變元素，則這個可變元素可以被改變

二、可變數據類型

列表(List)
字典(Dict)
集合(Set)

1.列表(List)

特徵

可存放多個值
按照從左到右的順序定義列表元素，下標從0開始順序訪問，有序
可修改指定索引位置對應的值，可變
增、刪、查、改

增

append—>追加(在列表中最後一個元素的後面加上需要追加的元素)

>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names.append('Jone')
>>> names
['Javier', 'Chica', 'Jone']

insert—>插入(可在列表中任意位置插入)

>>> names
['Javier', 'Chica', 'Jone']
>>> names.insert(1,'Jack')
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names.insert(3,1)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone']
>>> names.insert(5,2)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2]
>>> names.insert(7,3)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]
>>> names.insert(0,0)
>>> names
[0, 'Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]

extend—>合併(可以把兩個列表中的元素合併，有前後之分)

>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names1 = ['Jone','Jack']
>>> names1
['Jone', 'Jack']
>>> names.extend(names1)
>>> names
['Javier', 'Chica', 'Jone', 'Jack']
>>> names1.extend(names)
>>> names1
['Jone', 'Jack', 'Javier', 'Chica', 'Jone', 'Jack']

列表嵌套

>>> names.insert(1,[1,2,3])
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> names[1][2]
3

刪

直接刪(del)

>>> names
['Javier', (0, 4, 5), [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1]
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1][1]
>>> names
['Javier', [1, 3], 'Chica', 'Jone', 'Jack']

pop刪(刪除後返回被刪除的值，默認刪除最後一個元素)

>>> names.pop()
'Jack'
>>> names
['Javier', [1, 3], 'Chica', 'Jone']
>>> names.pop(1)
[1, 3]
>>> names
['Javier', 'Chica', 'Jone']

clear清空(清除所有元素)

>>> names.clear()
>>> names
[]

改：修改指定位置元素

>>> names = ['Javier', 'Jack', 'Chica', 'Jone']
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names[0] = 'Ji'
>>> names[-1] = 'Chen'
>>> names
['Ji', 'Jack', 'Chica', 'Chen']

查

index—>返回索引值

>>> names
['Ji', 'Jack', 'Chica', 'Chen']
>>> names.index('Chica')
2

count--->返回該元素個數
>>> names.count('Ji')
1
>>> names.append('Ji')
>>> names
['Ji', 'Jack', 'Chica', 'Chen', 'Ji']
>>> names.count('Ji')
2

切片：特性.顧頭不顧尾
names[start:end]

步長：names[start:end:step] #step 默認是1，(-1時列表反轉，start、end無效)

sort—>排序(只能排單一數據類型的列表)

>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']
>>> names1.append('1')
>>> names1.append('2')
>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone', '1', '2']
>>> names1.sort()
>>> names1
['1', '2', 'Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']

reverse—>反轉

>>> names1.reverse()
>>> names1
['Jone', 'Jone', 'Javier', 'Jack', 'Jack', 'Candy', '2', '1']

循環列表

>>> for i in names1:
	...   print(i)
	...
	Jone
	Jone
	Javier
	Jack
	Jack
	Candy
	2
	1

2.字典(Dict)

{key1:value1,key2:value2}

鍵與值用冒號分開；
項與項用逗號分開。

特徵

key必須爲不可變數據類型、必須唯一
可存放多個value值、可以修改、可以不唯一
無序
查詢速度快，並且不受字典大小影響

創建字典

names = {'name':'Javier','sex':'male'}
names = dict(name = 'Javier', sex = 'male')
names = dict({'name':'Javier','sex':'male'})
names = {}.fromkeys([1,2,3,4,5],99)

>>> names = {}.fromkeys([1,2,3,4,5],99)
>>> names
{1: 99, 2: 99, 3: 99, 4: 99, 5: 99}

增

1.直接增加：

>>> names = {'name':'Javier','sex':'male'}
>>> names['age'] = 23
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23
2.增加方法：
names.setdefault(self,key,default)
>>> names.setdefault('gf','Chica')
'Chica'
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}

刪

1.pop刪：刪除指定key，並返回該key下的value
names.pop('age')

>>> names.pop('age')
23
>>> names
{'name': 'Javier', 'sex': 'male', 'gf': 'Chica'}

2.popitem刪：隨機刪除1個key，並返回

>>> names.popitem()
('gf', 'Chica')
>>> names
{'name': 'Javier', 'sex': 'male'}

3.del刪：刪除指定key，不返回

>>> del names['sex']
>>> names
{'name': 'Javier'}

4.clear清空：

>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names.clear()
>>> names
{}

改

1.直接改：

>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names['age'] = 18
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 18, 'gf': 'Chica'}

2.更新改：即可對原key進行修改，也可增加新key

>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names1 = {'name':'Jone','gpa':5.0}
>>> names.update(names1)
>>> names
{'name': 'Jone', 'sex': 'male', 'age': 23, 'gf': 'Chica', 'gpa': 5.0}

查

1.直接查，返回key對應的value，若key不在字典中，則報錯

>>> names['gf']
'Chica'
>>> names['bf']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'bf'

2.get查，
names.get(key,default = None)若key在字典中，則返回key對應的value，若key不在字典中，則返回default(默認爲不返回)

>>> names.get('gf')
'Chica'
>>> names.get('gf','none')
'Chica'
>>> names.get('bf','none')
'none'
>>> names.get('bf')

3.判斷key在不在字典中，在返回True,不在返回False

>>> 'gf' in names
True
>>> 'bf' in names
False

4.names.keys()—>返回字典中所有key的列表

>>> names.keys()
dict_keys(['name', 'sex', 'age', 'gf', 'gpa'])

5.names.values()—>返回字典中所有value的列表

>>> names.values()
dict_values(['Jone', 'male', 23, 'Chica', 5.0])

6.names.items()—>返回每組key和key對應的value形成的元組並組成的列表

>>> names.items()
dict_items([('name', 'Jone'), ('sex', 'male'), ('age', 23), ('gf', 'Chica'), ('gpa', 5.0)])

求長度：

>>> len(names)
5

3.集合(Set)

特徵

元素不可變，不能嵌套可變數據類型如list、dict，str、數字、tuple等，不可變類型可以嵌套
天生去重，集合中無重複元素
無序

集合的常用之處：去重、關係運算

創建集合

>>> a = {1,2,2,3,9,5,5,6,7,8,8,'Javier','Chica','Jone'}
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}

增：相同元素不能再被增加

>>> a.add(2)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}
>>> a.add(10)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 10, 'Javier', 'Chica'}

刪

a.discard(self,element)—>刪除指定元素，若元素不存在，則什麼都不做

>>> a.discard('Jone')
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}
>>> a.discard(0)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}

a.pop()—>隨機刪，並返回刪除的元素

>>> a.pop()
1
>>> a
{2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}

a.remove(self,element)—>刪除指定元素，若元素不存在，則報錯

>>> a.remove(10)
>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> a.remove(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10

查

>>> 2 in a
True
>>> 10 in a
False

4.集合中的關係運算

差集：返回集合a中包含而集合b中不包含的元素

a - b

>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> b = {0,1,2,4,6,8}
>>> a - b
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b - a
{0, 1, 4}

a.difference(self,s)

>>> a.difference(b)
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b.difference(a)
{0, 1, 4}

交集：返回集合a和集合b共同包含的元素

a & b

>>> a & b
{8, 2, 6}

a.intersection(self,s)

>>> a.intersection(b)
{8, 2, 6}

並集：返回一個新集合包含集合a和集合b的所有元素

a | b

>>> a | b
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}

a.union(self,s)

>>> a.union(b)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}

對稱差集：把腳踩兩隻船的人丟掉，也就是“並集-交集”

a ^ b

>>> a ^ b
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}

a.symmetric_difference(self,s)

>>> a.symmetric_difference(b)
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}

判斷兩集合之間的關係：

判斷兩集合是否不相交：不相交返回True，相交則返回False

>>> a.isdisjoint(b)
False
>>> c = {10,11,12,'Jone'}
>>> a.isdisjoint(c)
True

a.issubset(self,s)—>判斷a是不是s的子集

>>> a.issubset(b)
False
>>> b
{0, 1, 2, 4, 6, 8}
>>> d = {0,1,2,4,5,6,7,8,9}
>>> b.issubset(d)
True

a.issuperset(self,s)—>判斷a是不是s的父集

>>> a.issuperset(b)
False
>>> d.issuperset(b)
True

Python數據類型(史上最全~不談)

Python中的6種標準數據類型