Python_day04_字典_集合_控制语句初步

字典

字典是"键值对"的无序可变序列，每个元素都是一个键值对。包含键对象和值对象。可以通过键对象实现快速获取删除更新对应的值对象。
列表中我们通过"下表数字"找到对应的对象，字典中通过"键对象"找到对应的"值对象"。
此处的键是任意的不可变的数据，而且键必须是唯一的，不可重复的。
但是值是任意的数据，并且可重复。
定义方式:

>>> a = {'name':'GSH','age':'18','school':'北大'}
>>> a
{'name': 'GSH', 'age': '18', 'school': '北大'}
>>> a.get('name')
'GSH'
>>> a['name']
'GSH'

字典的创建

创建字典的几种方式:

>>> a = {'name':'GSH','age':19,'学校':'北大'} # 标准定义
>>> a = dict(name = 'GSH',age = 12,job = 'student') # 用dict函数
>>> a = dict([("name","GSH"),("age",18)]) # 键值对创建
>>> c = {}  # 空的字典
>>> d = dict() # 空的字典
>>> k = ['name','age','job'] # 键对象集合
>>> v = ['GSH',12,'teacher'] # 值对象集合
>>> d = dict(zip(k,v)) # 通过zip()函数创建 前者k 是 键，后者v 是值。
>>> d
{'name': 'GSH', 'age': 12, 'job': 'teacher'}
>>> a = dict.fromkeys(['name','age','job']) # 通过fromkeys创建值为空的字典
>>> a
{'name': None, 'age': None, 'job': None}
>>> 

字典元素的访问:

a = {'name': 'GSH', 'age': 12, 'job': 'teacher'}

1. 通过键的方式来访问

>>> a = dict.fromkeys(['name','age','age'])
>>> a
{'name': None, 'age': None}
>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}
>>> a = {'name':'GSH','age':19,'学校':'北大'}
>>> a
{'name': 'GSH', 'age': 19, '学校': '北大'}
>>> a['name']
'GSH'
>>> a['age']
19
>>> a['学校']
'北大'
>>> a[0]

2. 通过get()的方式来访问

>>> a['name']
'GSH'
>>> a.get("name")
'GSH'
>>> a.get("age")
19
>>> a
{'name': 'GSH', 'age': 19, '学校': '北大'}
>>> a.get("学校")
'北大'
>>> a.get("ddd","no exit()") # 如果没有这个key时，后面的元素是默认的输出的字符串
'no exit()'

3. 列出(遍历)所有的键值对的方法items()和len()返回有多少键值对。

>>> a.items()
dict_items([('name', 'GSH'), ('age', 19), ('学校', '北大')])
>>> a.values()
dict_values(['GSH', 19, '北大'])
>>> a.keys()
dict_keys(['name', 'age', '学校'])
>>> len(a)
3

4. 检测一个键是否存在于字典之中。

>>> "name" in a
True

字典元素添加,修改,删除:

1. 字典的添加: 给字典新增"键值对"。如果"键"已经存在，则覆盖旧的键值对;如果"键"不存在，则新增"键值对"。

>>> a = {'name':'GSH','age':19,'学校':'北大'}
>>> a
{'name': 'GSH', 'age': 19, '学校': '北大'}
>>> a['address'] = '天津' # 此时不存在地址 添加进去即可
>>> a
{'name': 'GSH', 'age': 19, '学校': '北大', 'address': '天津'}
>>> a['age'] = 22 # 此时年龄以前有 现在进行覆盖
>>> a
{'name': 'GSH', 'age': 22, '学校': '北大', 'address': '天津'} 

2. 使用update()将新字典中所有的键值对全部添加到旧字典对象上,如果key有重复,则直接回覆盖。

>>> a
{'name': 'GSH', 'age': 22, '学校': '北大', 'address': '天津'}
>>> b = {"sex":"boy","money":"一万亿","job":"老师","学校":"清华"}  # 此时"学校"这个key重复 下面将会覆盖 其他都会添加到a字典里。
>>> a.update(b) # 把b覆盖近a
>>> a
{'name': 'GSH', 'age': 22, '学校': '清华', 'address': '天津', 'sex': 'boy', 'money': '一万亿', 'job': '老师'}
>>> 

