python复合数据类型包括_Python复合数据类型,组合

Python组合数据类型

4.1 列表

4.1.1 列表的表达

序列类型：内部元素有位置关系，可以通过位置序号访问元素

列表是一个可以使用多种类型的元素，支持元素的增、删、查、改操作的序列类型

ls =["python", 2020, True, {"version":3.7}]

ls

['python', 2020, True, {'version': 3.7}]

另一种产生方式：list(可迭代对象)

可迭代对象：字符串、元组、集合、range()等

字符串转列表

list("大数据是未来")

['大', '数', '据', '是', '未', '来']

元组转列表

list(("大","数","据"))

['大', '数', '据']

集合转列表

list({"大","数","据"})

['数', '据', '大']

特殊的range()

for i in [0,1,2,3,4,5]:

print(i)

0

1

2

3

4

5

for i in range(6):

print (i)

0

1

2

3

4

5

range(起始数字，终止数字，数字间隔)

若起始数字缺省默认为0

间隔缺省默认为1

range()转列表

list(range(0,8,2))

[0, 2, 4, 6]

4.1.2 列表的性质

列表的长度——len(列表)

ls = [1,2,3,4,5]

len(ls)

5

列表的索引

变量名[位置编号]

正向索引从0开始

反向索引从-1开始

ls = [1,2,3,4,5]

print(ls[0])

print(ls[-1])

1

5

列表的切片

变量名[开始:结束:间隔]

ls = [1,2,3,4,5]

print(ls[0:4:2])

[1, 3]

4.1.3 列表的操作符

用 list1 + list2 实现拼接

a = [1,2]

b = [3,4]

a+b

[1, 2, 3, 4]

用 list * n 成倍复制

初始化列表

[0]*10

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

4.1.4 列表的操作方法

1.增加元素

在末尾增加元素——.append(元素)

r = [1,2,3,4]

r.append(5)

r

[1, 2, 3, 4, 5]

在任意位置插入元素——.insert(编号，元素)

r.insert(0,0)

r

[0, 1, 2, 3, 4, 5]

在末尾整体并入另一列表——列表1.extend(列表2)

p = [7,8]r

r.extend(p)

r

[0, 1, 2, 3, 4, 5, 7, 8]

2. 删除元素

删除列表某位置的元素——列表.pop(编号)

r = [1,2,3,4]

r.pop(0)

r

[2, 3, 4]

不填位置信息默认删除最后一个元素

删除第一次出现的待删元素——列表.remove(待删元素)

r = [1,2,3,4,4]

r.remove(4)

r

[1, 2, 3, 4]

r = [1,2,3,4]

while 4 in r:

r.remove(4)

r

[1, 2, 3]

3.查找元素

列表中第一次出先得待查元素得位置——列表.index(待查元素)

r = [1,2,3,4]

n = r.index(1)

n

0

4. 修改元素

先索引后修改——列表[位置]=新值

r = [1,2,3,4]

r[0]=0

r

[0, 2, 3, 4]

5. 列表得复制

列表.copy()

列表[:]

r = [1,2,3,4]

r_2 = r.copy()

r_2

[1, 2, 3, 4]

6. 列表的排序

永久排序——列表.sort()

直接对列表进行操作，无返回值

r = [1,2,3,4,2,1]

r.sort()

r

[1, 1, 2, 2, 3, 4]

递减排序

r.sort(reverse = True)

r

[4, 3, 2, 2, 1, 1]

临时排序——sorted(列表)

r = [1,2,3,4,2,1]

r_2 = sorted(r)

r_2

[1, 1, 2, 2, 3, 4]

7. 列表的翻转

使用切片临时翻转

r = [1,2,3,4]

print(r[::-1])

[4, 3, 2, 1]

使用 .reverse() 永久翻转

r.reverse()

r

[4, 3, 2, 1]

8. 使用 for 循环对列表遍历

r = [1,2,3,4]

for i in r:

print(i)

1

2

3

4

4.2 元组

4.2.1 元组的表达

序列类型：可以使用多种类型的元素，一旦定义，不支持增删改

r = (1,2,3,4)

4.2.2 元组的操作

不支持增删改，其他操作与列表相同

4.2.3 元组的常见之处

打包与解包

def f1(x):

return x**2,x**3

