python数据类型整理--可变类型_python可变数据类型

1、python的数据类型

基本的数据类型：数字型、字符串、元祖、列表、字典、集合
不可变数据类型：数字型、字符串、元祖
可变数据类型：列表、字典、集合
1
2
3

2、序列是什么？

 序列是一种数据的存储方式，用来存储一系列的数据。
 由于Python3中一切皆对象，可以看出序列中存储的是整数对象的地址，而不是整数对象的值。
1
2

一、列表（list）

1.1 语法
列表：用于存储任意数目、任意类型的数据集合。
列表是内置可变序列，是包含多个元素的有序连续的内存空间
列表中的元素可以各不相同，可以是任意类型。比如：a = [10,20,‘abc’,True]

1.2 列表创建
1.2.1 基本创建

>>> a = [10,20,'gaoqi','sxt']
>>> a = [] #创建一个空的列表对象
1
2

注意：创建1个列表的步骤
1）实例化一个空列表。
2）循环遍历一个可迭代的（如 range）的元素。
3）将每个元素附加到列表的末尾。

numbers = []
for number in range(10):
    numbers.append(number)
    
print(numbers)
1
2
3
4
5

1.2.2 使用 list()可以将任何可迭代的数据转化成列表

>>> a = list() #创建一个空的列表对象
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = list("gaoqi,sxt")
>>> a
['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']
1
2
3
4
5
6
7

特别：将数字列表转换成字符串
map() 是创建列表的另一种方法。您需要向 map() 传递一个函数和一个可迭代对象，之后它会创建一个对象。该

# 随机生成3个元素的1~10的列表
a = np.random.randint(1, 10, 3)
# [1 7 1]

arr = map(str, a)
# <class 'map'>  可遍历, 但只能使用一次
# 将字符列表 拼接为字符串
b = ''.join(arr)
# 171
print(b)
1
2
3
4
5
6
7
8
9
10

1.2.3 range()创建整数列表
range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：
range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为 1
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其
转换成列表对象。

>>> list(range(3,15,2))
[3, 5, 7, 9, 11, 13]
>>> list(range(15,3,-1))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
>>> list(range(3,-10,-1))
>[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
1
2
3
4
5
6

1.2.4 推导式生成列表

>>> a = [x*2 for x in range(5)]  #循环创建多个元素
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if x%9==0] #通过 if 过滤元素
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
1
2
3
4
5
6

1.3 列表元素的增加和删除
当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这
个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素
或删除元素，这会大大提高列表的操作效率。

1.3.1 添加元素 append()
原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

a = [20,40]
a.append(80)
a
[20, 40, 80]
1
2
3
4

1.3.2 运算符操作
并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次
复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用

>>> a = [20,40]
>>> id(a)
46016072
>>> a = a+[50]
>>> a 
[20,40,50] 
>>> id(a)
46015432
1
2
3
4
5
6
7
8

1.3.3 extend（）方法 — 只能存放列表形式
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

>>> a = [20,40]
>>> id(a)
46016072
>>> a.extend([50,60])
>>> id(a)
46016072

1
2
3
4
5
6
7

# extend()添加列表,只能存放列表形式
a = [20,40]
a.extend([50,60])
print(a)   # [20, 40, 50, 60]

# append()添加元素
a = [20,40]
a.append(80)
a
[20, 40, 80]

# append（）添加列表
a = [20,40]
a.append([50,80])
print(a)  # [20, 40, [50, 80]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.3.4 insert（）插入元素
使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后
面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。

>>> a = [10,20,30]
>>> a.insert(2,100)
>>> a
[10, 20, 100, 30]
1
2
3
4

1.3.5 remove()、pop()、del() 删除元素
它们在删除非尾部元素时也会发生操作位置后面元素的移动。
remove()：需要指定待移除的元素

pop()：pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

del用于list列表操作，删除一个或者连续几个元素。
例：定义一个list型数据，data = [1,2,3,4,5,6]
1.del(data):删除整个list。
2.del(data[i]):删除data中索引为i个数据
3.del(data[i:j]):删除data中第i个数据到第j个数据之前（不含j）的数据

# remove()
a = [20,40, 60, 80,100]
a.remove(20)
print(a)	# [40, 60, 80, 100]

