系统定制开发python读取json格式文件大量数据，以及python字典和列表嵌套用法详解

1.Python读取JSON报错:JSONDecodeError:Extra data:line 2 column 1

错误原因：

  • JSON系统定制开发数据中数据存在多行，系统定制开发在读取数据时，系统定制开发不能够单单用open()，应利用for循环：
  • 可能存在系统定制开发换行符问题导致的

大量数据，系统定制开发里面有多行多列，系统定制开发出现类似标题报错
raise JSONDecodeError(“Extra data”, s, end)
json.decoder.JSONDecodeError: Extra data: line 2 column 1 (char 104)

解决方法：

系统定制开发可以逐行读取，系统定制开发然后再处理成列表

  1. json_data=[]
  2.  
  3. for line in open('多列表.json', 'r', encoding='utf-8'):
  4.  
  5.     json_data.append(json.loads(line))
  1. import json
  2.  
  3. # 系统定制开发由于文件中有多行，系统定制开发直接读取会出现错误，系统定制开发因此一行一行读取
  4. file = open("papers.json", 'r', encoding='utf-8')
  5. papers = []
  6. for line in file.readlines():
  7.     dic = json.loads(line)
  8.     papers.append(dic)
  9.  
  10.  
  11. print(len(papers))

2.python 系统定制开发如何读取列表中字典的value值

  1. list = [{"name": "推荐食谱", "1": "症状", "name1": "系统定制开发系统定制开发浑身忽冷忽热"}, {"name": "系统定制开发系统定制开发绿豆薏米饭"}, {"name": "芝麻"}]
  2. res = [item[key] for item in list for key in item]
  3. print(res)
  4. for item in list:
  5.    for key in item:
  6.       print(item[key])

  1. list = [{"name": "推荐食谱", "1": "症状", "name1": "浑身忽冷忽热"}, {"name": "绿豆薏米饭"}, {"name": "芝麻"}]
  2. res = [item[key] for item in list for key in item]
  3. print(res)
  4. for item in list:
  5. 	for k,v in item.items():
  6. 		print(k,v)

 系统定制开发获取字典的key和value

系统定制开发以迭代的方式，系统定制开发默认情况下，系统定制开发字典迭代的是key，key相当于item里面的[0]位置，value是[1]位置

  • a.items()
  • key=a.items[0]
  • value=a.items[1]
  1. for item in dict.items():
  2.     key = item[0]
  3.     value = item[1]

系统定制开发打印每一个key

  1. a = {'a':1,'b':2,'c':3}
  2. for item in a.items():
  3.     print(item[0])
  4. >>>
  5. a
  6. b
  7. c

打印每一个value

  1. a = {'a':1,'b':2,'c':3}
  2. for item in a.items():
  3. 	print(item[1])
  4. >>>
  5. 1
  6. 2
  7. 3

不通过dict.item()这个函数，直接利用默认迭代是key这个特性,可以直接迭代

  1. >>> dict = {'a': 1, 'b': 2, 'c': 3}
  2. >>> for key in dict:
  3. ...     print(key)
  4. ...
  5. a
  6. c
  7. b

第二种方式，如果要迭代value，可以用a.values()，这个是找值，找键是a.keys()

  1. a = {'a':1,'b':2,'c':3}
  2. for value in a.values():
  3.     print(value)
  4. >>>
  5. 1
  6. 2
  7. 3
  8. for key in a.keys():
  9. 	print(key)
  10. >>>
  11. a
  12. b
  13. c

第三种，如果要同时迭代key和value，可以用for k, v in d.items()。

  1. a = {'a':1,'b':2,'c':3}
  2.  
  3. for k,v in a.items():
  4.     print(k)
  5.     print(v)
  6. >>>
  7. a
  8. 1
  9. b
  10. 2
  11. c
  12. 3

输出全部的key和value，但不是list格式

  1. a = {'a':1,'b':2,'c':3}
  2. print(a.values())
  3. >>> dict_values([1, 2, 3])
  4. print(a.keys())
  5. >>>dict_keys(['a', 'b', 'c'])

如果要变成list列表，转换类型即可

  1. list(a.keys())
  2. >>>['a', 'b', 'c']

3.python字典和列表嵌套用法详解

3.1 列表(List)

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

列表是最常用的，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

特点就是：可重复，类型可不同

常用方式

