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()：四舍六入五取偶

1>>> round(2.6)
23

2.floor()地板：向下取整

1>>> import math
2>>> math.floor(2.9)
32

3.ceil()天花板：向上取整

1>>> import math
2>>> math.ceil(2.1)
33

4.int()取整数部分，和//整除一样

1>>> int(1.8)
21

5.min()：取最小值

1>>> min(1,6,9)
21

6.max()：取最大值

1>>> max(1,6,9)
29

7.pow(x,y)：等于x**y平方

1>>> pow(5,2)
225

8.math.sqrt()：返回数字x的平方根

1>>> import math
2>>> math.sqrt(100)
310.0

9.进制函数，返回值是字符串
(1)bin()：二进制整数

1>>> bin(2)
2'0b10'

(2)oct()：八进制整数

1>>> oct(2)
2'0o2'

(3)hex()：十进制整数

1>>> hex(2)
2'0x2'

10.math.pi：π的值

1>>> import math
2>>> math.pi
33.141592653589793

11.math.e自如常数

1>>> import math
2>>> math.e
32.718281828459045

三.类型判断
1.type(obj)，返回类型，而不是字符串
举例：判断1是什么类型

1>>> type(1)
2<class 'int'>

2.isinstance(obj,class_or_tuple)返回值是布尔值
举例：判断6是不是int类型

1>>> isinstance(6,int)
2True

举例：判断6是不是int类型或者str类型的其中一个

1>>> isinstance(6,(int,str))
2True

四.类型转换
1.字符串类型转换数字类型功能：将字符串转换为数字：a="123"是字符串，通过int(a)，把a变成int数字类型，type查看是类型

1a = "123"
2print(type(a), a)
3
4b = int(a)
5print(type(b), b)

输出：
<class 'str'> 123
<class 'int'> 123
2.进制转换功能：通过base=16把num="a"以16进制的方式转换成十进制

1num = "a"
2v = int(num, base=16)
3print(v)

输出：
10
3.bit_lenght功能：当前数字的二进制，至少用n位表示
举例：通过age.bit_length查看age=5是的二进制数字是几位来表示

1age = 5
2r = age.bit_length()
3print(r)

5的二进制数字是101输出：
3

第二类：线性结构(包括字符串-列表-元祖-bytes-bytearray)
字符串类型
一.字符串特性
1.使用引号定义的一组可以包含数字，字母，符号(非特殊系统符号)的集合
2.使用单引号，双引号，三引号引住的字符序列
3.字符串是不可变对象
4.一旦修改或者拼接，都会造成重新生成字符串
5.不同的字符串占用不同的空间
6.Python3起字符串就是Unicode类型
二.字符串定义初始化
举例1

1>>> s1 = 'string'
2>>> s1
3'string'

举例2

1>>> s2 = "string"
2>>> s2
3'string'

举例3

1>>> s3 = '''this's a "string" '''
2>>> s3
3'this\'s a "string" '

举例4

1>>> s4 = 'hello \n xixi.com'
2>>> s4
3'hello \n xixi.com'

举例5

1>>> s5 = r"hello \n xixi.com"
2>>> s5
3'hello \\n xixi.com'

举例6

1>>> s6 = 'C:\windows\nt'
2>>> s6
3'C:\\windows\nt'

举例7

1>>> s7 = R"C:\windows\nt"
2>>> s7
3'C:\\windows\\nt'

举例8

1>>> s8 = 'C:\windows\\nt'
2>>> s8
3'C:\\windows\\nt'

举例9

1>>> sql = """select * from user where name='xixi'"""
2>>> sql
3"select * from user where name='xixi'"

三.字符串元素访问---下标
1.字符串支持使用索引访问

1>>> sql = """select * from user where name='xixi'"""
2>>> sql
3"select * from user where name='xixi'"
4>>> sql[4]
5'c'

2.有序的字符集合，字符序列
格式：
for 变量名 in 值:
执行
举例：

1test = "西西是好人"
2for i in test:
3    print(i)
4输出：
5西
6西
7是
8好
9人

3.可迭代
举例：获取字符列表

1s1 = '东西南北'
2lst = list(s1)
3print(lst)
4返回结果：
5['东', '西', '南', '北']

四.字符串连接
1.字符串+连接
将2个字符串连接在一起，返回一个新的字符串

1>>> s1 = 'abc'
2>>> s2= 'def'
3>>> s1 + s2
4'abcdef'

