构建一个类 book，其中含有两个私有数据成员 qu 和 price，将 qu 初始化为 1~5，将 price 初始化为 qu 的 10 倍，建立一个有 5 个元素的数组对象。显示每 个对象数组元素的 qu*price 值。

class Book:
    def __init__(self):
        self.__qu = 0
        self.__price = 0

    def set_qu(self, qu):
        self.__qu = qu

    def set_price(self, price):
        self.__price = price

    def get_qu(self):
        return self.__qu

    def get_price(self):
        return self.__price


books = [Book() for i in range(5)]

for i in range(5):
    books[i].set_qu(i+1)
    books[i].set_price((i+1)*10)

for book in books:
    print(book.get_qu() * book.get_price())

输出结果：

10
40
90
160
250

相关问题

构建一个类 book，其中含有两个私有数据成员qu和 price，将qu初始化为1～5将price初始化为qu的10倍，建立一个有5个元素的数组对象。显示每个对象数组元素的qu*price

### 回答1：
。以下是一个可能的实现：

class Book:
    def __init__(self, qu):
        self.qu = qu
        self.price = qu * 10

books = [Book(qu) for qu in range(1, 6)]

for book in books:
    print(book.qu * book.price)

首先定义了一个 Book 类，其中有两个私有数据成员 qu 和 price，并在构造函数中对它们进行初始化。然后创建了一个有 5 个元素的数组对象 books，其中每个元素都是一个 Book 对象，qu 分别为 1 到 5。最后遍历数组并输出每个对象的 qu * price。

### 回答2：
构建一个类名为Book的类。在该类中有两个私有数据成员qu和price。其中，qu表示数量，price表示价格。在构造函数中，将qu初始化为1~5之间的随机数，并将price初始化为qu的10倍。接着，建立一个有5个元素的数组对象，每个元素都是Book类的对象。

具体的代码实现如下：

import random

class Book:
    def __init__(self):
        self.qu = random.randint(1, 5)
        self.price = self.qu * 10

book_array = [Book() for _ in range(5)]

for book in book_array:
    print(book.qu * book.price)

上述代码首先引入了random模块，用于生成1~5之间的随机整数。然后定义了一个Book类，其中的构造函数初始化了qu和price。接着，使用列表推导式创建了一个长度为5的book_array数组，每个元素都是Book类的对象。最后，通过遍历book_array数组，输出每个对象数组元素的qu乘以price的结果。

需要注意的是，这只是一个简单的示例代码。实际情况中可能需要根据具体需求进行修改和扩展。

### 回答3：
构建一个类 `Book`，其中包含两个私有数据成员 `qu` 和 `price`，将 `qu` 初始化为1～5，将 `price` 初始化为 `qu` 的10倍，然后建立一个有5个元素的数组对象。下面是具体的代码实现：

class Book:
    def __init__(self, qu):
        self.qu = qu
        self.price = qu * 10

books = []
for i in range(1, 6):
    books.append(Book(i))

for book in books:
    print("qu * price:", book.qu * book.price)

以上代码中，首先定义了一个名为 `Book` 的类，其中有一个初始化方法 `__init__`，用于初始化类的对象。初始化方法中接受一个参数 `qu`，并将其赋值给类的属性 `qu`，并将 `qu` 的10倍赋值给属性 `price`。接下来，通过循环创建了5个元素的数组对象 `books`，分别初始化了 `qu` 为1～5的 `Book` 对象。

最后，通过循环遍历 `books` 数组中的每个元素，计算并显示其 `qu` 乘以 `price` 的结果。

构建一个类book，其中含有两个私有数据成员qu和price，将qu初始化为1~5，将price初始化为qu的10倍，建立一个有5个元素的数组对象。显示每个对象数组元素的qu*price值。

下面是一个简单的实现：

#include <iostream>

using namespace std;

class Book {
private:
    int qu;   // 数量
    double price;   // 价格
public:
    Book(int q) {   // 构造函数，初始化 qu 和 price
        qu = q;
        price = q * 10.0;
    }
    double getQuPrice() {   // 计算 qu*price 的值
        return qu * price;
    }
};

int main() {
    const int SIZE = 5;   // 数组大小
    Book books[SIZE] = {1, 2, 3, 4, 5};   // 初始化对象数组
    for (int i = 0; i < SIZE; i++) {
        cout << "第 " << i+1 << " 本书的 qu*price 值为：" << books[i].getQuPrice() << endl;
    }
    return 0;
}

输出结果为：

第 1 本书的 qu*price 值为：10
第 2 本书的 qu*price 值为：40
第 3 本书的 qu*price 值为：90
第 4 本书的 qu*price 值为：160
第 5 本书的 qu*price 值为：250