Python中可变类型的数据集合

描述

  1. 列表简单介绍
  2. 列表常用操作
  3. 列表的应用
  4. 字典的简单介绍
  5. 字典的基本操作
  6. 字典的应用

重点

  • 掌握字典的特性与使用方法
  • 掌握列表的特性与使用方法

数据结构

  • 列表中的数据按顺序排列
  • 列表有正序与倒序两种索引
  • 列表可存储任意类型数据,且允许重复

列表(List)

倒序索引值: -7 -6 -5 -4 -3 -2 -1
列表: a b c 1 2 3 4
正序索引值: 0 1 2 3 4 5 6

列表的取值

倒序索引值: -6 -5 -4 -3 -2 -1
列表: 张三 李四 王五 赵六 钱七 孙八
正序索引值: 0 1 2 3 4 5

for..in语句

  • for..in语句专门用于遍历列表、元组等数据结构
for 迭代变量 in 可迭代对象
    循环体(必须缩进)

列表的反转与排序

  • 列表变量.reverse()方法用于反转列表
  • 列表变量.sort()方法用于排序,默认为升序排序
  • 列表变量.sort(reverse=True)降序排序
#列表的反转与排序
persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
persons.reverse() #reverse方法用于反转列表
print(persons)

numbers = [28,32,14,12,53,42]
numbers.sort(reverse=True) #sort()用于排序,reverse=True代表降序排列
print(numbers)

冒泡排序

对于前后两个数两两比较,将大的数往后移,通过多次循环,来找出最大值

例:原始值

28 32 14 12 53 42

第一次循环

28 32 14 12 53 42
28 32 14 12 53 42
28 14 32 12 53 42
28 14 12 32 53 42
28 14 12 32 53 42
28 14 12 32 42 53

 

第二次循环

28 14 12 32 42 53
14 28 12 32 42 53
14 12 28 32 42 53
14 12 28 32 42 53
14 12 28 32 42 53

 

第三次循环

14 12 28 32 42 53
12 14 28 32 42 53
12 14 28 32 42 53

 

循环直到排序结果:

12 14 28 32 42 53

列表的新增、修改、删除操作

函数名 描述
list.append(新元素) 在列表末端追加新元素
list.insert(索引,新元素) 在指定索引插入新元素
list[索引] = 新值 更新指定索引位置数据
list[起始索引:结束索引] = 新列表 更新指定范围数据
list.remove(元素) 删除指定元素
list.pop(索引) 按索引删除指定元素

例:

.append(新元素) # 在列表的末端追加新元素
.insert(索引,新元素) # 在指定索引插入新元素
list[索引] = 新值 更新指定索引位置数据
list[起始索引:结束索引] = 新列表 更新指定范围数据
list.remove(元素) # 删除指定元素
list.pop(索引) # 按索引删除指定元素
删除连续元素
list.[4:7] = []
删除列表中索引4到6的对应元素
# 列表的写操作
persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
# 列表的追加
persons.append("杨九")
print("列表的追加:", persons)
# 列表的插入
persons.insert(2, '刘二')
print("列表的插入:", persons)
persons.insert(len(persons), '候大')
print("列表的插入:", persons)

# 列表的更新
persons[2] = '宋二'
print("列表的更新:", persons)
# 列表范围取值是"左闭右开" 更新索引值3、4
persons[3:5] = ['王五', '李四']
print("列表的范围取值更新:", persons)

# 列表的删除操作
# 按元素内容删除
persons.remove('宋二')
print("按元素内容删除:", persons)
# 按索引值删除元素
persons.pop(4)
print("按索引值删除:", persons)
# 范围删除
persons[4:7] = []
print("范围删除:", persons)

执行以上程序输出结果为:

列表的追加: ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八', '杨九']
列表的插入: ['张三', '赵六', '刘二', '李四', '王五', '赵六', '钱七', '孙八', '杨九']
列表的插入: ['张三', '赵六', '刘二', '李四', '王五', '赵六', '钱七', '孙八', '杨九', '候大']
列表的更新: ['张三', '赵六', '宋二', '李四', '王五', '赵六', '钱七', '孙八', '杨九', '候大']
列表的范围取值更新: ['张三', '赵六', '宋二', '王五', '李四', '赵六', '钱七', '孙八', '杨九', '候大']
按元素内容删除: ['张三', '赵六', '王五', '李四', '赵六', '钱七', '孙八', '杨九', '候大']
按索引值删除: ['张三', '赵六', '王五', '李四', '钱七', '孙八', '杨九', '候大']
范围删除: ['张三', '赵六', '王五', '李四', '候大']

列表的其他常用方法

函数名 描述
list.count(元素) 统计元素出现的次数
list.append(列表) 将整个列表追加到末尾
list.extend(列表) 将列表中的元素追加到原始列表末尾
list.copy() 复制列表
list.clear() 清空列表
# 其他常用方法
persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']

# 统计出现次数
cnt = persons.count('赵六')
print("统计出现次数:", cnt)