2.字符串join连接：将可迭代对象连接起来，使用string作为分隔符，可迭代对象本身元素都是字符串，返回一个新的字符串
举例1：

1test = "你是风儿我是沙"
2v1 = "_".join(test)
3print(v1)
4返回：
5你_是_风_儿_我_是_沙

举例2：\转义引号用引号分割开

1test = "你是风儿我是沙"
2v2 = "\"".join(test)
3print(v2)
4返回：
5你"是"风"儿"我"是"沙

举例3：

1test = "你是风儿我是沙"
2v3 = "\n".join(test)
3print(v3)
4返回：
5你
6是
7风
8儿
9我
10是
11沙

五.字符串分割：分割字符串的分类分为两类
第一类：split()系
1.split()功能：分割为指定个数，从左边开始分割(弊端分割的字符自己拿不到)
语法：split(sep=None,maxsplit=-1)-> list of strings
sep指定分割字符串，缺省的情况下空白字符串作为分隔符
maketrans指定分割的次数，-1表示遍历整个字符串
举例：按照默认空白字符分割

1test ="I'm \ta super student."
2print(test.split())
3返回：["I'm", 'a', 'super', 'student.']

举例：根据字符串s分割

1test ="I'm \ta super student."
2print(test.split('s'))
3返回：
4["I'm \ta ", 'uper ', 'tudent.']

举例：根据字符串super分割

1test ="I'm \ta super student."
2print(test.split('super'))
3返回：
4["I'm \ta ", ' student.']

举例：根据空格分割

1test ="I'm \ta super student."
2print(test.split(' '))
3返回：
4["I'm", '\ta', 'super', 'student.']

举例：根据空格分割切两

1test ="I'm \ta super student."
2print(test.split(' ',2))
3返回：
4["I'm", '\ta', 'super student.']

举例：按照\t分割切两次

