Python常見數據類型及操作

基礎數據類型

什么是數據類型？

我們人類可以很容易的分清數字與字符的區別，但計算機並不能，計算機雖然很強大，但從某種角度上看又很傻，除非你明確的告訴它，1是數字，“漢”是文字，否則它是分不清1和‘漢’的區別的。

因此，在每個編程語言里都會有一個叫數據類型的東西，其實就是對常用的各種數據類型進行了明確的划分，你想讓計算機進行數值運算，你就傳數字給它，你想讓他處理文字，就傳字符串類型給他。 

字符串

str(字符串) ‘1’ ” I',m a teacher “

python中，凡是用引號（單引、雙引），引起來的內容都是字符串。

字符串常用操作：

s = 'I am from china'

#首字母大寫
print(s.capitalize())
I am from china

#全大寫
print(s.upper())
I AM FROM CHINA

#全小寫
print(s.lower())
i am from china

#大小寫反轉
print(s.swapcase())
i AM FROM CHINA

#所有首字母大寫
print(s.title())
I Am From China

#計算字符串長度
print(len(s))
15

#內容居中，兩邊填充（共50個字符串，多余的用~填充，默認填充符是空格）
print(s.center(50,'~'))
~~~~~~~~~~~~~~~~~I am from china~~~~~~~~~~~~~~~~~~

#判斷字符串以什么開始
print(s.startswith('I'))
True

#判斷字符串以什么結尾
print(s.endswith('I'))
False

#查詢字符串是否含有某元素,找到返回元素對應下標，找不到返回-1
print(s.find('a'))
2 

比較重要的幾個方法：

s='  Chi nese '

#刪除前后空格
print(s.strip())
Chi nese
#刪除后面的空格
print(s.rstrip())
  Chi nese
#刪除前面的空格
print(s.lstrip())
Chi nese 
#統計元素個數
print(s.count('e'))
2
#將字符串以元素中內容分割為列表
print(s.split())
['Chi', 'nese']
print(s.split('e'))
['  Chi n', 's', ' ']

切片：

切片就是通過索引（索引:索引:步長）截取字符串的一段，形成新的字符串（原則就是顧頭不顧尾）

a = 'ABCDEFGHIJK'
print(a[0:3])
ABC
print(a[2:5])
CDE
#默認到最后
print(a[0:])
ABCDEFGHIJK
# -1 是列表中最后一個元素的索引，但是要滿足顧頭不顧腚的原則，所以取不到K元素
print(a[0:-1])
ABCDEFGHIJ
#加步長
print(a[0:5:2]) 
ACE
#反向加步長
print(a[5:0:-2]) 
FDB　　

索引：

索引即下標，就是字符串組成的元素從第一個開始，初始索引為0以此類推

a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

#輸出
A
D
F
H

補充：
字符串計算

#相加，即拼接 : +
a = 'hello '
b = 'world'
print(a+b)
#輸出
hello world

#與數字相乘： * 
print('hello '*4)
#輸出
hello hello hello hell

字符串替換

#將重新替換為你，如果后面不跟次數，默認替換所有
s = '重新打開一個終端窗口，重新打開一個終端窗口'
s1 =s.replace('重新','你',1)
print(s1)
你打開一個終端窗口，重新打開一個終端窗口

字符串判斷

print("hahaha".isalpha())       #判斷是不是字母
print("hahaha123".isalnum())    #判斷是不是阿拉伯數字
print(u"23".isdecimal())        #判斷是否只包含十進制字符，定義十進制在字符串前加'u'即可
print("2".isdigit())            #判斷是否整數
print("al_ex".isidentifier())   #判斷是否合法的變量名
print("alex".islower())         #判斷是否全為小寫
print("Alex".isupper())         #判斷是否全為大寫

字符串循環

name='Love1'
for i in name:
    print(i)

#輸出
L
o
v
e
1

 整型

int（整型） 18,23 常用於計算。

在32位機器上，整數的位數為32位，取值范圍為-2**31～2**31-1，即-2147483648～2147483647

在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（長整型）

理論上Python沒有限制長整數大小，實際由於機器內存有限，數值不會無限大

注意：在Python3里不再有long類型了，全都是int

