字典+集合+控制语句+循环结构开头

最新推荐文章于 2022-05-06 00:09:54 发布

斯外戈的小白

最新推荐文章于 2022-05-06 00:09:54 发布

阅读量243

点赞数 1

文章标签： python 字典

本文链接：https://blog.csdn.net/weixin_51589123/article/details/114818963

版权

3.remove（）删除制定元素，clear（）清空整个集合

4、集合相关操作——并集、交集、插集

六、控制语句

1、选择结构：

·在选择和循环结构中，表达式的值为False的情况如下：

·条件控制语句中，出现赋值，立马报错

2.双分支选择结构：

3.多分枝选择结构：

·小练习：输入一个学生的成绩，将其转化为简单的描述：不及格（小于60分）、及格（60-79）、良好（80-89）、优秀（90-100）

一、字典：

键值对的无序可变序列

键是任意不可变的数据：整数、浮点数、字符串、元组。列表、字典、集合这些可变对象，不可作为“键”，且键是不重复的。

1.字典的创建

（1）通过花括号来创建

#空字典
c = {}


a = {"name": "litter star", "age": 18, "dd": [2, 3, 4]}
print(a)

（2）通过dict将元组转变为字典

c = dict()

b = dict(name="litter star", age=18)  #将元组构建成字典
print(b)
#{'name': 'litter star', 'age': 18}

（3）通过zip（）创建字典对象

k = ["a", "b", "c"]
v = [100, 200, 300]
d = zip(k, v)
print(dict(d))
#{'a': 100, 'b': 200, 'c': 300}; K和v的先后决定谁是键，谁是值

（4）通过formkeys创建值为空的字典

#创建值为空的字典，先把键定义好
a = dict.fromkeys(["name", "age", "job"])
print(a)
#{'name': None, 'age': None, 'job': None}

2.字典元素的访问

（1）通过键得到值，若键不存在，则抛出异常

a = {"name": "litter star", "age": 18, "job": "programer"}
print(a["name"])
#litter star

（2）通过get（）方法来获得”值“，推荐原因，如果不存在，不会报错，而是返回none

a = {"name": "litter star", "age": 18, "job": "programer"}

print(a["dddd"])
#KeyError: 'dddd'

print(a.get("name"))
#litter star

3.列出所有的键值对、键、值

a = {"name": "litter star", "age": 18, "job": "programer"}

#遍历所有的键值对
print(a.items())
#dict_items([('name', 'litter star'), ('age', 18), ('job', 'programer')])

#列出所有的键
print(a.keys())
#dict_keys(['name', 'age', 'job'])

#列出所有的值
print(a.values())
#dict_values(['litter star', 18, 'programer'])

4.len（）表示键值对的个数

a = {"name": "litter star", "age": 18, "job": "programer"}
print(len(a))
#3

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

（1）增加——直接定义键值对；如果键重复，直接覆盖;

a = {"name": "litter star", "age": 18, "job": "programer"}
a["address"] = "西电"
print(a)
#{'name': 'litter star', 'age': 18, 'job': 'programer', 'address': '西电'}

直接加

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

更改值：
a = {"name": "litter star", "age": 18, "job": "programer"}
b = {"name": "xiaoxingxing", "age": 26, "sex": "女"}
a.update(b)
print(a)
#{'name': 'xiaoxingxing', 'age': 26, 'job': 'programer', 'sex': '女'}

6.字典元素中的删除

（1）del 删除的是键值对

a = {"name": "litter star", "age": 18, "job": "programer"}
del(a["name"])
print(a)
#{'age': 18, 'job': 'programer'}

（2）clear全部删除

a = {"name": "litter star", "age": 18, "job": "programer"}
a.clear()
print(a)
#{}

（3）pop（）删除制定键值对，并返回对应的“值对象”

a = {"name": "litter star", "age": 18, "job": "programer"}
b = a.pop("name")
print(b)
#litter star

a = {"name": "litter star", "age": 18, "job": "programer"}
a.pop("job")
print(a)
#{'name': 'litter star', 'age': 18}

列表是有序的，但字典是无序的

（4）popitem（）：随机删除和返回该键值对

