03-Python數據類型

None類型

Python3中沒有NULL，取而代之的是空類型None、空列表、空字典等。
None是一個特殊的Python對象，表示無。
None的類型是NoneType。

如果只想聲明變量，而不想賦值，可以這麼做：

a=None     #聲明一個變量

通過type()函數可以查看變量的類型:

a=None
print(type(a))  #輸出<class 'NoneType'>

數字類型

Python3中有以下數字類型：

int #整數
float #浮點數
bool #布爾類型
complex #複數

小貼士：

Python2中還有long類型。
到了Python3中，整數都變成了int。

int整數

示例：

a=1     #定義一個int型變量

強制轉換：

print(float(2))     #將int轉換成float (結果爲2.0)
print(chr(65))      #將一個整數轉換爲一個字符 (結果爲A)
print(ord('a'))     #將一個字符轉換爲它的整數值 (結果爲97)
print(hex(15))      #將一個整數轉換爲一個十六進制字符串 (結果爲0xf)
print(oct(10))      #將一個整數轉換爲一個八進制字符串 (結果爲0o12)

float浮點數

示例：

a=2.4       #定義一個float變量

強制轉換：

int(2.4)   #將浮點數強制轉換成int,會將小數部分剔除 (結果爲2)

bool布爾類型

bool類型只有兩個值：True和False。

示例：

b=True
b= 1>3 and 4>0  #邏輯語句(結果爲False)

在Python中，0、None、空列表、空字典等爲False，其他都爲真。

但None和空列表等比較特殊：

a=None and True     #結果爲None
b=None and False    #結果爲None
c=[] and True       #結果爲[]
d=[] and False      #結果爲[]

a=None or True     #結果爲True
b=None or False    #結果爲False
c=[] or True       #結果爲True
d=[] or False      #結果爲False

print(not [])      #結果爲True
print(not None)    #結果爲True

complex

complex由實數和虛數組合構成，分別表示爲：x+yj。
其中，x和y都是浮點數。

示例：

a=1+2.3j        #定義一個複數
a=complex(2,3)  #定義一個複數

complex可以進行算術運算：

a=1+2j
b=2+3j
print(a+b)

complex的屬性與函數：

a=1+2.3j
print(a.real)   #返回實部 (結果爲1.0)
print(a.imag)   #返回虛部 (結果爲2.3)
print(a.conjugate())    #返回共軛複數 (結果爲1-2.3j)

List列表

什麼是列表

List類似C語言中的數組，但List能提供更爲強大的功能，如增刪改查、排序、切片等
列表中的元素可以是不同的數據類型。
下標從0開始

示例：

a=[11,22,33,44]     #定義一個列表
a=['張三',18,"男"]  #列表中的元素可以不同數據類型

訪問元素：

a=[11,22,33,44]
print(a[0])     #訪問下標爲0的元素，輸出11

List嵌套

List中可以是不同數據類型：

a=[1,2,'abc']

既然說列表中的元素可以是不同數據類型，那麼元素也可以是List:

a=[11,22,[1,2,3,4],44]
print(a[2])     #輸出[1, 2, 3, 4]
print( a[2][1] )#輸出2

解釋：

a[2]得到的元素也是一個列表[1,2,3,4]
a[2][1]表示得到列表中的列表中的元素2，將a[2]看作一個整體
a[2][1]形式與C/C++等語言中的二位數組類似。

增-往列表中添加數據

追加、插入

a=[11,22,33,44]
a.append('abc')     #在最後追加元素'abc'
a.insert(2,'qwe')   #在下標2處添加元素'qwe',原先2以後的元素依次後移
print(a)            #輸出[11, 22, 'qwe', 33, 44, 'abc']

合併列表

a=[11,22,33,44]
b=['aa','bb']
c = a+b       #列表合併後賦值給c (a和b本身無變化)
print(c)      #輸出[11, 22, 33, 44, 'aa', 'bb']

a=[11,22,33,44]
b=['aa','bb']
a.extend(b) #將列表b插入到a的後面
print(a)    #輸出[11, 22, 33, 44, 'aa', 'bb']

刪-刪除列表中的元素

remove()

a=['aaa','bbb','ccc','bbb']
a.remove('bbb')     #刪除第一個'bbb',a變成['aaa', 'ccc', 'bbb']
a.remove(a[2])      #刪除下標爲2的元素

通過a.remove('bbb')可以知道remove函數是通過元素值來刪除的。

