python数据类型大总结（字符串 列表 元组 字典 集合 ）

字符串：
有序、不可变数据类型，支持索引，切片，步长（字符串中的每一个字母或字符都称为元素）
索引(下标)：通过索引精确定位到每个元素
索引从左开始向右排 从0开始 索引时不能超过最大值，超出报错 从右向左排从-1开始
切片（顾头不顾尾）
步长 print(name[::2] 取整个字符串，步长为2
字符串方法：

  upper 全部大写   lower全部小写     capitalize  首字母大写     title每个单词的首字母大写    swapcase 大小写转换
  starswith 以..开头   endswith  以..结尾    
  center  居中 (填充）
  find 查找(通过元素查找索引，找不到返回-1)    index 查找(通过元素查找索引，查找不到报错)
  join 拼接 (将列表转化为字符串) print("_".join(["1","2","4"]))
  count 统计     strip脱去两端的空格换行以及制表符
  split 分割 (以空格和换行以及制表符进行分割，也可以以指定的方式进行分割)
  replace 替换 format 字符串格式化

判断系列（is）
   isdecimal 判断是否是十进制
   isalnum  判断是否是字母中文 数字
   isalpha 判断是否是字母中文
   isdigit 判断是否是全部是阿拉伯数字

列表（关键字：list）：它是以[]括起来，每个元素以逗号隔开，可以存放各种数据类型
可变有序的数据类型 支持索引，切片，步长和增删改查
列表的增：append insert extend
insert 方法用于将对象插入到列表中，而append方法则用于在列表末尾追加新的对象,
extend 把一个可迭代对象打开.每一项拿出来追加到list中 ,他们三个有个共同点就是没有返回值。
列表的删：remove pop del clear
1、 pop. 向外弹出最后一个或指定元素的索引，有返回值，可用一个变量接受被删除的内容,指定索引不存在时，会报错。
2、remove 指定元素进行删除 是元素不是索引，删除不存在的元素会报错。
3、 clear 清空列表
4、del 列表 将整个列表删除切片删除
del lst[1:3] 将指定切片范围内的元素进行删除
列表的改：索引、切片、步长
索引修改 li1 = [1, 2, 3, {'a':1, 'b':2}] li1[0] = 'a' # 改变1
切片修改（范围或区间）不带步长或者是步长为1的切片，则不用关心切片与修改的元素个数是否相等。
注意：步长不为1，要注意切片内的元素个数是否与更改的值是否相等。 如果步长不是1, 要注意. 元素的个数必须相同
列表的查：
for循环
列表的嵌套：[......] 视为一个元素

列表的其他：
1、count
查询列表中某个元素出现的次数
c = lst.count("太白") # 查询太白出现的次数
2、降序
lst.sort(reverse=True)
lis.sort(func=None, key=None, reverse=False(or True))
与sorted 的区别是sort是原地修改，只能用于列表，而sorted是返回一个新的序列，可以用在任意一个可迭代对象中
3、reverse
原地翻转
lst.reverse()
4、len
列表的长度

5、index
     返回从左到右列表中某个元素出现的第一个索引值

列表推导式
[变量(加工后的变量) for 变量 in 列表] 循环模式

列表sort()添加key和reverse参数操作方法
sort()是python列表排序方法，key和reverse更是经常用到的sort方法另外两个可选参数。使用时要通过关键字参数，也就是名字来指定。
key在sort()函数中的作用，使用时都需要提供可以做为排序依据的函数。比如说我们有一个列表，要以列表内元素的长度来排序，那么就需要用到计算长度的len()函数
x = ['hello','abc','iplaypython.com']
>>> x.sort(key=len)
>>> x
['abc', 'hello', 'iplaypython.com']
当然做为key排序依据的函数，不仅仅是len，只要按照你的需求写入对应的函数就可以。假如需要以整型数字来排序，就需要用到int：

    >>> a = ['3','188','50','1225']
    >>> a.sort(key=int)
    >>> a
    ['3', '50', '188', '1225']

    sort()还有另外一个关键字参数，就是reverse，它是一个布尔值True/False，作用是用来决定是否要对列表进行反向排序

        >>> a.sort(key=int,reverse=True)
        >>> a
        ['1225', '188', '50', '3']

l st = [1,23,4,5,7,8,9]
print(lst.index(4)) # 通过元素查找索引
lst.sort() # 排序 默认是升序
lst.sort(reverse=True) # 降序
print(lst)

        lst = [1,23,4,5,7,8,9]
        lst.sort()
        lst.reverse()             # 人工降序
        print(lst)

        lst = [1,23,4,5,7,8,9]
        lst.reverse()
        print(lst)               # 将源数据进行反转

        lst = [1,23,4,5,7,8,9]
        lst1 = lst[::-1]
        print(lst)
        print(lst1)              # 不修改源数据进行反转

        lst = [1,2,3,4]
        lst = lst + [1,2,3]
        print(lst)  # [1,2,3,4,[1,2,3],]   [1,2,3,4,1,2,3]

        lst = [1,2,3] * 5
        print(lst)
        print(id(lst[0]),id(lst[3]))

元组（关键字：tuple）：
有序，不可变数据类型（只有查）

range范围:
range（1,10）[起始位置：终止位置]顾头不顾尾，可迭代对象
range（1，10,2）[起始位置：终止位置：步长]
​ （10代表的是终止位置，起始位置默认为0）
range的诞生是为了解决不能循环数字

字典（关键字：dict）：所有的操作都是通过键
无序可变的数据类型
键：必须是不可变数据类型， 值是任意的

    字典的增：通过键值对添加（强加）
                       字典名['键]="值"
                      有则不加，无则不加
                        字典名.setdefault(键    , 值     )
    字典的删：pop  clear  del   字典中没有remove
                       字典名.pop()    通过字典的键进行删除
                       字典名clear()  清空整个列表
                       del.字典名[''键”]  通过键进行删除  
     字典的改                 
                   字典名['键]="值"
                    update
                        d={'x':5}
                        c={'12':65}
                        c.update(d)
                        print(c)

    字典的查
        dic.get("键") 查询不到返回None，查找不到的时候，返回自己制定的内容
        dic.setdefault(" 键 ")查询不到返回None
        print（dic.keys( ))    获取一个键高仿列表
        print（dic.values())获取一个值高仿列表
        高仿列表支持迭代，不支持索引
      for i in dic :
      print(i,dic[i])   打印键值
        lst.append(i,dic[i])

        for i in dic.items():
        print(lst(dic.items()))

    字典的其他：
        dic = {"key":1,"key1":2,"key2":4,"key3":1}
        print(dic.popitem())   # 随机删除  python3.6版删除最后一个键值对
        # popitem返回的是被删除的键值对
        print(dic)

集合（关键字：set） 集合就是没有值的字典（天然去重）
可变 无序的数量类型
一行代码去重
print(list(set(去重的内容))
集合的增：add(直接添加) update(迭代添加)
集合的删：remove(指定元素删除) clear（清空） pop（随机删，通常是最小的）
集合的改： 先删后加
集合的查： 只有for循环

集合的其他操作
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

交集

两个集合中的共有元素

print(s1 & s2) # {'⽪⻓⼭'}
print(s1.intersection(s2)) # {'⽪⻓⼭'}

并集

print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}

差集

print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
print(s1.difference(s2)) # {'赵四', '刘能'}

反交集

print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪⻓⼭"}

⼦集

print(s1 < s2) # set1是set2的⼦集吗? True
print(s1.issubset(s2))

超集

print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))

数据类型的各种转换

str -- int
int -- str
str -- bool
bool -- str
int -- bool
bool -- int

list -- tuple 元组
lst = [1,23,5,4]
print(tuple(lst))

tuple -- list
tu = (1,23,5,4)
print(list(tu))

list -- set
lst = [1,23,12,31,23]
print(set(lst))

set -- list

tuple -- set
tu = (1,2,3,4,5)
print(set(tu))

set -- tuple

目前字典转换,自己实现方法
例：有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 {'k':1,'k1':2,'k3':4}
dic = {}
a=a.split('|')
print(a)
for i in a:
print(i)
i=i.split(':')
dic.setdefault(i[0],int(i[1]))
print(dic)

字典和集合在遍历(循环)时不能修改原来的大小(字典的长度),可以进行修改值
s = {1,2,3,4,5,6}
for i in s:
s.pop()
print(s)