Python全栈__字典及其操作

1、字典

　　字典，基础数据类型之一，{}以键值对的形式存储数据。

　　以key : value 形式存储数据。例如，name 为 key，Laonanhai 为 value。

dic = {‘name‘: ‘Laonanhai‘,
        ‘age‘: 45,
       ‘name_list‘: [‘反面教材‘, ‘俊俊‘, ...]
       }

　　Python中唯一的映射类型。用以存储大量的关系型数据。

　　数据类型的分类：

　　　　可变类：

　　　　　　可变（不可哈希hash）：list、dict、set。例如list = [11, 222, 333]

　　　　　　不可变（可哈希hash）：str、int、tuple、bool。例如name = ‘alex‘

　　　　容器类：

　　　　　　容器类的数据类型：list、dict、tuple。例如l1 = [11, True, ‘alex‘, [22, 33, 44]]

　　　　　　非容器类的数据类型：int、str、bool。例如s1 = ‘[11, 22, 33]‘

　　字典的key必须是不可变的数据类型，是唯一的。

　　hash算法：

　　　　字典的键key通过hash表转换为数字，采用二分查找查询数字。

　　字典的value可以使任意的数据类型。

　　字典的查询速度非常快，可以存储大量的关系型数据。

　　字典在Python 3.5 包含3.5之前都是无序的，但在3.6之后是有序的。

2、字典的增删改查及其他操作

　　键唯一　　当存在一样的键时后面的覆盖前边的。例如：

dic = {
        ‘name‘: ‘alex‘,
        ‘name‘: ‘WuSir‘
}
print(dic)

　　键必须是不可变的可哈希的数据类型。当键为可变的不可哈希的数据类型是，输出提示错误。例如：

dic = {
        ‘name‘: ‘alex‘,
        [1, 2, 3]: ‘value‘
}
print(dic)

　　2、1 增

　　1、__[‘A‘] = ‘B‘　　A为键，B为值。直接增加，有则覆盖，无则添加。

　　　　无则添加。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic[‘sex‘] = ‘Laddy_boy‘
print(dic)

　　　　有则覆盖。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic[‘name‘] = ‘alex‘
print(dic)

　　2、 __.setdefault(‘A‘,‘B‘)  A为键，B为值。　　有责不变，无则添加。

　　无则添加。

　　当只添加A时，对应的B值默认为None。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic.setdefault(‘sex‘)
print(dic)

　　无则添加。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic.setdefault(‘sex‘,‘Laddyboy‘)
print(dic)

　　有责不变。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic.setdefault(‘name‘, ‘alex‘)
print(dic)

　　2、2 删

　　　　1、__.pop(‘A‘)　　有返回值，返回的是键对应的值。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
print（dic.pop（‘age’））print(dic)

　　当没有此键时，可修改默认返回值。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
print(dic.pop(‘age1‘, ‘没有此键...‘))
print(dic)

　　　　2、__.clear()　　清空字典。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic.clear()
print(dic)

　　　　3、__.popitem()　　随机删除，有返回值，返回值为元组，里面是删除的键值对。

　　在Python 3.5及包含3.5之前是无序删除，Python 3.6 以后是删除字典最后一位。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
print(dic.popitem())
print(dic)

　　　　4、del

　　　　　　（1）del __　　删除整个字典。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
del dic
print(dic)

　　　　　　（2）del dic[‘A‘]　　按照键A删除对应的键值对。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
del dic[‘name‘]
print(dic)

　　2、3 改

　　　　1、__[‘A‘] = ‘B‘　　有则覆盖，没有则添加。

dic = {‘name‘: ‘老男孩‘, ‘age‘: 56, ‘hobby‘: ‘women‘}
dic[‘name‘] = ‘Alex‘
print(dic)

　　　　　　2、A.update(B)　　AB分别为两个字典。两个字典的更新。　　将B字典的内容覆盖添加到A里面，B不变。

dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dic)
print(dic)
print(dic2)

　　2、4 查

　　　　1、__[‘A"]　　A为键。

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic[‘name‘])

　　当字典中没有查找的键是，打印报错。

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic[‘name1‘])

　　　　2、__.get(‘A‘)  A为键。

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.get(‘name‘))

