1.列表:是一个序列，用于顺序的存储数据 

lis=list()           #使用list函数定义列表
lis=[]               #使用中括号定义列表
lis=[1,2,3]          #使用中括号定义并初始化列表
lis=list(range(1,10))#使用list函数把可迭代对象转化成列表

   1.1.访问列表元素lis=list(range(10))

lis[0]     #通过下标访问，下标从0开始
lis[10]    #当下标超出范围是，会抛出indexerrror
lis[-1]    #负数索引从右边开始，并且索引从-1开始
lis[-11]   #无论正数负数都是有范围的
help(lis)  #查看更多操作

index方法          #0(n)线性复杂度，效率与规模线性相关
lis.index(4)       #给出值查找索引
lis=[1,2,3,2,4,5]
lis.index(2)       #返回找到的第一个索引
lis.index(2,2)     #start 指定从哪个索引开始查找
lis.index(2,2,3)   #end参数指定哪个索引结束，并且不包哪个索引，当值不在范围是会抛出indexvalue
lis.index(2,-4,-1) #star和stop可以为负数，但是从左往右查找

count方法          #返回值在列表里面出现的次数，0(n)线性复杂度，效率与数据规模线性相关

修改方法            #修改列表有且只有一种方法对下标赋值，对超出范围的索引修改元素，抛出indexerror
lis[2]=5

增加元素append insert extend
lis.append(9)       #append原地修改list，返回none，增加在end，操作单个元素
lis.insert(1,11)    #insert原地修改list，返回none
lis.extend(range(3))#extend原地修改list，返回none，可操作可迭代对象
lis+['a','b']       #不修改list本身，返回一个新的list，list的链接操作，开辟新的内存

insert当索引超出范围时
                    1.索引时负数时，会在第0个元素插入
                    2.索引时正数时，会在最后一个元素插入
insert，append效率
                    1.append时间复杂度0（1）常数时间效率和数据无关
                    2.insert的时间复杂度是0（n）线性时间，效率和数据规模线性相关

删除操作clear pop remove
lis=[1,2,3,2,4,3,5,3,4]
lis.remove(1)       #remove原地修改list,根据给定值删除元素
lis.remove(2)       #remove从左到右删除第一个元素
lis.remove(100)     #remove当索引不存在时抛出indexerror
lis.pop()           #pop返回并删除最后一个元素
lis.pop(1)          #pop返回并删除所有所在位置的元素，根据所有来删除
lis.pop(100)        #pop当索引不存在时抛出indexerror
lis.clear()         #删除所有元素

pop
                    1.不传递参数是，时间复杂度是0（1）
                    2.传递参数时，时间复杂度是0（n）

其他操作
len(lis)            #求list的长度
lis.reverse()       #返回none，原地修改，反转一个列表
lis=[2,1,4,5,7,3,2]
lis.sort()          #原地修改，返回none，变成顺序排列
lis.sort(resverse=Ture) 
                    #逆序排列

lis=[1,2,3]
lis2=lis
lis2[1]=5
print(lis2)         #结果1,5,2
print(lis)          #结果1,5,2，复制操作传递的是引用

lis2=lis.copy()     #影子copy，修改lis2,lis不会改变，对可变对象时引用传递，对不可变对象时值传递



2.元组:元组是不可变的，下标只能用来访问不能用来赋值
t=tuple()
t=(1,2,3)

3.字符串：是集合类型，是可迭代对象,不可变
s='hello python'       #定义字符串的方式，不能定义多行字符串
s="hello python"
s='''hello python'''   #三引号可以定义多行字符串
s="""hello python"""

3.1转义
s='i like \npython'
s='i\'m harden'
path='C:\\windows\\nt\\system32'   #2个\预防转义
path=r'C:\windows\nt\system32'     #加r前缀代表此字符串是自然字符串，不会转义

3.2字符串下标
s[3]
s[4]='C'                           #字符串不可变
list(s)                            #转化成了列表

3.3字符串的操作spilt rsplit splitliness partition rpartition
lst=['i','am','harden']
' '.join(lst)                      #join是字符串的方法，参数是可迭代对象，接收者是分隔符

s.split()                          #默认使用空格分隔，多个空格当做一个处理
'i    love python'.split()         #已空格分隔
s.spilt(maxsplit=2)                #从左往右分隔字符串，maxsplit指定分隔次数，默认-1分隔所有分隔符

rsplit是split从右往左分隔

'i am harden'.partition(' ')       #总是返回一个三元组，传入的分隔符分割成tail，head
rpartition是partition的从右往左的版本

3.4大小写转换
s='test'
s.upper()
s.upper().lower()                  
s.title()                          #每个单词首字母大写
s.capitalize()                     #第一个单词首字符大写
s.casefold()                       #忽略大小写
s.swapcase()                       #交换大小写


3.5字符串修改replace strip lstrip rstrip ljust rjust center
s='i love python'
s.replace('love','give up')       #返回新字符串，使用new代替old
s='i very very love python'
s.replace('very','not')           #有多少个替换多少个
s.replace('very','not',1)         #可选的count参数。指定替换多少次

s='   hahah  hahaha  '
s1='####haha###'
s.strip()                         #strip移除head和tail的空白（space \n \t \r）
s1.strip('#')                     #移除知道那个的字符#

lstrip                            #表现形式和strip一样，只处理左端
rstrip                            #表现形式和strip一样，只处理右端
s.ljust(10)                       #原串在右边
s.center(10)                      #原串在中间
s.center(10,'#')                  #指定填充字符，默认空格，填充字符串长度只能为1 不能为##

3.5字符串查找find,rfind(find从右往左),index,count
s='i love python'
s.find('love')                    #从左往右查，找到第一个字串love，返回字串首字母的索引
s.find('love',3，5)               #start参数指定从哪里查找strt=3 end=5,字串不存在时返回-1

s.index('love',8)                 #字串不存在时返回valueerror

s.count('very'，1)                #出现的次数

3.6判断