數據類型 電腦顧名思義就是可以做數學計算的機器，因此，電腦程式理所當然地可以處理各種數值。但是，電腦能處理的遠不止數值，還可以處理文本、圖形、音頻、視頻、網頁等各種各樣的數據，不同的數據，需要定義不同的數據類型。在Python中，能夠直接處理的數據類型有以下幾種 一 Number(數字) 1. ...
數據類型
電腦顧名思義就是可以做數學計算的機器，因此，電腦程式理所當然地可以處理各種數值。但是，電腦能處理的遠不止數值，還可以處理文本、圖形、音頻、視頻、網頁等各種各樣的數據，不同的數據，需要定義不同的數據類型。在Python中，能夠直接處理的數據類型有以下幾種
一 Number(數字)
1.1 數字類型的創建
| 1 2 3 4 5 6 |
a=10
b=a
b=666
print(a)#10
print(b)#666
|
註意這裡與C的不同：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#include <stdio.h>
void main(void)
{
int a = 1;
int b = a;
printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
a = 3;
printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
}
//列印結果：
topeet@ubuntu:~$ gcc test.c
topeet@ubuntu:~$ ./a.out
a:adr:0x7fff343a069c,val:1
b:adr:0x7fff343a0698,val:1
a:adr:0x7fff343a069c,val:3
b:adr:0x7fff343a0698,val:1
|
1.2 Number 類型轉換
| 1 2 3 4 5 6 |
var1=3.14
var2=5
var3=int(var1)
var4=float(var2)
print(var3,var4)
|
abs(x) 返回數字的絕對值，如abs(-10) 返回 10 # ceil(x) 返回數字的上入整數，如math.ceil(4.1) 返回 5 # cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 # exp(x) 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045 # fabs(x) 返回數字的絕對值，如math.fabs(-10) 返回10.0 # floor(x) 返回數字的下舍整數，如math.floor(4.9)返回 4 # log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 # log10(x) 返回以10為基數的x的對數，如math.log10(100)返回 2.0 # max(x1, x2,...) 返回給定參數的最大值，參數可以為序列。 # min(x1, x2,...) 返回給定參數的最小值，參數可以為序列。 # modf(x) 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。 # pow(x, y) x**y 運算後的值。 # round(x [,n]) 返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。 # 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 2 |
var1 = 'Hello World!'
var2 = "Python RAlvin"
|
對應操作：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
# 1 * 重覆輸出字元串
print('hello'*2)
# 2 [] ,[:] 通過索引獲取字元串中字元,這裡和列表的切片操作是相同的,具體內容見列表
print('helloworld'[2:])
# 3 in 成員運算符 - 如果字元串中包含給定的字元返回 True
print('el' in 'hello')
# 4 % 格式字元串
print('alex is a good teacher')
print('%s is a good teacher'%'alex')
# 5 + 字元串拼接
a='123'
b='abc'
c='789'
d1=a+b+c
print(d1)
# +效率低,該用join
d2=''.join([a,b,c])
print(d2)
|
python的內置方法
# string.capitalize() 把字元串的第一個字元大寫
# string.center(width) 返回一個原字元串居中,並使用空格填充至長度 width 的新字元串
# string.count(str, beg=0, end=len(string)) 返回 str 在 string 裡面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數
# string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式解碼 string，如果出錯預設報一個 ValueError 的 異 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
# string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式編碼 string，如果出錯預設報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'
# string.endswith(obj, beg=0, end=len(string)) 檢查字元串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.
# string.expandtabs(tabsize=8) 把字元串 string 中的 tab 符號轉為空格，tab 符號預設的空格數是 8。
# string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1
# string.index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不在 string中會報一個異常.
# string.isalnum() 如果 string 至少有一個字元並且所有字元都是字母或數字則返回 True,否則返回 False
# string.isalpha() 如果 string 至少有一個字元並且所有字元都是字母則返回 True,否則返回 False
# string.isdecimal() 如果 string 只包含十進位數字則返回 True 否則返回 False.
# string.isdigit() 如果 string 只包含數字則返回 True 否則返回 False.
# string.islower() 如果 string 中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是小寫，則返回 True，否則返回 False
# string.isnumeric() 如果 string 中只包含數字字元，則返回 True，否則返回 False
# string.isspace() 如果 string 中只包含空格，則返回 True，否則返回 False.
# string.istitle() 如果 string 是標題化的(見 title())則返回 True，否則返回 False
# string.isupper() 如果 string 中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是大寫，則返回 True，否則返回 False
# string.join(seq) 以 string 作為分隔符，將 seq 中所有的元素(的字元串表示)合併為一個新的字元串
# string.ljust(width) 返回一個原字元串左對齊,並使用空格填充至長度 width 的新字元串
# string.lower() 轉換 string 中所有大寫字元為小寫.
# string.lstrip() 截掉 string 左邊的空格
# string.maketrans(intab, outtab]) maketrans() 方法用於創建字元映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字元串，表示需要轉換的字元，第二個參數也是字元串表示轉換的目標。
# max(str) 返回字元串 str 中最大的字母。
# min(str) 返回字元串 str 中最小的字母。
# string.partition(str) 有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.
# string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
# string.rfind(str, beg=0,end=len(string) ) 類似於 find()函數，不過是從右邊開始查找.
# string.rindex( str, beg=0,end=len(string)) 類似於 index()，不過是從右邊開始.
# string.rjust(width) 返回一個原字元串右對齊,並使用空格填充至長度 width 的新字元串
# string.rpartition(str) 類似於 partition()函數,不過是從右邊開始查找.
# string.rstrip() 刪除 string 字元串末尾的空格.
# string.split(str="", num=string.count(str)) 以 str 為分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字元串
# string.splitlines(num=string.count('\n')) 按照行分隔，返回一個包含各行作為元素的列表，如果 num 指定則僅切片 num 個行.
# string.startswith(obj, beg=0,end=len(string)) 檢查字元串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查.
# string.strip([obj]) 在 string 上執行 lstrip()和 rstrip()
# string.swapcase() 翻轉 string 中的大小寫
# string.title() 返回"標題化"的 string,就是說所有單詞都是以大寫開始，其餘字母均為小寫(見 istitle())
# string.translate(str, del="") 根據 str 給出的表(包含 256 個字元)轉換 string 的字元,要過濾掉的字元放到 del 參數中
# string.upper() 轉換 string 中的小寫字母為大寫
三 位元組類型(bytes)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# a=bytes('hello','utf8')
# a=bytes('中國','utf8')
a=bytes('中國','utf8')
b=bytes('hello','gbk')
#
print(a) #b'\xe4\xb8\xad\xe5\x9b\xbd'
print(ord('h')) #其十進位 unicode 值為: 104
print(ord('中'))#其十進位 unicode 值為:20013
# h e l l o
# 104 101 108 108 111 編碼後結果:與ASCII表對應
# 中 國
# \xd6\xd0 \xb9\xfa gbk編碼後的位元組結果
#\xe4 \xb8 \xad \xe5 \x9b \xbd utf8編碼後的位元組結果
# 228 184 173 229 155 189 a[:]切片取
c=a.decode('utf8')
d=b.decode('gbk')
#b=a.decode('gbk') :很明顯報錯
print(c) #中國
print(d) #hello
|
註意：對於 ASCII 字元串，因為無論哪種編碼對應的結果都是一樣的，所以可以直接使用 b'xxxx' 賦值創建 bytes 實例，但對於非 ASCII 編碼的字元則不能通過這種方式創建 bytes 實例，需要指明編碼方式。
| 1 2 3 4 5 6 |
b1=b'123'
print(type(b1))
# b2=b'中國' #報錯
# 所以得這樣:
b2=bytes('中國','utf8')
print(b2)#b'\xe4\xb8\xad\xe5\x9b\xbd'
|
四 布爾值
一個布爾值只有True、False兩種值，要麼是True，要麼是False，在Python中，可以直接用True、False表示布爾值（請註意大小寫）
| 1 2 3 4 |
print(True)
print(4>2)
print(bool([3,4]))
print(True+1)
|
與或非操作：
| 1 2 3 4 |
bool(1 and 0)
bool(1 and 1)
bool(1 or 0)
bool(not 0)
|
布爾值經常用在條件判斷中:
| 1 2 3 4 5 |
age=18
if age>18:#bool(age>18)
print('old')
else:
print('young')
|
五 List（列表）
OK,現在我們知道了字元串和整型兩個數據類型了，那需求來了，我想把某個班所有的名字存起來，怎麼辦？
有同學說，不是學變數存儲了嗎，我就用變數存儲唄，呵呵，不嫌累嗎，同學，如班裡有一百個人，你就得創建一百個變數啊，消耗大，效率低。
又有同學說，我用個大字元串不可以嗎，沒問題，你的確存起來了，但是，你對這個數據的操作（增刪改查）將變得非常艱難，不是嗎，我想知道張三的位置，你怎麼辦？
在這種需求下，編程語言有了一個重要的數據類型－－－－列表（list）
什麼是列表：
列表（list）是Python以及其他語言中最常用到的數據結構之一。Python使用使用中括弧 [ ] 來解析列表。列表是可變的（mutable）——可以改變列表的內容。
對應操作：
1 查（［］）
| 1 2 3 4 5 6 7 8 9 10 |
names_class2=['張三','李四','王五','趙六']
# print(names_class2[2])
# print(names_class2[0:3])
# print(names_class2[0:7])
# print(names_class2[-1])
# print(names_class2[2:3])
# print(names_class2[0:3:1])
# print(names_class2[3:0:-1])
# print(names_class2[:])
|
2 增（append，insert）
insert 方法用於將對象插入到列表中，而append方法則用於在列表末尾追加新的對象
| 1 2 3 |
names_class2.append('alex')
names_class2.insert(2,'alvin')
print(names_class2)
|
3 改（重新賦值）
| 1 2 3 4 5 |
names_class2=['張三','李四','王五','趙六']
names_class2[3]='趙七'
names_class2[0:2]=['wusir','alvin']
print(names_class2)
|
4 刪（remove，del，pop）
| 1 2 3 4 |
names_class2.remove('alex')
del names_class2[0]
del names_class2
names_class2.pop()#註意,pop是有一個返回值的
|
5 其他操作
5.1 count
count 方法統計某個元素在列表中出現的次數：
| 1 2 3 4 5 6 7 |
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1
|
5.2 extend
extend 方法可以在列表的末尾一次性追加另一個序列中的多個值。
| 1 2 3 4 5 |
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
|
extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。
| 1 2 3 4 5 6 7 8 9 10 |
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
>>>
>>> a + b
[1, 2, 3, 4, 5, 6, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]
|
5.3 index
index 方法用於從列表中找出某個值第一個匹配項的索引位置：
| 1 |
names_class2.index('李四')
|
5.4 reverse
reverse 方法將列表中的元素反向存放。
| 1 2 |
names_class2.reverse()
print(names_class2)
|
5.5 sort
sort 方法用於在原位置對列表進行排序。
| 1 2 |
x = [4, 6, 2, 1, 7, 9]
x.sort()#x.sort(reverse=True)
|
5.6 深淺拷貝
現在，大家先不要理會什麼是深淺拷貝，聽我說，對於一個列表，我想複製一份怎麼辦呢？
肯定會有同學說，重新賦值唄：
| 1 2 |
names_class1=['張三','李四','王五','趙六']
names_class1_copy=['張三','李四','王五','趙六']
|
這是兩塊獨立的記憶體空間
這也沒問題，還是那句話，如果列表內容做夠大，你真的可以要每一個元素都重新寫一遍嗎？當然不啦，所以列表裡為我們內置了copy方法：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
names_class1=['張三','李四','王五','趙六',[1,2,3]]
names_class1_copy=names_class1.copy()
names_class1[0]='zhangsan'
print(names_class1)
print(names_class1_copy)
############
names_class1[4][2]=5
print(names_class1)
print(names_class1_copy)
#問題來了,為什麼names_class1_copy,從這一點我們可以斷定,這兩個變數並不是完全獨立的,那他們的關係是什麼呢?為什麼有的改變,有的不改變呢?
|
這裡就涉及到我們要講的深淺拷貝了：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
#不可變數據類型:數字,字元串,元組 可變類型:列表,字典
# l=[2,2,3]
# print(id(l))
# l[0]=5
# print(id(l)) # 當你對可變類型進行修改時,比如這個列表對象l,它的記憶體地址不會變化,註意是這個列表對象l,不是它裡面的元素
# # this is the most important
#
# s='alex'
# print(id(s)) #像字元串,列表,數字這些不可變數據類型,,是不能修改的,比如我想要一個'Alex'的字元串,只能重新創建一個'Alex'的對象,然後讓指針只想這個新對象
#
# s[0]='e' #報錯
# print(id(s))
#重點:淺拷貝
a=[[1,2],3,4]
b
|