　　当查找的键字典里没有时，默认打印输出None。例如：

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.get(‘name1‘))

　　当查找的键字典里面没有时，可将默认输出修改为自己需要的内容。例如：

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.get(‘name1‘,‘SB,没有此键‘))

　　　　3、for循环　　输出键。

dic = {"name": "jin", "age": 18, "sex": "male"}
for i in dic:
        print(i)

　　　　4、__.keys()　　打印输出的内容为键，打印输出的格式为 dict_keys

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.keys(), type(dic.keys()))

　　　　5、__.values()　　打印输出的内容为值，打印输出的格式为dict_values。

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.values(), type(dic.values()))

　　　　6、__.items()　　打印输出的内容为键值对，放在元组内。打印输出的格式为dict_items

dic = {"name": "jin", "age": 18, "sex": "male"}
print(dic.items(), type(dic.items()))

　　使用for循环将键循环打印出来。

dic = {"name": "jin", "age": 18, "sex": "male"}
for key in dic.keys():
        print(key)

　　将键转换成列表打印出来。

dic = {"name": "jin", "age": 18, "sex": "male"}
l_key = list(dic.keys())
print(l_key)

　　使用for循环将值循环打印出来。

dic = {"name": "jin", "age": 18, "sex": "male"}
for i in dic.values():
        print(i)

　　将输出转换成列表打印出来。

dic = {"name": "jin", "age": 18, "sex": "male"}
l_values = list(dic.values())
print(l_values)

　　7、分别赋值概念

a, b = 1, 2
print(a, b)


a, b = (‘alex‘, ‘34‘)
print(a, b)


a, b = [‘alex‘, ‘34‘]
print(a,b)

　　有如下：

　　　　a = 1

　　　　b = 3

　　用一行代码实现a b值互换。

a = 1
b = 3
a, b = b, a
print(a, b)


for i in [22, 33, 44]:
        print(i)


for i in [(11, 22), (33, 44), (55, 66)]:
        print(i)


k, v = (‘name‘, ‘老男孩‘)
print(k, v)


dic = {"name": "jin", "age": 18, "sex": "male"}
for k, v in dic.items():
        print(k, v)

3、字典的嵌套

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}

　　1、给dic添加一个键值对，学校：老男孩。

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}
dic[‘学校‘] = ‘老男孩‘
print(dic)

　　2、将status对应的值改为True。

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}
dic[‘status‘] = True
print(dic)

　　3、给name_list追加一个元素‘平平’。

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}
dic[‘name_list‘].append(‘平平‘)
print(dic)

　　4.给personal_msg对应的字典添加一个键值对sex：男。

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}
dic[‘personal_msg‘][‘sex‘] = ‘男‘
print(dic)

　　5、将hobby_list对应的列表中的烫头改成唱歌。

dic = {
    ‘name_list‘: [‘碗蓉‘, ‘俊俊‘, ‘爽妹‘],
    ‘status‘: None,
    ‘personal_msg‘: {
        ‘name‘: ‘反面教材‘,
        ‘age‘: 25,
        ‘hobby_list‘: [‘抽烟‘, ‘喝酒‘, ‘烫头‘],
    }
}
dic[‘personal_msg‘][‘hobby_list‘][-1] = ‘唱歌‘
print(dic)

原文地址：https://www.cnblogs.com/ZN-225/p/9587957.html

时间： 2024-10-29 10:48:30

Python全栈__字典及其操作的相关文章

Python全栈__字符串初识及操作

基础数据类型初识 1.int型 int:用于计算. 十进制转化成二进制的有效位数. 1 0000 0001 2 0000 0010 3 0000 0011 ... ... 100 ? 计算十进制转化成二进制的有效位数..bit_length() i = 100 print(i.bit_length()) 2.字符串str str: 'alex'.'1235443543'.'[1,2,3]'.可存放少量数据. 索引.切片.步长 索引编号: python12期 012345678 p 的正向索引编号

Python全栈__函数的有用信息、带参数的装饰器、多个装饰器装饰一个函数

