數據類型

計算機顧名思義就是可以做數學計算的機器，因此，計算機程序理所當然地可以處理各種數值。但是，計算機能處理的遠不止數值，還可以處理文本、圖形、音頻、視

頻、網頁等各種各樣的數據，不同的數據，需要定義不同的數據類型。在Python中，能夠直接處理的數據類型有以下幾種

一 Number(數字)

1.1 數字類型的創建

1 a=10
2 b=a
3 b=666
4   
5 print(a)
6 ---->10
7 print(b)
8 ---->666

註意這裏與C的不同：

 1 #include <stdio.h>
 

 2 void main(void)
 3 {
 4   
 5     int a = 1;
 6     int b = a;
 7     printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
 8     a = 3;
 9     printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
10   
11 }
12   
13 //打印結果：
14 topeet@ubuntu:~$ gcc test.c
15 topeet@ubuntu:~$ ./a.out
 
16 a:adr:0x7fff343a069c,val:1
17 b:adr:0x7fff343a0698,val:1
18 a:adr:0x7fff343a069c,val:3
19 b:adr:0x7fff343a0698,val:1

1.2 Number 類型轉換

1 var1=3.14
2 var2=5
3 var3=int(var1)  # 取整數部分
4 var4=float(var2)  #保留小數點後的數
5   
6 print(var3,var4)
7 ---->3 5.0

python內置數學函數

 1 #abs(x)    　　　　    返回數字的絕對值，如abs(-10) 返回 10
 

 2 # ceil(x)    　　      返回數字的上入整數，如math.ceil(4.1) 返回 5
 3 # cmp(x, y)   　　     如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
 4 # exp(x)              返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
 5 # fabs(x)             返回數字的絕對值，如math.fabs(-10) 返回10.0
 6 # floor(x)            返回數字的下舍整數，如math.floor(4.9)返回 4
 7 # log(x)              如math.log(math.e)返回1.0,math.log(100,10)返回2.0
 8 # log10(x)            返回以10為基數的x的對數，如math.log10(100)返回 2.0
 9 # max(x1, x2,...)     返回給定參數的最大值，參數可以為序列。
10 # min(x1, x2,...)     返回給定參數的最小值，參數可以為序列。
11 # modf(x)             返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
12 # pow(x, y)           x**y 運算後的值。
13 # round(x [,n])       返回浮點數x的四舍五入值，如給出n值，則代表舍入到小數點後的位數。python3中小數點一位為5，則返回離整數最近的偶數。
14 # sqrt(x)             返回數字x的平方根，數字可以為負數，返回類型為實數，如math.sqrt(4)返回 2+0j          

二 字符串類型（string）

字符串是以單引號‘或雙引號"括起來的任意文本，比如‘abc‘，"123"等等。

請註意，‘‘或""本身只是一種表示方式，不是字符串的一部分，因此，字符串‘abc‘只有a，b，c這3個字符。如果‘本身也是一個字符，那就可以用""括起來，比

如"I‘m OK"包含的字符是I，‘，m，空格，O，K這6個字符。

2.1 創建字符串：

1 var1 = ‘Hello World!‘
2 var2 = "Python chenxiaomei"

字符串操作：

 1 #   * 重復輸出字符串
 2 print(‘hello‘*2)
 3 --->hellohello
 4   
 5 #  [] ,[:] 通過索引獲取字符串中字符,這裏和列表的切片操作是相同的,具體內容見列表
 6 print(‘helloworld‘[2:])
 7 --->lloworld
 8   
 9 # in  成員運算符 - 如果字符串中包含給定的字符返回 True
10 print(‘el‘ in ‘hello‘)
11 --->True
12   
13 #  %   格式字符串
14 print(‘cxm is a good girl‘)
15 print(‘%s is a good girl‘%‘cxm‘)
16 --->cxm is a good girl
17   
18 #  +   字符串拼接
19 a=‘123‘
20 b=‘abc‘
21 c=‘789‘
22 d1=a+b+c
23 print(d1)
24 --->123abc789
25  
26 # +效率低,占內存多，該用join
27 d2=‘‘.join([a,b,c])
28 print(d2)
29 --->123abc789

python字符串內置方法

 1 # string.capitalize()                                  把字符串的第一個字符大寫
 2 # string.center(width)                                 返回內容是原字符串居中,並使用空格填充至長度為 width 的新字符串
 3 # string.count(str, beg=0, end=len(string))            返回 str 在 string 裏面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數
 4 # string.decode(encoding=‘UTF-8‘, errors=‘strict‘)     以 encoding 指定的編碼格式解碼 string，如果出錯默認報一個 ValueError 的 異 常 ， 除 非 errors 指 定 的 是 ‘ignore‘ 或 者‘replace‘
 5 # string.encode(encoding=‘UTF-8‘, errors=‘strict‘)     以 encoding 指定的編碼格式編碼 string，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是‘ignore‘或者‘replace‘
 6 # string.endswith(obj, beg=0, end=len(string))         檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.
 7 # string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符號轉為空格，tab 符號默認的空格數是 8。
 8 # string.find(str, beg=0, end=len(string))             檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1
 9 # string.index(str, beg=0, end=len(string))            跟find()方法一樣，只不過如果str不在 string中會報一個異常.
