# # # 索引：
# # # 正向索引： 0 1 2 3 4 5 6
# # # l= a b c d e f g
# # # 反向索引： -7 -6 -5 -4 -3 -2 -1
# # # range 遍历函数
# # # （起始位，结束位，隔位）
# # # 遍历函数中：包含起始不包含结束，隔位不能为0可以为1，1表示不隔位
# # # [起始索引位:结束位:步长值]
# # # 切片语法中：包含起始不包含结束，隔位不能为0可以为1，1表示不隔位
# # # l ='123456'
# # #[2:5:2] 3 5
# # '''
# st ='abcdefghjkl'
# # print(st[4]) #显示4 #d 截取当前索引值为4对应的值
# # print(st[-3]) #显示j # 截取当前索引值为-3对应的值
# # print(st[0:3]) #abc 从索引值0开始取，到结束索引3 0-2有对应值
# # print(st[1:3]) #bc 从索引值0开始取，到结束索引3 1-2有对应值
# # print(st[:-1]) #abcdefghjk
# # print (str[2:-1]) #cdefghjk
# # print (str[2:])# cdefghjkl
# # print(st[1:6:3])# be
# #print(st[::1]) #abcdefghjkl
# # print(st[::-1]) # lkjhgfedcba 面试题目重点把字符串中的值进行反向输出
# # print(st[-2:-5:-1]) #kjh
# # print(st[:5]) #abcde 为空则取所 有 # #开始索引，结束下标是5，显示0-4
# # print(st[:]) #abcdefghjkl 起始结束都为空则默认取所有
# #print(st[::-1]) # lkjhgfedcba 面试题目重点把字符串中的值进行反向输出
# # # print(st[-3:-6:-2])#fd
# #
# # '''
# # python 中的字符串
# # 字符串的定义用：单引号或者双引号英文的
# # '' ""
# # 字符串的类型为：str
# # '''
# # a ='asdfghjk' #定义一个字符串通过单引号
# # print(type(a)) #打印类型 <class 'str'>
# # # print(a) #打印结果 asdfghjk
# # # st ="asdfghjkl" #定义一个字符串通过双引号
# # # print(type(st)) #打印类型为：<class 'str'>
# # # print(st) #打印结果为：asdfghjkl
# #
# # # 在Python中字符串的一些常用函数
# # # 对于字符串中首字母大写
# # st_r ='abcedf'
# # print(st_r.capitalize())
# # # # 运行结果为：Abcedf
# # #
# # # # 统计字符串中具体的个数
# # st_r='abceacvea'
# # print(st_r.count('a'))
# # 运行结果为：3 当前a在字符串中有3个
# #
# # # 拼接函数
# # st_r='abcdef'
# # print('*'.join(st_r))
# # # # # 运行结果为：a*b*c*d*e*f
# # #
# # # #分割函数
# # str='abcedfg'
# # print(str.split('c')) #['ab', 'edfg']
# # # print(type(str.split('c'))) #<class 'list'>
# # # # split函数将对应的值进行分割后返回一个列表
# # #
# # # #删除字符串开头和结尾的字符
# # str1 ='abcefsd'
# # print(str1.strip('d')) #abcefs
# # # print(str1.strip('adsf')) #bce
# #
# # # 删除字符开头，不能删除结尾
# s ='abcedf'
# print(s.lstrip('a')) #bcedf
#
# # 删除尾部的字符，不能删除开头字符
# s1='sdfdsa'
# print(s1.rstrip('a')) #sdfds
# # #
# # # # 判断当前字符开头是否以某个值开头，返回的是布尔值
# # # s ='abcdefg'
# # # print(s.startswith('a')) #True
# # # print(s.startswith('c')) #False
# # #
# # # # 判断字符是以什么来结束，返回的是布尔值
# # # s1 ='adsfdsf'
# # # print(s1.endswith('f')) #True
# # # print(s1.endswith('a')) #False
# #
# # # find、rfind通过具体的值来找到对应值的索引位，
# # a ='ceafacaes'
# # print(a.find('a')) #2 索引位 #左边开始查
# # # print(a.rfind('a')) #6 索引位 #右边开始查
#
# # #replace()：replace(substring,newstring,max) substring表示被替换的字 符串,newstring要替换字符串,max表示替换的次数
# # # # 替换函数：把原有的值来替换成为新的值，也可以根据控制位数来替换几个
# # # # replace替换
# # a ='abdabda'
# # # print(a.replace('a','c')) #cbdcbdc
# ##cbdabda
# #print(a.replace('a','c',2)) #cbdcbda
# # #
# # # # 将所有的大小字符变成为小写
# # # a ='AsdfGES'
# # # print(a.lower()) #asdfges
# # #
# # # # 将字符串中索引的小写字符变成为大写字符
# # # a='ADSsdfdsSDF12'
# # # print(a.upper()) #ADSSDFDSSDF1
# # #
# # # # 判断当前字符串中是否全部都为数字，返回的是布尔值、
# # # a ='adsfdsa'
# # # a1 ='123123'
# # # a2 ='@1232132'
# # # print(a.isdigit()) #False
# # # print(a1.isdigit()) #True
# # # print(a2.isdigit()) #False
# # #
# # # # 判断当前字符串中是否全部都为字母,返回的是布尔值
# # # a ='adsfdsa'
# # # a1 ='123123'
# # # a2 ='@sadf132'
# # # print(a.isalpha()) #True
# # # print(a1.isalpha()) #False
# # # print(a2.isalpha()) #False
# #
# # # isaluum作用：判断当前字符串中是否全部为数字或者字母或者数字+字母组合
# # # 返回结果为布尔值
# # # a ='123214'
# # # print(a.isalnum()) #True
# # # a1='sadfdsa'
# # # print(a1.isalnum()) #True
# # # a2='adsf123'
# # # print(a2.isalnum()) #True
# # # a3='123@!'
# # # print(a3.isalnum()) #False
# # # a4='asdf#@'
# # # print(a4.isalnum()) #False
# # # a5='asd123#@'
# # # print(a5.isalnum()) #False
# #
# # # istitle判断当前字符串中首字符是否为大写，返回的为布尔值，其它为小写或者其它字符
# # # a ='Aasdf'
# # # print(a.istitle()) #True
# # # a1='asdf'
# # # print(a1.istitle()) #False
# # # a2='A123'
# # # print(a2.istitle()) #True
# # # a3='A#@#$'
# # # print(a3.istitle()) #True
# # # a4='AASDF'
# # # print(a4.istitle()) #False
# # #
# # # # isupper判断当前字符串中是否全部都为大写字母，返回为布尔值
# # # a ='ASDFDS'
# # # print(a.isupper()) #True
# # # a1='A123'
# # # print(a1.isupper()) #True
# # # a2='sadf'
# # # print(a2.isupper()) #False
# # # a3='Asd'
# # # print(a3.isupper())#False
# # #
# # # # islower判断当前字符串中是否全部都是为小写字符返回的是布尔值
# # # a ='ASDFDS'
# # # print(a.islower()) #False
# # # a1='ad123#$@'
# # # print(a1.islower()) #True
# # # a2='sadf'
# # # print(a2.islower()) #True
# # # a3='Asd'
# # # print(a3.islower()) #False
# #
# # '''
# # python 中的列表
# # 类型：
# # 字符串：str
# # 列表：list
# # 定义一个列表：[] 类型来定义:list类型
# # '''
# # # 第一种定义方法：
# # l =[1,2,3,'test'] #定义一个列表
# # print(type(l)) #<class 'list'> 列表类型
# # print(l) #打印结果为：[1, 2, 3, 'test']
# #
# # # 第二种定义方法：
# # # 可以通过类型来将其它转换为对应类型的值来显示
# # a ='asdf' #定义一个字符串
# # print(type(a)) #<class 'str'> 字符串类型
# # l_ist=list(a) #通过list列表类型来将a字符串转换成为列表
# # print(l_ist)#打印 ['a', 's', 'd', 'f']
# # # print(type(l_ist)) #查看类型 <class 'list'>
# # c =list('1')
# # print(type(c)) #<class 'list'>
# # print(c) #['1']
# #
# ## 通过索引来对列表中赋值
l =[1,2,3,4,5,'test'] # 定义一个列表
# l[4]='hello!!' #通过索引给对应索引位插入一个值
# print(l) #打印结果： [1, 2, 3, 4, 'hello!!', 'test']
#
l[2:]='123' #从索引值为2开始将后面所有的值赋予成123
print(l) #[1, 2, '1', '2', '3']
# #
i=[1,2,3,'多测师宝安大佬']
print(i) #[1, 2, 3, '多测师宝安大佬']
# # # # 在3以下的版本中：中文需要通过方法来进行转译
# # # # 3的版本不需要
# #
#2、列表中文打印乱码解决方法
# a = [1,2,3,"中国"]
# print (str(a).decode('string_escape'))
# decode()#指定编码格式
# string-escape：#编码格式，能解决因为被\转义的问题
# # # 添加一个元素
# l =[1,2,3,4] # 定义一个列表
# l.append('hello') #通过append函数来添加一个具体的元素值
# print(l) #打印列表 [1, 2, 3, 4, 'hello']
# # #
# a=[1,2,3] #定义一个列表
# b=[4,5,6] #定义一个列表
# a.extend(b) #把a列表中的值和b中的值进行拼接通过extend函数来形成一个列表
# print(a) #[1, 2, 3, 4, 5, 6]
# #
# # # 通过索引来给索引位置插入一个具体的值
# l3 =[1,2,3,4,5] #定义一个列表
# l3.insert(0,'hello') #给索引值为0的位置插入一个具体的值
# print(l3) #['hello', 1, 2, 3, 4, 5]
#
# # 移除当前列表中的某个元素值
l =['a',1,2,3,4,5,6,'b'] #定义一个列表
l.remove("a") #移除l列表中对应的具体值
print(l) #[1, 2, 3, 5, 6]
# #
# # # 删除列表或者通过索引来删除对应的元素
# # l1 =[1,2,3,4,5] #定义一个列表
# # del l1[4] #删除对应列表中对应的索引值对应的值
# # print(l1) #打印结果：[1, 2, 3, 4]
# # del l1 #删除列表
# # print(l1) #打印结果
# #
#*总结：如果列表中有多个相同的元素，会删除前面那个
# # # 通过列表中具体的值来得到对应值具体的索引位
# # l =['a','b','c','d','e'] #定义一个列表
# # print(l.index('c')) #通过index来获取对应列表中的值的索引位
# #
# # # 对列表中的值来进行升序的排序
# # l1 =[5,4,3,2,1] #定义一个列表
# # l1.sort() #通过sort来对列表进行升序排序
# # print(l1) #[1, 2, 3, 4, 5]
# #
# # l2 =[6,3,1,5,4,2]
# # print(sorted(l2,reverse=True)) #降序：[6, 5, 4, 3, 2, 1]
# # print(sorted(l2,reverse=False)) #升序：[1, 2, 3, 4, 5, 6]
# #
# # # 列表中反转输出：常问的面试题目用reverse函数
# # l3 =[1,2,3,4,5,6,7] #定义一个内部
# # l3.reverse() #列表中的反转输出
# # print(l3) #[7, 6, 5, 4, 3, 2, 1]
#
# # # pop函数：默认删除末尾的值，也可以通过索引来删除
# # l =[1,2,3,4,5] #定义一个列表
# # l.pop() #删除末尾的值
# # print(l) #[1, 2, 3, 4]
# print(l.pop()) #4 直接输出显示的为被删除的值，存留的不显示
# #
l2 =[1,2,3,4,5,6]#定义一个列表
#l2.pop(1) #通过pop来删除索引值为1的对应的值
#print(l2) #打印结果为：[1, 3, 4, 5, 6]
print(l2.pop(4)) #删除索引值为4对应的值：6
#
# '''
# Python中的元组
# 元组的类型为：tuple ()
# 字符串的类型为：str '' ""
# 列表的类型为：list []
# 元组是写保护的，一旦定义一个元组后是不允许直接元组中的元素进行增删改如需要增删改则需要通过类型进行转换'''
# # 元组的表达符号：() 英文的小括号
# # t =(1,2,3,4)#定义一个元组
# # print(type(t)) #<class 'tuple'>打印类型
# # print(t) #(1, 2, 3, 4)打印结果
# #
# # t1=(1) #如当前括号中只有一个值，在赋予的值是什么类型就是什么类型
# # print(t1)
# # print(type(t1)) #<class 'int'>
# #
# # # 如只有一个元素：想让它是以元组的类型输出，则需要在元素值后面加上
# # # 一个逗号英文的
# # t2=(1,) #定义一个元组 只有1个值后面加,号来转换为元组类型的输出
# # print(type(t2)) #<class 'tuple'>
# # print(t2) #打印结果为：(1,)
# #
# # # 列表和元组的区别：
# # # 一个是可变，一个是不可变
# # # 元组定义后由于不可直接修改则相对于代码来说要更加安全
# #
# # t3=(1,2,3,4,5) #元组
# # print(type(t3)) #<class 'tuple'> 元组
# # '''将元组转换成成为列表list'''
# # l =list(t3) #通过list类型将t3元组转换成为一个列表
# # print(type(l)) #<class 'list'> 列表
# # l.pop() #通过调用列表中的元素对值进行删除末尾，且返回的是列表
# # print(l)#[1, 2, 3, 4]
# # '''对元组通过转换且完成增删改后，
# # 将列表转换成为元组来实现最终输出'''
# # t3=tuple(l) #通过元组的类型tuple来将列表转换成为元组
# # print(type(t3))#打印类型 <class 'tuple'>
# # print(t3) #(1, 2, 3, 4)
#
# '''
# python中的字典：dict类型
# 键值对组成
# 键是唯一，值可以不唯一
# {} 英文的大括号或者花括号
# 字典中键值是一个整体，如有多个键值对要用英文的,逗号隔开
# 整形不需要加单双引号外，其它都需要加单双引号
# 键和值用英文的:冒号 比如：name:zhangsan
# '''
# # # 定义一个字典：
# # d ={'name':'zhangsan','age':18} #定义一个字典
# # print(type(d)) #<class 'dict'>字典的类型
# # print(d) #打印结果为：{'name': 'zhangsan', 'age': 18}
# # '''
# # {'name': 'zhangsan', 'age': 18}
# # 键key 值value
# # 键是唯一 值不唯一
# # '''
#
# # l =[('name','zhangsan'),('age',18)]
# # di_ct=dict(l)#将列表转换成为元组
# # print(type(di_ct)) #<class 'dict'>字典类型
# # print(di_ct) #{'name': 'zhangsan', 'age': 18}
#
#
# # d ={'name':'zhangsan','age':18}#定义一个字典
# # d['scroe']=100
# # print(d) #{'name': 'zhangsan', 'age': 18, 'scroe': 100}
# # d['scroe']=99
# # print(d) #{'name': 'zhangsan', 'age': 18, 'scroe': 99}
# # d['name']='lis'
# # print(d) #{'name': 'lis', 'age': 18, 'scroe': 99}
# '''给字典中增加一个键值对：如原字典内没有相同的减值对则新增一个
# 如原有字典中有相同的键，则会将对于的键的值进行重新赋值'''
#
# # d ={'name':'lis','age':18} #定义一个字典
# # print(d.keys()) #(['name', 'age'])
# # # 通过keys来取出对应的键
# # print(type(d.keys())) #<class 'dict_keys'>
# #
# # d1 ={'name':'lis','age':18} #定义一个字典
# # print(d.values()) #['lis', 18]
# # # 通过values来取出字典中对应的值
#
# # d2 ={'name':'lis','age':18} #定义一个字典
# # print(d2['name']) #lis
# # 通过键来获取对应键的值
#
# # d2 ={'name':'lis','age':18} #定义一个字典
# # d2.setdefault('scroe',100)
# # print(d2) #{'name': 'lis', 'age': 18, 'scroe': 100}
# # d2.setdefault('name','zhangsan')
# # print(d2) #{'name': 'lis', 'age': 18, 'scroe': 100}
# # d2['name']='wangwu'
# # print(d2) #{'name': 'wangwu', 'age': 18, 'scroe': 100}
# '''setdefault方法：如字典中没有相同的键则会新增一个键值对
# 如字典中以存在相同的键则不会对字典进行增加或者修改'''
#
# # d ={'name':'zhangsan','age':18}
# # del d['name']
# # print(d) #{'age': 18}
# # del (d)
# # print(d)
# # '''del 删除'''
# #
# # d ={'name':'zhangsan','age':18}
# # for k in d:
# # print(k) #拿到的是：键 值不拿
# #
# # d1 ={'name':'zhangsan','age':18}
# # for k in d1:
# # print(k,d1[k])
# #
# # # 通过items()方法来获取对应键值对
# # d2 ={'name':'zhangsan','age':18}
# # for k,v in d2.items():
# # print(k,v)
# #
# # d2 ={'name':'zhangsan','age':18}
# # print(d2.pop('name')) #zhangsan
# # '''通过pop函数删除指定的键，打印返回对应键的值'''
# #
# # d3 ={'name':'zhangsan','age':18}
# # d3.clear() #通过clear()来清空当前字典中的键值对
# # print(d3) #{}清空后返回就是一个空字典
#
# # d ={'name':'zhangsan','age':18,'':100}
# # print(d) #{'name': 'zhangsan', 'age': 18, '': 100}
# # print(d.get('name')) #zhangsan
# # print(d.get('')) #100
# # print(d.get('score')) #None
# # print(d.get(100)) #None
# # #
# # print({}.fromkeys(['name','age']))#{'name': None, 'age': None}
# # print({}.fromkeys(['name','age'],'a')) #{'name': 'a', 'age': 'a'}
# # d={}.fromkeys(['name','age'],'a')
# # print(d) #{'name': 'a', 'age': 'a'}
# # #
# # d={'name':'zhang','age':18}
# # print(d.fromkeys(['name','age'],'c')) #{'name': 'c', 'age': 'c'}
# #
# # d ={'name':'zhangsan','age':18,'':100}
# # print(d) #{'name': 'zhangsan', 'age': 18, '': 100}
# #
# # d ={'name':'zhangsan','age':18,'':100}
# # print(d.popitem()) #('', 100)
# # # popitem在字典中随机删除键值对，一般默认在末尾
# #
# # d1 ={'name':'zhangsan','age':18} #定义一个字典
# # d2={'scroe':100} #定义一个字典
# # d1.update(d2) #通过update方法将d1字典和d2字典进行合并
# # print(d1) #{'name': 'zhangsan', 'age': 18, 'scroe': 100}
题目：有如下字符串：user_name
将此字符串输出为：userName
'''
# s ='user_name'
# a=s.split('_')
# print(a) #['user', 'name']
# print(type(a)) #<class 'list'>
# c=a[0]
# print(c) #user
# d=a[1].capitalize()
# print(d) #Name
# print(c+d) #userName
# 十一、集合
#集合是不同元素的无序集合。与序列类型不同，集合是没有切片操作的
#语法：set 集合最重要的功能就是去重 集合分可变集合和不可变集合
# 1）可变集合（set）：集合里面的元素是可以发生变化，集合中可以动态的增加和删除。
# 2）不可变集合（frozenset）:集合里面的元素是不可以发生变化
# 注意：集合中的元素是无序的，且集合后元素不重复
#new = [1,2,33,2,2,99,'test'] #列表中元素去重
#yy = (set(new))
# print (yy) #结果： set(['test', 1, 2, 99, 33])
# test = 'hello'
# yy = set(test)
# print(yy) # 结果： set(['h', 'e', 'l', 'o'])
#yy.add('123')
# print (yy) #结果：set(['h', '123', 'e', 'l', 'o'])
# a=("1","88")
# yy.update(a) #添加集合的内容
#print (yy) # 结果：set(['e', 'h', 'l', 'o', '1', '88'])
#yy.clear() #清除集合中的内容
#print (yy) 结果：set()
# yy.pop() #删除集合中的内容
# print (yy) # 结果： set(['e', 'l', 'o'])
# 括号中填索引
# 备注：pop()方法用于随机移除一个元素例如：set.pop()
# 随机移除一个元素：
# 不带参数时，应该是移除最后位，但是我们这里是删除第一位
# a = ('1','88')
# yy = set(a)
# # yy.remove('88') #删除集合中的元素
# # print (yy)
# a = yy.copy() #复制集合
# print (a) #结果：set(['h', 'e', 'l', 'o'])
#不可变集合 frozenset
test = 'hello'
yy = frozenset(test)
yy.add('123') #AttributeError:
print (yy)
# # 'frozenset' object has no attribute 'add'译文：'frozenset'对象没有属性'add'
# a = yy.copy()
# print a 译文：'frozenset'对象没有属性'add'