a.remove(a[2])適用於元素不重複的列表，不然可能刪除的不是下標爲2的元素，而是在這之前的、與a[2]內容相同的元素。

pop()

a=['aaa','bbb','ccc','bbb']
a.pop(2)    #刪除下標爲2的元素,返回刪除的值
a.pop()     #刪除最後的元素,返回刪除的值

a=['aaa','bbb','ccc','bbb']
del a[2]    #刪除下標爲2的元素
del a       #刪除此列表

clear()清空列表

a.clear()   #清空列表

進階：通過append()和pop()實現棧的功能

append()追加，用於入棧
pop()彈出，用於出棧

a=[]
a.append(1)     #入棧 (a=[1])
a.append(2)     #入棧 (a=[1,2])
i=a.pop()       #出棧 (a=[1],i=2)

查-查詢列表中的元素

通過下標可以直接查詢

a=['aaa','bbb','ccc','bbb']
print(a[1])     #輸出bbb

通過運算符 in 可以查詢是否存在某元素

a=['aaa','bbb','ccc','bbb']
if "ccc" in a:
    print("a中存在元素'ccc'")

解釋：

“ccc” in a 將返回bool值

若a中存在元素"ccc"，則返回True，否則返回False

與運算符in對應的是not in

切片

通過切片可以截取列表中的片段

切片語法:

a = ['aaa','bbb','ccc','ddd']
b = a[0:2]    #截取下標0~1的元素，產生新列表賦值給b
b = a[1:]     #截取下標1到最後一個元素

結果：

['aaa', 'bbb']
['bbb', 'ccc', 'ddd']

解釋：

b = a[0:2]中的0表示切片起始下標(包括下標0)

b = a[0:2]中的2表示切片結束下標(不包括下標2)

如果省略結束下標，即一直切片到最後一個元素

切片-步長

示例：

a = ['aaa','bbb','ccc','ddd','eee','fff','ggg']
b = a[0:5:2]    #結果爲['aaa', 'ccc', 'eee']

解釋：

b = a[0:5:2]中的2表示步長
步長爲2時，切片就會間隔2個元素進行截取元素。
上例將bbb、ddd、fff丟棄，切片到fff結束

當步長爲負數時，表示從右往左切片。

a = ['aaa','bbb','ccc','ddd']
b = a[-1:-3:-1]     #結果爲['ddd', 'ccc']

解釋：

最後的-1表示步長
當步長爲負數時，表示從右往左切片
-1代表倒數第一個字符
-3代表倒數第三個字符
默認步長爲1，表示從左到右無間隔切片

改-修改列表中的元素

通過下標修改：

a = ['aaa','bbb','ccc','ddd']
a[1]='111'     #將'bbb'修改爲'111'
print(a)       #結果爲['aaa', '111', 'ccc', 'ddd']

通過切片修改：

a = ['aaa','bbb','ccc','ddd']
a[1:3]=['111','222']    #將下標1~2修改爲'111','222'
print(a)       #結果爲['aaa', '111', '222', 'ddd']

列表-排序

a = ['aaa','bbb','ccc','ddd']
a.sort()                #從小到大排序(會改變自身)
a.sort(reverse=True)    #從大到小排序
b=sorted(a)             #將a排序後返回給b，a不發生變化
a.reverse()             #反轉

列表-內置函數

a = ['aaa','bbb','aaa','bbb']
print( a.index('bbb') )   #查找元素bbb的下標(若有多個，只返回第一個)(此結果爲1)
print( a.count('bbb') )   #返回元素222的數量 (結果爲2)
print( len(a) )           #返回列表元素個數 (結果爲4)

遍歷列表

在Python中，只要爲序列，就可以被遍歷，List自然不例外

示例：

a = ['aa','bb','cc','dd']
for i in a:
    print(i)

結果：

aa
bb
cc
dd

元組Tuple

元組和List類似，擁有很多一樣的屬性和方法。
唯一的區別是：元組內的元素不可被修改。

示例：

a = ('aaa','bbb','ccc','ddd')
print(a[2])     #輸出ccc

字典Dictionary

什麼是字典

字典有以下特徵：

Python中唯一的映射類型
由鍵和值構成
通過鍵存取元素，所以鍵唯一
無序存儲，會被哈希
鍵必須是不可變類型
- 可變類型：列表，字典等
- 不可變類型：整型，浮點型，布爾型，元組等

舉例：

dic1={'name':'flight','age':20,'sex':'male'}        #定義一個字典

一個鍵對應一個值：

