字符，列表，元组，字典，集合

• capitalize 首字母大写
• title 每段字母的首个字母大写
• count 统计字符个数
• join 把字符集中每个字符用符号分割
• split 通过指定的内容进行分割，不显示被指定的内容
• strip 删除字符集中开头和结尾，字符相同也可以
• lstrip 删除字符集首字符
• rstrip 删除字符集末位字符
• startswith 判断字符集是不是以某个字符开头
• endswith 判断字符集是不是以某个字符结尾
• find 从左往右查字符在第几位
• rfind 串右往左查字符在第几位
• replace 替换相同字符
• upper 将字符集所有小写字符换成大写
• lower 将字符集所有大写字符换成小写
• isdigit 判断字符集是不是全数字
• isalpha 判断字符集是不是全字母
• isalnum 判断字符串中是全是字母或全是数字或数字和字母组合
• islower 判断是不是都小写
• isupper 判断是不是都大写
• set 去重

  #字符串
  xnt='hzdcs41wlc'
  xnt2='aaaabbbbcccc'
  xnt3='AAAABBBBCCCC'
  # capitalize 首字母大写
  print(xnt.capitalize()) # 返回值：Hzdcs41wlc
  # title  每段字母的首个字母大写
  print(xnt.title()) # 返回值：Hzdcs41Wlc
  # count 统计字符个数
  print(xnt.count('z')) # 返回值：1
  # join 把字符集中每个字符用符号分割
  print('/'.join(xnt)) # 返回值;h/z/d/c/s/4/1/w/l/c
  # split 通过指定的内容进行分割，不显示被指定的内容
  print(xnt.split('s')) # 返回值：['hzdc', '41wlc']
  # strip  删除字符集中开头和结尾，字符相同也可以
  print(xnt.strip('h.c')) # 返回值：zdcs41wl
  # lstrip  删除字符集首字符
  print(xnt.lstrip('h')) # 返回值：zdcs41wlc
  # rstrip 删除字符集末位字符
  print(xnt.rstrip('c')) # 返回值：hzdcs41wl
  # startswith  判断字符集是不是以某个字符开头
  print(xnt.startswith('z'))  # 返回值:对的True/错的False
  # endswith   判断字符集是不是以某个字符结尾
  print(xnt.endswith('c'))  # 返回值:对的True/错的False
  # find 从左往右查字符在第几位
  print(xnt.find('w')) # 返回值 ：7
  # rfind  串右往左查字符在第几位
  print(xnt.rfind('w'))  # 返回值：2
  # replace 替换所有相同字符
  print(xnt2.replace('a','s'))  #返回值：ssssbbbbcccc a是原值，b是替换值
  # replace 指定替换的次数
  print(xnt2.replace('a','s',3))   #返回值：sssabbbbcccc a是原值，b是替换值,3是次数
  # upper  将字符集所有小写字符换成大写
  print(xnt2.upper()) # 返回值：AAAABBBBCCCC
  # lower  将字符集所有大写字符换成小写
  print(xnt2.lower())  # 返回值：aaaabbbbcccc
  # isdigit 判断字符集是不是全数字
  print(xnt2.isdigit())    # 返回值:对的True/错的False
  # isalpha  判断字符集是不是全字母
  print(xnt2.isalpha())    # 返回值:对的True/错的False
  # isalnum   判断字符串中是全是字母或全是数字或数字和字母组合
  print(xnt2.isalnum())    # 返回值:对的True/错的False
  # istitle  判断首个字母是否大写必须是只有首个字符大小，其他字母为小写
  print(xnt2.istitle())    # 返回值:对的True/错的False
  # islower 判断是不是都小写
  print(xnt.islower())   # 返回值:对的True/错的False
  # isupper 判断是不是都大写
  print(xnt.isupper())   # 返回值:对的True/错的False
  # set  去重
  list = [1, 3, 6, 9, 1, 8]
  qc=set(list)
  print(qc)    返回值:{1, 3, 6, 8, 9}

  列表

  类型：<class 'list'> 符号：[] 定义：列表list 是一组有序存储的数据，也是python常见的序列值一、序列中的每个元素都分配一个索引，第一个元素的索引是0，第二个元素的索引是1，依次类推，序列都可以进行操作包括索引，切片 定义列表的方法有两种： 方法一：list1=[1,2,3,4] #直接通过[]进行定义 方法二：list2=list（'12345） #直接通过list转换

  通过索引添加值（覆盖原有值

  # 列表数据
  list1=[1,2,3,4,5]
  # 替换单个
  list1[2]='a'
  print(list1)   #返回值：[1, 2, 'a', 4, 5]
  # 替换多个
  list1[1:]='好好学习天天向上'
  print(list1)  #返回值：[1, '好', '好', '学', '习', '天', '天', '向', '上']

  列表中的函数

  append  添加元素           默认添加在最后一位   

  list1=[1,2,3,4,5]
  list2=[6,7,8,9,0]
  list1.append('name')
  print(list1) #返回值：[1, 2, 3, 4, 5, 'name']

  extend  ：连接两个列表

  list1=[1,2,3,4,5]
  list2=[6,7,8,9,0]
  list1.extend(list2)
  print(list1)  #返回值：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

  insert（） 在指定字符后插入数据

  list1=[1,2,3,4,5]
  list1.insert(2,'r')
  print(list1) #返回值：[1, 2, 'r', 3, 4, 5]

  remove删除列表中指定的值，从左开始删除，只删除第一个

  ist1=[1,2,3,4,5]
  list1.remove(3)
  print(list1) #返回值;[1, 2, 4, 5]

  del 通过 索引删除指定的值

  list1=[1,2,3,4,5]
  del list1[3]
  print(list1) #返回值：[1, 2, 3, 5]

  index 查看在列表中字符集的索引值

  list1=[1,2,3,4,5]
  print(list1.index(4)) #返回值：3

  sort 实现列表的升序排列

  ist1=[2,3,6,7,4,1,9,8]
  list1.sort()
  print(list1) # 返回值;[1, 2, 3, 4, 6, 7, 8, 9]

  sorted 排序字母和数字都可以排序

  list1=[2,3,6,7,4,1,9,8]
  print(sorted(list1,reverse=True)) #返回值：降序[9, 8, 7, 6, 4, 3, 2, 1]
  print(sorted(list1,reverse=False)) #返回值：升序[1, 2, 3, 4, 6, 7, 8, 9]
  list1=['a','c','d','b','e','f','g']
  print(sorted(list1,reverse=True))  #返回值：降序['g', 'f', 'e', 'd', 'c', 'b', 'a']
  print(sorted(list1,reverse=False))  #返回值：升序['a', 'b', 'c', 'd', 'e', 'f', 'g']

  reverse 列表中所有元素反转

  list1=[2,3,6,7,4,1,9,8]
  list1.reverse()
  print(list1)  #返回值：[8, 9, 1, 4, 7, 6, 3, 2]

  pop 默认移除列表中最后一个元素,括号内可以选择要移除的值

  list1=[1,2,3,4,5]
  list1.pop()
  print(list1) #返回值：[1, 2, 4, 5]

  元组 tuople

  元组不可变 定义：元组是python中一种数据结构，元组由不同的元素组成，每个元素可存储不同类型的数据；如字符串，数字，甚至元组， 元组是“写保护”的，即元组中元素作为一个整体，创建后不能做任何修改操作。 当出现一个字符时，加上逗号，（就变成了元组）

  xnt=(1,2,3,4,5,'a','b','c')
  print(type(xnt))  #返回值：<class 'tuple'>
  print(xnt)

  元组函数运用

  （1）index 索引

  xnt=(1,2,3,4,5)
  print(xnt.index(5)) #返回值：4

  （2）元组需要修改，只能将元组转换成列表，使用列表的函数操作，列表操作完在转换成元组

  xnt=(1,2,3,4,5,'a''b','c')   # 数值
  print(type(xnt))              # 查看类型为tuple元组类型
  xnt1=list(xnt)                # 重命名并转换成列表类型
  print(type(xnt1))             # 查看类型为list
  print(xnt1)                   # 打  印
  xnt1.insert(2,'s')            # 对列表进行操作
  print(xnt1)                   # 打印
  xnt2=tuple(xnt1)              # 重命名并将列表转回元组
  print(type(xnt2))             # 查看类型为tuple元组类型
  print(xnt2)                   # 打印

  元组和列表的区别：

  相同： 1、都是有序， 2、都支切片、迭代等操作 不同： 1、list是可变对象，元组tuple是不可变对象 2、tuple不可变，使用tuple编写的代码更安全 3、列表是[]，元组是() 4、列表的字符类型：list ，元组的字符类型：tuple  

  字典

  字典的字符类型 <class 'dict'> 符号：{}   1、字典（dict）是一种可变容器模型，且可存储任意类型对象 2、字典的每个键，值 key，value 键值对形式 3、键值用：分割，每个键值对之间用逗号分隔 4、整个字典用{}包含 5、字典键唯一，值不是唯一的  

  定义字典的方法

  方法一：通过{}定义字典

  xnt={'name':'wangfugui','age':'88',}
  print(type(xnt))  #返回值：<class 'dict'>

  方法二：通过dict来转换成字典

  xnt=[('aa',1),('bb',2),('cc',3)]  # 数值
  xnt1=dict(xnt)         # 重命名并转换成dict字典
  print(type(xnt1))      # 查看类型 返回值：<class 'dict'>
  print(xnt1)            # {'aa': 1, 'bb': 2, 'cc': 3}

  字典中常见的函数：

  1.添加新的键和值

  s={'a': 1, 'b': 2, 'c': 3}   # 字典
  s["d"]=4     # 要添加的键和值，'d'是键,4是值
  print(s)     # 返回值：{'a': 1, 'b': 2, 'c': 3, 'd': 4}