创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可。如下所示：

  1. list1 = ['apple', 'banana', 2008, 2021]
  2. list2 = [1, 2, 3, 4, 5 ]
  3. list3 = ["a", "b", "c", "d"]
  4.  
  5. ### 向list中增加元素
  6. list1.append(3)   ## ['apple', 'banana', 2008, 2021, 3]
  7.  
  8. ### 使用extend用来连接list
  9. list1.extend([7, 8])  ##['apple', 'banana', 2008, 2021, 3, 7, 8]
  10.  
  11. ### insert 将单个元素插入到list中
  12. list3.insert(2, 'q')   ##['a', 'b', 'q', 'c', 'd']
  13.  
  14. ### 获取列表的长度
  15. print(len(list1))   ## 5
  16.  
  17. ### 遍历list
  18. for name in list1:
  19.     print(name)

extend(扩展)与append(追加)的看起来类似，但实际上完全不同。

  • extend接受一个参数，这个参数总是一个list，并且把这个list中每个元素添加到原list中。
  • append接受一个参数，这个参数可以是任何数据类型，并且简单地追加到list的尾部。

3.2字典(dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

  • 键(key)必须是唯一的，可以用数字，字符串或元组充当，而用列表就不行
  • 同一个键出现两次，最后出现的会更新前一个的值。

字典的每个键值 key=>value 对用冒号:分割，每个键值对之间用逗号,分割，整个字典包括在花括号 {} 中 ,格式如下所示：

  1. >>> dict = {'a': 1, 'b': 2, 'b': '3'}
  2. >>> print(dict)
  3. {'a': 1, 'b': '3'}
  4.  
  5. ### 访问字典里的值
  6. >>> print(dict['b'])
  7. 3
  8.  
  9. ### 更新和添加字典
  10. >>> dict['a'] = 8
  11. >>> dict['c'] = 'cc'
  12. >>> print(dict['a'])
  13. 8
  14. >>> print(dict['c'])
  15. cc
  16.  
  17. ### 删除字典元素
  18. >>> del dict['a']
  19. >>> print(dict)
  20. {'b': '3', 'c': 'cc'}
  21. >>> dict.clear()      # 清空字典所有条目
  22. >>> del dict          # 删除字典

3.3组合使用

列表里也能嵌套列表，列表里能嵌套字典
字典里能嵌套字典，字典里也能嵌套列表
这是非常灵活的。

3.3.1 列表嵌套列表

这个用得不多，相对也比较简单，直接看例子：

  1. ### 打印输出字符 5
  2. l = [[1,2],[3,4],[[5,6],[7,8]]]	
  3. >>> print(l[2][0][0])
  4. 5
  5.  
  6. ### 将嵌套列表转为非嵌套列表
  7. >>> a = [[1,2,3],[4,5,6],[7],[8,9]]
  8. >>> for i in a:
  9. ...     t.extend(i)
  10. ...
  11. >>> print(t)
  12. [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 9]

*3.3.2列表嵌套字典

在列表中嵌套字典应该是最常用的方式了，直接举例说明：

  1. li = [{'a': 1}, {'b': 2}, {'c': 3}]
  2.  
  3. ###(1) 循环获取字典里每个键值对:
  4. >>> for i in range(len(li)):
  5. ...     for k, v in li[i].items():
  6. ...         print(k, v)
  7. ...
  8. a 1
  9. b 2
  10. c 3
  11.     
  12. ###(2) 获取字典里每个键值对(元组数据类型):
  13. >>> for i in range(len(li)):
  14. ...     for j in li[i].items():
  15. ...         print(j)
  16. ...
  17. ('a', 1)
  18. ('b', 2)
  19. ('c', 3)
  20.  
  21. ### 可以看到第二种获取到的键值对是 元组数据类型。

3.3.3字典嵌套字典

字典嵌套字典：字符串作为key，字典作为value：

  1. >>> s={'a':{0:'no',1:{'f':{0: 'no', 1: 'maybe'}}},'b':{}}  #构造字典
  2. >>> s['a'][0]  # 取值
  3. 'no'
  4. >>> s['a'][1]
  5. {'f': {0: 'no', 1: 'maybe'}}
  6. >>> s['a'][1]['f'][1]  
  7. 'maybe'
  1. ### 字典嵌套字典
  2. dict = {
  3.     '192.168.1.1':{'cpu':'0.23','内存':'16','硬盘':'500'},
  4.     '192.168.1.2':{'cpu':'3.22','内存':'64','硬盘':'700'},
  5.     '192.168.1.3':{'cpu':'1.99','内存':'32','硬盘':'800'},
  6. }
  7.  
  8. ### for遍历
  9. >>> for k,v in dict.items():
  10. ...     print('',k,end=': ')
  11. ...     for x,y in v.items():
  12. ...         print(x,y,end=' ')
  13. ...
  14.  
  15.  192.168.1.1: cpu 0.23 内存 16 硬盘 500
  16.  192.168.1.2: cpu 3.22 内存 64 硬盘 700
  17.  192.168.1.3: cpu 1.99 内存 32 硬盘 800

3.3.4 字典嵌套列表

那么如何在字典里嵌套列表呢？
字典嵌套列表：字符串作为key，列表作为value。

  1. ### 字典嵌套列表
  2. dict = {
  3.     '水果':['苹果','香蕉','橘子'],
  4.     '动物':['狮子','老虎','大象'],
  5.     '语言':['中文','英文','日语'],
  6. }
  7.  
  8. ### 访问字典里的值
  9. >>> print(dict['水果'])
  10. ['苹果', '香蕉', '橘子']
  11.  
  12. ### 访问列表里的值
  13. >>> print(dict['语言'][1])
  14. 英文
  15.  
  16. ### 循环打印输出看效果
  17. >>> for k, v in dict.items():
  18. ...     print('', k, end=':')
  19. ...     for x in v:
  20. ...         print(x,end=' ')
  21. ...
  22.  
  23.  水果:苹果 香蕉 橘子
  24.  动物:狮子 老虎 大象
  25.  语言:中文 英文 日语

3.3.5 嵌套什么时候用

比如希望存储年级前100名学生的各科成绩时，由于学生是由成绩进行排名的，列表是有序的数据类型，而字典是无序的数据类型，所以外面会用列表去存储所有的数据。

而对于学生的各科成绩来说，看重的不是有序，而是需要科目和成绩一一对应，这才是最重要的。或者说当我想获取到年纪第十名同学的语文成绩，那么可以直接去获取到列表对应的索引，和字典里对应的key就可以了，这样就能得到相应的value。

至于嵌套中的排序用法

4. 实际案例：列表嵌套字典

数据格式：

  1. {"id": "538f267d2e6fba48b1286fb7f1499fe7", "title": "一种信号的发送方法及基站、用户设备", "assignee": "华为技术有限公司", "abstract": "一种信号的发送方法及基站、用户设备。在一个子帧中为多个用户设备配置的参考信号的符号和数据的符号在子帧中的时域位置关系满足前提一和前提二；前提一为，将每个用户设备的参考信号所需的资源包括在多个参考信号的符号中，前提二为以下条件中的至少一个：将每个用户设备的多个参考信号设置在每个用户设备的数据的符号之前的参考信号的符号中，和/或每个用户设备的数据的符号之后的参考信号的符号中，从而有效地节省了发送参考信号的开销，满足了资源设计的需求；且部分或全部用户设备可在多个参考信号的符号中包含其参考信号，使该用户设备的解调性能得到进一步改善。", "label_id": 0}
  2. {"id": "635a7d4b6358b6ff24a324bb871505db", "title": "一种5G通讯电缆故障监控系统", "assignee": "中铁二十二局集团电气化工程有限公司", "abstract": "本发明公开了一种5G通讯电缆故障监控系统，包括信号采样模块、补偿反馈模块，所述信号采样模块对5G通讯电缆信号采样，信号采样模块连接补偿反馈模块，补偿反馈模块运用三极管Q1、电容C3和电感L2、电容C2组成高频补偿电路展宽信号的通频带，为了进一步保证滤除扰动信号的准确性，避免异常高电平信号击穿电感L3，运用三极管Q4检测运放器AR2输出端信号，将异常高电平信号经电阻R14分压，最后运用运放器AR3同相放大信号，三极管Q5进一步三极管运放器AR3输出信号、三极管Q3发射极信号电位差，运用三极管Q2反馈信号至运放器AR2输出端，对运放器AR3输出信号峰值进一步校准，5G通讯电缆故障监控系统终端能够及时对5G通讯电缆故障及时响应。", "label_id": 0}

代码一：

  1. import json
  2. import pandas as pd
  3. # json_data=[]
  4. # for line in open('test_data.json', 'r', encoding='utf-8'):
  5. #     json_data.append(json.loads(line))
  6.  
  7. # print(json_data)
  8.  
  9. # 由于文件中有多行，直接读取会出现错误，因此一行一行读取
  10. file = open("test_data.json", 'r', encoding='utf-8')
  11. papers = []
  12. for line in file.readlines():
  13.     dic = json.loads(line)
  14.     papers.append(dic)
  15.  
  16. res = [v[key] for v in papers for key in v] #将字典数值放在，一个列表
  17. # print(res)
  18. #读取后不含字典键值
  19. id=[]
  20. case=[]
  21. labels=[]
  22. for v in papers:
  23.     id.append(v['id'])
  24.     case.append([v['title'],v['assignee'],v['abstract']])
  25.     labels.append(v['label_id'])
  26.     
  27. # print(case)
  28. # print(labels)
  29.  
  30.  
  31.  
  32. final_data=pd.DataFrame(columns = ['id','content','label'])
  33. final_data['id']=id
  34. final_data['content']=case
  35. final_data['label']=labels
  36.  
  37. final_data.to_csv("output.txt",sep='\t',index=False,index_label=False,header=False) 
  38.  
  39.  
  40. #合并在一个list中
  41. # for v in papers:
  42. #     case=[]
  43. #     for key in v:
  44. #         print(v[key])
  45. #         if key=="title" or key=="assignee" or key=="abstract" :
  46. #             case.append(v[key])
  47. # print(case)

代码二推荐：

  1. import json
  2. import pandas as pd
  3.  
  4. json_data=[]
  5. id=[]
  6. content=[]
  7. label=[]
  8.  
  9. for line in open("test_data.json",'r',encoding='utf8'):
  10.     json_data.append(json.loads(line))
  11.     # print('这是文件中的json数据：',json_data)
  12.     # print('这是读取到文件数据的数据类型：', type(json_data))
  13.     for v in json_data:
  14.         # print(v)
  15.         # 取出特定数据
  16.         # print("%s,%s"%(v['id'],v['title']))
  17.         id.append(v['id'])
  18.         content.append([v['title'],v['assignee'],v['abstract']])
  19.         label.append(v['label_id'])
  20.         
  21. # print(id)
  22. # print(content)
  23. # print(label)
  24.  
  25. final_data=pd.DataFrame(columns = ['id','content','label'])
  26. final_data['id']=id
  27. final_data['content']=content
  28. final_data['label']=label
  29.  
  30. print(final_data)

输出样式：

  1. 0  538f267d2e6fba48b1286fb7f1499fe7  [一种信号的发送方法及基站、用户设备, 华为技术有限公司, 一种信号的发送方法及基站、用户设...      0
  2. 1  538f267d2e6fba48b1286fb7f1499fe7  [一种信号的发送方法及基站、用户设备, 华为技术有限公司, 一种信号的发送方法及基站、用户设...      0
  3. 2  635a7d4b6358b6ff24a324bb871505db  [一种5G通讯电缆故障监控系统, 中铁二十二局集团电气化工程有限公司, 本发明公开了一种5G...      0

存在括号进行改进： 改为相加即可：列表list合并的4种方法

方法一：

  1. import json
  2. import pandas as pd
  3.  
  4. json_data=[]
  5. id=[]
  6. content=[]
  7. label=[]
  8.  
  9. for line in open("test_data.json",'r',encoding='utf8'):
  10.     json_data.append(json.loads(line))
  11.     # print('这是文件中的json数据：',json_data)
  12.     # print('这是读取到文件数据的数据类型：', type(json_data))
  13.     for v in json_data:
  14.         # print(v)
  15.         # 取出特定数据
  16.         # print("%s,%s"%(v['id'],v['title']))
  17.         id.append(v['id'])
  18.         content.append(v['title']+v['assignee']+v['abstract'])
  19.         label.append(v['label_id'])
  20.         
  21. # print(id)
  22. # print(content)
  23. # print(label)
  24.  
  25. final_data=pd.DataFrame(columns = ['id','content','label'])
  26. final_data['id']=id
  27. final_data['content']=content
  28. final_data['label']=label
  29.  
  30. print(final_data)

 *方法二：

更简洁：

  1. import json
  2. import pandas as pd
  3. # json_data=[]
  4. # for line in open('test_data.json', 'r', encoding='utf-8'):
  5. #     json_data.append(json.loads(line))
  6.  
  7. # print(json_data)
  8.  
  9. # 由于文件中有多行，直接读取会出现错误，因此一行一行读取
  10. file = open("test_data.json", 'r', encoding='utf-8')
  11. papers = []
  12. for line in file.readlines():
  13.     dic = json.loads(line)
  14.     papers.append(dic)
  15.  
  16. res = [v[key] for v in papers for key in v] #将字典数值放在，一个列表
  17. # print(res)
  18. #读取后不含字典键值
  19. id=[]
  20. case=[]
  21. labels=[]
  22. for v in papers:
  23.     id.append(v['id'])
  24.     case.append(v['title']+v['assignee']+v['abstract'])
  25.     labels.append(v['label_id'])
  26.     
  27. # print(case)
  28. # print(labels)
  29.  
  30.  
  31. final_data=pd.DataFrame(columns = ['id','content','label'])
  32. final_data['id']=id
  33. final_data['content']=case
  34. final_data['label']=labels
  35.  
  36. final_data.to_csv("train_input.txt",sep='\t',index=False,index_label=False,header=False) 
  37.  
  38. print("数据导出")
  39.  
  40. #合并在一个list中
  41. # for v in papers:
  42. #     case=[]
  43. #     for key in v:
  44. #         print(v[key])
  45. #         if key=="title" or key=="assignee" or key=="abstract" :
  46. #             case.append(v[key])
  47. # print(case)
  48.

5. 补充列表list合并的4种方法

5.1两个列表合并

总结：

第一种方法思路清晰，就是运算符的重载

第二种方法比较简洁，但会覆盖原始list

第三种方法功能强大，可以将一个列表插入另一个列表的任意位置

第四种方法直接把一个元素，整个放入到另一个列表中

方法1：直接使用“+”合并列表

  1. alist = [1,2,3]
  2. blist = ['www','pythontab.com']
  3. clist = alist + blist
  4. dlist = blist + alist
  5. print(clist)
  6. print(dlist)
  7.  
  8.  
  9. [1, 2, 3, 'www', 'pythontab.com']

方法2：使用extend方法

  1. alist = [1,2,3]
  2. blist = ['www','pythontab.com']
  3. alist.extend(blist)
  4. print(alist)

注意：使用方法会直接修改list数据，extend方法的返回值为None，所以直接打印alist

方法3：使用切片

  1. alist = [1,2,3]
  2. blist = ['www','pythontab.com']
  3. alist[len(alist):len(alist)] = blist
  4. print(alist)

 注意：len(alist)表示要将blist插入alist中的位置，例如

  1. alist = [1,2,3]
  2. blist = ['www','pythontab.com']
  3. alist[1:1] = blist
  4. print(alist)
  5.  
  6. [1,'www','pythontab.com',2,3]

方法4：使用append方法

a.append(b)将b看成list一个元素和a合并成一个新的list，它和前面的方法的输出结果不同

  1. alist = [1,2,3]
  2. blist = ['www','pythontab.com']
  3. alist.append(blist)
  4. print(alist)
  5.  
  6.  
  7. [1, 2, 3, ['www', 'pythontab.com']]

5.2 python 中如何把嵌套的列表合并成一个列表?

参考链接：

5.3 python-实用的函数-将多个列表合并为一个

抓数据的的时候把数据存在了多个列表里，做数据清洗的时候需要将多个列表中的元素合并为一个列表

  1. # 将多个列表合并为一个列表
  2. def get_sublist_all_elements(input_lst):
  3.     out_lst = []
  4.     for item in input_lst:
  5.         out_lst.extend(item)
  6.     return out_lst
  7. a = ["455","4343","4535"]
  8. b = ["fdsfs","fdsfsfs"]
  9. c = [a,b]
  10. print(c)
  11. print(get_sublist_all_elements(c))
  1. [['455', '4343', '4535'], ['fdsfs', 'fdsfsfs']]
  2. ['455', '4343', '4535', 'fdsfs', 'fdsfsfs']
  1. PS: extend实例
  2.  
  3. aList = [123, 'xyz', 'zara', 'abc', 123];
  4. bList = [2009, 'manni'];
  5. aList.extend(bList)
  6. 输出：
  7.  
  8. [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发