索引，切片，集合，元组

一、索引

索引在公司中一般也叫下标或角标

索引： 正向索引  ，负向索引

正向索引：从零（0）开始；

负向索引：从负一（-1）开始

格式：【开始索引位 ：结束索引位：步长值】

切片：包含起始值，不包含结束值，隔位不能为0，可以为为1，1表示不隔位,2开始隔位

空格：代表所有

切片：
a='qwertuuopd'
print(a[1:2]) #w
print(a[:-1]) #qwertuuop
print(a[2:-1]) #ertuuop
print(a[2:]) #ertuuopd
print(a[2:7:2]) #etu
print(a[::1])#qwertuuopd
print(a[:]) #qwertuuopd
print(a[::-1]) #dpouutrewq
print(a[-2:-5:-1]) #pou


字符串：' '  <class 'str'>

a='buhfqkyhukhsf'
b='1234'
c='SADAF'
d=' '
print(a.capitalize()) #Buhfqkyhukhsf 首字母大写
print(a.title()) #Buhfqkyhukhsf  首字母大写
print(a.count('h')) #3   统计
print('A',a.join(b))  #A 1buhfqkyhukhsf2buhfqkyhukhsf3buhfqkyhukhsf4 整个拼接
print('G'.join(a)) #bGuGhGfGqGkGyGhGuGkGhGsGf 字符件拼接
print(a.split('h')) #['bu', 'fqky', 'uk', 'sf']  指定h作为分隔结果为列表
print(a.strip('b')) #uhfqkyhukhsf   删首部一个字符
print(a.lstrip('b')) # uhfqkyhukhsf   删首部一个字符
print(a.rstrip('f')) #buhfqkyhukhs 删尾部一个字符
print(a.startswith('b'))  #True  判断首字符
print(a.endswith('f'))  #True  判断末尾字符
print(a.find('h'))   #2   查找一个字符 又左到右，返回一个的下标
print(a.find('w'))   #-1   没有匹配的返回一个-1
print(a.rfind('h'))  #10  反向查找 返回第一个 ，返回一个下标
print(a.replace('s','o')) # buhfqkyhukhof  替换字符
print(a.replace('h','g',2)) #bugfqkygukhsf  替换字符，指定替换两次
print(c.lower())  #sadaf  更换大写字符为小写字符
print(a.upper())  #BUHFQKYHUKHSF  更换小写字符为大写字符
print(a.isalnum()) # True   判断由字母或数字组成
print(b.isdigit()) #Ture  判断由数字组成
print(a.islower()) #Ture  判断是否全部小写
print(c.isupper()) #Ture  判断是否全部大写
print(d.isspace()) #Ture  判断是否为空
print(a.istitle()) #False 判断后字母是否大写





列表：  [  ]      <class 'list'>

定义列表的两种方法：

1,直接通过【】来定义a = [1,2,3,4,5,6]
print(a)第二种通过list来转换定义
a='qwewty'  #字符串
b=list(a)  #转换为列表
print(b)

1、通过索引值赋值

b[2]='o' #['q', 'w', 'o', 'w', 't', 'y']
print(b)
2、通过切片赋值
b[1:4]='GG'
print(b) #['q', 'G', 'G','t','y']
3、append  添加函数
b.append('31h') #['q', 'G', 'G', 't', 'y', '31h']注意：默认添加在最后一位

4、exend   添加 （把两个列表进行拼接通过extend函数形成一个列表）
c=[1,2,3]
b.extend(c) #['q', 'G', 'G', 't', 'y', '31h', 1, 2, 3]
print(b)
5、insert  插入
  
b.insert(1,'2') #['q', '2', 'G', 'G', 't', 'y', '31h', 1, 2, 3]
print(b)


如果超出索引位，自动在最后一位添加
b.insert(18,'oo') #['q', '2', 'G', 'G', 't', 'y', '31h', 1, 2, 3, 'oo']
print(b)6、remove  删除
删除具体的值（3）为列表内的值
b.remove(3)  #['q', '2', 'G', 'G', 't', 'y', '31h', 1, 2, 'oo']
print(b)

7、del 删除
删除下标为1 的
del b[1] #['q',  'G', 'G', 't', 'y', '31h', 1, 2, 'oo']
print(b)del b  #删除列表
8、sort  升序

e=[4,2,1,6]
print(e)
e.sort() #[1, 2, 4, 6]
print(e) 9、sorted  降序
print(sorted(e,reverse = True)) #降序  [6, 4, 2, 1]
print(sorted(e,reverse = False)) #升序  [1, 2, 4, 6]10、reverse 反转
e.reverse() #[6, 4, 2, 1]
print(e)11、pop  删除
删除指定值，默认删除最后一位
e.pop(2) #[6, 4, 1]print(e.pop()) #2312、索引位
print(e.index(4))

元组  （）   <class 'tuple'>

特点：元组是有序， 但是元组的元素是不可修改，  更加安全

定义：元组使用小括号（）， 元组创建只需要在括号中添加元素，并使用逗号隔开即可元组是有序，可以通过索引取值

a=(1,3,5,'a','g') #(1, 3, 5, 'a', 'g')
print(a)


