python基础：列表，元组，字典，集合

学习记录(四):python容器：字符串，列表，元组，字典，集合（一）

• 基础概念

  变量：存储的是数据，在修改变量时，修改的是指向的内存地址，创建新的数据，变量给变量赋值，传递的是数据地址

  数据：数据是不可变的，如果没有变量指向它，即引用数量为0时，数据就会被销毁

  列表：由一系列变量组成的可变序列容器，有序，可以通过索引寻找到每个元素

  元组：由一系列表变量组成的不可变容器，有序，它的内存空间是按需分配的，所以不可以被修改（内部嵌套可变数据类型时，可以修改内部可变数据

  字典：由一系列键值对组成的可变散列容器，无序，可以看作是两个列表，根据键找值定位单个元素最快

  集合：由一系列不重复的不可变类型遍历(元组,数,字符串)组成的可变散列容器，无序

  可迭代对象：字符串，列表，元组，字典，集合都是可迭代对象

  容器基础内建函数：

  操作	函数
  返回序列长度	len(x)
  返回序列的最大值元素	max(x)
  返回序列的最小值元素	min(x)
  返回序列中所有元素的和（元素必须是数值类型）	sum(x)

• 字符串

  定义：由一系列字符组成的不可变序列容器,存储的是字符的编码值

通用运算

运算	功能
+	元素拼接
*	元素重复
== , != , < , >	比较
in , not in	成员运算

2.定位

操作	语法	举例
通过索引定位单个字符	字符串[编号]	print(msg[1]
通过切片定位多个字符	字符串[开始：结束：间隔]	print(msg[0:3:1])

注：1.容器名[开始:结束:间隔],不包含结束  print(msg[0:3:1])
	2:容器名[开始:结束],间隔默认为1   print(msg[0:3])
	3.容器名[:结束],开始默认为0   print(msg[:3])
	4.容器名[:],结束默认为末尾   print(msg[:])

• 列表

定义：由一系列表变量组成的可变容器，创建列表时会自动预留空间,列表没有空间上限,能够自动扩容

1.创建列表

创建的方法分为两种：根据元素创建以及根据可迭代对象直接转化

操作	语法	举例
根据元素创建列表	列表名=[元素1，元素2，…元素n]	list01=["a","b","c"]
根据可迭代对象转换	列表名=list(可迭代对象)	list02=list("创建列表")

2.添加元素至列表

添加元素至列表的方法有两种：追加和插入

操作	语法	举例
追加元素到列表	列表名.append(元素)	list01.append("d")
插入元素到列表	列表名.insert(插入位置，插入元素)	list02.insert(0,"插入")

3.定位元素

定位元素分为通过索引单个元素以及通过切片定位多个元素

操作	语法	举例
索引（定位单个元素）	列表[编号]	print(list01[0])
切片（定位多个元素）	列表[开始编号：结束编号：间隔]	print(list01[1:3:1])

注：切片以及索引都能够对列表进行遍历，但是切片和索引的操作不一样，切片是将数据从列表中取出，会创建一个新的列表

4.遍历

根据查找顺序分为正序查找和倒序查找

# 从头到尾获取数据
for item in list_name:
     if(item[0]==item[-1]):
          print(item)
for item in list_name[::-1]:
     print(item)

 # 倒序查找数据
 for i in range(len(list_name)-1,-1,-1):
     print(list_name[i])

注：根据索引和item都能遍历列表，但是通过item遍历时只能读取元素，不能同时进行修改；根据索引遍历时，可以修改

5.删除元素

删除列表元素可以根据元素删除，也可以根据索引删除

操作	语法	举例
根据元素删除	列表名.remove(元素)	list01.remove("a")
根据索引删除	del 列表名[编号]	del list01[1]

• 元组

  定义：由一系列表变量组成的不可变容器，内存空间按需分配

  1.创建元组

  操作	语法	举例
  根据元素创建元组	元组名（元素1,元素2,…,元素n）	tuple01=("星期一","星期二")
  根据可迭代对象创建元组	元组名=tuple(可迭代对象)	tuple02=(list01)

  注:1.创建元组的括号在没有歧义的情况下可以省略
       tuple_week="星期一","星期二","星期三"`
     2:如果元组中只有一个元素,必须加逗号
       tuple_week=(10,)
  

  2.定位

  操作
  通过索引定位元组元素	元组名（编号）	tuple[0]
  通过切片定位元组元素	元组名[开始：结束：间隔]	tuple[1:3:1]

  3.遍历

  # # 遍历
  for item in tuple_week:
       print(item)
  　　 print(len(tuple_week))
  for i in range(len(tuple_week)-1,-1,-1):
        print(tuple_week[i])
  

• 字典

  定义:由一系列键值对组成的可变散列容器

  1.创建字典

  操作	语法	举例
  根据键值对创建字典	字典名={键1:值1,键2:值2,…,键3:值3}	dic_01={"name":"李同学","age":"19","sex":"女"}
  根据可迭代对象创建字典	字典名=dict(可迭代对象)	print(dict(list01))

  2.定位、修改、添加

  语法：字典[键]=值

    注：1.字典内的元素是无序的，因此没有编号，只能根据键找值（或者根据值找键，但是根据键找值更快）
        2.修改的语法和添加的一样，字典内存在该键的时候是修改，不存在的时候是添加**
  

  dic_01={"name":"李同学","age":"19","sex":"女"}`
  # 根据键找值
  if "name" in dic_01:
      print(dic_01["name"])
  # 根据值找键（不常用）
  # 思路:查看所有的键和值
  for k,v in dic_01.items():
      if v=="19":
          print(k)
  # 添加:字典[键]=值
  if "height" not in dic_01:#判断原来字典里有没有
       dic_01["height"]=170
  

  3.遍历

  可以通过遍历获取字典的键，值，或者键与值

  dic_01={"name":"李同学","age":"19","sex":"女"}`
  # 获取所有的key
  for key in dic_01:
       print(key)
  #获取所有的value
  for value in dic_01.values():  #values函数获得字典里的值
      print(value)
  # 获取所有的key和value,items()函数,获得的是一个元组(键,值)
  for  item in dic_01.items():
           print(item)
  for k,v in dic_01.items():
      print(k)
      print(v)
  

• 集合

  定义：由一系列不重复的不可变类型遍历(元组,数,字符串)组成的可变散列容器

  1.创建集合

  操作	语法	举例
  根据元素创建集合	集合名={元素1,元素2,…,元素n}	set01={"小李","小王","小刘","小李"}
  根据可迭代对象创建集合	集合名=set(可迭代对象)	set02=set(list01)

    注：1.集合内的元素是不重复的，即使在创建的时候添加了相同的元素，在集合中也只存在一份
       2.创建集合的符号也是大括号（和字典一样），但是创建空集合的时候不能用大括号，用的是小括号:`set01=set()`
  

  2.添加元素到集合

  语法：集合名.add(元素)

  ​ set02.add("小赵")

  3.遍历

  for item in set01:
       print(item)
  

4.删除元素

操作	语法	举例
删除元素（集合内不存在会报错）	集合名.remove(元素)	set01.remove("小王")
删除元素（集合内不存在也不会报错）	集合名.discard(元素)	set01.dicscard("小黄")

5.集合数学运算

操作	语法	举例
交集	集合1&&集合2	print(s1&s2)
并集	集合1|集合2	`print(s1
补集	集合1-集合2	print(s2-s1)