python基础_基础数据类型(序列)

变量除了数字型，还有序列类型。序列类型主要包括列表(list)、元组(tuple)、字典(dict)、集合(set)。字符串也是一种序列类型（支持for遍历、不可修改）

目标了解序列型变量的特点及基本操作，并能进行类型转换

序列类型变量特点

序列类型变量赋值

备注1：seq指序列类型，包括list、tuple、dict、set、str（字符串可以认为是特殊的元组）

基本操作(增删改查)

1 list

 ========增=========
 a_list.append(3)
 #在末尾追加
 a_list.insert(3,'a')
 #在指定位置插入
 a_list.extend(b_list)
 #将列表b_list中的元素添加到a_list后面
 
 ========删=========
 a_list.remove(3)
 #删除第一个匹配项，若元素不存在则报错
 a_list.pop()
 #删除最后一个元素并返回该元素
 
 ========改=========
 a_list[2]=12
 #单元素修改
 a_list[2:3]=[12,13]
 #多元素修改
 a_list.sor(reverse=True)
 #a_list进行排序处理，不返回内容，reverse设置为True表示倒序，False为正序
 sorted(a_list,reverse=False)
 #对a_list进行排序处理并返回结果，reverse设置为True表示倒序，False为正序
 a_list.reverse()
 #对列表进行反转处理
 
 ========查=========
 a_list.index(1)
 #获取指定元素第一次出现的位置
 1 in a_list
 #判断指定元素是否在a_list中
 a_list.count(3)
 #计算a_list中指定元素出现的次数
复制

2 tuple

 ========增=========
 不可新增
 
 ========删=========
 del a_tuple
 #删除整个元组，而非删除元组中元素
 
 ========改=========
 #不可修改
 
 ========查=========
 a_tuple[0]
 #获取指定元素
 a_tuple[1:3]
 #获取指定范围的元素，获取的结果依旧是元组
 max(a_tuple)
 #获取元组中的最大值，只支持同类型比较
 min(a_tuple)
 #获取元组中的最小值，只支持同类型比较
 1 in a_tuple
 #判断元素是否在元组中
复制

3 dict

 ========增=========
 a_dict.setdefault('name','lin')
 #若键不存在字典中，则新增键值对；否则返回对应的值
 a_dict.update(b_dict)
 #将字典b_dict中的键值对添加到a_dict中
 
 ========删=========
 a_dict.pop(3)
 #删除指定键值对并返回；若不存在则报错
 a_dict.popitem()
 #随机删除键值对，并返回
 del a_dict[3]
 #删除指定键值对无返回；若不存在则报错
 a_dict.clear
 #清空字典中所有元素
 
 ========改=========
 dict['name']='Lin'
 #修改某个键值对的值
 
 ========查=========
 dict1['name']
 #查询某个键值对的值，若不存在则报错
 dict2.get('name',0)
 #查询某个键值对的值，若不存在则返回默认值
 ’name‘ in dict3.keys()
 #查询某个键是否存在
复制

4 set

 ========增=========
 a_set.add('1')
 #添加元素
 a_set.update(b_set)
 #将集合b_set中的元素添加到集合a_set
 
 ========删=========
 a_set.discard(6)
 #删除指定元素，元素不存在不报错
 a_set.remove(6)
 #删除指定元素，元素不存在则报错
 a_set.pop()
 #随机删除一个元素并返回
 a_set.clear()
 #清空集合
 
 ========改=========
 a_set.intersection_update(b_set)
 #将a_set与b_set的并集赋值给a_set
 a_set.difference_update(b_set)
 #将a_set与b_set的差集赋值给a_set
 set1.symmetric_difference_update(set2)
 #获取a_set与b_set的对称差集赋值给a_set
 
 ========查=========
 x in a_set
 #判断元素是否在集合a_set中
 a_set.issubset(b_set)
 #判断a_set是否是b_set的子集，超集则是issuperset
 a_set.union(b_set)
 #获取a_set和b_set的并集，不影响a_set与b_set，类似的还有differenct(差)、intersection(交)、symmetric_defference(对称差)
复制

类型转换

#a_str.join(seq),只适用于元素为字符串，a_str用于保存拼接之后的字符串

