一 int 數字類型

#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值，則代表舍入到小數點后的位數。python3中小數點一位為5，則返回離整數最近的偶數。 # sqrt(x) 返回數字x的平方根，數字可以為負數，返回類型為實數，如math.sqrt(4)返回 2+0j

二 string 字符串類型

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

請注意，''或""本身只是一種表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c這3個字符。

如果'本身也是一個字符，那就可以用""括起來，比如"I'm OK"包含的字符是I，'，m，空格，O，K這6個字符。

a = 'hello world' b= "I'm Tom"

python字符串內置方法

# string.capitalize() 把字符串的第一個字符大寫 # string.center(width) 返回內容是原字符串居中,并使用空格填充至長度為 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數 # string.startswith(obj, beg=0,end=len(string)) 檢查字符串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定范圍內檢查. # string.endswith(obj, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False. # string.join(seq) 以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串 # string.upper() 轉換 string 中的小寫字母為大寫 # string.lower() 轉換 string 中所有大寫字符為小寫. # string.split(str="", num=string.count(str)) 以 str 為分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字符串 # string.splitlines(num=string.count('\n')) 按照行分隔，返回一個包含各行作為元素的列表，如果 num 指定則僅切片 num 個行. # string.title() 返回"標題化"的 string,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle()) # string.translate(str, del="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符,要過濾掉的字符放到 del 參數中 # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次. # # string.swapcase() 翻轉 string 中的大小寫 # 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.ljust(width) 返回一個原字符串左對齊,并使用空格填充至長度 width 的新字符串 # string.rjust(width) 返回一個原字符串右對齊,并使用空格填充至長度 width 的新字符串 # string.strip([obj]) 在 string 上執行 lstrip()和 rstrip() # string.lstrip() 截掉 string 左邊的空格 # string.rstrip() 刪除 string 字符串末尾的空格. # # string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍，則檢查是否包含在指定范圍內，如果是返回開始的索引值，否則返回-1 # string.rfind(str, beg=0,end=len(string) ) 類似于 find()函數，不過是從右邊開始查找. # string.index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不存在 string中會報一個異常. # string.rindex( str, beg=0,end=len(string)) 類似于 index()，不過是從右邊開始. # string.rpartition(str) 類似于 partition()函數,不過是從右邊開始查找.# string.isalnum() 如果 string 至少有一個字符并且所有字符都是字母或數字則返回 True,否則返回 False # string.isalpha() 如果 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.maketrans(intab, outtab]) maketrans() 方法用于創建字符映射的轉換表，對于接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉為空格，tab 符號默認的空格數是 8。 # string.isdecimal() 如果 string 只包含十進制數字則返回 True 否則返回 False. # string.partition(str) 有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.

?

三、列表

常用的方法

append() index() sort() count() pop() copy() remove() clear() extend() reverse() insert()

列表的索引和切片：

li = ['a','b','c',1,2,3] print(li[0]) print(li[2]) print(li[-1]) # a # c # 3 #切片 print(li[0:3]) print(li[2:5]) print(li[0:5:2]) # ['a', 'b', 'c'] # ['c', 1, 2] # ['a', 'c', 2]

增：

append(self, p_object) 添加?

Demo = ['name','age','job'] Demo.append('hobby') #在列表后面新增元素 print(Demo) Demo.append([1,'hehe',True]) print(Demo) #直接添加整個列表 # ['name', 'age', 'job', 'hobby'] # ['name', 'age', 'job', 'hobby', [1, 'hehe', True]]

insert(self, index, p_object) 插入

Demo = ['name','age','job'] Demo.insert(1,'kitty') #通過索引插入 print(Demo) # ['name', 'kitty', 'age', 'job'] insert()只能通過 索引 插入

extend(self, iterable)??

在列表后面 可迭代 的添加 Demo = ['name','age','job'] Demo.extend(' ') print(Demo) # ['name', 'age', 'job', ' '] Demo = ['name','age','job'] Demo.extend('a') print(Demo) # ['name', 'age', 'job', 'a'] Demo = ['name','age','job'] Demo.extend('abc') #可迭代的對象拆分遍歷后添加 print(Demo) # ['name', 'age', 'job', 'a', 'b', 'c'] Demo = ['name','age','job'] Demo.extend(['abc','b','c']) #可迭代的對象拆分(子序列)遍歷后添加 print(Demo) # ['name', 'age', 'job', 'abc', 'b', 'c']

