python数据分析--- ch1-2 python初识入门

1. 安装并启动jupyter

• 1. 安装Anaconda:Windows下Anaconda软件安装教程
• 2. 安装jupyter: pip install jupyter
• 3. 启动jupyter: 目标文件夹空白处，shift+右键 -> 在此处打开powershell窗口 ->输入：jupyter notebook

在markdown中插入图片，默认居中对齐

• 方法1： 菜单Edit->Insert Image 不可调节图片大小以及对齐方式
  

• 方法2：html形式,可调节图片大小以及对齐方式
  

2. 打印变量print()

#打印整数
print(1234)
#查看数据类型
type(1234)

output

1234
int

print(1.2)#打印浮点数
type(1.2)#查看数据类型

output
1.2
float

print('人生苦短，我用python！')#打印字符串 用单引号

output
人生苦短，我用python！

print("人生苦短，我用python！")#打印字符串 用双引号

output
人生苦短，我用python！

#for循环，python中range生成的列表是左闭右开即包含初始值不包含结束值
for i in range(0,10):
    print(i)
print('循环结束')#返回的是0-9的整数，不包含10

output
0
1
2
3
4
5
6
7
8
9
循环结束

#求数值1-100的和
j=0
for i in range(1,101):
    j=i+j
print("和为：",j)

output
和为： 5050

练一练

请借助**print()**输出下面的图形

# 方法1
print("*****")
print("*****")
print("*****")
print("*****")
print("*****")

output
*****
*****
*****
*****
*****

# 方法2
print("*****\n*****\n*****\n*****\n*****")

output
*****
*****
*****
*****
*****

# 方法3
star = '*'*5
print(f"{star}\n{star}\n{star}\n{star}\n{star}")

output
*****
*****
*****
*****
*****

3. 变量与赋值 input()

1.基本用法：
input() 函数用于接收用户的输入，并将输入的内容作为字符串返回。调用 input() 时，可以提供一个可选的提示字符串（prompt），当调用时会显示在控制台或终端上。

2.提示字符串（Prompt）：
提示字符串是显示在输入前的文字，用于告诉用户期望他们输入什么类型的信息。如果省略提示字符串，input() 函数只显示一个空行，等待用户输入。

3.返回值：
input() 函数总是返回一个字符串类型的值，即使用户输入的是数字或其他类型的内容。如果需要将输入转换为其他类型，必须使用相应的类型转换函数，如 int(), float() 等。

4.类型转换：
由于 input() 始终返回字符串，如果用户输入的是数字，需要显式转换类型以进行数值计算。

3.1 示例–饮料交换

glass1=input('请输入杯子1中的饮料名称：')

output
请输入杯子1中的饮料名称：可乐

print(glass1)

output
可乐

glass1

output
‘可乐’

glass2=input('请输入杯子2中的饮料名称：')

output
请输入杯子2中的饮料名称：牛奶

glass2

output
‘牛奶’

temp=""
temp

output
‘’

temp = glass1
temp

output
‘可乐’

glass1=glass2
glass1

output
‘牛奶’

glass2 = temp
glass2

output
‘可乐’

3.2 饮料交换完整code