1test ="I'm \ta super student."
2print(test.split('\t',2))
3返回：
4["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等
举例:

1test = "asdfadfasdf\nasdfasdf\nadfasdf"
2v = test.splitlines(False)
3print(v)
4输出：
5['asdfadfasdf', 'asdfasdf', 'adfasdf']

第二类：partition系
1.partition()功能：
语法：partition(sep)->(head,sep,tail)
从左至右，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾三部分的三元组；如果没有找到分隔符，就返回头，2个空元素的三元组
sep分割字符串，必须指定
举例1：通过s分割

1s1 = "I'm a super student."
2print(s1.partition('s'))
3返回：
4("I'm a ", 's', 'uper student.')

举例：通过stu分割

1s2 = "I'm a super student."
2print(s2.partition('stu'))
3返回：
4("I'm a super ", 'stu', 'dent.')

举例：通过abc没有这个分割

1s2 = "I'm a super student."
2print(s2.partition('abc'))
3返回：
4("I'm a super student.", '', '')

2.rpartition()功能：
语法：rpartition(sep)->(head,sep,tail)
从右至左，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾三部分的三元组；如果没有找到分隔符，就返回头，2个空元素的三元组
sep分割字符串，必须指定
六.字符串大小写
1.upper()功能：转换为大写

1s1 = "I'm a super student."
2print(s1.upper())
3输出：
4I'M A SUPER STUDENT.

2.casefold()功能和lower()功能：所有变小写，casefold()可以很多未知的对相应变小写，lower()只能把英文转换小写

1test = "wangXIXI"
2v1 = test.casefold()
3print(v1)
4v2 = test.lower()
5print(v2)
6输出：
7wangxixi
8wangxixi

3.swapcase()大小写转换功能：大写变小写，小写变大写

1test = "WanG"
2v = test.swapcase()
3print(v)
4输出：
5aANg

七.字符串的排版
1.title()功能：把普通字符串转换成标题
举例：标题的每个单子都大写

1test = "return True if all cased characters in S are uppercase and there is"
2v1 = test.title()
3print(v1)
4输出：
5Return True If All Cased Characters In S Are Uppercase And There Is

2.capitalize()功能：首字母大写

1test = "wang xi xi"
2v = test.capitalize()
3print(v)
4输出：
5Wang xi xi

3.center()功能：设置宽度,并将内容居中(只能填一个字符，不填默认为空格)
语法：center(width[,fillchar])->str
width打印宽度
fillchar填充的字符
举例：宽度20，填充*

1test = "wangXIXI"
2v = test.center(20,"*")
3print(v)
4输出：
5******wangXIXI******

4.zfill()功能：默认不能指的填充，默认0
语法：zfill(width)->str
width打印宽度，居右，左边用0填充

1test = "wangxixi"
2v = test.zfill(20)
3print(v)
4输出：
5000000000000wangxixi

5.ljust()功能：内容在左参数右边填充

1test = "wangxixi"
2v = test.ljust(20,"*")
3print(v)
4返回：
5wangxixi************

6.rjust()功能：内容在右参数左边填充

1test = "wangxixi"
2v = test.rjust(20,"*")
3print(v)
4输出
5************wangxixi

八.字符串修改
1.replace()替换功能：将指定字符串替换为指定字符串
语法：replace(old,new[,count])->
字符串中找到匹配替换为新字符，返回新字符
count表示替换几次，不指定就是全部替换
举例：把bbb换所有xixi

1test = "wangxishixi"
2v = test.replace("xi",'bbb')
3print(v)
4输出：
5wangbbbshibbb

举例：把bbb换所有xixi,只替换第一个

1test = "wangxishixi"
2v = test.replace("xi",'bbb',1)
3print(v)
4输出：
5wangbbbshixi

2.strip()去掉功能：
语法：strip([chars])->str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去除两端的空白字符
举例：把不可见空白字符都去掉

1s = "\r\n\t Hello XiXi \n \t"
2print(s.strip())
3输出：
4Hello XiXi

举例：去掉r字符y和空格

1s = 'I am very very very sorry   '
2print(s.strip('r y'))
3输出：
4I am very very very so

3.lstrip()从左边开始去掉
举例：将字符串去掉右边空格

1test = "   xixi   "
2v = test.lstrip()
3print(v)
4输出：
5xixi  

4.rstrip()功能：从右边开始去掉

1test = "   xixi   "
2v = test.rstrip()
3print(v)
4输出：
5    xixi

5.expandtabs()功能：断句，把字符串中的tab符号('\t')转为空格

1test = "username\temail\tpassword\nxixi\txixi@q.com\t123\nshishi\tshishi@q.com\t123\nwangwang\twangwang@q.com\t123"
2v = test.expandtabs(20)
3print(v)
4输出：(每行不够20位数用/t空格补够20位)
5username            email               password
6xixi                xixi@q.com          123
7shishi              shishi@q.com        123
8wangwang            wangwang@q.com      123

6.maketrans( )对应关系替换功能：

1test =  "aeiou"
2test1 = "12345"
3v = "asidufkasd;fiuadkf;adfkjalsdjf"
4m = str.maketrans("aeiou", "12345")
5new_v = v.translate(m)
6print(new_v)
7创建对应关系str.maketrans("aeiou", "12345")用v.translate(m)做出对应关系的替换字符串v里的所有aeiou替换成12345输出：
81s3d5fk1sd;f351dkf;1dfkj1lsdjf

九.字符串查找
1.find()功能：
语法：find(sub[,start[,end]])->int
在指定的区间[start,end),从左到右，查找子串sub,找到返回索引，没找到返回-1
举例：找到第一个very的索引

1s = 'I am very very very sorry'
2print(s.find('very'))
3输出：
45

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个位数范围内寻找

1test = "aLexalexr"
2v = test.count('ex',5,6)
3print(v)
4输出：
50

6.endswith()功能：以什么什么结尾
语法：endswith(suffix[,start[,end]])->bool
在指定的区间内[start,end),字符串是否是suffix结尾
举例：查询是very结尾吗？

1s = "I am very very very sorry"
2print(s.startswith('very'))
3输出：
4False

举例：查询第五位结尾是不是very

1s = "I am very very very sorry"
2print(s.startswith('very',5))
3输出：
4True

举例：只留5-8位是判断是否是very结尾

1s = "I am very very very sorry"
2print(s.startswith('very',5,9))
3输出：
4True

7.startswith()功能：以什么什么开始
在指定的区间内[start,end),字符串是否是prefix开头

1s = "I am very very very sorry"
2print(s.endswith('sorry',5,100))
3输出：
4True

8.len()：获取当前字符串中由几个字符组成

1test = "西西是好人"
2v = len(test)
3print(v)
4输出：
55

十.字符串判断
1.isalnum()功能：判断字符串中是否只包含字母和数字

1test = "123"
2v = test.isalnum()
3print(v)
4输出：
5True

2.isalpha()功能：判断字符串中是否是字母或汉子

1test = "as2df"
2v = test.isalpha()
3print(v)
4输出：
5False

3.isdecimal()功能：是否只包含十进制数字
4.isdigit()功能：判断当前输入是否是数字，包含特殊特殊符号的字符不支持中文
5.isnumberic()功能：判断当前输入是否是数字，支持中文
6.isprintable()功能：判断是否存在不可显示的字符 ( \t制表符  \n换行)

1test = "oiuas\tdfkj"
2v = test.isprintable()
3print(v)
4输出：
5False

7.isspace()功能：判断是否全部都是空格

1test = "a b"
2v = test.isspace()
3print(v)
4输出：
5False
6istitle()功能:判断是否是标题

8.islower()功能：判断是否全部是小写

1test = "XIxi"
2v1 = test.islower()
3print(v1)
4输出：
5False

9.isupper()功能：判断是否全部是大写

1test = "Xixi"
2v1 = test.isupper()
3print(v1)
4输出：
5False 

10.isidentifier()功能：是否字母和下划线开头，其他都是字母，数字下划线
11.startswith功能：以xxx开头：是否以a开头不是返回False

1test = "backend 1.1.1.1"
2v = test.startswith('a')
3print(v)
4输出：
5False

12.endswith功能：以xx结尾功：是否以1为结尾是返回True

1test = "backend 1.1.1.1"
2v = test.endswith('1')
3print(v)
4输出：
5True

十一.字符串格式化
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)

