抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

Python基础教程

发布于：2024年11月7日

前排

如果显示有问题,请关闭黑暗模式
电脑端滚轴上滑会显示顶端栏,有一个黑暗模式
手机端点击右上角，找到黑暗模式

特别鸣谢： 童博扬、王昌翔、张紫涵、石非易

本文内容可能存在错误，欢迎指正
习题没有标准答案,提供的题解仅供参考

基本操作

数据的输入input()

Python程序的输入通过函数input()实现，特别注意，利用input()函数输入的任何数据都是字符串类型
所以需要整数数字需要用int()函数转换为整数 如下

1
x = int(input("请输入x:"))

其中input()中引号中的内容为显示的内容，不影响程序的运行

变量数据类型

int : 整数型
str ：字符串类型
tuple : 元组类型
float : 浮点数类型(可以理解为有小数)
list : 列表类型
dict : 字典类型
range : 数字序列类型
Bool : 布尔型 (只含有True和False两个值)
*NoneType : 空值类型(None)
*set : 无序的不重复集合

变量的赋值操作

直接赋值

赋值通过符号实现

1
2
3
>>> x = 5
>>> x
5

通过,我们将一个值5赋值给了变量 默认是整数int类型
它的默认值和你后面的数据有关 比如

1
2
3
>>> x = "5"
>>> y = "abc"
>>> z = True

x = “5” 加了引号，则这个x的值5实际上是一个字符串类型，同理下面的y = abc得到的也是一个字符串类型
就是一个布尔型

增量赋值

对于 变量 += 值,相当于 变量 = 变量 + 值 如下

1
2
3
4
>>> x = 5
>>> x += 2 (等价于x = x + 2)
>>> x
7

链式赋值

多个等号赋值
即将x,y,z值都赋值为n

1
2
3
>>> x = y = z = 5
>>> print(x,y,z)
5 5 5

位置赋值

等号两边的变量分别用逗号隔开,然后根据对应位置进行赋值
比如 a,b,c = x,y,z,结果a = x,b = y,c = z;

1
2
# 交换a,b的值
a,b = b,a

二、八、十六进制

关于进制学习

  1. 0b(0B) 二进制
    1
    2
    >>> 0b101
    5
  2. 0o(0O) 八进制
    1
    2
    >>> 0o101
    65
  3. 0x(0X) 十六进制
    1
    2
    >>> 0x101
    257

字符串

ASCII码

*介绍

通过整数int型对应的字符串,是一种字符编码标准，用于表示文本中常见的字符。它通过给每个字符分配一个整数值，使得计算机能够存储和传输文本信息。
ord()：将一个字符转换为对应的 ASCII（或 Unicode）码点。
chr()：将一个整数（ASCII 或 Unicode 码点）转换为对应的字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 字符 'A' 的 ASCII 码
print(ord('A'))  # 输出 65

# 字符 'a' 的 ASCII 码
print(ord('a'))  # 输出 97

# 空格字符的 ASCII 码
print(ord(' '))  # 输出 32

# 数字字符 '0' 的 ASCII 码
print(ord('0'))  # 输出 48

# 标点符号字符 '!' 的 ASCII 码
print(ord('!'))  # 输出 33

# 字符 'Z' 的 ASCII 码
print(ord('Z'))  # 输出 90

# 字符 'z' 的 ASCII 码
print(ord('z'))  # 输出 122

#####################################

# ASCII 码 65 对应的字符
print(chr(65))  # 输出 'A'

# ASCII 码 97 对应的字符
print(chr(97))  # 输出 'a'

# ASCII 码 32 对应的字符
print(chr(32))  # 输出 ' ' (空格)

# ASCII 码 48 对应的字符
print(chr(48))  # 输出 '0'

# ASCII 码 33 对应的字符
print(chr(33))  # 输出 '!'

常见元素的ASCII码

  1. int()整数型与ASCII码的关系为
    比如 48的ASCII值对应字符’1’,49对应’2’,……,57对应’9’

  2. A的ASCII码为65,a的ASCII码为97
    A - Z,a - z的ASCII码可以根据ABCDE……XYZ的顺序推出 B就是66，b就是98

注意：以上不管是ABC，abc,还是0 1 2,ASCII码对应的都是字符型(str),数字也是字符型

索引与切片

索引

索引就是字符串按顺序从左到右的编号。
特别地，如果字符串长度为n,字符串第一个元素地编号为0，最后一个为n-1 从0开始
反向索引则第一个为-n,最后一个为-1 则为从-1开始

1
2
3
4
5
>>> s = "ABC"
>>> s[0]
A
>>> s[1]
B

正反索引转换

为了方便，我们把反索引转换为正索引，下面给出公式：
反索引为-i,正索引为n - i
正索引为i,反索引为n - i - 1
比如反索引为-5，字符串长度为9，正索引为4

切片

定义一个字符串s = “abcdefg”
切片: s[begin:end:step]
begin : 起始索引
end : 终止索引(不包括该索引下的字符,可以理解为一个左闭右开区间[begin,end))
step : 步长，默认1，可省略
起始终止索引如果省略默认为最左边的索引(0)，但是二者中间的 : 不可省略
如果起始终止索引都不填，默认为整个字符串
看示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> s[2:5] #从第三个字符开始，到第5个字符,步长默认为1
cde

>>> s[2:5:2] #步长改为2
ce

>>> s[ :5] #默认起始索引为0
abced

>>> s[2:-3] #-3的正索引为7 - 3 = 4,即为s[2:4]
cd

>>> s[5: :-2] #默认终止索引为0，步长为负，往左切，从s[5]= f开始
fdb

字符串运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
x = "abc"
y = "ABC"
# [] 通过索引获取字符
>>> x[2]
c

# [: :] 切片
略

# + 连接两个字符串
>>> x + y
abcABC
>>> y + x
>>> ABCabc

# * 重复拼接,理解为做乘法
>>> x * 2
abcabc

# in,not in 判断子字符串是否存在，返回布尔值True or False
>>> 'bc' in x
True
>>> 'bd' not in x
True
注意 空格也算一个字符
>>> 'b c' in x
False

字符串中的函数

详见P31-P36 课本很详细
在文末通过例题进行讲解，这里不赘述

运算符

算术运算符