# pop()
a = [20,40, 60, 80,100]
a.pop()	# 移除末尾
print(a)  # [20,40, 60, 80]
a = [20,40, 60, 80,100]
a.pop(3)  # 移除指定元素
print(a)  # [20, 40, 60, 100]
1
2
3
4
5
6
7
8
9
10
11
12

1.3.6 乘法扩展
使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复。

>>> a = ['sxt',100]
>>> b = a*3
>>> a
['sxt', 100]
>>> b
['sxt', 100, 'sxt', 100, 'sxt', 100]
# 适用于乘法操作的，还有：字符串、元组。例如：
>>> c = 'sxt' >>> d = c*3
>>> c
'sxt' >>> d
'sxtsxtsxt
1
2
3
4
5
6
7
8
9
10
11

1.3.7 列表元素访问和计数

• 访问可以通过索引直接访问元素

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a[2]
30
>>> a[10]
Traceback (most recent call last):
File "<pyshell#211>", line 1, in <module>
a[10]
IndexError: list index out of range
1
2
3
4
5
6
7
8

1.3.8 index()获得指定元素在列表中首次出现的索引
index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，
start 和 end 指定了搜索的范围。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>> a.index(20,3)
5
>>> a.index(20,3) #从索引位置 3 开始往后搜索的第一个 20
5
>>> a.index(30,5,7) #从索引位置 5 到 7 这个区间，第一次出现 30 元素的位置
6
1
2
3
4
5
6
7
8
9

1.3.9 count()获得指定元素在列表中出现的次数

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3
1
2
3

1.4.0 成员资格判断
判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回
大于 0 则表示存在。但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回 True
或 False。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 100 not in a
True
>>> 30 not in a
False
1
2
3
4
5
6
7

1.4.1 切片操作**(包头不包尾)**
切片 slice 操作可以让我们快速提取子列表或修改。
标准格式为：[起始偏移量 start:终止偏移量 end[:步长 step]]

1.4.2 列表排序
1）修改原列表，不建新列表的排序，默认是升序排列 — sort()

>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a.sort() #默认是升序排列
>>> a
[10, 20, 30, 40]
>>> a = [10,20,30,40]
>>> a.sort(reverse=True) #降序排列
>>> a
[40, 30, 20, 10]
>>> import random
>>> random.shuffle(a) #打乱顺序
>>> a
[20, 40, 30, 10]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2）建新列表的排序----sorted()，默认是升序

>>> a = [20,10,30,40]
>>> id(a)
46016008
>>> a = sorted(a) #默认升序
>>> a
[10, 20, 30, 40]
>>> id(a)
45907848
1
2
3
4
5
6
7
8

1.4.3 reversed()返回迭代器
内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数
reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
并且迭代器对象仅仅使用一次，第二次为空：那是因为迭代对象
在第一次时已经遍历结束了，第二次不能再使用。

>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x0000000002BCCEB8>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
1
2
3
4
5
6
7
8

1.4.4 列表相关的其他内置函数汇总
max 和 min ：用于返回列表中最大和最小值。
sum：对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。

1.4.5 多维列表
一维–线性数据
二维–表格数据

a = [
["高小一",18,30000,"北京"], ["高小二",19,20000,"上海"], ["高小一",20,10000,"深圳"], ]
1
2

for m in range(3): // 行
	for n in range(4): 列
	print(a[m][n],end="\t")
print() #打印完一行，换行
1
2
3
4

1.4.6 找到一个列表中的重复元素

# 利用里 列表.count(元素) 该元素出现的次数 
a = ['l', 'i', 'u', 'h', 'a', 'i', 'w', 'l', 'n']
ret= [val for val in list(set(a)) if a.count(val) >= 2]
print(ret)  
# ['l', 'i']
1
2
3
4
5

1.4.7 找到一个列表中的元素出现的次数

from collections import Counter
alist = [1,2,2,2,2,3,3,3,4,4,4,4]
ret = Counter(alist)
# Counter({2: 4, 4: 4, 3: 3, 1: 1})
# 求得不重复元素的个数
count = len(set(alist))
# 与列表嵌套元组的形式展示元素即个数
result = ret.most_common(count)
print(result)
# [(2, 4), (4, 4), (3, 3), (1, 1)]
1
2
3
4
5
6
7
8
9
10

二、字典（dict）