1>>> "I am %03d" % (20,)
2'I am 020'

举例2:传单个值(%s可以接收任何类型值)

1>>> 'I like %s.' % 'python'
2'I like python.'

举例3:%3打印3位有效数字，.2小数点两位

1>>>'%3.2f%%,0x%x,0X%02X' %(89.7654,10,15)
2'89.77%,0xa,0X0F'

举例4

1>>> "I am %-5d" % (20,)
2'I am 20   '

举例5：根据键拼接字符串%()s %()d传字典

1>>> tpl = "i am %(name)s age %(age)d" % {"name": "xixi", "age": 18}
2>>> print(tpl)
3i am xixi age 18

举例6：打印浮点数percent %.2f

1tpl = "percent %.2f" % 99.976234444444444444
2print(tpl)
3打印小数点后面俩位(四舍五入)输出:
4percent 99.98

举例7：%%打印百分号

1tpl = 'percent %.2f %%' % 99.976234444444444444
2print(tpl)
3打印小数点后面两位的百分百输出：
4percent 99.98

举例8：%%打印百分号

1tpl = 'percent %.2f %%' % 99.976234444444444444
2print(tpl)
3打印小数点后面两位的百分百输出：
4percent 99.98 %

举例9：给字符串加分隔符sep=''

1print('root','x','0','0',sep=':')
2输出：
3root: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

1test = 'i am {name}, age {a}'
2print(test)
3v = test.format(name='xixi',a=19)
4print(v)
5输出：
6i am {name}, age {a}
7i am xixi, age 19

3.访问元素
举例：根据出现的顺序替换：第一次出现0替换xixi,第二次出现1替换19

1test = 'i am {0}, age {1}'
2print(test)
3v = test.format('xixi',19)
4print(v)
5输出：
6i am {0}, age {1}
7i am xixi, age 19

4.对象属性方法访问

1>>> from collections import namedtuple
2>>> Point = namedtuple('Point','x y')
3>>> p1 = Point(5,6)
4>>> p1.x
55
6>>> p1.y
76
8>>> "Point = ({{{0.x},{0.y}}})".format(p1)
9'Point = ({5,6})'

5.对齐
举例：右边对齐

1>>> '{0}*{1}={2:>02}'.format(3,2,2*3)
2'3*2=06'

举例：居中

1>>> '{:^30}'.format('centered')
2'           centered           '

举例：居中空格用*代替

1>>> '{:*^30}'.format('centered')
2'***********centered***********'

6.进制

1>>> "int:{0:d},hex:{0:x}:oct:{0:o}:bin:{0:b}".format(42)
2'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():新建空列表
方式一：

1>>> list()
2[]

方式二：

1>>> lst = []
2>>> lst
3[]

2.list(可迭代对象)：可放可迭代对象初始化的新列表

1>>> list(range(5))
2[0, 1, 2, 3, 4]

3.定义list列表初始化

1>>> list = [1, 12, 9, "age", ["西西", ["19", 10], "大西西"], "shishi", True]
2>>> list
3[1, 12, 9, 'age', ['西西', ['19', 10], '大西西'], 'shishi', True]

