2021/1/20 python基础-字典_集合_控制语句

字典

’键值对‘的无序可变序列，字典中每一个元素都是‘键值对’，包含键对象和值对象。可以通过键对象实现快速获取、删除、更新对应的值对象
键是任意的不可变数据，比如：整数、浮点数、字符串、元组
列表、字典、集合这些可变对象不能作为键，并且键不可重复
值可以式任意的数据，并且可以重复
a = ('name':'jining','age':30,'job':'staff')

一、字典的创建

1、通过{},dict()来创建字典对象

>>> a = {'myname':'jining','age':'30'}#花括号生成
>>> a
{'myname': 'jining', 'age': '30'}
>>> b=dict(myname = 'jining')#dict函数生成
>>> b
{'myname': 'jining'}
>>> b=dict(myname = 'jining',age = 30)
>>> b
{'myname': 'jining', 'age': 30}
>>> b=dict([('myname','jining'),('age',30)])#dict函数用数组生成
>>> b
{'myname': 'jining', 'age': 30}

2、通过zip()创建字典对象

>>> k = ['name','age','job']
>>> v = ['jining','30','staff']
>>> d = dict(zip(k,v))
>>> d
{'name': 'jining', 'age': '30', 'job': 'staff'}

3、通过fromkeys创建值为空的字典

>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}

二、字典元素的访问

1、通过[键]获得'值'，若键不存在，则抛出异常

>>> b=dict(myname = 'jining',age = 30)
>>> b
{'myname': 'jining', 'age': 30}
>>> b['myname']
'jining'
>>> b['sex']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'sex'

2、通过get( )方法获得‘值’。 推荐
优点：指定键不存在，返回None;也可以设定指定键不存在时默认返回的对象
推荐使用get()获取‘值对象’

>>> b.get('myname')
'jining'
>>> b.get('sex','无此键')
'无此键'

3、列出所有的键值对a.items()

>>> b.items()
dict_items([('myname', 'jining'), ('age', 30)])

4、列出所有的键a.keys，列出所有的值a.values

>>> b.keys()
dict_keys(['myname', 'age'])
>>> b.values()
dict_values(['jining', 30])

5、len()键值对的个数

>>> len(b)
2

6、检测一个‘键’是否在字典中in

>>> 'name'in b
False
>>> 'myname'in b
True

三、字典元素的添加/修改/删除

• 添加
  给字典新增‘键值对’。如果‘键‘已经存在，则覆盖旧的键值对；如果’键‘不存在，则新增’键值对‘。

>>> b['add']='成都市'
>>> b
{'myname': 'jining', 'age': 30, 'add': '成都市'}
>>> b['age'] = 18
>>> b
{'myname': 'jining', 'age': 18, 'add': '成都市'}
>>> 

• 修改
  使用update()将新字典中所有键值对全部添加到旧字典对象上，如果key有重复，则直接覆盖。

>>> a = {'name':'jining','age':18,'job':'staff'}
>>> b = {'name':'haha','age':18,'add':'成都'}
>>> a.update(b)
>>> a
{'name': 'haha', 'age': 18, 'job': 'staff', 'add': '成都'}

• 删除
  字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的‘值对象’

>>> del(a['name'])
>>> a
{'age': 18, 'job': 'staff', 'add': '成都'}
>>> c = a.pop('age')
>>> c
18
>>> a.clear()
>>> a
{}

popitem：随机删除和返回该键值对。字典是==‘无序可变序列’==，因此没有第一个元素、最后一个元素的概念；popitem弹出随机的项，因为字典中并没有‘最后的元素’或者其他有关顺序的概念，若想一个接一个的移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）

>>> b.popitem()
('add', '成都')
>>> b
{'name': 'haha', 'age': 18}
>>> b.popitem()
('age', 18)
>>> b
{'name': 'haha'}

四、序列解包用于列表/元组/字典

序列解包可以用于元组、列表、字典、序列解包，可以方便的对多个变量赋值

>>> x,y,z,=30,50,80
>>> x
30
>>> z
80
>>> (a,b,c)=(4,7,2)
>>> a
4
>>> [a,b,c]=[34,937,293]
>>> a
34

