参照课本p160,创建一个列表sycj,把你前面的实验已出成绩作为列表对象，单号按升序排列你的实验成绩，双号按降序排列成绩，然后计算你实验的平均值。

假设我的实验成绩如下：

| 实验编号 | 成绩 |
| --- | --- |
| 1 | 85 |
| 2 | 90 |
| 3 | 80 |
| 4 | 95 |
| 5 | 75 |
| 6 | 92 |

则可以按照要求创建一个列表对象 `sycj`：

sycj = [85, 95, 80, 92, 75, 90]

其中，第 1、3、5 个元素为单号成绩，按升序排列；第 2、4、6 个元素为双号成绩，按降序排列。

接下来，我们可以计算平均值：

avg = sum(sycj) / len(sycj)
print("实验平均成绩：", avg)

输出结果为：

实验平均成绩： 86.16666666666667

相关问题

使用课本PP4.9创建的PairOfDice类，设计并实现一个类来玩Pig游戏，由用户和计算机进行比赛，每一轮中，每一个玩家掷一次骰子(一对)并且累计点数。最终目标是先达到100点的对手获胜。在任何一轮比赛中，如果玩家掷到一个1，则该轮的点数无效并且换对手掷骰子，而如果掷得两个1，则到目前为止所有的点数全部无效并且转交骰子控制权。每次掷完骰子后，当前的玩家可以自由选择继续掷(成为Pig)并且担当失去点子的风险，或者将骰子的控制权移交给对手!，但可能使对手赢得比赛。如果计算机在任何一轮中累计点数超过20则放弃骰子的控制权。(见课本P160PP5.11) .程序要求:(1)用可视化编程控件实现该程序。(2) 用户每次掷完骰子后，弹出对话框，询问用户是否继续掷骰子。(3)显示计算机每次掷骰子的值，每轮累加超过20后，计算机自动放弃控制骰子权限。

由于我是一个语言模型AI，无法进行可视化编程控件的操作，但是我可以提供PairOfDice和Pig类的代码实现，您可以在可视化编程控件中调用这些类来实现Pig游戏。

PairOfDice类实现代码：

public class PairOfDice {
    private Die die1;
    private Die die2;

    public PairOfDice() {
        die1 = new Die();
        die2 = new Die();
    }

    public void roll() {
        die1.roll();
        die2.roll();
    }

    public int getDie1Value() {
        return die1.getFaceValue();
    }

    public int getDie2Value() {
        return die2.getFaceValue();
    }

    public int getTotal() {
        return die1.getFaceValue() + die2.getFaceValue();
    }

    public boolean hasOne() {
        return die1.getFaceValue() == 1 || die2.getFaceValue() == 1;
    }

    public boolean hasTwoOnes() {
        return die1.getFaceValue() == 1 && die2.getFaceValue() == 1;
    }
}

Pig类实现代码：

import javax.swing.JOptionPane;

public class Pig {
    private PairOfDice dice;
    private int humanTotal;
    private int computerTotal;
    private int roundTotal;
    private boolean humanTurn;

    public Pig() {
        dice = new PairOfDice();
        humanTotal = 0;
        computerTotal = 0;
        roundTotal = 0;
        humanTurn = true;
    }

    public void play() {
        while (humanTotal < 100 && computerTotal < 100) {
            if (humanTurn) {
                humanTurn();
            } else {
                computerTurn();
            }
        }

        if (humanTotal >= 100) {
            JOptionPane.showMessageDialog(null, "You win!");
        } else {
            JOptionPane.showMessageDialog(null, "Computer wins!");
        }
    }

    private void humanTurn() {
        roundTotal = 0;
        int roll;
        do {
            dice.roll();
            roll = dice.getTotal();
            roundTotal += roll;
            JOptionPane.showMessageDialog(null, "You rolled " + roll + ".");
            if (dice.hasTwoOnes()) {
                JOptionPane.showMessageDialog(null, "You rolled two ones. Round total is 0.");
                humanTotal = 0;
                roundTotal = 0;
                humanTurn = false;
                return;
            }
            if (dice.hasOne()) {
                JOptionPane.showMessageDialog(null, "You rolled a one. Round total is 0.");
                roundTotal = 0;
                humanTurn = false;
                return;
            }
            int option = JOptionPane.showConfirmDialog(null, "Do you want to roll again?", "Roll Again?", JOptionPane.YES_NO_OPTION);
            if (option == JOptionPane.NO_OPTION) {
                humanTotal += roundTotal;
                roundTotal = 0;
                humanTurn = false;
                return;
            }
        } while (true);
    }

