python中数据结构容器（list、dict、tuple、set）和C++、JAVA中的导出数据类型， 数组

字典，列表，元组，集合的区别

	列表	元组	集合	字典
英文	list	tuple	set	dict
可否读写	读写	只读	读写	读写
可否重复	是	是	否	是
存储方式	值	值	键（不可重复）	键值对（不能重复）
是否有序	有序	有序	无序	无序（自动正序）
初始化	[1,‘a’]	(1,‘a’)	{1,2}或set([1,2])	{‘a’:1,‘b’:2}
添加	append or insert	只读	add	d[‘key’]=‘value’
读元素	l[2:]	t[0]	无	d[‘a’]

list(列表）：语法：列表形如 [1, 2, 3, 4] [‘小明’,‘小红’,] ，用中括号括住，里面是字符串、布尔，每一项逗号分开。

创建

1. 声明变量时 中括号、项，创建一个非空的列表。
   num_list = [1,2,3,4]
2. 创建一个空列表，之后再修改
   num_list = []
3. 类实例化创建
   list1 = list()

添加

1.(常用）append() 追加
列表对象.append(新项),追加一个元素到列表末尾。
list1 = [1,2,3]
list1.append(4) →[1,2,3,4]
2. insert()
列表对象.insert(索引，新项)
list = [1，2，3]
list1.insert(0,4) →[4,1,2,3]
3.列表合并
两个变量都是列表时， 可以合并
list1 = [1,2,3]
list2 = [4,5,6]
list1 + list2 → [1,2,3,4,5,6]
4.批量添加
list1 = [‘小明’,‘小红’]
for i in range[‘小李’,‘小王’,‘萧萧’]:
list1.append(i)
list1 →[‘小明’,‘小红’,‘小李’,‘小王’,'萧萧]
5.extend是列表和列表的扩展
nums = [‘alice’,‘jiuk’,‘mary’]
nums.extend([‘peter’,‘lili’])
print(nums) [‘alice’, ‘jiuk’, ‘mary’, ‘peter’,‘lili’]

删除

1. pop()
   列表对象.pop(索引)， 删除指定索引的那一项。
   list1 = [1,2,3]
   list1.pop(0) → 1
   list1 = [2,3]
2. remove()
   list1 = [‘小明’,‘小红’,‘小青’]
   list1.remove(‘小红’)
   list1 → [‘小明’,‘小青’]
3. (不常用)clear()
   列表对象.clear(),清空所有项。
   list1 = [‘小明’,‘小红’,‘小青’]
   list1.clear()
   list1 →[]
   4.(不常用)关键字 del
   list1 = [‘小明’,‘小红’,‘小青’]
   del list1[1]
   list1 → [‘小明’, ‘小青’]

修改

1. 根据下标修改
   列表对象[索引] = 新值
   list1 = [‘小明’,‘小红’,‘小青’]
   list1[1]=‘小王’
   list1 →[‘小明’,‘小王’,‘小青’]

访问

1.通过下标（索引 index) 访问。
列表中的项以 0，1，2， 编号。比如[1，2，3]中的元素1的下表是0.
list1 = [1,2,3]
list1[0] → 1
list1[-1] → 3 下标负数表示倒数第几个项
2.遍历，访问列表中每一项
for i in [‘小明’,‘小红’,‘小青’]:
print(i)
3.遍历，循环下标。 场景 修改
len(列表对象)返回的是列表的长度
list1 = [‘小明’,‘小红’,‘小青’]
for i in range(0,len(list1)):
print(list1[i])

切片

列表对象[起始下标:结束下表+1] 左闭右开区间

list1 = [‘小明’,‘小红’,‘小青’,‘小王’,‘萧萧’]
list1[1:3] →[‘小红’,‘小青’]
list1[1:5] → [‘小红’, ‘小青’, ‘小王’, ‘萧萧’]
list1[2:-1] →[‘小青’,‘小王’]
list1[ : ] 从头截取或截取到末尾，下标为0可以省略
[‘小明’, ‘小红’, ‘小青’, ‘小王’, ‘萧萧’]
list1[4:1] []注意截取方向，第一个下标小于第二个，如果下标顺序反，返回空列表

dict(字典）：大括号括住，键值对之间逗号分隔，键和值之间用 ： （冒号）隔开。{键1:值1,键2：值2，…}, 键名一般是字符串类型（键要括号括住）

创建

1.创建一个非空字典 #字符串要用单引号括住
stu1_dict = {‘name’:‘小明’,‘age’: 16,‘sex’:‘男’,‘height’:170}
2.创建一个空字典
dict1 = {}
3.类实例化创建
sd = dict()
sd → {}
sd = dict(name=‘小明’,age=10)
sd → {‘name’: ‘小明’, ‘age’: 10}

访问

1.通过键访问值，字典对象[键]
stu1_dict = {‘name’:‘小明’,‘age’: 16}
stu1_dict[‘name’] →’小明’
找不到键名会报错，错误反应严重，适合严谨的情况
2. 对象.get(键名，默认值)
stu1_dict.get(‘name’) → ‘小明’
stu1_dict.get(‘height’，0) → 0
找不到键名不会报错，会返回默认值，适合事先知道数据可能收不到，需要
默认情况下，不太严谨。
3.可能的错误：
stu1_dict[‘height’] 报错键错误KeyError’height’

其它常用方法

1.所有项的值。遍历
字典对象.values() 返回值组成的列表
for i in stu1_dict.values():
print(i)
小明
16
50

stu1_dict.values() → dict_values([‘小明’, 16, 50])
2.所有项的值
字典对象.keys() 返回值组成的列表
stu1_dict.keys()
dict_keys([‘name’, ‘age’, ‘weight’])
3.获取所有项
字典对象.items()
for i in stu1_dict.items():
print(i)
(‘name’, ‘小明’)
(‘age’, 16)
(‘weight’, 50)

添加

1.对象[新建]=新值
stu1_dict = {‘name’:‘小明’,‘age’: 16}
stu1_dict[‘weight’]=50
stu1_dict → {‘name’: ‘小明’, ‘age’: 16, ‘weight’: 50}

new_key=‘sex’
new_value=‘男’
{‘name’: ‘小明’, ‘age’: 16, ‘weight’: 50,new_key:new_value}
{‘name’: ‘小明’, ‘age’: 16, ‘weight’: 50, ‘sex’: ‘男’}

更新

（了解）内存原理:键名映射指向了新的值，哈希表，字典查询效率比较高
1.(常用)字典对象[键名]= 新值
stu1_dict = {‘name’: ‘小明’, ‘age’: 16, ‘weight’: 50}
stu1_dict[‘name’]=‘小红’
stu1_dict → {‘name’: ‘小红’, ‘age’: 16, ‘weight’: 50}

2.字典对象.update(key1=value1,key2=value2 …)
stu1_dict.update(name=‘小李’)
stu1_dict → {‘name’: ‘小李’, ‘age’: 16, ‘weight’: 50}

删除（不太常用）

1.把值更新成默认值或None
2.字典对象.pop(key),删除键值对，删除成功后返回键对应的值。
stu1_dict.pop(‘age’) → 16
stu1_dict →{‘name’: ‘小李’, ‘weight’: 50}
3.del 关键字
del stu1_dict[‘weight’]
stu1_dict → {‘name’: ‘小李’}
4.stu1_dict.clear() →{}

嵌套

列表，字典可以根据需求相互嵌套
1.列表套列表
字典对象.items() 返回值类似与[[‘name’,‘小明’],[‘age’,10]]
二维数组 、矩阵 [[1,2,3],[4,5,6],[7,8,9]]
2. (常见)列表套字典
students = [{‘name’:‘小明’，‘age’:10,‘sex’:‘男’},
{‘name’:‘小好’，‘age’:17,‘sex’:‘nale’},
]
3. 字典套列表
接口上常见，比如天气预报接口
weather_info = {
‘success’: ok,
‘status_code’:200,
city_list:[
{‘name’:‘郑州’, ‘temp’:‘28’,‘wet’:30},
{‘name’:‘洛阳’, ‘temp’:‘25’,‘wet’:30}
]

tuple(元组）：”小括号“括住，每一项逗号分隔，每一项可以是字符串，数字，布尔。列如：hobby_tuple = (‘打电脑’,‘看电视’,‘逛街’)

创建

tuple1 = (‘小明’,‘小红’)

访问

也是通过下标访问
tuple1 = (‘小明’,‘小红’)
tuple1[0] → ‘小明’

切片

tuple1 = (‘小明’,‘小红’,‘小青’)
tuple1[ :2] →(‘小明’, ‘小红’)
tuple1[ :1] →(‘小明’,)
注意元组切片后多余一个逗号，可能会影响逻辑错误
temp =(1)
type(temp) →<class ‘int’>
temp =(1,)
type(temp) →<class ‘tuple’>

不可修改

tuple1[1] = ‘晓晓’
报错元组的项不能被修改
TypeError: ‘tuple’ object does not support item assignment

虽不可修改，可通过切片达到效果

tuple1 = (1,2,3,4,5)
tuple1 = tuple1[ :2] + tuple1[3: ]
tuple1 →(1, 2, 4, 5)

无论在元组里什么形式自动会换成元组格式

tuple([1,2,3]) → （1, 2, 3)
tuple(‘asd’) → (‘a’, ‘s’, ‘d’)

set 集合 ：大括号括住，里面每一个元素不是键值对，跟列表项类似。 列如：set1 ={1, 2, 3}。

注意：集合是无序的。集合只关心元素是否出现过，不关心元素顺序。（唯一）元素不能重复。

创建

1.创建空集合
set1 = set()
2.创建非空集合
set1 = {‘a’, ‘b’, ‘c’}

添加

set1 ={‘a’,‘b’,‘c’}
set1.add(‘d’)
set1 → {‘a’, ‘d’, ‘b’, ‘c’} 可以看出集合无序特性

删除

set1 ={‘a’,‘b’,‘c’,‘b’,‘c’}

1. remove()
   根据元素值来删除
   set1.remove(‘a’)
   set1 → {‘b’,‘c’}
2. pop

 set1 ={1,9,0,4,5}
set1.pop()   →{1, 4, 5, 9} 

删除集合中的某一项（集合的无序性）并返回，如果集合为空，会报错
4. clear()
set1.clear()
set1 → set()

去重

1.普通写法

list1 = [1,2,3,4,3,1]
list2 = []
for i in list1:
    if i not in list2:
        list2.append(i)
print(list2)
→  {1,2,3,6}

2.用集合写法：

set([1,2,3,2,1,6])  →  {1,2,3,6}

C++、JAVA中的数组：把一系列有序的相同类型的数据组合起来的数据集合。数组都有一个名字即数组名。数组中的每一个元素称为数组元素，有下表确定。

注意：数组使用前，必须进行定义。

一维数组定义格式：

<类型> <数组名>[<常量表达式>];
列如： int a[下标] 数组的下标也是从0开始的。

一维数组初始化赋值：

int a[10]={1,2,3,4,5,6,7,8,9,10};       

// a[10] 中10代表数组的长度，可以不写

访问：

C++ 规定只能对数组中的元素进行访问，不能把整个数组作为一个整体使用。
<数组名>[<下标表达式>]

二维数组：

定义格式：

<类型> <数组名>[<常量表达式1>[<常量表达式2>]];
二维数组可以看做一个矩阵，<常量表达式1> 可以看做 行，<常量表达式2>可以看做 列
列如: int a[2][3]; 有2行3列共12各元素：
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
a[2][0] a[2][1] a[2][2]

初始化赋值:

1方法1. int a[2][3]={{1,2,3},{4,5,6},{7,8,9}}
2方法2. int a[2][3]={1,2,3,4,5,6,7,8,9}
C++中按行顺序存放二维数组个数组元素，即先存放第一行上的元素，再存放第二行上的元素，依次把各行上的元素存放入一串连续的存储单元中。

访问格式：

<数组名>[<下标表达式1>][<下标表达式2>]