序列解包用于字典时，默认是对‘键’进行操作；如果需要对键值对操作，则需要使用item();如果需要对‘值’进行操作，则需要用values();

>>> b = {'name':'haha','age':18,'add':'成都'}
>>> x,y,z,=b
>>> x
'name'
>>> e,d,f =b.values()
>>> e
'haha'
>>> h,i,j = b.items() 
>>> h
('name', 'haha')

五、 表格数据使用字典和列表存储，并实现访问

字典与列表结合使用生成表格数据
任何数据都可以用表格表示

r1 = {'name':'高小一','age':18,'add':'北京','薪资':20000}
r2 = {'name':'高小二','age':26,'add':'成都','薪资':30000}
r3 = {'name':'高小五','age':23,'add':'天津','薪资':10000}
tb = [r1,r2,r3]
print(tb[2].get('age'))
#遍历每个人的年龄
for i in range(len(tb)):
    print(tb[i].get('age'))
#遍历整个表格
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('add'),tb[i].get('薪资'))

六、字典核心底层原理

字典对象的核心是散列表。散列表是一个稀疏数组（总有空白元素的数组）
数组的每个单元叫做buket，里面存有两部分：一个是键对象的引用，一个是值对象的引用，通过偏移量来读取buket。

将一个键值放进字典的底层过程

根据bin(hash('键'))生成一个二进制的散列值
假设数组长度为8，取计算出的散列值的最右边3位数字作为偏移量，转换成十进制后，查看对应数字的偏移量的bucket是否为空，如为空，则将键值放进去，如不为空，则依次取右边3位作为偏移量，转换成十进制，再看相应十进制数值偏移量的bucket是否为空，依次进行，直至将该键值放入，如果到最后还未放入，则将数组长度进行扩容，例如将数组长度扩为32，则计算出的散列值就取最右边的6位。再按照上面的方法继续进行直到将键值放入。

根据键查找‘键值对’的底层过程

同样根据bin(hash('键'))生成具体键名的散列值，和存储的底层流程算法一致，根据计算出的偏移量查看对应的bucket，如果都为空，则返回none，如果不为空，则将这个bucket的键对象计算对应的hash值，和最初生成的散列值进行比较，如果相等摩登将值对象返回，如果不相等，则再依次取其它几位数字，重新计算偏移量，依次取完仍没有找到，则返回none

用法总结

1、键必须是可散列
（1）数字、字符串、元组都是可散列
（2）自定义对象需要支持下面三点：
- 支持hash函数
- 支持通过_eq()_方法检测相等性
- 若a==b为真，则hash(a)==hash(b)也为真
2、字典在内存中开销巨大，典型的空间换时间
3、键查询速度很快
4、往字典里面添加新键可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改。

集合

集合的特点
集合是无序可变，元素不能重复
集合底层是字典，集合的所有元素都是字典中的‘键对象’，因此是不能重复且是唯一的

一、集合的创建和删除

1、使用{}创建集合对象，并使用add()方法添加元素

>>> a = {20,30,'jining'}
>>> a
{20, 'jining', 30}
>>> a.add(3)
>>> a
{3, 20, 'jining', 30}

2、使用set(),将列表、元组等可迭代对象转化成集合。如果原来数据存在重复数据，则只保留一个。

>>> a=['j','i','n','i','n','g']
>>> c=set(a)
>>> c
{'n', 'g', 'j', 'i'}

3、remove()删除指定元素；clear()清空整个集合

>>> c
{'n', 'g', 'j', 'i'}
>>> c.remove('g')
>>> c
{'n', 'j', 'i'}
>>> 

二、集合相关操作

并集（｜/union）、交集（&/intersection）、差集（-/difference）

>>> a = {1,3,'sxt'}
>>> b = {'he','it','sxt'}
>>> a&b
{'sxt'}
>>> a.intersection(b)
{'sxt'}
>>> a|b
{1, 3, 'sxt', 'he', 'it'}
>>> a.union(b)
{1, 3, 'sxt', 'he', 'it'}
>>> a-b
{1, 3}
>>> a.difference(b)
{1, 3}

控制语句

前面学习的变量，数据类型（整数、浮点、布尔）、序列（字符串、列表、元组、字典、集合）可以看作是数据的组织方式，而流程控制语句是代码的组织方式。