1
2
3
4
5
6
7
8
9
10
a = 10
b = 3
print("加法:", a + b)       # 输出 13
print("减法:", a - b)       # 输出 7
print("乘法:", a * b)       # 输出 30
print("除法:", a / b)       # 输出 3.3333333333333335
print("整除:", a // b)      # 输出 3
print("取余:", a % b)       # 输出 1
print("幂运算:", a ** b)    # 输出 1000
print("负号:", -a)          # 输出 -10

其中//整除默认向下取整

运算符优先级顺序（总结）
指数运算：** （最高优先级）
正负号：+ - （用于表达式的单目运算符）
乘法/除法等：* / // %
加法/减法：+ -
关系运算符：== != > < >= <= （最低优先级）
比如x = 5 + 2 * 3 ** 2 == 10 / 2

3 ** 2 = 9
2 * 9 = 18
5 + 18 = 23
10 / 2 = 5.0
23 == 5.0，结果为 False

关系运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
a = 10
b = 5
c = 10

# 等于运算符
print(a == b)  # False
print(a == c)  # True

# 不等于运算符
print(a != b)  # True
print(a != c)  # False

# 大于运算符
print(a > b)   # True
print(a > c)   # False

# 小于运算符
print(a < b)   # False
print(a < c)   # False

# 大于等于运算符
print(a >= b)  # True
print(a >= c)  # True

# 小于等于运算符
print(a <= b)  # False
print(a <= c)  # True

感叹号在这不是阶乘，不是阶乘，等于关系是双等号！双等号！
is,not is判断是不是一个内存地址,相当于id(x) ==或!= id(y)的用处
只需要记住整数型如果两个数的值相等且该值处于-5~256的闭区间，内存地址一样
字符串型号如果只有数字和字母(没有空格)且相同，内存地址一样

逻辑运算符

not and or,优先级 not > and > or
not就是对表达式的布尔值取反
and就是连接两个表达式，都为真为真，有一个为假则为假
or就是两个表达式有一个为真就为真

常见保留关键字

False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield

格式化

介绍

格式化输出主要使用到f-string和format()两种
f-string 更加简洁和高效，推荐在 Python 3.6 及以后的版本中使用，尤其是当你需要直接嵌入变量或表达式时。
format 在需要更复杂的格式化控制时更有用，特别是当你需要在同一个字符串中使用多次相同的变量或进行特殊格式化时。
课本上给的大多数是format(),考试中的考察大多数也是format()用法,这里我们对两种方法进行讲解
后面习题用的是f-string
注意 对于一些你想到的但是没有出现的可能，一定要试着自己敲一敲代码看一看结果,切记实践是检验真理的唯一标准

f-string

它以字面值字符串的形式在前面加上 f 或 F，并在字符串中使用花括号 {} 来嵌入表达式或变量。
意思就是{}中的元素 输出时候会显示它的量,比如x = 1,{x}就是输出1而不是x,但是花括号外就是x
如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
x = 5
y = 1
print(f"x")
<<< x

print(f"{x}")
<<< 5

print(f"x + y = x + y")
<<< x + y = x + y

print(f"x + y = {x + y}")
<<< x + y = 6

你也可以把它当成一个变量来进行输出 如下

1
2
3
4
5
6
x = 5
y = 1
sum = x + y 
result = f"The sum of x + y = {sum}"
print(result)
<<< The sum of x + y = 6

format()

这里我们详讲一下format()，这是考点之一
使用大括号 {} 作为占位符，在 format() 方法中传入相应的值。
示例

基本用法

1
2
3
4
5
name = "Alice"
age = 30
greeting = "Hello, my name is {} and I am {} years old.".format(name, age) # {}个数和后面format()中元素个数对应一致即可
print(greeting)
<<< Hello, my name is Alice and I am 30 years old.

位置参数

你可以通过在 format() 中指定位置来插入多个变量。位置是从 0 开始的，类似于列表索引。

1
2
3
greeting = "Hello, {0}! Today is {1}.".format("Alice", "Monday")
print(greeting)
<<< Hello, Alice! Today is Monday.

上面括号中的从左到右的索引顺序就是{}的索引

1
2
3
greeting = "Hello, {1}! Today is {0}.".format("Monday", "Alice")
print(greeting)
<<< Hello, Alice! Today is Monday.

关键字参数

你也可以使用关键字参数传递值，并在花括号中通过名字来引用它们。
如下

1
2
3
greeting = "Hello, {name}! Today is {day}.".format(name="Alice", day="Monday")
print(greeting)
<<< Hello, Alice! Today is Monday.

重复使用变量

示例如下

1
2
3
4
greeting = "Hello, {0}! Your {0}'s status is confirmed.".format("Alice")  或者
greeting = "Hello, {name}! Your {name}'s status is confirmed.".format(name="Alice")
print(greeting)
<<< Hello, Alice! Your Alice's status is confirmed.

混合用法

关键字参数和索引地一起使用 如下

1
2
3
greeting = "Hello, {0}! Today is {day}.".format("Alice", day="Monday")
print(greeting)
<<< Hello, Alice! Today is Monday.

注意 你可以将位置参数和关键字参数混合在同一个 format() 中，但位置参数必须放在关键字参数之前。
比如如下情况就会报错

1
2
3
4
greeting = "Hello, {0}! Today is {1}.".format("Alice", day="Monday")
greeting = "Hello, {0}! Today is {1}.".format("Alice", day="Monday","test")
greeting = "Hello, {0}! Today is {day}.".format("Alice", day="Monday")
greeting = "Hello, {0}! Today is {day}.".format(day="Monday","Alice")

即关键字在位置参数变量的后面，而且不算到位置参数里面，即索引的个数只与位置参数有关，与关键字参数的个数无关

数字格式化

format 可以用来格式化数字，指定小数位数、宽度、对齐方式等。
示例1：小数位数的保留 {:.nf} 保留n位小数

1
2
3
4
pi = 3.14159
formatted = "The value of pi is {:.2f}".format(pi)
print(formatted)
<<< 3.14

其中:前面填它的位置参数

1
2
3
4
5
6
7
8
pi = 3.14159
tx = 2.22222
print("The value of pi is {0:.2f}".format(pi,tx))
print("The value of pi is {1:.2f}".format(pi,tx))
print("The value of pi is {e:.2f}".format(e=2.71828))
<<< 3.14
<<< 2.22
<<< 2.72

保留小数的依据是：四舍五入
示例2：你可以使用 :<、:>、:^ 来设置文本的对齐方式，还可以使用数字来设置字段宽度。

1
2
3
4
5
6
7
8
9
10
11
12
text = "Hello"
formatted = "{:<10}".format(text)  # 左对齐
print(f"'{formatted}'")

formatted = "{:>10}".format(text)  # 右对齐
print(f"'{formatted}'")

formatted = "{:^10}".format(text)  # 居中对齐
print(f"'{formatted}'")
<<< 'Hello     '
<<< '     Hello'
<<< '  Hello   '

其中10为整个范围的场宽,如果这个数字小于原本元素的宽度，比如小于hello的宽度5，就不会有影响
f-string的使用是为了显示出两个单引号’’来表示它的场宽
你也可以直接用一个数字来表示这个输出的宽度,不进行对齐

1
2
3
4
number = 42
formatted = "{:5}".format(number)
print(f"'{formatted}'")
<<< '   42'

默认是右对齐

格式化数字的填充与符号

    • 表示无论正数还是负数都显示符号：
      1
      2
      3
      4
      num1 = 42
      num2 = -42
      formatted1 = "{:+}".format(num1)  # 输出 +42
      formatted2 = "{:+}".format(num2)  # 输出 -42
    • 表示仅在负数前显示符号，而正数不显示符号。实际上，这是默认的符号显示方式，所以即使省略 - 也会得到同样的效果。
      1
      2
      formatted1 = "{:-}".format(num1)  # 输出 42
      formatted2 = "{:-}".format(num2)  # 输出 -42

  3. （空格）表示在正数前显示一个空格，而负数显示 -。这种方式在对齐时很有用，因为正数会有一个占位空格，与负数对齐更整齐。

    1
    2
    formatted1 = "{: }".format(num1)  # 输出  42 (42前空一个字节)
    formatted2 = "{: }".format(num2)  # 输出 -42

  4. 填充 

    1
    2
    3
    4
    5
    6
    num = 42
    formatted = "{:05}".format(num)  # 宽度为5，使用0填充 {:05}等价于{0>5}
    print(formatted)
    <<< 00042
    # formatted = "{:0<5}".format(num)  # 42000 数字左对齐,右填充
    # formatted = "{:0^5}".format(num)  # 04200 居中,左右一起填充

    除此之外 对于符号 比如+ - * . # 也可以填充,替换0即可

百分比格式化

你可以通过 format 来格式化百分比数值，使用 :.2% 来指定保留两位小数的百分比。

1
2
3
4
percentage = 0.12345
formatted = "{:.2%}".format(percentage)
print(formatted)
<<< 12.35%

日期格式化

1
2
3
4
5
from datetime import datetime
now = datetime.now()
formatted = "Current date and time: {:%Y-%m-%d %H:%M:%S}".format(now)
print(formatted)
<<< Current date and time: 2024-11-10 15:42:30

嵌套格式化

你也可以在格式化字符串中进行嵌套，先使用一个表达式再进行格式化。

1
2
3
formatted = "{:,.2f}".format(1234567.8910) # 这里 :, 用来添加千位分隔符，.2f 控制显示两位小数。
print(formatted)
<<< 1,234,567.89

对应的f-string的功能用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 数字格式化
pi = 3.14159
print(f"The value of pi is {pi:.2f}") 

# 填充和对齐
text = "Hello"
print(f"'{text:<10}'")  # 左对齐
print(f"'{text:>10}'")  # 右对齐
print(f"'{text:^10}'")  # 居中对齐

# 指定场宽
num = 42
print(f"'{num:5}'")

# 日期格式化
from datetime import datetime
now = datetime.now()
print(f"Current date and time: {now:%Y-%m-%d %H:%M:%S}")

# 百分比
percentage = 0.12345
print(f"{percentage:.2%}")

课本习题

我们通过课本习题进行大多数内容讲解，建议看完课本剩余内容的基本定义
然后根据题目的讲解进行理解
因为没有标准答案，所以答案仅供参考

P14 Problem 1-7

  1. D
  2. C
  3. D
  4. B
  5. D
  6. 1
    2
    3
    11+22
    33
    11 22 33
  7. 1
    2
    3
    Hello

    World

P14 Problem 8-12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# Problem 8: 输入两个整数，输出它们的和
def Problem_eight():
    num1 = int(input("请输入第一个整数："))
    num2 = int(input("请输入第二个整数："))
    result = num1 + num2
    print(f"这两个整数的和是: {result}")

# Problem 9: 输入两个整数，输出这两个整数为高位和低位组成的整数
def Problem_nine():
    num1 = int(input("请输入第一个整数（高位）："))
    num2 = int(input("请输入第二个整数（低位）："))
    # 将两个数合并为一个整数
    result = int(str(num1) + str(num2))
    print(f"组成的新整数是: {result}")

# Problem 10: 输出1+2+3+4+......+10的和
def Problem_ten():
    total = sum(range(1, 11))
    print(f"1到10的和是: {total}")

# Problem 11: 输出1*2*3*...*10的积
def Problem_eleven():
    total = 1
    for i in range(1, 11):
        total *= i
    print(f"1到10的积是: {total}")

# Problem 12: 以数字*作为基本要素输出"ZJUT"的图案
def Problem_twelve():
    # Z
    print("********  ")
    print("        * ")
    print("       *  ")
    print("******    ")
    print("     *     ")
    print("    *      ")
    print("********  ")
    print()
    # J
    print("      *** ")
    print("      *   ")
    print("      *   ")
    print("      *   ")
    print("*     *   ")
    print("*     *   ")
    print("*******   ")
    print()
    # U
    print("*       * ")
    print("*       * ")
    print("*       * ")
    print("*       * ")
    print("*       * ")
    print("*       * ")
    print("********* ")
    print()
    # T
    print("********* ")
    print("    *     ")
    print("    *     ")
    print("    *     ")
    print("    *     ")
    print("    *     ")
    print("    *     ")

print("请输入题号（8-12）来选择对应的题目：")
problem_number = int(input())
    
if problem_number == 8:
    Problem_eight()
elif problem_number == 9:
    Problem_nine()
elif problem_number == 10:
    Problem_ten()
elif problem_number == 11:
    Problem_eleven()
elif problem_number == 12:
     Problem_twelve()
else:
    print("无效的题号。请输入一个有效的题号（8-12）。")

P53 Problem 2-10

  1. A
    解析
    B ： 变量名不可用数字开头，通常用大小驼峰习惯进行命名，比如getNumber这种
    C : and是保留关键字，不可以命名
    D : 不可用特殊符号进行命名,下划线_除外

  2. B
    解析
    A D : 不严谨,不纯粹
    C : 赋值左边是一个变量，不可以是一个表达式

  3. D
    解析
    A B : 单双引号不影响，都是字符串类型
    C : 字符串类型，空字符串
    D : 复数类型

  4. C
    解析
    指数运算，右结合(从右往左进行运算)
    2 ** 3 = 8
    2 ** 8 = 256

  5. D
    解析
    A : 字符串不能直接加数字
    ord函数：函数内填字符,返回字符所对应的ASCII码
    chr函数: 函数内填ASCII码，返回字符
    B : ord(‘D’) = 68,该选项得到67
    C : chr(65)返回字符’A’，不可与数字相加
    D : ord(‘B’) + 1 = 66 + 1 = 67,chr(67) = ‘C’ 正确

  6. C
    解析
    A B : 分别得到第一个，第二个字符
    D : len(s) 返回字符串s的长度，超出索引,应该是len(s) - 1

  7. B
    解析
    A : 返回’Pr’
    C : 返回’ro’
    D : 返回’rog’

  8. C
    解析
    A B D : 返回’ab’
    C : 返回’aba’

  9. D
    解析
    randint(10,99) 随机返回一个位于闭区间[10,99]的整数
    randrange(10,100) 随机返回一个位于左闭右开区间[10,100)的整数，步长为1
    randrange(10,100,2) 随机返回一个位于左闭右开区间[10,100)的整数，步长为2 即10 12 14 16 …… 96 98之一
    uniform(10,99) 随机返回一个位于闭区间[10,99]的浮点数

D : 返回的不是整数

  1. BC
    解析
    A : 使用大小驼峰进行命名
    D : 可以使用中文名，但是不建议

P53 Problem 11

1
2
3
4
5
6
7
8
9
10
11
12
13
# 引入数学模块
import math

# 输入球的半径
r = float(input("请输入球的半径 r: "))

# 计算球的体积 V
# math.pi 为 
V = (4/3) * math.pi * r**3

# 输出球的体积，保留四位小数
# f-string格式化输入 {变量} 输出为变量所表示的值 .4f 保留四位小数
print(f"球的体积 V: {V:.4f}")

P53 Problem 12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import math

# 输入三角形的两条边和夹角
a = float(input("请输入边 a 的长度: "))
b = float(input("请输入边 b 的长度: "))
C = float(input("请输入夹角 C 的角度值: "))

# 将角度值转换为弧度值
C_rad = math.radians(C)

# 计算三角形的面积 math.sin()函数计算正弦值
S = 0.5 * a * b * math.sin(C_rad)

# 输出三角形的面积，保留四位小数
print(f"三角形的面积 S: {S:.4f}")

P53 Problem 13

1
2
3
4
5
6
7
8
9
10
11
12
# 引入calendar库
import calendar

# 输入年份和月份
year = int(input("请输入年份: "))
month = int(input("请输入月份: "))

# 使用calendar.month()获取指定月份的日历
month_calendar = calendar.month(year, month)

# 输出指定的月份日历
print(month_calendar)

P74 Problem 1-7

  1. B
    解析
    int类型中0为False，非0都为True
    字符串只有空串为False 其他为True

  2. C
    解析
    列表大小比较先比较长度，短的小
    长度一样从左往右依次比较对位元素，直到找到第一个可以比较大小的元素，停止，不看后面的元素
    比如此题1 3都相同开始比较下一个元素字符串
    字符串先比较长短，短的小
    长度相同开始从左往右比较各个字符的ASCII码 按大小比较
    c的ASCII码大于D 所以返回True 满足三目运算符,得3

  3. D
    解析
    A B : Python也有类似C语言中的三目运算符 ? 但用法如下
    a = x if x > y else y
    取两个值较大的一个
    C : if后跟冒号 改为if(x > y): 或者 if x > y :

  4. A
    解析
    x初始为0,在布尔类型下0对应False
    while x:循环条件为x，但一开始就为False无法进行

1
2
3
4
ZJUT
ZJU
ZJ
Z

解析
while s 即理解为s不为空串就执行
每一次更新s为它的子串0~length-1,也就是删掉最后一个元素

6. 

1
2
3
4
=ZJUT=
ZU=
=U
U

解析

1
2
3
s = s[1:] # 删去头部元素
s = s[: : 2] # 隔一个取一个
s = s[: :-1] # 字符串翻转

7.
分行输出1 3 4 3
解析
else与j的for循环并列 : 如果j循环完全执行(即没有被break过),则进行else
continue不影响else的函数,但是会影响它下面的输出ij
首先i = 1,j = 1,if和elif都不满足,执行print(ij),输出ij 也就是1
然后i = 1,j = 2,满足elif的条件,跳过,不执行执行print(ij)
此时i = 1时候j的循环完全执行,执行else里面的内容 执行print(i+j),输出i+j,此时j是循环到最后的值
也就是2i+1,为2，输出1+2,即3
然后i = 2,j = 1,满足elif 跳过
然后i = 2,j = 2,不满足if和elif,执行print(ij)，输出4
然后i = 2,j = 3,满足if条件,执行break函数跳出j的循环，因为没有运行完整该循环
不执行else的内容
然后i = 3,j = 1,不满足if和elif,执行print(ij)，输出3
然后i = 3,j = 2,满足if条件,执行break函数,不执行else的内容
i枚举完1~3,程序结束
所以分行输出1 3 4 3

P75 Problem 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 引入随机数库
import random

# 生成两个随机的正整数
number_one = random.randint(1, 100)  # 生成 1 到 100 之间的随机整数
number_two = random.randint(1, 100)

# 计算它们的和
total = number_one + number_two

# 提示用户输入这两个数的和
user_input = int(input(f"请计算 {number_one} + {number_two} 的和: "))

# 判断用户输入是否正确
if user_input == total:
    print("正确")
else:
    print("错误")

P75 Problem 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import math

# 输入x的值
x = float(input("请输入x的值: "))

# 判断x的值，计算对应的y值
if x < 0:
    y = x**2 + 5 # ** 取幂运算
elif 0 <= x < 10:
    y = math.sin(math.radians(x))**2  # 将x转换为弧度后计算sin(x)
else:
    y = math.exp(x) - math.log(x) # exp(x)即为函数e^x,log(x)函数为ln(x)

# 输出y的值，保留四位小数
print(f"y = {y:.4f}")

P75 Problem 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import math

# 输入三边
a = float(input("请输入边 a 的长度: "))
b = float(input("请输入边 b 的长度: "))
c = float(input("请输入边 c 的长度: "))

# 判断是否能构成三角形
if a + b > c and a + c > b and b + c > a: 
    s = (a + b + c) / 2 # 计算半周长
    area = math.sqrt(s * (s - a) * (s - b) * (s - c)) # 计算面积 math.sqrt()函数为开方
    print(f"三角形的面积为: {area:.4f}")  # 输出三角形的面积
else:
    # 如果不能构成三角形，输出提示信息
    print("无法构成三角形")

P76 Problem 11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 定义一个子函数对秒数进行处理
def convertTime(seconds):
    if seconds >= 86400: # 大于一天
        days = seconds // 86400 # 求天数，向下取整
        seconds %= 86400 # 取模，得到除去天数剩下的秒数
        hours = seconds // 3600 # 求小时数，向下取整
        seconds %= 3600  # 取模，同上
        minutes = seconds // 60 # 同上，后面不赘述
        seconds %= 60 
        print(f"{days}天{hours}小时{minutes}分钟{seconds}秒")
    elif seconds >= 3600: # 大于一小时
        hours = seconds // 3600
        seconds %= 3600
        minutes = seconds // 60
        seconds %= 60
        print(f"{hours}小时{minutes}分钟{seconds}秒")
    elif seconds >= 60: # 大于一分钟
        minutes = seconds // 60
        seconds %= 60
        print(f"{minutes}分钟{seconds}秒")
    else:
        print(f"{seconds}秒")

seconds = int(input("请输入秒数: "))
convertTime(seconds)

P76 Problem 12

1
2
3
4
5
6
def getZodiac(year):
    animals = ["鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"]
    return animals[(year - 2020) % 12] # 求出索引

year = int(input("请输入年份: "))
print(f"{year}年对应的生肖是:{getZodiac(year)}")

P76 Problem 13

1
2
3
4
5
6
n = int(input("请输入整数 n: "))
ans = 1
# 写一个循环,i从1到n range内为左闭右开区间
for i in range(1, n + 1): 
    ans *= i
print(f"{n} 的阶乘是: {ans}")

P76 Problem 14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import math
# 求平均值 sum函数为求一个列表的和,len函数返回列表的元素个数
def average(numbers):
    return sum(numbers) / len(numbers)

# 求标准差 varience是方差
def standardDeviation(numbers):
    n = len(numbers) # 求出元素个数
    sum_xi = sum(numbers)  # 计算所有数的和
    sum_xi_squared = sum([x ** 2 for x in numbers])  # 计算所有数的平方和
    variance = (sum_xi_squared - (sum_xi ** 2) / n) / (n - 1)  # 计算样本方差
    return math.sqrt(variance)

# 输入多个数，用逗号分隔
numbers_input = input("请输入多个数，用逗号分隔: ")

# 将输入的字符串按逗号分隔，并转换为浮点数列表
# split函数实现用,分隔开输入的元素，float转化为字符串
numbers = [float(x) for x in numbers_input.split(',')]

# 计算平均值和标准差
avg = average(numbers)
std_dev = standardDeviation(numbers)

# 输出结果
print(f"平均值: {avg:.4f}, 标准差: {std_dev:.4f}")

P76 Problem 15

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义一个子函数，来判断num是不是质数
def isPrime(num):
    if num < 2: # 0,1不是质数
        return False
    for i in range(2, int(num ** 0.5) + 1): # 从2到根号num开始枚举
        if num % i == 0:
            return False # 有一个数整除num,返回False ： 为合数
    return True # 到最后都没有一个因子，返回True : 为质数

def findPrimes(n):
    primes = [i for i in range(2, n + 1) if isPrime(i)] # 列表推导式,左边是数，右边是对数进行判断是不是质数
    return primes

n = int(input("请输入整数 n: "))
primes = findPrimes(n)
print(f"小于或等于 {n} 的素数有: {primes}, 总数为: {len(primes)}")

P76 Problem 16

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import math

def calculateSeries(x):
    sumResult = 0  # 结果初始化为0
    n = 1  # 从x^1开始
    term = x  # 第一项是x^1 / 1!
    sign = 1  # 第一项的符号是正
    while abs(term) >= 1e-5:  # 直到项的绝对值小于10^-5
        sumResult += term  # 累加当前项
        n += 2  # 下一项是 x 的下一个奇数次方
        sign *= -1  # 符号交替
        term = sign * (x**n) / math.factorial(n)  # 计算下一项
    return sumResult

# 输入浮点数
x = float(input("请输入浮点数 x: "))

# 计算并输出结果，保留六位小数
result = calculateSeries(x)
print(f"计算结果: {result:.6f}")

P76 Problem 17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import math

# 角度列表
angles = [0, 30, 60, 90, 120, 150, 180]

# 打印表头
print(f"{'角度':<10}{'sin':<10}{'cos':<10}{'tan':<10}")

# 计算并打印每个角度的三角函数值
for angle in angles: # 枚举属于角度列表的角度
    radians = math.radians(angle)  # 将角度转换为弧度
    sin_value = math.sin(radians) # 计算正弦值余弦值和正切值
    cos_value = math.cos(radians)
    tan_value = math.tan(radians)
    
    # 打印当前角度及其对应的三角函数值
    print(f"{angle:<10}{sin_value:<10.4f}{cos_value:<10.4f}{tan_value:<10.4f}")

P76 Problem 18

1
2
3
4
5
6
7
8
9
10
11
def print_multiplication_table():
    # 计算每个乘法表达式的最大长度
    max_width = len(f"9 * 9 = 81")
    
    for i in range(1, 10):  # 控制行数
        for j in range(1, i + 1):  # 每行的乘法表达式个数
            # 使用字符串格式化控制宽度
            print(f"{j} * {i} = {i * j:2}", end="  ")
        # 换行
        print()
print_multiplication_table()

P107 Problem 7

1
2
3
4
5
6
7
8
9
10
11
# 输入10个数值，用空格隔开
numbersList = list(map(int, input("请输入10个数值，用空格隔开：").split()))

# 计算平均数
averageValue = sum(numbersList) / len(numbersList)

# 找出大于平均数的所有数值
greaterThanAverage = [num for num in numbersList if num > averageValue]

# 输出大于平均数的数值
print("大于平均数的数值是:", greaterThanAverage)

P106 Problem 1-7

  1. B
    解析
    A : 一个空元组
    C : 含有单个元素的元组
    D : 一个元组
    B : 整数1

  2. D
    解析
    A. list.insert(index,number) 把number插入位置index 为[1,2,3,5]
    比如 a.insert(2,5) 就是插到第二个数后面,变为[1,2,5,3],(实际上是插到索引为2的位置，索引从0开始在第二个数后面)
    B. list.append(number) 把number插入末尾，括号里面只能一个数字(或者数对)
    比如 list.append((4,5)) 就是在末尾加入一个元组(4,5) 即[1,2,3,(4,5)]
    C. list.extend([number1,number2,….]) 将多个元素加入末尾
    这里非法了,应改为a.extend([4,5])
    如果要加入一个元组,这样 a.extend([(4,5)]) 变为[1,2,3,(4,5)]

  3. D
    解析
    [::-1] 切片操作，先翻转 (可以没有)
    [2] 找到索引为2的元素[1,2]
    [1] 找到[1,2]中索引为1的元素,即2
    为2

  4. A
    解析
    Python中元组和字符串是不可变的
    A : 第一个元素会变为[1,2,’X’] 是合法的
    B : add是集合set的用法，这里不能用
    C : 字符串不可变
    D : 元组不可变

  5. [0, 2, 4, 6, 8]
    [4, 6, 8, 0, 2]
    [8, 6, 4, 2, 0]
    [4, 6, 8, 0, 2]
    解析

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    x = [i for i in range(0,10) if i % 2 == 0] #取出[0,10)中所有偶数
    print(x) # >>> [0, 2, 4, 6, 8]
    for i in range(3): # 枚举0,1,2
        t = x.pop() # 弹出最右边的元素8,并赋值给t
        x.insert(0,t) # 把t插入列表最左边  实际上就是进行了三次把最右边元素放到最左边的操作
    # [0,2,4,6,8] → [8,0,2,4,6] → [6,8,0,2,4] → [4,6,8,0,2]
    print(x) # [4,6,8,0,2]
    y = x # 让y地址为x
    z = x[:] # 让z等于字符串x
    x.sort(reverse=True) # 降序排序
    print(y) # 因为y的地址为x,x降序排序 所以y降序 [8,6,4,2,0]
    print(z) # 为for循环运行结束时x的字符串,没进行降序 [4,6,8,0,2]

  6. [83, 3, 86, 89]
    [3, 83, 86, 89]
    [83, 86]
    [3]
    解析
    首先解释sort和sorted的区别
    sort : 只能用于列表,用法 a.sort(),修改原函数
    降序为a.sort(reverse = True)
    可以理解为一个操作,sort看成一个动词

sorted : 可以用于任何迭代对象,且不会修改原函数
理解返回它的变化值,sorted看成一个形容词
sorted_a = sorted(a, reverse=True) 降序排列操作，取a列表的降序顺序列表

1
2
3
x = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
x.sort()  # 对 x 进行排序
print(x)  # 输出 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
1
2
3
4
x = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
y = sorted(x)  # 返回排序后的新列表
print(x)  # 输出原始列表 [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(y)  # 输出排序后的新列表 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
1
2
3
4
5
6
7
8
9
10
11
12
x = [86,89]
a,b = x # a = 86,b = 89
i = 0 
while i < 2: # 枚举i = 0 和 i = 1
    a,b = b-a,a
    x.insert(0,a) # 插入元素
    i = i + 1
# a,b后面分别变为3,86和83,3 所以插入后x变为[83,3,86,89]
print(x)   # [83,3,86,89]
print(sorted(x)) # 输出升序后的x [3,83,86,89]
print(x[::2]) # x没变,对原列表切,步长为2 [83,86]
print([n for n in reversed(x) if n % 3 == 0]) # reversed是翻转的x,找出被3整除的数,即为[3]

reversed同样不会改变x原先的状态

P107 Problem 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import random

# 生成10个两位随机整数并放入列表
aList = [random.randint(10, 99) for _ in range(10)]  # 产生10个两位整数

# 输出原列表
print("原列表是:", aList)

# 获取用户输入的循环次数n
n = int(input("请输入循环次数n："))

# 确保n值不超过列表长度
n = n % len(aList)

# 执行右循环n次 list[a:b] 得到子列表a~b,不包含b
# aList[-n:] 得到最后n个元素 aList[:-n] 得到前面的元素
# 把最后n个元素放到剩下元素前面 实现后移
aList = aList[-n:] + aList[:-n]

# 输出循环后的列表
print("循环后的列表是:", aList)

P107 Problem 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import math

# 输入多个点的坐标，格式：x1 y1 x2 y2 x3 y3 ...
coords = input("请输入多个点的坐标，格式为x1 y1 x2 y2 ...：").split()

# 将输入的坐标转化为浮点数，并按顺序存储为元组
points = [(float(coords[i]), float(coords[i+1])) for i in range(0, len(coords), 2)]

# 计算从原点(0, 0)开始，按顺序连接这些点的线段的总长度
totalLength = 0

# 从原点到第一个点的距离
x0, y0 = 0, 0  # 原点
for x, y in points:
    distance = math.sqrt((x - x0)**2 + (y - y0)**2)
    totalLength += distance # 加上距离
    x0, y0 = x, y  # 更新当前点的位置

# 输出总长度，保留两位小数
print(f"从原点开始按顺序连接这些点的总长度为: {totalLength:.2f}")

P107 Problem 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import math

# 用户输入数据个数
n = int(input("请输入数据个数n："))

# 用户输入n个浮点数
data = list(map(float, input("请输入n个浮点数，用空格隔开：").split()))

# 计算平均值
average = sum(data) / n

# 计算标准差（近似标准差）
variance = sum((x - average) ** 2 for x in data) # 列表推导式枚举x
standardDeviation = math.sqrt(variance / (n - 1))

# 输出平均值和标准差，保留两位小数
print(f"平均值: {average:.2f}")
print(f"标准差: {standardDeviation:.2f}")

P107 Problem 11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def main():
    students = []

    # 持续接收输入，直到输入"OVER"
    while True:
        userInput = input("请输入学号和成绩，用空格隔开（输入OVER结束）：")
        if userInput == "OVER":
            break #如果输出OVER 结束程序

        # 分割学号和成绩
        studentInfo = userInput.split() # 读入学生信息为一个列表
        studentId = int(studentInfo[0]) # 学号
        score = float(studentInfo[1])   # 成绩

        # 判断成绩是否及格
        if score >= 60:
            students.append((studentId, score)) # 及格学生列表加入学生学号和成绩

    # 按学号升序排序
    students.sort(key=lambda student: student[0]) # 用sort函数按照学号进行排序

    # 输出结果
    print("\n考试及格的学生名单：")
    for student in students:
        print(f"学号: {student[0]}, 成绩: {student[1]:.2f}")

main()

P107 Problem 12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def main():
    students = []
    while True:
        userInput = input("请输入学号和成绩，用空格隔开（输入OVER结束）：")
        
        if userInput == "OVER":
            break
        studentInfo = userInput.split()
        studentId = int(studentInfo[0])
        score = float(studentInfo[1])
        if score >= 60:
            students.append((studentId, score))
    students.sort(key=lambda student: student[1], reverse=True) # reverse = True 降序排列
    print("\n考试及格的学生名单：")
    for student in students:
        print(f"学号: {student[0]}, 成绩: {student[1]:.2f}")

main()

上机实验

本实验题目解析不再赘述,仅给出答案
需要学习具体用法可以参考课本习题，大多数用法已经介绍过
实验课题目仅给出代码

实验1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 1
a = input("输入一个地名：")
b = input("输入一个人名：")
print(a+"很美,"+b+"想去看看")

# 2
month="JanFebMarAprMayJunJulAugSepOctNovDec"
index=int(input("请输入月份："))
print(  str(index)+"月的月份简写是" + month[index*3-3]+month[index*3-2]+month[index*3-1])

# 3
nums=[34,5,89,3,32,122]
print("一组数：%s"%nums)
sum=0
for i in nums:
   sum=sum+i
res=sum/len(nums)
print("{:.3f}".format(res))

# 4
inp=input("请输入三个字符用逗号分隔：")
lis=inp.split(",")
orilis=lis
if lis[0]>lis[1]:
    lis[1]=lis[2]
else:
    lis[0]=lis[2]
if lis[0]>lis[1]:
    res=lis[0]
else:
    res=lis[1]
print(orilis[0]+","+orilis[1]+","+orilis[2]+"中最大的字符是"+res)

# 5
import math
x1 = int(input("请输入x1的值: "))
x2 = int(input("请输入x2的值: "))
y1 = int(input("请输入y1的值: "))
y2 = int(input("请输入y2的值: "))
s = math.sqrt(pow(y2 - y1,2) + pow(x2 - x1,2)) # sqrt()开根 pow()取幂
print("%.2f"%s)

实验2-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import random # 随机数库

c = 5
while c > 0:
    c = c - 1 # 运行5次
    ch = chr(random.randint(97, 122)) # ASCII码的范围为a,z
    print(ch * 3, end=" ") # *3 重复三个 end=" " 间隔一个空格
print("")

c = 5
while c > 0:
    c = c - 1
    chc = random.randint(3, 5) # 长度为3-5 随机
    while chc > 0:
        chc = chc - 1
        print(chr(random.randint(97, 122)), end="") # 随机生成a-z的字母
    print(" ", end="")

实验2-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
inp=input("请输入一个三位整数：")
err=False
try:
    inp=int(inp)
    if inp>999 or inp<=100: # 范围卡在三位数
        err=True
except:
    err=True
if err:
    print("请输入一个正确的三位整数！")
else:
    if inp//100==inp%10: # 第一位和第三位
        print(inp,"是一个对称的三位数")
    else:
        print(inp,"不是一个对称的三位数")

实验2-3

三种方法

1
2
3
4
5
6
7
8
9
10
11
12
inp = input("请输入一个三位数：")
err = False
try:
    inp = int(inp)
    if inp > 999 or inp < 100:
        err = True
except:
    err = True
if err:
    print("警告：输入数据有误，请输入一个三位数！")
else:
    print(str(inp % 10) + str((inp % 100) // 10) + str(inp // 100)) # 取出三位数，然后倒序连接
1
2
3
4
5
6
7
8
9
10
11
12
13
inp = input("请输入一个三位数：")
err = False
try:
    inp = int(inp)
    if inp > 999 or inp < 100:
        err = True
except:
    err = True
if err:
    print("警告：输入数据有误，请输入一个三位数！")
else:
    inp = str(inp)
    print(inp[2] + inp[1] + inp[0]) # 根据索引顺序倒序连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
inp = input("请输入一个三位数：")
err = False
try:
    inp = int(inp)
    if inp > 999 or inp < 100:
        err = True
except:
    err = True
if err:
    print("警告：输入数据有误，请输入一个三位数！")
else:
    inp = str(inp)
    inp = list(inp)
    inp.reverse()
    print("".join(inp))

实验2-4

1
2
3
4
5
6
7
8
9
10
import random
import string
head = random.choice(string.ascii_uppercase)
tail =''.join(random.choices(string.ascii_letters + string.digits, k=7))
password = head + tail
print(password)
if any(char.isdigit() for char in password):
    print(password)
else:
    print("密码无效！")

实验3-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import math
def work(x):
    if x < 0:
        y = abs(x)
    elif 0 <= x < 5:
        y = math.cos(math.radians(x)) * math.exp(x) # 三个函数 余弦值 弧度值 e^x函数
    elif 5 <= x < 10:
        y = x ** 3
    else: 
        y = (7 + 8 * x) * math.log(x)
    
    return y
def main():
    x_input = input("请输入一个数x：")
    try:
        x = float(x_input) 
        y = work(x)

        if y.is_integer():
            print(f"y = {int(y)}") 
        else:
            print(f"y = {y:.2f}")  
    except ValueError:
        print("请输入有效的数字")
main()

实验3-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def One(a, b, c):
    if a >= b and a >= c: # a最大
        return a
    elif b >= a and b >= c: # b最大
        return b
    else: # a,b都不是最大，那么c最大
        return c
def Two(a, b, c):
    max_value = a # 假定a最大,此时最大值为max_value
    if b > max_value: # 如果b大于此时的最大值,更新最大值为b
        max_value = b
    if c > max_value: # 同理如果c大于更新后的最大值，继续更新
        max_value = c
    return max_value 
def max_of_two(x, y):
    return x if x > y else y # 三目运算符返回两个数的最大值

def Three(a, b, c):
    return max_of_two(max_of_two(a, b), c) # 返回a,b的最大值,然后返回max(a,b)和c的最大值

def main():
    a, b, c = map(int, input(" ").split())
    max_one = One(a, b, c)
    max_two = Two(a, b, c)
    max_three = Three(a, b, c)
    print(max_one, max_two, max_three)
main()

实验3-3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def number_to_words(num):
    number_words = {
        0: 'zero',
        1: 'one',
        2: 'two',
        3: 'three',
        4: 'four',
        5: 'five',
        6: 'six',
        7: 'seven',
        8: 'eight',
        9: 'nine'
    }
    return number_words.get(num, '') 
def main():
    user_input = input("请输入一串数字：") 
    result_words = []
    for char in user_input:
        if char.isdigit(): 
            num = int(char) - 1  
            if num < 0:
                num = 0
            result_words.append(number_to_words(num)) 
        else:
            print("请输入有效的整数")
            return
    print(' '.join(result_words))
main()

实验3-4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def is_hui(s):
    return s == s[::-1] # s[::-1]为翻转字符串 判断翻转前后是否一致
    # 一致返回True 否则返回False

def is_shui(num):
    num_str = str(num)
    n = len(num_str) 
    total = sum(int(digit) ** n for digit in num_str) 
    return total == num  

def main():
    hui_input = input("请输入一个字符串")
    if is_hui(hui_input):
        print(f"{hui_input} 是一个回文字符")
    else:
        print(f"{hui_input} 不是一个回文字符")

    shui_input = input("请再次输入一个整数")
    if shui_input.isdigit():  
        shui_num = int(shui_input)
        if is_shui(shui_num):
            print(f"{shui_num} 是水仙花数")
        else:
            print(f"{shui_num} 不是水仙花数")
    else:
        print("请输入有效的整数")

main()

实验3-5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def work(sum):
    if 100 <= sum < 300:
        percent = 0.98
    elif 300 <= sum < 500:
        percent = 0.90
    elif sum >= 500:
        percent = 0.88
    else:
        percent = 1.00 
    
    ans = sum * percent
    discount_amount = sum - ans
    
    return ans, discount_amount

def main():
    total_price_input = input("请输入商品总价：")
    
    try:
        sum = float(total_price_input)
        ans, discount_amount = work(sum)
        
        print(f"需要支付价格为{ans:.2f}元，优惠{discount_amount:.2f}元")
    except ValueError:
        print("请输入有效的数字")
main()

实验4-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def solve_one():
    ans = 0
    for i in range(1,1001):
        if i % 10 == 0 : continue
        else : ans+=i
    print(ans)

def solve_two():
    number_list = [i for i in range(1,1001) if i % 10 != 0]
    print(sum(number_list))

def flag(x):
    return x % 10 != 0
def solve_three():
    ans = sum(filter(flag,range(1,1001)))
    print(ans)

def solve_four():
    # filter(lambda x: condition, iterable)
    # condition: 条件表达式或者一个布尔值
    # lterable : 一个数据序列,x为从中取出的值
    ans = sum(filter(lambda i : i % 10 != 0,range(1,1001)))  
    print(ans)

solve_one()
solve_two()
solve_three()
solve_four()

实验4-2

本题题意有歧义，这里理解为多次输入

1
2
3
4
5
6
7
8
9
import random
number_one = random.randint(1,10)
number_two = random.randint(1,10)
if number_two > number_one: # 令number_one为较大的一个
    number_one,number_two = number_two,number_one
a = int(input(f"What is {number_one} - {number_two} ="))
while a != number_one - number_two:
    a = int(input(f"Wrong! What is {number_one} - {number_two} = "))
print("You Got It")

实验4-3

1
2
3
4
5
6
7
8
9
x = float(input("请输入x的值: "))
total = 0.0 
now = 1.0  
index = 0  
while abs(x / now) > 1e-5: #1e-5 为10^(-5)
    total += pow(x, index) / now #index为n的值,now为n!
    index += 1 # 更新index和now
    now *= index  
print(total)

实验4-4

辗转相除法

1
2
3
4
5
6
7
8
9
10
11
# gcd()在math库里有，可以引入后直接使用
# 这里介绍下原理：辗转相除法
def gcd(a,b):  
    while b:
        a,b = b,a % b
    return int(a)
def lcm(a,b): # 最小公倍数等于两数和除以最大公约数
    return int(a * b / gcd(a,b))
numbers = (input("请输入两个数:"))
number_one,number_two = map(int,numbers.split())
print(f"最大公因数为{gcd(number_one,number_two)};最小公倍数为{lcm(number_one,number_two)}")

实验4-5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def solve_one(x):
    arr = []
    for i in range(1,x + 1):
        temp = str(x) * i # 求出x个长度为i的字符串iiiii......
        arr.append(temp) # 加到队列中
    total = ' + '.join(arr) # 把队列中的这些字符串类型的数字用"+"连接 
    print(eval(total)) # eval 对加号"+"进行运算

def solve_two(x):
    arr = []
    for i in range(1,x + 1):
        temp = int(str(x) * i) # 同上求出数字串,但是转换为整数型
        arr.append(temp)
    print(sum(arr)) # 直接sum函数求和

def solve_three(x):
    total = sum(int(str(x) * i) for i in range(1,x + 1)) # 解法2的列表推导式
    print(total)

def solve_four(x):
    total = sum(map(lambda i : int(str(x) * i) ,range(1,x + 1)))
    print(total)

number = int(input("请输入a:"))
solve_one(number)
solve_two(number)
solve_three(number)
solve_four(number)

实验4-6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def GetPrimes(n): # 欧拉筛
    is_prime = [True] * (n + 1) # 把所有的元素都初始化为"是一个素数"
    primes = [] # 存储素数
    for i in range(2,n + 1):
        if is_prime[i] : primes.append(i) # 如果这个数不是素数,加到列表里面
        for j in range(i * 2, n + 1, i): # 枚举i的小于n的正整数倍数
            is_prime[j] = False # i的倍数都是合数,标记为非负数
    return primes # 返回素数列表

def main():
    n = int(input("请输入一个整数N:"))
    origin_n = n
    primes = GetPrimes(n) # 得到2-n范围内的素数列表
    AnswerArr = [] # 存储答案
    temp = 0 # 索引
    while n > 1:
        while(n % primes[temp] == 0 and n): # 如果n整除该素数 除以它
            n //= primes[temp]
            AnswerArr.append(primes[temp]) # 把该素数加到答案列表中
        temp+=1 # 如果n不能整除该素数了,索引+1,继续枚举后续素数
    if AnswerArr[0] == origin_n : # 如果答案的第一位和原数相等,说明本身就是素数
        print(f"1 * {origin_n}")
    else : # 如果是合数,用*连接它的质因子
        print(' * '.join(map(str,AnswerArr)))

main()

更新于：2024年11月11日

本科教学知识

评论