1、字典的用途
字典是Python提供的一种常用的数据结构，它用于存放具有映射关系的数据。 字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来访问，被称为 value。
注意：key是十分关键的数据，而且访问value的时候需要通过key进行访问，因此字典的key不允许重复。

2、创建和使用字典
2.1 使用dict函数创建
1）可以使用函数 dict 从其他映射或键值对序列创建字典

items=[('name','god'),('age',42)]
d=dict(items)
print(d)
# 结果为{'name': 'god', 'age': 42}
# 如果不为dict函数传入数据，则会创建一个空字典
t=dict()
print(t)
# 结果为 {}
1
2
3
4
5
6
7
8

2）除了传递键值对序列创建字典还可以指定关键字参数来创建字典

d=dict(name='god',age=12)
print(d)
# 结果为 {'name':'god','age':12}
1
2
3

3、字典的基本用法
3.1 通过key访问value

items = {'name': 'god', 'age': 42}
print(items['age'])
# 结果为 42
1
2
3

3.2 通过key添加key-value对

items = {'name': 'god', 'age': 42}
items['sex'] = 'man'
print(items)
# 结果为 {'name': 'god', 'age': 42, 'sex': 'man'}	
1
2
3
4

3.3 通过key删除key-value对

items = {'name': 'god', 'age': 42}
del items['name']
print(items)
#结果为 {'age': 42}
1
2
3
4

3.4 通过key值修改值

items = {'name': 'god', 'age': 42}
items['name']='James'
print(items)
# {'name': 'James', 'age': 42}
1
2
3
4

3.5 通过key判断指定的key-value是否存在

items = {'name': 'god', 'age': 42}
print('name' in items)
print('sex' in items)
# 结果为  True False 
1
2
3
4

4、字典常用方法

• clear()
  clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典

man={'name':'james','age':12}
print(man) 
# 结果为 {'name':'james','age':12}
man.clear()
print(man)
# 结果为 {}
1
2
3
4
5
6

• copy()浅拷贝：返回一个字典浅拷贝的副本

dict1 = {'Name': 'Xiaowuge', 'Age': 17};
dict2 = dict1.copy()
str(dict2)
"{'Name': 'Xiaowuge', 'Age': 17}"
1
2
3
4

• get()方法
  get()方法是根据key值来获取value,使用get()方法的时候，如果key值不存在则会返回None。

man={'name':'james','age':12}
print(man.get('name'))
# 结果为 'james'
print(man.get('sex'))
# 结果为None
1
2
3
4
5

• update()方法
  update()方法可使用一个字典所包含的 key-value对来更新己有的字典。在执行 update()方法时，如果被更新的字典中己包含对应的 key-value对，那么原value 会被覆盖；如果被更新的字典中不包含对应的 key-value对，则该key-value对被添加进去。

man={'name':'james','age':12}
man.update({'name':'tom'})
print(man)
# 结果为 {'name': 'tom', 'age': 12}
man.update({'sex':'man'})
print(man)
# 结果为： {'name': 'tom', 'age': 12, 'sex': 'man'}
1
2
3
4
5
6
7

• items()、keys()、values()
  items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象。
  最终得到的是一个dict_items对象。这个对象也是一个可迭代对象,可以用iter方法将其转化为一个迭代器，其将字典的每一个键值对都转化成了元组

man={'name':'james','age':12}
print(man.items())
# 结果为： dict_items([('name', 'tom'), ('age', 12), ('sex', 'man')])
dic1 = iter(dict.items())
for i in dic1:
print(i)
print(type(i))

----
print(man.keys())
# 结果为 dict_keys(['name', 'age', 'sex'])
list(dict.keys())#转换成列表
['name', 'age', 'address']
------
print(man.values())
# 结果为 dict_values(['tom', 12, 'man'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#同时进行引用循环
dict = {'name':'Alice','age':23,'address':'Hangzhou'}
for i,v in dict.items():
print(i+':'+str(v))
name:Alice
age:23
address:Hangzhou
1
2
3
4
5
6
7

• pop()方法
  pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。

man={'name':'james','age':12}
print(man.pop('name'))
print(man)
# 结果为 james和 {'age':12}
1
2
3
4

-popitem()：返回并删除字典中的最后一对键和值。