3. 字典中元素的删除:可以使用del()方法;或者clear()删除所有键值对;pop()删除指定键值对，并返回对应的值对象。

>>> a
{'name': 'GSH', 'age': 22, '学校': '清华', 'address': '天津', 'sex': 'boy', 'money': '一万亿'}
>>> b = a.pop('sex')
>>> b
'boy'
>>> a.clear()
>>> a
{}
>>> 

4. popitem():随机删除和返回该键值对。 字典是"无序可变序列"，因此没有第一个元素，最后一个元素的概念。popitem弹出随机的项，因为字典并没有"最后元素"或者其他顺序的概念，所以用此方法可以一个接一个的移除并处理项。

>>> a = {'name':'GSH','age':19,'学校':'北大'}
>>> a.popitem()
('学校', '北大')
>>> 

序列解包:

序列解包可以用于元祖，列表，字典。序列解包可以让我们方便对多个变量赋值。

>>> x,y,z = (10,20,30)
>>> x
10
>>> y
20
>>> z
30
>>> type(x)
<class 'int'>
>>> (a,b,c) = (8,9,10)
>>> a
8
>>> type(a)
<class 'int'>
>>> [a,b,c] = [10,2,30]
>>> a
10
>>> type(a)
<class 'int'>
>>> 

当用于字典时，默认是对键进行操作;
如果需要对键值对操作，则需要使用items()
如果需要对值进行操作，则需要使用values();

>>> a = {'name':'GSH','age':19,'学校':'北大'}
>>> a
{'name': 'GSH', 'age': 19, '学校': '北大'}
>>> type(a)
<class 'dict'>
>>> s = {'name':'GSH','age':19,'学校':'北大'}
>>> a,b,c = s # 此时默认的是对键进行操作
>>> a
'name'
>>> b
'age'
>>> c
'学校'
>>> name,age,学校 = s.items() # 对键值对进行操作
>>> 学校
('学校', '北大')
>>> name,age,学校 = s.values() # 对值进行操作
>>> name
'GSH'
>>> age
19
>>> 学校
'北大'
>>> s = {'name':'GSH','age':19,'学校':'北大'}
>>> s
{'name': 'GSH', 'age': 19, '学校': '北大'}
>>> a,b,c = s.items() # 不一定非要用键进行命名
>>> a
('name', 'GSH')
>>> b
('age', 19)
>>> c
('学校', '北大')
>>> 

练习:表格数据使用字典和列表储存，并实现访问

r1 = {'name':'张三','age':18,'薪资':30000,'city':'北京'}
r2 = {'name':'李四','age':20,'薪资':35660,'city':'广州'}
r3 = {'name':'王五','age':22,'薪资':23040,'city':'天津'}

tb = [r1,r2,r3]

# 获得第二行人的薪资
# print(tb[1].get("薪资"))

#打印表中所有的薪资
for x in range(3):
        print(tb[x].get('city'))

#打印表中所有的数据
for x in range(3):
        print(tb[x])

输出:

北京
广州
天津
{'name': '张三', 'age': 18, '薪资': 30000, 'city': '北京'}
{'name': '李四', 'age': 20, '薪资': 35660, 'city': '广州'}
{'name': '王五', 'age': 22, '薪资': 23040, 'city': '天津'}

字典核心底层原理:
每个字典元素都是一个bucket，每个结构都是一样的，每个bucket分为两个部分，分别是键对象的引用和值对象的引用。
我们可以通过偏移量来读取指定的bucket。
启示: 不要一边遍历一边进行字典的修改。

集合

集合是无序可变，元素不可以重复，底层实现就是字典的键对象，所以是不能重复而且唯一的。

集合的创建:

>>> a = {2,3,4}
>>> a
{2, 3, 4}
>>> type(a)
<class 'set'>
>>> a.add(5) #用add方法添加元素
>>> a
{2, 3, 4, 5}
>>> 

使用set()函数来把别的元祖列表转化成我们的集合，如果原来是有重复的数据，则只会保留一个。

>>> a = [2,3,4,5]
>>> a
[2, 3, 4, 5]
>>> b = set(a)
>>> b
{2, 3, 4, 5}
>>> type(b)
<class 'set'>

remove()删除指定元素;clear()清空整个集合。

