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)

你可能感兴趣的:(python,rpc,开发语言)