python第四章

字典

’键值对‘的无序可变序列，字典中每一个元素都是键值对
键值对：键（类似于索引数字）+ 值
可通过键对象快速的获取、删除、更新对应的只对象
键：是任意的不可变数据：int、float、str、tuple，并且不可以重复
值：可以是任意的数据，并且可以重复

---

字典的创建

①通过{ }来创建
a={‘name’:‘vivi’,‘age’:18,'class’1}

②通过dict()
dict(name=‘vivi’,age=18,class=1)
dict([(‘name’,‘vivi’),(‘age’,18),(‘class’,1)])

③通过zip()

>>>k=['name','age','class']
>>>v=['vivi',18,1]
>>>d=dict(zip(k,v))

④通过fromkeys创建值为空的字典

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

---

字典元素的访问

①通过key来获得value

>>>a={'name':'vivi','age':18,'class'1}
>>>a.['name']
>>>a
vivi
>>>a.['job'] #会报错

②通过get()方法获得value 推荐使用
优点：指定键不存在时不会报错，而是返回None，并且可以设定指定键不存在时默认返回的对象

>>>a={'name':'vivi','age':18,'class':1}
>>>print(a.get('name'))
vivi
>>>print(a.get('job'))
None
>>>print(a.get('job','teacher'))
teacher

③列出所有键值对

>>>a={'name':'vivi','age':18,'class':1}
>>>print(a.items())
dict_items([('name','vivi'),('age',18),('class',1)])

④列出所有键&列出所有值

>>>a={'name':'vivi','age':18,'class':1}
>>>print(a.keys())
dict_keys(['name','age','class'])
>>>print(a.values())
dict_values(['vivi',18,1])

⑤键值对的个数

>>>a={'name':'vivi','age':18,'class':1}
>>>len(a)
3

⑥检测 键 是否在字典中

>>>a={'name':'vivi','age':18,'class':1}
>>>'name' in a
True

---

字典元素的添加修改删除

①添加新的键值对，如果键不存在则新加入，如果键存在则覆盖

>>>a={'name':'vivi','age':18,'class':1}
>>>a['job']='teacher'
>>>a['name']='jane'
>>>print(a)
{'name':'jaen','age':18,'class':1,'job':'teacher'}

②使用update()
将新字典中所有键值对添加到原来的字典中，如果有相同的键，则覆盖

>>>a={'name':'vivi','age':18,'class':1}
>>>b={'name':'jane','job':'teacher','address':'万科'}
>>>print(a.update(b))
{'name':'jane','age':18,'class':1,'job':'teacher','address':'万科'}

③字典中元素的删除del()删除指定键值对、clear()清除所有键值对、pop()删除指定键值对，并返回对应的值对象

>>>a={'name':'vivi','age':18,'class':1,'job':'teacher','address':'万科'}
>>>del(a['name'])
>>>print(a)
{'age':18,'class':1,'job':'teacher','address':'万科'}
>>>b=a.pop('age')
>>>print(b)
18
>>>print(a)
{'class':1,'job':'teacher','address':'万科'}
>>>a.clear() #返回的值为None
print(a)
{}

④popitems()随机删除并返回删除的键值对，字典是无序可变序列，没有第一个元素和最后一个元素之分，所以像一个接一个地移除并处理项，这个方法十分有效（因为不用获取相关键的列表）

>>>a={'name':'vivi','age':18,'class':1,'job':'teacher','address':'万科'}
>>>b=a.popiteam()
>>>print(b)
{'class':1} #随机
>>>print(a)
{'name':'vivi','age':18,'job':'teacher','address':'万科'}

---

序列解包

用于列表、元组、字典，方便多个变量赋值
序列解包用于字典是默认对 键 操作

>>>dic={'name':'vivi','age':18,'class':1,'job':'teacher','address':'万科'}
>>>a,b,c=dic
>>>print(a)
'name'
>>>d,e,f=dic.values
>>>print(d)
'vivi'
>>>g,h,i=dic.items
>>>print(g)
('name','vivi') #储存到元组中

---

表格数据使用字典和序列储存，并访问

>>>r1={'name':'li','age':10,'class':1}
>>>r2={'name':'hu','age':11,'class':2}
>>>r3={'name':'gao','age':12,'class':3}
>>>table=[r1,r2,r3]
>>>for x in range(len(table)):
>>>    print(table[x]['name']，table[x]['age']，table[x]['class'])
>>>for x in range(len(table)):
>>>    print(table[x].get('name')，table[x].get('age')，table[x].get('class'))
li,10,1
hu,11,2
gao,12,3
li,10,1
hu,11,2
gao,12,3

---

字典核心底层原理

键值对的储存：bin（hush(key)）
将键转化为可以找到的数列值的二进制
根据数组长度，找到最右边的几位数字作为偏移量（比如：假设数组长度为8，bin（7）=111 ，则取最右边3位数字为偏移量）
要是最右三位数字对应的位置有东西则向左瞬移三位，直到找到空位，如果没有空位则扩容（一般有东西的数组占到2/3的时候便会扩容）

键值对的取出
第一步仍然计算你要找的键的hush值
去找位置，找到后计算对应位置存储的键的hush值，比较两个hush值是否相同，直到找到了你要的对象

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

---

集合

无序可变，元素不能重复。实际上集合底层是字典实现，集合中的所有元素都是字典中的键对象，因此是不能重复且唯一的。

---

集合创建和删除

①使用{ }创建集合对象，并使用add()来添加元素

>>>a={3,5,7}
>>>print(a)
{3,5,7}
>>>a.add(9)
>>>print(a)
{9,3,5,7}

②使用set()，将列表元组等可迭代对象转成集合，如果原来数据有重复，则是保留一个（因为是集合）

>>>a=['a','b','c','d']
>>>b=set(a)
>>>print(b)
{'a','b','c','d'}

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

>>>a={'a','b','c','d'}
>>>a.remove('a')
>>>print(a)
{'b','c','d'}
>>>a.clear()
>>>print(a)
set() #{}代表空字典

集合的并、交、差

>>>a={1,2,3}
>>>b={'he','she','1'}
#并集
>>>print(a|b)
{1,2,3,'he','she'}
>>>print(a.union(b))
{1,2,3,'he','she'}
#交集
>>>print(a&b)
{'1'}
>>>print(a.intersection(b))
{'1'}
#差集
>>>print(a-b)
{'2','3'}
>>>print(a.difference(b))
{'2','3'}

---

控制语句

选择结构——单分支结构

语法结构：
if 条件表达式
语句/语句块
其中：
1.条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等
2.语句/语句块：可以是一条语句，也可以是多条语句，多条语句，缩进必须对其一致

num=input('请输入一个数字：') #输入值后返回为字符串
if int(num)<10
	print(num)

条件表达式详解
在选择和循环结构中，条件表达式值为false入下
False，0，0.0，空值None,空序列对象（空列表、空集合、空元组、空字典、空字符串）、空range对象、空迭代对象
python所有合法表达式都可以看做条件表达式，甚至包括函数调用的表达式
条件表达式中不能出现=，但是可以有等于判断==

---

选择结构——双分支结构

语法格式：
if 条件表达式：
语句1/模块1
else：
语句2/模块2

逻辑图：

num=input('请输入一个数字：') #输入值后返回为字符串
if int(num)<10
	print(’num是小于10的数字)
else：
	print(’num是大于10的数字)

三元条件运算符
语法结构：
条件为真时候的值 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

逻辑图：

score=int(input('请输入分数：'))
grade=''
if score>100 or <0
	print(input('请重新输入分数：'))
if score<60
	grade='不及格'
elif score<80
	grace='及格'
elif score<90
	grace='良好'
elif score<100
	grace='优秀'
	print('成绩是：','等级是'.format(score，grade))

---

选择结构的嵌套

语法结构：
if 表达式1：
语句块1
if 表达式2：
语句块2
else：
语句块3
else：
if 表达式4：
语句块4

score=int(input('请输入分数：'))
grade = ''
if score>100 or score<0:
    score=int(input('请重新输入分数：'))
    if score<60:
        grade='不及格'
    elif score<80:
        grade='及格'
    elif score<90:
        grade='良好'
    elif score:
        grade='优秀'
    print('成绩是:{0},等级是:{1}'.format(score, grade))
else:
    if score<60:
        grade='不及格'
    elif score<80:
        grade='及格'
    elif score<90:
        grade='良好'
    elif score:
        grade='优秀'
    print('成绩是:{0},等级是:{1}'.format(score,grade))

---

循环结构

重复执行一条或多条语句，如果符合条件，则反复执行循环体里面的语句，每一次执行完后会判断一次True/False，是True则再执行一遍
循环体中要写一句改变表达式的语句，并趋近于结束，否则为死循环
逻辑图：

循环结构——while循环

语法结构：
while 条件表达式：
循环体语句

#利用while循环打印1-10的数字
num=0
while nun<10:
	print(num)
	num=num+1
a=0
sumall=0
while a<100:
	sumall=sumall+1
	a=a+1
print(sumall)