python-task-09 综合练习

西唯兵欧泡

于 2023-11-16 09:00:00 发布

阅读量299

点赞数 1

分类专栏： Python 文章标签：算法

本文链接：https://blog.csdn.net/2202_75442297/article/details/134325667

版权

Python 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.输出0.4 + 0.2的结果，和0.6是否相等，为什么？

不相等。因为在进行浮点数运算时，由于计算机内部的表示限制，可能会出现精度误差。虽然 0.6 和0.6000000000000001 在大多数情况下看起来是相等的，但它们实际上是略有不同的值。在进行浮点数比较时，应该使用一个小的容差值来检查两个浮点数是否相等，而不是直接比较它们是否完全相等。

#方法
import math
print(math.fabs(0.4+0.2-0.6)<1e-10)
print(math.isclose(0.4+0.2,0.6))

2.函数的使用：enumerate
（1）下面的输出结果是什么？
for item in enumerate('xyz'):
print(item)
a=[15,25,35,45]
for item in enumerate(a):
print(item)
（2）说说该函数的作用

for item in enumerate('xyz'):   
    print(item) 
a=[15,25,35,45]
for item in enumerate(a):   
    print(item) 

#输出
(0, 'x')
(1, 'y')
(2, 'z')
(0, 15)
(1, 25)
(2, 35)
(3, 45)

它用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

enumerate 函数接受两个参数：

可遍历的数据对象，如列表、元组或字符串等；开始的下标，默认为 0。返回的是一个枚举对象（enumerate object），它生成一个 (index, item) 元组序列，index 是从开始下标开始的整数，item 是数据对象中每个元素的迭代器对象。

3.递归函数练习。理解下面程序的含义并输出结果。
如果把下面的f = {1:10, 2:20}改为f = {1:1, 2:1}，输出是斐波那契数列吗？试一下。
def func(n):
f = {1:10, 2:20}
if n in f.keys():
return f[n]
else:
return func(n-1) + \
func(n-2)
print(func(1),func(2),func(3),func(4))

#f = {1:10, 2:20}
def func(n):
    f = {1:10, 2:20}
    if n in f.keys():
        return f[n]
    else:
        return func(n-1) + \
           func(n-2) 
print(func(1),func(2),func(3),func(4))

#f = {1:1, 2:1}
def func(n):
    f = {1:1, 2:1}
    if n in f.keys():
        return f[n]
    else:
        return func(n-1) + \
           func(n-2) 
print(func(1),func(2),func(3),func(4))

#输出
10 20 30 50
1 1 2 3

这段代码是一个递归函数，它使用了一个字典 f 来存储前两个数，然后通过递归调用来计算斐波那契数列中的其他数。

如果将 f = {1:10, 2:20} 改为 f = {1:1, 2:1}，那么函数将使用新的字典来计算斐波那契数列。在这种情况下，函数将返回第一项和第二项的值，它们都是 1。因此，输出将是斐波那契数列的前四个数：1、1、2、3。

4.给定一个二维列表，输出每行元素之和，每列元素之和，主对角线元素之和。

def calculate_sums(matrix):  
    # 每行元素之和  
    row_sums = [sum(row) for row in matrix]  
      
    # 每列元素之和  
    col_sums = [sum(matrix[i][j] for i in range(len(matrix))) for j in range(len(matrix[0]))]  
      
    # 主对角线元素之和  
    diagonal_sum = sum(matrix[i][i] for i in range(len(matrix)))  
      
    return row_sums, col_sums, diagonal_sum  
  
matrix = [  
    [1, 2, 3],  
    [4, 5, 6],  
    [7, 8, 9]  ]  
  
row_sums, col_sums, diagonal_sum = calculate_sums(matrix)  
print("每行元素之和：", row_sums)  
print("每列元素之和：", col_sums)  
print("主对角线元素之和：", diagonal_sum)

5.给定两个整数，求最大公约数和最小公倍数。

def gcd(a, b):  
    while b != 0:  
        a, b = b, a % b  # a的值会被更新为b的值，b的值会被更新为a除以b的余数。这个操作会持续进行，直到b变为0。
   
 return a  
  
def lcm(a, b):  
    return a * b // gcd(a, b)    # 将两个对象除取整
  
# 测试代码  
print(gcd(24, 36))  # 12  
print(lcm(24, 36))  # 72

