第二章Python语言基础

1. 编写程序，输人3个整数x，y，z，并把这3个数由小到大输出。

# 输入3个整数
x = int(input("请输入第一个整数: "))
y = int(input("请输入第二个整数: "))
z = int(input("请输入第三个整数: "))

# 创建一个包含这3个整数的列表
a = [x, y, z]

# 使用sorted函数对列表进行排序
sorted_a = sorted(a)

# 输出排序后的结果
print("从小到大排序后的结果为:", sorted_a)

 

2.编程实现奇偶归一猜想:对于一个正整数n，如果它是奇数，则对它乘以3再加1;如果它是偶数，则对它除以2。如此循环，最终都能够得到1。例如，n=6，则序列为6 3 10 5 16 8 4 2 1。

def a(n):                                #自定义的函数，它接受一个正整数 `n` 作为参数，然后生成奇偶归一猜想的序列，并返回一个包含该序列的列表。
    c = [n]                              #在函数内部，我们创建一个名为 `c` 的列表，用来存储奇偶归一猜想的序列，初始时将 `n` 添加到列表中。
    
    while n != 1:                        #使用一个 `while` 循环，当 `n` 不等于1时，继续进行奇偶归一猜想。
        if n % 2 == 0:                   #检查 `n` 是否为偶数，通过取余运算 (`n % 2`) 来判断。如果是偶数，执行下面的语句。
            n = n // 2                   #如果 `n` 是偶数，将 `n` 除以2，即整数除法，以继续下一个循环。
        else:                            #如果 `n` 是奇数时，执行下面的语句。
            n = 3 * n + 1                #如果 `n` 是奇数，将 `n` 乘以3再加1，以继续下一个循环。
        c.append(n)                      #在每次循环结束时，将当前的 `n` 添加到 `c` 列表中，记录当前的值
    
    return c                             #当 `n` 最终等于1时，循环结束，函数返回包含奇偶归一猜想序列的 `c` 列表。

# 输入一个正整数
n = int(input("请输入一个正整数: "))

if n <= 0:
    print("请输入一个正整数。")            #如果输入的数小于等于0，则输出提示信息，要求用户输入一个正整数。避免报错！
else:
    b = a(n)                             #调用 `a` 函数生成奇偶归一猜想的序列，并将结果打印出来。
    print("奇偶归一猜想序列为:", b)

 

3.编写程序，输人一个考试分数，并按照“优秀”[90~100]、“良好”[80~90)、“中等”[70~80)、“及格”[60~70) 和“不及格” [0~60) 判定等级后输出。

# 输入考试分数
a = float(input("请输入考试分数: "))

# 判定等级
if a >= 90 and a <= 100:
    grade = "优秀"
elif a >= 80 and a < 90:
    grade = "良好"
elif a >= 70 and a < 80:
    grade = "中等"
elif a >= 60 and a < 70:
    grade = "及格"
elif a >= 0 and a < 60:
    grade = "不及格"
else:
    grade = "无效输入"

# 输出等级
if grade != "无效输入":
    print(f"{grade}")
else:
    print("输入的分数无效，请输入0到100之间的分数。")

 

4.编写程序，使一个整数的各位数字逆序排列后输出。例如，给定整数123456，经处理后得到整数654321(注意数据类型应为整数)。

# 输入一个整数
a = int(input("请输入一个整数: "))

# 将整数转换为字符串以便反转各位数字
a_str = str(a)

# 反转字符串
reversed_str = a_str[::-1]

# 将反转后的字符串转换回整数
reversed_a = int(reversed_str)

# 输出反转后的整数
print("逆序排列后的整数是:", reversed_a)

 

5.圆周率可以用公式 π=4x（1-1/3+1/5-1/7+1/9-...+...) 近似计算。编写程序,利用该公式计算圆周率，输出不同求和项数的值及计算结果，展示其精确性。

def a(n):                                        #定义一个名为 a 的函数，它接受一个参数 n，表示要计算的项数。
    b = 0                                        #创建一个变量 b，用于存储圆周率的近似值，并将其初始化为0。
    sign = 1                                     #创建一个变量 sign，用于追踪每一项的正负号。开始时，它被初始化为1，表示正数。

    for i in range(1, n * 2, 2):                 #使用 for 循环迭代计算每一项的值。i从1开始，每次增加2，以便生成1, 3, 5, 7等奇数项
        b += sign * (4 / i)                      #根据公式计算每一项的值，然后将其加到 b上。这里 sign 控制正负号，而 (4 / i) 表示当前项的值
        sign *= -1                               #在每次迭代结束时，切换正负号，以便在奇数项和偶数项之间交替。

    return b                                     #返回计算出的近似圆周率值。

# 输入要计算的项数
n = int(input("输入要计算的项数: "))

if n <= 0:
    print("项数必须为正整数。")
else:
    b = a(n)
    print(f"{n} 项的近似圆周率值为: {b}")

 

6.酒厂有瓶盖换啤酒活动。3个瓶盖可以换一瓶啤酒。编写程序，计算如果一开始买了n瓶啤酒，那么这么一直换下去，最终能喝到几瓶啤酒？例如，初始瓶数n为100，则程序应该输出149;初始瓶数n为101，程序应该输出151。

