python中对各类数据存储方式的操作

0 前言基础

1 科普关键字/函数/方法

关键字：del list[0]
函数：print("str") - print是一个函数
方法：list.append()方法是基于对象的基础上说的。

1 列表【List】

1.1 对列表的方法

查阅方法：在Ipython中.+tab可以获取对列表的所有操作
注：在windows下我的电脑没法进行命令补全，Ubuntu下则可以

增加：
- [].insert(index,data)
- [].append(data)
- [].extend(list2)
修改;
- [][index]= data
删除
- del \[][inedx]关键字
- [].remove[data]
- [].pop 删除末尾数据
- [].pop(indx) 指定索引删除
- [].clear清空
统计：
- len([])
- [].count(data)统计数据在列表中出现的次数
排序：
- 升序[].sort()
- 降序 [].sort(reverse = True)
- [].reverse() 逆序 [和降序不一样，降序根据首字母，逆序直接翻转]

1.2 应用场景：循环遍历

作为循环体：for name in list： print（name）
利用循环生成列表：[i for i in list]

2 元组【tuple】

可以保存不同类型的数据

2.1 应用场景：

⭐️ **list：**可以存放不同类型的数据，但是一般不用，在开发法中常用来存放相同数据，通过循环遍历做一点事情
元组有它特定的应用场景，因为不可修改、
1. 函数的参数和返回值
2. 格式化字符串：如print("%d %s",(xx,xx))传入的参数类型就是元组
3. 保护数据（修改时可以转换出来）
  - list（元组）
  - tuple（列表）

2.2 注意事项

注1：元组基本不会使用空元祖，因为无法修改
注2：(5)是整数型而非元组，(5,)才是元组
⭐️注3：一般开发中，不推荐使用tuple遍历，因为tuple默认保存的是一堆不同格式的内容，故无法确定取出数据的类型

3 字典格式

基本使用：
{key：value}特点：一一对应

3.1 对字典的方法

清空：dict.clear()
与其余字典合并：dict.update(new_dict)
增加：dict[“new_key”] = new_data
- 一一对应：当key相同时，后输入的date会修改

字典的遍历

默认取出的循环体是key

In [1]: card_list = {"name": "张三","qq": "12345", "phone": "110"}    

In [2]: for k in card_list: 
   ...:     print(k,card_list[k]) 
name 张三
qq 12345
phone 110

3.2 应用场景总结

有序：list存
无序：dict存

字典+列表：多个字典放在一个列表中**【实现：一个 Key 多个 Value 】**

card_list = [{"name": "张三","qq": "12345", "phone": "110"}, 
             {"name": "李四","qq": "54321", "phone": "10086"}]

4 字符串【str】

python中对于字符串的操作多到爆炸，保证了对于字符串操作的灵活性

学习与使用技巧：

重点还是TAB后直接看英文知道这个方法的含义

方法太多，根本记不下来，只能保存下来，用markdown做笔记了。

4.1 对字符串的方法

字符串变量可以用 + 拼接字符串
*可以重复相同的字符串
格式化字符串
- 方法一：print("%d" % 变量名)
- 方法二："{}".format(变量名)
- 注：可以控制
  - 前补零：print("06%d")，长度6，不足0补
  - 后补零：print(".06%f")，类型肯定为浮点型

4.2 规范化：

技巧：单引号与双引号都可以创建字符串
- 通常：使用双引号
- 若str文本中有双引号时，才使用单引号，避免转义

4.3 对字符串的索引

规则：
- 从头开始索引：开始可以省略
- 到末尾结束索引：结束可以省略
- 当索引值为负号，逆序索引
从索引 1 开始，每隔一个取一个：num_str[1::2]
字符串的逆序：num_str[::-1]

5 转换

首先思考可用for循环完成，如将标签 $y = [1,2,0,0,1,1,2]$ 转换为颜色字符串 $y = ["r","b","k","k","r","r","b"]$

[str(i).replace("1","r").replace("2","k").replace("0","b") for i in y ]

5.1 列表——》字符串

In [1]: list1 = ['1','2','3','4','a'] 
   ...: print(''.join(list1)) 
   ...: print(' '.join(list1)) 
   ...: print('!'.join(list1))                
1234a
1 2 3 4 a
1!2!3!4!a

5.2 列表——》元组

In [2]:  list1 = ['1','2','3','4','a',(1,2,3)] 
   ...:  tuple(list1)         
Out[2]: ('1', '2', '3', '4', 'a', (1, 2, 3))

5.3 列表——》字典

dict()里面要求的是映射关系，所以需要用zip把他们建立映射关系，再去转换

