python索引、切片、列表、元组、字典、集合

索引:
正向索引    0 1 2 3 4 5 6
反向索引   -7-6-5-4-3-2-1
切片：[起始索引位:结束索引位:步长值]
切片语法中：包含起始不包含结束位，步长值不能为0，可以为1(默认为1),1表示不隔位
st ="abcdefghjkl"
#print(st)
print(st[3])#d 截取当前索引值为3对应的值
print(st[-3])#j 截取当前索引值为-3对应的值
print(st[1:4])#bcd 从索引值为1开始取，到结束索引4，1-3有值
print(st[0:3])#abc 从索引值为0开始取，到结束索引3，0-2有值
print(st[2:-1])#cdefghjk
print(st[:-1])#abcdefghjk
print(st[2:])#cdefghjkl
print(st[1:6])#bcdef
print(st[1:6:3])#be
print(st[1:6:2])#bdf
print(st[::1])#abcdefghjkl 为空则取所有
print(st[::-1])#lkjhgfedcba 把字符串的值进行反向输出
print(st[-2:-5:-1])#kjh
print(st[-3:-6:-2])#jg
起始索引位和结束索引位控制取值范围,步长值控制取值的方向及隔位取值
字符串
字符串的定义用：单引号或者双引号
字符串的类型：str
a = 'sdfdsfdsf' #通过单引号定义一个字符串
print(type(a))#打印类型
对字符串中首字母改为大写
a = "helloword" #定义一个字符串
a1 = a.capitalize()#通过变量来接收参数，对当前字符串中首字母小写改变为大写
print(a1)#Helloword
或直接使用print(a.capitalize())#Helloword
统计字符串中具体元素出现的次数
a = "helloword" #定义一个字符串
a1= a.count("l")#通过变量来接收值
print(a1)#2
或直接使用print(a.count("l"))#2
join 拼接（把列表或一个字符串中的多个字符串拼接成一个）
a = "helloword" #定义一个字符串
print("".join(a))#helloword
l=['h','e','l','l','o','w','o','r','d']#定义一个列表
print(''.join(l))#helloword
split 分割
a = "hell,oword" #定义一个字符串
s=a.split(',')#把a字符串中的多余的元素分割，输出会变成一个列表，然后再使用join拼接
print(s)#['hell', 'oword']
print(type(s))#打印类型
print(''.join(s))#helloword
print(type(''.join(s)))#打印类型
删除字符
strip:删除字符串开头和结尾的元素
lstrip:删除字符开头的元素,不能删除结尾的
rstrip:删除字符串结尾的元素,不能删除开头的
a = "helloword" #定义一个字符串
print(a.strip('he'))#lloword
print(a.strip("rd"))#hellowo
print(a.lstrip('h'))#elloword
print(a.rstrip('d'))#hellow
判断字符以什么开头或结尾，返回的是布尔值
a = "helloword" #定义一个字符串
#startswith 判断是否以某某开头，是返回true 反之false
#endswith 判断是否以某某结尾，是返回true 反之false
print(a.startswith('he'))#True
print(a.startswith('e'))#False
print(a.endswith('rd'))#True
print(a.endswith('r'))#False
find: 获取指定值的索引值，从左开始
rfind：获取指定值的索引值，从右开始
a = "helloword" #定义一个字符串
print(a.find("o"))#4
print(a.rfind("o"))#6
replace 替换函数
a = "helloword" #定义一个字符串
print(a.replace('l','2'))#he22oword 默认替换指定值，所有
print(a.replace('l','3',1))#he3loword 把l换成3 数字1表示替换次数
print(a.replace("helloword",'小刘'))#把小刘 替换所有
print(a.replace(a,'xiaoliu'))#xiaoliu
把大写字母转换为小写
st='HELLOword'#定义一个字符串
print(st.lower())#helloword
把小写字母转换为大写
st='HELLOword'#定义一个字符串
print(st.upper())#HELLOWORD
判断是否全部为数字，返回布尔值 是返回true 反之false
st1='h123llo'#定义字符串
st2='12345'#定义字符串
print(st1.isdigit())#False
print(st2.isdigit())#True
判断是否全部为字母，返回布尔值 是返回true 反之false
st1='h12ee'
st2='12345'
st3='abAB'
print(st1.isalpha())#False
print(st2.isalpha())#False
print(st3.isalpha())#True
判断是否为全数字或全字母或数字加字母是返回true 反之false
st1='h12ee'
st2='12345'
st3='abAB'
st4='ab12@'
print(st1.isalnum())#True
print(st2.isalnum())#True
print(st3.isalnum())#True
print(st4.isalnum())#False
判断首字母是否为大写，其他无大写（注意：若字符串中有数字或特殊字符，则下一个大写字母默认当成一个新的字符串开始判断。例如：st7='Aasf123*A'   print(st7.istitle())#True）
st1='A'
st2='AA'
st3='A123'
st4='Aasff'
st5='asd'
st6='A@33'
print(st1.istitle())#True
print(st2.istitle())#False
print(st3.istitle())#True
print(st4.istitle())#True
print(st5.istitle())#False
print(st6.istitle())#True
判断字符串全部为大写或者小写
isupper 判断全部为大写
islower 判断全部为小写
st1='sfsgfdj'#定义字符串
print(st1.isupper())#False 判断全部为大写
print(st1.islower())#True  判断全部为小写
st2 ='asaDEDE'#定义字符串
print(st2.isupper())#False 判断全部为大写
print(st2.islower())#False 判断全部为小写
st3='SDSFDFD'#定义字符串
print(st3.isupper())#True
print(st3.islower())#False
列表：[]中括号来定义，类型：list
list = ['123']#定义列表
print(type(list))#打印类型
print(list)#['123']
list1=list('123')#用函数定义一个列表
print(list1)#['1', '2', '3']
print(type(list1))#
st='hello'#定义字符串
print(type(st))#
c =list(st)#通过list函数把字符串变为列表
print(c)#['h', 'e', 'l', 'l', 'o']
print(type(c))#打印类型
list2=['hello',1,2,3,4,5,6]#定义列表
#列表中的每个元素都有一个索引
print(list2[0])#hello
print(list2[4])#4
python3中可以直接打印中文，python2中不可以直接打印
往列表中添加元素
list2=['hello',1,2,3,4,5,6]#定义列表
list2.append('xiaoliu')#添加元素
print(list2)#['hello', 1, 2, 3, 4, 5, 6, 'xiaoliu']
往列表指定索引位添加元素(.insert(索引值，插入值))
list2=['hello',1,2,3,4,5,6]#定义列表
list2.insert(4,'xiaoliu)
print(list2)#['hello', 1, 2, 3, 'xiaoliu', 4, 5, 6]
列表的拼接
list1=[1,2,3]#定义列表
list2=[4,5,6]#定义列表
list1.extend(list2)#
print(list1)#[1, 2, 3, 4, 5, 6]
获取列表中指定元素对应的索引值
list2=['hello',1,2,3,4,5,6]#定义列表
print(list2.index(4))#4
移除元素
list2=['hello',1,2,3,4,5,6,1]#定义列表
list2.remove(1)
print(list2)#['hello', 2, 3, 4, 5, 6, 1]
注：列表中有相同元素时，删除前面的元素
删除元素(索引值)
list2=['hello',1,2,3,4,5,6,1]#定义列表
del list2[7]#通过 del来删除索引值对应的数据
print(list2)#['hello', 1, 2, 3, 4, 5, 6]
排序（默认升序）
list =[5,3,2,4,1]
list.sort()#对当前这个列表进行升序排序
print(list)#[1, 2, 3, 4, 5]
降序排序：reverse=True，反之，reverse=False
print(sorted(list,reverse=True))#[5, 4, 3, 2, 1]
print(sorted(list,reverse=False))#[1, 2, 3, 4, 5]
列表元素反转输出
list =[5,3,2,4,1]#定义列表
list.reverse()#对列表进行反转
print(list)#[1, 4, 2, 3, 5]
st ='12345'#定义字符串
print(st[::-1])#对字符串的反转
pop 删除元素
list = [1,2,3,4,5]#定义列表
list.pop()#默认删除末尾的元素
print(list)#[1, 2, 3, 4]
查看删除的值
list2 = [1,2,3,4,5]#定义列表
print(list2.pop())#5 直接打印被删除的值
list3 = [1,2,3,4,5]#定义列表
list3.pop(0)#通过索引值删除对应的数据
print(list3)#[2, 3, 4, 5]

元组：()定义，类型tuple
元组是不可变的，定义好元组之后不能直接增删改元组中的元素，只能间接转化成其他数据类型，再进行修改。
如果元组中只有一个元素，一定要在后面加上一个逗号，如果不加，原始元素是什么类型它就打印成什么类型
列表和元组的区别:
1.类型不同 list tuple
2.定义不同 列表通过[]定义，元组通过()定义
3.列表定义是可以随意的增删改（元素不受保护）
4.元组定义是不可以随意的增删改（元素受保护）
元组也是支持切片操作的

对元组进行修改
t =(1,2,3,4,5,6)#定义元组
往元组中添加元素(通过list把元组转换为列表,再添加元素，再通过tuple转换成元组)
print(type(t))#
t1=list(t)#通过list把元组转换为列表
print(type(t1))#
t1.append(7)#往列表中插入元素
print(t1)#[1, 2, 3, 4, 5, 6, 7]
t2=tuple(t1)#把列表转换为元组
print(type(t2))#
print(t2)#(1, 2, 3, 4, 5, 6, 7)
#字符串转元组
s="hello"#定义字符串
print(type(s))#
print(tuple(s))#('h', 'e', 'l', 'l', 'o')
#元组转换字符串
t =(1,2,3,4,5,6)#定义元组
s1=t.str()
print(type(s1))#
print(s1)#(1, 2, 3, 4, 5, 6)

字典：定义{}，类型：dict
字典中：键值对形式存储，键是唯一的，值可以不唯一
键值对用冒号分割，如：“name”："zhangsan"。 多个键值对之间用逗号分割，如果键后面没值，则需要加‘’“
d ={}#定义空字典
print(type(d))#


d ={'name':"zhangsan"}#定义字典,里面有一个键值对
print(type(d))#
print(d)#{'name': 'zhangsan'}

d1 ={'name':''}#如果字典中没有值一定要加引号，
print(d1)#{'name': ''}

d={'name':'zhangsan','age':18}#定义字典，有多个键值对用逗号分隔
print(d)


t =('a',1)#定义元组
print(type(t))#
d=dict(t)#转换为字典
print(type(d))
print(d)#在单个元组的情况转换字典失败

t1 =[('a',1)]#定义列表
print(type(t1))#
d1=dict(t1)#转换为字典
print(type(d1))#
print(d1)#{'a': 1}

添加键值对
原字典中没有相同的键，则会把键值添加到字典中
d={'name':'zhangsan','age':18}#定义字典
d['score']=100#添加键值对
print(d)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d={'name':'zhangsan','age':18,'score':90}#定义字典
原字典中存有此键，执行替换
d['score']=100#设置键值对
print(d)


设置键值对
注：此方法执行后会进行判断，如果发现字典中没有此键则会把键值对设置到字典中，
如果原字典中有此键则不会执行替换
d1={'name':'zhangsan','age':18}#定义字典
d1.setdefault('score',100)#设置键值对
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d2 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d2.setdefault('score',98)#设置键值对
print(d2)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d2 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
key=d2.keys()#取出当前字典中所有键
print(key)#dict_keys(['name', 'age', 'score'])

#取值values
d3 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
value=d3.values()#取出当前字典中所有的值
print(value)#ict_values(['zhangsan', 18, 100])

#取指定键的值
d4 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
value1=d4['name']#获取name这个键对应的值
print(value1)#zhangsan


# d4 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
# del d4#删除整个字典
# print(d4)#抛异常，因为字典已被删除

#删除指定键和值
d5 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
del d5['score']#删除键和对应的值，返回剩余的键值对
print(d5)#{'name': 'zhangsan', 'age': 18}


字典遍历：for 变量名 in 字典名称
当前变量获取到的值为键，值不显示
d5 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for i in d5:
    #print(i)#name\age\score
    print(i,d5)#键和值一起显示

通过items函数获取键值对
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for k,v in d6.items(): #k代表键，v代表值
   print(k,v)#键和值一起显示

删除键返回对应键的值
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
# a=d6.pop('score')#删除score这个键并返回键对应的值
# print(a)#100
print(d6.pop('score'))

清空
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d6.clear()#把这个字典中的所有键值清空掉
print(d6)#{}  返回空字典


获取指定键的值
#如果没有指定的键则返回none
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
a=d6.get("name")#获取name这个键对应的值
print(a)#zhangsan
print(d6.get("name"))#zhangsan
print(d6.get('a'))#None

给键指定值
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
#不指定值
print({}.fromkeys(['name','age',"score"]))#{'name': None, 'age': None, 'score': None}
#指定值
print({}.fromkeys(['name','age',"score"],'dcs16')) #{'name': 'dcs16', 'age': 'dcs16', 'score': 'dcs16'}

python2：has_key 函数检查字典是否有指定的键存在
python3：__contains__ 函数检查字典是否有指定的键存在
有存在返回true,反之返回false
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d6.__contains__('name'))#True
print(d6.__contains__('a'))#False

删除字典中的键值对，并返回删除的数据（默认删除末尾）
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d6.popitem())#('score', 100)
print(d6.popitem())#('age', 18)

更新把两个字典拼接形成新的字典
d1={'name': 'zhangsan', 'age': 18}#定义字典
d2={'score': 100}#定义字典
d1.update(d2)
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}
#存在相同的键，则执行替换
d3={'name': 'zhangsan', 'age': 18,'score': 98}#定义字典
d4={'score': 100}#定义字典
d3.update(d4)
print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}

把两个列表设置为字典
a = ['a','b','c']#定义列表
c = [1,2,3]#定义列表
l=zip(a,c)#把两个列表拼接形成多个元组，索引值相同的为一个整体('a',1)
d=dict(l)#转换为字典
print(d)#{'a': 1, 'b': 2, 'c': 3}
print(type(d))#

集合
没有切片操作

可变集合 set
不可变集合 frozenset

区别：
相同点都能够进行去重
不同点：
可变集合去重后可以实现增删改
不可变集合去重后不可以进行增删改