2020.3.16 python笔记

字典

字典是键值对的无序的可变序列，字典中的每个元素都是一个键值对。
典型字典：
a = {‘name’:‘hj’,‘age’:‘24’,‘job’:‘student’}，有三个键值对，name是键，hj是值。可以通过a.get(‘name’)得到‘hj’。
列表通过下标数字找到对应对象，比如a[1]，字典通过键对象。
键是任意不可改变的数据，比如：整数，浮点数，字符串，元组。但是列表、字典、集合这些可变对象，不能成为键，并且键不可重复，如果重复，则会对之前的键覆盖。

字典的创建

1.{}，dict()

>>> a = {'name':'hj','age':'18','dd':[2,3,4]}
>>> a
{'name': 'hj', 'age': '18', 'dd': [2, 3, 4]}
>>> b = dict(name='hj',age=18)
>>> b
{'name': 'hj', 'age': 18}
>>> b=[('name','hj'),('age',18)]#用元组方法创建字典对象
>>> b
[('name', 'hj'), ('age', 18)]
>>> c={}
>>> d=dict() #空的字典对象

2.zip()

>>> k=['name','age']
>>> l=['hj',18]
>>> m=dict(zip(k,l))
>>> m
{'name': 'hj', 'age': 18}

3.fromkeys创建值为空的字典对象

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

注意none是一个值。

字典元素的访问

以 a={‘name’:‘hj’,‘age’:18,‘job’:‘student’}为例。
1.通过[键]获得值，若键不存在，则抛出异常。

>>> a={'name':'hj','age':18,'job':'student'}
>>> a['name']
'hj'
>>> a['age']
18
>>> a['sex']
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    a['sex']
KeyError: 'sex'
>>> 
KeyboardInterrupt

2.通过get()获取‘值对象’，推荐使用，优点是指定键不存在，返回none，也可以设定指定键不存在时默认返回的对象。

>>> a.get('name')
'hj'
>>> a.get('sex')
>>> print(a.get('sex'))
None
>>> a.get('sex','女')
'女'

3.列出所有键值对

>>> a.items()
dict_items([('name', 'hj'), ('age', 18), ('job', 'student')])

4.列出所有的键，列出所有的值

>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['hj', 18, 'student'])

5.len()键值对的个数

>>> len(a)
3

6.检测一个键是否在字典中

>>> 'name' in a
True

字典元素添加、修改和删除

以 a={‘name’:‘hj’,‘age’:18,‘job’:‘student’}为例。
1.新增键值对，如果键已经存在，则覆盖旧的键值对；如果键不存在，则新增键值对。

>>> a={'name':'hj','age':18,'job':'student'}
>>> a['like']='food'  #新增
>>> a
{'name': 'hj', 'age': 18, 'job': 'student', 'like': 'food'}
>>> a['age']=19  #覆盖
>>> a
{'name': 'hj', 'age': 19, 'job': 'student', 'like': 'food'}

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

>>> a={'name':'hj','age':18,'job':'student'}
>>> b={'name':'mhh','sex':'女'}
>>> a.update(b)
>>> a
{'name': 'mhh', 'age': 18, 'job': 'student', 'sex': '女'}

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

>>> a={'name':'hj','age':18,'job':'student'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'student'}
>>> b=a.pop('age')#删除age这个键值对，但是保留值
>>> b
18
>>> a.clear()#就是都删了，为空
>>> a
{}

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

>>> a={'name':'hj','age':18,'job':'student'}
>>> a.popitem()
('job', 'student')
>>> a
{'name': 'hj', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'hj'}

序列解包

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

>>> x,y,z=(20,30,10)
>>> x
20
>>> y
30
>>> z
10
>>> (a,b,c)=(1,2,3)
>>> a
1
>>> a,b,c=1,2,3
>>> a
1
>>> [a,b,c]=[1,2,3]
>>> a
1

这几种写法都可以。

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

>>> a={'name':'hj','age':18,'job':'student'}
>>> s,b,c=a#s,b,c接受字典
>>> s
'name'
>>> b
'age'
>>> c
'job'
>>> e,d,f=a.values()#对值进行操作
>>> e
'hj'
>>> d
18
>>> f
'student'
>>> g,h,i=a.items()#对键值对进行操作
>>> g
('name', 'hj')
>>> h
('age', 18)
>>> h[1]
18
>>> h[0]
'age'

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

明白这个，任何表格都可以做！
源代码（mypy_08.py）:

r1 = {'name':'hj1','age':18,'salary':300,'city':'北京'}
r2 = {'name':'hj2','age':19,'salary':200,'city':'上海'}
r3 = {'name':'hj3','age':20,'salary':400,'city':'杭州'}

tb = [r1,r2,r3]

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

#打印所有人的薪资，用到循环
for i in range(len(tb)):   #i -->0,1,2
    print(tb[i].get('salary'))

#打印表的所有数据
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

>>> 
======================= RESTART: F:/python.exec/mypy08.py ======================
200
300
200
400
hj1 18 300 北京
hj2 19 200 上海
hj3 20 400 杭州

字典核心底层原理（重要）

字典对象的核心是散列表。
散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做bucket（桶的意思）。每个bucket有两部分：一个是键对象的引用，一个是值对象的引用。键是key，值是value。
由于所有bucket结构和大小一致，我们可以通过偏移量来读取指定bucket。

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

集合

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

集合创建和删除

1.使用{}创建集合对象，使用add()添加元素。

