python基础之数据类型下篇

python基础之数据类型下篇

上篇梳理了python数据类型中的不可变数据类型，主要有Boolean、None、Tuple、String以及Number类型，点击这里即可查看python基础之数据类型上篇。好了，废话不多说，开始可变数据类型的梳理吧！

1、List

list：列表，是一种容器，Python提供了一种数据结构List，可以同时存储多个数据，其本质是一种有序的集合

# 如果需要统计很多数据，可以这样写
age_1 = 19
age_2 = 23
age_3 = 25
age_4 = 45
# 但有列表这个容器后，你可以这样写
l = [19,23,25,45]

1.1 创建列表

使用[]表示列表，列表名其实就是标识符，将列表中的列表选项被称为元素​，列表中的元素分别被编了号，这些编号被称为索引【下标，角标】，从0开始编号。
语法：列表名 = [列表选项一，列表选项二，列表选项三…列表选项n]

a = [2,3,4,5,6]# 此时a就是一个列表
print(type(a))# <class 'list'>
# 列表中选项可以是元组，字符串、字典、列表等，如下：
c = [(1,2),"asd",[1,2,4],{"age":23}]

1.2 列表中元素的访问

1.2.1 切片与取值

语法：列表[m,n,s] ,其中m代表从第几位开始，n代表到第几位，不包括n，s代表步长

list4 = [100,200,400,300,800]
print(list4[2])# 400
print(list4[2,5,1])# [400, 300, 800],注意此时返回的是列表

1.2.2 替换

语法：列表[索引] = 值

list4 = [100,200,400,300,800]
list4[3] = 666
print(list4)# [100, 200, 400, 666, 800] 注意此时的替换是直接修改原列表

1.3 列表操作

# 列表组合
list1 = [43,65,76,6]
list2 = [45,77,90,11,2,4,66]
print(list1 + list2)# [43, 65, 76, 6, 45, 77, 90, 11, 2, 4, 66]
# 列表重复
print(list1 * 4)# [43, 65, 76, 6, 43, 65, 76, 6, 43, 65, 76, 6, 43, 65, 76, 6]
# 判断指定元素是否存在于列表中 in 和 not in
list3 = ["hello",False,189,"good"]
print(189 in list3) #True
print(180 not in list3)  #True

1.4 列表内置功能

函数	解释
len()	计算列表的长度
list.count()	统计某个元素在列表中出现的次数
append	向列表中添加一个值
list.extend()	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index()	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.pop()	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove()	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort()	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表
copy.deepcopy()	深拷贝 拷贝对象及其子对象
copy.copy()	浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象

语法：列表名.功能()

#添加元素
#1.append   在列表结尾添加元素或者新的列表【追加】
list11 = [1,2,3,4,5]
list11.append(100)
print(list11)
#追加列表【将容器和元素一起添加进去】
list11.append([547,76,87])
print(list11)
#2.extend    在列表的末尾一次性追加另一个列表中的元素
list12 = [1,2,3,4,5,100]
list12.extend([547,76,87]) #只将元素添加进去
print(list12)# [1, 2, 3, 4, 5, 100, 547, 76, 87]
#3.insert  在指定索引处插入一个元素，不覆盖原来的元素，原有的元素向后顺延
#注意：告诉编译器，需要在什么位置插入什么元素
list13 = [1,2,3,4,5]
list13.insert(2,555)
print(list13)# [1, 2, 555, 3, 4, 5]
#插入列表
list13.insert(4,[22,33])
print(list13)# [1, 2, 555, 3, [22, 33], 4, 5]
#4.pop   移除列表中指定下标的元素
list14 = [1,2,3,4,5,100]
print(list14)
#默认移除最后一个元素
list14.pop()
print(list14)
#移除指定下标的元素
list14.pop(3)
print(list14)
#5.remove  移除元素
list15 = [11,23,354,45,5,100]
#list15.remove(3) 如果元素不存在，则出现错误：ValueError: list.remove(x): x not in list
list15.remove(5)
print(list15)
#6.clear   清空列表
list16 = [11,23,354,45,5,100]
list16.clear()
print(list16)
#7.index   从列表中查询第一个匹配的元素的下标
list17 = [11,23,354,45,5,100,100,23,354]
print(list17)
#在整个列表中查询
print(list17.index(23))
#只在部分列表中查询（包头不包尾）注意：2和8表示开始下标和结束下标
print(list17.index(23,2,8))
#8.len 获取列表中元素的个数【获取列表的长度】
list18 = [11,23,354,45,5,100,100,23,354]
print(len(list18))# 9
#9.max  获取列表中的最大值
print(max(list18))# 354
#10.min  获取列表中的最小值
print(min(list18))
#11.count  查看元素在列表中出现的次数
print(list18.count(23))
#12.reverse  将列表实现倒序
list18.reverse()
print(list18)
#13.sorted
list19 = [11,23,354,45,5,100,100,23,354]
#默认升序排序
list1 = sorted(list19)
print(list1)
#降序排序
list2 = sorted(list19,reverse=True)
print(list2)
#通过key关键字来实现排序：根据字符串的长度排序
list20 = ["zoo","manager","hello","jack","international"]
list3 = sorted(list20,key=len)
print(list3)
#14.sort 注意sort会直接修改原列表
list19.sort()  #升序 
print(list19)
list19.sort(reverse=True)  #降序
print(list19)