# 追加操作
# append将整个列表追加到末尾,extend则是将列表中的元素追加到原始列表末尾
persons.append(['杨九', '吴十'])
print("追加操作:", persons)
persons.extend(['杨九', '吴十'])
print("追加操作:", persons)

# in(成员运算符) 运算符用于判断数据是否在列表中存在,存在返回True,不存在返回False
persons.remove('张三')
b = '张三' in persons
print("成员运算符:", b)

# copy 函数用于复制列表
# list.copy() 与 list1=list区别
persons1 = persons.copy()
persons2 = persons
print("复制列表:", persons1)
# is 身份运算符用于判断两个变量是否指向同一块内存
print("copy复制列表:", persons1 is persons)
print("list1=list:", persons2 is persons)


# clear 用于清空列表
persons.clear()
print("原列表:", persons)
print("copy复制列表:", persons1)
print("list1=list:", persons2)

执行以上程序输出结果为:

统计出现次数: 2
追加操作: ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八', ['杨九', '吴十']]
追加操作: ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八', ['杨九', '吴十'], '杨九', '吴十']
成员运算符: False
复制列表: ['赵六', '李四', '王五', '赵六', '钱七', '孙八', ['杨九', '吴十'], '杨九', '吴十']
copy复制列表: False
list1=list: True
原列表: []
copy复制列表: ['赵六', '李四', '王五', '赵六', '钱七', '孙八', ['杨九', '吴十'], '杨九', '吴十']
list1=list: []

项目中的使用场景

函数名 描述
str.split(“切割符号”) 分割成列表

例:

str1 = "张三,30,2000"
l = str1.split(",")


# 多维列表(嵌套列表)
# [[姓名,年龄,工资],[姓名,年龄,工资],[姓名,年龄,工资],[姓名,年龄,工资]]
# 字符串:"姓名,年龄,工资"例如: "张三,30,2000"
# str = "张三,30,2000"
# l = str.split(",")
# print(l)
emp_list = []
while True:
    info = input("请输入员工信息:")
    if info == "":
        print("程序结束")
        break
    info_list = info.split(",")
    if len(info_list) != 3:
        print("输入格式不正确,请重新输入")
        continue
    emp_list.append(info_list)
    # print(emp_list)

    for emp in emp_list:
        print("{n},年龄:{a},工资:{s}".format(n=emp[0],a=emp[1],s=emp[2]))

什么是字典

  • 字典(Dictionary)是Python中的内置数据结构
  • 字典非常适合表达结构化数据

例如:

{
    '姓名' : '王峰', '性别' : '男' , 
    '绩效评级':'A' , '岗位':'销售',
    '工资':1000 , '话费补贴':100
}

字典的特点

  1. 字典采用键(key):值(value)形式表达数据
  2. 字典中key不允许重复,value允许重复
  3. 字典是可修改的,运行时动态调整存储空间

创建字典的两种方式

使用{}创建字典

dict1 = {} # 空字典

使用dict函数创建字典

dict函数:
语法:
1.dict(键=‘值’,键=‘值’)#使用dict函数时,键不再需要 '' ,
键与值的链接也不再用:连接改用=连接

2.dict.fromkeys([‘键’,‘键’],‘N/A’)
# .fromkeys用列表来带入键,
这个方法有两个参数,
第一个参数是一个列表,里面放的是键,
第二个参数是赋予value的初始值,
这样创建的字典value默认为空,在列表后,‘默认值’可以给这些键赋予初始值
PS:N/A通常代表值为空
dict3 = dict(姓名='王峰',sex='男',hiredate='1997-10-20')
print(dict3)
结果:{'姓名': '王峰', 'sex': '男', 'hiredate': '1997-10-20'}

字典的取值操作

字典的取值:
变量名 = 字典名[‘key’]#获取指定键(key)的值(value)
字典名.get('key','默认值')
#get函数有两个参数:
第一个参数是需要获取数据的键;
第二个参数是若这个键不存在字典中时给它的默认值;
get函数可以获取不存在的key,其value返回None,可以再get函数的第二个参数赋予它默认值。

成员运算符in也可以用在字典内 返回true或false

字典取值遍历(通用key):

dict1 = {'name': 'bowyn', 'url': '7i5.com'}
for key in dict1:
    v = dict1[key]
    print(v)

执行以上程序结果:

bowyn
7i5.com

 

使用.items()函数遍历获取键值对

函数名 描述
dict.items() 返回字典的每一个键值对
for key,value in dict1.items(): 
    print(key, value)

执行以上程序结果:

name bowyn
url 7i5.com

字典更新与删除操作

函数名 描述
dict.update() 字典的新增、修改与更新
dict.pop(‘键(key)’) 删除指定的键值对(在参数中传入指定的key即可删除)
dict.popitem() 删除最后一个键值对(不需要传入任何参数,返回值是被删掉的键值对)
dict.clear() 清空字典

字典的更新操作

dict1 = {'name': 'bowyn', 'sex': "男", 'hiredate': '1996-03-20'}
#单个key/value进行更新
dict1['hiredate'] = '1996-01-01'
print(dict1)
#对多个kv进行更新
dict1.update(name='柒爱屋', sex='女')
print(dict1)

执行以上程序结果:

{'name': 'bowyn', 'sex': '男', 'hiredate': '1996-01-01'}
{'name': '柒爱屋', 'sex': '女', 'hiredate': '1996-01-01'}

 

字典的新增操作与更新操作完全相同,秉承有则更新,无则新增的原则

dict1 = {'name': 'bowyn', 'sex': "男", 'hiredate': '1996-03-20'}
dict1['admin'] = 'chen'
print(dict1)
dict1['admin'] = 'li'
print(dict1)
dict1.update(weight=80, dept='财务部')
print(dict1)

执行以上程序结果:

{'name': 'bowyn', 'sex': '男', 'hiredate': '1996-03-20', 'admin': 'chen'}
{'name': 'bowyn', 'sex': '男', 'hiredate': '1996-03-20', 'admin': 'li'}
{'name': 'bowyn', 'sex': '男', 'hiredate': '1996-03-20', 'admin': 'li', 'weight': 80, 'dept': '财务部'}

 

删除字典的相关函数
1. pop 删除指定的kv

dict1 = {'name': 'bowyn', 'sex': "男", 'hiredate': '1996-03-20'}
dict1.pop('hiredate')
print(dict1)

执行以上程序结果:

{'name': 'bowyn', 'sex': '男'}

2.popitem 删除最后一个kv

dict1 = {'name': 'bowyn', 'sex': "男", 'hiredate': '1996-03-20'}
kv = dict1.popitem()
print(kv) # 输出被删除的值
print(dict1) # 输出字典

执行以上程序结果:

('hiredate', '1996-10-20')
{'name': 'bowyn', 'sex': '男'}

 

清空字典(dict.clear())

dict1 = {'name': 'bowyn', 'sex': "男", 'hiredate': '1996-10-20'}
dt = dict1.clear()
print(dict1)
执行以上程序的结果:
{}

字典的常用操作

函数名 描述
dict.setdefault(‘key’, ‘vaule’) 为字典设置默认值,如果字典中有这个key则忽视默认值 如果没有则添加这个默认值
dict.keys() 获取字典所有的键
dict.values() 获取字典所有的值
dict.items() 获取字典所有的键对值
“name:{key}, str:{key}”.format_map(dict) 字典的格式化输出(传入{key}值

为字典设置默认值

dict1 = {'name': 'Bowyn', 'grade': 'B'}
dict1.setdefault('grade', 'B')
print(dict1)

执行以上程序的结果:

{'name': 'Bowyn', 'grade': 'B'}

 

字典的视图

1、获取字典所有的键

dict1 = {'name': 'Bowyn', 'grade': 'B'}
ks = dict1.keys()
print(ks)
print(type(ks))

执行以上程序的结果:

dict_keys(['name', 'grade'])
<class 'dict_keys'>

2、获取字典所有的值

dict1 = {'name': 'Bowyn', 'grade': 'B'}
vs = dict1.values()
print(vs)
print(type(vs))

执行以上程序的结果:

dict_values(['Bowyn', 'B'])
<class 'dict_values'>

3、获取字典所有的键对值

dict1 = {'name': 'Bowyn', 'grade': 'B'}
kv = dict1.items()
print(kv)
print(type(kv))
执行以上的程序的结果:
dict_items([('name', 'Bowyn'), ('grade', 'B')])
<class 'dict_items'>

 

字典的格式化输出

dict1 = {'name': 'Bowyn', 'grade': 'B'} 
emp_str1 = "姓名:{name},评级:{grade}".format_map(dict1) print(emp_str1)

执行以上程序的结果:

姓名:Bowyn,评级:B

散列值(Hash)

整数的哈希值就是本身,因为他本身就是唯一标识,每一个数据都有唯一的标识,保证了数据的稳定性,但是每次运行的哈希值是不一样的,只有同一次内是一样的。

  1. 字典也称为”哈希(Hash)”,对应”散列值”
  2. 散列值是从任何一种数据中创建数字”指纹”
  3. Python中提供了hash()函数生成散列值

哈希值在程序中一次运行中相同的数据无论调用(生成)多少次,哈希值都是相同的,例:

h1 = hash("abc")
h2 = hash("def")
h3 = hash("abc")
h4 = hash("def")
print(h1)
print(h2)
print(h3)
print(h4)

执行以上程序结果:

-1542785523233452110
7082138217045317036
-1542785523233452110
7082138217045317036

 

整数的散列值与本身一致,例:

h1 = hash(20191025)
h2 = hash(20181010)
print(h1)
print(h2)

执行以上程序结果:

20191025
20181010

字典的存储原理

key会先变成唯一的哈希值,然后转换成对应的内存地址,然后把value存储在内,他们并不是连续存储,是根据哈希散列值,而且也不是根据key的顺序来排列的,数据提取速度很快,因为每一个key对应了唯一散列值


key–转换—>hash()—存储—>内存地址
对于字典,通过key所对应的散列值找到对应的数据。
数据在内存中不是连续存储(列表、元组则是),也不是按照key的顺序排列。
通过字典提取数据比在列表中提取数据效率要高的多。

人已赞赏
0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
有新消息 消息中心
搜索