a = {"name": "litter star", "age": 18, "job": "programer"}
a.popitem()  #随机去掉一个键值对
print(a)
#{'name': 'litter star', 'age': 18}

二、序列解包：

可以用于元组、列表和字典。序列解包可以让我们钢鞭得对多个变量赋值

x, y, z = (20, 30, 40)
x, y, z = 20, 30, 40
(x, y, z) = (10, 20, 30)
[x, y, z] = [20, 30, 40]

s = {"name": "litter star", "age": 18, "job": "programer"}
a, b, c = s  #对键进行了解包
print(a, b, c)
#name age job

d, e, f = s.values()  #对字典的值进行解包
print(d, e, f)
#litter star 18 programer

h, i, j = s.items()
print(h, i, j) #将键值对以元组的形式进行解包
#('name', 'litter star') ('age', 18) ('job', 'programer')
print(h[0])
#name

三、用字典表示表格

r1 = {"name": "高小一", "age": 18, "salary": 30000, "cite": "北京"}
r2 = {"name": "高小二", "age": 19, "salary": 20000, "cite": "上海"}
r3 = {"name": "高小五", "age": 20, "salary": 10000, "cite": "深圳"}
r4 =[r1, r2, r3]
print(r4)
#[{'name': '高小一', 'age': 18, 'salary': 30000, 'cite': '北京'}, {'name': '高小二', 'age': 19, 'salary': 20000, 'cite': '上海'}, {'name': '高小五', 'age': 20, 'salary': 10000, 'cite': '深圳'}]
#获得第二行的表示
print(r4[1].get("salary"))
#20000

#打印表中所有的薪资
for i in range(len(r4)):
    print(r4[i].get("salary"), end="\t")
    i += 1
    print()

#30000	20000	10000

#打印所有的数据
for i in range(len(r4)):
    print(r4[i].get("name"), r4[i].get("age"), r4[i].get("salary"), r4[i].get("cite"))
    i += 1
'''
高小一 18 30000 北京
高小二 19 20000 上海
高小五 20 10000 深圳
'''

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

如何存储：

在列表中是通过索引来找对象

在字典中是通过键来找对象

字典底层是通过数组来实现的。字典对象的核心是散列表，散列表是一个稀疏数组。每个数组的单元为bucket。一个bucket包括两部分：一个是键对象的引用，一个是指对象的引用。

假设字典a创建对象后，数组长度为8

要把“name”=“gaoqi”这个键值对放到字典对象a中，

第一步要计算“name”的哈希值，0-7内的二进制是三位数，从哈希值的最后三位开始找偏移量，如果满了就依次往前找，找到为止。

五.集合：

无序可变，元素不能重复，集合底层是字典，只有字典的“键对象”，因此不能重复且唯一的。

1.列表的创建

a = {233, 30, 2, "gg"}   #集合的创建，同样也是用花括号来表示

#集合是元素是唯一的，不可重复的
a.add(30)
print(a)
#{233, 2, 'gg', 30} 且集合是无序的

2.将列表转换为集合

a = ["a", "b", "c", "d"]
e = set(a)
print(e)
#{'b', 'c', 'd', 'a'}

3.remove（）删除制定元素，clear（）清空整个集合

a = ["a", "b", "c", "d"]
e = set(a)
print(e)
#{'b', 'c', 'd', 'a'}

a = {233, 30, 2, "gg"}  
a.remove(30)
print(a)
# {'gg', 233, 2}

4、集合相关操作——并集、交集、插集

a = {1, 3, "sxt"}
b = {"he", "it", "sxt"}

#并集
print(a | b)    #上一篇笔记的基本运算符里面有介绍
#{1, 3, 'sxt', 'it', 'he'}

#交集
print(a & b)
#{'sxt'}

print(a.intersection(b))
#{'sxt'}

#差集
print(a - b)
#{1, 3}

print(a.difference(b))
#{1, 3}

六、控制语句

1、选择结构：

如果某个条件满足，则执行某个代码

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

if a < 10:
    print(a)

报错：
File "D:/developer_tools/python/pythonProject/控制语句.py", line 9, in <module>
    if a < 10:
