python学习 07基本数据类型之字典类型

一、字典

1.1 字典的定义

字典的由来：
因为集合无序，因此集合中的数据不能很便捷地取出特定的元素，利用集合元素不重复的特性，使集合中的元素映射值组成键值对，再通过键来获取对应的值。

字典的定义：
python中的字典(dict)数据类型就是键值对的集合，使用一对大括号进行定义，每对键值对之间使用逗号隔开，键和值使用冒号分割。
{key:value, key1:value1,…}
字典的key，本质上是集合，必须是不可变类型，且不会重复。绝大多数情况下，我们使用字符串作为key，而value可以是任意数据类型。

a = {}                      # 空字典
b = {
    1: 2,                   # key:数字；value：数字
    2: 'hello',             # key:数字；value：字符串
    ('k1',): 'v1',          # key:元祖；value：字符串
    'k2': [1, 2, 3],        # key:字符串；value：列表
    'k3': ('a', 'b', 'c'),  # key:字符串；value：元祖
    'k4': {                 # key:字符串；value：字典
        'name': 'feifei',
        'age': '18'
    }
}

print('a的类型为：', type(a))    # a的类型为： <class 'dict'>
print('b的类型为：', type(b))    # b的类型为： <class 'dict'>

python中字典使用dict表示
注意：字典的key本质上是集合，必须是不可变类型,且不会重复，而value可以是任意类型。
例题：

1.2 字典的索引

字典通过键值对中的键作为索引来获取对应的值，字典中的键是无序的
语法如下
dict[key]

xinlan = {
    'name': '心蓝',
    'age': 18,
    'sex': '男',
    'hobby': ['健身', '阅读'],
    'friends': [
        {
            'name': '刘德华',
            'age': 59,
            'sex': '男'
        },
        {
            'name': '王组贤',
            'age': 58,
            'sex': '女'
        }
    ]
}
print(xinlan['name'])  #   心蓝 表示从字典xinlan中去取key为'name'的值  心蓝
print(xinlan['age'])   #   18   表示从字典xinlan中去取key为'age'的值   18
如果要拿到健身怎么办？
print(xinlan['hobby'][0])  # 健身
# 如果要取到王祖贤应该怎么做？
print(xinlan['friends'][1]['name'])  # 王祖贤
注意：不存在的key会报错

1.3 字典的常用操作

增

• 增加一个 直接利用key索引赋值的方式可以添加元素，如果增加的key已存在，则会修改原来的key所对应的值。

xinlan = {'name':'心蓝'}
xinlan['age']=18
print(xinlan)    # {'name': '心蓝', 'age': 18}

• 增加多个 .update(new_dict),将new_dict合并到字典中
  把一个新字典合并到前面的字典中去。

xinlan = {'name':'心蓝'}
new_dict = {'age':18, 'height':170}
res = xinlan.update(new_dict)
print(xinlan)     # {'name': '心蓝', 'age': 18, 'height': 170}

注意 ： 当我们去update的时候有重复的key的时候会覆盖原值(会修改)
删

• .pop(key[,d])，删除指定key对应的值，并返回该值，[,d]可写可不写。

xinlan = {'name': '心蓝'}
res = xinlan.pop('name')
print(res)      #  心蓝
print(xinlan)   #  {}

如果不存在这个key则返回d，如果没有给定d，则抛出异常。

xinlan = {'name': '心蓝'}
res = xinlan.pop('age', -1)
print(res)    # -1
print(xinlan)  # {'name': '心蓝'} 

• popitem(), 按照LIFO(last-in, first-out)后进先出的方式删除dict中的一个键值对，并以二元元组(key, value)的方式返回。
  

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
res = xinlan.popitem()
print(res)   #  ('sex', '男')

• clear() 清空字典

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
res = xinlan.clear()
print(xinlan)     # ｛｝

修改

• 直接通过key赋值，理解为替换也可以

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
xinlan['name'] ='xinlan'
print(xinlan)    # {'name': 'xinlan', 'age': 18, 'sex': '男'}

• 修改多个 .update

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
new_dict ={'name':123, 'age':456}
xinlan.update(new_dict)
print(xinlan)   #   {'name': 123, 'age': 456, 'sex': '男'}

在key相同的情况下会更新原来key所对应的值
查询

• 通过key直接获取对应的值

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
print(xinlan['name'])   # 心蓝

• .get(key, defaul=None) 获取key对应的值,如果key不存在则返回default,其中 default可以指定