刪：

pop(self, index=None)?

Demo = ['name','age','job'] t = Demo.pop(1) #pop(索引) print(Demo) print(t) # ['name', 'job'] # age

remove(self, value)

直接刪除值 Demo = ['name','age','job'] Demo.remove('age') print(Demo) # ['name', 'job']

clear(self)

清空列表 Demo = ['name','age','job'] Demo.clear() print(Demo) # []

del

刪除 Demo = ['name','age','job','wall_e','eva',1,2,3] del Demo[2] #索引刪除 print(Demo) # ['name', 'age', 'wall_e', 'eva', 1, 2, 3] Demo = ['name','age','job','wall_e','eva',1,2,3] del Demo[2:6:2] #切片刪除 print(Demo) # ['name', 'age', 'wall_e', 1, 2, 3] Demo = ['name','age','job','wall_e','eva',1,2,3] del Demo #把列表刪了，列表不存在了，報錯 not defined print(Demo) # Traceback (most recent call last): # File "D:/Demo/test.py", line 11, in <module> # print(Demo) # NameError: name 'Demo' is not defined

改：

通過索引改

Demo = ['name','age','job','wall_e','eva',1,2,3] Demo[2] = 'hobby' print(Demo) # ['name', 'age', 'hobby', 'wall_e', 'eva', 1, 2, 3]

通過切片改（迭代添加新的）

Demo = ['name','age','job','wall_e','eva',1,2,3] Demo[2:5:] = 'abcde' print(Demo) # ['name', 'age', 'a', 'b', 'c', 'd', 'e', 1, 2, 3]

查：

通過索引查

Demo = ['name','age','job','wall_e','eva',1,2,3] print(Demo[2]) # job

通過切片查

print(Demo[5:0:-2]) # [1, 'wall_e', 'age']

for i in list: 用for循環把列表的每個元素列出來

列表的嵌套：

Demo = ['name','age',['job','wall_e','eva',1],2,3] Demo[1] = 'AGE' print(Demo) # ['name', 'AGE', ['job', 'wall_e', 'eva', 1], 2, 3]
Demo = ['name','age',['job','wall_e','eva',1],2,3] Demo[1] = Demo[1].upper() print(Demo) # ['name', 'AGE', ['job', 'wall_e', 'eva', 1], 2, 3] #***必須把新生成的AGE 替換掉原來的， （通過索引改）
Demo = ['name','age',['job','wall_e','eva',1],2,3] Demo[2][2] = Demo[2][2].upper() print(Demo) # ['name', 'age', ['job', 'wall_e', 'EVA', 1], 2, 3]#列表元素 首字母大寫 Demo = ['name','age',['job','wall_e','eva',1],2,3] Demo[0].capitalize() print(Demo) print(Demo[0].capitalize()) # ['name', 'age', ['job', 'wall_e', 'eva', 1], 2, 3] # Name #不替換新的元素，原列表是不變的，即使列表是可變類型，因為字符串是不可變類型， #對字符串的操作不會改變原字符串 Demo[0] = Demo[0].capitalize() print(Demo) # ['Name', 'age', ['job', 'wall_e', 'eva', 1], 2, 3]

計數count()

Demo = ['name','age',['name','wall_e','name',1],2,'name'] print(Demo.count('name')) # 2 print(Demo.count('haha')) # 0

排序
sort(self, key=None, reverse=False) 正序
sort(reverse=True) 倒序

Demo = [1,2,3,7,6,0,4,5] Demo.sort() print(Demo) Demo = [1,2,3,7,6,0,4,5] Demo.sort(reverse=True) print(Demo) # [0, 1, 2, 3, 4, 5, 6, 7] # [7, 6, 5, 4, 3, 2, 1, 0]

反轉
reverse(self)

Demo = [1,2,3,7,6,0,4,5] Demo.reverse() print(Demo) # [5, 4, 0, 6, 7, 3, 2, 1]

join 拼接列表元素（元素如果是字符串），返回字符串

b = ['a','b','c'] print('_'.join(b)) print('mnmn'.join(b)) # a_b_c # amnmnbmnmnc s = 'alex' 字符串 通過**分開 print('_'.join(s)) # a_l_e_x

