Python 学习Day4
- 一、字典
- 1.字典的创建
- 2.字典元素的访问
- 3.字典元素添加、修改、删除
- 4.序列解包
- 5.表格数据使用字典和列表存储，并实现访问
- 6.字典核心底层原理
- 二、集合
- 1.集合创建和删除
- （1）使用{}创建集合对象，并使用 add()方法添加元素
- （2）使用set()，将列表、元组等可迭代对象转成集合。（如果原来数据存在重复数据，则只保留一个）
- （3）remove()删除指定元素
- （4）clear()清空整个集合
- 2.集合相关操作
- 三、控制语句
- 1.选择结构
- （1）单分支选择结构
- （2）双分支选择结构
- （3）多分支选择结构
- （4）选择结构嵌套
- 四、循环结构
一、字典
字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。
通过“键对象”实现快速获取、删除、更新对应的“值对象”。
“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。（列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。）
“值”可以是任意的数据，并且可重复。
1.字典的创建
（1）通过{}、dict()来创建字典对象。
eg：
1 2 3 4 5 | >>> a = {'name':'sansan','age':18,'job':'teacher'} >>> b = dict(name='sansan',age=18,job='teacher') >>> a = dict([("name","sansan"),("age",18)]) >>> c = {} #空的字典对象 >>> d = dict() #空的字典对象 |
（2）通过 zip()创建字典对象
eg：
1 2 3 4 5 | >>> k = ['name','age','job'] >>> v = ['sansan',18,'techer'] >>> d = dict(zip(k,v)) >>> d {'name': 'sansan', 'age': 18, 'job': 'techer'} |
(3)通过 fromkeys 创建值为空的字典
eg：
1 2 3 | >>> a = dict.fromkeys(['name','age','job']) >>> a {'name': None, 'age': None, 'job': None} |
2.字典元素的访问
（1）通过键获得值，若键不存在，则抛出异常。
eg：
1 2 3 4 5 6 7 | >>> a = {'name':'sansan','age':18,'job':'teacher'} >>> a['name'] 'sansan' >>> a['age'] 18 >>> a['sex'] Traceback (most recent call last): File "<pyshell#374>", line 1, in <module> a['sex'] KeyError: 'sex' |
（2）通过get()方法获得“值”。（优点：指定键不存在，返回 None；也可以设定指定键不存在时默认返回的对象）
eg：
1 2 3 4 | >>> a.get('name') 'sansan' >>> a.get('sex') >>> a.get('sex','一个女人') >>>'一个女人' |
（3）列出所有的键值对
eg：
1 2 | >>> a.items() dict_items([('name', 'sansan'), ('age', 18), ('job', 'teacher')]) |
（4）列出所有的键和值
eg：
1 2 3 | >>> a.keys() dict_keys(['name', 'age', 'job']) >>> a.values() dict_values(['sansan', 18, 'teacher']) |
（5）len() 键值对的个数
使用len()方法
（6）检测一个键是否在字典中
eg：
1 2 | >>> a = {"name":"sansan","age":18} >>> "name" in a True |
3.字典元素添加、修改、删除
（1）给字典新增键值对
如果键已经存在，则覆盖旧的键值对；如果键不存在， 则新增键值对。
eg：
1 2 3 4 5 | >>>a = {'name':'sansan','age':18,'job':'teacher'} >>> a['address']='天津' >>> a['age']=16 >>> a {'name': 'sansan', 'age': 16, 'job': 'teacher', 'address': '天津'} |
（2）使用update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖。
eg：
1 2 3 4 5 | >>> a = {'name':'sansan','age':18,'job':'teacher'} >>> b = {'name':'axiang','money':2000,'sex':'男的'} >>> a.update(b) >>> a {'name': 'axiang', 'age': 18, 'job': 'teacher', 'money': 2000, 'sex': '男的'} |
（3）字典中元素的删除使用 del()方法； clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”
eg：
1 2 3 4 5 6 | >>> a = {'name':'sansan','age':18,'job':'teacher'} >>> del(a['name']) >>> a {'age': 18, 'job': 'teacher'} >>> b = a.pop('age') >>> b 18 |
4.popitem()
随机删除和返回该键值对。
注：
字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）。
eg：
1 2 3 4 5 6 7 | >>> a = {'name':'sansan','age':18,'job':'teacher'} >>> a.popitem() ('job', 'teacher') >>> a {'name': 'sansan', 'age': 18} >>> a.popitem() ('age', 18) >>> a {'name': 'sansan'} |
4.序列解包
序列解包可以用于元组、列表、字典。序列解包可以方便的对多个变量赋值。
eg：
1 2 3 4 5 6 7 8 9 | >>> x,y,z=(20,30,10) >>> x 20 >>> y 30 >>> z 10 >>> (a,b,c)=(9,8,10) >>> a 9 >>> [a,b,c]=[10,20,30] >>> a 10 >>> b 20 |
注：
序列解包用于字典时，默认是对键进行操作； 如果需要对键值对操作，则需要使用items()；如果需要对值进行操作，则需要使用 values()
eg：
1 2 3 4 5 6 7 8 9 | >>> s = {'name':'sansan','age':18,'job':'teacher'} >>> name,age,job=s #默认对键进行操作 >>> name 'name' >>> name,age,job=s.items() #对键值对进行操作 >>> name ('name', 'sansan') >>> name,age,job=s.values() #对值进行操作 >>> name 'sansan' |
5.表格数据使用字典和列表存储，并实现访问
eg：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | r1 = {"name":"高小一","age":18,"salary":30000,"city":"北京"} r2 = {"name":"高小二","age":19,"salary":20000,"city":"上海"} r3 = {"name":"高小五","age":20,"salary":10000,"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")) |
6.字典核心底层原理
后续详细介绍
二、集合
集合是无序可变，元素不能重复。
集合底层是字典实现，集合的所有元素都是字典中的键对象，因此是不能重复的且唯一的。
1.集合创建和删除
（1）使用{}创建集合对象，并使用 add()方法添加元素
（2）使用set()，将列表、元组等可迭代对象转成集合。（如果原来数据存在重复数据，则只保留一个）
eg：
1 2 3 4 | >>> a = ['a','b','c','b'] >>> b = set(a) >>> b {'b', 'a', 'c'} |
（3）remove()删除指定元素
1 2 3 4 | >>> a = {10,20,30,40,50} >>> a.remove(20) >>> a {10, 50, 30} |
（4）clear()清空整个集合
2.集合相关操作
Python 对集合提供了并集、交集、差集等运算。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | >>> a = {1,3,'sxt'} >>> b = {'he','it','sxt'} >>> a|b #并集 {1, 3, 'sxt', 'he', 'it'} >>> a&b #交集 {'sxt'} >>> a-b #差集 {1, 3} >>> a.union(b) #并集 {1, 3, 'sxt', 'he', 'it'} >>> a.intersection(b) #交集 {'sxt'} >>> a.difference(b) #差集 {1, 3} |
三、控制语句
1.选择结构
（1）单分支选择结构
if 语句单分支结构的语法形式如下：
if 条件表达式：语句/语句块
其中：
1.条件表达式：可以是逻辑表达式、关系表达式、算术表达式。
2.语句/语句块：可以是一条语句，多条语句。多条语句，缩进必须对齐一致。
补充：
条件表达式详解
在选择和循环结构中，条件表达式的值为 False 的情况如下：
False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空 range 对象、空迭代对象。
其他情况，均为True。所以Python 所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。
eg：
1 2 3 4 5 6 7 8 9 10 11 12 13 | if 3: #整数作为条件表达式 print("ok") a = [] #列表作为条件表达式，由于为空列表，是 False if a: print("空列表，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 3
（2）双分支选择结构
双分支结构的语法格式：
if 条件表达式 :
语句 1/语句块 1 else:
语句 2/语句块 2
①三元条件运算符
条件为真时的值 if (条件表达式) else 条件为假时的值
（3）多分支选择结构
多分支选择结构的语法格式如下：
if 条件表达式 1 :
语句 1/语句块 1
elif 条件表达式 2:
语句 2/语句块 2
.
.
.
elif 条件表达式 n : 语句 n/语句块 n
[else:
语句 n+1/语句块 n+1
]
注：
1.计算机行业，描述语法格式时，使用中括号[]通常表示可选，非必选。
2.多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
eg：
输入一个学生的成绩，将其转化成简单描述：不及格(小于 60)、及格(60-79)、良好(80-89)、优秀(90-100)。
1.每个分支都使用了独立的、完整的判断，顺序可以随意挪动，而不影响程序运行。
1 2 3 4 5 6 7 8 9 10 11 12 | score = int(input("请输入分数")) grade = '' 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)) |
2.利用多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
1 2 3 4 5 6 7 8 9 10 11 12 | score = int(input("请输入分数")) grade = '' if score<60 : grade = "不及格" elif score<80 : grade = "及格" elif score<90 : grade = "良好" elif score<=100: grade = "优秀" print("分数是{0},等级是{1}".format(score,grade)) |
（4）选择结构嵌套
选择结构可以嵌套，使用时控制好不同级别代码块的缩进量（缩进量决定了代码的从属关系）
语法格式如下：
if 表达式 1：
语句块 1
if 表达式 2：
语句块 2
else:
语句块 3
else:
if 表达式 4：
语句块 4
eg：输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60 以上是 D。60 以下是 E。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | 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)) |
或者
1 2 3 4 5 6 7 8 9 10 | score = int(input("请输入一个在 0-100 之间的数字：")) degree = "ABCDE" num = 0 if score>100 or score<0: score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) else: num = score//10 if num<6: #防止出现索引值错误 num=5 print("分数是{0},等级是{1}".format(score,degree[9-num])) |
四、循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果为 True 则重复执行循环体里的语句。
循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否则，就会变成一个死循环。
1.while循环
while 循环的语法格式如下：
while 条件表达式：
循环体语句
eg：
①利用 while 循环打印从 0-10 的数字。
1 2 3 4 | num = 0 while num<=10: print(num) num += 1 #改变条件表达式的语句 |
②利用 while 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和。
1 2 3 4 5 6 7 8 9 10 11 12 13 | num = 0 sum_all = 0 #1-100 所有数的累加和 sum_even = 0 #1-100 偶数的累加和 sum_odd = 0 #1-100 奇数的累加和 while num<=100: sum_all += num if num%2==0:sum_even += num else:sum_odd += num num += 1 #迭代，改变条件表达式，使循环趋于结束 print("1-100 所有数的累加和",sum_all) print("1-100 偶数的累加和",sum_even) print("1-100 奇数的累加和",sum_odd) |