dict = {'name':'Alice','age':23,'address':'Hangzhou'}
dict.popitem()
('address', 'Hangzhou')
print(dict)
{'name': 'Alice', 'age': 23}
1
2
3
4
5

• setdefault()方法
  setdefault() 方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，即当程序要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 设置默认值，该key在dict中不存在，新增key-value对
print(cars.setdefault('PORSCHE', 9.2)) # 9.2
print(cars)
# 设置默认值，该key在dict中存在，不会修改dict内容
print(cars.setdefault('BMW', 3.4)) # 8.5
print(cars)
1
2
3
4
5
6
7

• fromkeys()方法
  fromkeys() 方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。

# 使用列表创建包含2个key的字典
a_dict = dict.fromkeys(['a', 'b'])
print(a_dict) # {'a': None, 'b': None}

# 使用元组创建包含2个key的字典
b_dict = dict.fromkeys((13, 17))
print(b_dict) # {13: None, 17: None}

# 使用元组创建包含2个key的字典，指定默认的value
c_dict = dict.fromkeys((13, 17), 'good')
print(c_dict) # {13: 'good', 17: 'good'}
1
2
3
4
5
6
7
8
9
10
11

三、集合(set)

集合不同于列表或元组，集合中的每一个元素不能出现多次，并且是无序存储的。
由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或元组中删除重复值，并执行取并集、交集等常见的的数学操作。

不可变集的一个主要的缺点是：由于它们是不可变的，这意味着你不能向其中添加元素或者删除其中的元素。

结语

1、集合初始化
集合是一个拥有确定（唯一）的、不变的的元素，且元素无序的可变的数据组织形式。
因为：使用不包含值的花括号是初始化字典（dict）的方法之一

1、通过set()初始化
set1=set(['python','java'])
2、通过{}花括号来初始化,花括号只能用于初始化包含值的集合。
set2 = {'python','java'}
1
2
3
4

2、向集合添加值或删除值

• add 添加值
  【注意】：向集合添加，只能添加字符串和元祖不可变的数据
• remove 删除一个值
• discard 删除一个值，这种方法相对于「remove」方法的好处是，如果你试图删除一个集合中不存在的值，系统不会返回「KeyError」。
• pop 从集合中删除并且返回一个任意的值。
• clear 删除集合中所有的值。

3、在集合上进行迭代
用户可以在集合（set）上进行迭代。集合中打印出来的每一个值，你会发现集合中的值被打印出来的顺序与它们被添加的顺序是不同的。

4、将集合中的值变为有序
集合是无序的。如果你认为你需要以有序的形式从集合中取出值，你可以使用「sorted」函数，它会输出一个有序的列表。

dataScientist = {'a','C'}
sorted(dataScientist, reverse = True)
1
2

5、删除列表中的重复项
首先我们必须强调的是，集合是从列表（list）中删除重复值的最快的方法。
方法 1：使用集合删除列表中的重复值。

print(list(set([1, 2, 3, 1, 7])))
1

方法 2：使用一个列表推导式（list comprehension）从一个列表中删除重复值。

def remove_duplications(original):
	unique = []
	[unique.append(n) for n in original if n not in unique]
	return unique
1
2
3
4

6、集合的运算方法

• 并集union:使用「union」方法找出两个集合中所有唯一的值。

dataA = {'python', 'java','c'}
dataB = {'java', 'c'}

c = dataA.union(dataB)
print(c)  # {'java', 'python', 'c'}
1
2
3
4
5
6

• 交集intersection ：是所有同时属于两个集合的元素集合。

dataA = {'python', 'java','c'}
dataB = {'java', 'c'}

c = dataA.intersection(dataB)
print(c) # {'c', 'java'}
1
2
3
4
5
6

• 差集 difference:是所有属于「A」但不属于「B」的元素集合。

dataA = {'python', 'java','c'}
dataB = {'java', 'c'}

c = dataA.difference(dataB)
print(c). # {'python'}
1
2
3
4
5
6

• 对称集 symmetric_difference ：所有属于两个集合但不属于二者共有部分的集合。

dataA = {'python', 'java', 'c'}
dataB = {'java', 'c', 'sql'}

c = dataA.symmetric_difference(dataB)
print(c)
1
2
3
4
5

7、集合推导式
同列表推导式。把符号换成{}