b=list(a) #元组转换到列表 [1, 3, 5, 'a', 'g']
print(b)
a=tuple(b)#列表转换到元组  (1, 3, 5, 'a', 'g')
print(a)
字典： dict   {  }  <class 'dict'>
键：值       ，键：值     
{'name': 'tom', 'num': 2}
键值对组成，键是唯一的，值不唯一

一、直接定义字典：
a={'name':'tom','num':2} #{'name': 'tom', 'num': 2}
print(a)
二、列表转换成字典
a=[('name','tim'),('add','oo')]
print(a) #[('name', 'tim'), ('add', 'oo')]  列表
b = dict(a)
print(b) # {'name': 'tim', 'add': 'oo'}  字典

三、字典中添加键值对

新增键 ，键值对都不存在
b['sex']='女' #{'name': 'tim', 'add': 'oo', 'sex': '女'}
print(b)
键存在，值替换b['name'] = 'java' #{'name': 'java', 'add': 'oo', 'sex': '女'}
print(b)四、通过keys 取出所有键
print(b.keys()) #dict_keys(['name', 'add', 'sex'])五、通过values 取出所有的值
print(b.values()) #dict_values(['java', 'oo', '女'])六、通过键来获取对应键的值
print(b['name']) #java七、删除键 （键没有，值也没有）
del b['add'] #{'name': 'java', 'sex': '女'}
print(b)八、for循环获取   

for  遍历

通过 for 循环  ，取键
for x in b:  # 取键
    print(x)
    #name  sex

通过 for 循环 ，取键 取值
for x in b:  # 取键和值   {'name': 'java', 'sex': '女'}
    print(x,b)通过items 方法来获取定影键值对

for x,y in b.items():
    print(x,y)

# name java
# sex 女9、通过pop  函数删除指定的键，返回对应键的值
print(b.pop('sex')) #女

删除指定的键
b['sex'] = '女'
print(b)
b.pop('sex') #{'name': 'java'}
print(b)
popitem在字典删除键值对，一般默认删除末尾
b['sex'] = '女'
b.popitem() #{'name': 'java'}
print(b)

10、clear  清空当前字典中的键值对，返回一个空字典
b.clear('sex') #{}
print(b)

11、get    ，get通过键获取对应的值

print(b.get('sex')) #女
当get的键不存在时，就返回None
print(b.get('add')) #None
12、fromkeys 快速生成字典
print({}.fromkeys(['name','add'])) #{'name': None, 'add': None}生成字典的键和值
print({}.fromkeys(["name","age"],'a'))  #{'name': 'a', 'age': 'a'}13、update  方法 将多个字典合并

a ={'name':'tom'}
b={'add':'dh'}
a.update(b)
print(a) #{'name': 'tom', 'add': 'dh'}
14、copy 复制字典
a ={'name':'tom'}
d= a.copy() #{'name': 'tom'}
print(d)15、setdefault  添加设置默认键值 setdefault

案例1  ：添加不存在的键值
a ={'name':'tom'}
a.setdefault('add','kk')
print(a) # {'name': 'tom', 'add': 'kk'}

集合：

集合是不同元素的无序集合。与序列类型不同，集合是没有切片操作的

语法：set 集合最重要的功能就是去重，

集合分可变集合，不可变集合

（1）可变集合（set）

集合里面的元素是可以发生变化，集合中可以动态的增加和删除

（2）不可变集合（frozenset  ）

集合里面的元素是不可以发生变化

注意：集合中的元素是无序的，且集合后元素是不重复



一、可变集合

#<class 'set'>
1.
（1）对列表数据重复的，进行去重

（2）对一个字符串进行去重

对一个列表去重
a=[1,2,3,3,4,5,6,7,7]
b=set(a)
print(b) #{1, 2, 3, 4, 5, 6, 7}


对字符去重
a='aabdfggh'
b=set(a)
print(b) #{'d', 'f', 'a', 'g', 'b', 'h'}
1、add  添加
print(b) #{'d', 'f', 'a', 'g', 'b', 'h'}
b.add('abdd')
print(b) #{'d', 'h', 'g', 'abdd', 'a', 'b', 'f'}
b.add(123)
print(b) #{'d', 'g', 'b', 'h', 'abdd', 'f', 'a', 123}2、update  添加   （集合是无序的）
str="abcdaaabbmm"
s=set(str)
s.update("1")
print(s) #{'1', 'a', 'b', 'c', 'd', 'm'}

3、clear  清除集合中的内容，返回一个空集合

a='huikhnksja'
b=set(a)
b.clear
print(b) #{'a', 'u', 'k', 'i', 'h', 'n', 's', 'j'}4、pop 删除集合中的内容  （随机删除一个元素）
b.pop()
print(b) #{'s', 'n', 'u', 'j', 'k', 'h', 'a'}
5、remove  删除 指定的内容
b.remove('u') #{'s', 'n', 'j', 'a', 'h', 'i'}
print(b)6、copy 复制集合
a='huikhnksja'
b=set(a)
c=b.copy()
print(c)#{'a', 'i', 'k', 'n', 'j', 'h', 'u', 's'}（2）不可变集合： frozenset
只能使用copy，其他函数不能使用
a='huikhnksja'
b=frozenset(a)
print(b) #frozenset({'i', 'j', 'k', 's', 'h', 'u', 'a', 'n'})