>>> a = {1,2,3,'hj'}
>>> a
{1, 2, 3, 'hj'}
>>> a.add(3)#添加一个相同的，不会重复添加，是唯一的
>>> a
{1, 2, 3, 'hj'}

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

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

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

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

集合相关操作

并集，交集，差集

>>> a={1,3,'sxt'}
>>> b={1,2,4,'sxt','it'}
>>> a|b  #并集
{1, 2, 3, 4, 'it', 'sxt'}
>>> a&b  #交集
{1, 'sxt'}
>>> a-b  #差集，不同的地方，a中与b不相同的地方
{3}
>>> a.union(b)  #并集
{1, 2, 3, 4, 'it', 'sxt'}
>>> a.intersection(b)  #交集
{1, 'sxt'}
>>> a.difference(b)#差集
{3}

控制语句

前面学习的变量、数据类型（整数、浮点数、布尔）、序列（字符串、列表、元组、字典、集合），可以看做是数据的组织方式。数据可以看做是“砖块”。
流程控制语句是代码的组织方式，可以看做是“混凝土”。
一个完整的程序，离不开“砖块”，也离不开“混凝土”，他们的组合，才能让我们建立从小到一个方法，达到操作系统，这样各种各样的“软件”。

PyCharm开发环境的使用

目前比较流行的IDE是PyCharm，比idle更强大。
jetbrains开发的。
64位系统也可以用32位的。
普遍是64位的系统。

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分支，双分支，多分支。流程图：

单分支选择结构

if条件表达式：
语句/语句块
其中：

1. 条件表达式可以是逻辑表达式、关系表达式、算术表达式等等。
2. 语句/语句块可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

a = input("请输入一个小于10的数字：")

if int(a)<10:
    print(a)

条件表达式详解

在选择和循环结构中，条件表达式的值为False的情况入下：
False、0、0.0、空格None、空序列对象（空列表、空元组、空集合、空字典、空字符串）、空range对象、空迭代对象。
其他情况均为True。

b=[]
if not b:
    print("空的列表是False")

c = "False"  #非空字符串也是True
if c:
    print("c")

d = 10
if d:
    print("d")

if 3<d<100:
    print("3<d<100")

空的列表是False
c
d
3<d<100

条件表达式中，不能有赋值操作符“=”，应用等与判断符“==”

双分支选择结构

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

a = input("请输入一个数字")

if int(a)<10:
    print("a是小于10的数字")
else:
    print("a是大于等于10的数字")

请输入一个数字23
a是大于等于10的数字

三元条件运算符

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

a = input("请输入一个数字")

if int(a)<10:
    print("a是小于10的数字")
else:
    print("a是大于等于10的数字")
#测试三元条件运算符
print("a是小于等于10的数字" if int(a)<10 else "a大于等于10")

请输入一个数字30
a是大于等于10的数字
a大于等于10

多分支选择结构

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

[]里表示的是可选的。
多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。

【操作】输入一个学生的成绩，将其转化成简单描述：不及格（小于60）、及格（60-79）、良好（80-89）、优秀（90-100）。

#测试多分支选择结构
score = int(input("请输入分数："))
grade = ""

if score<60:
    grade = "不及格"
elif score<80:
    grade = "及格"
elif score<90:   #60-80之间，不用写>60了
    grade = "良好"
else:
    grade= "优秀"
print("分数是{0}，等级是{1}".format(score,grade))
print("************************************")
#另一种方法，就可以调换顺序。
if(score<60):
    grade = "不及格"
if(60<=score<80):   #可以换顺序
    grade = "及格"
if(80<=score<90):
    grade = "良好"
if(90<=score<=100):
    grade= "优秀"
print("分数是{0}，等级是{1}".format(score,grade))

请输入分数：45
分数是45，等级是不及格
************************************
分数是45，等级是不及格

选择结构嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。
if 表达式1：
语句块1
if 表达式2：
语句块2
else：
语句块3
else：
if 表达式4：
语句块4

#测试选择结构的嵌套
score = int(input("请输入一个在0-100之间的数字"))
grade = ""
if score>100 or score<0:
    score = int(input("输入错误！请输入一个在0-100之间的数字"))
else:
    if score>=90:
        grade = "A"
    elif score>=80:
        grade = "B"
    elif score>=70:
        grade = "C"
    elif score>=60:
        grade = "D"
    else:
        grade = "E"
    print("分数为{0},等级为{1}".format(score,grade))

print("******************************************")
#另一种简单写法
score = int(input("请输入一个分数"))
degree = 'ABCDE'
num = 0
if score>100 or score<0:
    print("请输入一个0-100的分数")
else:
    num = score//10
    if num<6:
        num = 5
    print(degree[9-num])

请输入一个在0-100之间的数字67
分数为67,等级为D
******************************************
请输入一个分数89
B

循环结构

循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为True，如果为True则重复执行循环体里的语句。图示如下：

循环体里面的语句枝梢应该包含改变条件表达式的语句，以使循环趋于结束；否则就会变成一个死循环。

while循环

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

num = 0
while num<10:
    print(num)
    num+=1

0
1
2
3
4
5
6
7
8
9

【操作】计算1-100数字的累加和：

#计算1-100之间数字的和
num2 = 0
sum_all = 0
while num2<=100:
    sum_all = sum_all + num2
    num2 +=1
print("1-100所有数字的累加和：",sum_all)

1-100所有数字的累加和： 5050