Python数据结构常用方法

1. Integer类型

1. a + b
2. a - b
3. a * b
4. a ** b  
    a的b次方，同pow(a, b)
5. a / b
    a除以b，5 / 2 = 2.5
6. a // b
    a除以b，去掉余数， 5 // 2 = 2， 5.1 // 2 == 2.0
7. abs(a)
    取绝对值
8. divmod(a, b)
    以二元组形式返回商和a对b的取余数（a%b）
    divmod(5, 2) = (2, 5)
9. pow(a, b)
    a的b次方
10. pow(a, b, c)
    a的b次方，然后对c取余 (a ** b) % c
11. round(a, b)
    对a进行四舍五入，保留b位小数点
12. bin(a)
      返回a的二进制表示 bin(255) = "0b11111111"
13. hex(a)
      返回a的十六进制表示 hex(255) = "0xff"
14. int(a)
      可以把str, float, 八进制，十六进制，二进制转化为10进制整数
      int(0x1111) = 15
      int(10.999) = 10
      int("10") = 10
15. oct(a)
    返回a的八进制表示 oct(10) = 0o12
16. sys.float_info.epsilon
      机器可区分的浮点数的最小区别

2. str字符串

str = "hello world"  
1. for c in str:
    iterable
2. str[0:2] = "he"
    str[0:4:2] = "hl"
    str[2:] = "llo world"
    str[:2] = "he"
    str[::2] = "hlowrd"
    str[-2] = "l"
3. str.capitalize()
    首字母大写，其他字母小写 "hELLo".capitalize() = "Hello"
4. str.count(c, start, end)
    str中，子字符串c出现的次数
5. str.endswith(c, start, end)
    str或者str的分片是否以c结尾
6. str.startswith(c, start, end)
    str或者str的分片是否以c开始
7. str.expandtabs(size)
    str中的制表符使用8个或者size个空格替换，"\ta".expandtabs(10)
8. str.find(c, start, end)
    返回c第一次在str中出现的位置，没有找到返回-1
9. str.format()
    格式化
    "{0} is a {1}".format("she", "girl")
    "{0[0]} is a {0[1]}".format(("She", "girl"))
    "{who} is a {what}".format(who="She", what="girl")
    格式化的时候，!s对应__str__, !a对应__ascii__, !r对应__repr__
10. str.index(c, start, end)
    同str.find()，但是找不到会抛出ValueError
11. str.isalnum()
    str非空，且每个字符都为字母数字
12. str.isalpha()
    str非空，且每个字符都为字母
13. str.isnumeric()
          True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
          False: 无
          Error: byte数字（单字节）
      str.isdecimal()
          True: Unicode数字，，全角数字（双字节）
          False: 罗马数字，汉字数字
          Error: byte数字（单字节）
      str.isdigit()
          True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
          False: 汉字数字
          Error: 无
14. str.islower()
      str非空，且都是小写
      str.isupper()
      str非空，且都是大写
      str.istitle()
      str非空，且首字母大写，其他小写
15. str.join(seq)
      "-".join(("1991", "8", "6")) = 1991-8-6
16. str.ljust(width, c)      左对齐，用c填充
      str.rjust(width, c)      右对齐，用c填充
      str.center(width, c)    中间对齐，用c填充
17. str.replace(t, u, n)
      将字符串中的t换成u，最多替换n次
18. str.split(c, n)
      将字符串以c分割，最多分割n次
19. str.strip(chars)
      去除str前后的空白字符（或者chars中的字符）
20. str.swapcase()
      交换字符串的大小写
21. str.title()
      str首字母大写，其他字母小写
22. str.lower()    小写
      str.upper()    大写
23. str.zfill(w)  
      用0填充str到长度w
24. ord(c)
      返回字符c的ASCII码
25. chr(ascii)
      返回ascii对应的字符

3. list列表

lst = list()
1. lst.append(x)
2. lst.count(x)
3. lst.extend(lst2)
    相当于 lst += lst2
4. lst.index(x, start, end)
    x首次出现的位置， 不存在抛出ValueError
5. lst.insert(index, x)
    在index处插入x，如果index > len(lst)，则在末尾插入
6. lst.remove(x)
    删除首次出现的x，如果不存在抛出ValueError
7. lst.pop(i)
    删除i处的数据，如果i >= len(lst)， 抛出IndexError
8. lst.pop()
    删除最后一个
9. lst.sort(reverse=True, key=lambda x: x%3)
10. 列表内涵
      lst = [x for x in range(1900, 2017) if (x % 4 ==0 and x % 100 != 0) or (x % 400 == 0)]

4. set集合类型

s = set()
1. s.add(x)
2. s.clear()
3. s.copy()
    浅拷贝
4. s.difference(t)  s-t，在s中，但不在t中的
5. s.difference_update(t)
    移除s中的既在t中，也在s中的 {1,2}.difference_update({1, 5}) = {2}
6. s.intersection(t) s&t，在s中，也在t中
    s.intersection_update(t) 使得s中，只包含s与t的交集 {1,2}.intersetion_update({1,5}) = {1}
7. s.union(t) s | t， 并集，s与t的并集
8. s.update(t) 
    使得s包含s与t的并集
9. s.symmetric_difference(t)
    返回不同时在s和t中的集合 {1, 2, 3}.symmetric_difference({1, 4, 5})  = {2, 3, 4, 5}
10. s.symmetric_difference_update(t)
    使得s等于不同时在s和t中的所有项的集合
11. s.isdisjoint(t)
    如果s和t没有相同的项，返回True
12. s.issuperset(t) s是否是t的超集
13. s.issubset(t)  s是否是t的子集
14. s.pop()
      移除s的一个随机项，（第一项）
15. s.remove(x)
      移除x

5. 字典dict

d = dict() || d = {}
1. d.clear()
2. d.copy()
    浅拷贝
3. d.fromkeys(list, value)
    添加list数据作为key，值为value || None
4. d.get(k)
    如果不存在k，返回None
5. d.get(k, v)
    如果不存在k，返回v
6. d.items()
    返回(key, value)值对
    for key, value in d.items():
      print(key, value)
7. d.keys()
    返回所有的键
8. d.pop(k)
    如果k在d中，返回并移除，如果不存在，抛出KeyError
9. d.pop(k, v)
    如果k在d中，返回并移除，不存在，返回v
10. d.popitem()
    随机移除并返回一个键值对，如果为空，抛出KeyError
11. d.setdefaut(k, v)
    如果存在，返回d[k]， 如果不存在，设定d[k] = v
12. d.update(a)
    更新字典，a可以是字典，元祖对，或者key=value
13. d.values(a)
    获取字典所有的值
14. 字典内涵：
      ``` 
      def  asc(start, end):
          while(ord(start) <= ord(end)):
              yield start
              start = chr(ord(start) + 1)    
      d = {k: "we are default" in asc('a', 'c')}
      ```
      ```
      m = lambda x: [v for v in asc(x, "z")]
      d = {k: m(k) for k in asc("a", "c")}
      ```