增加和修改元素

在字典中，鍵相當於List中的下標，通過鍵就可以對值進行存取

例如：

dic1['age']=20      #通過下標修改或增加鍵值對

當字典中不存在此鍵時，就添加此鍵值對。

示例：

dic1={'name':'張三','age':18,'sex':'男'}
print( dic1['name'] )       #輸出：張三
dic1['age']=20              #將age修改爲20
dic1['favorable']='計算機'  #添加鍵值對'favorable':'計算機'

查詢元素

在字典中，鍵相當於List中的下標，通過鍵就可以對值進行存取

同樣的道理，通過鍵來取出想要的鍵值對。

示例：

dic1={'name':'張三','age':18,'sex':'男'}
dic1['name']       #取值(不存在則報錯)
dic1.get('name')   #取值(不存在不報錯)

通過in、not in查詢：

dic1={'name':'張三','age':18,'sex':'男'}
if 'name' in dic1:      #dic1中存在此鍵則爲True
    print("dic1中有'name'鍵")

刪除元素

dic1={'name':'張三','age':18,'sex':'男'}

del dic1['name']        #刪除鍵爲'name'的鍵值對
del dic1                #刪除整個字典
dic1.clear()            #清空字典
myName=dic1.pop('name') #刪除鍵爲'name'的鍵值對，並返回'name'的值
kv=dic1.popitem()       #刪除最後添加到字典中的鍵值對,並返回此鍵值對

排序

字典的鍵是無序的。
sorted函數可以得到一個根據鍵排序後的列表，再根據此列表進一步得到相應的值。

示例：

dic1={'name':'張三','age':18,'sex':'男'}
list1 = sorted(dic1)    #得到['age', 'name', 'sex']
for i in list1:
    print(dic1[i])

結果：

18
張三
男

字典中的內置函數

setdefault()函數

dic1={'name':'張三','age':20,'sex':'男'}
a=dic1.setdefault('age',18)     #如果存在此鍵，不作任何變動；如果不存在，增加此鍵值對
			        #還返回age此時的值

keys()、values()、items()

dic1={'name':'張三','age':20,'sex':'男'}
list(dic1.keys())     #得到所有的鍵,list做強制轉換
list(dic1.values())   #得到所有的值,list做強制轉換
list(dic1.items())    #得到所有的鍵值對,list做強制轉換

update()

dic1={'name':'張三','age':20}
dic_temp={'name':'李四','birthday':'1998-01-01'}
dic1.update(dic_temp)  #將dic_temp加入到dic中，鍵重複則覆蓋
print(dic1)     #結果爲{'name': '李四', 'age': 20, 'birthday': '1998-01-01'}

fromkeys()

dic1=dict.fromkeys(['host1','host2','host3'],'test')   #創建並初始化字典
print(dic1)

結果：

{'host1': 'test', 'host2': 'test', 'host3': 'test'}

解釋：

fromkeys()函數用於創建並初始化字典
參數1：key
參數2：value
每一個鍵對應的值都爲’test’

集合-Set

什麼是集合

集合（set）是一個無序的、不重複元素序列。
集合中的元素可以是不同數據類型。
可以使用大括號 { } 或者 set() 函數創建集合
注意：創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。

創建一個集合：

s1=set()        #創建一個空集合
s2={1,2,3,1,2}  #會被去掉重複項，變成{1, 2, 3}
s=set('Hello') #s={'H','e','l','o'}

強制轉換：

list1=[1,2,3,1,2]s1=set(list1)       #將List轉換成set，去除重複項list1=list(s1)      #將Set轉換成List，變成[1, 2, 3]

List和Set可以互相轉換

增

s={1,2,3}

s.add('uu')        #增加一個元素
s.update('pos')    #增加'p', 'o', 's'三個元素
s.update('a','b')  #增加'a','b'兩個元素(update函數可以傳入多個參數)

刪

s={1,2,3}

s.remove('o')  #移除元素'o'
chr=s.pop()    #隨機彈出一個值，並返回這個值
s.clear()      #清空集合

查

s={1,2,3}

if 1 in s:     #查詢s中是否含有元素 1
    print("s中含有元素1")

集合運算

a < b     #判斷a是否屬於b，相當於a.issubset(b)
a > b    #判斷b是否屬於a，相當於a.issuperset(b)
a == b    #判斷a和b是否相等

還有>=、<=負號