2、Dict

Dict：字典
字典是一种映射数据结构，无序，字典具有较高效率的查找速度，依据hash函数映射到制定位置

2.1 字典的创建

字典：由{}创建
语法：{key1：value1，key2：value2：…keyn：valuen}
注意：字典的key即键是惟一的，必须是不可变的，所以key不能为可变数据类型

dict_a = {"age":12,"sex":"male","country":"china"}
dict_b = {[1,2]:12,23:234}

上面dict_a是正确的字典格式，dict_b是错误的，其key可变

# 创建空字典
dict_c = {}

2.2 字典元素的访问和常见函数

2.2.1 元素访问

元素访问：有两种格式，一种是dict.get()获取，另外一种是dict[key]

dict_1 = {"jack":78,"hanmeimei":99,"lilei":60}
print(dict1["hanmeimei"])
print(dict1["tom"])

上面是直接通过对应的key来获取value，当访问不存在的key时，python会报错，如第二个print输出KeyError: ‘tom’

result = dict1.get("lilei")
print(result)

通过get（）也可获得对应的value

2.2.2 增加删除元素

#添加:当指定的键不存在的时候，则表示添加
dict1["tom"]  = 70
print(dict1)
#但是，如果键已经存在，则表示修改value
dict1["jack"]  = 50
print(dict1)
#删除 pop
#注意：通过键，直接删除整个键值对
dict1.pop("jack")
print(dict1)

2.2.3 获取所有的键或值

# 获取键
dict2 = {"jack":78,"hanmeimei":99,"lilei":60}
print(dict2.keys())
# dict_keys(['jack', 'hanmeimei', 'lilei'])
# 获取值
print(dict2.values())
# dict_values([78, 99, 60])
# 获取键值对
print(dict2.items())
# dict_items([('jack', 78), ('hanmeimei', 99), ('lilei', 60)])

3、Set

Set：集合
集合是一个无序、不重复元素的序列

1. 全集: 所有元素的集合.例如实数集,所有实数组成的集合就是全集
2. 子集subset和超集superset: 一个集合A所有的元素都在另一个集合B内,A是B的子集,B是A的超集
3. 真子集和真超集: A是B的子集,且A不等于B,A就是B的真子集,B是A的真超集
4. 并集: 多个集合合并的解构
5. 交集: 多个集合的公共部分
6. 差集: 集合中除去和其他集合公共部分

3.1 集合创建

集合创建由{}来完成，但空集合用set（）来创建，而不是{}

jihe = set()
s = {1,2,3,4,5,6,7,8,9,10}

3.2 集合运算

# set可以进行集合运算
a = set('abk')
b = set('bal')
print(a)
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素

依次输出：
{‘a’, ‘b’, ‘k’}
{‘k’}
{‘a’, ‘b’, ‘l’, ‘k’}
{‘a’, ‘b’}
{‘l’, ‘k’}
注意：可以利用集合无序、不重复的特点去重，如：

a = [1, 2, 3, 43, 31, 2]         　# 新建一个列表
b = set(a) #转化为集合
print(b)

输出：{1,2,3,43,31}