float（浮點型）

掃盲 http://www.cnblogs.com/alex3714/articles/5895848.html 
浮點數用來處理實數，即帶有小數的數字。類似於C語言中的double類型，占8個字節（64位），其中52位表示底，11位表示指數，剩下的一位表示符號。

complex(復數) 
復數是由實數部分和虛數部分組成，一般是x+yj形式，其中x為復數的實數部分，y為復數的虛數部分

用來測磁場、量子力學之類的，很少用到。

數字在pycharm 中的表現形式： 
加引號的數字是 字符串;不加引號的數字是 “數字”，紅色的

布爾值

bool(布爾值)

只有真或假兩種狀態，性別、命題真假，常用於判斷。

真   1   True

假   0   False

列表

列表是python中的基礎數據類型之一，它是以[ ]括起來，每個元素以逗號隔開，而且可以存放各種數據類型。

列表相比於字符串，不僅可以儲存不同的數據類型，而且可以儲存大量數據，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。列表是有序的，有索引值，可切片，方便取值。

列表常用方法：

索引、切片同字符串。

增加

li = [1,'a','b',2,3,'a']

#按照索引去增加
li.insert(0,55)
print(li)
[55, 1, 'a', 'b', 2, 3, 'a']
#默認增加到最后一個元素
li.append('aaa')
print(li)
[1, 'a', 'b', 2, 3, 'a', 'aaa']
#增加一個列表到最后一個元素
li.append([1,2,3])
print(li)
[1, 'a', 'b', 2, 3, 'a', [1, 2, 3]]
#迭代增，會將內容分解到最小元素
li.extend('abc')
print(li)
[1, 'a', 'b', 2, 3, 'a', 'a', 'b', 'c']

　刪除

li = [1,'a','b',2,3,'a']

#按索引刪除
li.pop(0)
print(li)
['a', 'b', 2, 3, 'a']
#默認刪除最后一個
li.pop()
print(li)
[1, 'a', 'b', 2, 3]
#按元素刪除
li.remove('a')
print(li)
[1, 'b', 2, 3, 'a']
#清空列表
li.clear()
print(li)
[]
#直接刪除列表
del li
print(li)
NameError: name 'li' is not defined
#切片去刪除
del li[0:2]
print(li)
['b', 2, 3, 'a']

　修改

li = [1,'a','b',2,3,'a']

#按索引修改
li[0] = '8'
print(li)
['8', 'a', 'b', 2, 3, 'a']

#切片修改，按迭代處理，內容會分解到最小元素都加進去
li[0:2]='hello'
print(li)
['h', 'e', 'l', 'l', 'o', 'b', 2, 3, 'a']

　查詢

li = [1,'a','b',2,3,'a']
#遍歷查詢
for i in li:
    print(i)
1
a
b
2
3
a

#測量長度
l=len(li)
print(l)
6

#統計次數
print(li.count('a'))
2

#查索引
print(li.index('b'))
2

　排序

li = [1, 5, 7, 2, 3, 4]

#正排序
li.sort()
print(li)
[1, 2, 3, 4, 5, 7]

#倒排序
li.sort(reverse=True)
print(li)
[7, 5, 4, 3, 2, 1]

#反轉
li.reverse()
print(li)
[4, 3, 2, 7, 5, 1]

元組

數據只讀，也叫做只讀列表。

元組被稱為只讀列表，即數據可以被查詢，但不能被修改，所以，字符串的切片操作同樣適用於元組。例：（1，2，3）（"a","b","c"）

字典　

字典一種key - value 的數據類型，使用就像我們小時候用的字典，通過部首、拼音來查對應頁的詳細內容。 
字典的特性： 字典是無序的； key必須是唯一的,so天生去重。 
字典里面的key是唯一的，所以不用索引表 
如何實現唯一？

hash 中文名：散列 通過一定的數學算法，使字符串能變成唯一的數字序列

 增刪改查