一、pycham开发环境的使用

IDE集成开发环境

二、选择结构

有三种：单分支选择结构、双分支选择结构、多分支选择结构

单分支选择结构

if条件表达式: 语句/语句块
注意：if表达式后有冒号
其中：
1、条件表达式:可以是逻辑表达式、关系表达式、算数表达式等等
2、语句/语句块：可以是一条语句，也可以是多条语句、缩进必须对齐一致
【操作】输入一个数字，如果小于10，则打印这个数字

num = input("请输入一个数字：")#键盘输入内容赋值给变量
if int(num)<10:
    print(num)

• 条件表达式详解
  在选择和循环结构中，各种表达式的值为false的情况如下：
  false、0、0.0、空值None、空序列对象（空列表、空元组、空集合、空字典、空字符串）、空range对象，空迭代对象 除此之外，均为True。这么看来python所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。
  注意：条件表达式中，不能有赋值操作符‘=’ 。

双分支选择结构

if条件表达式: 语句1/语句块1 else 语句2/语句块2
【操作】输入一个数字，小于10，则打印该数字；大于10，则打印“数字太大”

num = input("请输入一个数字：")
if int(num)<10:
    print(num)
else:
    print('数字太大')

• 三元条件运算符
  python提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如下：
  条件为真时的值 if(条件表达式)。else 条件为假时的值

num = input("请输入一个数字")
print(num if int(num)<10 else '数字太大')

多分支选择结构

if 条件表达式1:
    语句1/语句块1
    elif 条件表达式2:
	    语句2/语句块2
·
·
·
    elif 条件表达式n:
	    语句n/语句块n
else：
    语句n+1/语句块n+1

多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
【操作】输入一个学生的成绩，将其转化成简单描述：不及格（小于60）、及格（60-79）、良好（80-89）、优秀（90-100）。

a = int(input('请输入成绩：'))
if a < 60:
    print('不及格')
elif a<80:#因为分支之间有逻辑关系，故这里便不用再去写a>=60
    print('及格')
elif a<90:
    print('良好')
else:
    print('优秀')

a = int(input('请输入成绩：'))
grade = ''

if a < 60:
    grade ='不及格'
elif a<80:
    grade ='及格'
elif a<90:
    grade ='良好'
else:
    grade ='优秀'

print('分数是{0},等级是{1}'.format(a,grade))##该行为重点，字符串格式

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

if 表达式1：
	语句块1
	if 表达式2:
		语句块2
	else：
		语句块3
else：
	if 表达式4:
		语句块4

【操作】输入一个分数，分数在0～100之间，90分以上时A，80以上是B，70分以上是C，60分以上是D，60分一下是E

a = int(input('请输入分数：'))
if a<0 or a>100:
    print("请输入一个0～100之间的分数")
else:
    if a>90:
        print('等级为A')
    elif a>80:
        print('等级为B')
    elif a>70:
        print('等级为C')
    elif a>60:
        print('等级为D')
    else:
        print('等级为E')

score = int(input('请输入一个分数'))
degree = 'A B C D E'
num = 0
if score < 0 or score > 100:
    print('请输入0～100的分数')
else:
    num = score// 10
    if num < 6:
        num = 5
    print(degree[9-num])

三、循环结构

循环结构用来重复执行一条或多条语句
循环逻辑：如果符合条件，则反复执行循环体里的语句；在每次执行完后都会判断一次条件是否为true，如果为true则重复执行循环体里的语句
循环体里的语句至少应该包含改变条件表达式的语句，以使循环趋于结束，否则就会变成一个死循环。

while循环

while 条件表达式
	循环体语句

【操作】利用while循环，打印从1-10的数字

num = 0
while num<=10:
print(num,end='\t')
 num+=1 

【操作】利用while循环，计算1-100的累加和；计算1-100之间偶数的累加和；1-100之间奇数的累加和。

num = 0
sum = 0
while num<=100:
       sum=num+sum
       num+=1
print(sum)
*********************
num = 0
sum = 0
while num<=100:
    if num%2 == 0:
        sum=sum+num
    num+=1
print(sum)
*********************
num = 0
sum = 0
while num<=100:
    if num%2 == 1:
        sum=sum+num
    num+=1
print(sum)