4.由加创建新列表+ - >list
连接操作，将两个列表连接起来
产生新的列表，原列表不变
本质上调用的是__add__()方法

1>>> list = [11,12,13]
2>>> list1 = [1,2,3,4,5,6]
3>>> list + list1
4[11, 12, 13, 1, 2, 3, 4, 5, 6]

5.由乘创建新列表* - >list
重复操作将本列表元素重复n次，返回新的列表
举例：list列表有一个元素1，list列表乘以5，相当于列表元素重复了5次

1>>> list = [1]
2>>> list
3[1]
4>>> list = list*5
5>>> list
6[1, 1, 1, 1, 1]

三.列表索引切片访问
(1)索引，也叫下标
(2)正索引：从左至右，从0开始，为列表中每一个元素编号
(3)负索引：从右至左，从-1开始
(4)正负索引不可以超界，否则引发异常
(5)为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
(6)列表通过索引访问list[index],index就是索引，使用中括号访问
(7)列表元素的取值
1.索引取值：取出列表第三个元素

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "xixi", True]
2print (li[3])
3输出：
4age

2.切片取值：取出列表(大于等于3小于5)的值，切片取值的结果也是一个列表

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "xixi", True]
2print (li[3:5])
3输出：
4['age', ['西西', ['19', 10], '诗诗']]

四.列表的查询
1.通过值value,从指定区间查找列表内的元素是否匹配
语法：index(value,[start,[stop]])
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
举例：查找7在索引的第几位

1>>> list=[1,5,7,'ab']
2>>> list.index(7)
32

举例：从指定区间第三个位置开始匹配一次，返回3的索引位置是2

1>>> list=[1,2,3,4,5,6,7]
2>>> list.index(3,1)
32

2.返回列表中匹配value的次数

1语法：count(value)
2举例：2这个元素出现几次
3>>> list.count(2)
44

3.时间复杂度
index和count方法都是O(n)随着列表数据规模的增大，而效仿下降
4.内置函数len()：取列表长度
举例：获取列表list的长度

1>>> list=[1,2,3,4,5,6,7]
2>>> len(list)
37

五.列表的元素切片的修改
1.索引修改：把列表的第二个元素12换成777
语法：list[index] = value

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "alex", True]
2li[1] = 777
3print (li)
4输出：
5[1, 777, 9, 'age', ['西西', ['19', 10], '诗诗'], 'alex', True]

2.切片修改：把列表元第1个元素到第2个元素换成777和888

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "alex", True]
2li[1:3] = [777,888]
3print (li)
4输出：
5[1, 777, 888, 'age', ['西西', ['19', 10], '诗诗'], 'alex', True]

六.列表增加，插入元素
1.增加append()功能：原来的值后追加
语法：append(object)->None
列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(1)

1li = [11, 22, 33, 22, 44]
2li.append(5)
3li.append("alex")
4li.append([1234,2323])
5print(li)
6输出：
7[11, 22, 33, 22, 44, 5, 'alex', [1234, 2323]]

2.插入insert()功能：在指定索引位置插入元素
语法：insert(index,object)->None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改时间复杂度是O(1)
索引超越上界，尾部追加，超越下界，头部追加

1li = [11, 22, 33, 22, 44]
2li.insert(0,99)
3print(li)
4在列表第0个位置插入元素99输出：
5[99, 11, 22, 33, 22, 44]

3.extend()扩展原列表，参数：可迭代对象(可以被for循环)把要追加的值循环，把每一个元素做一个for循环扩展到列表的最后边
语法：extend(iteratable)->None(就地修改)
方法一：把可迭代对象列表扩展到li这个列表后

1li = [11, 22, 33, 22, 44]
2li.extend([9898,"不得了"])
3print(li)
4输出：
5[11, 22, 33, 22, 44, 9898, '不得了']

方法二：把可迭代对象里的元素(字符串)扩展到li这个列表后

1li = [11, 22, 33, 22, 44]
2li.extend("不得了")
3print(li)
4输出：
5[11, 22, 33, 22, 44, '不', '得', '了']

七.列表删除元素
1.索引删除：的方式把列表的第二个元素12删除

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "alex", True]
2del li[1]
3print (li)
4输出：
5[1, 9, 'age', ['西西', ['19', 10], '诗诗'], 'alex', True]

2.切片删除：把列表2-5的元素删除

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "alex", True]
2del li[2:6]
3print (li)
4输出：
5[1, 12, True]