1 str

 >>> print(a_list,type(a_list),str(a_list),type(str(a_list)))
 [1, 2, 3, 4, 5] <class 'list'> [1, 2, 3, 4, 5] <class 'str'>
 #seq->str:会先将值转为标准的seq表达式(包括list、tuple、dict、set)，然后直接转为字符串
 
 >>> a_list
 ['1', '2', '3']
 >>> a_str=''
 >>> a_str.join(a_list)
 '123'
 #a_str.join(seq):当元素为字符串时可以将元素合并并赋值给a_str
复制

2 list

 >>> print(a_str,list(a_str))
 12345 ['1', '2', '3', '4', '5']
 #str->list:将每个字符转为list中的元素
 
 >>> list(b'hello')
 [104, 101, 108, 108, 111]
 #bytes->list:取每个字节的ASCII十进制值并组合成列表。
 
 >>> print(a_tuple,list(a_tuple))
 (1, 2, 3) [1, 2, 3]
 #tuple->list:元组中每个元素转换为列表中的元素
 
 >>> print(a_dict,list(a_dict))
 {'name': 'lin', 'sex': 'man'} ['name', 'sex']
 #dict->list:取字典中每个键值对的键做为列表中的元素
 
 >>> a_set={1,2,3,4,4,4,4,4}
 >>> print(a_set,list(a_set))
 {1, 2, 3, 4} [1, 2, 3, 4]
 #set->list:先去重再转成列表。由于集合不可重复，去重在赋值时已完成
复制

3 tuple

 >>> print(a_str,tuple(a_str))
 123456 ('1', '2', '3', '4', '5', '6')
 #str->tuple:将每个字符转换成元组中的元素
 
 >>> print(a_list,tuple(a_list))
 ['1', '2', '3'] ('1', '2', '3')
 #list->tuple:将list中的元组转成元组中的元素
 
 >>> print(a_dict,tuple(a_dict))
 {'name': 'lin', 'sex': 'man'} ('name', 'sex')
 #dict->tuple:将字典键值对中的键转成元组中的元素
 
 >>> a_set={1,2,3,4,4,4,4,4}
 >>> print(a_set,tuple(a_set))
 {1, 2, 3, 4} (1, 2, 3, 4)
 set->tuple:集合去重之后转成元组中的元素。由于集合不可重复，去重在赋值时已完成
复制

4 dict

 >>> a_str="{'name':'lin','age':12}"
 >>> import ast
 >>> ast.literal_eval(a_str)
 {'name': 'lin', 'age': 12}
 #str->dict:若使用json需确保所有的键值都用单引号包围、若使用eval则会执行任何符合语法的表达式字符串，存在安全隐患
 
 >>> print(a_list,b_list,dict(zip(a_list,b_list)))
 ['name', 'age'] ['lin', 12, 'man'] {'name': 'lin', 'age': 12}
 #list->dict：合并两组列表作为字典；第一组为键，第二组为值；若键重复则后面的覆盖前面的。
 若list中的元素为两个元素的list，则可以直接使用dict(list)进行转换
 
 >>> print(a_tuple,b_tuple,dict(zip(a_tuple,b_tuple)))
 ('name', 'age') ('lin', 12, 'man') {'name': 'lin', 'age': 12}
 tuple->dict#合并两组元组作为字典；第一组为键，第二组为值；若键重复则后面的覆盖前面的。
         若元组中的元素为两个元素的元组，则可以直接使用dict(tp)进行转换
   
 >>> print(a_set,b_set,dict(zip(a_set,b_set)))
 {'name', 'age'} {12, 'lin', 'man'} {'name': 12, 'age': 'lin'}
 #set->dict:合并两个集合作为字典，第一组为键，第二组为值
复制

5 set

 >>> print(a_str,set(a_str))
 123133 {'1', '2', '3'}
 #str->set:先将字符切割成元组，然后去重转换为集合
 
 >>> print(a_list,set(a_list))
 [1, 2, 1, 2, 1, 2] {1, 2}
 #list->set:先对列表去重，然后转换为集合
 
 >>> print(a_tuple,set(a_tuple))
 (1, 2, 1, 2, 1, 2) {1, 2}
 #tuple->set:先对元组去重，然后转换为集合
 
 >>> print(a_dict,set(a_dict))
 {'name': 'lin', 'xb': 'boy'} {'name', 'xb'}
 #dict->set:取字典的键名组合成集合
复制