names = {
    "stu1101" :{"name":"Alex","age":22,"hobbie":"girl"},
    "stu1102" : "Jack",
    "stu1103" : "rain",
}
print(names)
#查詢
print(names["stu1101"])
print(names["stu1101"]["hobbie"])
#判斷key-"stu1104"是否存在，如果存在返回值,如果否返回none;也可以自定義返回內容，此處為no
print(names.get("stu1104","no"))
#增加
names["stu1104"] = ["Rose",23,"DBA"]
print(names["stu1104"])
#修改
names["stu1104"][0] = "Violet"
print(names["stu1104"])
#刪除
print(names.pop("stu1105","不存在"))
del names["stu1103"]
print(names)

#輸出
{'stu1103': 'rain', 'stu1102': 'Jack', 'stu1101': {'age': 22, 'name': 'Alex', 'hobbie': 'girl'}}
{'age': 22, 'name': 'Alex', 'hobbie': 'girl'}
girl
no
['Rose', 23, 'DBA']
['Violet', 23, 'DBA']
不存在
{'stu1104': ['Violet', 23, 'DBA'], 'stu1102': 'Jack', 'stu1101': {'age': 22, 'name': 'Alex', 'hobbie': 'girl'}}

循環

names = {
    "stu1101":{"name":"Alex","age":22,"hobbie":"girl"},
    "stu1102": "Jack",
    "stu1103": "rain",
    "stu1104":{"Rose",23,"DBA"}
}
#字典循環常用的兩種方式：打印出key和value
# @1 盡量用這種，效率高
for key in names:
    print(key,names[key])
# @2 先將字典轉為列表，再進行循環，效率低
print(names.items())
for k,v in names.items():
    print(k,v)
print(names.keys())         #打印所有key
print(names.values())       #打印所有value
#先獲取這個值，如果存在就打印，不存在就創建
print(names.setdefault("stu1106","Mary"))
print(names)
#字典合並 相當於修改1102的值，因為字典中的key是唯一的
name1 = {"stu1102":"Java",1:333,2:444}
names.update(name1)
print(names)
#輸出
stu1103 rain
stu1101 {'name': 'Alex', 'age': 22, 'hobbie': 'girl'}
stu1102 Jack
stu1104 {'Rose', 'DBA', 23}
dict_keys(['stu1103', 'stu1101', 'stu1104', 'stu1102'])
dict_values(['rain', {'name': 'Alex', 'hobbie': 'girl', 'age': 22}, {'DBA', 'Rose', 23}, 'Jack'])
Mary
{'stu1103': 'rain', 'stu1101': {'hobbie': 'girl', 'age': 22, 'name': 'Alex'}, 'stu1106': 'Mary', 'stu1104': {'Rose', 'DBA', 23}, 'stu1102': 'Jack'}
{1: 333, 'stu1106': 'Mary', 2: 444, 'stu1104': {'Rose', 'DBA', 23}, 'stu1103': 'rain', 'stu1102': 'Java', 'stu1101': {'hobbie': 'girl', 'age': 22, 'name': 'Alex'}}

字典中的深淺copy

names = {
    "stu1101":{"name":"Alex","age":22},
    "stu1102": "Jack",
    "stu1103": "rain",
    "stu1104":{"Rose",23,"DBA"}
}
name1 = names.copy()
#第一層的數據不會變，其他的都會變。應用場景：銀行共享賬戶：主卡、副卡
names["stu1103"] = "RAIN"       #此處相當於開辟了一塊新的內存地址，所以names中的rain會改變
names["stu1101"]["age"] = 24    #此處只是修改了列表中的數據，而列表的內存地址沒有改變，所以打印出的names和name1內容會相同
print(names)
print(name1)
#深copy， 完全copy
import copy
name2 = copy.deepcopy(names)
print(name2)
#輸出
{'stu1103': 'RAIN', 'stu1102': 'Jack', 'stu1101': {'age': 24, 'name': 'Alex'}, 'stu1104': {'DBA', 'Rose', 23}}
{'stu1101': {'age': 24, 'name': 'Alex'}, 'stu1102': 'Jack', 'stu1103': 'rain', 'stu1104': {'DBA', 'Rose', 23}}
{'stu1101': {'age': 24, 'name': 'Alex'}, 'stu1102': 'Jack', 'stu1103': 'RAIN', 'stu1104': {'DBA', 'Rose', 23}}