In [3]: list1 = ['1','2','3','4','a',(1,2,3)] 
   ...: list2 = ['a','b','c','d','e','f'] 
   ...: dict1 = dict(zip(list1,list2)) 
In [4]: print(dict1)                   
{'1': 'a', '2': 'b', '3': 'c', '4': 'd', 'a': 'e', (1, 2, 3): 'f'}

5.4 列表——》集合set

根据结合的要求，会把list中的相同元素去重。

In [5]: list1 = ['1','2','3','3'] 
   ...: set(list1)                                                                                          
Out[5]: {'1', '2', '3'}

5.5 元组——》列表

In [6]: tuple1 = (1,2,3,4,5,'2','a') 
   ...: list(tuple1)                                                         
Out[6]: [1, 2, 3, 4, 5, '2', 'a']

5.6 元组——》字符串

tuple和list函数要想转换成字符串，必须依靠‘ ’.join(tuple/list)来实现，要字符串型的要求

In [7]: tuple1 = ('1','2','3','4','5','2','a')  
   ...: ''.join(tuple1)                                                        
Out[7]: '123452a'

5.7 元组——》字典

也是通过zip实现map映射的

In [9]: tuple1 = ('1','2','3','4')  
   ...: tuple2= ('a','b','c','d') 
   ...: dict1 = dict(zip(tuple1,tuple2))  
In [10]: print(dict1)                                                        
{'1': 'a', '2': 'b', '3': 'c', '4': 'd'}

5.8 元组——》集合 set

In [11]: tuple1 = ('1','2','3','4')  
    ...: set(tuple1)             
Out[11]: {'1', '2', '3', '4'}

5.9字符串——》列表

字符串转换成list的时候，str可以作为迭代对象，直接放入；也可以使用split对字符串进行切割。然后返回list中去。

In [13]: s ='a1b1c1' 
    ...: print(list(s))   
    ...: print(s.split('1'))                            
['a', '1', 'b', '1', 'c', '1']
['a', 'b', 'c', '']

5.10 字符串——》元组

这里面没有split这个函数，因为split后会形成list

In [14]: s ='a1b1c1' 
    ...: tuple(s)               
Out[14]: ('a', '1', 'b', '1', 'c', '1')

5.11 字符串——》字典

其核心还是利用map建立映射关系

In [15]: s ='a1b1c1' 
    ...: b = '123456' 
    ...: dict(zip(s,b))       
Out[15]: {'a': '1', '1': '6', 'b': '3', 'c': '5'}

5.12 字符串——》集合 set

还是注意set会去重，并且set里面是可迭代的对象即可

In [16]: set('abca')                               
Out[16]: {'a', 'b', 'c'}

5.13 字典——》列表/元组/set

In [18]: dict1 = {1:'a',2:'b',3:'c'} 
    ...:  
    ...: print(list(dict1.keys())) 
    ...: print(list(dict1.values())) 
    ...: print(tuple(dict1.keys())) 
    ...: print(tuple(dict1.values())) 
    ...: print(set(dict1.keys())) 
    ...: print(set(dict1.values())) 
    ...: print(tuple(dict1.items()))  #生成元祖为单位的元祖 
    ...: print(list(dict1.items()))  #生成元祖为单位的列表 
    ...: print(set(dict1.items()))   #生成元祖为单位的集合  
[1, 2, 3]
['a', 'b', 'c']
(1, 2, 3)
('a', 'b', 'c')
{1, 2, 3}
{'b', 'a', 'c'}
((1, 'a'), (2, 'b'), (3, 'c'))
[(1, 'a'), (2, 'b'), (3, 'c')]
{(1, 'a'), (2, 'b'), (3, 'c')}

5.14 字典——》字符串

技巧在于：字典——》列表——》"".join(list)

In [33]: print(''.join(list(dict1.values()))) 
    ...: print(' '.join(list(dict1.values()))) 
    ...: print('!'.join(list(dict1.values())))                 
abc
a b c
a!b!c

5.15 集合set——》列表/元组

In [35]: set1 = {1,2,3,4,5,6} 
    ...: print(list(set1)) 
    ...: print(tuple(set1))                                        
[1, 2, 3, 4, 5, 6]
(1, 2, 3, 4, 5, 6)

5.16 集合set——》字符

路径：集合——》列表/元组——》字符

In [38]: set1 = {1,2,3,4,5,6}
In [39]: ["{}".format(i) for i in set1] 
Out[39]: ['1', '2', '3', '4', '5', '6']

5.17 集合——》字典

In [40]: set1 = {1,2,3,4,5,6} 
    ...: set2 = {1,2,3,4,5,6}                                               
In [41]: dict(zip(set1,set2))         
Out[41]: {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6}