xinlan = {'name': '心蓝', 'age':18,'sex':'男'}
print(xinlan.get('name'))  #　心蓝
print(xinlan.get('height')  # None
print(xinlan.get('height', -1)  #  -1

如果不确定里面是不是有要查找的key，直接用key去寻找可会报错，用get会更安全一些。

• .keys() 返回字典的所有key（键）
• .values() 返回字典的所有的value（值）

xinlan = {'name': '心蓝', 'age': 18, 'sex': '男'}
print(xinlan.keys())
print(xinlan.values())
#  dict_keys(['name', 'age', 'sex'])
#  dict_values(['心蓝', 18, '男'])

• dict.items() 返回字典的键值对

xinlan = {'name': '心蓝', 'age': 18, 'sex': '男'}
print(xinlan.items())
#  dict_items([('name', '心蓝'), ('age', 18), ('sex', '男')])

• 例题
  
• 

二、其他数据类型

2.1 布尔型 bool

条件表达式的运算结果返回布尔型(bool),布尔型数据只有两个，True 和 False 表示 真和假 (注意首字母大写)
布尔型是整数的子类
True 1 真
False 0 假

2.2 比较运算符

比较运算符运算后的结果是布尔型

==
!=
>
<
>=
<=
a = 1
b = 1
print(a==b)  # True
print(a>b)   # False
a = 300
b = 300
a == b  # True
a is b  # False  注意：小整数池的范围是 -5 - 256
c = a
c is a  # True  is 和 == 的区别，面试和笔试经常考
1 != 2  # True

数据和数据做比较都有一定的规则
对于字符串，可以通过unicode进行比较
查看字符编码通过ord(str) ，只接收单个字符

>>> '吴'>'无'
False
>>> ord('吴')
21556
>>> ord('无')
26080
>>>

注意：一定要是相同的才能比较

2.3 成员运算符

成员运算符用于检查某个对象是否在另外一个对象中。
包含两个运算符 in 、not in

• x in y : x是否是y的一个元素， 是返回True ，否返回False
• x not in y : x 是否不是y的一个元素，不是返回True,是返回False

ls = [1, 2, 3]
print(1 in ls)   # True
print(6 in ls)   # False
1 in(1,2,3)  # True
s = ['abcdefg'] #   s是一个列表，这个列表里面只有一个元素就是这个字符串，在外面套了一层，'a'in s  'a'是否是s中的一个元素
'a' in s   ?  # False  如果这样写 s = 'abcdefg'   'a' in s  # True  不会往里面递归地找只会找一层。
st = {1, 2, 3} 
1 in st  # True
'a' not in ls  # True

成员运算符，序列类型(str,list,tuple)、集合、字典都可以用
特别要注意的是：当成员运算符用在字典中时，默认检查的是字典的key。 # 字典检索key很快

print('a' in {'a': 'b'})  #  True   
print('b' in {'a': 'b'})  #  False   # 检查的是字典的key

例题：

'ac’是连在一起的，相当于一个子串，s里面没有一个’ac’这样子的子串，所以’ac’不在s里面，答案是True.

2.4 布尔型运算

布尔型数据可以和数值类型数据进行数学计算，这时，‘True’表示整数’1’, ‘False’表示整数’0’
布尔型是整数的子类

print(True+1)　　　# 2
print(False+1)　　 # 1
print(True+False)  # 1
print(True+1.1)   # 2.1

print(type(True))   #  <class 'bool'>

python中使用bool 表示布尔型

2.5 布尔类型转换

任意数据都可以通过函数bool转换成布尔型

a = 1
print(bool(a))  # True
b = 0 
print(bool(b))  # False

实际上所有的数据都可以通过bool这个内置函数将数据转化为布尔型，也就是说任何数据都可以转换成True或Fasle。
在python中,None, 0(整数), 0.0(浮点数), 0.0+0j(复数), ‘’(空字符串), [] (空列表), ()(空元组), set()（空集合), {} (空字典),的布尔值都是False，其他数值为True。

print(bool(0))
print(bool(0.0))
print(bool(0.0 + 0.0j))
print(bool(''))
print(bool([]))
print(bool(()))
print(bool(set()))
print(bool({}))
print(bool(None))
False
False
False
False
False
False
False
False
False

2.5 逻辑运算

逻辑运算符
逻辑运算符两边的表达式不是布尔型时，在运算前会转换成布尔型。

• and 与 基本规则： 两个为都为真才为真

True and True   #  True
True and False  #  False
False and True  #  False
False and False #  Fasle
1 and 2  # 2  会去布尔一下1看它是True还是False，然后再去布尔一下2，看它是True还是False。
# and左边是True的时候，决定整个逻辑运算表达式值应该由右边的值来决定（原因)
# 当and左边为True的时候，整个逻辑运算表达式的结果就是右边的值(结果)
True and 0  #  0
True and '' # ''
这个叫短路,当and的左边为False的时候没有必要去算右边
当 and的左边是False的时候
0 and 1  # 0
'' and 'a'  # ''
{} and {'name':'心蓝'  # {}

• or 或 基本规则 ：有一个为真就为真，都为假的时候才为假

True or False  # True
False or True  # True
True or True   #  True
False or False # False
1 or 0  #  1 当左边为True的时候，就没有必要算右边的，直接返回左边的值。
0 or '' #  '' 当左边为False的时候，整个逻辑表达式的结果就是右边的值。 

• not 取反（not运算符返回的永远是True或者False）

not False  # True
not True   # False
not 0  #  True
note 'a' #  False

逻辑运算符的优先级：not > and >or　
例：

做这道题，要首先注意：not运算符运算后的结果一定是布尔型。所以 not 1 的结果是 Fasle
然后是 False and 1 and 运算符，两边都是真，结果才为真。所以答案为False。

2.6 None

None是python中的特殊数据类型，它的值就是它本身None，表示空，表示不存在。
print(None) # None 注意首字母大写