2.python内置数据结构

第一类：数值类型
一.数值型包括
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\[e-mail]\t123\nshishi\[e-mail]\t123\nwangwang\[e-mail]\t123"
v = test.expandtabs(20)
print(v)
输出：(每行不够20位数用/t空格补够20位)
username            email               password
xixi                [e-mail]          123
shishi              [e-mail]        123
wangwang            [e-mail]      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)

0的值输出：
111
(3)通过切片取值

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu[0:2]
print(v)

0-2的值输出：
(111, 'alex')
(4)可以被for循环(可迭代对象)

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
for item in tu:
     print(item)

for循环每一个元素输出：
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)]修改成567输出：
[(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'])

~~~~~~~~~~~~~~~~~~