字典是键值对的无序的可变序列,字典中的每个元素都是一个键值对。
典型字典:
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 "" , line 1, in
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}
前面学习的变量、数据类型(整数、浮点数、布尔)、序列(字符串、列表、元组、字典、集合),可以看做是数据的组织方式。数据可以看做是“砖块”。
流程控制语句是代码的组织方式,可以看做是“混凝土”。
一个完整的程序,离不开“砖块”,也离不开“混凝土”,他们的组合,才能让我们建立从小到一个方法,达到操作系统,这样各种各样的“软件”。
目前比较流行的IDE是PyCharm,比idle更强大。
jetbrains开发的。
64位系统也可以用32位的。
普遍是64位的系统。
选择结构通过判断条件是否成立,来决定执行哪个分支。选择结构有多种形式,分为:单分支,双分支,多分支。流程图:
if条件表达式:
语句/语句块
其中:
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)
空的列表是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 条件表达式:
循环体语句
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