10 # string.isalnum()                                     如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False
11 # string.isalpha()                                     如果 string 至少有一個字符並且所有字符都是字母則返回 True,否則返回 False
12 # string.isdecimal()                                   如果 string 只包含十進制數字則返回 True 否則返回 False.
13 # string.isdigit()                                     如果 string 只包含數字則返回 True 否則返回 False.
14 # string.islower()                                     如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False
15 # string.isnumeric()                                   如果 string 中只包含數字字符，則返回 True，否則返回 False
16 # string.isspace()                                     如果 string 中只包含空格，則返回 True，否則返回 False.
17 # string.istitle()                                     如果 string 是標題化的(見 title())則返回 True，否則返回 False
18 # string.isupper()                                     如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False
19 # string.join(seq)                                     以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合並為一個新的字符串
20 # string.ljust(width)                                  返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串
21 # string.lower()                                       轉換 string 中所有大寫字符為小寫.
22 # string.lstrip()                                      截掉 string 左邊的空格
23 # string.maketrans(intab, outtab])                     maketrans() 方法用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。
24 # max(str)                                             返回字符串 str 中最大的字母。
25 # min(str)                                             返回字符串 str 中最小的字母。
26 # string.partition(str)                                有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.
27 # string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
28 # string.rfind(str, beg=0,end=len(string) )            類似於 find()函數，不過是從右邊開始查找.
29 # string.rindex( str, beg=0,end=len(string))           類似於 index()，不過是從右邊開始.
30 # string.rjust(width)                                  返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串
31 # string.rpartition(str)                               類似於 partition()函數,不過是從右邊開始查找.
32 # string.rstrip()                                      刪除 string 字符串末尾的空格.
33 # string.split(str="", num=string.count(str))          以 str 為分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字符串
34 # string.splitlines(num=string.count(‘\n‘))            按照行分隔，返回一個包含各行作為元素的列表，如果 num 指定則僅切片 num 個行.
35 # string.startswith(obj, beg=0,end=len(string))        檢查字符串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查.
36 # string.strip([obj])                                  在 string 上執行 lstrip()和 rstrip()
37 # string.swapcase()                                    翻轉 string 中的大小寫
38 # string.title()                                       返回"標題化"的 string,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle())
39 # string.translate(str, del="")                        根據 str 給出的表(包含 256 個字符)轉換 string 的字符,要過濾掉的字符放到 del 參數中
40 # string.upper()                                       轉換 string 中的小寫字母為大寫

三 字節類型(bytes)

 1 # a=bytes(‘hello‘,‘utf8‘)
 2 # a=bytes(‘中國‘,‘utf8‘)
 3   
 4   
 5 a=bytes(‘中國‘,‘utf8‘)
 6 b=bytes(‘hello‘,‘gbk‘)
 7 #
 8 print(a)        #b‘\xe4\xb8\xad\xe5\x9b\xbd‘
 9 print(b)　　　　 #b‘hello‘
10 print(ord(‘h‘)) #其十進制 unicode 值為: 104
11 print(ord(‘中‘))#其十進制 unicode 值為:20013
12   
13 #  h   e  l   l   o
14 # 104 101 108 108 111   編碼後結果:與ASCII表對應
15   
16   
17 #     中                國
18 #   \xd6\xd0         \xb9\xfa       gbk編碼後的字節結果
19 #\xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8編碼後的字節結果
20 # 228 184 173      229 155  189        a[:]切片取
21   
22   
23 c=a.decode(‘utf8‘)
24 d=b.decode(‘gbk‘)
25 #c=a.decode(‘gbk‘) :很明顯報錯
26   
27 print(c) #中國
28 print(d) #hello　

註意：對於 ASCII 字符串，因為無論哪種編碼對應的結果都是一樣的，所以可以直接使用 b‘xxxx‘ 賦值創建 bytes 實例，但對於非 ASCII 編碼的字符則不能通過這

種方式創建 bytes 實例，需要指明編碼方式。

1 b1=b‘123‘
2 print(type(b1))
3 # b2=b‘中國‘ #報錯
4 # 所以得這樣:
5 b2=bytes(‘中國‘,‘utf8‘)
6 print(b2)#b‘\xe4\xb8\xad\xe5\x9b\xbd‘