**3.remove()功能：**从左至右查找第一个匹配value的值，移除该元素，返回None,就地修改
语法：remove(value)_>None

1li = [11, 22, 33, 22, 44]
2li.remove(22)
3print(li)
4删除列表指定值第一个22输出：
5[11, 33, 22, 44]

**4.pop()功能：**不指定索引index,就从列表尾部弹出一个元素.指定索引index,就从索引处弹出一个元素，索引超界抛出IndexError错误
语法：pop([index])->item
方法一：

1li = [11, 22, 33, 22, 44]
2v = li.pop()
3print(li)
4print(v)
5删除列表最后一个值44并把这个删除的值44打印出来输出：
6[11, 22, 33, 22]
744

方法二：

1li = [11, 22, 33, 22, 44]
2v = li.pop(1)
3print(li)
4print(v)
5指定索引删除列表第二个值22并把这个删除的值22打印出来输出：
6[11, 33, 22, 44]
722

**5.clear()功能：**清除列表所有元素，剩下一个空元素(会引起垃圾回收)
语法:clear()->None

1li = [11, 22, 33, 22, 44]
2li.clear()
3print(li)
4输出：
5[]

八.列表其它操作
1.reverse()功能：将当前列表进行翻转，就地修改
语法：reverse()->None

1li = [11, 22, 33, 22, 44]
2li.reverse()
3print(li)
4输出：
5[44, 22, 33, 22, 11]

2.sort()功能：列表的排序（默认不加参数是从小到大排序）
对列表元素进行排序，就地修改，默认升序
reverse为True,反转，降序
key一个函数，指定key如何排序
举例：利用reverse=True参数把列表从大到小排序

1li = [11,44, 22, 33, 22]
2li.sort(reverse=True)
3print(li)
4输出：
5[44, 33, 22, 22, 11]

3.利用in操作查找列表里有没有"age"元素

1li = [1, 12, 9, "age", ["西西", ["19", 10], "诗诗"], "alex", True]
2v = "age" in li
3print (v)
4输出：
5True

九.列表复制
1.浅拷贝(shadow copy)：影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已
语法：copy()->List
方式一：

1>>> li = [11, 22, 33, 22, 44]
2>>> li2 = li.copy()
3>>> li2
4[11, 22, 33, 22, 44]
5内容一样：
6>>> li == li2
7True
8id不一样：
9>>> id(li)
10139821729157384
11>>> id(li2)
12139821729158088

2.深拷贝：copy模块提供了deepcopy(深拷贝)

1>>> li = [1,[2,3,4],5]
2>>> li2 = li.copy()
3>>> li
4[1, [2, 3, 4], 5]
5>>> li2
6[1, [2, 3, 4], 5]
7改变li2里的[2,3,4]地址也改变了li里的[2,3,4]
8>>> li2[1][1] = 20
9>>> li
10[1, [2, 20, 4], 5]
11>>> li2
12[1, [2, 20, 4], 5]

十.列表的转换(数字转换不成列表)
1.字符串转换成列表（内部使用的for循环）

1li = "adfasdfsdffdf"
2new_li = list(li)
3print(new_li)
4输出：
5['a', 'd', 'f', 'a', 's', 'd', 'f', 's', 'd', 'f', 'f', 'd', 'f']

2.列表转换成字符串(俩种方法)
方法一：列表中只有字符串，直接使用字符串的join方法

1li = ["123","西西"]
2v = "".join(li)
3print(v)
4输出：
5123西西

方法二：列表中既有数字又有字符串，需要自己写一个for循环一个一个处理

1li = [11,22,33,"123","西西"]
2s = ""
3for i in li:
4    s = s + str(i)
5print(s)
6输出：
7112233123西西

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

元祖tupl
1.元祖的组成
元祖和列表十分类似，可以存储一系列的元素，元祖的元素不可被修改，元祖不能被增加或者删除，元祖相当于列表的二次加工
tu叫对象，元祖对应的类叫tuple
2.tuple类中提供的方法共6个
(1)书写格式

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)

#一般写元组的时候，推荐在最后加逗号
#元素不可被修改，不能被增加或者删除
(2)通过索引取值

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

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

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

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

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

for循环每一个元素输出：
111
alex
(11, 22)
[(33, 44)]
True
33
44
(5)相互转换

字符串转换成元祖：

1s = "asdfasdf0"
2v = tuple(s)
3print(v)

输出：
('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')

列表转换成元祖：

1li = ["asdf","asdfasdf"]
2v = tuple(li)
3print(v)

