【2020Python修炼记10】Python语法入门—基本数据类型_字典+集合+布尔值

一、字典

1、什么是字典

 如果我们需要用一个变量记录多个值，但多个值是不同属性的，比如人的姓名、年龄、身高，用列表可以存，

但列表是用索引对应值的，而索引不能明确地表示值的含义，

这就用到字典类型，字典类型是用key：value形式来存储数据，其中key可以对value有描述性的功能

2、定义字典

定义：{}内用逗号分隔开多个 key：value，

其中value可以是任意类型，

但是 key 必须是不可变类型,且不能重复 

# 造字典的方式一：

d={'k1':111,(1,2,3):222}  # d=dict(...)
print(d['k1'])
print(d[(1,2,3)])
print(type(d))

d={} # 默认定义出来的是空字典
print(d,type(d))

# 造字典的方式二：

d=dict(x=1,y=2,z=3)
print(d,type(d))

3、数据类型转换

3.1 其他类型——>字典:dict()

引子：

info=[
    ['name','egon'],
    ('age',18),
    ['gender','male']
]
d={}
for k,v in info: # k,v=['name','egon'],
    d[k]=v
print(d)

# 造字典的方式三：dict()

res=dict(info) # 一行代码搞定上述for循环的工作
print(res)

# 造字典的方式四: 快速初始化一个字典——d={}.fromkeys( ,None)

keys=['name','age','gender']
# d={}
# for k in keys:
#     d[k]=None
# print(d)
d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
print(d)

3.2 字典——>其他类型：输出的是key值

4、内置方法

#优先掌握的操作：

 # 1、按key存取值：可存可取

d={'k1':111}
针对赋值操作：key存在，则修改
d['k1']=222
针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d)

#2、长度len

d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d)
print(len(d))

#3、成员运算in和not in:根据key

d={'k1':111,'k2':2222}
print('k1' in d)
print(111 in d)

#4、删除

d={'k1':111,'k2':2222}

# 4.1 通用删除：del

del d['k1']
print(d)

# 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值

res=d.pop('k2')
print(d)
print(res)

# 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)

res=d.popitem()
print(d)
print(res)

#5、键keys()，值values()，键值对items()

# 在python3中得到的是老母鸡
d={'k1':111,'k2':2222}

'''
# 在python2中
>>> d={'k1':111,'k2':2222}
>>> 
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>> dict(d.items())
{'k2': 2222, 'k1': 111}
>>>
'''

#6 for 循环

for k in d.keys():
    print(k)

for k in d:
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():
    print(k,v)


print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

#需要掌握的内置方法

#1、d.clear()

#2、d.update()

d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d)

#3、d.get() ：根据key取值，容错性好

print(d['k2'])  # key不存在则报错

print(d.get('k1')) # 111
print(d.get('k2')) # key不存在不报错，返回None

#4、d.setdefault()

info={}
if 'name' in info:
    ... # 等同于pass
else:
    info['name']='egon'
print(info)

# 4.1 如果key有则不添加,返回字典中key对应的值

info={'name':'egon'}
res=info.setdefault('name','egon')
# print(info)

print(res)

# 4.2 如果key没有则添加，返回字典中key对应的值

info={}
res=info.setdefault('name','egon')
# print(info)
print(res)

 二、集合

1、什么是集合

 集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

2、定义集合 

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})
s={1,[1,2]} # 集合内元素必须为不可变类型
s={1,'a','z','b',4,7} # 集合内元素无序
s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，
        的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict字典，也可以用于定义集合，
       但是字典内的元素必须是key:value的格式，
       一个空字典和空集合，该如何准确去定义两者?

d = {} # 默认是空字典 

s = set() # 这才是定义空集合

3、类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

set({1,2,3})
res=set('hellolllll')
print(res)

print(set([1,1,1,1,1,1]))
print(set([1,1,1,1,1,1,[11,222]]) # 报错

print(set({'k1':1,'k2':2}))

4、内置方法

4.1【集合运算】

涉及关系运算符
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}

4.1.1 取交集：两者共同好友 ——&

res=friends1 & friends2
print(res)
print(friends1.intersection(friends2))

4.1.2 取并集 / 合集：两者全部好友—— |

print(friends1 | friends2)
print(friends1.union(friends2))

4.1.3 取差集：—— -

取 friends1 独有的好友

print(friends1 - friends2)
print(friends1.difference(friends2))

 取 friends2 独有的好友

print(friends2 - friends1)
print(friends2.difference(friends1))

4.1.4 取对称差集：取出两者各自独有的好友（即 去除共同部分，留下两者各自独有的部分） —— ^

print(friends1 ^ friends2)
print(friends1.symmetric_difference(friends2))

4.1.5 父子集：包含关系 

s1={1,2,3}
s2={1,2,4}
不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)

s1={1,2,3}
s2={1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s2  =>True

s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))

4.2【去重】

# 1、只能针对不可变类型去重

print(set([1,1,1,1,2]))

# 2、无法保证原来的顺序

l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)

l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)

# 其他操作

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

4.3【其他内置方法】

# 需要掌握的内置方法 

1：discard（）

s.discard(4) # 删除元素不存在do nothing
print(s)
s.remove(4) # 删除元素不存在则报错

2：update（）

s.update({1,3,5})
print(s)

3：pop（）

res=s.pop()
print(res)

4：add（）

s.add(4)
print(s)

# 其余方法

1、
res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res)

2、
s.difference_update({3,4,5}) # s=s.difference({3,4,5})
print(s)

 三、布尔值

1、作用

用来记录真假这两种状态

2、定义

>>> is_ok = true 
>>> is_ok = false

3、使用

• 通常用来当作判断的条件，我们将在if判断中用到它。
• 一般除了 0，none，空 三种为 false，其余基本数据类型 均为 true
• 注意，在Python解释器中布尔值的英文表示，首字母要大写，真——True，假——False

四、数据类型的总结

——数字类型（int，float），字符串，列表，元祖，字典，集合

1、存储空间的占用：

 

2、存值个数：

 

3、访问方式

 

4、可变/不可变