基本數據類型:
(1)數字(int): 整形，浮點
整數類型定義的時候變量名后面直接跟數字，數字類型是不可變數據類型
>>> age = 20 >>> type(age) <class 'int'> >>>
數字類型的基本操作
#數字的操作類型主要在程序中起到一個判斷作用 num1=b'4' #bytes num2=u'4' #Unicode #python3中不用管，可以忽略 num3='四' #中文數字 num4='Ⅳ' #羅馬數字 #isdigt #作用就是判斷是否是數字，一般就用isdigt就搞定了 print(num1.isdigit()) #True print(num2.isdigit()) #True print(num3.isdigit()) #False print(num4.isdigit()) #False #isdecimal:uncicode #bytes類型無isdecimal方法 print(num2.isdecimal()) #True print(num3.isdecimal()) #False print(num4.isdecimal()) #False #isnumberic:unicode,中文數字,羅馬數字 #bytes類型無isnumberic方法 print(num2.isnumeric()) #True print(num3.isnumeric()) #True print(num4.isnumeric()) #True
數字類型操作
(2)字符串（str）:
定義字符串的時候需要用引號引起來,可以用單，雙，三引號，三引號多表示多行字符串，這樣就可以省掉“\n”換行符換行。
>>> name = "alex" >>> type(name) <class 'str'> >>>
字符串的基本操作主要有：copy，拼接，查找，統計，檢測，切片，大小寫等。這里需要注意字符串是不可變類型，上述操作並沒有改變原來的字符串，只是創建了一個新的字符串，原來的字符串任然在內存中！
1，copy 復制
1 a = "alex" 2 b = a 3 print(a,b) 4 alex alex
2，拼接
1 a = "alex" 2 b = "egon" 3 print(a + b) 4 #alexegon
這里也可以用join來實現字符串的拼接效果，可以指定連接符號如（？， —，*) 之類的，當然也可以是空格!
1 a = "alex" 2 b = "egon" 3 print(a.join(b)) 4 #ealexgalexoalexn
3,查找，獲取對象的下標
這里的查找是按照下標索引進行的，用到index
>>> a = 'alex' >>> a.index('l') 1 >>> a.index('a')#返回值是0，下標是從0開始的 0 >>> a.index('A')#找不到會報錯 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: substring not found >>>
4，統計 這里用到count
>>> name = 'alex' >>> name.count('l')#統計name中l的個數 1 >>>
5,切片 這里是按照索引來切的，切片就是取一個范圍
>>> word = "keep doing" >>> word[6:10]#注意使用中括號來做取值范圍，顧頭不顧尾，不包含10 'oing' >>> word[5:9] 'doin' >>>
6，檢測
1 >>> name = "alex"#檢測’l‘有沒有在name里面，返回布爾值 2 >>> "l"in name 3 True 4 >>> num = "12345678" 5 >>> num.isdigit()#檢測“num”是不是由整形數字組成，浮點數都不行 6 True 7 >>> name.isidentifier()#檢測name是否可以被用來做變量名 8 True 9 >>> name.find("l")#檢測能否從name中找到“l”,找到返回1，找不到返回-1這點和index是 有區別的 10 1 11 >>> name.find('N') 12 -1 13 >>> name.index('N')#找不到報錯 14 Traceback (most recent call last): 15 File "<stdin>", line 1, in <module> 16 ValueError: substring not found 17 >>> name.index("l") 18 1 19 >>>
7，大小寫
1 >>> name = "I am alex" 2 >>> name.swapcase()#大小寫互換 3 'i AM ALEX' 4 >>> name.capitalize()#首字母大寫，其它都小寫 5 'I am alex' 6 >>> name.upper()#全部大寫 7 'I AM ALEX' 8 >>> name.lower()#全部小寫 9 'i am alex' 10 >>>
8，移除空格“strip”，替換“replace”，分割“split，format格式化輸出的三種玩法
1 >>> name = " alex" 2 >>> print(name.strip()) 3 alex 4 #replace 替換 5 >>> name='alex say :i have one tesla,my name is alex' 6 >>> name.replace("alex","SB",1)#替換第一個就寫1 7 'SB say :i have one tesla,my name is alex' 8 >>> 9 #split分割 10 >>> name = "a*b*c*gh*kjk*" 11 >>> name.split('*')#以*為分割符號 12 ['a', 'b', 'c', 'gh', 'kjk', ''] 13 >>> name = "h*b*c*gh*gj*hkjhj" 14 >>> name.split('*') 15 ['h', 'b', 'c', 'gh', 'gj', 'hkjhj'] 16 >>> 17 18 #format的三種玩法 19 >>> res = '{},{},{}'.format("egon",18,"male") 20 >>> print(res) 21 egon,18,male 22 >>> res = "{1},{0},{1}".format("egon",18,"male")#中括號里面是索引 23 >>> print(res) 24 18,egon,18 25 >>> res = "{0}{1}{2}".format("egon",18,"male") 26 >>> print(res) 27 egon18male 28 >>> res = "{name} {age} {sex}".format(sex="male",name = "egon",age=18) 29 >>> print(res) 30 egon 18 male
字符串還有很多操作方法，不詳細舉例了，見一下代碼。還有更多 的用法可以直接help（str）
1 str.startswith(prefix[,start[,end]]) #是否以prefix開頭 2 str.endswith(suffix[,start[,end]]) #以suffix結尾 3 str.isalnum() #是否全是字母和數字，並至少有一個字符 4 str.isalpha() #是否全是字母，並至少有一個字符 5 str.isdigit() #是否全是數字，並至少有一個字符 6 str.isspace() #是否全是空白字符，並至少有一個字符 7 str.islower() #S中的字母是否全是小寫 8 str.isupper() #S中的字母是否便是大寫 9 str.istitle() #S是否是首字母大寫的 #以上返回時布爾值True str.ljust(width,[fillchar]) #輸出width個字符，str左對齊，不足部分用fillchar填充，默認的為空格。 str.rjust(width,[fillchar]) #右對齊 str.center(width, [fillchar]) #中間對齊 str.zfill(width) #把str變成width長，並在右對齊，不足部分用0補足 str.replace(oldstr, newstr, [count]) #把str中的oldstar替換為newstr，count為替換次數。這是替換的通用形式，還有一些函數進行特殊字符的替換 str.strip([chars]) #把str中前后chars中有的字符全部去掉，可以理解為把str前后chars替換為None str.lstrip([chars]) #把str前面的去掉 str.rstrip([chars]) #把str后面的去掉 str.expandtabs([tabsize]) #把str中的tab字符替換沒空格，每個tab替換為tabsize個空格，默認是8個 str.split([sep, [maxsplit]]) #以sep為分隔符，把str分成一個list。maxsplit表示分割的次數。默認的分割符為空白字符 str.splitlines([keepends]) #把str按照行分割符分為一個list，keepends是一個bool值，如果為真每行后而會保留行分割符。 str.maketrans(from, to) #返回一個256個字符組成的翻譯表，其中from中的字符被一一對應地轉換成to，所以from和to必須是等長的。 str.translate(table[,deletechars]) # 使用上面的函數產后的翻譯表，把S進行翻譯，並把deletechars中有的字符刪掉。需要注意的是，如果str為unicode字符串，那么就不支持 deletechars參數，可以使用把某個字符翻譯為None的方式實現相同的功能。此外還可以使用codecs模塊的功能來創建更加功能強大的翻譯表。
（三），列表：
列表是常見的數據類型，用中括號[]定義，可以存多個任意類似的值，列表和字符串一樣都是有序排列的，可以用切片和索引的方式訪問數據，並且列表是可變數據類型。
創建一個列表
info= ["name",''age","hobbies","sex",1,2,3,"height"]本質上就是info = list(["name",''age","hobbies","sex",1,2,3,"height"])
字符串可以轉換成列表，list在把字符串轉換成列表的時候，會把字符串用for循環迭代一下，然后將字符串的每一個值當做list的元素。
>>> name = "alex" >>> li = list(name) >>> li ['a', 'l', 'e', 'x'] >>>
列表的基本操作有：索引（訪問），切片，擴展，刪除，追加，統計，長度，獲取下標等。
1，訪問，根據索引
1 >>> info= ["name","age","hobbies","sex",1,2,3,"height"] 2 >>> info[0]#訪問列表中第一個元素 3 'name' 4 >>> info[1]#訪問列表中第二個元素 5 'age' 6 >>> info[-1]#訪問列表中最后一個元素 7 'height' 8 >>> info[-2]#訪問列表中倒數第二個元素 9 3
2，切片
>>> info= ["name","age","hobbies","sex",1,2,3,"height"] >>> info[1:3]#取1到3之間的值，包括1不包括3，顧頭不顧尾 ['age', 'hobbies'] >>> info[1:-1]#取1到最后一個之間的值 ['age', 'hobbies', 'sex', 1, 2, 3] >>> info[0:3]#取第一個到第三個之間的值 ['name', 'age', 'hobbies'] >>> info[:3]#效果同上，0可以省略掉 ['name', 'age', 'hobbies'] >>> info[3:]#取3到最后的值 ['sex', 1, 2, 3, 'height'] >>> info[1:8:2]#每隔2步取一個值，取1到8之間的值，這里的2是步長，當然也可以用3做步長，默認步長是1 ['age', 'sex', 2, 'height'] >>>
3，追加，插入，擴展
>>> info= ["name","age","hobbies","sex",1,2,3,"height"] >>> info.append("girls")#append添加默認是末尾位置 >>> info ['name', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls'] >>> info.insert(1,"apple")#insert可以根據索引在指定位置添加 >>> info ['name', 'apple', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls'] >>> x =["lenovo","apple","mac"] >>> info.extend(x)#extend用於在列表末尾一次性追加另一個序列中的多個值 >>> info ['name', 'apple', 'age', 'hobbies', 'sex', 1, 2,3, 'height', 'girls', 'lenovo', 'apple', 'mac'] >>>
4，修改
>>> x =["lenovo","apple","mac"] >>> x[0]="HUAWEI"#通過下標直接修改 >>> x ['HUAWEI', 'apple', 'mac'] >>>
5，刪除
>>> x =["lenovo","apple","mac"] >>> del x[1]#根據下標刪除 >>> x ['lenovo', 'mac'] >>> x.remove("mac")#指定元素刪除 >>> x ['lenovo'] >>> x =["lenovo","apple","mac"] >>> x.pop()#刪除最后一個元素 'mac' >>> x =["lenovo","apple","mac"] >>> x.pop(0)#根據下標刪除，有返回值 'lenovo' >>> x =["lenovo","apple","mac"] >>> x.clear()#清除所有 >>> x []
6，統計 個數（count），長度（len）
>>> x =["lenovo","apple","mac","lenovo","boys","girls"] >>> x.count("lenovo")#統計列表中“lenovo”的個數 2 >>> x =["lenovo","apple","mac","lenovo","boys","girls"] >>> len(x)#統計列表中元素的總長度（總個數） 6
7，排序&翻轉
>>> x =["lenovo","apple","mac","lenovo","boys","girls",23,"Alex","HUWEI"] >>> x[-3]="23"#不是同類型不能排序，轉換成str類型 >>> x.sort()#排序順序數字>大寫>小寫 >>> x ['23', 'Alex', 'apple', 'boys', 'girls', 'lenovo', 'lenovo', 'mac'] >>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"] >>> x.reverse()#翻轉 >>> x ['Alex', '23', 'girls', 'boys', 'lenovo', 'mac', 'apple', 'lenovo']
8. 獲取下標
>>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"] >>> x.index("lenovo")#只返回第一個元素的下標 0 >>>
還有成員運算in ，not in和字符串是一樣的方法
（四）字典
字典是一種映射型的數據類型，每個元素成對出現，即key- value,每對元素key 和 value“：”冒號分開，元素之間用逗號隔開，整個字典包括子在{}中。
字典中的“key”必須是不可變類型，“value”則可以是任意類型，如果出現一個“key”被多個“value”賦值，那么值為最后一個被賦的值，字典是可變數據類型，並且是無序的。所有不可變的數據類型都可以作為字典中的key,例如數字，字符串，元祖。字典的基本操作包括 創建，增加，刪除，修改，查找，遍歷，更新，in or not in 等。
1，創建
#用fromkeys創建一個字典 >>> dic = ["name","age","sex"] >>> dict = dict.fromkeys(dic)#以序列dic中元素做字典的鍵，value為字典所有鍵對應的初始值 >>> dic ['name', 'age', 'sex']#value對應值為None,不顯示 >>> dict = dict.fromkeys(dic,"123")#設置默認值value為“123” >>> dict {'name': '123', 'age': '123', 'sex': '123'} >>>
2,增加，刪除，修改，查找
1 >>> info = {"name":"egon","age":18} 2 >>> info["sex"]="male"#直接添加 3 >>> info 4 {'name': 'egon', 'age': 18, 'sex': 'male'} 5 6 7 #這里的setdefault 如果key存在，返回已存在的值不修改，如不存在則創建,也可算作一種添加的方法吧 8 >>> info.setdefault("hobby","girls") 9 'girls' 10 >>> info 11 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 12 >>>info = {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 13 >>> info.setdefault("age",20) 14 18 15 >>> info 16 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 17 >>> 18 19 20 21 #指定刪除pop(),返回對應的值，並把這個值從字典中移除。 22 >>> info={'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 23 >>> info.pop("hobby") 24 'girls' 25 >>> info 26 {'name': 'egon', 'age': 18, 'sex': 'male'} 27 >>>>>> info.popitem()#刪除任意鍵值對，因為字典是無序的。 28 ('sex', 'male') 29 >>> info 30 {'name': 'egon', 'age': 18} 31 >>> info.popitem() 32 ('age', 18) 33 >>> info 34 {'name': 'egon'} 35 >>> 36 37 38 39 #修改，直接修改 40 >>> info = {"name":"egon","age":18} 41 >>> info["age"]=20 42 >>> info 43 {'name': 'egon', 'age': 20} 44 >>> 45 46 47 48 #查找 49 >>> info={'name': 'egon', 'age': 20} 50 >>> "name"in info#成員運算符判斷，返回布爾值 51 True 52 >>> info.get("name")#get查找字典中的key,key不存在返回默認值“None” 53 'egon' 54 >>> info["name"]#直接查找，根據“key” 55 'egon' 56 >>>
3,遍歷(循環輸出）
dic = {"name":"alex","age":18,"sex":"male"}
for key in dic.keys():
print(key,end=" ")
# name age sex
for value in dic.values():
print(value,end=" ")
# alex 18 male
for item in dic.items():
print(item,end=" ")
#('name', 'alex') ('age', 18) ('sex', 'male')
4，更多
>>> info = {"name":"egon","age":18,"sex":"male"}
>>> info.keys()#循環取key
dict_keys(['name', 'age', 'sex'])
>>> info.values()#循環取value
dict_values(['egon', 18, 'male'])
>>> info.items()#循環取鍵值對
dict_items([('name', 'egon'), ('age', 18), ('sex', 'male')])
len(dict) #計算字典元素個數
str(dict) #輸出字典可打印的字符串表示，數據類型會發生改變
dict.clear() # 清空詞典所有條目
>>> info = {"name":"alex"}#將字典info中的鍵值更新到dic
>>> dic = {"age":18}
>>> info.update(dic)
>>> info
{'name': 'alex', 'age': 18}
>>>
（五），元祖
元祖和字符串一樣都是不可修改的，用（）小括號括起來，元素使用逗號隔開。注意當元祖中只有一個元素的時候，要加上逗號，不然就變成字符串了。
元祖的基本操作方法有 統計，查找，嵌套修改，切片，in ，not in，
1，統計
>>> tuple = ("alex","egon","hello","apple","alex","alex") >>> tuple.count("alex")#統計元素“alex”的個數 3 >>> len(tuple)#統計元素個數 6 >>>
2，查找
>>> tuple = ("alex","egon","hello","apple","alex","alex") >>> tuple.index("alex")#查找元素在元祖中的位置，多個重復元素只返回第一個的位置 0 >>> tuple[1]#根據索引查找元素 'egon' >>>
3,嵌套修改
#列表的元素是不可以更改的，但元素的元素就有可能是可以更改的 >>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}]) >>> tuple[4].append(0) >>> tuple ('alex', 'egon', 'hello', 'apple', ['world', {'name': 'lesheng'}, 0]) >>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}]) >>> tuple[4][1]["name"]="egon" >>> tuple ('alex', 'egon', 'hello', 'apple', ['world', {'name': 'egon'}]) >>>
（六）集合
集合是一個無序，不重復，每個元素必須是不可變類型的數據組合，主要作用有去重和關系運算。
a = b | c#求合集 ， union等同| a = b & c#求交集 ， intersection等同& a = b - c#求差集 ， difference等同- a = b^ c#求對稱差集 symmetric_difference(求對稱差集)
基本操作
s.add('x') # 添加一項 s.update([10,37,42]) # 在s中添加多項 s.remove(1) #刪除一項 len(s) #set 的長度 x in s #測試 x 是否是 s 的成員 x not in s #測試 x 是否不是 s 的成員
數據類型總結：
按照存值對象分：
單個：數字，字符串
多個：列表，字典，元祖
按照可變不可變分：
可變（不可hash）： 列表，字典
不可變（可hash）：數字，字符串，元祖
按訪問順序分：
順序訪問 ： 字符串，列表，元祖（序列類型）
key訪問 ： 字典 （映射類型）