输出：
('asdf', 'asdfasdf')

元祖转换成列表：

1tu = ("asdf","asdf")
2v = list(tu)
3print(v)

输出：
['asdf', 'asdf']
元祖转换成字符串：如果元祖里都是字符串的话可以通过join方法直接把元祖转换成字符串

1tu = ("asdf","asdf")
2
3v = "_".join(tu)
4print(v)

元祖转换字符串以_连接输出：
asdf_asdf
(6)元组的二极元素增删改(一级元素不可修改/删除/增加)

1tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
2v=tu[3]
3print(v)
4tu[3][0] = 567
5print(tu)

把元祖里的元素[(33, 44)]修改成567输出：
[(33, 44)]
(111, 'alex', (11, 22), [567], True, 33, 44)
3.元祖的俩个基本方法
(1)tu.count()功能：去元祖中寻找，寻找子序列的出现次数

1tu = (11,22,33,44,)
2v = tu.count(22)
3print(v)

查找22出现的次数输出：
1
2.tu.index()功能：根据值获取当前值索引位置（左边优先）

1tu = (11,22,33,44)
2v = tu.index(33)
3print(v)

查找33出现的索引位置输出：
2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bytes(字节)
一.bytes定义：不可变字节序列
1.bytes()空bytes
2.bytes(int)指定字节的bytes,被0填充
3.bytes(iterable_of_ints)->bytes[0,255]的int组成的可迭代对象

1>>> bytes([1,3,5])
2b'\x01\x03\x05'

4.bytes(string,encoding,[,errors])->bytes等介于string.encode()

1>>> bytes("abc","utf8")
2b'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',空格将被忽略

1>>> bytes.fromhex('6162 09 6a 6b00')
2b'ab\tjk\x00'

3.hex()
返回16进制表示的字符串

1>>> 'abc'.encode().hex()
2'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

1>>> 'www.xixi.com'[4:8]
2'xixi'

举例：切0-8

1>>> 'www.xixi.com'[:8]
2'www.xixi'

举例：切4往后的

1>>> 'www.xixi.com'[4:]
2'xixi.com'

举例：切从头到尾

1>>> 'www.xixi.com'[:]
2'www.xixi.com'

举例：

1>>> 'www.xixi.com'[:-1]
2'www.xixi.co'

举例：

1>>> 'www.xixi.com'[4:-4]
2'xixi'

举例：

1>>> 'www.xixi.com'[4:50]
2'xixi.com'

举例：

1>>> b'www.xixi.com'[-40:10]
2b'www.xixi.c'

举例：

1>>> bytearray(b'www.xixi.com')[-40:4]
2bytearray(b'www.')

举例：元祖

1>>> tuple('www.xixi.com')[4:8]
2('x', 'i', 'x', 'i')

举例：列表

1>>> list('www.xixi.com')[4:8]
2['x', 'i', 'x', 'i']

4.步长切片
[start:stop:step]
step为步长，可以正，负整数，默认是1
step要喝start:stop同向，否则返回空序列
举例：

1>>> 'www.wang.com'[4:8:2]
2'wn'

第三类：键值对(包括集合，字典)
集合(set)
一.集合(set)
(1)可变的，无序的，不重复的元素，不可以索引，可以迭代
(2)无序排列的可hash值
(3)集合中元素必须是不可变类型(不可变类型包括数字，字符串，元祖)
二.set定义初始化
(1)迭代结果放到集合里

1>>> s1 = set(range(5))
2>>> s1
3{0, 1, 2, 3, 4}

(2)把列表里的元素放到集合里

1>>> s2 = set(list(range(5)))
2>>> s2
3{0, 1, 2, 3, 4}

(3)把元祖，字符串，数字放到集合里

1>>> s4={(1,2),3,'a'}
2>>> s4
3{(1, 2), 'a', 3}

(4)通过set列表简化去重方

1names=['shi','shi','xixi']
2names=list(set(names))
3print(names)
4输出：
5['shi', 'xixi']

(5)通过frozenset()定义不可变集合[不可变集合就不能删除或添加]

1s=frozenset('hello')
2print(s)
3输出：
4frozenset({'h', 'l', 'e', 'o'})

三.set增加
(1)add(elem)：增加一个元素到set中，如果元素存在什么都不做

1s = {1,2,3,4,5,6}
2s.add('xixi')
3s.add('shishi')
4print(s)
5输出：
6{1, 2, 3, 4, 5, 6, 'xixi', 'shishi'}

