Python基础篇—序列

 序列

• 用于存放多个值的连续的内存空间，并且按一定的顺序排列，每一个位置分配一个数字，称为索引或位置

  1、索引

  • 左边开始的索引从0开始，右边开始的索引从-1开始

  2、切片

  • s[序列开始位置：序列结束位置（不包括该位置）：步长（默认为1）]

  • s[st:ed]//s[st-ed)
    

  3、序列相加

  • ‘+’实现两个序列拼接，只能拼接；两个相同类型的东西

  4、乘法

  • 可以实现序列重复拼接

  • 创建序列时可以指定长度

    list=[None]*2//[None,None],None表示什么都没有
    

  5、检查某个元素是否在序列中

  value (not) in sequence// Ture,False
  

  6、序列的内置函数

  //不会改变原序列，函数返回一个新的值，定义一个（字符/序列）类型去接收即可。
  len(s),max(s),min(s)
  list(s)//序列转换为列表
  str(s)//序列转换为字符串
  sum(s)//计算元素和
  sorted(s)//排序
  reversed(s)//反向序列中的元素
  /*
  s=[],s.reverse(),print(s),s原序列改变
  s=[],s1=reversed(s),s1是一个生成器对象，通过for循环访问，或者转换为list，tuple等类型。
  */
  enumerate(s)//将序列组合为一个索引序列，多用在for循环中
  

一、列表

• 可变序列，列表中的元素可以是整数，实数、字符串、列表、元组

  1、创建与删除

  s=[]//创建空列表
  s=list()//创建数值列表
  del s//删除列表
  

  2、访问列表元素

  print(s)//[,,]打印整体
  print(s[n])//打印单个元素
  s[st:ed]//通过切片访问
  

  3、遍历

  for item in s://遍历出来的是单个元素
  for index,item in enumerate(s)://遍历索引值，元素内容
  

  4、增、删、改

  //增
  s.append(item)//列表末尾追加元素item
  s.extend(s1)//将列表s1添加到s
  s.insert(index,item)//向指定位置添加元素
  //删
  del s[num]//根据索引删除
  s.remove(item)//根据内容删除;首先判断内容是否存在，s.count(item),计算元素出现的次数
  s.pop()//返回一个元素并删除
  //改
  s[num]=""//根据索引重新赋值
  

  6、对列表进行计算

  s.count(item)//item在s中出现的次数
  s.index(item)//item在s中首次出现的下标，如果元素不存在，会抛出异常
  sum(s[,start])//
  

  7、排序

  s.sort(key,reverse=(True:降序/False:升序))//这是一个语句
  /*key表示指定从每个元素中提取一个用于比较的元素，eg:key=str.lower,表示在排序时不区分大小写。
  对数值排序从小到大；对英文字母，先大写后小写；对汉字，按照第一个汉字首字母排序
  排序后，原列表元素顺序改变
  s=[],s.sort(),print(s),在原序列上排序
  */
  sn=sorted(s,key,reverse)
  /*排序后，原列表元素顺序不变,为排序后的元素建立一个副本
  s=[],s1=sorted(s),print(s1)即可。
  */
  s.reverse()//逆序
  

  8、列表推导式

  s=[Expression for val in range]//生成指定范围的数值列表
  ns=[Expression for val in list]//根据原列表生成指定需求的新列表
  ns=[Expression for val in list if condition]//从原列表中选择符合条件的组成新列表
  

  9、二维列表

  s=[[],[]]//根据元素内容创建
  s=[]//创建s[M][N]空列表
  for i in range(M):
  	s.append([])
  	for j in range(N):
  		arr[i].append(j)
  s=[[j for j in range(N)] for i in range(M)]//创建s[M][N]空列表，先确定列，再确定行
  

 二、元组

• 不可变序列，元素类型随便

  1、创建与删除

  t=(1,)//赋值直接创建，元组只有一个值时，不要忘记后面的’，‘
  t=()//创建一个空元组
  t=tuple()//创建数值元组
  del t//删除元素
  

  2、访问元组元素

  print(t)//打印整个元组
  t[num]//根据索引访问
  t[s:e]//根据切片访问
  for index,value in enumerate(t)//根据索引与内容访问
  

  3、修改

  nt=()//整个组重新赋值
  t=t+nt//连接一个元组，只能是元组
  

  4、元组推导式

  t=tuple(Expression for val in range())
  t=(Expression for val in range)
  /*
  元组推导式生成的结果是一个生成器对象
  访问元素通过t._next_(),类似于指针,遍历完不存在  
  通过 for i in t:，遍历完依旧不存在。
  */
  

  5、列表与元组的区别

  • 列表可变，它的元素可以随时修改，元组不可变，它的元素不可修改，除非整体替换
  • 元组比列表的访问和处理速度快
  • 元组可以作为字典的键，列表不能。

 三、字典

• 无序的可变序列，内容以“键-值”的方式存在，键是唯一的且不可变的，值可以有多个。

  1、创建与删除

  d={k:v,}//通过赋值直接创建
  d={}//创建空字典
  d={t:s}//通过已经存在的元组和列表创建字典，键只能是元组。
  d=dict()//创空，通过已有数据快速创建字典
  /*
  d=dict(zip(s,t))//使用zip函数将列表或元组对应位置的元素组合为元组
  d=dict(k=v,)//通过给定键值对创建
  d=dict.fromkeys(list)//创建值为空的字典
  */
  
  //删
  del d
  d.clear()//将字典变为空字典
  d.pop()//删除并返回指定“键”
  d.popitem()//删除并返回字典中的一个元素。
  

  2、访问字典

  print(d)//打印访问
  d[key]//通过键，如果指定的键不存在，则会抛出异常
  d.get(key)
  

  3、遍历字典

  d.items()
  /*
  获取字典的“键-值对”列表  
  for item in d.items():
  for key,value in d.items():
  */
  values()//返回字典值
  keys()//返回字典键
  

  4、增、删，改

  //增
  d[key]=value//当元素存在时，相当于修改
  //删
  del d[key]
  

  5、字典推导式

  与列表类似
  d={i:Expression for i in range}
  d={i:j for i,j in zip(s1,s2)}//使用列表导式
  

 四、集合

• 无序可变序列，集合有可变和不可变之分。

  1、创建

  s={item,}//输入重复元素，只会保留一个
  ##### s={}//创建空字典，不能创建空集合。
  //字典无序，每次输出的元素的排列顺序可能不同s=set()//创建集合并且也可将其他类型转换为集合
  

  2、增，删

  //增
  s.add(item)//元素只能是字符串、数字、布尔类型的
  //删
  s.remove(value)//元素不存在会抛出异常
  s.pop()//移除一个元素
  s.clear()//清空
  

  3、交集、并集、差集

  &-交
  |-并
  - 差
  

  4、列表、元组、字典、集合的区别

  数据结构	可变	重复	有序	符号
  列表（list）				[]
  元组（tuple）	否			()
  字典（dic）			否	{k:v}
  集合（set）		否	否	{}