6.编写函数func(x, n)，接收一个所有元素值都不相等的整数列表x和一个整数n，要求将值为n的元素作为支点，将列表x中所有值小于n的元素全部放到n的前面，将列表x中所有值大于n的元素放到n的后面。
(1)尝试使用原生Python代码实现,直接改变原列表(参考示例代码）
(2)尝试使用原生Python代码实现,返回新的列表
(2)使用numpy数组实现
(3)比较三种方法的区别，写出心得体会。

def demo(x, n):
    i = x.index(n)               #获取指定元素在列表中的索引
    x[0], x[i] = x[i], x[0]      #将指定元素与第0个元素交换
    key = x[0]
    i = 0
    j = len(x) - 1
    while i<j:
        while i<j and x[j]>=key: #从后向前寻找第一个比指定元素小的元素
            j -= 1
        x[i] = x[j] 
        while i<j and x[i]<=key: #从前向后寻找第一个比指定元素大的元素
            i += 1
        x[j] = x[i]
    x[i] = key
a=[1,2,10,9,8,7,6,11,15]
print(demo(a,8))
print(a)

# (1) 使用原生Python代码实现，直接改变原列表：
def func(x, n):  
    i = x.index(n)  
    x[:i] = sorted(x[:i], reverse=True)  
    x[i+1:] = sorted(x[i+1:], reverse=False)  
    return x
# 该方法的基本思路是：找到值为n的元素在列表中的位置，然后分别对列表中n之前的元素和n之后的元素进行排序。这种方法会直接修改原列表。

# (2) 使用原生Python代码实现，返回新的列表：
def func(x, n):  
    left = [i for i in x if i < n]  
    right = [i for i in x if i > n]  
    return sorted(left, reverse=True) + [n] + sorted(right)
# 这种方法的思路是：分别找出列表中n之前的元素和n之后的元素，然后将它们分别排序，最后将它们与n拼接起来。这种方法不会修改原列表。

# (3) 使用numpy数组实现：
import numpy as np   
def func(x, n):  
    arr = np.array(x)  
    indices = np.argsort(arr)  
    pivot_index = np.where(arr[indices] == n)[0][0]  
    pivot_left = indices[:pivot_index]  
    pivot_right = indices[pivot_index+1:]  
    return np.array([arr[i] for i in pivot_left[::-1]] + [n] + [arr[i] for i in pivot_right])
#该方法使用了numpy的argsort函数对整个列表进行排序，然后找到值为n的元素的索引，最后根据这个索引将列表分成三部分：n之前的元素、n本身、n之后的元素。这种方法可以在处理大型数据集时提供更高的效率。

#三种方法的区别在于：(1)方法直接修改原列表，操作简单但可能会影响其他部分的代码；(2)方法不修改原列表，但需要创建两个新的列表，可能会消耗更多的内存；(3)方法使用numpy数组操作，可以在处理大型数据集时提供更高的效率，但对于小型数据集，由于numpy的初始化成本，可能不如前两种方法快。因此，在实际使用中，需要根据具体的需求和限制来选择合适的方法。

7.计算前n个自然数的阶乘之和1!+2!+3!+...+n!

def factorial_sum(n):  
    factorial = 1  
    sum = 0  
    for i in range(1, n+1):  
        factorial *= i  
        sum += factorial  
    return sum  
  
print("请输入自然数n：")
n = int(input()) 
result = factorial_sum(n)  
print(f"1!+...+{n}! = {result}")

8.设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法与浮点除法和向下取整除法运算。

class Vector3D:  
    def __init__(self, x=0, y=0, z=0):  
        self.x = x  
        self.y = y  
        self.z = z  
  
    def __add__(self, other):  
        return Vector3D(self.x + other.x, self.y + other.y, self.z + other.z)  
  
    def __sub__(self, other):  
        return Vector3D(self.x - other.x, self.y - other.y, self.z - other.z)  
  
    def __mul__(self, scalar):  
        return Vector3D(self.x * scalar, self.y * scalar, self.z * scalar)  
  
    def __truediv__(self, scalar):  
        return Vector3D(self.x / scalar, self.y / scalar, self.z / scalar)  
  
    def __floordiv__(self, scalar):  
        return Vector3D(self.x // scalar, self.y // scalar, self.z // scalar)  
  
    def magnitude(self):  
        return (self.x ** 2 + self.y ** 2 + self.z ** 2) ** 0.5  
  
    def __str__(self):  
        return f"Vector3D({self.x}, {self.y}, {self.z})"

西唯兵欧泡

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
python-task-09 综合练习

重庆理工大学（CQUT）返回的是一个枚举对象（enumerate object）它生成一个 (index, item) 元组序列，index 是从开始下标开始的整数，item 是数据对象中每个元素的迭代器对象。如果将 f = {1:10, 2:20} 改为 f = {1:1, 2:1}，那么函数将使用新的字典来计算斐波那契数列。在这种情况下，函数将返回第一项和第二项的值，它们都是 1。它用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
复制链接

扫一扫