python 的与众不同 --序列篇

序列（sequence）

• 序列是Python中最基本的一种数据结构
  • 数据结构指计算机中数据存储的方式
  • 序列的分类：
    可变序列：
    列表（List）
    不可变序列：
    字符串（str）
    元组（tuple）

常用函数

• 使用 in 检查某元素是否在列表中
• 使用 not in 检查某元素是否不在列表中
• 使用 len() 获取列表中元素个数
• 使用 min() 获取列表中最小值
• 使用 max() 获取列表中最大值
• s.index(x) 获取元素在列表中的索引，没有抛异常
• s.count(x) 获取元素在列表中出现的次数
• s.pop() 删除并返回
• s.remove(x) 删除指定元素
• s.clear() 清空

列表（list）

• 通过[]来创建列表
• 列表中对象会按照插入顺序存储
• 列表中对象是 Object类型
• 索引是列表中元素位置，从0开始，可以使用索引取出数据
• 如果索引是负数，表示是从后往前取，从-1开始
• 取出数据 ：list[0]
• 列表长度：len(list)

截取 切片

• 语法：列表[起始:结束]
  • 前开后闭规则，
    如：list[1:4]是从索引第一个开始截取到第4个，但不包含第4个，一共截取3个元素
• 语法：列表[起始：结束：步长]
  • 步长是截取列表时查找规则，默认为1。

    mlist = [1,2,3,4,5,6,7,8,9,10]
    print(mlist[0:5:2])
    # 打印：[1, 3, 5] 
    # 原因是步长为2，两个两个读取
    

  • 步长不可以为0，但可以为负数，负数就是倒着取

    print(mlist[::-1])  反转
    打印：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    

拼接

• 使用 + 可以将两个列表拼接成一个列表
• 使用 * 可以将列表重复指定次数

修改

• list[索引] = Value
• 切片修改 mlist[0:2] = [11,12,13,14]

  如果有步长，则要求替换列表元素个数统一

删除

• del list[索引]
• list.clear() 清空
• list.pop(索引) 删除指定元素 并 返回删除元素
• list.remove(元素) 删除第一个值得元素

增加

• 列表 + [元素] 添加到最后
• list.append(元素) 添加到最后
• list.insert(索引，元素) 指定位置插入元素
• list.extend（list） 添加多个元素

反转

• list[::-1] 使用切片方法完成反转
• list.reverse() 使用函数完成反转

排序

• list.sort() 默认升序排列
  list.sort(reverse=True) 降序排列
  list.sort(key=len) 字符串长度排序
  list.sort(key=str) 同意转换为字符串排序
• list.sorted() 对任意类型排序
  排序后返回新的列表

遍历

• while循环遍历

  i = 0
  while i < len(array) :
     print(array[i])
     i += 1
  

• for 循环遍历
  • 语法：for 变量 in 序列： 代码块
    只要是序列就可以只用for进行遍历
    如使用for可以遍历字符串

  for v in 'asdfg' :
      print(v)
  

  • 遍历列表

  for v in array : 
      print(v)
  

range() 函数得使用

• range()函数可以用来生成一个自然数序列,有单个参数
  第一个参数 – 起始位置，默认是0
  第二个参数 – 结束位置
  第三个参数 – 步长，默认是1
• 通过range()可以创建一个执行指定次数的for循环

  for i in range(10) :
      print(i)
  

元组（tuple）

• 通过()来创建列表,创建元组时可以省略()
• 不可变的序列
• 操作上基本和列表一致
• 元组不为空时，至少有一个逗号

  my_tuple = (1,2,3,4,5,6)
  my_tuple = 1,2,3,4,5,6
  my_tuple = 1,
  

• 元组解包（结构）

  my_tuple = 10,20,30,40
  a,b,c,d = my_tuple
  

• 交换a，b值可以利用元组的解包来完成

  a,b = b,a
  print(a,b,c,d)
  print(my_tuple)
  

• 元组解包时，变量数量必须和元组元素的数量一致
  也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余元素

  a,b,*c = my_tuple
  print(a,b,c) #c是一个数组
  

• 解包 所有序列都可以使用解包

可变对象

• 可变对象就是可以修改对象值

  # 无论如何修改对象，对象id始终没有改变（内存地址没有改变）
  a = [11,12,13,14]
  print(f'原始数据a   ：{a} id={id(a)}')
  
  a[0] = 20
  print(f'修改后数据a ：{a} id={id(a)}')
  
  b = a
  print(f'赋给变量b   ：{b} id={id(b)}')
  
  b[1] = 21
  print(f'b修改后打印a：{a} id={id(a)}')
  print(f'b修改后打印b：{b} id={id(b)}')
  
  a[2] = 22
  print(f'a修改后打印a：{a} id={id(a)}')
  print(f'a修改后打印b：{b} id={id(b)}')
  

字典（dict）

• 通过{}来创建字典,也可以使用dict创建
• 键值对（key = value）结构
• 键（key）不可重复，如果重复就会被覆盖掉前面的
• 字典属于一种新的数据结构，称为映射（mapping）
• 字典和列表相似，都是用来存储对象的容器
• 列表存储数据性能好，但查询性能差
• 字典中每一个元素都有一个唯一的名字，通过名字可以快速的查找到指定元素
• 查询元素时，字典的效率非常高

  my_dict = {'name':'张三'，'age':'15'}
  my_dict = dict(name = 'zhangsan',age = '23')
  
  # 也可以将双值序列转为字典
  
  array = [['name','王五'],['age',35]]
  my_dict = dict(array)
  print(my_dict)
  
  # 修改字典
  print(my_dict['name'])
  

遍历字典

• 通过keys()获取所有键

  my_dict = {'name':'张三','age':'15'}
  keys = my_dict.keys()
  
  for k in keys :
      print(k,my_dict[k])
  

• 通过values()获取所有值

  values = my_dict.values()
  for v in values:
      print(v)
  

• 通过items()获取键值对序列

  items = my_dict.items()
  #因为值键值对，所以用两个变量接收
  for k,v in items:
      print(k,v)
  

集合（set）

• 使用{}创建集合，也可以使用set()
• 不可变对象
• 存储对象不是按照插入顺序存储的（无序的）
• 不可重复
• 集合中只能存贮不可变对象
• 可将列表、元组、字典(转换后只存在键)直接转为集合

  s = set(x)
  # 添加元素
  s.add(x)
  # 添加一个集合
  s.update(列表、元组、字典、集合)
  # 删除
  s.pop # 随机删除一个元素 有返回值
  s.remove(x) # 删除指定元素
  

集合运算

• 集合运算时不会影响原来的集合，会返回一个新的集合
• & 交集

  s1 = {1,2,3,4,5,6}
  s2 = {4,5,6,7,8,9}
  print(s1 & s2) # 返回{4, 5, 6}
  

• | 并集

  s1 = {1,2,3,4,5,6}
  s2 = {4,5,6,7,8,9}
  print(s1 | s2) # 返回{1, 2, 3, 4, 5, 6, 7, 8, 9}
  

• -差集

  s1 = {1,2,3,4,5,6}
  s2 = {4,5,6,7,8,9}
  print(s1 - s2) # 返回{1, 2, 3}
  

• ^ 异或集

  s1 = {1,2,3,4,5,6}
  s2 = {4,5,6,7,8,9}
  print(s1 ^ s2) # 返回{1, 2, 3, 7, 8, 9}
  

• '<= 检查是否为子集
• '>= 检查是否为超集
• '< 检查是否为真子集
• '> 检查是否为真超集
  为保证符号正常显示添加了’符号，使用请注意