示例：

? 把任何一個嵌套列表的列表拆分打印出來

li = [1,3,4,'alex',[['a','b',['y','n'],5],7,8,['q','w',3],'taibai',[1,2,3]],5,'ritian',['haha',666]] n = 0 while n < len(li):if type(li[n]) == list:li[n:n+1] = li[n] #切片 重新賦值 一個可迭代對象（列表） ，zhongdianshi迭代添加n = n - 1else:n += 1 for j in li:print(j)# 1 # 3 # 4 # alex # a # b # y # n # 5 # 7 # 8 # q # w # 3 # taibai # 1 # 2 # 3 # 5 # ritian # haha # 666 把任何一個嵌套列表的列表拆分打印出來

四、字典

字典是無序的

字典關聯性強

字典元素為鍵值對 且 鍵 唯一 鍵 是 可哈西的（不可變數據類型：int str bool tuple）

不可哈西（list dict set）

字典是唯一一個映射的數據類型

dic_1 = {'name':'Tom','age':20}

dic_2 = {'class_1':['Tom','xiaoming','ligang'],'class_2':['張三','李四','王五']}

鍵是唯一的

dic = {'name':'Tom','name':'李剛','age':20}

print(dic) #兩個'name'

增：

?

dic[key] = value

　　原字典已經存在key 覆蓋

　　如果沒有，則添加

dic = {'name':'Tom','son':'李剛','age':20} dic['job'] = 'teacher' print(dic) # {'name': 'Tom', 'son': '李剛', 'age': 20, 'job': 'teacher'} dic = {'name':'Tom','son':'李剛','age':20} dic['son'] = '張三' print(dic) # {'name': 'Tom', 'son': '張三', 'age': 20}

setdefault(self, key, default = None)

dic = {'name':'Tom','son':'李剛','age':20} dic.setdefault('hobby') #default沒有的情況，默認為None # {'name': 'Tom', 'son': '李剛', 'age': 20, 'hobby': None} #None 就是空 分配給一個特殊的所有的空的公共內存空間 dic = {'name':'Tom','son':'李剛','age':20} dic.setdefault('hobby','girls') # {'name': 'Tom', 'son': '李剛', 'age': 20, 'hobby': 'girls'} dic = {'name':'Tom','son':'李剛','age':20} dic.setdefault('name','王五') #字典中已經有'name' key ，就不對字典做任何修改 # {'name': 'Tom', 'son': '李剛', 'age': 20} #

刪：

pop(self, key)? ?有返回值

dic = {'name':'Tom','son':'李剛','age':20} print(dic.pop('name')) #通過鍵刪除 print(dic) # Tom # {'son': '李剛', 'age': 20} dic = {'name':'Tom','son':'李剛','age':20} print(dic.pop('city')) #如果鍵不存在，報錯 KeyError：*** print(dic)# Traceback (most recent call last): # File "D:/Demo/test2.py", line 2, in <module> # print(dic.pop('city')) # KeyError: 'city' dic = {'name':'Tom','son':'李剛','age':20} print(dic.pop('city',None)) #加上返回值None，且鍵不存在，說明key不存在， 當然也可以把None換成 '不存在' print(dic) # None # {'name': 'Tom', 'son': '李剛', 'age': 20}

popitem(self)??隨機刪

dic = {'name':'Tom','son':'李剛','age':20} print(dic.popitem()) print(dic) # ('age', 20) # {'name': 'Tom', 'son': '李剛'}

clear(self)? 清空

dic = {'name':'Tom','son':'李剛','age':20} print(dic.clear()) print(dic) # None # {}

del? 刪除字典

dic = {'name':'Tom','son':'李剛','age':20} del dic['name'] print(dic) # {'son': '李剛', 'age': 20}del dic #刪除整個字典

改：

增功能中的覆蓋

dic = {'name':'Tom','son':'李剛','age':20} dic['name'] = '王五' print(dic) # {'name': '王五', 'son': '李剛', 'age': 20}

update（self, E=None, **F）? 更新

　　覆蓋并添加

dic1 = {'name':'Tom','age':20} dic2 = {'name':'王五','pc':8888} dic1.update(dic2) print(dic1) #dic1變了 dic2沒有變 print(dic2) # {'name': '王五', 'age': 20, 'pc': 8888} # {'name': '王五', 'pc': 8888}