print(f1(3))

print(type(f1(3)))

(9, 27)

a,b = f1(3)

print(a)

print(b)

9

27

numbers = [101,202,303]

name = ["uzi","ming","mlxg"]

list(zip(numbers,name))

[(101, 'uzi'), (202, 'ming'), (303, 'mlxg')]

for numbers,name in zip(numbers,name):

print(numbers,name)

101 uzi

202 ming

303 mlxg

4.3 字典

4.3.1 字典的表达

映射类型：通过 键:‘值’ 的映射实现数据存储和查找

字典是无序的

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng

{101: 'uzi', 202: 'ming', 303: 'mlxg'}

字典键的要求

1、 字典的键不能重复

rng = {101:'uzi',101:'ming',303:'mlxg'}

rng

{101: 'ming', 303: 'mlxg'}

键值是不可变类型

不可变类型：数字、字符串、元组

可变类型：列表、字典、集合

4.3.2 字典的性质

字典的长度——键值对的个数

rng = {101:'uzi',202:'ming',303:'mlxg'}

len(rng)

3

字典的索引

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng[101]

'uzi'

4.3.3 字典的操作方法

1. 增加键值对

变量名[新键] = 新值

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng[404] = "hu"

rng

{101: 'uzi', 202: 'ming', 303: 'mlxg', 404: 'hu'}

2. 删除键值对

del 变量名[待删除键]

rng = {101:'uzi',202:'ming',303:'mlxg'}

del rng[303]

rng

{101: 'uzi', 202: 'ming'}

变量名.pop(待删除键) #删除键值对的同时获得他的值

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng_2 = rng.pop(303)

print(rng_2)

print(rng)

mlxg

{101: 'uzi', 202: 'ming'}

变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng_2 = rng.popitem()

print(rng_2)

print(rng)

(303, 'mlxg')

{101: 'uzi', 202: 'ming'}

3. 修改值

先索引后赋值

rng = {101:'uzi',202:'ming',303:'mlxg'}

rng[303] = "hu"

rng

{101: 'uzi', 202: 'ming', 303: 'hu'}

4. d.get()方法

d.get(key,default)

从字典 d 中获取键 key 的值，如果没有这个键，则返回 default

s = "214241242421"

d = {}

print(d)

for i in s:

d[i] = d.get(i,0)+1

print(d)

{}

{'2': 1}

{'2': 1, '1': 1}

{'2': 1, '1': 1, '4': 1}

{'2': 2, '1': 1, '4': 1}

{'2': 2, '1': 1, '4': 2}

{'2': 2, '1': 2, '4': 2}

{'2': 3, '1': 2, '4': 2}

{'2': 3, '1': 2, '4': 3}

{'2': 4, '1': 2, '4': 3}

{'2': 4, '1': 2, '4': 4}

{'2': 5, '1': 2, '4': 4}

{'2': 5, '1': 3, '4': 4}

5. d.keys() d.values()

rng = {101:'uzi',202:'ming',303:'mlxg'}

print(list(rng.keys()))

print(list(rng.values()))

[101, 202, 303]

['uzi', 'ming', 'mlxg']

6. d.items()

print(list(rng.items()))

for k,v in rng.items():

print(k,v)

[(101, 'uzi'), (202, 'ming'), (303, 'mlxg')]

101 uzi

202 ming

303 mlxg

4.4 集合

4.4.1 集合的表达

一系列互不相等的元素的无序组合

元素必须是不可变类型

rng = {"uzi","uzi","ming","mlxg"}

rng

{'ming', 'mlxg', 'uzi'}

4.4.2 集合的运算

rng = {"uzi","ming","mlxg"}

ADC = {"uzi","deft"}

rng & ADC #交集

{'uzi'}

rng | ADC #并集

{'deft', 'ming', 'mlxg', 'uzi'}

4.4.3 集合的操作方法

增加元素——S.add(x)

rng = {"uzi","ming","mlxg"}

rng.add("hu")

rng

{'hu', 'ming', 'mlxg', 'uzi'}

移除元素——S.remove(x)

rng = {"uzi","ming","mlxg"}

rng.remove("mlxg")

rng

{'ming', 'uzi'}

集合的长度——len(S)

rng = {"uzi","ming","mlxg"}

len(rng)

3

]