glass1=input('请输入杯子1中的饮料名称：')
glass2=input('请输入杯子2中的饮料名称：')
print("交换前杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)
temp=""
temp = glass1
glass1=glass2
glass2 = temp
print("交换后杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)

output
请输入杯子1中的饮料名称：可乐
请输入杯子2中的饮料名称：牛奶
交换前杯子1和杯子2中的饮料分别为：
可乐
牛奶
交换后杯子1和杯子2中的饮料分别为：
牛奶
可乐

3.3 jupyter中写入code到py文件中

%%writefile 文件名

%%writefile ch2_1.py

glass1=input('请输入杯子1中的饮料名称：')
glass2=input('请输入杯子2中的饮料名称：')
print("交换前杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)
temp=""
temp = glass1
glass1=glass2
glass2 = temp
print("交换后杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)

output
Writing ch2_1.py

%%writefile ch2_2.py

glass1=input('请输入杯子1中的饮料名称：')
glass2="牛奶"
print("交换前杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)
temp=""
temp = glass1
glass1=glass2
glass2 = temp
print("交换后杯子1和杯子2中的饮料分别为：")
print(glass1)
print(glass2)

output
Overwriting ch2_2.py

3.4 在终端运行.py文件 ： python 文件名

3.5练一练

请借助**input()**让注册用户输出昵称、密码以及性别信息，可自定义增加填写提示或者填写要求

1：简易版

name=input("请输入不超过8个字符作为你的昵称：")
if len(name)<=8:
    print(name)
else:
    print("请重新设置您的昵称：")
    
password = input("请输入4个数字作为你的密码：")
if password.isdigit() and len(password)==4:
    print(password)
else:
    print("请重新设置你的密码：")
    
sex = input("请填写您的性别（男/女）：")
if sex in ['男','女']:
    print(sex)
else:
    print("请重新填写您的性别信息：")

output
请输入不超过8个字符作为你的昵称：abcdabcda
请输入4个数字作为你的密码：abcd
请填写您的性别（男/女）：1

while True:
    sex = input("请填写您的性别（男/女）：")
    if sex in ['男','女']:
        print(sex)
        break
    else:
        print("请重新填写您的性别信息：")
#         sex = input("请填写您的性别（男/女）：")

output
请填写您的性别（男/女）：1
请重新填写您的性别信息：
请填写您的性别（男/女）：0
请重新填写您的性别信息：
请填写您的性别（男/女）：3
请重新填写您的性别信息：
请填写您的性别（男/女）：男
男

2：判断版

name=input("请输入不超过8个字符作为你的昵称：")
        
if len(name) > 8:
    print("昵称长度不能超过8个字符,请重新设置")
    
password = input("请输入4为数字作为你的密码：")
if not password.isdigit() or len(password) != 4:
    print("密码必须是4位数字,请重新设置")
    input("请输入4为数字作为你的密码：")
    
sex = input("请填写您的性别（男/女）：")

if sex not in ["男", "女"]:
    print("性别输入错误，请填写'男'或'女'")

3：判断修正版

# name=input("请输入不超过8个字符作为你的昵称：")

while True:
    name=input("请输入不超过8个字符作为你的昵称：")#要求
    if len(name) > 8:#判断
        print("昵称长度不能超过8个字符,请重新设置")#错误信息
    else:
        print(name)
        break
        
while True:
    password=input("请输入4为数字作为你的密码：：")#要求
    if not password.isdigit() or len(password) != 4:#判断
        print("密码必须是4位数字,请重新设置")#错误信息
    else:
        print(password)
        break
        
while True:
    sex=input("请填写您的性别（男/女）：")#要求
    if sex not in ["男", "女"]:#判断
        print("性别输入错误，请填写'男'或'女'")#错误信息
    else:
        print(sex)
        break

output
请输入不超过8个字符作为你的昵称：7777777777
昵称长度不能超过8个字符,请重新设置
请输入不超过8个字符作为你的昵称：000000
000000

4：判断修正函数版

def get_valid_input(prompt, validator, error_message):
    while True:
        user_input=input(prompt)#要求
        if validator(user_input):#判断
#             print(user_input)
            return user_input #以函数定义的话要改成return，否则输出为None
        else:
            print(error_message)#错误信息
            
        
# 获取符合要求的昵称
name = get_valid_input("请输入不超过8个字符作为你的昵称：", lambda name: len(name) <= 8, "昵称长度不能超过8个字符，请重新输入：")

# 获取符合要求的密码
password = get_valid_input("请输入4位数字作为你的密码：", lambda password: password.isdigit() and len(password) == 4, "密码必须是4位数字，请重新输入：")

# 获取符合要求的性别
sex = get_valid_input("请填写您的性别（男/女）：", lambda sex: sex.lower() in ["男", "女"], "性别输入错误，请填写'男'或'女'，然后重新输入：")

# 所有输入均符合要求，输出确认信息
print(f"您的昵称是：{name}")
print(f"您的密码是：{password}")
print(f"您的性别是：{sex}")

output
请输入不超过8个字符作为你的昵称：plkij
请输入4位数字作为你的密码：0318
请填写您的性别（男/女）：女
您的昵称是：plkij
您的密码是：0318
您的性别是：女

将上面练一练的程序写入ch2_3.py文件中

%%writefile ch2_3.py

def get_valid_input(prompt, validator, error_message):
    while True:
        user_input=input(prompt)#要求
        if validator(user_input):#判断
            return user_input #以函数定义的话要改成return，否则输出为None
        else:
            print(error_message)#错误信息
            
        
# 获取符合要求的昵称
name = get_valid_input("请输入不超过8个字符作为你的昵称：", lambda name: len(name) <= 8, "昵称长度不能超过8个字符，请重新输入：")

# 获取符合要求的密码
password = get_valid_input("请输入4位数字作为你的密码：", lambda password: password.isdigit() and len(password) == 4, "密码必须是4位数字，请重新输入：")

# 获取符合要求的性别
sex = get_valid_input("请填写您的性别（男/女）：", lambda sex: sex.lower() in ["男", "女"], "性别输入错误，请填写'男'或'女'，然后重新输入：")

# 所有输入均符合要求，输出确认信息
print(f"您的昵称是：{name}")
print(f"您的密码是：{password}")
print(f"您的性别是：{sex}")

output
Writing ch2_3.py

type(glass1)# 查看glass1变量的类型

output
str

4.python 关系型运算相关知识

知识点梳理

在Python中，关系型运算也被称作比较运算，主要用于比较两个值之间的关系，并返回一个布尔值（True或False）。以下是对Python中的关系型运算符的梳理：

• 1.等于(==)：用来比较两个对象的值是否相等。例如：3 == 3 返回 True。
• 2.不等于(!=)：用来比较两个对象的值是否不相等。例如：3 != 4 返回 True。
• 3.大于(>)：用于判断左侧对象是否大于右侧对象。例如：4 > 3 将返回 True。
• 4.小于(<)：用来判断左侧对象是否小于右侧对象。例如：2 < 3 会返回 True。
• 5.大于等于(>=)：用于判断左侧对象是否大于或等于右侧对象。例如：3 >= 3 将返回 True。
• 6.小于等于(<=)：用于判断左侧对象是否小于或等于右侧对象。例如：2 <= 3 也将返回 True。

需要注意的是，关系表达式的结果只有两个可能的值，即逻辑真(True)和假(False)。这些关系运算符通常被用在if条件语句、循环以及列表推导式等多种场景中，作为程序流程控制的一部分。

4.1 示例–世界杯足球赛计分

v1 = True
v2 = False
type(v1)

output
bool

v1 = int(v1)#bool类型转换为整型数据：True->1 ; False->0
type(v1)

output
int

a = input("输入a球队的实力值：")
b = input("输入b球队的实力值：")
a+b #返回的是字符拼接

output
输入a球队的实力值：20
输入b球队的实力值：12

a = int(input("输入a球队的实力值："))
b = int(input("输入b球队的实力值："))
a+b #通过int()对input输入的字符串进行显示变换之后返回的是数值的加法运算结果

output
输入a球队的实力值：20
输入b球队的实力值：12

32

type(a)

output
int

a = int(input("输入a球队的实力值："))#20
b = int(input("输入b球队的实力值："))#12
c = int(input("输入c球队的实力值："))#13
d = int(input("输入d球队的实力值："))#23

output
输入a球队的实力值：20
输入b球队的实力值：12
输入c球队的实力值：13
输入d球队的实力值：23

avsb = int(a>b)*3+int(a==b)*1 # 计算球队a与球队b比赛的分数
avsc = int(a>c)*3+int(a==c)*1 # 计算球队a与球队c比赛的分数
avsd = int(a>d)*3+int(a==d)*1 # 计算球队a与球队d比赛的分数
score = avsb + avsc +avsd #计算球队a小组赛的总得分
print("a球队小组赛总得分为：",score)

output
a球队小组赛总得分为： 6

4.2 世界杯足球赛计分完整code并写入py文件

%%writefile ch2_4.py
a = int(input("输入a球队的实力值："))#20
b = int(input("输入b球队的实力值："))#12
c = int(input("输入c球队的实力值："))#13
d = int(input("输入d球队的实力值："))#23
avsb = int(a>b)*3+int(a==b)*1 # 计算球队a与球队b比赛的分数
avsc = int(a>c)*3+int(a==c)*1 # 计算球队a与球队c比赛的分数
avsd = int(a>d)*3+int(a==d)*1 # 计算球队a与球队d比赛的分数
score = avsb + avsc +avsd #计算球队a小组赛的总得分
print("a球队小组赛总得分为：",score)

output
Overwriting ch2_4.py

4.3 函数的定义

计算两球队比赛的分数

def x1vsx2_score(x1,x2):
    x1vsx2 = int(x1>x2)*3+int(x1==x2)*1
    return x1vsx2
   

avsb = x1vsx2_score(x1=a,x2=b)
avsc = x1vsx2_score(x1=a,x2=c)
avsd = x1vsx2_score(a,d)
avsd

output
0

4.4 定义函数版完整code并写入py文件

%%writefile ch2_5.py
a = int(input("输入a球队的实力值："))#20
b = int(input("输入b球队的实力值："))#12
c = int(input("输入c球队的实力值："))#13
d = int(input("输入d球队的实力值："))#23

def x1vsx2_score(x1,x2):
    x1vsx2 = int(x1>x2)*3+int(x1==x2)*1
    return x1vsx2

avsb = x1vsx2_score(a,b) # 计算球队a与球队b比赛的分数
avsc = x1vsx2_score(a,c) # 计算球队a与球队c比赛的分数
avsd = x1vsx2_score(a,d) # 计算球队a与球队d比赛的分数
score = avsb + avsc +avsd #计算球队a小组赛的总得分
print("a球队小组赛总得分为：",score)

output
Writing ch2_5.py

4.5 练一练

请python关系型运算完成以下练习：请小明输入期末考试三门课的成绩，然后计算这三门课程的总积分为多少。积分规则如下：

# 方法1：
score1 = int(input("请输入第一门成绩："))
score2 = int(input("请输入第二门成绩："))
score3 = int(input("请输入第三门成绩："))

s1 = int(score1>=60)*int(score1<90)*1 + int(score1>=90)*2 #计算课程1转换后的积分
s2 = int(score2>=60)*int(score2<90)*1 + int(score2>=90)*2 #计算课程2转换后的积分
s3 = int(score3>=60)*int(score3<90)*1 + int(score3>=90)*2 #计算课程3转换后的积分

total_score = s1 + s2 + s3 #计算3门课程转换后的总积分

print("您的课程总积分为：",total_score) #打印3门课程转换后的总积分

output
请输入第一门成绩：60
请输入第二门成绩：80
请输入第三门成绩：91
您的课程总积分为： 4

# 方法2：函数版
score1 = int(input("请输入第一门成绩："))
score2 = int(input("请输入第二门成绩："))
score3 = int(input("请输入第三门成绩："))

# 定义课程与积分转换的函数
def score_trans(score):
    s = int(score>=90)*2 + int(score>=60)*int(score<90)
    return s

s1 = score_trans(score1) # 调用函数计算课程1转换后的积分
s2 = score_trans(score2) # 调用函数计算课程2转换后的积分
s3 = score_trans(score3) # 调用函数计算课程3转换后的积分

total_score = s1 + s2 + s3 # 计算3门课程转换后的总积分

print("您的课程总积分为：",total_score) #打印3门课程转换后的总积分

output
请输入第一门成绩：60
请输入第二门成绩：80
请输入第三门成绩：91
您的课程总积分为： 4

将上面练一练的程序写入ch2_6.py文件中

%%writefile ch2_6.py

score1 = int(input("请输入第一门成绩："))
score2 = int(input("请输入第二门成绩："))
score3 = int(input("请输入第三门成绩："))

# 定义课程与积分转换的函数
def score_trans(score):
    s = int(score>=90)*2 + int(score>=60)*int(score<90)
    return s

s1 = score_trans(score1) # 调用函数计算课程1转换后的积分
s2 = score_trans(score2) # 调用函数计算课程2转换后的积分
s3 = score_trans(score3) # 调用函数计算课程3转换后的积分

total_score = s1 + s2 + s3 # 计算3门课程转换后的总积分

print("您的课程总积分为：",total_score) #打印3门课程转换后的总积分

output
Overwriting ch2_6.py

5. for循环的概念与运算

知识点梳理

for循环是一种程序设计语言中的控制结构，用于重复执行一段代码直到满足特定的条件。以下是对for循环概念及其运算过程的详细解释：

• 1.初始化表达式（表达式1）：通常用于声明并初始化循环控制变量。
• 2.条件表达式（表达式2）：在每次循环开始时评估。如果结果为真（通常是非零值），则继续执行循环体；如果为假（零值），循环终止。
• 3.增值表达式（表达式3）：在每次循环体执行完毕后执行。通常用于更新循环控制变量，逐步使循环条件趋近于不成立的状态。
• 4.循环体：包含一条或多条语句，它们将被重复执行，直到循环条件不再满足为止。

在编写for循环时需要注意的几个要点包括：

• 确保在使用之前已经声明了循环控制变量。
• 条件表达式应该能够在某些条件下最终变为假，以避免无限循环。
• 循环体内可以包含其他控制结构，如if语句或另一个for循环，以实现更复杂的逻辑。

总的来说，for循环是编程中一个基础且重要的构造，它允许程序员以有序和自动的方式重复执行代码，从而简化了许多编程任务。

a=range(0,10)
print(a)

output
range(0, 10)

for i in range(0,10):
#     print(i)
#     print("i=",i)
#     print("i=%d"%i)
    print(f"i={i}")

output
i=0
i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

5.1 示例–兔子的繁殖

不考虑死亡，在空间和食物充足的情况下，农场N年后有多少只兔子？

rabbit = 3
N = int(input("请输入N的数量："))
print(3*pow(2,3))

output
请输入N的数量：3
24

rabbit = 3
N = int(input("请输入N的数量："))
for i in range(1,N+1):
    print(f"i={i}")
    rabbit = rabbit*2
    print("rabbit数量为%d"%rabbit)

output
请输入N的数量：3
i=1
rabbit数量为6
i=2
rabbit数量为12
i=3
rabbit数量为24

5.2 练一练

请用for循环生成以下九九乘法表：

for i in range(1,10):
    for j in range(1,i+1):
        k = i*j
        print(f"{i}x{j}={k}",end="\t")
    print()

output
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

%%writefile ch2_7.py

for i in range(1, 10):
    for j in range(1, i+1):
        k = i*j
        print(f"{j} * {i} = {k}", end="\t")
    print()

output
Writing ch2_7.py

N=int(input("请输入正整数 N = "))
sum_num = 0
for i in range(1,N+1):
     sum_num += i
print(sum_num)

output
请输入正整数 N = 100
5050

6. 字典的概念与创建

在Python中，可以使用一对花括号 {} 来创建一个字典，或者使用内置的dict()函数来创建一个字典。字典由键-值对(key-value pairs)组成，每个键都唯一且不可变（通常是字符串或数字），对应一个值。以下是一些示例：

6.1 示例–计算水果总价

container = {"苹果":5,"桃子":6,"香蕉":3,"梨子":4}
print(container) # 打印字典中的内容
container["桃子"]*3 #提取指定key对应的value：字典[key名称]

output
{‘苹果’: 5, ‘桃子’: 6, ‘香蕉’: 3, ‘梨子’: 4}
18

container["荔枝"]# 若字典中没有指定的key会报错

output
--------------------------------------------------------------

KeyError                     Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_11408\305154328.py in <module>
----> 1 container["荔枝"]


KeyError: '荔枝'

container.keys() # 查看字典中所有的key

dict_keys(['苹果', '桃子', '香蕉', '梨子'])

fruits = container.keys()
fruit1 = "荔枝"
w1 = 2

fruit2 = "桃子"
w2 = 3

fruit3 = "梨子"
w3 = 4
sales1 = 0
sales2 = 0
sales3 = 0
if fruit1  in fruits :
    price1 = container[fruit1]
    sales1 = price1 * w1  
    
if fruit2  in fruits :
    price2 = container[fruit2]
    sales2 = price2 * w2 
    
if fruit3  in fruits :
    price3 = container[fruit3]
    sales3 = price3 * w3 
    
total_sale = sales1+sales2+sales3
print(f"水果总价为{total_sale}")

output
水果总价为34

num_fruits = 3
fruit = ["荔枝","桃子","梨子"]
weights = [2,3,4]
container = {"苹果":5,"桃子":6,"香蕉":3,"梨子":4}
sale = 0
for i in range(0,num_fruits):
    f = fruit[i]
    if f in container.keys():
        p = container[f]
        w = weights[i]
        sale += p*w
print(f"水果总价为{sale}元")

output
水果总价为34元

%%writefile ch2_8.py
num_fruits = 3
fruit = ["荔枝","桃子","梨子"]
weights = [2,3,4]
container = {"苹果":5,"桃子":6,"香蕉":3,"梨子":4}
sale = 0
for i in range(0,num_fruits):
    f = fruit[i]
    if f in container.keys():
        p = container[f]
        w = weights[i]
        sale += p*w
print(f"水果总价为{sale}元")

output
Writing ch2_8.py

6.2 字典的创建

在Python中，可以使用一对花括号 {} 来创建一个字典，或者使用内置的dict()函数来创建一个字典。字典由键-值对(key-value pairs)组成，每个键都唯一且不可变（通常是字符串或数字），对应一个值。以下是一些示例：

# 创建一个空字典
empty_dict = {}
print(empty_dict)

output
{}

# 创建一个包含三个键，值为空列表的字典
subject_scores={
    "小红":None,
    "小明":None,
    "小亮":None,
}
print(subject_scores)

output
{‘小红’: None, ‘小明’: None, ‘小亮’: None}

# 创建一个包含三个键值对的字典
subject_scores={
    "小红":90,
    "小明":80,
    "小亮":95,
}
print(subject_scores)

output
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

# 通过 dict() 函数创建字典
empty_dict1 = dict()
print(empty_dict1)

subject_scores1=dict(小红=90,小明=80,小亮=95)
print(subject_scores1)

output
{}
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

# 使用列表推导式创建字典
students = ["小红","小明","小亮"]
scores = [90,80,95]
subject_scores2={students[i]:scores[i] for i in range(len(students))}
print(subject_scores2)

output
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

6.3 字典内容的提取

在Python中，字典（dictionary）是一种内置的数据结构，用于存储键（key）和值（value）的对应关系。字典的键（key）必须是唯一的，而值（value）则可以是任何数据类型。以下是字典内容的键（key）和值（value）的提取方法：

my_dict = {"小明":269,"小红":243,"小亮":227}
print(my_dict)

output
{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227}

# 提取所有键（keys）：使用 `keys()` 方法可以获取字典中所有的键。
keys = my_dict.keys()
print(keys)

output
dict_keys([‘小明’, ‘小红’, ‘小亮’])

# 提取所有值（values）：使用 `values()` 方法可以获取字典中所有的值。
values = my_dict.values()
print(values)

output
dict_values([269, 243, 227])

# 提取键值对（items）：使用 `items()` 方法或字典的 `items` 属性可以获取字典中的所有键值对。

# 使用 items() 方法
items1  = my_dict.items()
print(items1)
print(list(items1)[0])

output
dict_items([(‘小明’, 269), (‘小红’, 243), (‘小亮’, 227)])
(‘小明’, 269)

for k,v in items1:
    print('names = ',k)
    print('scores = ', v)

output
names = 小明
scores = 269
names = 小红
scores = 243
names = 小亮
scores = 227

# 提取特定键的值：使用方括号 `[]` 并提供键名可以获取特定键对应的值。
scores0 = my_dict['小明']
print(scores0)

output
269

# 如果键不存在，将会抛出 KeyError
scores1 = my_dict['小白']
print(scores1)

output
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14716\3599480679.py in <module>
      1 # 如果键不存在，将会抛出 KeyError
----> 2 scores1 = my_dict['小白']
      3 print(scores1)


KeyError: '小白'

# 为了安全地提取特定键的值，可以使用 `get()` 方法，它允许您为不存在的键提供一个默认值。
scores2 = my_dict.get('小白',0)
print(scores2)

output
0

6.4 练一练

练习1：用字典的知识计算每个学生期末考试语数外的总成绩

scores_all ={'小明':[85,96,88],'小红':[72,80,91],'小亮':[83,69,75]}
print('输入为：',scores_all)
total_scores = {}
for names,s in scores_all.items():
    ts = sum(s)
    total_scores[names]= ts
print('输出为：',total_scores)

output
{‘小明’: [85, 96, 88], ‘小红’: [72, 80, 91], ‘小亮’: [83, 69, 75]}
{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227}

%%writefile ch2_10.py
scores_all ={'小明':[85,96,88],'小红':[72,80,91],'小亮':[83,69,75]}
print('输入为：',scores_all)
total_scores = {}
for names,s in scores_all.items():
    ts = sum(s)
    total_scores[names]= ts
print('输出为：',total_scores)

output
Writing ch2_10.py

练习2：若分别计算期末考试语、数、外的平均成绩，应该怎么做？

# import numpy as np
scores_all ={'小明':[85,96,88],'小红':[72,80,91],'小亮':[83,69,75]}
# print(scores_all)
subject_scores = {
    "语文":[],
    "数学":[],
    "英语":[]
}
for names,s in scores_all.items():
    subject_scores['语文'].append(s[0])
    subject_scores['数学'].append(s[1])
    subject_scores['英语'].append(s[2])
print(subject_scores)#打印每科成绩对应的学生分数

avg_scores ={}
for subject,s in subject_scores.items():
    avg_s = sum(s)/len(s)
    avg_scores[subject] = avg_s
print(avg_scores)

output
{‘语文’: 80.0, ‘数学’: 81.66666666666667, ‘英语’: 84.66666666666667}

%%writefile ch2_11.py
# import numpy as np
scores_all ={'小明':[85,96,88],'小红':[72,80,91],'小亮':[83,69,75]}
subject_scores = {
    "语文":[],
    "数学":[],
    "英语":[]
}
for names,s in scores_all.items():
    subject_scores['语文'].append(s[0])
    subject_scores['数学'].append(s[1])
    subject_scores['英语'].append(s[2])
print(subject_scores)#打印每科成绩对应的学生分数

avg_scores ={}
for subject,s in subject_scores.items():
    avg_s = sum(s)/len(s)
    avg_scores[subject] = avg_s
print(avg_scores)

output
Writing ch2_11.py

7. 集合的概念与使用

集合（set）是一个无序的、不重复的元素集。集合可以用来执行数学上的集合操作，如并集、交集、差集和对称差集等。

7.1示例–提取两班级重名学生

#运用其它知识求一班、二班同名的学生
class1 = ['joan','bill','niki','mark','mark']
class2 = ['tom','linda','bill']
for name1 in class1:
    for name2 in class2:
        if name1 == name2:
            print(name1)

output
bill

#运用其它集合求一班、二班同名的学生
class1 = set(['joan','bill','niki','mark','mark'])
class2 = set(['tom','linda','bill'])
same_name = class1&class2
print(same_name)

output
{‘bill’}

7.2 集合的创建

使用 set() 函数创建集合

# 创建一个空集合
my_set =set()
print(my_set)

output
set()

my_set1 ={}#不能用{}创建空集合，{}默认创建的是空字典
print(type(my_set1))

output
<class ‘dict’>

# 向集合中添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)
my_set.add(4)
print(my_set)

output
{1, 2, 3, 4}

# 移除集合中的元素
my_set.remove(1)
print(my_set)

output
{2, 3, 4}

# 创建一个包含元素的集合
class1 = set(['joan','bill','niki','mark','mark'])

print(type(class1))

output
<class ‘set’>

# 直接定义一个包含元素的集合
class1 = {'joan','bill','niki','mark','mark'}
print(type(class1))

# 创建一个不可变集合
my_nochange = frozenset([1,2,3])

my_nochange.add(4)#不可变集合不能进行元素的增删改

output
---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14716\1262365579.py in <module>
----> 1 my_nochange.add(4)


AttributeError: 'frozenset' object has no attribute 'add'

7.3 集合的访问

在Python中，由于集合（set）是无序的，我们不能通过索引或位置来访问集合中的元素，这与列表（list）和元组（tuple）等有序数据结构不同。然而，我们可以使用以下几种方法来访问集合中的元素或进行操作：

list0=[1,5,6,9,2]
print(list0)
set0={1,5,6,9,2}#集合无序
print(set0)
set1={1,5,5,9,2}#集合会自动只保留重复元素的一个
print(set1)

output
[1, 5, 6, 9, 2]
{1, 2, 5, 6, 9}
{1, 2, 5, 9}

# 检查元素是否在集合中：使用 `in` 关键字可以检查一个元素是否存在于集合中。
my_set = {1, 2, 3}
print(4 in my_set)
print(3 in my_set)

output
False
True

# 遍历集合中的所有元素：使用 `for` 循环可以遍历集合中的所有元素。
for n in my_set:
    print(n)

output
1
2
3

# 获取集合的长度：使用 `len()` 函数可以获取集合中元素的数量。
len(my_set)

output
3

# 获取集合中的最小值和最大值
print(min(my_set))
print(max(my_set))
#如果集合为空，使用 `min()` 或 `max()` 函数将会抛出 `ValueError`。
my_set4 = set()
min(my_set4)

output
1
3

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14716\3659269115.py in <module>
      4 #如果集合为空，使用 `min()` 或 `max()` 函数将会抛出 `ValueError`。
      5 my_set4 = set()
----> 6 min(my_set4)


ValueError: min() arg is an empty sequence

# 检查集合是否为空
if len(my_set4)==0:
    print("my_set4集合为空")
else:
    print("my_set4集合不为空")

output
my_set4集合为空

7.4 集合操作

如并集、交集、差集和对称差集等

set1 = {1, 2, 3,4}
set2 = {3, 4, 5,6}

# 交集（intersection）
print(set1&set2)
print(set1.intersection(set2))

output
{3, 4}

# 并集（union）
print(set1|set2)
print(set1.union(set2))

output
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}

# 差集（difference）
print(set1-set2)
print(set1.difference(set2))

output
{1, 2}
{1, 2}

print(set2-set1)
print(set2.difference(set1))

output
{5, 6}
{5, 6}

# 对称差集（symmetric difference）：两集合中交集之外的元素
print(set1^set2)

output
{1, 2, 5, 6}

7.5 练一练

求在二班出现一班没出现的学生名

#运用其它集合求一班、二班同名的学生
class1 = set(['joan','bill','niki','mark','mark'])
class2 = set(['tom','linda','bill'])
name_in2_notin1 = class2-class1
print(name_in2_notin1)

output
{‘linda’, ‘tom’}

8. 模块

在Python中一个模块就是一个文件。

模块是保存代码的最小单位，在模块中可以声明变量、函数、属性和类等Python代码元素。

• 方式1：import<模块名>

➼如果想导入所有内容，则使用方式1。

• 方式2：from< 模块名>import< 代码元素>

➼如果只是导入一个元素，则使用方式2。

• ➼方式3：from<模块名>import <代码元素>as <代码元素别名>

➼如果名称有冲突或待导入模块名称很复杂，则使用方式3。

8.1 示例–验证用户注册信息是否合规

请让注册用户输出昵称、密码以及性别信息，可自定义增加填写提示或者填写要求

while True:
    name=input("请输入不超过8个字符作为你的昵称：")#要求
    if len(name) > 8:#判断
        print("昵称长度不能超过8个字符,请重新设置")#错误信息
    else:
        print(name)
        break
        
while True:
    password=input("请输入4为数字作为你的密码：：")#要求
    if not password.isdigit() or len(password) != 4:#判断
        print("密码必须是4位数字,请重新设置")#错误信息
    else:
        print(password)
        break
        
while True:
    sex=input("请填写您的性别（男/女）：")#要求
    if sex not in ["男", "女"]:#判断
        print("性别输入错误，请填写'男'或'女'")#错误信息
    else:
        print(sex)
        break

def get_valid_input(prompt, validator, error_message):
    while True:
        user_input=input(prompt)#要求
        if validator(user_input):#判断
#             print(user_input)
            return user_input #以函数定义的话要改成return，否则输出为None
        else:
            print(error_message)#错误信息

def valid_name():
    while True:
        name=input("请输入不超过8个字符作为你的昵称：")#要求
        if len(name) > 8:#判断
            print("提示：昵称长度不能超过8个字符,请重新设置")#错误信息
        else:
            print(name)
            break

valid_name()

%%writefile ch2_12.py
def valid_name():
    while True:
        name=input("请输入不超过8个字符作为你的昵称：")#要求
        if len(name) > 8:#判断
            print("提示：昵称长度不能超过8个字符,请重新设置")#错误信息
        else:
            print(name)
            break


def valid_password():
    while True:
        password=input("请输入4位数字作为你的密码：：")#要求
        if not password.isdigit() or len(password) != 4:#判断
            print("提示：密码必须是4位数字,请重新设置")#错误信息
        else:
            print(password)
            break
            
def valid_sex():
    while True:
        sex=input("请填写您的性别（男/女）：")#要求
        if sex not in ["男", "女"]:#判断
            print("性别输入错误，请填写'男'或'女'")#错误信息
        else:
            print(sex)
            break

output
Writing ch2_12.py

import ch2_12
ch2_12.valid_password()

output
请输入不超过8个字符作为你的昵称：aaa
aaa

from ch2_12 import valid_password
valid_password()

output
请输入4位数字作为你的密码：：d345
提示：密码必须是4位数字,请重新设置
请输入4位数字作为你的密码：：1254
1254

from ch2_12 import valid_password as vp
vp()

output
请输入4位数字作为你的密码：：k111
提示：密码必须是4位数字,请重新设置
请输入4位数字作为你的密码：：1254
1254

import ch2_12 as f
f.valid_password()

output
请输入4位数字作为你的密码：：k112
提示：密码必须是4位数字,请重新设置
请输入4位数字作为你的密码：：1254
1254

8.2 练习

%%writefile ch2_13.py
x=20
y='hello world!'
bool_value=True

output
Overwriting ch2_13.py

import ch2_13
from ch2_13 import y
from ch2_13 import bool_value as z
print(ch2_13.x)
print(y)
print(z)

output
20
hello world!
True

print(x)

output
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_28360\1353120783.py in <module>
----> 1 print(x)


NameError: name 'x' is not defined

x='good luck!'
print(x)

output
good luck!