TypeError: '<' not supported between instances of 'str' and 'int'


#解决的方案：将字符串转化为数值 if int(a) < 10

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

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

·在选择和循环结构中，表达式的值为False的情况如下：

（1）False；

（2）在整数的情况下，数值为0

（3）空值None

（4）空序列对象（空列表、空元组、空集合、空字典、空字符串

（5）空range对象

（6）空迭代对象

b = []
if b:
    print("空的列表是false")
#不会被打印

if not b:
    print("空的列表是false")
#空的列表是false

c = True
if c:
    print("c")
#c 布尔值

c = ""
if c:
    print("c")
#空字符串不打印，说明它也是false

d = 0
if d:
    print("d")
#没有打印结果，所以也是false

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

    #d是数值型，且不为0，所以直接转换为字符串d，可以打印

·条件控制语句中，出现赋值，立马报错

d = 10
if 3 < d < 100:
    print("3<d<100")
#3<d<100


if 3 < c and (c = 100):
    print("赋值不能出现在条件语句中")
#报错了！

2.双分支选择结构：

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

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

#请输入一个数字：100
a是大于10的数字

三元条件运算符

双分支结构比较简单的情况下，可以中三元条件运算符

a = input("请输入一个数字：")
print(a if int(a) < 10 else "a是大于等于10的数字")

请输入一个数字：3
3

3.多分枝选择结构：

·小练习：输入一个学生的成绩，将其转化为简单的描述：不及格（小于60分）、及格（60-79）、良好（80-89）、优秀（90-100）

score = int(input("输入成绩："))
grade = ""
if score < 60:
    grade = "不及格"
elif score < 80:
    grade = "及格"
elif score < 90:
    grade = "良好"
else:
    grade = "优秀"

print("分数是：{0}, 等级:{1}".format(score, grade))

·已知点的坐标(x,y),判断其所在象限

x = int(input("请输入一个横坐标"))
y = int(input("请输入一个纵坐标"))

if x > 0 and y > 0 :
    print("坐标在第一象限")
elif x > 0 and y != 0 :
    print("坐标在第四象限")
elif y < 0 and x != 0 :
    print("坐标在第三象限")
elif y != 0 and x != 0 :
    print("坐标在第二象限")
elif x == 0 and y == 0 :
    print("坐标原点上")
elif y == 0:
    print("坐标在横轴上")
elif x == 0:
    print("坐标在y轴上")

4.选择结构的嵌套：

#选择结构的嵌套测试

score = int(input("请输入一个0-100的分数："))

if score < 0 or score >100:
    print("输入错误，请重新输入一个0-100的分数：")
else:
    if score >= 90:
        grade = "优秀"
    elif 80 <= score <90:
        grade = "良好"
    elif 60 <= score <80:
        grade = "及格"
    else:
        grade = "不及格"

    print("分数为：{0}， 等级为：{1}".format(score, grade))



#变形，简化控制语句的嵌套结构
degree = "ABCDE"

score = int(input("请输入一个分数："))
if score < 0 or score >100:
    print("输入错误，请重新输入一个0-100的分数：")
else:
    num = score//10
    if num > 9 :
        print(degree[0])
    elif num < 6:
        print(degree[4])
    else:
        print(degree[9-num])

七、循坏结构：

一定要有条件判断，不然就会死循环

计算数字1——100的累计和

a = 0
b = 0

while 0 <= a <= 100:
    a += 1
    b += a
    if a == 100:
        print(b, end="\t")

斯外戈的小白

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
字典+集合+控制语句+循环结构开头

目录一、字典：1.字典的创建2.字典元素的访问3.列出所有的键值对、键、值4.len（）表示键值对的个数5.字典元素的添加、修改和删除6.字典元素中的删除二、序列解包：三、用字典表示表格四.字典核心底层原理（重要）五.集合：1.列表的创建2.将列表转换为集合3.remove（）删除制定元素，clear（）清空整个集合4、集合相关操作——并集、交集、插集六、控制语句1、选择结构：·在选择和循环结构中，表达式的值为Fal...
复制链接

扫一扫