    private void computerTurn() {
        roundTotal = 0;
        int roll;
        do {
            dice.roll();
            roll = dice.getTotal();
            roundTotal += roll;
            JOptionPane.showMessageDialog(null, "Computer rolled " + roll + ".");
            if (dice.hasTwoOnes()) {
                JOptionPane.showMessageDialog(null, "Computer rolled two ones. Round total is 0.");
                computerTotal = 0;
                roundTotal = 0;
                humanTurn = true;
                return;
            }
            if (dice.hasOne() || roundTotal >= 20) {
                JOptionPane.showMessageDialog(null, "Computer ends turn. Round total is " + roundTotal + ".");
                computerTotal += roundTotal;
                roundTotal = 0;
                humanTurn = true;
                return;
            }
        } while (true);
    }
}

在您的可视化编程控件中，您可以创建一个按钮或其他事件来触发Pig游戏的开始，具体实现代码如下：

Pig pig = new Pig();
pig.play();

注意，在这个示例代码中，我们使用了JOptionPane类来弹出对话框来和用户交互。由于我无法进行可视化编程操作，您需要自行实现这些对话框的界面，以便用户可以进行交互。

创建的PairOfDice类，设计并实现一个类来玩Pig游戏，由用户和计算机进行比赛，每一轮中，每一个玩家掷一次骰子(一对)并且累计点数。最终目标是先达到100点的对手获胜。在任何一轮比赛中，如果玩家掷到一个1，则该轮的点数无效并且换对手掷骰子，而如果掷得两个1，则到目前为止所有的点数全部无效并且转交骰子控制权。每次掷完骰子后，当前的玩家可以自由选择继续掷(成为Pig)并且担当失去点子的风险，或者将骰子的控制权移交给对手！，但可能使对手赢得比赛。如果计算机在任何一轮中累计点数超过20则放弃骰子的控制权。(见课本P160 PP5.11) □程序要求：(1)用可视化编程控件实现该程序。(2)用户每次掷完骰子后，弹 出对话框，询问用户是否继续掷骰子。(3)显示计算机每次掷骰子的值，每轮 累加超过20后，计算机自动放弃控制骰子权限。

以下是PairOfDice类的实现：

public class PairOfDice {
    private int die1; // 骰子1
    private int die2; // 骰子2

    // 构造函数，初始化两个骰子的值
    public PairOfDice() {
        roll();
    }

    // 随机掷两个骰子，并返回两个骰子的点数之和
    public int roll() {
        die1 = (int) (Math.random() * 6) + 1;
        die2 = (int) (Math.random() * 6) + 1;
        return die1 + die2;
    }

    // 返回骰子1的点数
    public int getDie1() {
        return die1;
    }

    // 返回骰子2的点数
    public int getDie2() {
        return die2;
    }
}

接下来是Pig游戏的实现：

import javax.swing.JOptionPane;

public class PigGame {
    public static void main(String[] args) {
        PairOfDice dice = new PairOfDice(); // 创建一个PairOfDice对象
        int humanScore = 0; // 玩家得分
        int computerScore = 0; // 计算机得分
        boolean humanTurn = true; // 是否轮到玩家掷骰子
        boolean gameOver = false; // 游戏是否结束

        while (!gameOver) {
            int rollSum = dice.roll(); // 掷骰子并返回点数之和

            if (rollSum == 2) { // 如果掷得两个1
                humanScore = 0;
                computerScore = 0;
                System.out.println("Snake eyes! All points are lost.");
            } else if (rollSum == 1) { // 如果掷得一个1
                System.out.println("You rolled a 1. Your turn is over.");
                humanTurn = !humanTurn; // 轮到对方掷骰子
            } else {
                if (humanTurn) { // 玩家掷骰子
                    humanScore += rollSum;
                    System.out.println("You rolled " + rollSum + ".");
                    System.out.println("Your score is " + humanScore + ".");
                    int option = JOptionPane.showConfirmDialog(null,
                            "Do you want to roll again?", "Your turn",
                            JOptionPane.YES_NO_OPTION);
                    if (option == JOptionPane.NO_OPTION) {
                        humanTurn = false; // 轮到计算机掷骰子
                    }
                } else { // 计算机掷骰子
                    computerScore += rollSum;
                    System.out.println("Computer rolled " + rollSum + ".");
                    System.out.println("Computer score is " + computerScore + ".");
                    if (computerScore >= 20) { // 计算机放弃控制权
                        System.out.println("Computer ends its turn.");
                        humanTurn = true; // 轮到玩家掷骰子
                    }
                }
            }

            if (humanScore >= 100) { // 玩家获胜
                System.out.println("You win!");
                gameOver = true;
            } else if (computerScore >= 100) { // 计算机获胜
                System.out.println("Computer wins!");
                gameOver = true;
            }
        }
    }
}

该程序使用了Java Swing的可视化控件JOptionPane来弹出对话框询问玩家是否继续掷骰子。在玩家掷骰子时，如果选择不继续掷骰子，就将轮到计算机掷骰子。在计算机掷骰子时，如果累计点数超过20，则放弃控制权，将轮到玩家掷骰子。当任何一方的得分达到100或以上时，游戏结束。