第一類：數值類型
一.數值型包括
1.int(整型)：python3里數字不管多大永遠都是int長整型，且沒有大小限制，受限於內存區域的大小
類型轉換：int(x)返回一個整數
2.float(浮點型)：有整數部分和小數部分組成。支持十進制和科學計數法表示。只有雙精度型
類型轉換：float(x)返回一個浮點數
3.complex(負數)：有實數和虛數部分組成，實數和虛數部分都是浮點數，3+4.2J
類型轉換：comlex(x),complex(x,y)返回一個復數
4.bool(布爾型)：int的子類，僅有2個實例True,False對應1和0，可以和整數直接運算
類型轉換：bool(x)返回布爾值
二.數字的處理函數
1.round()：四舍六入五取偶
>>> round(2.6)
3
2.floor()地板：向下取整
>>> import math >>> math.floor(2.9) 2
3.ceil()天花板：向上取整
>>> import math >>> math.ceil(2.1) 3
4.int()取整數部分，和//整除一樣
>>> int(1.8)
1
5.min()：取最小值
>>> min(1,6,9)
1
6.max()：取最大值
>>> max(1,6,9)
9
7.pow(x,y)：等於x**y平方
>>> pow(5,2)
25
8.math.sqrt()：返回數字x的平方根
>>> import math >>> math.sqrt(100) 10.0
9.進制函數，返回值是字符串
(1)bin()：二進制整數
>>> bin(2) '0b10'
(2)oct()：八進制整數
>>> oct(2) '0o2'
(3)hex()：十進制整數
>>> hex(2) '0x2'
10.math.pi：π的值
>>> import math >>> math.pi 3.141592653589793
11.math.e自如常數
>>> import math >>> math.e 2.718281828459045
三.類型判斷
1.type(obj)，返回類型，而不是字符串
舉例：判斷1是什么類型
>>> type(1) <class 'int'>
2.isinstance(obj,class_or_tuple)返回值是布爾值
舉例：判斷6是不是int類型
>>> isinstance(6,int)
True
舉例：判斷6是不是int類型或者str類型的其中一個
>>> isinstance(6,(int,str))
True
四.類型轉換
1.字符串類型轉換數字類型功能：將字符串轉換為數字：a="123"是字符串，通過int(a)，把a變成int數字類型，type查看是類型
a = "123" print(type(a), a) b = int(a) print(type(b), b)
輸出：
<class 'str'> 123
<class 'int'> 123
2.進制轉換功能：通過base=16把num="a"以16進制的方式轉換成十進制
num = "a" v = int(num, base=16) print(v)
輸出：
10
3.bit_lenght功能：當前數字的二進制，至少用n位表示
舉例：通過age.bit_length查看age=5是的二進制數字是幾位來表示
age = 5 r = age.bit_length() print(r)
5的二進制數字是101輸出：
3
第二類：線性結構(包括字符串-列表-元祖-bytes-bytearray)
字符串類型
一.字符串特性
1.使用引號定義的一組可以包含數字，字母，符號(非特殊系統符號)的集合
2.使用單引號，雙引號，三引號引住的字符序列
3.字符串是不可變對象
4.一旦修改或者拼接，都會造成重新生成字符串
5.不同的字符串占用不同的空間
6.Python3起字符串就是Unicode類型
二.字符串定義初始化
舉例1
>>> s1 = 'string' >>> s1 'string'
舉例2
>>> s2 = "string" >>> s2 'string'
舉例3
>>> s3 = '''this's a "string" ''' >>> s3 'this\'s a "string" '
舉例4
>>> s4 = 'hello \n xixi.com' >>> s4 'hello \n xixi.com'
舉例5
>>> s5 = r"hello \n xixi.com" >>> s5 'hello \\n xixi.com'
舉例6
>>> s6 = 'C:\windows\nt' >>> s6 'C:\\windows\nt'
舉例7
>>> s7 = R"C:\windows\nt" >>> s7 'C:\\windows\\nt'
舉例8
>>> s8 = 'C:\windows\\nt' >>> s8 'C:\\windows\\nt'
舉例9
>>> sql = """select * from user where name='xixi'""" >>> sql "select * from user where name='xixi'"
三.字符串元素訪問---下標
1.字符串支持使用索引訪問
>>> sql = """select * from user where name='xixi'""" >>> sql "select * from user where name='xixi'" >>> sql[4] 'c'
2.有序的字符集合，字符序列
格式：
for 變量名 in 值:
執行
舉例：
test = "西西是好人" for i in test: print(i) 輸出： 西 西 是 好 人
3.可迭代
舉例：獲取字符列表
s1 = '東西南北' lst = list(s1) print(lst) 返回結果： ['東', '西', '南', '北']
四.字符串連接
1.字符串+連接
將2個字符串連接在一起，返回一個新的字符串
>>> s1 = 'abc' >>> s2= 'def' >>> s1 + s2 'abcdef'
2.字符串join連接：將可迭代對象連接起來，使用string作為分隔符，可迭代對象本身元素都是字符串，返回一個新的字符串
舉例1：
test = "你是風兒我是沙" v1 = "_".join(test) print(v1) 返回： 你_是_風_兒_我_是_沙
舉例2：\轉義引號用引號分割開
test = "你是風兒我是沙" v2 = "\"".join(test) print(v2) 返回： 你"是"風"兒"我"是"沙
舉例3：
test = "你是風兒我是沙" v3 = "\n".join(test) print(v3) 返回： 你 是 風 兒 我 是 沙
五.字符串分割：分割字符串的分類分為兩類
第一類：split()系
1.split()功能：分割為指定個數，從左邊開始分割(弊端分割的字符自己拿不到)
語法：split(sep=None,maxsplit=-1)-> list of strings
sep指定分割字符串，缺省的情況下空白字符串作為分隔符
maketrans指定分割的次數，-1表示遍歷整個字符串
舉例：按照默認空白字符分割
test ="I'm \ta super student." print(test.split()) 返回：["I'm", 'a', 'super', 'student.']
舉例：根據字符串s分割
test ="I'm \ta super student." print(test.split('s')) 返回： ["I'm \ta ", 'uper ', 'tudent.']
舉例：根據字符串super分割
test ="I'm \ta super student." print(test.split('super')) 返回： ["I'm \ta ", ' student.']
舉例：根據空格分割
test ="I'm \ta super student." print(test.split(' ')) 返回： ["I'm", '\ta', 'super', 'student.']
舉例：根據空格分割切兩
test ="I'm \ta super student." print(test.split(' ',2)) 返回： ["I'm", '\ta', 'super student.']
舉例：按照\t分割切兩次
test ="I'm \ta super student." print(test.split('\t',2)) 返回： ["I'm ", 'a super student.']
2.rsplit()功能：分割為指定個數，從右邊開始分割(弊端分割的字符自己拿不到)
語法：rsplit(sep=None,maketrans=-1)->list of strings
sep指定分割字符串，缺省的情況下空白字符串作為分隔符
maketrans指定分割的次數，-1表示遍歷整個字符串
3.splitlines()功能：只根據換行符分割(只能根據，true，false：是否保留換行)
語法：splitlines([keepends])->list of strings
按照行來切分字符串
keepends指的是是否留存分隔符
行分隔符包括\n,\r\n,\r等
舉例:
test = "asdfadfasdf\nasdfasdf\nadfasdf" v = test.splitlines(False) print(v) 輸出： ['asdfadfasdf', 'asdfasdf', 'adfasdf']
第二類：partition系
1.partition()功能：
語法：partition(sep)->(head,sep,tail)
從左至右，遇到分隔符就把字符串分割成兩部分，返回頭，分隔符，尾三部分的三元組；如果沒有找到分隔符，就返回頭，2個空元素的三元組
sep分割字符串，必須指定
舉例1：通過s分割
s1 = "I'm a super student." print(s1.partition('s')) 返回： ("I'm a ", 's', 'uper student.')
舉例：通過stu分割
s2 = "I'm a super student." print(s2.partition('stu')) 返回： ("I'm a super ", 'stu', 'dent.')
舉例：通過abc沒有這個分割
s2 = "I'm a super student." print(s2.partition('abc')) 返回： ("I'm a super student.", '', '')
2.rpartition()功能：
語法：rpartition(sep)->(head,sep,tail)
從右至左，遇到分隔符就把字符串分割成兩部分，返回頭，分隔符，尾三部分的三元組；如果沒有找到分隔符，就返回頭，2個空元素的三元組
sep分割字符串，必須指定
六.字符串大小寫
1.upper()功能：轉換為大寫
s1 = "I'm a super student." print(s1.upper()) 輸出： I'M A SUPER STUDENT.
2.casefold()功能和lower()功能：所有變小寫，casefold()可以很多未知的對相應變小寫，lower()只能把英文轉換小寫
test = "wangXIXI" v1 = test.casefold() print(v1) v2 = test.lower() print(v2) 輸出： wangxixi wangxixi
3.swapcase()大小寫轉換功能：大寫變小寫，小寫變大寫
test = "WanG" v = test.swapcase() print(v) 輸出： aANg
七.字符串的排版
1.title()功能：把普通字符串轉換成標題
舉例：標題的每個單子都大寫
test = "return True if all cased characters in S are uppercase and there is" v1 = test.title() print(v1) 輸出： Return True If All Cased Characters In S Are Uppercase And There Is
2.capitalize()功能：首字母大寫
test = "wang xi xi" v = test.capitalize() print(v) 輸出： Wang xi xi
3.center()功能：設置寬度,並將內容居中(只能填一個字符，不填默認為空格)
語法：center(width[,fillchar])->str
width打印寬度
fillchar填充的字符
舉例：寬度20，填充*
test = "wangXIXI" v = test.center(20,"*") print(v) 輸出： ******wangXIXI******
4.zfill()功能：默認不能指的填充，默認0
語法：zfill(width)->str
width打印寬度，居右，左邊用0填充
test = "wangxixi" v = test.zfill(20) print(v) 輸出： 000000000000wangxixi
5.ljust()功能：內容在左參數右邊填充
test = "wangxixi" v = test.ljust(20,"*") print(v) 返回： wangxixi************
6.rjust()功能：內容在右參數左邊填充
test = "wangxixi" v = test.rjust(20,"*") print(v) 輸出 ************wangxixi
八.字符串修改
1.replace()替換功能：將指定字符串替換為指定字符串
語法：replace(old,new[,count])->
字符串中找到匹配替換為新字符，返回新字符
count表示替換幾次，不指定就是全部替換
舉例：把bbb換所有xixi
test = "wangxishixi" v = test.replace("xi",'bbb') print(v) 輸出： wangbbbshibbb
舉例：把bbb換所有xixi,只替換第一個
test = "wangxishixi" v = test.replace("xi",'bbb',1) print(v) 輸出： wangbbbshixi
2.strip()去掉功能：
語法：strip([chars])->str
從字符串兩端去除指定的字符集chars中的所有字符
如果chars沒有指定，去除兩端的空白字符
舉例：把不可見空白字符都去掉
s = "\r\n\t Hello XiXi \n \t" print(s.strip()) 輸出： Hello XiXi
舉例：去掉r字符y和空格
s = 'I am very very very sorry ' print(s.strip('r y')) 輸出： I am very very very so
3.lstrip()從左邊開始去掉
舉例：將字符串去掉右邊空格
test = " xixi " v = test.lstrip() print(v) 輸出： xixi
4.rstrip()功能：從右邊開始去掉
test = " xixi " v = test.rstrip() print(v) 輸出： xixi
5.expandtabs()功能：斷句，把字符串中的tab符號('\t')轉為空格
test = "username\temail\tpassword\nxixi\txixi@q.com\t123\nshishi\tshishi@q.com\t123\nwangwang\twangwang@q.com\t123" v = test.expandtabs(20) print(v) 輸出：(每行不夠20位數用/t空格補夠20位) username email password xixi xixi@q.com 123 shishi shishi@q.com 123 wangwang wangwang@q.com 123
6.maketrans( )對應關系替換功能：
test = "aeiou" test1 = "12345" v = "asidufkasd;fiuadkf;adfkjalsdjf" m = str.maketrans("aeiou", "12345") new_v = v.translate(m) print(new_v) 創建對應關系str.maketrans("aeiou", "12345")用v.translate(m)做出對應關系的替換字符串v里的所有aeiou替換成12345輸出： 1s3d5fk1sd;f351dkf;1dfkj1lsdjf
九.字符串查找
1.find()功能：
語法：find(sub[,start[,end]])->int
在指定的區間[start,end),從左到右，查找子串sub,找到返回索引，沒找到返回-1
舉例：找到第一個very的索引
s = 'I am very very very sorry' print(s.find('very')) 輸出： 5
2.rfind()功能：
語法：find(sub[,start[,end]])->int
在指定的區間[start,end),從右到左，查找子串sub,找到返回索引，沒找到返回-1
舉例：從-1開始找，
3.index()功能：
語法：index(sub,[,start[,end]])->int
在指定的區間[start,end),從右到左，查找子串sub,找到返回索引，沒找到拋出異常ValueError
4.rindex()功能
語法：index(sub,[,start[,end]])->int
在指定的區間[start,end),從左到右，查找子串sub,找到返回索引，沒找到拋出異常ValueError
5.count()功能尋找：去字符串中尋找，尋找子序列的出現次數
語法：count(sub[,start[,end]])-> int
在指定的區間[start,end),從右到左，統計子串sub出現次數
舉例：從第5個位數開始往后找到第6個位數范圍內尋找
test = "aLexalexr" v = test.count('ex',5,6) print(v) 輸出： 0
6.endswith()功能：以什么什么結尾
語法：endswith(suffix[,start[,end]])->bool
在指定的區間內[start,end),字符串是否是suffix結尾
舉例：查詢是very結尾嗎？
s = "I am very very very sorry" print(s.startswith('very')) 輸出： False
舉例：查詢第五位結尾是不是very
s = "I am very very very sorry" print(s.startswith('very',5)) 輸出： True
舉例：只留5-8位是判斷是否是very結尾
s = "I am very very very sorry" print(s.startswith('very',5,9)) 輸出： True
7.startswith()功能：以什么什么開始
在指定的區間內[start,end),字符串是否是prefix開頭
s = "I am very very very sorry" print(s.endswith('sorry',5,100)) 輸出： True
8.len()：獲取當前字符串中由幾個字符組成
test = "西西是好人" v = len(test) print(v) 輸出： 5
十.字符串判斷
1.isalnum()功能：判斷字符串中是否只包含字母和數字
test = "123" v = test.isalnum() print(v) 輸出： True
2.isalpha()功能：判斷字符串中是否是字母或漢子
test = "as2df" v = test.isalpha() print(v) 輸出： False
3.isdecimal()功能：是否只包含十進制數字
4.isdigit()功能：判斷當前輸入是否是數字，包含特殊特殊符號的字符不支持中文
5.isnumberic()功能：判斷當前輸入是否是數字，支持中文
6.isprintable()功能：判斷是否存在不可顯示的字符 ( \t制表符 \n換行)
test = "oiuas\tdfkj" v = test.isprintable() print(v) 輸出： False
7.isspace()功能：判斷是否全部都是空格
test = "a b" v = test.isspace() print(v) 輸出： False istitle()功能:判斷是否是標題
8.islower()功能：判斷是否全部是小寫
test = "XIxi" v1 = test.islower() print(v1) 輸出： False
9.isupper()功能：判斷是否全部是大寫
test = "Xixi" v1 = test.isupper() print(v1) 輸出： False
10.isidentifier()功能：是否字母和下划線開頭，其他都是字母，數字下划線
11.startswith功能：以xxx開頭：是否以a開頭不是返回False
test = "backend 1.1.1.1" v = test.startswith('a') print(v) 輸出： False
12.endswith功能：以xx結尾功：是否以1為結尾是返回True
test = "backend 1.1.1.1" v = test.endswith('1') print(v) 輸出： True
十一.字符串格式化
1.字符串格式化是一種拼接字符串輸出樣式的手段，更靈活方便
(1)join拼接只能使用分隔符，且要求被拼接的是可迭代對象
(2)+拼接字符串還算方便，但是非字符串需要先轉換為字符串才能拼接
2.在2.5版本之前，只能使用printf style風格的print輸出
(1)printf-style formatting來自C語言的printf函數
(2)格式要求：
<1>占位符：使用%和格式字符組成，例如%s,%d等
s調用str(),r會調用repr()。所有對象都可以被這兩個轉換。
<2>占位符中還可插入修飾字符，例如%03d表示打印3個位置，不夠前面補零
<3>format % values,格式字符串和被格式的值之間使用%分割
<4>values只能是一個對象，伙食一個和格式字符串占位符數目相等的元祖，或字典
3.printf-style formatting舉例
舉例1:傳單個值(3d替換20)
>>> "I am %03d" % (20,) 'I am 020'
舉例2:傳單個值(%s可以接收任何類型值)
>>> 'I like %s.' % 'python' 'I like python.'
舉例3:%3打印3位有效數字，.2小數點兩位
>>>'%3.2f%%,0x%x,0X%02X' %(89.7654,10,15) '89.77%,0xa,0X0F'
舉例4
>>> "I am %-5d" % (20,) 'I am 20 '
舉例5：根據鍵拼接字符串%()s %()d傳字典
>>> tpl = "i am %(name)s age %(age)d" % {"name": "xixi", "age": 18} >>> print(tpl) i am xixi age 18
舉例6：打印浮點數percent %.2f
tpl = "percent %.2f" % 99.976234444444444444 print(tpl) 打印小數點后面倆位(四舍五入)輸出: percent 99.98
舉例7：%%打印百分號
tpl = 'percent %.2f %%' % 99.976234444444444444 print(tpl) 打印小數點后面兩位的百分百輸出： percent 99.98
舉例8：%%打印百分號
tpl = 'percent %.2f %%' % 99.976234444444444444 print(tpl) 打印小數點后面兩位的百分百輸出： percent 99.98 %
舉例9：給字符串加分隔符sep=''
print('root','x','0','0',sep=':') 輸出： root:x:0:0
4.format()函數格式字符串語法---Python鼓勵使用
語法："{} {xxx}".format(*args, **kwargs)->str
花括號表示占位符
{}表示按照順序匹配位置參數，{n}表示取位置參數索引為n的值
{xxx}表示在關鍵字參數中搜索名稱一致的
{{}}表示打印花括號
(1)args是位置參數，是一個元祖
"{}:{}.format('192.168.1.1',8888),這就是按照位置順序用位置參數替換前面的格式字符串的占位符中"
(2)kwargs是關鍵字參數，是一個字典
"{setver}{1}:{0}".format(8888,'192.1681.1.1',server='Web Server Info:'),位置參數按照序號匹配，關鍵字參數按照名次匹配
舉例：根據名字替換：name替換xixi,a替換19
test = 'i am {name}, age {a}' print(test) v = test.format(name='xixi',a=19) print(v) 輸出： i am {name}, age {a} i am xixi, age 19
3.訪問元素
舉例：根據出現的順序替換：第一次出現0替換xixi,第二次出現1替換19
test = 'i am {0}, age {1}' print(test) v = test.format('xixi',19) print(v) 輸出： i am {0}, age {1} i am xixi, age 19
4.對象屬性方法訪問
>>> from collections import namedtuple >>> Point = namedtuple('Point','x y') >>> p1 = Point(5,6) >>> p1.x 5 >>> p1.y 6 >>> "Point = ({{{0.x},{0.y}}})".format(p1) 'Point = ({5,6})'
5.對齊
舉例：右邊對齊
>>> '{0}*{1}={2:>02}'.format(3,2,2*3) '3*2=06'
舉例：居中
>>> '{:^30}'.format('centered') ' centered '
舉例：居中空格用*代替
>>> '{:*^30}'.format('centered') '***********centered***********'
6.進制
>>> "int:{0:d},hex:{0:x}:oct:{0:o}:bin:{0:b}".format(42)
'int:42,hex:2a:oct:52:bin:101010'
列表list
一.列表的特性
(1)一個隊列，一個排列整齊的隊伍
(2)列表內的個體稱作元素，由若干元素組成列表
(3)元素可以是任意對象(數字，字符串，對象，列表等)
(4)列表內元素有順序，可以使用索引
(5)線性的數據結構
(6)使用[ ]表示
(7)列表是可變的
(8)列表list,鏈表,queue(隊列),stack的差異
(9)列表不能一開始就定義大小
二.列表list定義初始化
1.定義list列表初始化
語法：list():新建空列表
方式一：
>>> list()
[]
方式二：
>>> lst = [] >>> lst []
2.list(可迭代對象)：可放可迭代對象初始化的新列表
>>> list(range(5))
[0, 1, 2, 3, 4]
3.定義list列表初始化
>>> list = [1, 12, 9, "age", ["西西", ["19", 10], "大西西"], "shishi", True] >>> list [1, 12, 9, 'age', ['西西', ['19', 10], '大西西'], 'shishi', True]
4.由加創建新列表+ - >list
連接操作，將兩個列表連接起來
產生新的列表，原列表不變
本質上調用的是__add__()方法
>>> list = [11,12,13] >>> list1 = [1,2,3,4,5,6] >>> list + list1 [11, 12, 13, 1, 2, 3, 4, 5, 6]
5.由乘創建新列表* - >list
重復操作將本列表元素重復n次，返回新的列表
舉例：list列表有一個元素1，list列表乘以5，相當於列表元素重復了5次
>>> list = [1] >>> list [1] >>> list = list*5 >>> list [1, 1, 1, 1, 1]
三.列表索引切片訪問
(1)索引，也叫下標
(2)正索引：從左至右，從0開始，為列表中每一個元素編號
(3)負索引：從右至左，從-1開始
(4)正負索引不可以超界，否則引發異常
(5)為了理解方便，可以認為列表是從左至右排列的，左邊是頭部，右邊是尾部，左邊是下界，右邊是上界
(6)列表通過索引訪問list[index],index就是索引，使用中括號訪問
(7)列表元素的取值
1.索引取值：取出列表第三個元素
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "xixi", True] print (li[3]) 輸出： age
2.切片取值：取出列表(大於等於3小於5)的值，切片取值的結果也是一個列表
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "xixi", True] print (li[3:5]) 輸出： ['age', ['西西', ['19', 10], '詩詩']]
四.列表的查詢
1.通過值value,從指定區間查找列表內的元素是否匹配
語法：index(value,[start,[stop]])
匹配第一個就立即返回索引
匹配不到，拋出異常ValueError
舉例：查找7在索引的第幾位
>>> list=[1,5,7,'ab'] >>> list.index(7) 2
舉例：從指定區間第三個位置開始匹配一次，返回3的索引位置是2
>>> list=[1,2,3,4,5,6,7] >>> list.index(3,1) 2
2.返回列表中匹配value的次數
語法：count(value) 舉例：2這個元素出現幾次 >>> list.count(2) 4
3.時間復雜度
index和count方法都是O(n)隨着列表數據規模的增大，而效仿下降
4.內置函數len()：取列表長度
舉例：獲取列表list的長度
>>> list=[1,2,3,4,5,6,7] >>> len(list) 7
五.列表的元素切片的修改
1.索引修改：把列表的第二個元素12換成777
語法：list[index] = value
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "alex", True] li[1] = 777 print (li) 輸出： [1, 777, 9, 'age', ['西西', ['19', 10], '詩詩'], 'alex', True]
2.切片修改：把列表元第1個元素到第2個元素換成777和888
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "alex", True] li[1:3] = [777,888] print (li) 輸出： [1, 777, 888, 'age', ['西西', ['19', 10], '詩詩'], 'alex', True]
六.列表增加，插入元素
1.增加append()功能：原來的值后追加
語法：append(object)->None
列表尾部追加元素，返回None
返回None就意味着沒有新的列表產生，就地修改
時間復雜度是O(1)
li = [11, 22, 33, 22, 44] li.append(5) li.append("alex") li.append([1234,2323]) print(li) 輸出： [11, 22, 33, 22, 44, 5, 'alex', [1234, 2323]]
2.插入insert()功能：在指定索引位置插入元素
語法：insert(index,object)->None
在指定的索引index處插入元素object
返回None就意味着沒有新的列表產生，就地修改時間復雜度是O(1)
索引超越上界，尾部追加，超越下界，頭部追加
li = [11, 22, 33, 22, 44] li.insert(0,99) print(li) 在列表第0個位置插入元素99輸出： [99, 11, 22, 33, 22, 44]
3.extend()擴展原列表，參數：可迭代對象(可以被for循環)把要追加的值循環，把每一個元素做一個for循環擴展到列表的最后邊
語法：extend(iteratable)->None(就地修改)
方法一：把可迭代對象列表擴展到li這個列表后
li = [11, 22, 33, 22, 44] li.extend([9898,"不得了"]) print(li) 輸出： [11, 22, 33, 22, 44, 9898, '不得了']
方法二：把可迭代對象里的元素(字符串)擴展到li這個列表后
li = [11, 22, 33, 22, 44] li.extend("不得了") print(li) 輸出： [11, 22, 33, 22, 44, '不', '得', '了']
七.列表刪除元素
1.索引刪除：的方式把列表的第二個元素12刪除
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "alex", True] del li[1] print (li) 輸出： [1, 9, 'age', ['西西', ['19', 10], '詩詩'], 'alex', True]
2.切片刪除：把列表2-5的元素刪除
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "alex", True] del li[2:6] print (li) 輸出： [1, 12, True]
3.remove()功能：從左至右查找第一個匹配value的值，移除該元素，返回None,就地修改
語法：remove(value)_>None
li = [11, 22, 33, 22, 44] li.remove(22) print(li) 刪除列表指定值第一個22輸出： [11, 33, 22, 44]
4.pop()功能：不指定索引index,就從列表尾部彈出一個元素.指定索引index,就從索引處彈出一個元素，索引超界拋出IndexError錯誤
語法：pop([index])->item
方法一：
li = [11, 22, 33, 22, 44] v = li.pop() print(li) print(v) 刪除列表最后一個值44並把這個刪除的值44打印出來輸出： [11, 22, 33, 22] 44
方法二：
li = [11, 22, 33, 22, 44] v = li.pop(1) print(li) print(v) 指定索引刪除列表第二個值22並把這個刪除的值22打印出來輸出： [11, 33, 22, 44] 22
5.clear()功能：清除列表所有元素，剩下一個空元素(會引起垃圾回收)
語法:clear()->None
li = [11, 22, 33, 22, 44] li.clear() print(li) 輸出： []
八.列表其它操作
1.reverse()功能：將當前列表進行翻轉，就地修改
語法：reverse()->None
li = [11, 22, 33, 22, 44] li.reverse() print(li) 輸出： [44, 22, 33, 22, 11]
2.sort()功能：列表的排序（默認不加參數是從小到大排序）
對列表元素進行排序，就地修改，默認升序
reverse為True,反轉，降序
key一個函數，指定key如何排序
舉例：利用reverse=True參數把列表從大到小排序
li = [11,44, 22, 33, 22] li.sort(reverse=True) print(li) 輸出： [44, 33, 22, 22, 11]
3.利用in操作查找列表里有沒有"age"元素
li = [1, 12, 9, "age", ["西西", ["19", 10], "詩詩"], "alex", True] v = "age" in li print (v) 輸出： True
九.列表復制
1.淺拷貝(shadow copy)：影子拷貝，也叫淺拷貝，遇到引用類型，只是復制了一個引用而已
語法：copy()->List
方式一：
>>> li = [11, 22, 33, 22, 44] >>> li2 = li.copy() >>> li2 [11, 22, 33, 22, 44] 內容一樣： >>> li == li2 True id不一樣： >>> id(li) 139821729157384 >>> id(li2) 139821729158088
2.深拷貝：copy模塊提供了deepcopy(深拷貝)
>>> li = [1,[2,3,4],5] >>> li2 = li.copy() >>> li [1, [2, 3, 4], 5] >>> li2 [1, [2, 3, 4], 5] 改變li2里的[2,3,4]地址也改變了li里的[2,3,4] >>> li2[1][1] = 20 >>> li [1, [2, 20, 4], 5] >>> li2 [1, [2, 20, 4], 5]
十.列表的轉換(數字轉換不成列表)
1.字符串轉換成列表（內部使用的for循環）
li = "adfasdfsdffdf" new_li = list(li) print(new_li) 輸出： ['a', 'd', 'f', 'a', 's', 'd', 'f', 's', 'd', 'f', 'f', 'd', 'f']
2.列表轉換成字符串(倆種方法)
方法一：列表中只有字符串，直接使用字符串的join方法
li = ["123","西西"] v = "".join(li) print(v) 輸出： 123西西
方法二：列表中既有數字又有字符串，需要自己寫一個for循環一個一個處理
li = [11,22,33,"123","西西"] s = "" for i in li: s = s + str(i) print(s) 輸出： 112233123西西
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
元祖tupl
1.元祖的組成
元祖和列表十分類似，可以存儲一系列的元素，元祖的元素不可被修改，元祖不能被增加或者刪除，元祖相當於列表的二次加工
tu叫對象，元祖對應的類叫tuple
2.tuple類中提供的方法共6個
(1)書寫格式
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
#元素不可被修改，不能被增加或者刪除
(2)通過索引取值
tu = (111,"alex",(11,22),[(33,44)],True,33,44,) v = tu[0] print(v)
111
(3)通過切片取值
tu = (111,"alex",(11,22),[(33,44)],True,33,44,) v = tu[0:2] print(v)
(111, 'alex')
(4)可以被for循環(可迭代對象)
tu = (111,"alex",(11,22),[(33,44)],True,33,44,) for item in tu: print(item)
111
alex
(11, 22)
[(33, 44)]
True
33
44
(5)相互轉換
s = "asdfasdf0" v = tuple(s) print(v)
('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')
li = ["asdf","asdfasdf"] v = tuple(li) print(v)
('asdf', 'asdfasdf')
tu = ("asdf","asdf") v = list(tu) print(v)
['asdf', 'asdf']
元祖轉換成字符串：如果元祖里都是字符串的話可以通過join方法直接把元祖轉換成字符串
tu = ("asdf","asdf") v = "_".join(tu) print(v)
asdf_asdf
(6)元組的二極元素增刪改(一級元素不可修改/刪除/增加)
tu = (111,"alex",(11,22),[(33,44)],True,33,44,) v=tu[3] print(v) tu[3][0] = 567 print(tu)
[(33, 44)]
(111, 'alex', (11, 22), [567], True, 33, 44)
3.元祖的倆個基本方法
(1)tu.count()功能：去元祖中尋找，尋找子序列的出現次數
tu = (11,22,33,44,)
v = tu.count(22) print(v)
查找22出現的次數輸出：
1
2.tu.index()功能：根據值獲取當前值索引位置（左邊優先）
tu = (11,22,33,44)
v = tu.index(33) print(v)
查找33出現的索引位置輸出：
2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bytes(字節)
一.bytes定義：不可變字節序列
1.bytes()空bytes
2.bytes(int)指定字節的bytes,被0填充
3.bytes(iterable_of_ints)->bytes[0,255]的int組成的可迭代對象
>>> bytes([1,3,5]) b'\x01\x03\x05'
4.bytes(string,encoding,[,errors])->bytes等介於string.encode()
>>> bytes("abc","utf8") b'abc'
5.bytes(bytes_or_buffer)->immutable copy of bytes_or_buffer從一個字節序列或者buffer復出一個新的不可變的byters對象
6.使用b前綴定義
(1)只允許基本ASCII使用字符形式b
(2)使用16進制表示b"\x41\x61"
二.bytes操作
1.和str類型類似，都是不可變類型，所以方法很多都一樣，只不過bytes的方法是輸入bytes,輸出是bytes
2.類方法bytes.fromhex(string)
(1)string必須是2個字符的16進制的形式，'6162 6a 6b',空格將被忽略
>>> bytes.fromhex('6162 09 6a 6b00') b'ab\tjk\x00'
3.hex()
返回16進制表示的字符串
>>> 'abc'.encode().hex() '616263'
4.索引
b'abcdef'[2]返回該字節對應的數，int類型
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bytearray(字節數組)
一.bytearray定義：可變的字節序列，相當於bytes的可變版本
(1)bytearray()空bytearray
(2)bytearray(int)指定字節的bytearray,被0填充
(3)bytearray(iterable_of_ints)->bytearray[0,255]的int組成的可迭代對象
(4)bytearrays(string,encoding,[,errors])->bytearray等介於string.encode(),不過返回可變對象
(5)bytearray(bytes_or_buffer)->immutable copy of bytes_or_buffer從一個字節序列或者buffer復出一個新的不可變的bytearray對象
二.bytearray操作：
1.append(int)尾部追加一個元素
2.insert(inedx,int)在指定索引位置插入元素
3.extend(iterable_of_ints)將一個可迭代的整數集合追加到當前bytearray
4.pop(index=-1)從指定索引上移除元素，默認從尾部移除
5.remove(value)找到第一個value移除，找不到拋ValueError異常
6.clear()清空bytearray
7.reverse()翻轉bytearray,就地修改
三.字符串與bytes
1.字符串是字符組成的有序序列，字符可以使用編碼來理解
2.bytes是字節組成的有序的不可變序列
3.bytearray是字節組成的有序的可變序列
編碼與解碼
<1>字符串按照不同的字符集編碼encode返回字節序列bytes
encode(encoding = 'utf-8',errors='strict')->bytes
<2>字節序列按照不同的字符集解碼decode返回字符串
bytes.decode(encoding="utf-8",errors="strict")->str
bytearray.decode(encoding="utf-8",errors="strict")->str
線性結構切片
1.可迭代for...in
(1)len()可以獲取長度
(2)通過下標可以訪問
(3)可以切片:學過的線性結構
(4)列表，元祖，字符串，bytes,bytearray
2.切片
(1)通過索引區間訪問線性結構的一段數據
(2)sequence[start:stop]表示返回[start,stop)區間的子序列
(3)支持負索引
(4)start為0，可以省略
(5)stop為末尾，可以省略
(6)超過上界(右邊界)，就取到末尾；超過下界(左邊界)，取到開頭
(7)start一定要在stop的左邊
(8)[:]表示從頭至尾，全部元素被取出，等效於copy()方法
3.切片舉例
舉例：切4-8
>>> 'www.xixi.com'[4:8] 'xixi'
舉例：切0-8
>>> 'www.xixi.com'[:8] 'www.xixi'
舉例：切4往后的
>>> 'www.xixi.com'[4:] 'xixi.com'
舉例：切從頭到尾
>>> 'www.xixi.com'[:] 'www.xixi.com'
舉例：
>>> 'www.xixi.com'[:-1] 'www.xixi.co'
舉例：
>>> 'www.xixi.com'[4:-4] 'xixi'
舉例：
>>> 'www.xixi.com'[4:50] 'xixi.com'
舉例：
>>> b'www.xixi.com'[-40:10] b'www.xixi.c'
舉例：
>>> bytearray(b'www.xixi.com')[-40:4] bytearray(b'www.')
舉例：元祖
>>> tuple('www.xixi.com')[4:8] ('x', 'i', 'x', 'i')
舉例：列表
>>> list('www.xixi.com')[4:8] ['x', 'i', 'x', 'i']
4.步長切片
[start:stop:step]
step為步長，可以正，負整數，默認是1
step要喝start:stop同向，否則返回空序列
舉例：
>>> 'www.wang.com'[4:8:2] 'wn'
第三類：鍵值對(包括集合，字典)
集合(set)
一.集合(set)
(1)可變的，無序的，不重復的元素，不可以索引，可以迭代
(2)無序排列的可hash值
(3)集合中元素必須是不可變類型(不可變類型包括數字，字符串，元祖)
二.set定義初始化
(1)迭代結果放到集合里
>>> s1 = set(range(5)) >>> s1 {0, 1, 2, 3, 4}
(2)把列表里的元素放到集合里
>>> s2 = set(list(range(5))) >>> s2 {0, 1, 2, 3, 4}
(3)把元祖，字符串，數字放到集合里
>>> s4={(1,2),3,'a'}
>>> s4
{(1, 2), 'a', 3}
(4)通過set列表簡化去重方
names=['shi','shi','xixi'] names=list(set(names)) print(names) 輸出： ['shi', 'xixi']
(5)通過frozenset()定義不可變集合[不可變集合就不能刪除或添加]
s=frozenset('hello') print(s) 輸出： frozenset({'h', 'l', 'e', 'o'})
三.set增加
(1)add(elem)：增加一個元素到set中，如果元素存在什么都不做
s = {1,2,3,4,5,6}
s.add('xixi')
s.add('shishi')
print(s)
輸出：
{1, 2, 3, 4, 5, 6, 'xixi', 'shishi'}
(2)update(*others)：合並其他元素到set集合中來，參數others必須是可迭代對象，就地修改
s1={1,2}
s2={1,2,3}
s1.update(s2)
print(s1)
把s2的值更新到s1輸出：
{1, 2, 3}
(3)copy()拷貝方法：
s = {1,2,3,4,5,6}
s1=s.copy()
print(s1)
輸出：
{1, 2, 3, 4, 5, 6}
四.set刪除
(1)remove(elem)：從set中移除元素，元素不存在，拋出KeyError異常。
s = {1,2,3,4,5,6}
s.remove(5)
print(s)
輸出：
{1, 2, 3, 4, 6}
(2)discard(elem)：從set中移除一個元素，元素不存在，什么都不做(刪除元素不存在的情況下不會報錯)
s = {1,2,3,4,5,6}
s.discard(5555)
print(s)
輸出：
{1, 2, 3, 4, 5, 6}
(3)pop()->item：移除並返回任意的元素(無序的隨機刪除一個)。空集返回KeyError異常
>>> s1 = set(range(5)) #s1集合內容 >>> s1 {0, 1, 2, 3, 4} #隨機刪除一個 >>> s1.pop() 0 #當前s1集合內容 >>> s1 {1, 2, 3, 4}
(4)clear()：移除所有元素
s = {1,2,3,4,5,6}
s.clear()
print(s)
輸出：
set()
五.set修改，查詢
(1)修改：要么刪除，要么假如新的元素
(2)查詢：非線性結構，無法索引
(3)遍歷：可迭代所有元素
(4)成員運算符：in和not in判斷元素是否在set中
六.set和線性結構
1.線性結構的查詢時間復雜度是O(n),即隨着數據規模的增大而增加耗時
2.set,dict等結構，內部使用hash值作為key,時間復雜度可以做到O(1),查詢時間和數據規模無關
3.可hash包括：
數值型int,float,complex
布爾值True,False
字符串string,bytes
元祖tuple
None
以上都是不可變類型，成為可哈希類型
4.set的元素必須是可hash的
七.集合數學方面的概念
1.全集：所有元素的集合。例如實數集，所有實數組成的集合就是全集
2.子集subset和超集superset：一個集合A所有元素都在另一個集合B內，A是B的子集，B是A的超集
3.真子集和真超集：A是B的子集，且A不等於B，A就是B的真子集，B是A的真超集
(1)語法：issubset(other),<=
舉例：issubset判斷：集合1是不是集合2的子集，如果是返回True不是返回False
s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1是s2的子集
print(s2.issubset(s1))#False
輸出：
True
False
(2)判斷當前集合是否是other的超集
語法：issuperset(other),>=
舉例：issuperset判斷：集合1是否是集合2的父集是返回True
s1={1,2}
s2={1,2,3}
print(s2.issuperset(s1))#s1是s2的父集
輸出：
True
4.並集：多個集合合並的結果，將兩個集合A和B的所有元素合並到一起，組成的集合稱作集合A與集合B的並集
語法：union(*others)返回和多個集合合並后的新的集合。運算符重載：|等同union
update(*others)和多個子集合並，就地修改，|=等同update
舉例求並集：
python_l=['wang','shi','yao','xixi'] linux_l=['xixi','shi','yueyue'] p_s=set(python_l) l_s=set(linux_l) print(p_s,l_s) print(p_s.union(l_s)) #方式1 print(p_s|l_s) #方式2 輸出： {'xixi', 'shi', 'yao', 'wang'} {'yueyue', 'xixi', 'shi'} {'xixi', 'shi', 'yueyue', 'yao', 'wang'} {'xixi', 'shi', 'yueyue', 'yao', 'wang'}
舉例：調a的方法並b的元素，並好后賦值給a,
>>> a={1,2,3,4}
>>> b={5,6,7,8}
>>> c={9,10,11,12}
>>> c=a.update(b)
>>> a
{1, 2, 3, 4, 5, 6, 7, 8}
>>> b
{8, 5, 6, 7}
>>> c
>>>
5.交集：多個集合的公共部分,集合A和B，由所有屬於A且屬於B的元素組成的集合
語法：intersection(*others)返回和多個集合的交集。&等同於intersection
intersection_update(*others)獲取和多個集合的交集，並就地修改。&=等同於intersection_update
舉例1：intersection()求交集：
python_l=['wang','shi','yao','xixi'] linux_l=['xixi','shi','yueyue'] p_s=set(python_l) l_s=set(linux_l) print(p_s,l_s) print(p_s.intersection(l_s)) #方式1 print(p_s&l_s) #方式2 輸出： {'shi', 'xixi', 'yao', 'wang'} {'yueyue', 'xixi', 'shi'} {'xixi', 'shi'} {'xixi', 'shi'}
舉例2：求a和b的交集
>>> a={1,2,3,4}
>>> b={3,4,5,6}
>>> a.intersection_update(b)
>>> a
{3, 4}
>>> b
{3, 4, 5, 6}
當前集合和另一個集合沒有交集
語法：isdisjoint(other)沒有交集返回True
舉例：判斷集合a和集合b有相交的部分，有返回False
>>> a={1,2,3,4}
>>> b={3,4,5,6}
>>> a.isdisjoint(b)
False
6.差集：集合中除去和其他集合公共部分，集合A和B，由所有屬於A且不屬於B的元素組成的集合
difference(*thers)返回和多個集合的差集。-等同於difference
difference_update(*others)獲取和多個集合的差集並就地修改。-=等同difference_update
舉例：difference()求差集
python_l=['wang','shi','yao','xixi'] linux_l=['xixi','shi','yueyue'] p_s=set(python_l) l_s=set(linux_l) print(p_s,l_s) print('差集',p_s-l_s) #p_s-l_s方式1 print(p_s.difference(l_s)) #p_s-l_s方式2 print('差集',l_s-p_s) #l_s-p_s方式1 print(l_s.difference(p_s)) #l_s-p_s方式2 輸出： {'yao', 'shi', 'xixi', 'wang'} {'yueyue', 'xixi', 'shi'} 差集 {'yao', 'wang'} {'yao', 'wang'} 差集 {'yueyue'} {'yueyue'}
7.對稱差集：集合A和B，由所有不屬於A和B的交集元素組成的集合，記作(A-B) U (B-A)
symmetric_differece(other)返回和另一個集合的差集。^等同於symmetric_differece
symmetric_differece_update(other)。^=等同於symmetric_differece_update
python_l=['wang','shi','yao','xixi'] linux_l=['xixi','shi','yueyue'] p_s=set(python_l) l_s=set(linux_l) print(p_s,l_s) p_s.difference_update(l_s) #相當於：p_s=p_s-l_s print(p_s) 輸出： {'shi', 'wang', 'yao', 'xixi'} {'shi', 'xixi', 'yueyue'} {'wang', 'yao'}
舉例：首先把倆合到一起在減去共同部分
python_l=['wang','shi','yao','xixi'] linux_l=['xixi','shi','yueyue'] p_s=set(python_l) l_s=set(linux_l) print(p_s|l_s) print('交叉補集',p_s.symmetric_difference(l_s)) #方式1 print('交叉補集',p_s^l_s) #方式2 輸出： {'yao', 'xixi', 'wang', 'yueyue', 'shi'} 交叉補集 {'yao', 'wang', 'yueyue'} 交叉補集 {'yao', 'wang', 'yueyue'}
八.集合應用
1.共同好友：
你的好友A，B,C ,他的好友C，B，D，求共同好友
交集問題：
>>> {'A','B','C'}.intersection({'B','C','D'})
{'C', 'B'}
2.微信群提醒
XXX與群里其他人都不是微信好友關系
並集問題：
userid in (A|B|C|...)==False,A,B,C等是微信好友的並集，用戶Id不在這並集中，說明他和任何人都不是朋友
3.權限判斷
1)有一個API，要求權限同時具備A,B,C才能訪問，用戶權限是B，C，D，判斷用戶是否能夠訪問該API
API集合A，權限集合P
A-P={}，A-P為空集，說明P包含A
A.issubset(P)也行，A是P的子集也行
A&P=A也行
2)有一個API，要求權限具備A，B，C任意一項就可以訪問，用戶權限是B，C，D，判斷用戶是否能夠訪問API
API集合A，權限集合P
A&P!={}就可以
A.isdisjoint(P)==False表示有交集
4.一個總任務列表，存儲所有任務，一個完成的任務列表。找出未完成的任務
業務中，任務ID一般不可以重復
所有任務Id放到一個set中，假設為ALL
所有已完成的任務Id放到一個set中，假設為COMPLETED，它是ALL的子集
ALL=COMPLETED=UNCOMPLETED
九.集合練習
2組各10個數字的列表
每個數字取值范圍[10,20]
統計20個數字中，一共有多少個不同的數字
2組中，不重復的數字有幾個？分別是什么
2組中，重復的數字有幾個？分別是什么
>>> a=[1,2,4,5,7,3,8,5,1,3] >>> b=[3,5,6,8,3,1,5,7,9,7] >>> s1=set(a) >>> s2=set(b) >>> print(s1) {1, 2, 3, 4, 5, 7, 8} >>> print(s2) {1, 3, 5, 6, 7, 8, 9} #統計20個數字中，一共有多少個不同的數字 >>> print(s1.union(s2)) {1, 2, 3, 4, 5, 6, 7, 8, 9} #2組中，不重復的數字有幾個？分別是什么 >>> print(s1.symmetric_difference(s2)) {2, 4, 6, 9} #2組中，重復的數字有幾個？分別是什么 >>> print(s1.intersection(s2)) {8, 1, 3, 5, 7}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
字典dict
一.字典dict
1.字典是python中唯一的映射類型（哈希表）
2.字典獨享是可變的,無序的,但是字典的鍵(索引)必須不重復,並且一個字典以使用不同類
二.字典dict定義初始化
(1)d=dict()或d={}
(2)dict(**kwargs)使用name=value對初始化一個字典
info = { "k1": "v1", # 鍵值對(一個鍵K1一個值V1生成了一對) "k2": "v2" }
舉例1：
info = { "k1": 18, "k2": True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } print(info) 四組鍵值對輸出： {'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
舉例2：列表、字典不能作為字典的key, 布爾值(1,0)是可以做key但不能跟別的重復，數字，字符串，元祖可以做字典的key
info ={ 1: 'asdf', "k1": 'asdf', (11,22): 123, } print(info) 數字，字符串，元祖作為key輸出： {1: 'asdf', 'k1': 'asdf', (11, 22): 123}
(3)dict(iterable,*kwarg)使用可迭代對象和name=value對構造字典，不可迭代對象的元素必須是一個二元結構
舉例1：
>>> d=dict(((1,'a'),(2,'b'))) >>> d {1: 'a', 2: 'b'}
舉例2：
>>> d=dict((([1,'a'],[2,'b']))) >>> d {1: 'a', 2: 'b'}
(4)dict(mapping,*kwarg)使用一個字典構造另一個字典
(5)d={'a':10,'b':20,'c':None,'d':[1,2,3]}
>>> d={'a':10,'b':20,'c':None,'d':[1,2,3]}
>>> d
{'c': None, 'a': 10, 'b': 20, 'd': [1, 2, 3]}
(6)類方法dict,fromkeys(iterable,value)
舉例1：
>>> d=dict.fromkeys(range(5)) >>> d {0: None, 1: None, 2: None, 3: None, 4: None}
舉例2：
>>> d=dict.fromkeys(range(5),0) >>> d {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
舉例3
dic = { "k1": 'v1' } v = dict.fromkeys(["k1",123,"999"],123) print(v) 創建字典key是["k1",123,"999"]value是123輸出： {'k1': 123, 123: 123, '999': 123}
三.字典元素的訪問
1.d[key]返回key對應的值value
key不存在拋出KeyError異常
舉例：通過[key]獲取value的值
>>> d2=dict(([(1,3,4),{1,3,5,6,6}],))
>>> d2
{(1, 3, 4): {1, 3, 5, 6}}
>>> d2[(1,3,4)]
{1, 3, 5, 6}
舉例：索引方式找到指定元素
info = { "k1": 18, 2: True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } v = info['k1'] print(v) v = info[2] print(v) v = info['k3'][5]['kk3'][0] print(v) 通過字符串key="k1"輸出: 18 通過數字key=2輸出: True 通過元祖key=['k3']列表=[5]找到['kk3']的[0]輸出: 11
2.get(key[,default])返回key對應的值value
key不存在返回缺省值，如果沒有設置缺省值就返回None
舉例1:通過get[key]獲取value的值
>>> d=dict(([(1,3,4),{1,3,5,6,6}],))
>>> f=d.get((1,3,4))
>>> f
{1, 3, 5, 6}
舉例2：通過get[key]獲取value的值，key不存在返回填入的缺省值50
>>> d=dict(([(1,3,4),{1,3,5,6,6}],))
>>> f=d.get((1),50)
>>> f
50
舉例3：
dic = { "k1": 'v1' } v = dic.get('k1',111111) print(v) 取字典的value值輸出： v1
3.setdefault(key,[,default])返回key對應的值value。key不存在，添加kv對，value為default，並返回default,如果default沒有設置，缺省為None
舉例1：當key已存在，不設置，獲取當前key對應的值:
dic = { "k1": 'v1', "k2": 'v2' } v = dic.setdefault('k1','123') print(dic,v) 存在不設置輸出key對應的值： {'k1': 'v1', 'k2': 'v2'} v1
舉例2：當key不存在，設置，獲取當前key對應的值
dic = { "k1": 'v1', "k2": 'v2' } v = dic.setdefault('k1111','123') print(dic,v) 不存key值設置進去並把新value值拿到輸出： {'k1': 'v1', 'k2': 'v2', 'k1111': '123'} 123
四.字典的增加和修改
(1)d[key]=value將key對應的值修改為value,key不存在添加新的kv對
增加舉例：把100:100增加到字典d里
>>> d {(1, 3, 4): {1, 3, 5, 6}} >>> d[100]=100 >>> d {100: 100, (1, 3, 4): {1, 3, 5, 6}}
修改舉例：把100:50修改字典d里100: 100
>>> d {100: 100, (1, 3, 4): {1, 3, 5, 6}} >>> d[100]=50 >>> d {100: 50, (1, 3, 4): {1, 3, 5, 6}}
(2)update([other])->None使用另一個字典的kv對更新本字典,key不存在，就添加。key存在，覆蓋已經存在的key對應的值就地修改
增加舉例：
dic = { "k1": 'v1', "k2": 'v2' } dic.update({'k1': '111111','k3': 123}) print(dic) 輸出： {'k1': '111111', 'k2': 'v2', 'k3': 123}
修改舉例：
dic.update(k1=123,k3=345,k5="asdf") print(dic) 輸出： {'k1': 123, 'k2': 'v2', 'k3': 345, 'k5': 'asdf'}
五.字典刪除
(1)pop(key[,default])key存在，移除它，並返回它的value,key不存在，返回給定的default。當default未設置，key不存在則拋出keyError異常
舉例：
dic = { "k1": 'v1', "k2": 'v2' } v = dic.pop('k1') print(dic,v) 刪除key="k1"的value值v1並打印出來: {'k2': 'v2'} v1
(2)popitem()移除並返回一個任意的鍵值對,字典為empty,拋出KeyError異常。
舉例：
dic = { "k1": 'v1', "k2": 'v2' } k,v = dic.popitem() print(dic,k,v) 刪除key="k2"的value值v2並打印出刪除的鍵值對並獲取打印： {'k1': 'v1'} k2 v2
(3)clear()清空字典
(4)del語句
舉例：
info = { "k1": 18, 2: True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } del info['k1'] del info['k3'][5]['kk1'] print(info) 根據字符串字符串key="k1"刪除18，根據元祖key=['k3']列表=[5]找到['kk1']刪除vv1輸出： {2: True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
六.字典遍歷
(1)for ...in dict
<1>遍歷key
方式一：
for k in d: print(k)
方式二：
for k in d.keys(): print(k)
舉例：
info = { "k1": 18, 2: True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } for item in info: print(item) 遍歷key輸出： k1 2 k3 k4
<2>遍歷value
方式一：
for k in d: print(d[k])
方式二：
for k in d.keys(): print(d.get(k))
通過info.values for循環values的值輸出：
info = { "k1": 18, 2: True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } for item in info.values(): print(item) 通過info.values for循環values的值輸出： 18 True [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] (11, 22, 33, 44)
(2)for...in dict
遍歷item,即kv對
方式一：
for item in d.items(): print(item)
方式二：
for k,v in d.items(): print(k,v)
舉例：通過items獲取字典出鍵值對
info = { "k1": 18, 2: True, "k3": [ 11, [], (), 22, 33, { 'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11,22), } ], "k4": (11,22,33,44) } for k,v in info.items(): print(k,v) 通過info.items for循環出鍵值對的值輸出： k1 18 2 True k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] k4 (11, 22, 33, 44)
總結：
python3中，keys,values,items方法返回一個類似一個生成器的可迭代對象，不會把函數的返回結果復制到內存中
python2中，上面的方法會返回一個新的列表，占據新的內存空間
七.字典的key
(1)key的要求和set的元素要求一致，hashable可哈希才可以作為key
舉例：
>>> d={1:0,2.0:3,"abc":None,('wang','xi','xixi'):"string",b'abc':'135'}
>>> d
{'abc': None, 1: 0, 2.0: 3, b'abc': '135', ('wang', 'xi', 'xixi'): 'string'}
八.defaultdict
(1)collections.defaultdict([default_factory[,...]])
第一個參數是default_factory,缺省是None,它提供一個初始化函數。當key不存在的時候，會調用這個工廠函數來生成key對應的value
舉例：未用default_factory
d1 = {} for k in "abcde": #迭代順序的結構字符串生成5個key：a,b,c,d,e for v in range(5): #value湊了5個數0，1，2，3，4 if k not in d1.keys(): #判斷k在不在，如果不在 d1[k] = [] #初始化空列表 d1[k].append(v) print(d1) 返回： {'d': [0, 1, 2, 3, 4], 'b': [0, 1, 2, 3, 4], 'e': [0, 1, 2, 3, 4], 'c': [0, 1, 2, 3, 4], 'a': [0, 1, 2, 3, 4]}
舉例：用default_factory
from collections import defaultdict d1 = {} d2 = defaultdict(list) #定義初始化函數，當有key缺值的時候湊上 for k in "abcde": #迭代順序的結構字符串生成5個key：a,b,c,d,e for v in range(3): #value湊了3個數0，1，2 d2[k].append(v) #相當於a進來湊了3個數,b進來湊了3個數 print(d2) 返回： defaultdict(<class 'list'>, {'c': [0, 1, 2], 'd': [0, 1, 2], 'b': [0, 1, 2], 'e': [0, 1, 2], 'a': [0, 1, 2]})
九.OrderedDict
collections.OrderedDict([items])
有序字典可以記錄元素插入的順序，打印的時候也是按照這個順序輸出打印
from collections import OrderedDict import random d = {'banana':3,'apple':4,'pear':1,'orange':2} print('當前字典：',d) keys = list(d.keys()) #把所有的key拿過來 random.shuffle(keys) #把key打亂 print('打亂的key:',keys) od = OrderedDict() #實例化OrderedDict()定義成od for key in keys: # od[key]=d[key] #把加入的順序賦值 print(od) print(od.keys()) 返回：打亂后加入循環的順序不變 當前字典： {'apple': 4, 'orange': 2, 'banana': 3, 'pear': 1} 打亂的key: ['pear', 'orange', 'apple', 'banana'] OrderedDict([('pear', 1), ('orange', 2), ('apple', 4), ('banana', 3)]) odict_keys(['pear', 'orange', 'apple', 'banana'])
~~~~~~~~~~~~~~~~~~