Python3 中有六種標準數據類型:
A、Number(數字)
B、String(字符串)
C、List(列表)
D、Tuple(元組)
E、Set(集合)
F、Dictionary(字典)
Python3 的六種標準數據類型中,Number(數字)、String(字符串)、Tuple(元組)是不可變的,List(列表)、Dictionary(字典)、Set(集合)是可變的。python
Python 數字數據類型用於存儲數值。
數字數據類型是不容許改變的,若是改變數字數據類型的值,將從新分配內存空間。
Python中Number有四種類型:bool、int、float、complex。bool類型表示真假,值爲True、False;int類型表示長整數;float表示浮點數;complex表示複數。
int (整數),只有一種整數類型 int。
bool (布爾),如 True。
float (浮點數),如 1.2三、3E-2
complex (複數),如 1 + 2j、1.1 + 2.2jgit
若是須要對數據內置的類型進行轉換,數據類型的轉換,只須要將數據類型做爲函數名便可。
bool(x):將x轉換爲一個bool值,非空爲True,空爲Fasle。
int(x) :將x轉換爲一個整數。
float(x) :將x轉換到一個浮點數。
complex(x) :將x轉換到一個複數,實數部分爲 x,虛數部分爲 0。
complex(x, y) :將 x 和 y 轉換到一個複數,實數部分爲 x,虛數部分爲 y。x 和 y 是數字表達式。api
#!/usr/bin/python3 a = 3.14 b = int(a) print(b) c = complex(a) print(c) d = complex(a,b) print(d)
Python 解釋器能夠解析輸入的一個表達式,輸出表達式的值。
在整數除法中,除法 / 老是返回一個浮點數,若是隻想獲得整數的結果,丟棄可能的分數部分,可使用運算符 //。在整數除法中,除法 / 老是返回一個浮點數,若是隻想獲得整數的結果,丟棄可能的分數部分,可使用運算符 // 。// 獲得的並不必定是整數類型的數,結果與分母分子的數據類型有關係。數組
#!/usr/bin/python3 a = 10 b = 5 c= a + b print(c) c = a - b print(c) c = a * b print(c) c = a / b print(c) c = 2 ** a print(c) c = 10 % 3 print(c) c = 10 // 3 print(c) c = 10.0 // 3 print(c) c = 10 // 3.0 print(c)
在交互模式中,最後被輸出的表達式結果被賦值給變量 _
。數據結構
>>> tax = 13/100 >>> price = 100 >>> price * tax 13.0 >>> _ 13.0 >>> price + _ 113.0 >>> _ 113.0
abs(x):返回數字的絕對值
ceil(x):返回數字的向上取整整數
exp(x):返回e的x次冪,如math.exp(1) 返回2.718281828459045
fabs(x):返回數字的絕對值,如math.fabs(-10) 返回10.0
floor(x):返回數字的向下取整整數,如math.floor(4.9)返回 4
log(x):返回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,...,xn):返回給定參數的最大值,參數能夠爲序列
min(x1,x2,...,xn):返回給定參數的最小值,參數能夠爲序列
modf(x):返回x的整數部分與小數部分,兩部分的數值符號與x相同,整數部分以浮點型表示
pow(x,y):x**y
運算後的值
round(x,[n]):返回浮點數x的四捨五入值,如給出n值,則表明舍入到小數點後的位數。
sqrt(x):返回數字x的平方根。app
#!/usr/bin/python3 import math c = abs(-10.9) print(c) c = math.ceil(4.1) print(c) c = math.exp(1) print(c) c = math.exp(3) print(c) c = math.fabs(-10.9) print(c) c = math.floor(4.9) print(c) c = math.log(math.e) print(c) # 1.0 c = math.log(100,10) print(c) # 2.0 c = math.log10(100) print(c) # 2.0 c = max([1,4,2]) print(c) c = min([1,4,3]) print(c) c = math.modf(4.8) print(c) # (0.7999999999999998, 4.0) c = pow(10,2) print(c) c = round(3.1415,2) print(c) c = math.sqrt(3) print(c)
choice(seq):從序列的元素中隨機挑選一個元素,好比random.choice(range(10)),從0到9中隨機挑選一個整數。
randrange([start,] stop [,step]) :從指定範圍內,按指定基數遞增的集合中獲取一個隨機數,基數缺省值爲1
random():隨機生成下一個實數,在[0,1)範圍內。
shuffle(seq):將序列的全部元素隨機排序
uniform(x,y):隨機生成下一個實數,在[x,y]範圍內。dom
#!/usr/bin/python3 import random c = random.choice([1,2,3,4,5,6]) print(c) c = random.randrange(0,100,2) print(c) c = random.random() print(c) list1 = [1,2,3,4,5] random.shuffle(list1) print(list1) c = random.uniform(1,100) print(c)
acos(x):返回x的反餘弦弧度值
asin(x):返回x的反正弦弧度值
atan(x):返回x的反正切弧度值
atan2(y,x):返回給定的 X 及 Y 座標值的反正切值
cos(x):返回x的弧度的餘弦值
hypot(x):返回歐幾里德範數 sqrt(xx + yy)。
sin(x):返回的x弧度的正弦值
tan(x):返回x弧度的正切值。
degrees(x):將弧度轉換爲角度,如degrees(math.pi/2) , 返回90.0
radians(x):將角度轉換爲弧度ide
#!/usr/bin/python3 import math c = math.acos(0) print(c) c = math.acos(-1) print(c) c = math.acos(1) print(c) c = math.asin(0) print(c) c = math.asin(-1) print(c) c = math.asin(1) print(c) c = math.atan(0) print(c) c = math.atan(-1) print(c) c = math.atan(1) print(c) c = math.atan2(-0.5,-0.5) print(c) c = math.cos(math.pi) print(c) c = math.cos(0) print(c) c = math.cos(2*math.pi) print(c) c = math.hypot(3,2) print(c) c = math.sin(math.pi) print(c) c = math.sin(0) print(c) c = math.sin(math.pi / 2) print(c) c = math.tan(math.pi / 2) print(c) c = math.tan(math.pi / 4) print(c) c = math.tan(0) print(c) c = math.degrees(math.pi / 2) print(c) c = math.degrees(math.pi / 4) print(c) c = math.degrees(math.pi) print(c) c = math.radians(math.pi / 2) print(c) c = math.radians(math.pi / 4) print(c) c = math.radians(math.pi) print(c)
pi:數學常量 pi(圓周率,通常以π來表示)。
e:數學常量 e,e即天然常數(天然常數)。函數
#!/usr/bin/python3 import math print(math.pi) print(math.e)
Python中,二進制、八進制、十六進制的表示以下:
二進制表示:0bxxxx,如0b0101
八進制表示:0oxxxx,如0o11
十六進制表示:0xxxxx,如0x1FFF
Python中不一樣進制數轉換爲二進制、八進制、十進制、十六進制的函數以下:
bin()、oct()、int()、hex()。ui
#!/usr/bin/python3 # 二進制表示 print(0b0101) # 八進制表示 print(0o10) # 十六進制表示 print(0xABC) # 二進制轉換 print(bin(1024)) # 八進制轉換 print(oct(1024)) # 十六進制轉換 print(hex(1024)) # 十進制轉換 print(int(0b0101))
字符串是 Python 中最經常使用的數據類型,可使用引號( ' ,"或""")來建立字符串,其中"""用於建立多行字符串。
Python不支持單字符類型,單字符在Python 中也是做爲一個字符串使用。
Python 訪問子字符串,可使用方括號來截取字符串。
#!/usr/bin/python3 a = 'Hello World!' print(a[0]) print(a[1:5])
在須要在字符中使用特殊字符時,python用反斜槓()轉義字符。
#!/usr/bin/python3 print('This is Python') print("This's Python") print(""" This is Go, Python, C++ """ )
Python 不支持單字符類型,單字符在 Python 中做爲一個字符串使用。Python 訪問子字符串,可使用方括號來截取字符串。
#!/usr/bin/python3 a = "Hello world" print(a[0]) print(a[0:5]) print(a[-1])
使用索引訪問字符串中字符時,若是使用負數索引,表示從字符串右側開始進行索引,-1表示字符串右側開始的第一個字符。
lang = "Java,C,C++,Go,Python" print(lang[-6:]) # Python print(lang[14:]) # Python print(lang[11:13]) # Go
\(在行尾):續行符
\:反斜杆符號
\’:單引號
\」:雙引號
\a:響鈴
\b:退格
\e:轉義
\000:空
\n:換行
\v:縱向製表符
\t:橫向製表符
\r:回車
\f:換頁
\oyy:八進制數,yy表明字的字符
\xyy:十六進制數,yy表明的字符
\other:其它字符以普通格式還輸出
+:鏈接字符串*
:重複輸出字符串
[]:經過索引獲取字符串中字符
[:]:截取字符串的一部分,左閉右開
in:若是字符串中包含給定的字符,返回True
not in:若是字符串中不包含給定的字符,返回True
%:格式字符串
r/R:原始字符串,原始字符串除在字符串的第一個引號前加上字母 r(能夠大小寫)之外,字符串的字符不進行轉義。
#!/usr/bin/python3 a = "Hello" b = "Python3" c = a + b print(c) c = 2 * a print(c) print(a[3]) print(a[1:4]) if "3" in b: print("3") print(r"Hello Go\n") print("Hello Python3"[-1]) print("Hello Python3"[6:]) # Python3 print("Hello Python3"[:5]) # Hello print("Hello Python3"[:-1]) # Hello Python
對字符串進行截取時,須要指定起始索引和結束索引,若是給定的結束索引超出了字符串的實際結束位置,會截取從開始索引到結束的字符串部分。若是不指定開始索引或結束索引,表示從第0個元素開始或是到最後一個元素結束。
Python 支持格式化字符串的輸出 ,基本用法是將一個值插入到一個有字符串格式符 %s 的字符串中。字符串格式化符號以下:
%c:格式化字符以及ASCII碼
%s:格式化字符串
%d:格式化整數
%u:格式化無符號整數
%o:格式化無符號八進制數
%x:格式化無符號十六進制數
%X:格式化無符號十六進制數()大寫
%f:格式化浮點數,可指定精度
%e:使用科學計數法格式化浮點數
%E:使用科學計數法格式化浮點數
%g:%f和%e的簡寫
%G:%f和%E的簡寫
%p:用十六進制數格式化變量的地址
#!/usr/bin/python3 print("姓名:%s 年齡:%d 歲" % ('×××', 20))
str.capitalize():將字符串的第一個字母變成大寫,其餘字母變小寫。
center(width[, fillchar]):返回一個指定的寬度 width 居中的字符串,fillchar 爲填充的字符,默認爲空格。
str.count(sub, start= 0,end=len(string)):統計字符串裏某個字符出現的次數。可選參數爲在字符串搜索的開始與結束位置。
str.encode(encoding='UTF-8',errors='strict'):以指定的編碼格式編碼字符串,errors參數能夠指定不一樣的錯誤處理方案。
bytes.decode(encoding="utf-8", errors="strict"):指定的編碼格式解碼 bytes 對象。默認編碼爲 'utf-8'。
str.endswith(suffix[, start[, end]]):用於判斷字符串是否以指定後綴結尾,若是以指定後綴結尾返回True,不然返回False。可選參數"start"與"end"爲檢索字符串的開始與結束位置。
expandtabs(tabsize=8):把字符串中的 tab 符號('\t')轉爲空格,tab 符號('\t')默認的空格數是 8。
find(str, beg=0, end=len(string)):檢測字符串中是否包含子字符串 str ,若是指定 beg(開始) 和 end(結束) 範圍,則檢查是否包含在指定範圍內,若是指定範圍內若是包含指定索引值,返回的是索引值在字符串中的起始位置。若是不包含索引值,返回-1。
index(str, beg=0, end=len(string)):若是包含子字符串返回開始的索引值,不然拋出異常。
isalnum():檢測字符串是否由字母和數字組成。若是 字符串至少有一個字符而且全部字符都是字母或數字則返回 True,不然返回 False。
isalpha():檢測字符串是否只由字母組成。若是字符串至少有一個字符而且全部字符都是字母則返回 True,不然返回 False。
isdigit():檢測字符串是否只由數字組成。若是字符串只包含數字則返回 True ,不然返回 False。
islower():檢測字符串是否由小寫字母組成。若是字符串中包含至少一個區分大小寫的字符,而且全部區分大小寫的字符都是小寫,則返回 True,不然返回 False。
isnumeric():檢測字符串是否只由數字組成,只針對unicode對象。若是字符串中只包含數字字符,則返回 True,不然返回 False。
isspace():檢測字符串是否只由空白字符組成。若是字符串中只包含空格,則返回 True,不然返回 False。
istitle():檢測字符串中全部的單詞拼寫首字母是否爲大寫,且其它字母爲小寫。若是字符串中全部的單詞拼寫首字母是否爲大寫,且其它字母爲小寫則返回 True,不然返回 False。
isupper():檢測字符串中全部的字母是否都爲大寫。若是字符串中包含至少一個區分大小寫的字符,而且全部區分大小寫的字符都是大寫,則返回 True,不然返回 False。
join(sequence):用於將序列中的元素以指定的字符鏈接生成一個新的字符串。返回經過指定字符鏈接序列中元素後生成的新字符串。
len(str):返回對象(字符、列表、元組等)長度或項目個數。
ljust(width[, fillchar]):返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。若是指定的長度小於原字符串的長度則返回原字符串。
lower():轉換字符串中全部大寫字符爲小寫。將字符串中全部大寫字符轉換爲小寫後返回。
lstrip([chars]):用於截掉字符串左邊的空格或指定字符。返回截掉字符串左邊的空格或指定字符後生成的新字符串。
str.maketrans(intab, outtab):用於建立字符映射的轉換表,第一個參數是字符串,表示須要轉換的字符,第二個參數是字符串表示轉換的目標。兩個字符串的長度必須相同,爲一一對應的關係。
translate(table[, delete]):根據參數table轉換字符串的字符,要過濾掉的字符放到 deletechars 參數中。table翻譯表是經過 maketrans() 方法轉換而來,delete是字符串中要過濾的字符列表。返回翻譯後的字符串,若給出了delete 參數,則將原來的bytes中的屬於delete的字符刪除,剩下的字符要按照table中給出的映射來進行映射 。
max(str):返回字符串中最大的字母。
min(str):返回字符串中最小的字母。
replace(old, new[, max]):把字符串中的 old(舊字符串) 替換成 new(新字符串),若是指定第三個參數max,則替換不超過 max 次。
rfind(str, beg=0 end=len(string)):返回字符串最後一次出現的位置,若是沒有匹配項則返回-1。
rindex(str, beg=0 end=len(string)):返回子字符串 str 在字符串中最後出現的位置,若是沒有匹配的字符串會報異常,能夠指定可選參數[beg:end]設置查找的區間。
rjust(width[, fillchar]):返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。若是指定的長度小於字符串的長度則返回原字符串。
rstrip([chars]):刪除 string 字符串末尾的指定字符(默認爲空格)
split(str="", num=string.count(str)):指定分隔符對字符串進行切片,若是參數 num 有指定值,則僅分隔 num+1 個子字符串。返回分割後的字符串列表。
splitlines([keepends]): 按照行('\r', '\r\n', \n')分隔,返回一個包含各行做爲元素的列表,若是參數 keepends 爲 False,不包含換行符,若是爲 True,則保留換行符。
startswith(substr, beg=0,end=len(string)):用於檢查字符串是不是以指定子字符串開頭,若是是則返回 True,不然返回 False。若是參數 beg 和 end 指定值,則在指定範圍內檢查。若是檢測到字符串則返回True,不然返回False。
strip([chars]):用於移除字符串頭尾指定的字符(默認爲空格)或字符序列。
返回移除字符串頭尾指定的字符序列生成的新字符串。
swapcase():用於對字符串的大小寫字母進行轉換。返回大小寫字母轉換後生成的新字符串。
title():返回"標題化"的字符串,全部單詞的首個字母轉化爲大寫,其他字母均爲小寫。若是單詞的第一個字符爲非字母,非字母后的第一個字母將轉換爲大寫字母。
upper():將字符串中的小寫字母轉爲大寫字母。返回小寫字母轉爲大寫字母的字符串。
zfill(width):返回指定長度的字符串,原字符串右對齊,前面填充0。返回指定長度的字符串。
isdecimal():檢查字符串是否只包含十進制字符,只存在於unicode對象。若是字符串是否只包含十進制字符返回True,不然返回False。
ord(c):獲取字符c的ASCII碼編碼值
#!/usr/bin/python3 a = str.capitalize("hello Python") print(a) # Hello python a = "Hello Python3" print(a.center(40, "-")) # ------------Hello Python3-------------- print(a.count("l")) # 2 a_utf8 = a.encode("UTF-8") print(a_utf8) print(a_utf8.decode("UTF-8")) a = "hello.bin" if a.endswith("bin"): print("The file is bin file") a = "\tHello Python3" print(a.expandtabs(4)) print(a[a.find("Hello"):]) print(a.isalnum()) a = "Hello python3" print(a.istitle()) # False a = "Hello Python3" print(a.istitle()) # True s1 = "," s2 = "" seq = ["C++","Go","Java","Python"] print(s1.join(seq)) # C++,Go,Java,Python print(s2.join(seq)) # C++GoJavaPython print(a.ljust(40,"-")) print(a.lower()) a = "***Hello Python3" print(a.lstrip("*")) intab = "aeiou" outtab = "12345" c = "Hello Python3" trantab = str.maketrans(intab, outtab) print(c.translate(trantab)) c = "hello world" trantab = str.maketrans('abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') print(c.translate(trantab)) c = "Hello Python3" print(c.split(" "))
序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字做爲索引,第一個索引是0,第二個索引是1,依此類推。
Python常見的序列是字符串、列表和元組。
序列均可以進行的操做包括索引,切片,加,乘,檢查成員。
此外,Python已經內置肯定序列的長度以及肯定最大和最小的元素的方法。
列表是最經常使用的Python數據類型,能夠做爲一個方括號內的逗號分隔值出現。
列表的數據項不須要具備相同的類型。
建立一個列表,只要把逗號分隔的不一樣的數據項使用方括號括起來便可。
列表元素的訪問可使用索引進行,能夠指定開始索引和結束索引進行切片操做。
#!/usr/bin/python3 list1 = ['Python3', True, 2019, 3.14]; list2 = [1, 2, 3, 4, 5, 6, 7]; print(list1[0]) print(list2[1:5])
對列表進行解包時,接收對象個數必須與列表的元素個數相匹配。
#!/usr/bin/python3 a, b, c = [1, "Hello Python", True] # a, b = [1,"Hello Python", True]錯誤 print(a, b, c)
#!/usr/bin/python3 list1 = ['Go', 'Python3', "Java", 2019] print(list1[3]) list1[3] = "C++" print(list1[3])
del 語句能夠用於刪除列表的的元素。
#!/usr/bin/python3 list1 = ['Go', 'Python3', "Java", 2019] print(list1[3]) del list1[3] print(list1)
+:組合,將兩個列表進行組合後生成新的列表*
:重複,將列表的元素重複屢次,生成新的列表
x in list:判斷x是否在列表中,若是是返回True,不然返回False。
for x in list: print(x, end=" "):對列表進行迭代
#!/usr/bin/python3 list1 = ["C++", "Java", "Python", "Go"] list2 = ["Lua", "NodeJS"] print(list1 + list2) print(2 * list1) if "C++" in list1: print("C++") for x in list1: print(x)
len(list)
列表元素個數
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
將序列轉換爲列表
#! /usr/bin/python3 list1 = [1, 1, 2, 3, 4, 5, 8] print(len(list1)) print(max(list1)) print(min(list1)) list2 = list((1, 2, 3, 4, 5)) print(list2)
list.append(obj)
在列表末尾添加新的對象
list.count(obj)
統計某個元素在列表內出現的次數
list.extend(seq)
在列表末尾一次性追加另外一個序列中的多個值(用新列表擴展原來的列表)
list.index(obj)
從列表中找出某個值第一個匹配項的索引位置
list.×××ert(index,obj)
在列表的index位置插入對象obj
list.pop(index=-1)
移除列表中位置爲index(默認爲最後一個)的元素,並返回元素的值
list.remove(obj)
移除列表中某個值的第一個匹配項
list.reverse()
反向列表中的元素
list.sort(key=None,reverse=False)
對列表進行排序,較函數指定的比較函數。
key 用來進行比較的元素,只有一個參數,具體的函數的參數就是取自於可迭代對象中,指定可迭代對象中的一個元素來進行排序;reverse 指定排序規則,reverse = True 降序, reverse = False 升序(默認)。
list.clear()
清空列表
list.copy()
複製列表
#! /usr/bin/python3 list1 = [1, 3.14, True] list1.append("Python") print(list1) print(list1.count(1)) # True也會被統計爲1 list1.extend(["C++", "Java", "Go"]) print(list1) print(list1.index(1)) list1.×××ert(1, "Hello") print(list1) print(list1.pop(1)) list1.remove(True) # 刪除第一個1 print(list1) list1.reverse() print(list1) list1 = [1, 13, 5, 9] list2 = list1.copy() print(list2) list1.clear() print(list1) list1 = [(2, 2), (3, 4), (4, 1), (1, 3)] def take(elem): return elem[1] list1.sort(key=take) print(list1) # [(4, 1), (2, 2), (1, 3), (3, 4)]
元組使用小括號建立,只須要在括號中添加元素,並使用逗號隔開,元素能夠是不一樣類型。
#! /usr/bin/python3 tup1 = ("Go", "Python", 1, 3.14, True) # 元組 tup2 = 1, 2, 3.14, "Python" # 元組 tup3 = () # 空元組 tup4 = (1,) # 一個元素的元組 tup5 = (1) # 整型數字 print(type(tup1)) print(type(tup2)) print(type(tup3)) print(type(tup4)) print(type(tup5))
元組可使用下標索引來訪問元組中的值。
#! /usr/bin/python3 tup1 = ('Go', 'C++', True, 3.14) tup2 = (1, 2, 3, 4, 5, 6, 7) print(tup1[1]) print(tup2[1:5])
對元組進行解包時,接收對象個數必須與元組的元素個數相匹配。
#!/usr/bin/python3 a, b, c = (1, "Hello Python", True) # a, b = (1,"Hello Python", True) 錯誤 print(a, b, c)
元組中的元素值是不容許修改的,但能夠對元組進行鏈接組合。
#! /usr/bin/python3 tup1 = (1, 2) tup2 = ('Go', 'Python') # tup1[0] = 100 # 不能修改 tup3 = tup1 + tup2 print(tup3)
tuple元素不可變有一種特殊狀況,當元素是可變對象時,對象內部屬性是能夠修改的。tuple的不可變限制只是在一個緯度上:元素的類型。tuple的元素所保存的內容(數值或內存地址)是不容許修改的,但地址映射的對象自身是能夠修改的。
#!/usr/bin/python3 tup1 = ("Go", "Python", [1,2,True]) tup1[2][2] = False print(tup1)
元組中的元素值不容許刪除,但可使用del語句來刪除整個元組。
#! /usr/bin/python3 tup2 = ('Go', 'Python') print(tup2) del tup2
+:鏈接兩個元組,生成新的元組。*
:重複屢次元組
x in tuple:判斷x是否在元組中,若是存在返回True,不然返回False。
for x in tuple:迭代元組
#!/usr/bin/python3 tup1 = ("Go", "Python", [1, 2, True]) tup2 = (1, 2, 3) print(tup1 + tup2) print(2 * tup1) if "Python" in tup1: print("Python") for x in tup1: print(x)
len(tuple)
計算元組元素的個數
max(tuple)
返回元組中元素的最大值
min(tuple)
返回元組中元素的最小值
tuple(seq)
將序列轉換爲元組
#! /usr/bin/python3 tup1 = (1, 2, 3) print(len(tup1)) print(max(tup1)) print(min(tup1)) tup2 = tuple([1, "Go", 3.14, True]) print(tup2)
字典是一種無序的數據結構,可存儲任意類型對象。字典的每一個鍵值(key:value)對用冒號(:)分割,鍵值對之間用逗號(,)分割,整個字典包括在花括號({})中 ,格式以下:
d = {key1 : value1, key2 : value2 }
鍵必須是惟一的,但值則沒必要惟一。值能夠取任何數據類型,但鍵必須是不可變的,如字符串,數字或元組。
字典值能夠是標準的對象,也能夠是用戶定義的,但鍵不行。
字典中不容許同一個鍵出現兩次,建立時若是同一個鍵被賦值兩次,後一個值會被記住。鍵必須不可變,能夠用數字、字符串或元組做爲鍵,列表不能夠。
#!/usr/bin/python3 dict1 = {'Name': 'Lee', 'Age': 27} print(dict1['Name']) print(dict1['Age'])
字典是無序的,所以不能使用索引訪問字典的元素,可使用key訪問字典的相應key的值,若是用字典裏沒有的鍵訪問數據,會輸出錯誤。
向字典添加新內容的方法是增長新的鍵/值對,修改或刪除已有鍵值對。
#!/usr/bin/python3 dict1 = {'Name': 'Lee', 'Age': 17} print(dict1['Name']) print(dict1['Age']) dict1['Name'] = "Bauer" dict1['Age'] = 30 dict1['School'] = "Python School" print(dict1['Name']) print(dict1['Age']) print(dict1['School'])
能夠刪除字典元素,能夠清空字典,也能夠刪除字典。
#!/usr/bin/python3 dict1 = {'Name': 'Lee', 'Age': 17} print(dict1) del dict1["Age"] dict1.clear() del dict1
len(dict)
計算字典元素個數,即鍵的總數。
str(dict)
輸出字典
dict.clear()
刪除字典內全部元素
dict.copy()
返回一個字典的淺複製
dict.fromkeys(seq[,value])
以序列 seq 中元素作字典的鍵,value 爲字典全部鍵對應的初始值建立一個新字典。
dict.get(key[,default=None])
返回字典中指定鍵的值,若是值不存在,返回default值。
key in dict
若是key存在字典中,返回True,不然返回False。
dict.items()
以列表返回可遍歷的(鍵, 值) 元組數組
dict.keys()
返回一個迭代器,可使用list轉換爲列表
dict.setdefault(key,default=None)
修改key的值爲default,若是鍵不存在於字典中,將會添加鍵並將值設爲default。
dict.update(dict2)
將字典dict2的鍵值對更新到dict字典裏
dict.values()
返回字典中全部值的迭代器,可使用list轉換爲列表
dict.pop(key[,default])
刪除字典給定鍵 key 所對應的值,返回值爲被刪除的值。key值必須給出。 不然,返回default值。
dict.popitem()
隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)。
集合(set)是一個無序的無重複元素序列,可使用大括號 { } 或者 set() 函數建立集合。建立一個空集合必須用 set() 而不是 { },{ } 用來建立一個空字典。
集合是無序的序列,所以不能使用索引對集合元素進行訪問。集合的運算包括差、並、交。
#!/usr/bin/python3 fruit = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(fruit) print("apple" in fruit) a = set("Hello") b = set("world") print(a) print(b) print(a - b) print(a | b) print(a & b) print(a ^ b) c = {x for x in 'abracadabra' if x not in 'abc'} print(c)
add(x):將元素 x 添加到集合 中,若是元素已存在,則不進行任何操做。
update(x):將x添加到集合中,且x參數能夠是列表,元組,字典等。
remove(x):將元素 x 從集合中移除,若是元素不存在,則會發生錯誤。
discard(x):將元素 x 從集合中移除,若是元素不存在,不會發生錯誤。
pop():隨機刪除集合中的一個元素
len(s):計算集合 s 元素個數。
clear():清空集合。
x in s:判斷元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。
copy():返回一個集合的拷貝
set.difference(set):返回集合的差集,即返回的集合元素包含在第一個集合中,但不包含在第二個集合(方法的參數)中。
set.difference_update(set):在原始集合上移除指定集合中存在的元素,沒有返回值。
set.intersection(set1, set2 ... etc):返回兩個或更多集合中都包含的元素,即交集。
set.intersection_update(set1, set2 ... etc):在原始的集合上移除不重疊的元素,沒有返回值。
set.isdisjoint(set):判斷兩個集合中是否包含相同的元素,若是沒有返回 True,不然返回 False。
set.issubset(set):判斷集合是不是指定集合的子集,若是是則返回 True,不然返回 False。
set.issuperset(set):判斷指定集合是不是集合的子集,若是是則返回 True,不然返回 False。
set.symmetric_difference(set):將兩個集合中不重複的元素做爲一個集合返回。
set.symmetric_difference_update(set):移除當前集合中在另一個指定集合相同的元素,並將另一個指定集合中不一樣的元素插入到當前集合中。無返回值。
set.union(set1, set2...):返回兩個集合的並集,即包含了全部集合的元素,重複的元素只會出現一次。
#!/usr/bin/python3 set1 = {"Go", "C++", "Java", "Python3"} set1.add("C") print(set1) set1.add("Go") print(set1) set1.update({"NodeJS", "Lua"}) print(set1) set1.update([1, 2, 3], [4, 5]) print(set1) set1 = {"C++", "C", "Go"} set2 = {"Python", "Lua", "NodeJS"} set3 = set1.union(set2) print(set3) print(set1.intersection(set3)) print(set1.issubset(set3)) print(set3.issuperset(set1)) print(set3.difference(set1)) print(set1.symmetric_difference(set3)) set1.symmetric_difference_update(set3) set1.difference_update(set3) print(set1)