四 布爾值

一個布爾值只有True、False兩種值，要麽是True，要麽是False，在Python中，可以直接用True、False表示布爾值（請註意大小寫）

1 print(True)
2 print(4>2)
3 print(bool([3,4]))
4 print(True+1)

與或非操作：

1 bool(1 and 0)
2 bool(1 and 1)
3 bool(1 or 0)
4 bool(not 0)

布爾值經常用在條件判斷中:

1 age=18
2 if age>18:#bool(age>18)
3     print(‘old‘)
4 else:
5     print(‘young‘)

五 List（列表）

OK,現在我們知道了字符串和整型兩個數據類型了，那需求來了，我想把某個班所有的名字存起來，怎麽辦？

有同學說，不是學變量存儲了嗎，我就用變量存儲唄，呵呵，不嫌累嗎，同學，如班裏有一百個人，你就得創建一百個變量啊，消耗大，效率低。

又有同學說，我用個大字符串不可以嗎，沒問題，你的確存起來了，但是，你對這個數據的操作（增刪改查）將變得非常艱難，不是嗎，我想知道張三的位置，你怎麽辦？

在這種需求下，編程語言有了一個重要的數據類型－－－－列表（list）

什麽是列表：

列表（list）是Python以及其他語言中最常用到的數據結構之一。Python使用使用中括號 [ ] 來解析列表。列表是可變的（mutable）——可以改變列表的內容。

對應操作：

1 查（［］）

 1 names_class2=[‘張三‘,‘李四‘,‘王五‘,‘趙六‘]
 2  
 3 # print(names_class2[2])
 4 # print(names_class2[0:3])
 5 # print(names_class2[0:7])
 6 # print(names_class2[-1])
 7 # print(names_class2[2:3])
 8 # print(names_class2[0:3:1])
 9 # print(names_class2[3:0:-1])
10 # print(names_class2[:])　

2 增（append，insert）

insert 方法用於將對象插入到列表中，而append方法則用於在列表末尾追加新的對象

1 names_class2.append(‘xuyaping‘)
2 names_class2.insert(2,‘alvin‘)
3 print(names_class2)

3 改（重新賦值）

1 names_class2=[‘張三‘,‘李四‘,‘王五‘,‘趙六‘]
2  
3 names_class2[3]=‘趙七‘
4 names_class2[0:2]=[‘wusir‘,‘alvin‘]
5 print(names_class2)

4 刪（remove，del，pop）

1 names_class2.remove(‘xuyaping‘)
2 del names_class2[0]
3 del names_class2
4 names_class2.pop()#註意,pop是有一個返回值的　

5 其他操作

5.1 count

count 方法統計某個元素在列表中出現的次數：

1 >>> [‘to‘, ‘be‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘].count(‘to‘) 
2 2 
3 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] 
4 >>> x.count(1) 
5 2 
6 >>> x.count([1,2]) 
7 1

5.2 extend

extend 方法可以在列表的末尾一次性追加另一個序列中的多個值。

1 >>> a = [1, 2, 3] 
2 >>> b = [4, 5, 6] 
3 >>> a.extend(b) 
4 >>> a 
5 [1, 2, 3, 4, 5, 6] 

extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。

 1 >>> a = [1, 2, 3] 
 2 >>> b = [4, 5, 6] 
 3 >>> a.extend(b) 
 4 >>> a 
 5 [1, 2, 3, 4, 5, 6] 
 6 >>> 
 7 >>> a + b 
 8 [1, 2, 3, 4, 5, 6, 4, 5, 6] 
 9 >>> a 
10 [1, 2, 3, 4, 5, 6] 

5.3 index

index 方法用於從列表中找出某個值第一個匹配項的索引位置：　

1 names_class2.index(‘李四‘)

5.4 reverse

reverse 方法將列表中的元素反向存放。

1 names_class2.reverse()
2 print(names_class2)

5.5 sort

sort 方法用於在原位置對列表進行排序。

1 x = [4, 6, 2, 1, 7, 9]
2 x.sort()#x.sort(reverse=True)
3 print(x)  # [1, 2, 4, 6, 7, 9]

5.6 深淺拷貝

現在，大家先不要理會什麽是深淺拷貝，聽我說，對於一個列表，我想復制一份怎麽辦呢？

肯定會有同學說，重新賦值唄：

1 names_class1=[‘張三‘,‘李四‘,‘王五‘,‘趙六‘]
2 names_class1_copy=[‘張三‘,‘李四‘,‘王五‘,‘趙六‘]

這是兩塊獨立的內存空間