查：

dic[key]? 如果鍵不存在，會報錯

dic = {'name':'Tom','age':20} print(dic['name']) print(dic['hehhehe']) # Tom# Traceback (most recent call last): # File "D:/Demo/test2.py", line 3, in <module> # print(dic['hehhehe']) # KeyError: 'hehhehe'

get(self, k: _KT)

dic = {'name':'Tom','age':20} print(dic.get('name')) # Tom dic = {'name':'Tom','age':20} print(dic.get('heheh')) # None dic = {'name':'Tom','age':20} print(dic.get('heheh','鍵不存在 -1')) # 鍵不存在 -1

字典for循環：

#1. keys() dic = {'name':'Tom','age':20,'job':'teacher'} for key in dic: # for key in dic.keys()print(key) # print(key) 一樣的效果 # name # age # job #2. values() dic = {'name':'Tom','age':20,'job':'teacher'} print(dic.values(),type(dic.values())) #直接print # dict_values(['Tom', 20, 'teacher']) <class 'dict_values'> for value in dic.values():print(value) # Tom # 20 # teacher #3. items() dic = {'name':'Tom','age':20,'job':'teacher'} print(dic.items(),type(dic.items())) # dict_items([('name', 'Tom'), ('age', 20), ('job', 'teacher')]) <class 'dict_items'> for i in dic.items():print(i) # ('name', 'Tom') # ('age', 20) # ('job', 'teacher') #-------------------- a,b = [1,2] print(a,b) #分別賦值 # 1 2 dic = {'name':'Tom','age':20,'job':'teacher'} for key, value in dic.items(): #key, value 分別接收數據print(key,value) # name Tom # age 20 # job teacher print(type(key),type(value)) #得到的是字符串 # <class 'str'> <class 'str'>

五、元組

只讀，不可修改
元組不可修改，但是元組如果包含列表，列表的內容可以更改

a = (1,3,5) a[1] = 9 #報錯，tuple 對象不支持更改 print(a) # Traceback (most recent call last): # File "D:/Demo/test.py", line 2, in <module> # a[1] = 9 # TypeError: 'tuple' object does not support item assignment Demo = ('name','age',['wall_e','name',1],2) Demo[2][1] = 'job' print(Demo) # ('name', 'age', ['wall_e', 'job', 1], 2)

六、集合

集合是無序的，不重復的數據集合，它里面的元素是可哈希（不可變類型），

但是集合本身是不可哈希，（所以集合做不了字典的鍵）

集合最重要的2點：

　　去重：把一個列表變成集合，就自動去重了。

　　關系測試：測試兩組數據之間的交集、并集、差集等關系

創建： set = set({ }) set = { } ------------------------------------- 增： add.() set = { } set.add(self, element) #set.add('kitty') update(self, iterable) # 迭代添加 set.update() #set = {1,'d'} #set.update('龜叔') #print(set) #{1, '龜', 'd', '叔'} 刪： pop(self) # 隨機刪1個element remove(self, element) # 指定刪1個element clear(self) # 清空set() del set # 刪集合本身 返回<class 'set'>

集合交集、并集、差集、反交集、子集、超集：

set1 = {1,2,3,4} set2 = {3,4,5,6} 交集：set1 & set2 set1.intersection(set2) # 3，4 反交集：set1 ^ set2 set1.symmetric_difference(set2) # 1,2,5,6 并集：set1 | set2 set1.union(set2) # 1,2,3,4,5,6 差集 : set1 - set2 是 1,2 set1 - set2 set1.difference(set2)set2 - set1 是 3,4 ***----*** ****------------****set1 = {1,2,3} set2 = {1,2,3,4,5,6} 子集：set1 < set2 set1.issubset(set2) 返回True or False 超集：set2 > set1 set2.issuperset(set1) 返回True or False不可變集合：（把集合變成可哈西的）set = frozenset(iteralbe) 迭代創建set()set = frozenset('abc')print(type(set))#frozenset({'b', 'c', 'a'})#<class 'frozenset'>

?

轉載于:https://www.cnblogs.com/zhzhlong/p/8480581.html

總結

以上是生活随笔為你收集整理的python（5）- 基础数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。