>>> a = {10,20,30}
>>> a
{10, 20, 30}
>>> a.remove(20)
>>> a
{10, 30}
>>> a.clear()
>>> a
set()
>>>

集合相关操作:
像数学中概念一样，Python中对集合提供了并集 交集 差集等运算:

>>> x = {1,3,'GSH'}
>>> y = {'he','it','GSH'}
>>> x|y # 并集
{1, 3, 'GSH', 'it', 'he'}
>>> x&y # 交集
{'GSH'}
>>> x-y # 差集
{1, 3}
>>> x.union(y) # 并集
{1, 3, 'GSH', 'it', 'he'}
>>> x.intersection(y) # 交集
{'GSH'}
>>> x.difference(y) # 差集
{1, 3}
>>> 

控制语句

这是一座代码大楼:

• 数据 = “砖块”
• 数据类型(整型,浮点型,布尔) + 序列(字符串,列表,元祖,字典,集合) = 数据的组织方式
• 流程控制语句 = 代码的组织方式 = “混凝土”

选择结构

单分支结构

if 条件表达式:
	语句/语句块

比如:

num = int(input("输入一个数字:"))
if num < 10:
    print(num)

测试各种条件表达式:

if 3:
    print("OK") # 执行

a = []
if a:
    print("空列表:",False) # 因为a是个空列表是False 不执行

s = 'False' # 它就是个字符串 这个字符创并不是空的 所以它其实是True
if s:
    print("非空字符串,是True")

c = 9
if 3<c<20:
    print("3<c<20:") # 执行
if 3<c and c<20:
    print('3<c and c<20') # 执行

if True:
    print("True") # 执行

总结: 在选择和循环结构中，条件表达式的值为False的情况下:
False、0、 0.0、空置None、空序列对象(空列表、空元祖、空集合、空字典、空字符串)、空range对象。空迭代对象。

注意: 条件表达式中，不可以出现'='，这里是赋值语句，不是判断语句。'=='才是判断语句。

双分支结构

基本语法

if 条件表达式:
	语句1/语句块1
else:
	语句2/语句块2

举例:

s = int(input("请输入一个数字: "))
if s < 10:
    print('s小于10')
else:
    print('s大于等于10')

三元条件运算符

条件为真时的值 if (条件表达式) else 条件为假的时的值

s = int(input("请输入一个数字: "))
if s < 10:
    print('s小于10')
else:
    print('s大于等于10')
# 就相等于下面的这一句话
print("s小于10" if s < 10 else "s大于等于10")

多分支结结构

基础语法

if 条件表达式1:
		语句1/语句块1
elif 条件表达式2:
		语句2/语句块2
.....
elif 条件表达式n:
		语句n/语句块n
[else: # 可选可不写
		语句n+1 / 语句块n+1
]

多分支结构，几个分支之间是有逻辑关系的，不可以随意颠倒顺序。
举例:

score = int(input("请输入分数: "))

grade = ""
if score < 60:
    grade = "不及格"
elif score < 80: # 60-80 这是有逻辑顺序的 先判断是不是小于60之后才判断此行 所以不用写大于等于60了
    grade = "及格"
elif score <90:
    grade = "良好"
else:
    grade = "优秀"

print("分数是{0},等级是{1}".format(score,grade))

选择结构的嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。

if 条件表达式1:
	语句1/语句块1
		if 条件表达式2:
			语句2/语句块2
		else:
			语句3/语句块3
else:
	语句是4/语句块4

举例:

score = int(input("请输入一个分数: "))
grade = ""
if score>100 or score<0:
    print("请输入一个0-100的分数")
else:
    if score < 60:
        grade = "不及格"
    elif score < 80:
        grade = "及格"
    elif score < 90:
        grade = "良好"
    else:
        grade = "优秀"
    print("分数是{0},等级是{1}".format(score,grade))

循环结构

while循环

基本语法:

while 条件表达式:
		循环体语句

例子: 利用while循环打印0-10的数字:

a = 0
while a<10:
    a += 1 # 条件判断控制
    print(a)

结果:

1	2	3	4	5	6	7	8	9	10	

练习: 计算1-100之间的累加和

num = 0
sum = 0
while num <= 100:
    sum += num
    num += 1
print('总和:',sum)

输出:

总和: 5050