a & b   #交集，相當於a.intersection(b)
a | b  #並集，相當於a.union(b)
a - b  #差集，相當於a.difference(b)
a ^ b  #對稱差集(去除交集後的並集),相當於a.symmetric_difference(b)

示例:

a={1,2}
b={1,2,3}
print(a<b) #判斷a是否屬於b

字符串-String

關於String

在Python中，單引號和雙引號的作用是一樣的

s1='eagle'
s2="eagle"

多行字符串：

msg='''
    hello1
    hello2
    hello3
'''

字符串中帶有單引號和雙引號：

print("it's mother's apple")    #輸出單引號
print('"I love you"said Tom')   #輸出雙引號
print(''' aaa""bbb''ccc''')     #輸出單雙引號

字符串運算

切片：同樣可以像List一樣切片

s1='eagle'
s2=s1[1:3]      #s2='ag'
print(s2)

通過下標[]獲取字符

s="hello"
print(s[1])     #輸出e

乘法與加法

"123qwe"*2          #結果爲'123qwe123qwe'
c='123'+'abc'     #效率比較低，可以使用join方法(結果爲'123abc')

in和not in運算符

if 'el' in 'hello':    #判斷'el'是否存在於'hello'中
    print('''  "hello"中含有字串'el'  ''')

轉義符

示例：

s="hello\nworld"    #\n被轉義成換行
print(s)

結果：

hello
world

取消轉義

s=r"hello\nworld"    #字符串前加 r，表示取消轉義
print(s)       #結果爲hello\nworld

轉義符：

轉義字符	描述
\(在行尾時)	續行符
\\	反斜槓符號
\’	單引號
\"	雙引號
\a	響鈴
\b	退格(Backspace)
\000	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁
\oyy	八進制數，yy 代表的字符，例如：\o12 代表換行，其中 o 是字母，不是數字 0。
\xyy	十六進制數，yy代表的字符，例如：\x0a代表換行
\other	其它的字符以普通格式輸出

強制轉換

Python中，萬物皆可轉化爲字符串。

示例：

str([1,2,3])
str({"name":"張三","age":18})

字符串中的內置函數

s='+'.join(['a','b'])   #使用'+'連接'a'和'b' (結果爲'a+b')
s=''.join(['a','b'])    #連接列表中的元素 (結果爲'ab')
s='+'.join('abc')       #使用'+'夾在'abc'各字母的中間 (結果爲'a+b+c')
s='hello my home'.split(' ')   #使用' '分割字符串，返回一個列表 (結果爲['hello', 'my', 'home'])
c='hello'.count('l')       #計算字母的個數 (結果爲2)
s='hello'.capitalize()     #將首字母大寫 (結果爲'Hello')
s='hello'.center(10,'-')   #字符串居中，'-'填充，總佔用10個位置 (結果爲'--hello---')
b='hello'.startswith('he') #查看字符串是否以he開頭，返回布爾值 (結果爲True)
b='hello'.endswith('lo')   #查看字符串是否以lo結尾，返回布爾值 (結果爲True)
c='hello'.find('ll')       #查找'll'的下標 (結果爲2)
c='hello'.index('ll')      #查找'll'的下標，如果不存在則報錯 (結果爲2)
s='hello {name}'.format(name='flight') #將{name}置換成'flight'返回 (結果爲hello flight)
s='hello {name}'.format_map({'name':'flight'}) #參數爲字典 (結果爲hello flight)
b='123'.isdigit()          #查看字符串是否爲整型數字,返回bool值 (結果爲True)
b='2flight'.isidentifier() #查看字符串是否符合命名規則 (結果爲False)
b='aBc'.islower()      #查看字符串是否全小寫 (結果爲False)
b='aBc'.isupper()      #查看字符串是否全大寫 (結果爲False)
b='   \t'.isspace()    #查看字符串是否全爲空白字符 (結果爲True)
s='My'.lower() #所有大寫字母變小寫 (結果爲'my')
s='My'.upper() #所有小寫字母百年大寫 (結果爲'MY')
s='My'.swapcase()      #大寫變小寫，小寫變大寫 (結果爲'mY')
b='My Home'.istitle()  #查看字符串是否爲標題格式(所有單詞首字母大寫)(結果爲True)
s='Hello eagle'.title()    #將字符串變成title格式 (結果爲'Hello Eagle')
s=' hello \n'.strip()  #將字符串開頭和結尾的空格、換行符和製表符去除 (結果爲'hello')
s='hello'.replace('he','123')  #將'he'替換成'123' (結果爲'123llo')