1.函数的有用信息 代码1: 1 def login(username, password): 2 """ 3 此函数需要用户名,密码两个参数,完成的是登录的功能. 4 :return: True 登录成功. False登录失败. 5 """ 6 print(login.__name__) 7 print(login.__doc__) 8 print('登录成功...') 9 return True 10 11 print(login.__nam

Python全栈__数据类型的补充、集合set、深浅copy

1.数据类型的补充 1.1 元组 当元组里面只有一个元素且没有逗号时,则该数据的数据类型与括号里面的元素相同. tu1 = ('laonanhai') tu2 = ('laonanhai') print(tu1, type(tu1)) print(tu2, type(tu2),) tu1 = (1) tu2 = (1,) print(tu1, type(tu1)) print(tu2, type(tu2)) tu1 = ([1, 2, 3]) tu2 = ([1, 2, 3],) print(t

Python全栈__函数的初识、函数的返回值、函数的参数

1.函数的初识 def关键字 空格 函数名(与变量名命名规则相同):英文冒号 函数体 执行函数:函数名+() 函数是以功能为导向的. def login(): pass def register(): pass 1 def my_len(): 2 l1 = [1, 2, 3, 1, 6, 9, 10] 3 count = 0 4 for i in l1: 5 count += 1 6 my_len() 2.函数的返回值 return: 1.函数中遇到 return 结束函数,下面代码不执行. d

Python全栈开发之文件操作

No.1 文件的概念 文件的概念和作用 计算机中的文件,就是存储在某种长期储存设备上的一段数据流 计算机中的文件,可以在需要的时候使用 文件的存储方式 文本文件 可以使用文本编辑器查看 本质上还是二进制文件 二进制文件 保留的内容不能直接查看,而是提供给其他软件查看 图片.音频.视频等都是二进制文件 No.2 文件的基本操作 操作文件的基本套路 打开文件 读写文件 关闭文件 操作文件的函数 函数 说明 fp.read([size]) size为读取的长度,以byte为单位 fp.readline

Python全栈__服务器与多客户端通信、UDP协议、pycharm打印带颜色输出、时间同步的机制

1.服务器与多客户端通信 1 import socket 2 # 创建tcp socket的套接字 3 sk = socket.socket() 4 # bind 5 sk.bind(('127.0.0.1',8080)) 6 # 监听 7 sk.listen(5) 8 # 等待连接 9 while 1: 10 conn, addr = sk.accept() 11 while 1: 12 msg_s = input('>>>') 13 conn.send(msg_s.encode('u

Python全栈__动态参数、名称空间、作用域、作用域链、加载顺序、函数的嵌套、global、nonlocal

1.动态参数 当实参数量与形参数量相等时,参数传递正常. def func1(a, b, c): pass func1(1, 2, 3) 当实参数量与形参数量不相等时,则会报错. def func1(a, b, c): pass func1(1, 2, 3, 4, 5, 6, 6) 用户传入到函数中的实参数量不确定时,或者为了以后扩展,此时要用到动态参数 *args  **kwargs(万能参数). 顺序: 位置参数,*args,默认参数,**kwargs 1.*args *args是接收的是所

Python全栈开发【基础三】

Python全栈开发[基础三]  本节内容: 函数(全局与局部变量) 递归 函数 一.定义和使用 函数最重要的是减少代码的重用性和增强代码可读性 1 def 函数名(参数): 2 3 ... 4 函数体 5 ... 6 返回值 函数的定义主要有如下要点: def:表示函数的关键字 函数名:函数的名称,日后根据函数名调用函数 函数体:函数中进行一系列的逻辑计算 参数:为函数体提供数据 返回值:当函数执行完毕后,可以给调用者返回数据. 总结使用函数的好处: 1.减少代码重用 2.保持一致性,易维护

python 全栈开发，Day30(第一次面向对象考试)

月考题: python 全栈11期月考题 一 基础知识:(70分) 1.文件操作有哪些模式?请简述各模式的作用(2分) 2.详细说明tuple.list.dict的用法,以及它们的特点(3分) 3.解释生成器(generator)与函数的不同,并实现且使用简单generator(3分) 4.如何理解lambda函数/表达式(2分) 5.a=10 b=20 def test(a,b): print(a,b) c = test(b,a) print(c) 上述代码中,打印出来的值a,b,c分别是什么