def a(n):
    total = n
    while n >= 3:
        b = n // 3
        total += b
        n = b + (n % 3)
    return total

n = int(input("请输入初始瓶数："))
result = a(n)
print("最终能喝到的啤酒瓶数为:", result)

 

7.编写程序，输出三角形的“九九乘法表”。¶

def a(n):
    for i in range(1, n + 1):
        for j in range(1, i + 1):
            product = i * j
            print(f"{j} x {i} = {product}\t", end="")
        print()

n = 9  # 你可以根据需要更改n来控制输出的行数
a(n)

 

8.编写程序，输人多个正整数，以-1表示结束，输出这些正整数之和。例如：输人第1个数:1 ； 输人第2个数:2 ； 输入第3个数:3 ； 输入第4个数:-1 ； 正整数之和为:6

total = 0

while True:
    number = int(input("请输入一个正整数（输入-1结束）: "))
    if number == -1:
        break
    if number > 0:
        total += number

print("正整数之和为:", total)

 

9.自幂数是指一个n位数(n>=3)，它的每个位上的数字的n次幂之和等于它本身 (例如1**3+5**3+3**3=153)。编写程序，求出所有3位、4位和5位数的自幂数。

# 定义一个函数，判断一个数是否是自幂数
def is_narcissistic(num):
  # 将数字转换为字符串
  s = str(num)
  # 获取数字的位数
  n = len(s)
  # 初始化数字的各位数字的n次幂之和
  sum = 0
  # 遍历字符串中的每个字符
  for c in s:
    # 将字符转换为数字
    d = int(c)
    # 计算数字的n次幂，并累加到sum中
    sum += d ** n
  # 判断sum是否等于num，如果是，返回True，否则返回False
  return sum == num

# 定义一个函数，输出所有m位数的自幂数
def print_narcissistic(m):
  # 计算m位数的最小值和最大值
  min = 10 ** (m - 1)
  max = 10 ** m - 1
  # 遍历m位数的所有可能值
  for i in range(min, max + 1):
    # 判断i是否是自幂数，如果是，打印i
    if is_narcissistic(i):
      print(i)

# 输出所有3位、4位和5位数的自幂数
print("3位数的自幂数有：")
print_narcissistic(3)
print("4位数的自幂数有：")
print_narcissistic(4)
print("5位数的自幂数有：")
print_narcissistic(5)

 

10.编写程序，产生MyPyLib扩展库，在其中实现可以计算给定数值的平方数的函数: MyPyLib.sqr(val)。编写程序，对该扩展库的sqr()函数功能进行测试。

要创建一个名为MyPyLib的Python扩展库，并在其中实现一个计算给定数值的平方数的函数sqr(val)，你需要遵循以下步骤：

1. 创建一个名为MyPyLib的文件夹，用于存储你的扩展库。

2. 在MyPyLib文件夹中，创建一个名为`__init__.py`的空文件，以便Python将该文件夹识别为一个包。

3. 在MyPyLib文件夹中创建一个名为`mylib.py`的Python模块，并在其中实现sqr函数。你的`mylib.py`文件可以如下所示：

def sqr(val):
    return val ** 2

4. 确保`mylib.py`文件位于MyPyLib文件夹中。

5. 现在，你可以在另一个Python脚本中测试你的MyPyLib扩展库。创建一个名为`test_mypylib.py`的脚本，并在其中导入并使用MyPyLib中的sqr函数。示例测试脚本如下：

from MyPyLib import mylib

value = 5
result = mylib.sqr(value)
print(f"The square of {value} is {result}")

6. 保存`test_mypylib.py`脚本，并确保它与MyPyLib文件夹位于同一目录中。

7. 确保你已经将Python包含在你的环境中。

8. 运行`test_mypylib.py`脚本，它将导入MyPyLib扩展库并测试sqr函数。

这样，你就创建了一个名为MyPyLib的扩展库，并测试了其中的sqr函数。在实际应用中，你可以将MyPyLib文件夹部署到Python的`site-packages`目录中，以便在其他项目中使用它。

 

11.形如 1/1 +1/2 +1/3 +1/4 +...称为调和级数。该级数是缓慢发散的，例如其前 83 项之和才仅超过5.0。编写程序，计算级数中要加多少项，才能使得级数达到或超过15.0

a = 15.0
b = 0.0
n = 0

while b < a:
    n += 1
    b += 1 / n

print("需要加入前", n, "项才能使级数达到或超过", a)

 

12.编写程序，在给定的一个句子s中，查找其中给定字符串c，并输出以c开始，长度为1的各字符串。
例如:对于句子“If your life feels like it is lacking the power that you want and the motivation that you need, sometimes all you have to do is shift your point of view. ”
当查找的特定字符串为"yo"，长度为7时，则输出结果如下：
第1处,位置 3:your li ；
第2处位置53;you wan ；
第3处,位置86;you nee ；
第4处位置110:you hav ；
第5处位置134:your po

s = "If your life feels like it is lacking the power that you want and the motivation that you need, sometimes all you have to do is shift your point of view."
c = "yo"

start = 0
index = 0

while True:
    index = s.find(c, start)
    if index == -1:
        break
    a = s[index - 1:index + 7]  # 获取以c开始，长度为7的子字符串
    print(f"第{start + 1}处,位置 {index} : {a}")
    start = index + 1