這也沒問題，還是那句話，如果列表內容做夠大，你真的可以要每一個元素都重新寫一遍嗎？當然不啦，所以列表裏為我們內置了copy方法：

 1 names_class1=[‘張三‘,‘李四‘,‘王五‘,‘趙六‘,[1,2,3]]
 2 names_class1_copy=names_class1.copy()
 3  
 4 names_class1[0]=‘zhangsan‘
 5 print(names_class1)　　　　　　# [‘zhangsan‘, ‘李四‘, ‘王五‘, ‘趙六‘, [1, 2, 3]]
 6 print(names_class1_copy)　　　# [‘張三‘, ‘李四‘, ‘王五‘, ‘趙六‘, [1, 2, 3]]
 7  
 8 ############
 9 names_class1[4][2]=5
10 print(names_class1)　　　　　　# [‘zhangsan‘, ‘李四‘, ‘王五‘, ‘趙六‘, [1, 2, 5]]
11 print(names_class1_copy) 　　 # [‘張三‘,‘李四‘,‘王五‘,‘趙六‘,[1,2,5]]
12 #問題來了,為什麽names_class1_copy,從這一點我們可以斷定,這兩個變量並不是完全獨立的,那他們的關系是什麽呢?為什麽有的改變,有的不改變呢?

這裏就涉及到我們要講的深淺拷貝了：

 1 #不可變數據類型:數字,字符串,元組         可變類型:列表,字典
 2 l=[2,2,3]
 3 print(id(l))  # 35557064
 4 l[0]=5
 5 print(id(l))  # 35557064  # 當你對可變類型進行修改時,比如這個列表對象l,它的內存地址不會變化,註意是這個列表對象l,不是它裏面的元素
 6                # this is the most important
 7 
 8 s=‘alex‘
 9 print(id(s))   #像字符串,列表,數字這些不可變數據類型,,是不能修改的,比如我想要一個‘Alex‘的字符串,只能重新創建一個‘Alex‘的對象,然後讓指針只想這個新對象
10 
11 s[0]=‘e‘       #報錯
12 print(id(s))
13 
14 #重點:淺拷貝
15 a=[[1,2],3,4]
16 b=a[:]#b=a.copy()
17 
18 # id地址全相同
19 print(a,b)  # [[1, 2], 3, 4] [[1, 2], 3, 4]
20 print(id(a),id(b))  # 41848776 41869448
21 print(‘*************‘)
22 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0]))  # a[0]: 41848712 b[0]: 41848712
23 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0]))  # a[0][0]: 2006304432 b[0][0]: 2006304432
24 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
25 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
26 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528
27 
28 
29 print(‘___________________________________________‘)
30 b[0][0]=8  #[1, 2]--》[8, 2]
31 
32 
33 print(a,b)  # [[8, 2], 3, 4] [[8, 2], 3, 4]
34 print(id(a),id(b))  # 35893576 35893704
35 print(‘*************‘)
36 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0]))  # a[0]: 35893512 b[0]: 35893512
37 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0]))  # a[0][0]: 2006304656 b[0][0]: 2006304656
38 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
39 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
40 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528

 1 #不可變數據類型:數字,字符串,元組         可變類型:列表,字典
 2 l=[2,2,3]
 3 print(id(l))  # 35557064
 4 l[0]=5
 5 print(id(l))  # 35557064  # 當你對可變類型進行修改時,比如這個列表對象l,它的內存地址不會變化,註意是這個列表對象l,不是它裏面的元素
 6                # this is the most important
 7 
 8 s=‘alex‘
 9 print(id(s))   #像字符串,列表,數字這些不可變數據類型,,是不能修改的,比如我想要一個‘Alex‘的字符串,只能重新創建一個‘Alex‘的對象,然後讓指針只想這個新對象
10 
11 s[0]=‘e‘       #報錯
12 print(id(s))
13 
14 #重點:淺拷貝
15 a=[[1,2],3,4]
16 b=a[:]#b=a.copy()
17 
18 # id地址全相同
19 print(a,b)  # [[1, 2], 3, 4] [[1, 2], 3, 4]
20 print(id(a),id(b))  # 41848776 41869448
21 print(‘*************‘)
22 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0]))  # a[0]: 41848712 b[0]: 41848712
23 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0]))  # a[0][0]: 2006304432 b[0][0]: 2006304432
24 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
25 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
26 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528
27 
28 
29 print(‘___________________________________________‘)
30 b[0][0]=8  #[1, 2]--》[8, 2]
31 
32 
33 print(a,b)  # [[8, 2], 3, 4] [[8, 2], 3, 4]
34 print(id(a),id(b))  # 35893576 35893704
35 print(‘*************‘)
36 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0]))  # a[0]: 35893512 b[0]: 35893512
37 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0]))  # a[0][0]: 2006304656 b[0][0]: 2006304656
38 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
39 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
40 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528

那麽怎麽解釋這樣的一個結果呢？

python（8）- python基礎數據類型