(2)update(*others)：合并其他元素到set集合中来，参数others必须是可迭代对象，就地修改

1s1={1,2}
2s2={1,2,3}
3s1.update(s2)
4print(s1)
5把s2的值更新到s1输出：
6{1, 2, 3}

(3)copy()拷贝方法：

1s = {1,2,3,4,5,6}
2s1=s.copy()
3print(s1)
4输出：
5{1, 2, 3, 4, 5, 6}

四.set删除
(1)remove(elem)：从set中移除元素，元素不存在，抛出KeyError异常。

1s = {1,2,3,4,5,6}
2s.remove(5)
3print(s)
4输出：
5{1, 2, 3, 4, 6}

(2)discard(elem)：从set中移除一个元素，元素不存在，什么都不做(删除元素不存在的情况下不会报错)

1s = {1,2,3,4,5,6}
2s.discard(5555)
3print(s)
4输出：
5{1, 2, 3, 4, 5, 6}

(3)pop()->item：移除并返回任意的元素(无序的随机删除一个)。空集返回KeyError异常

1>>> s1 = set(range(5))
2#s1集合内容
3>>> s1
4{0, 1, 2, 3, 4}
5#随机删除一个
6>>> s1.pop()
70
8#当前s1集合内容
9>>> s1
10{1, 2, 3, 4}

(4)clear()：移除所有元素

1s = {1,2,3,4,5,6}
2s.clear()
3print(s)
4输出：
5set()

五.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

1s1={1,2}
2s2={1,2,3}
3print(s1.issubset(s2))#s1是s2的子集
4print(s2.issubset(s1))#False
5输出：
6True
7False

(2)判断当前集合是否是other的超集
语法：issuperset(other),>=
举例：issuperset判断：集合1是否是集合2的父集是返回True

1s1={1,2}
2s2={1,2,3}
3print(s2.issuperset(s1))#s1是s2的父集
4输出：
5True

4.并集：多个集合合并的结果，将两个集合A和B的所有元素合并到一起，组成的集合称作集合A与集合B的并集
语法：union(*others)返回和多个集合合并后的新的集合。运算符重载：|等同union
update(*others)和多个子集合并，就地修改，|=等同update
举例求并集：

1python_l=['wang','shi','yao','xixi']
2linux_l=['xixi','shi','yueyue']
3p_s=set(python_l)
4l_s=set(linux_l)
5print(p_s,l_s)
6print(p_s.union(l_s))     #方式1
7print(p_s|l_s)            #方式2
8输出：
9{'xixi', 'shi', 'yao', 'wang'} {'yueyue', 'xixi', 'shi'}
10{'xixi', 'shi', 'yueyue', 'yao', 'wang'}
11{'xixi', 'shi', 'yueyue', 'yao', 'wang'}

举例：调a的方法并b的元素，并好后赋值给a,

1>>> a={1,2,3,4}
2>>> b={5,6,7,8}
3>>> c={9,10,11,12}
4>>> c=a.update(b)
5>>> a
6{1, 2, 3, 4, 5, 6, 7, 8}
7>>> b
8{8, 5, 6, 7}
9>>> c
10>>>

5.交集：多个集合的公共部分,集合A和B，由所有属于A且属于B的元素组成的集合
语法：intersection(*others)返回和多个集合的交集。&等同于intersection
intersection_update(*others)获取和多个集合的交集，并就地修改。&=等同于intersection_update
举例1：intersection()求交集：

1python_l=['wang','shi','yao','xixi']
2linux_l=['xixi','shi','yueyue']
3p_s=set(python_l)
4l_s=set(linux_l)
5print(p_s,l_s)
6print(p_s.intersection(l_s))   #方式1
7print(p_s&l_s)                 #方式2
8输出：
9{'shi', 'xixi', 'yao', 'wang'} {'yueyue', 'xixi', 'shi'}
10{'xixi', 'shi'}
11{'xixi', 'shi'}

举例2：求a和b的交集

1>>> a={1,2,3,4}
2>>> b={3,4,5,6}
3>>> a.intersection_update(b)
4>>> a
5{3, 4}
6>>> b
7{3, 4, 5, 6}

当前集合和另一个集合没有交集
语法：isdisjoint(other)没有交集返回True
举例：判断集合a和集合b有相交的部分，有返回False

1>>> a={1,2,3,4}
2>>> b={3,4,5,6}
3>>> a.isdisjoint(b)
4False