Tag: 编程

📚 Core Programming Constructs and Algorithms for Edexcel A-Level | Edexcel A-Level 核心编程构造与算法

This article covers the essential programming constructs, data structures and algorithms required for the Edexcel A-Level Computer Science specification. You will learn how to trace code, apply pseudocode ideas and translate them into Python, with clear examples and exam-focused explanations.

本文介绍 Edexcel A-Level 计算机科学考试中必备的核心编程构造、数据结构和算法。你将学会如何跟踪代码、运用伪代码思想并将其转换为 Python，配合清晰的示例和紧扣考点的解释。

1. Data Types and Variables | 数据类型与变量

In Edexcel A-Level programming questions, you must distinguish between primitive data types and compound data types. The common primitive types are integer, real/float, Boolean and character. A variable is a named memory location whose value can change during execution; a constant is fixed at compile time. Strong typing requires every variable to be declared with a type, while Python uses dynamic typing but you still need to reason about types when tracing code.

在 Edexcel A-Level 编程题中，你必须区分基本数据类型和复合数据类型。常见的基本类型有整型、实型/浮点型、布尔型和字符型。变量是命名的内存位置，其值在执行期间可以改变；常量在编译时固定。强类型要求声明变量的类型，而 Python 使用动态类型，但你在跟踪代码时仍需推断类型。

When tracing code, watch for implicit type conversion: in Python, 3/2 gives 1.5, while 3//2 gives 1. Integer division in pseudocode DIV also gives the whole-number quotient. Variables should have meaningful names and follow the language’s naming rules, such as no spaces and not starting with a digit.

跟踪代码时，注意隐式类型转换：在 Python 中 3/2 得到 1.5，而 3//2 得到 1。伪代码中的整数除法 DIV 也给出整数商。变量应使用有意义的名称，并遵循语言命名规则，例如不能包含空格，不能以数字开头。

2. Operators and Expressions | 运算符与表达式

Operators build expressions. Arithmetic operators +,

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Edexcel A-Level Programming: Core Techniques from Data Types to Recursion | Edexcel A-Level 编程核心技法：从数据类型到递归

This revision article covers the essential programming skills tested in Edexcel A-Level Computing. You will review data types, control structures, subroutines, parameter passing, arrays, strings, file handling, recursion, exception handling, and algorithm efficiency. Each section pairs a clear English explanation with a Chinese translation to support bilingual learners. The focus is on exam-style understanding, trace tables, and correct pseudocode conventions.

本篇复习文章涵盖 Edexcel A-Level 计算机编程的核心技能。你将回顾数据类型、控制结构、子程序、参数传递、数组、字符串、文件处理、递归、异常处理以及算法效率。每个小节都提供清晰的英文解释并配以中文翻译，方便双语学习者。重点在于考试风格的理解、跟踪表以及正确的伪代码规范。

1. Data Types and Type Casting | 数据类型与类型转换

In Edexcel A-Level programming, you must be confident with primitive data types: integer, real or float, boolean, character, and string. Each type has a specific memory footprint and allowed range. Choosing the wrong type can cause overflow when values exceed the maximum limit or loss of precision when real numbers are stored incorrectly.

在 Edexcel A-Level 编程中，你必须熟练掌握基本数据类型：整数、实数或浮点数、布尔值、字符和字符串。每种类型都有特定的内存占用量和允许范围。如果选错类型，当数值超过最大限制时会发生溢出，或者实数被错误存储时会造成精度丢失。

Type casting converts data from one type to another, such as int(“42”) or str(3.14). However, casting is only safe when the original data can be interpreted in the target type. For example, int(“3.14”) causes a runtime error because the string “3.14” is not a valid integer literal. Exam questions often test whether you validate input before casting.

类型转换将数据从一种类型转换为另一种类型，例如 int(“42”) 或 str(3.14)。然而，只有当原始数据能够被解释为目标类型时，类型转换才是安全的。例如，int(“3.14”) 会导致运行时错误，因为字符串 “3.14” 不是有效的整数字面量。考题经常考查你是否在类型转换之前验证了输入。

A common pitfall is mixing integer and float in division. In many languages, 5 / 2 returns 2.5 if real division is used, while 5 DIV 2 returns 2 for integer division. Be clear about which operator your pseudocode is using.

一个常见的误区是在除法中混用整数和浮点数。在许多语言中，如果使用实数除法，5 / 2 返回 2.5；而 5 DIV 2 返回整数除法的结果 2。要清楚你的伪代码使用的是哪种运算符。

2. Operators and Expressions | 运算符与表达式

Arithmetic operators include addition, subtraction, multiplication, division, integer DIV, and modulus MOD. DIV gives the quotient without the remainder, while MOD gives the remainder only. For example, 17 DIV 5 = 3 and 17 MOD 5 = 2. These are extremely useful for problems involving cycles, divisibility, or grouping.

算术运算符包括加、减、乘、除、整数 DIV 和取模 MOD。DIV 给出商但不含余数，MOD 只给出余数。例如，17 DIV 5 = 3，17 MOD 5 = 2。它们在处理循环、整除或分组问题时非常有用。

Comparison operators such as <, >, <=, >=, ==, and != produce Boolean results. Logical operators AND, OR, and NOT combine or invert Boolean expressions. Operator precedence is critical: NOT is evaluated before AND, and AND before OR. Parentheses should be used to make the order of evaluation explicit and to avoid logic errors.

比较运算符如 <、>、<=、>=、== 和 != 产生布尔结果。逻辑运算符 AND、OR 和 NOT 用于组合或取反布尔表达式。运算符优先级非常重要：NOT 先于 AND 求值，AND 先于 OR。应使用圆括号明确求值顺序，避免逻辑错误。

In Edexcel pseudocode, assignments often use the arrow symbol ←, while comparisons use = or == depending on the style. Always distinguish between assignment and equality testing because exam questions may ask you to find a bug caused by confusing the two.

在 Edexcel 伪代码中，赋值通常使用箭头符号 ←，而比较则根据风格使用 = 或 ==。务必区分赋值和相等性测试，因为考题可能会要求你找出由于混淆两者而导致的错误。

3. Selection: if, elif, else | 选择结构：if、elif、else

The if-elif-else structure allows a program to branch based on the value of a Boolean condition. A basic if statement executes a block only when the condition is true. An else clause handles the false case, and elif lets you test multiple conditions in sequence without excessive nesting.

if-elif-else 结构允许程序根据布尔条件的值进行分支。基本的 if 语句仅在条件为真时执行某个代码块。else 子句处理条件为假的情况，elif 则允许你按顺序测试多个条件，避免过多嵌套。

Always place the most specific or restrictive condition first when using elif. For example, if checking score >= 90, score >= 70, and score >= 50, the first condition should catch the highest range. If the order is reversed, lower ranges will incorrectly absorb higher scores.

使用 elif 时，始终将最具体或最严格的条件放在最前面。例如，检查 score >= 90、score >= 70 和 score >= 50 时，第一个条件应该捕获最高分数段。如果顺序颠倒，较低分数段会错误地包含较高分数。

Boolean variables can simplify selection. Instead of writing if flag == True, write if flag. This reduces redundancy and makes the condition easier to read. Exam questions may present nested selection and ask you to draw a decision tree or complete a trace table.

布尔变量可以简化选择结构。不要写 if flag == True，而应写 if flag。这样可以减少冗余，使条件更易读。考题可能给出嵌套选择结构，要求你画出决策树或填写跟踪表。

4. Iteration: Count-Controlled and Condition-Controlled Loops | 迭代：计数控制与条件控制循环

Count-controlled loops repeat a fixed number of times. In Edexcel pseudocode, this is typically written as FOR i ← 1 TO n … ENDFOR. The loop variable takes each value in the specified range. This is ideal when you know in advance how many iterations are needed.

计数控制循环重复固定次数。在 Edexcel 伪代码中，通常写作 FOR i ← 1 TO n … ENDFOR。循环变量依次取指定范围内的每个值。当你事先知道需要多少次迭代时，这是理想的选择。

Condition-controlled loops repeat while a condition is true or until a condition becomes true. The WHILE loop checks the condition before each iteration, so it may execute zero times. The REPEAT…UNTIL loop checks after each iteration, so it always executes at least once.

条件控制循环在条件为真时重复，或重复直到条件变为真。WHILE 循环在每次迭代之前检查条件，因此可能执行零次。REPEAT…UNTIL 循环在每次迭代之后检查条件，因此总是至少执行一次。

A trace table is essential for recording variable values during each iteration. When you analyse a loop, update the loop counter, condition, and any accumulator step by step. A common exam error is failing to write down the value of the loop condition at the end of each pass, leading to an incorrect final output.

跟踪表对于记录每次迭代中的变量值至关重要。分析循环时，要逐步更新循环计数器、条件和所有累加器。考试中常见的错误是未能写出每轮结束时循环条件的值，从而得出错误的最终输出。

5. Subroutines: Procedures and Functions | 子程序：过程与函数

Subroutines break a complex problem into smaller, reusable blocks. A procedure performs a task but does not return a value. A function performs a task and returns exactly one value. In Python, a procedure is simply a function that returns None implicitly.

子程序将复杂问题分解为更小的、可复用的代码块。过程执行任务但不返回值。函数执行任务并返回且仅返回一个值。在 Python 中，过程只是隐式返回 None 的函数。

Using parameters and local variables improves modularity and avoids unintended side effects. Local variables are created when the subroutine is called and destroyed when it finishes. Global variables should be used sparingly because they make debugging and reasoning about programs more difficult.

使用参数和局部变量可以提高模块化程度，避免意外的副作用。局部变量在子程序被调用时创建，在子程序结束时销毁。全局变量应尽量少用，因为它们会使程序的调试和推理更加困难。

Edexcel exam questions often provide pseudocode for a subroutine and ask for the output after a particular call. Practise dry running subroutines by drawing a call stack or by writing down the values passed back and forth. Pay close attention to whether a variable is being updated or replaced.

Edexcel 考题经常给出子程序的伪代码，并要求回答特定调用后的输出。练习通过绘制调用栈或写下来回传递的值来手工执行子程序。要特别注意变量是被更新还是被替换。

6. Parameter Passing: By Value and By Reference | 参数传递：按值与按引用

By value passes a copy of the argument to the subroutine. Any changes made to the parameter inside the subroutine do not affect the original variable outside. By reference passes the memory address, so the subroutine can modify the original data directly.

按值传递将参数的副本传递给子程序。子程序内部对参数所做的任何更改都不会影响外部的原始变量。按引用传递传递的是内存地址，因此子程序可以直接修改原始数据。

In Python, integers, floats, strings, and booleans are immutable, so they behave like by-value arguments. Lists and dictionaries, however, are mutable and behave like by-reference arguments. This distinction is important when predicting the output of a subroutine that modifies an array.

在 Python 中，整数、浮点数、字符串和布尔值是不可变的，因此它们的行为类似于按值传递的参数。然而，列表和字典是可变的，行为类似于按引用传递的参数。在预测修改数组的子程序的输出时，这一区别非常重要。

Edexcel pseudocode may explicitly state whether parameters are passed by value or by reference, or you may need to infer it from the problem context. If a subroutine needs to return more than one result, by-reference parameters can be used, but a cleaner approach is often to return a record or tuple.

Edexcel 伪代码可能会明确说明参数是按值还是按引用传递，也可能需要你根据问题背景进行推断。如果子程序需要返回多个结果，可以使用按引用传递的参数，但更清晰的做法往往是返回一条记录或元组。

7. Arrays, Lists and 2D Structures | 数组、列表与二维结构

Arrays store multiple values under one identifier and use an index to access each element. The first index may be 0 or 1 depending on the language or pseudocode convention. Always state your indexing assumption when writing Edexcel answers.

数组在一个标识符下存储多个值，并使用索引访问每个元素。第一个索引可能是 0 或 1，具体取决于语言或伪代码规范。在编写 Edexcel 答案时，务必说明你的索引假设。

A 2D array is an array of arrays, often visualised as a grid with rows and columns. It is accessed using two indices, such as grid[row, column]. Common operations include traversing all elements, summing rows, and searching for a maximum or minimum value.

二维数组是数组的数组，通常可视化为带有行和列的网格。它使用两个索引进行访问，例如 grid[row, column]。常见的操作包括遍历所有元素、对各行求和以及查找最大值或最小值。

You should be able to write pseudocode for insertion, deletion, linear search, and finding the average. Remember that updating an array inside a subroutine may affect the original array if the language uses by-reference semantics for mutable objects.

你应该能够编写插入、删除、线性搜索和求平均值的伪代码。请记住，如果语言对可变对象使用按引用语义，在子程序内部更新数组可能会影响原始数组。

8. String Handling and File I/O | 字符串处理与文件输入输出

String operations frequently tested include length, substring, concatenation, and character access. For example, in many languages string[0] returns the first character, and length(string) returns the number of characters. Concatenation uses + or & depending on the language.

经常考查的字符串操作包括长度、子串、连接和字符访问。例如，在许多语言中，string[0] 返回第一个字符，length(string) 返回字符数量。连接操作根据语言使用 + 或 &。

File handling follows a standard sequence: open, read or write, then close. You should always close a file to release resources and ensure data is flushed to disk. Exam questions may ask you to read a text file line by line and count words

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Edexcel A-Level Programming: Core Constructs and Algorithms | Edexcel A-Level 编程：核心结构与算法

This revision guide covers the essential programming knowledge required for the Edexcel A-Level Computer Science specification. It focuses on core programming constructs, data structures, subroutines, recursion, file handling, searching and sorting algorithms, complexity analysis, and exam techniques.

本复习指南涵盖 Edexcel A-Level 计算机科学考试大纲所要求的核心编程知识。重点包括编程基本结构、数据结构、子程序、递归、文件处理、搜索与排序算法、复杂度分析以及考试技巧。

1. Programming Paradigms and Structure | 编程范式与程序结构

Programming paradigms are fundamental styles of programming. The two most relevant to Edexcel A-Level are procedural programming and object-oriented programming. Procedural programming organises code into procedures or functions that operate on data, while object-oriented programming bundles data and methods into objects.

编程范式是编程的基本风格。与 Edexcel A-Level 最相关的两种范式是面向过程编程和面向对象编程。面向过程编程将代码组织为操作数据的过程或函数，而面向对象编程将数据和方法封装在对象中。

A well-structured program is modular, with each module performing a single clear task. This improves readability, maintainability, and testability. You should be able to write pseudocode that follows a logical top-down design.

结构良好的程序是模块化的，每个模块执行单一明确的任务。这提高了可读性、可维护性和可测试性。你应该能够编写遵循逻辑自顶向下设计的伪代码。

2. Data Types and Variables | 数据类型与变量

Data types define what kind of value a variable can hold. Common primitive types include integer, real, Boolean, character, and string. Choosing the correct data type affects memory usage and the operations that can be performed.

数据类型定义变量可以保存何种值。常见的基本类型包括整数、实数、布尔型、字符和字符串。选择正确的数据类型会影响内存使用以及可执行的操作。

A variable is a named memory location whose value can change during execution. A constant is similar but its value cannot be modified after initialisation. You must understand variable scope, including local and global variables.

变量是一个命名的内存位置，其值在执行期间可以改变。常量类似，但初始化后其值不可修改。你必须理解变量的作用域，包括局部变量和全局变量。

3. Sequence, Selection, and Iteration | 顺序、选择与迭代

All procedural programs are built from three basic control structures: sequence, selection, and iteration. Sequence means statements are executed in the order written. Selection allows branching based on conditions, using IF, ELSE IF, ELSE, and CASE statements.

所有面向过程的程序都由三种基本控制结构构建：顺序、选择和迭代。顺序意味着语句按编写的顺序执行。选择允许根据条件进行分支，使用 IF、ELSE IF、ELSE 和 CASE 语句。

Iteration repeats a block of code. Definite iteration, such as a FOR loop, runs a known number of times. Indefinite iteration, such as a WHILE or REPEAT UNTIL loop, continues until a condition is met. Infinite loops occur when the termination condition is never satisfied.

迭代重复执行代码块。确定迭代（如 FOR 循环）运行已知次数。不确定迭代（如 WHILE 或 REPEAT UNTIL 循环）持续到满足条件为止。当终止条件永远不满足时，就会发生无限循环。

4. Arrays and Lists | 数组与列表

Arrays and lists store multiple values under one identifier. A one-dimensional array is a fixed-size indexed collection, whereas a list is often dynamic and supports insertion and deletion. A two-dimensional array can model a table or grid.

数组和列表在一个标识符下存储多个值。一维数组是固定大小的索引集合，而列表通常是动态的，支持插入和删除。二维数组可以模拟表格或网格。

When manipulating arrays, you must be careful with index bounds. Many languages use zero-based indexing, so the first element is at index 0. Accessing an out-of-range index causes a runtime error.

操作数组时，必须注意索引边界。许多语言使用从零开始的索引，因此第一个元素位于索引 0。访问越界索引会导致运行时错误。

5. Subroutines: Procedures and Functions | 子程序：过程与函数

A subroutine is a named block of code that can be called from elsewhere in the program. Procedures perform a task but do not return a value. Functions perform a task and return a value to the caller.

子程序是一段命名代码块，可以从程序的其他位置调用。过程执行任务但不返回值。函数执行任务并向调用者返回一个值。

Parameters allow data to be passed into subroutines. Passing by value copies the argument, while passing by reference passes the memory address, allowing changes to affect the original variable. Return values are produced using a RETURN statement.

参数允许将数据传入子程序。按值传递会复制实参，而按引用传递传递内存地址，允许更改影响原始变量。返回值使用 RETURN 语句产生。

6. Recursion | 递归

Recursion is a technique where a subroutine calls itself to solve a smaller instance of the same problem. Every recursive algorithm must have a base case that stops the recursion and a recursive case that reduces the problem size.

递归是一种子程序调用自身来解决同一问题的较小实例的技术。每个递归算法必须有一个停止递归的基准情况，以及一个减小问题规模的递归情况。

A classic example is the factorial function: factorial(n) = n × factorial(n – 1) with factorial(1) = 1 as the base case. Recursion can be elegant but may use more memory due to the call stack.

一个经典示例是阶乘函数：factorial(n) = n × factorial(n – 1)，基准情况为 factorial(1) = 1。递归可能很优雅，但由于调用栈可能会使用更多内存。

7. File Handling and Exception Management | 文件处理与异常管理

Programs often need to read from and write to files. Typical operations include opening a file in read, write, or append mode, reading lines or records, writing data, and closing the file. Always close files to prevent data loss.

程序通常需要读写文件。典型操作包括以读、写或追加模式打开文件，读取行或记录，写入数据以及关闭文件。始终关闭文件以防止数据丢失。

Exceptions are runtime errors that can be handled using TRY, EXCEPT, and FINALLY blocks. Exception handling makes programs more robust by preventing crashes when unexpected input or file errors occur.

异常是可以使用 TRY、EXCEPT 和 FINALLY 块处理的运行时错误。异常处理通过在发生意外输入或文件错误时防止崩溃，使程序更加健壮。

8. Searching Algorithms | 搜索算法

Linear search checks each element in order until the target is found or the end is reached. It works on unsorted data and has a worst-case time complexity of O(n).

线性搜索按顺序检查每个元素，直到找到目标或到达末尾。它适用于未排序的数据，最坏情况时间复杂度为 O(n)。

Binary search repeatedly divides a sorted list in half, comparing the middle element with the target. If the target is smaller, search the left half; if larger, search the right half. It has a time complexity of O(log n) but requires sorted data.

二分搜索反复将有序列表分成两半，将中间元素与目标比较。如果目标较小，搜索左半部分；如果较大，搜索右半部分。其时间复杂度为 O(log n)，但要求数据有序。

9. Sorting Algorithms | 排序算法

Bubble sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The largest unsorted element ‘bubbles’ to the end each pass. It has average and worst-case complexity O(n²).

冒泡排序反复遍历列表，比较相邻元素，如果顺序错误则交换它们。最大的未排序元素每次遍历都会“冒泡”到末尾。其平均和最坏情况复杂度为 O(n²)。

Merge sort uses a divide-and-conquer approach: split the list into halves recursively, sort each half, then merge the sorted halves. It has a guaranteed time complexity of O(n log n) but uses additional memory.

归并排序使用分治方法：递归地将列表分成两半，对每一半进行排序，然后合并已排序的两半。它的时间复杂度保证为 O(n log n)，但使用额外内存。

10. Algorithm Complexity and Big O Notation | 算法复杂度与大 O 表示法

Big O notation describes the upper bound of an algorithm’s time or space requirements as the input size n grows. Common complexities include O(1), O(log n), O(n), O(n log n), O(n²), and O(2ⁿ).

大 O 表示法描述随着输入规模 n 增长，算法时间或空间需求的上界。常见复杂度包括 O(1)、O(log n)、O(n)、O(n log n)、O(n²) 和 O(2ⁿ)。

Constant time O(1) means runtime does not depend on input size. Linear time O(n) means runtime grows proportionally with input size. Quadratic time O(n²) means doubling input quadruples runtime, which becomes impractical for large data sets.

常数时间 O(1) 意味着运行时间不依赖于输入规模。线性时间 O(n) 意味着运行时间与输入规模成正比增长。二次时间 O(n²) 意味着输入翻倍会使运行时间变为四倍，这对于大数据集变得不切实际。

11. Debugging and Testing | 调试与测试

Debugging is the process of finding and fixing errors in code. Syntax errors occur when the code violates language rules. Logic errors occur when the code runs but produces incorrect results. Runtime errors occur during execution, such as division by zero.

调试是查找并修复代码错误的过程。语法错误在代码违反语言规则时发生。逻辑错误在代码运行但产生错误结果时发生。运行时错误在执行期间发生，例如除以零。

Testing strategies include dry run, trace tables, unit testing, and integration testing. A trace table records variable values at each step, helping you verify that loops and conditions behave as intended.

测试策略包括干运行、跟踪表、单元测试和集成测试。跟踪表记录每一步的变量值，帮助你验证循环和条件按预期运行。

12. Exam Techniques and Pseudocode | 考试技巧与伪代码

In the Edexcel A-Level exam, you may be asked to read, trace, or write pseudocode. Pseudocode should be clear, unambiguous, and use consistent indentation. It does not need to follow the syntax of a specific programming language.

在 Edexcel A-Level 考试中，你可能会被要求阅读、跟踪或编写伪代码。伪代码应当清晰、无歧义，并使用一致的缩进。它不需要遵循特定编程语言的语法。

When designing a solution, break the problem into smaller parts, define inputs and outputs, and identify the control structures needed. Show your working in trace tables and justify your choice of algorithm based on efficiency and data conditions.

设计解决方案时，将问题分解为更小的部分，定义输入和输出，并确定所需的控制结构。在跟踪表中展示工作过程，并根据效率和数据条件证明算法选择的合理性。

Published by TutorHao | Programming Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Operators and Expressions in Edexcel A-Level Programming | Edexcel A-Level 编程中的运算符与表达式

In Edexcel A-Level Computer Science, programming questions often depend on a precise understanding of operators and how expressions are evaluated. This article explains arithmetic, relational, logical and assignment operators, along with precedence, type conversion and common exam pitfalls. The content is suitable for both Paper 2 algorithm questions and practical programming tasks.

在 Edexcel A-Level 计算机科学中，编程题往往取决于对运算符及表达式求值方式的准确理解。本文讲解算术、关系、逻辑和赋值运算符，以及优先级、类型转换和常见考试误区。内容适合 Paper 2 算法题和实际编程任务。

1. What Are Operators and Expressions? | 什么是运算符与表达式？

An operator is a symbol that tells the computer to perform a specific operation on one or more operands. An expression is a sequence of operands and operators that can be evaluated to produce a single value.

运算符是告诉计算机对一个或多个操作数执行特定操作的符号。表达式是由操作数和运算符组成的序列，它可以被求值并产生一个单一的值。

For example, in the expression x + y * 2, the operands are x, y and 2, while the operators are + and *. The order in which operators are applied is governed by precedence rules, which we will explore later.

例如，在表达式 x + y * 2 中，操作数是 x、y 和 2，运算符是 + 和 *。运算符应用的顺序由优先级规则决定，我们稍后会深入探讨。

2. Arithmetic Operators | 算术运算符

Arithmetic operators perform mathematical calculations. In Edexcel pseudocode and Python, the main arithmetic operators are +, -, *, /, DIV or //, MOD or %, and exponentiation such as ^ or **.

算术运算符执行数学计算。在 Edexcel 伪代码和 Python 中，主要的算术运算符包括 +、-、*、/、DIV 或 //、MOD 或 %，以及幂运算如 ^ 或 **。

In Edexcel pseudocode, you may see DIV and MOD written as words instead of symbols. The DIV operator gives the whole-number part of a division, while MOD gives the remainder.

在 Edexcel 伪代码中，你可能会看到 DIV 和 MOD 以单词形式出现，而不是符号。DIV 运算符给出除法中的整数部分，MOD 给出余数。

3. Relational / Comparison Operators | 关系（比较）运算符

Relational operators compare two values and return a Boolean result: either TRUE or FALSE. These operators are essential for building conditions in selection and iteration statements.

关系运算符比较两个值并返回布尔结果：TRUE 或 FALSE。这些运算符对于在选择和循环语句中构建条件至关重要。

A common mistake is writing = when you mean ==. The single equals sign is assignment, while the double equals sign is a comparison for equality.

一个常见错误是当你想表达 == 时却写成了 =。单个等号是赋值，双等号才是相等比较。

4. Logical Operators | 逻辑运算符

Logical operators combine Boolean expressions. The three main logical operators are AND, OR and NOT. They follow the rules of Boolean algebra and are used in compound conditions such as age >= 18 AND status == 'active'.

逻辑运算符用于组合布尔表达式。三个主要的逻辑运算符是 AND、OR 和 NOT。它们遵循布尔代数规则，并用于复合条件，例如 age >= 18 AND status == 'active'。

Short-circuit evaluation is often examined: for A AND B, if A is FALSE then B is not evaluated; for A OR B, if A is TRUE then B is not evaluated. This can prevent runtime errors in expressions such as x != 0 AND 10 / x > 2.

短路求值经常被考查：对于 A AND B，如果 A 为 FALSE，则不会求值 B；对于 A OR B，如果 A 为 TRUE，则不会求值 B。这可以防止诸如 x != 0 AND 10 / x > 2 这样的表达式出现运行时错误。

5. Assignment Operators and Compound Assignment | 赋值运算符与复合赋值

The basic assignment operator is = in most languages. It assigns the value on the right to the variable on the left. For example, score = 10 stores 10 in the variable score.

在大多数语言中，基本赋值运算符是 =。它将右侧的值赋给左侧的变量。例如，score = 10 将 10 存储到变量 score 中。

Compound assignment operators combine an arithmetic operation with assignment. For instance, x += 5 is equivalent to x = x + 5. Similarly, x *= 2 means x = x * 2, and x //= 3 means x = x // 3.

复合赋值运算符将算术运算与赋值结合起来。例如，x += 5 等价于 x = x + 5。类似地，x *= 2 表示 x = x * 2，而 x //= 3 表示 x = x // 3。

• += add and assign
• -= subtract and assign
• *= multiply and assign
• /= divide and assign
• //= integer divide and assign
• %= modulo and assign
• **= exponentiate and assign

These operators make code shorter and are often used inside loops to update counters or totals.

这些运算符使代码更简洁，并且常用于循环内部更新计数器或总计。

6. Operator Precedence and Associativity | 运算符优先级与结合性

Operator precedence determines the order in which operations are evaluated in an expression. Higher precedence operators are applied before lower precedence operators. When two operators have the same precedence, associativity determines whether evaluation is left-to-right or right-to-left.

运算符优先级决定表达式中运算的求值顺序。优先级较高的运算符先于优先级较低的运算符应用。当两个运算符具有相同优先级时，结合性决定求值是从左到右还是从右到左。

The typical precedence order, from highest to lowest, is shown below:

从高到低的典型优先级顺序如下：

• Parentheses () — highest priority
• Exponentiation ** or ^ — right-to-left associative
• Unary positive and negative +x, -x
• Multiplication, division, integer division, modulo * / // % — left-to-right
• Addition and subtraction + - — left-to-right
• Relational comparisons < > <= >= == !=
• Logical NOT NOT
• Logical AND AND
• Logical OR OR
• Assignment operators = += -= *= /= — lowest priority, right-to-left

For example, 2 + 3 * 4 evaluates the multiplication first, giving 2 + 12 = 14. To change the order, use parentheses: (2 + 3) * 4 = 20.

例如，2 + 3 * 4 先计算乘法，得到 2 + 12 = 14。要改变顺序，请使用括号：(2 + 3) * 4 = 20。

7. Type Conversion in Expressions | 表达式中的类型转换

Expressions often mix different data types, such as integers, real numbers and strings. Type conversion changes a value from one data type to another. Implicit conversion happens automatically, while explicit conversion is written by the programmer using functions like int(), float() and str().

表达式经常混合不同的数据类型，如整数、实数和字符串。类型转换将值从一种数据类型更改为另一种。隐式转换自动发生，而显式转换由程序员使用 int()、float() 和 str() 等函数编写。

For example, int(3.9) truncates the decimal part and returns 3, not 4. float(7) returns 7.0. The expression "3" + "4" produces the string “34”, but int("3") + int("4") produces the integer 7.

例如，int(3.9) 会截去小数部分并返回 3，而不是 4。float(7) 返回 7.0。表达式 "3" + "4" 生成字符串 “34”，但 int("3") + int("4") 生成整数 7。

In integer division, the result is an integer even if the operands are integers. This can cause unexpected truncation: 1 / 2 is 0.5 in true division, but 1 // 2 is 0, and 1 % 2 is 1.

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Object-Oriented Programming in Python for Edexcel A-Level | Edexcel A-Level Python 面向对象编程详解

Object-oriented programming (OOP) is one of the most important paradigms assessed in the Edexcel A-Level Computer Science specification. Mastering OOP concepts in Python not only helps you write modular and reusable code but also prepares you for questions on class design, inheritance, and relationships. This article provides a comprehensive revision guide, covering every key OOP topic you need for the exam, with clear examples and exam-focused insights.

面向对象编程（OOP）是 Edexcel A-Level 计算机科学考试中最重要的编程范式之一。掌握 Python 中的 OOP 概念不仅能帮助你编写模块化、可复用的代码，还能为应对类设计、继承和关系类考题做好准备。本文是一份全面的复习指南，涵盖考试所需的所有关键 OOP 主题，并配有清晰的示例和考试重点解析。

1. What is Object-Oriented Programming? | 什么是面向对象编程？

OOP is a programming paradigm that organizes code around ‘objects’ rather than functions and logic. Objects contain data, in the form of attributes, and behaviour, in the form of methods. The four main pillars of OOP are encapsulation, inheritance, polymorphism, and abstraction. In Edexcel A-Level, you need to understand how these principles are implemented in Python and how they lead to better software design.

面向对象编程是一种围绕“对象”而非函数和逻辑来组织代码的编程范式。对象包含数据（以属性的形式）和行为（以方法的形式）。OOP 的四大支柱是封装、继承、多态和抽象。在 Edexcel A-Level 考试中，你需要理解这些原则如何在 Python 中实现，以及它们如何带来更好的软件设计。

2. Classes and Objects | 类与对象

A class is a blueprint for creating objects. It defines a set of attributes and methods that the objects created from it will have. You define a class in Python using the class keyword. For example, class Dog: followed by an indented block. An object is an instance of a class. To create an object, you call the class as if it were a function: my_dog = Dog().

类是创建对象的蓝图。它定义了一组从该类创建的对象将具有的属性和方法。在 Python 中，使用 class 关键字定义类。例如，class Dog: 后跟缩进块。对象是类的一个实例。要创建对象，你可以像调用函数一样调用类：my_dog = Dog()。

Each object has its own copy of the instance attributes, and multiple objects can be created from the same class. The self parameter refers to the current instance and is used to access attributes and methods within the class.

每个对象都有自己的实例属性副本，并且可以从同一个类创建多个对象。self 参数指向当前实例，并用于在类内部访问属性和方法。

3. Attributes and Methods | 属性与方法

Attributes are variables that belong to a class (class attributes) or to an instance (instance attributes). Instance attributes are typically defined inside the __init__ method using self.attribute_name = value. Class attributes are defined directly inside the class body and are shared by all instances.

属性是属于类（类属性）或实例（实例属性）的变量。实例属性通常在使用 self.attribute_name = value 的 __init__ 方法中定义。类属性直接定义在类体内，并由所有实例共享。

Methods are functions defined inside a class. They always take self as the first parameter (unless they are static or class methods). Methods operate on the instance data and can modify the object’s state. You call a method on an object: my_dog.bark().

方法是定义在类内部的函数。它们始终将 self 作为第一个参数（除非是静态方法或类方法）。方法操作实例数据，并可以修改对象的状态。你可以在对象上调用方法：my_dog.bark()。

4. The __init__ Method (Constructor) | 构造方法 __init__

The __init__ method is a special method in Python classes that acts as a constructor. It is automatically called when a new object is created. You use it to initialise instance attributes with values passed as arguments. For example: def __init__(self, name, age): inside a class assigns self.name = name and self.age = age.

__init__ 方法是 Python 类中用作构造函数的特殊方法。当创建一个新对象时，它会被自动调用。你可以用它来使用传入的参数初始化实例属性。例如，在类中定义 def __init__(self, name, age): 并赋值 self.name = name 和 self.age = age。

If you do not define an __init__ method, Python provides a default constructor that does nothing. Understanding the role of __init__ is essential for class-based exam questions where you must write or interpret a class definition.

如果你不定义 __init__ 方法，Python 会提供一个什么都不做的默认构造函数。理解 __init__ 的作用对于基于类的考试题至关重要，这些题目要求你编写或解读类定义。

5. Encapsulation and Access Control | 封装与访问控制

Encapsulation is the bundling of data and methods that operate on that data within a single unit (class), and restricting direct access to some of the object’s components. In Python, we use naming conventions to indicate protected and private members: a single leading underscore _ for protected, and double leading underscore __ for private name mangling.

封装是将数据与操作这些数据的方法捆绑在单个单元（类）中，并限制对对象某些组件的直接访问。在 Python 中，我们使用命名约定来指示受保护成员和私有成员：单下划线前缀 _ 表示受保护，双下划线前缀 __ 会触发名称改写以实现私有。

Although Python does not enforce strict access modifiers like Java, the convention is respected in Edexcel exam contexts. Getter and setter methods (or properties using the @property decorator) are often used to control access to attributes.

虽然 Python 不像 Java 那样强制执行严格的访问修饰符，但在 Edexcel 考试情境中，这些约定是被认可的。通常使用 getter 和 setter 方法（或使用 @property 装饰器的属性）来控制对属性的访问。

6. Inheritance and the ‘is-a’ Relationship | 继承与“是一个”关系

Inheritance allows a class (child or subclass) to acquire attributes and methods from another class (parent or superclass). This supports code reuse and establishes an ‘is-a’ relationship. In Python, a subclass is created by placing the parent class name in parentheses: class Puppy(Dog):.

继承允许一个类（子类或派生类）从另一个类（父类或超类）获取属性和方法。这支持代码复用，并建立“是一个”关系。在 Python 中，子类通过将父类名称放在括号中来创建：class Puppy(Dog):。

You can override parent methods by redefining them in the child class. To call the parent’s constructor, use super().__init__(...). Edexcel questions often require you to extend a given class and demonstrate method overriding and the use of super().

你可以通过在子类中重新定义来覆盖父类方法。要调用父类的构造函数，使用 super().__init__(...)。Edexcel 考题经常要求你扩展一个给定的类，并演示方法覆盖和 super() 的用法。

Multiple inheritance is possible in Python but can lead to complexity. For Edexcel, focus on single inheritance and understanding how the subclass can add extra attributes or modify behaviour.

Python 支持多重继承，但可能导致复杂性。对于 Edexcel，重点放在单继承上，并理解子类如何添加额外属性或修改行为。

7. Polymorphism and Method Overriding | 多态与方法覆盖

Polymorphism means ‘many forms’. It allows objects of different classes to be treated as objects of a common superclass. The most common form is method overriding, where a subclass provides a specific implementation of a method already defined in its parent. The correct method is invoked based on the object’s actual class at runtime.

多态意为“多种形态”。它允许将不同类的对象视为公共超类的对象来处理。最常见的形式是方法覆盖，即子类提供对父类中已定义方法的具体实现。运行时根据对象的实际类别调用正确的方法。

For example, a function that expects an Animal object can work with a Dog or Cat as long as they implement the same method

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Object-Oriented Programming Concepts | 面向对象编程概念

Object-Oriented Programming (OOP) is a paradigm that organises software design around data, or objects, rather than functions and logic. An object is a self-contained entity that contains both data in the form of attributes and procedures in the form of methods. This approach models real-world entities, making code more intuitive, reusable, and scalable. In the Edexcel A-Level Computer Science syllabus, understanding OOP is essential for Paper 2, where you are expected to apply these principles in pseudocode and recognise them in Python or other high-level languages.

面向对象编程是一种将软件设计围绕数据（即对象）而非函数与逻辑来组织的编程范式。对象是一个自包含的实体，包含属性形式的数据和方法形式的操作。这种方法模拟了现实世界实体，使得代码更加直观、可复用且易于扩展。在Edexcel A-Level计算机科学教学大纲中，理解面向对象编程对Paper 2至关重要，你需要能够在伪代码中应用这些原则，并在Python或其他高级语言中识别它们。

1. Classes and Objects | 类与对象

A class is a blueprint or template that defines the attributes and behaviours common to a set of objects. An object is a specific instance of a class, created at runtime. For example, a class Car might define attributes like colour and speed, and methods like accelerate(). An object myCar = new Car() would then represent a particular car with its own attribute values. The class provides the structure; the object holds the actual state.

类是定义一组对象共有属性和行为的蓝图或模板。对象是类的具体实例，在运行时创建。例如，一个 Car 类可能定义了颜色和速度等属性，以及 accelerate() 等方法。而对象 myCar = new Car() 则代表一辆具有自己属性值的特定汽车。类提供了结构，对象持有实际状态。

2. Encapsulation and Data Hiding | 封装与数据隐藏

Encapsulation bundles the data (attributes) and the methods that operate on that data into a single unit, the class. It also restricts direct access to some of an object’s internal state. Data hiding is typically achieved using access modifiers such as private, protected, and public. By making attributes private, we force external code to interact with the object only through its public methods, protecting the integrity of the data and reducing unintended interference.

封装将数据（属性）和操作这些数据的方法捆绑到一个单元，即类中。它还限制了对对象某些内部状态的直接访问。数据隐藏通常通过 private、protected 和 public 等访问修饰符来实现。通过将属性设为 private，我们强制外部代码只能通过对象的公共方法与之交互，从而保护数据的完整性，减少意外的干扰。

3. Inheritance: Reusing Code | 继承：代码复用

Inheritance allows a new class (subclass or derived class) to acquire the properties and methods of an existing class (superclass or base class). This promotes code reuse and establishes an ‘is-a’ relationship. For instance, a SportsCar class can inherit from Car, adding a turboBoost() method while automatically having access to accelerate(). Inheritance can be single (one superclass) or multiple (more than one), though many languages like Python support multiple inheritance whereas Java restricts to single inheritance with interfaces.

继承允许一个新类（子类或派生类）获取已有类（超类或基类）的属性和方法。这促进了代码复用，并建立了“是一个”的关系。例如，一个 SportsCar 类可以从 Car 继承，添加 turboBoost() 方法，同时自动拥有 accelerate() 方法。继承可以是单继承（一个超类）或多继承（多个超类），不过像 Python 这样的语言支持多继承，而 Java 则限定为通过接口实现的单继承。

4. Polymorphism: Many Forms | 多态：多种形态

Polymorphism means ‘many forms’ and allows objects of different classes to respond to the same method call in their own specific way. This is often achieved through method overriding, where a subclass provides a tailored implementation of a method already defined in its superclass. Polymorphism enables writing more flexible and generic code. For example, a function can accept a parameter of type Shape and call draw(), and at runtime the correct draw() method of Circle or Rectangle will execute.

多态意为“多种形态”，允许不同类的对象以各自特定的方式响应同一个方法调用。这通常通过方法重写来实现，即子类提供对超类中已定义方法的定制实现。多态使得代码更加灵活和通用。例如，一个函数可以接受 Shape 类型参数并调用 draw()，运行时将执行 Circle 或 Rectangle 正确的 draw() 方法。

5. Method Overriding vs Overloading | 方法重写与重载

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method signature (name and parameters) remains the same, and the decision about which version to invoke is made at runtime (dynamic binding). In contrast, method overloading is defining multiple methods with the same name but different parameter lists within the same class. Overloading is resolved at compile time (static binding) and is not strictly a feature of all OOP languages; Python does not support traditional overloading but can simulate it with default arguments.

方法重写发生在子类提供对超类中已定义方法的具体实现时。方法签名（名称和参数）保持不变，调用哪个版本的决策在运行时作出（动态绑定）。相比之下，方法重载是在同一个类中定义多个同名但参数列表不同的方法。重载在编译时解析（静态绑定），并非所有面向对象语言都严格支持；Python 不支持传统重载，但可以用默认参数来模拟。

6. Abstract Classes and Interfaces | 抽象类与接口

An abstract class is a class that cannot be instantiated and is designed to be subclassed. It may contain abstract methods (without implementation) that subclasses must override. Interfaces define a contract of methods that implementing classes must provide, without any concrete implementation. In Python, the abc module allows creating abstract base classes. Abstract classes and interfaces support polymorphism and enforce a consistent design across a class hierarchy.

抽象类是不能实例化并设计用于被继承的类。它可以包含抽象方法（无实现），子类必须重写这些方法。接口定义了一组实现类必须提供的方法契约，没有任何具体实现。在 Python 中，abc 模块用于创建抽象基类。抽象类和接口支持多态，并在类层次结构中强制一致的设计。

7. Association, Aggregation and Composition | 关联、聚合与组合

These terms describe relationships between classes. Association is a general ‘uses-a’ relationship where objects of one class interact with objects of another. Aggregation is a ‘has-a’ relationship that implies ownership, but the contained object can exist independently (e.g., a Library aggregates Books, but a Book can exist without the Library). Composition is a stronger ‘has-a’ relationship where the contained object cannot exist without the container (e.g., a House is composed of Rooms; destroying the House destroys the Rooms). These concepts are essential for modelling real-world systems.

这些术语描述了类之间的关系。关联是一种普遍的“使用”关系，一个类的对象与另一个类的对象交互。聚合是一种“拥有”关系，暗示所有权，但所包含对象可以独立存在（例如，图书馆聚合了书籍，但书籍可以脱离图书馆而存在）。组合是一种更强的“拥有”关系，被包含对象不能脱离容器而存在（例如，房子由房间组成；销毁房子也将销毁房间）。这些概念对于现实世界系统建模至关重要。

8. The Four Pillars of OOP | OOP的四大支柱

The four fundamental principles of Object-Oriented Programming are encapsulation, inheritance, polymorphism, and abstraction. Abstraction involves hiding complex implementation details and exposing only the essential features of an object. Together, these pillars enable programmers to build modular, maintainable, and robust applications. In your Edexcel exam, you will often be asked to explain these concepts with clear examples, so it is critical to memorise their definitions and demonstrate them in pseudocode.

面向对象编程的四个基本原则是封装、继承、多态和抽象。抽象涉及隐藏复杂的实现细节，只暴露对象的必要特征。这些支柱共同使程序员能够构建模块化、可维护且健壮的应用程序。在 Edexcel 考试中，你经常会被要求用清晰的例子解释这些概念，因此记住它们的定义并在伪代码中展示它们至关重要。

9. OOP in Python (Practical Examples) | Python中的OOP实例

Python is a multi-paradigm language that fully supports OOP. Here is a concise example illustrating class definition, constructor (__init__), instance variables, inheritance, and method overriding:

Python 是一种全面支持面向对象的多范式语言。以下是一个简洁的示例，展示了类定义、构造方法 (__init__)、实例变量、继承和方法重写：

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return “Some sound”

d = Dog(“Fido”)
print(d.speak()) # Output: Fido barks

In this code, the subclass Dog inherits from Animal and overrides the speak() method, demonstrating polymorphism. Encapsulation is present with the attribute name accessed via self; you could make it private by prefixing it with double underscores (__name) to enforce data hiding.

在这段代码中，子类 Dog 继承自 Animal 并重写了 speak() 方法，展示了多态。封装体现在通过 self 访问 name 属性；你可以通过在属性名前加双下划线（__name）将其设为私有以强制数据隐藏。

10. Advantages and Disadvantages of OOP | 面向对象编程的优缺点

Advantages include improved modularity, code reusability through inheritance, easier maintenance due to encapsulation, and the ability to model complex real-world systems elegantly. OOP also enables collaborative development because classes can be developed independently. However, disadvantages include a steep learning curve, potential performance overhead, and the tendency to create overly complex class hierarchies. Programs written in an OOP style can sometimes be longer than equivalent procedural code, and analysis of the right object model requires significant effort upfront.

优点包括更好的模块化、通过继承实现的代码复用性、因封装而更易维护，以及优雅地建模复杂现实世界系统的能力。OOP 还支持协作开发，因为类可以独立开发。然而，缺点包括学习曲线陡峭、潜在的性能开销，以及创建过于复杂的类层次结构的倾向。面向对象风格的程序有时可能比等价的面向过程代码更长，而对正确对象模型的分析需要大量前期工作。

11. Common OOP Design Patterns | 常见OOP设计模式

Design patterns are reusable solutions to common software design problems within a given context. Examples include the Singleton pattern that ensures a class has only one instance, the Factory pattern that creates objects without specifying the exact class, and the Observer pattern that defines a one-to-many dependency between objects. While not mandatory for the Edexcel specification, recognising these patterns can deepen your understanding of OOP principles and help in solving complex programming problems.

设计模式是针对特定上下文中常见软件设计问题的可复用解决方案。例子包括确保一个类只有一个实例的单例模式、无需指定确切类即可创建对象的工厂模式，以及定义对象间一对多依赖关系的观察者模式。虽然这些不属 Edexcel 考试要求范围，但认识这些模式可以加深你对 OOP 原则的理解，并有助于解决复杂编程问题。

12. Exam Tips for Edexcel A-Level | Edexcel A-Level考试技巧

When tackling OOP questions in the Edexcel Computer Science examination, always refer to the official pseudocode conventions. Be prepared to write class definitions with attributes, constructors, and methods. Clearly indicate inheritance using the ‘IS A’ relationship in class diagrams or pseudocode. Use access modifiers as specified by the exam board, and illustrate polymorphism by showing how a parent class reference can invoke overridden methods in subclasses. Timed practice with past papers will build confidence, and ensure you can explain concepts in plain English as well as code.

在应对 Edexcel 计算机科学考试中面向对象的题目时，务必参照官方伪代码规范。准备好编写包含属性、构造方法和方法在内的类定义。在类图或伪代码中清楚用“是一个”关系表示继承。按考试局规定使用访问修饰符，并通过展示父类引用如何调用子类重写的方法来说明多态。用历年真题进行限时练习可以建立信心，并确保你能用通俗英语以及代码来解释概念。

Published by TutorHao | Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Object-Oriented and Structured Programming: A Combined Approach | 面向对象与结构化编程：结合方法

In Edexcel A-Level programming, you need to master two fundamental programming paradigms: structured programming and object-oriented programming (OOP). Real-world software development rarely uses them in isolation. The real power emerges when you understand how to combine the clarity of structured control flow with the scalability of OOP. This article explores both paradigms, their key features, and practical ways to blend them in your own code.

在 Edexcel A-Level 编程中，你需要掌握两种基本的编程范型：结构化编程和面向对象编程（OOP）。现实世界的软件开发很少单独使用其中一种。当你理解如何将结构化控制流的清晰性与 OOP 的可扩展性相结合时，真正的威力就显现出来了。本文探讨这两种范型、它们的关键特性以及在自己的代码中混合使用它们的实用方法。

1. Understanding Programming Paradigms | 理解编程范型

A programming paradigm is a fundamental style of coding that determines how the structure and elements of a program are organised. Structured programming focuses on decomposing a problem into procedures and using sequence, selection, and iteration. Object-oriented programming organises code around objects that contain data and methods. The Edexcel specification requires you to compare these paradigms and apply them appropriately.

编程范型是一种基本的编码风格，它决定了程序的结构和元素如何组织。结构化编程侧重于将问题分解为过程，并使用顺序、选择和迭代。面向对象编程则将代码围绕包含数据和方法的对象进行组织。Edexcel 规范要求你比较这些范型，并恰当地应用它们。

2. The Three Pillars of Structured Programming | 结构化编程的三大支柱

Structured programming is built on three core control constructs: sequence (executing statements in step-by-step order), selection (using if-else or case structures to make decisions), and iteration (repeating blocks with for, while, or do-while loops). These constructs eliminate the need for unpredictable ‘goto’ statements and produce code that is easy to trace and debug.

结构化编程建立在三个核心控制结构上：顺序（按逐步顺序执行语句）、选择（使用 if-else 或 case 结构做出决策）和迭代（使用 for、while 或 do-while 循环重复代码块）。这些结构消除了对不可预测的 ‘goto’ 语句的需求，并生成了易于追踪和调试的代码。

3. The Four Pillars of Object-Oriented Programming | 面向对象编程的四大支柱

OOP rests on four principles: encapsulation, abstraction, inheritance, and polymorphism. Encapsulation bundles attributes and methods in a class and controls access with private/public modifiers. Abstraction hides complex implementation details. Inheritance allows child classes to reuse and extend parent behaviour. Polymorphism lets a single interface represent different underlying forms, often achieved through method overriding.

面向对象编程建立在四个原则上：封装、抽象、继承和多态。封装将属性和方法捆绑在类中，并用 private/public 修饰符控制访问。抽象隐藏复杂的实现细节。继承允许子类重用和扩展父类的行为。多态使单一接口能代表不同的底层形式，通常通过方法重写实现。

4. Structured Programming in Practice: Modules and Parameters | 实践中的结构化编程：模块与参数

In structured code, a large program is divided into functions and procedures. Each module performs a well-defined task, taking parameters as input and returning values as output. This top-down design encourages code reuse and readability. It also promotes loose coupling, as modules interact only through their interfaces rather than global variables.

在结构化代码中，大型程序被分成函数和过程。每个模块执行一个明确定义的任务，接受参数作为输入并返回值作为输出。这种自顶向下的设计鼓励代码重用和可读性。它还促进了松散耦合，因为模块仅通过接口交互，而不是通过全局变量。

5. OOP in Practice: Designing Classes and Objects | 实践中的面向对象编程：设计类与对象

Applying OOP starts with identifying real-world entities relevant to the problem. You model these as classes, defining attributes (fields) and behaviours (methods). For example, a ‘Student’ class might have fields such as studentID and name, and methods like enrolCourse(). An object is an instance of a class, holding its own state. This approach mirrors real-life systems, making complex projects easier to manage.

应用面向对象编程从识别与问题相关的现实世界实体开始。你将它们建模为类，定义属性（字段）和行为（方法）。例如，‘Student’ 类可能包含 studentID 和 name 等字段，以及 enrolCourse() 等方法。对象是类的一个实例，拥有自己的状态。这种方法反映了现实世界系统，使复杂项目更易于管理。

6. Why Combine Structured and Object-Oriented Approaches? | 为什么结合结构化与面向对象方法？

No modern application relies exclusively on one paradigm. Inside a class method, you will use structured if-else and loops to implement the logic. The class provides the encapsulation and reusability; the structured control flow ensures the method is correct and readable. Combining them gives you the micro-level clarity of structured programming and the macro-level organisation of OOP.

现代应用程序不会完全依赖单一种范型。在类方法内部，你会使用结构化的 if-else 和循环来实现逻辑。类提供了封装和可重用性；而结构化控制流确保方法正确且可读。结合二者，你就获得了结构化编程在微观层面的清晰性和面向对象编程在宏观层面的组织性。

7. Example: Blending Paradigms Inside a BankAccount Class | 示例：在 BankAccount 类中融合范型

Consider a simple BankAccount class. The deposit(amount) method needs to check that the amount is positive (selection), and perhaps apply a bonus while a counter is below a limit (iteration). The code below illustrates this combination concisely:

考虑一个简单的 BankAccount 类。deposit(amount) 方法需要检查金额是否为正（选择），并且可能在计数器低于某个限制时应用奖金（迭代）。下面的代码简洁地说明了这种结合：

class BankAccount:
    private balance ← 0
    public procedure deposit(amount)
        if amount > 0 then
            balance ← balance + amount
        else
            output “Invalid amount”
        endif
    endprocedure
endclass

虽然这是一个面向对象的类，但其方法内部完全依赖于结构化流程。这个方法可重用，并且封装的数据不会被外部直接篡改。

Although this is an object-oriented class, the inside of its method relies entirely on structured flow. The method is reusable, and the encapsulated data is not directly tampered with from outside.

8. Top-Down Design Meets Encapsulation | 自顶向下设计遇上封装

A top-down design strategy (a hallmark of structured programming) can be used to plan the classes in an OOP system. You first define high-level responsibilities, then break them into class methods, and finally implement each method using structured constructs. This layered approach keeps the overall architecture clean while ensuring low-level logic is robust.

自顶向下的设计策略（结构化编程的标志）可用于规划面向对象系统中的类。你首先定义高层职责，然后将其分解为类方法，最后使用结构化构造实现每个方法。这种分层方法保持整体架构清晰，同时确保低层逻辑健壮。

9. Inheritance and Modular Code Organisation | 继承与模块化代码组织

Inheritance allows you to create a hierarchy of classes that share common behaviour, reducing code duplication. Structured decomposition is used inside each class method. For instance, a generic ‘Vehicle’ class might declare an abstract move() method, while ‘Car’ and ‘Bike’ subclasses provide their own implementations using iteration and conditions. The paradigm combination keeps both the class tree and the method logic well-structured.

继承允许创建共享共同行为的类层次结构，从而减少代码重复。结构化分解在每个类方法内部使用。例如，一个通用的 ‘Vehicle’ 类可以声明一个抽象的 move() 方法，而 ‘Car’ 和 ‘Bike’ 子类使用迭代和条件提供自己的实现。范型的结合使类树和方法逻辑都保持结构良好。

10. Case Study: A Combined Approach in a Shopping Cart | 案例研究：购物车中的结合方法

Imagine a ShoppingCart class containing a list of items. The calculateTotal() method might iterate through the list (iteration) and for each item apply a discount if it is on sale (selection). The class itself encapsulates the item list and exposes only safe operations. This shows how a real-world feature naturally merges OOP structure with procedural logic.

想象一个 ShoppingCart 类，其中包含一个商品列表。calculateTotal() 方法可能遍历该列表（迭代），并对每个在售的商品应用折扣（选择）。类本身封装了商品列表，仅暴露安全的操作。这表明现实世界功能如何自然地将 OOP 结构与过程化逻辑融合。

11. Common Pitfalls When Mixing Paradigms | 混合范型时的常见陷阱

One mistake is using global variables inside class methods, which breaks encapsulation. Another is writing massive methods that perform too many tasks, violating both the single-responsibility principle and modular decomposition. Also, over-engineering a class hierarchy for a simple problem can make code harder to follow. Always balance: use robust OOP boundaries but keep the logic within methods clean and sequential.

一个常见的错误是在类方法内部使用全局变量，这破坏了封装性。另一个错误是编写执行过多任务的庞大方法，既违反了单一职责原则，也违反了模块化分解。此外，为简单问题过度设计类层次结构会使代码更难理解。始终保持平衡：使用健壮的 OOP 边界，但让方法内的逻辑保持清晰有序。

12. Edexcel A-Level Exam Focus | Edexcel A-Level 考试焦点

In Edexcel A-Level programming questions, you may be asked to compare the two paradigms or to write code that combines them. Examiners look for evidence that you can identify where structured loops and selections are used inside a class method. They also reward clear naming, appropriate encapsulation, and the correct application of inheritance. Practice writing short programs that define a class with at least one method that uses both an if statement and a loop, and explain why this is an example of paradigm combination.

在 Edexcel A-Level 编程试题中，你可能会被要求比较这两种范型，或编写结合它们的代码。考官期望你能识别出在类方法内部使用结构化循环和选择的地方。他们还会奖励清晰的命名、适当的封装以及对继承的正确应用。练习编写简短的程序，定义一个包含至少一个方法的类，其中同时使用了 if 语句和循环，并解释为什么这是范型结合的例子。

Published by TutorHao | Programming Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Mastering Operations on Stacks, Queues and Linked Lists | 精通栈、队列和链表操作

Linear data structures form the backbone of efficient algorithm design, and understanding their core operations is essential for success in Edexcel A-Level Computer Science. This revision guide breaks down the standard operations on stacks, queues and linked lists, using clear pseudocode, real-world analogies and exam-focused explanations.

线性数据结构是高效算法设计的基础，掌握它们的核心操作对 Edexcel A-Level 计算机科学考试至关重要。这份复习指南通过清晰的伪代码、现实类比和紧扣考点的解释，详细拆解了栈、队列和链表的标准操作。

1. Introduction to Linear Data Structures | 线性数据结构简介

A linear data structure organises elements in a sequential order where each element, except the first and last, has a unique predecessor and successor. The three fundamental linear structures examined in Edexcel are stacks, queues and linked lists. They differ in how elements are inserted and removed, which directly affects their use cases and algorithm efficiency.

线性数据结构将元素按顺序组织，除第一个和最后一个外，每个元素都有唯一的前驱和后继。Edexcel 考试涉及的三种基本线性结构是栈、队列和链表。它们在元素的插入和删除方式上各不相同，这直接影响了它们的应用场景和算法效率。

2. The Stack – LIFO Principle | 栈 —— 后进先出原则

A stack follows the Last-In-First-Out (LIFO) rule: the most recently added element is the first to be removed. Think of a stack of plates in a cafeteria – you take the top plate first. In computer science, stacks are used for tracking function calls, undo mechanisms, and expression evaluation.

栈遵循后进先出 (LIFO) 规则：最近添加的元素最先被移除。想象自助餐厅里的一叠盘子 —— 你总是先拿最上面的那个。在计算机科学中，栈用于跟踪函数调用、实现撤销功能以及表达式求值。

3. Stack Operations: Push, Pop, Peek | 栈操作：压入、弹出、窥视

The primary stack operations are push, pop and peek (or top). Push adds an element to the top of the stack; if the stack is implemented with a fixed-size array, a push on a full stack causes overflow. Pop removes and returns the top element; attempting to pop from an empty stack results in underflow. Peek returns the top element without removing it, allowing you to inspect the stack’s state. All three operations run in O(1) constant time because no shifting is needed.

主要的栈操作是 push（压入）、pop（弹出）和 peek（窥视）。Push 将一个元素添加到栈顶；如果用固定大小的数组实现栈，对已满的栈执行 push 会导致溢出。Pop 移除并返回栈顶元素；试图从空栈中弹出元素会导致下溢。Peek 返回栈顶元素但不移除它，让你能查看栈的状态。这三种操作都在 O(1) 常数时间内完成，因为不需要移动其他元素。

• Push(item): top <- top + 1; stack[top] <- item
• Pop(): IF top = -1 THEN UNDERFLOW; item <- stack[top]; top <- top - 1; RETURN item
• Peek(): IF top = -1 THEN UNDERFLOW; RETURN stack[top]

4. Applications of Stacks | 栈的应用场景

Stacks are used extensively in system software. The call stack stores return addresses when functions are called, and local variables are destroyed in LIFO order when functions return. In compilers, stacks help convert infix expressions like (A + B) * C to postfix notation A B + C * for easier evaluation. The depth-first search algorithm also relies on a stack – either explicitly or via recursion.

栈在系统软件中广泛应用。调用栈在函数调用时存储返回地址，局部变量在函数返回时按 LIFO 顺序销毁。在编译器中，栈有助于将中缀表达式如 (A + B) * C 转换为后缀表达式 A B + C *，以便于求值。深度优先搜索算法也依赖栈 —— 无论是显式地使用栈还是通过递归。

5. The Queue – FIFO Principle | 队列 —— 先进先出原则

A queue operates on the First-In-First-Out (FIFO) principle. Elements enter at the rear and leave from the front, much like a line of people waiting for a bus. Queues are essential for buffering data streams, managing print jobs, and scheduling processes in an operating system.

队列遵循先进先出 (FIFO) 原则。元素从队尾进入，从队首离开，就像排队等公交车的人群。队列对于缓冲数据流、管理打印作业以及操作系统中的进程调度至关重要。

6. Queue Operations: Enqueue, Dequeue | 队列操作：入队、出队

The two fundamental queue operations are enqueue and dequeue. Enqueue adds an item to the rear pointer and increments it; dequeue removes the item at the front pointer and increments that pointer. In a linear array implementation without optimisation, the queue can suffer from ‘drifting’ where unused slots appear at the front, causing a false overflow even when space is available. Both operations should be O(1).

队列的两个基本操作是 enqueue（入队）和 dequeue（出队）。Enqueue 将元素添加到队尾指针处，并递增该指针；dequeue 移除队首指针处的元素，并递增该指针。在不优化的线性数组实现中，队列会出现“漂移”现象，队首出现未使用的空位，导致在有空间的情况下出现假溢出。两种操作都应为 O(1)。

• Enqueue(item): IF rear = maxSize-1 THEN OVERFLOW; rear <- rear + 1; queue[rear] <- item
• Dequeue(): IF front > rear THEN UNDERFLOW; item <- queue[front]; front <- front + 1; RETURN item

7. Circular Queues and Priority Queues | 循环队列与优先队列

A circular queue overcomes the drift problem by connecting the rear and front of the array in a circular buffer. When the rear reaches the end, it wraps around to index 0 if space exists. This maximises storage use. A priority queue assigns each element a priority; the dequeue operation removes the element with the highest priority, not necessarily the oldest. Priority queues are commonly implemented using a heap data structure for O(log n) insertion and removal.

循环队列通过将数组的队尾和队首连接成一个环形缓冲区来克服漂移问题。当队尾指针到达末尾时，如果有空间，它会绕回到索引 0 处。这最大限度地利用了存储空间。优先队列为每个元素分配一个优先级；出队操作移除优先级最高的元素，而不一定是最早加入的元素。优先队列通常使用堆数据结构实现，以获得 O(log n) 的插入和删除性能。

8. Linked Lists – Dynamic Memory | 链表 —— 动态内存

Unlike arrays, a linked list stores each element in a separate node that contains a data field and a pointer (or link) to the next node. This dynamic structure can grow and shrink at runtime without the need for contiguous memory. Linked lists form the basis of many advanced data structures and are heavily examined in Edexcel A-Level.

与数组不同，链表将每个元素存储在一个单独的节点中，节点包含数据域和一个指向下一节点的指针（或链接）。这种动态结构可以在运行时增长和收缩，无需连续内存。链表是许多高级数据结构的基础，且在 Edexcel A-Level 考试中是重点考查内容。

9. Singly Linked List Operations: Insertion, Deletion, Traversal | 单向链表操作：插入、删除、遍历

In a singly linked list, each node points only to its successor. The three core operations are insertion (at head, tail, or a given position), deletion (removing a node by value or position), and traversal (visiting each node from head to tail). Insertion at the head is O(1): create a new node, set its next pointer to the current head, then update head. Deletion finds the predecessor of the target node, updates its next pointer to bypass the target, and then frees memory. Traversal uses a temporary pointer that moves stepwise until it becomes null.

在单向链表中，每个节点只指向其后继。三个核心操作是插入（在头部、尾部或指定位置）、删除（按值或位置移除节点）和遍历（从头到尾访问每个节点）。在头部插入是 O(1)：创建新节点，将其 next 指针指向当前 head，然后更新 head。删除操作需要找到目标节点的前驱，更新其 next 指针以绕过目标节点，然后释放内存。遍历用一个临时指针逐步移动，直到变为 null。

• InsertAtHead(list, data): newNode <- new Node(data); newNode.next <- list.head; list.head <- newNode
• DeleteNode(list, target): IF list.head is null RETURN; IF list.head.data = target THEN list.head <- list.head.next; RETURN; ELSE prev <- list.head; WHILE prev.next != null AND prev.next.data != target DO prev <- prev.next; IF prev.next != null THEN prev.next <- prev.next.next

10. Doubly Linked Lists and Their Operations | 双向链表及其操作

A doubly linked list node has two pointers: one to the next node and one to the previous node. This bidirectional traversal enables more efficient deletion when only the node to be deleted is given – no need to scan for the predecessor. Insertion and deletion require updating both the next and previous pointers of adjacent nodes. The memory overhead is higher, but operations like reversing the list become simpler.

双向链表的节点有两个指针：一个指向下一个节点，一个指向前一个节点。这种双向遍历使得在只知道要删除的节点时，删除操作更高效 —— 无需遍历查找前驱。插入和删除需要同时更新相邻节点的 next 和 previous 指针。内存开销更大，但像反转列表这样的操作变得更简单。

11. Comparing Stacks, Queues and Linked Lists | 栈、队列与链表的比较

Each linear structure excels in specific scenarios. Stacks provide strict LIFO access ideal for recursive backtracking. Queues enforce FIFO and are indispensable for fair scheduling. Linked lists offer flexible dynamic storage with fast insertions and deletions, but at the cost of extra pointer memory and no random access. In A-Level exams, you may be asked to justify choosing a stack over a queue for parsing or to compare the trade-offs between array-based and linked-list-based implementations.

每种线性结构都在特定场景下表现出色。栈提供严格的 LIFO 访问，非常适合递归回溯。队列强制遵循 FIFO，对于公平调度不可或缺。链表提供灵活的动态存储，插入和删除速度快，但代价是额外的指针内存且不支持随机访问。在 A-Level 考试中，你可能需要说明在解析任务中为什么选择栈而不是队列，或者比较基于数组和基于链表的实现之间的权衡。

12. Exam Tips for Edexcel A-Level | Edexcel A-Level 考试技巧

When tackling structured programming questions, always begin by clearly identifying the data structure required. Draw a diagram to track pointer changes step by step. Write pseudocode using consistent indentation and variable names like ‘top’, ‘front’, ‘rear’, ‘head’ as defined in the Edexcel specification. If a question asks about overflow or underflow, always state the condition explicitly. Finally, practice tracing code for mixed operations – pushing and popping on a stack, or inserting and deleting in a linked list – to build fluency with pointer logic.

解答结构化编程题时，首先要明确所需的数据结构。用图示逐步跟踪指针的变化。书写伪代码时使用一致的缩进和符合 Edexcel 规范的变量名，如 ‘top’、’front’、’rear’、’head’。如果题目涉及溢出或下溢，务必明确陈述条件。最后，多练习混合操作的代码追踪 —— 如在栈上连续压入和弹出，或在链表中插入和删除 —— 以熟练掌握指针逻辑。

Published by TutorHao | Programming Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Object-Oriented Programming Concepts | 面向对象编程概念

Object-oriented programming (OOP) is a paradigm that organises software design around data, or objects, rather than functions and logic. In the Edexcel A Level Computer Science course, understanding OOP is crucial for developing robust, maintainable applications. This revision note covers key concepts including encapsulation, inheritance, polymorphism, and abstraction, providing clear definitions and practical examples aligned with the specification.

面向对象编程（OOP）是一种以数据或对象为中心组织软件设计的范式，而非围绕功能和逻辑。在Edexcel A Level计算机科学课程中，理解OOP对于开发健壮、可维护的应用程序至关重要。本复习笔记涵盖封装、继承、多态和抽象等关键概念，并提供与大纲相一致的清晰定义和实用示例。

1. Introduction to OOP | 面向对象编程简介

OOP models real-world entities as objects that have state (attributes) and behavior (methods). Unlike procedural programming, which emphasises sequences of instructions, OOP focuses on creating reusable components that interact with each other.

OOP将现实世界实体建模为具有状态（属性）和行为（方法）的对象。与强调指令序列的过程式编程不同，OOP侧重于创建可重用的、相互交互的组件。

The four main principles of OOP are encapsulation, inheritance, polymorphism, and abstraction. These principles help to reduce complexity, increase code reusability, and improve security.

OOP的四个主要原则是封装、继承、多态和抽象。这些原则有助于降低复杂性、提高代码可重用性和增强安全性。

2. Classes and Objects | 类与对象

A class is a blueprint or template that defines the attributes and methods common to a group of objects. It specifies what data the objects will hold and what operations they can perform.

类是定义一组对象共有属性和方法的蓝图或模板。它指定了对象将持有何种数据以及能够执行哪些操作。

An object is an instance of a class. When a class is defined, no memory is allocated until an object is created from it. Each object has its own unique state but shares the structure defined by the class.

对象是类的实例。定义类时不会分配内存，直到从该类创建对象。每个对象都有自己独特的状态，但共享类定义的结构。

3. Attributes and Methods | 属性与方法

Attributes (also called properties or fields) represent the data stored within an object. For example, a Car class might have attributes like colour, model, and speed.

属性（也称为特性或字段）表示对象内部存储的数据。例如，一个Car类可能有颜色、型号和速度等属性。

Methods define the behaviours that an object can perform. They are functions defined inside a class and can manipulate the object’s attributes. A Car class could have methods such as accelerate() or brake().

方法定义对象可执行的行为。它们是类内部定义的函数，可以操作对象的属性。一个Car类可能有accelerate()或brake()等方法。

4. Encapsulation | 封装

Encapsulation is the practice of hiding an object’s internal state and requiring all interaction to be performed through well-defined methods. It promotes data integrity and reduces unintended interference.

封装是隐藏对象内部状态并要求通过明确定义的方法进行所有交互的实践。它促进了数据完整性并减少了意外干扰。

In programming, encapsulation is typically achieved using access modifiers such as private and public. Attributes are often declared private while getter and setter methods provide controlled access.

在编程中，封装通常使用私有和公共等访问修饰符来实现。属性通常声明为私有的，而getter和setter方法提供受控访问。

5. Access Modifiers | 访问修饰符

Access modifiers determine the visibility of class members. Common modifiers include public, private, and protected. Public members are accessible from anywhere, private members are only accessible within the class itself, and protected members are accessible within the class and its subclasses.

访问修饰符决定了类成员的可见性。常见的修饰符包括public、private和protected。公共成员可以从任何地方访问，私有成员只能在类内部访问，受保护成员可以在类及其子类中访问。

Proper use of access modifiers is essential for encapsulation. By making attributes private, we can ensure that external code cannot directly modify the data in unexpected ways.

正确使用访问修饰符对于封装至关重要。通过将属性设为私有，我们可以确保外部代码无法以意外的方式直接修改数据。

6. Constructors | 构造函数

A constructor is a special method that is automatically called when an object is instantiated. It usually initialises the attributes of the object. The constructor has the same name as the class and no return type.

构造函数是一种特殊的方法，在实例化对象时自动调用。它通常初始化对象的属性。构造函数与类同名，且没有返回类型。

Many languages support multiple constructors through overloading. A default constructor takes no parameters, while parameterised constructors allow setting initial values at creation time.

许多语言通过重载支持多个构造函数。默认构造函数不带参数，而参数化构造函数允许在创建时设置初始值。

7. Inheritance | 继承

Inheritance allows a new class (subclass) to derive properties and behaviours from an existing class (superclass). It promotes code reuse and establishes a hierarchical relationship.

继承允许新类（子类）从现有类（超类）派生属性和行为。它促进了代码重用并建立了层次关系。

For example, a Vehicle superclass might define general attributes like speed and manufacturer. A Car subclass can inherit these and add specific attributes such as numberOfDoors.

例如，一个Vehicle超类可以定义速度和制造商等一般属性。Car子类可以继承这些属性，并添加特定属性如numberOfDoors。

In Edexcel A Level, you are expected to understand ‘is-a’ relationships, where a subclass object is also a type of the superclass. The subclass can override inherited methods to provide specialised functionality.

在Edexcel A Level中，你需要理解“is-a”关系，即子类对象也是超类的一种类型。子类可以重写继承的方法以提供专门的功能。

8. Polymorphism | 多态

Polymorphism literally means ‘many forms’. In OOP, it allows objects of different classes to be treated as objects of a common superclass, enabling a single interface to represent different underlying forms.

多态字面意思是“多种形态”。在OOP中，它允许将不同类的对象视为共同超类的对象，使一个接口可以代表不同的底层形式。

Method overriding is a key technique for achieving polymorphism. A subclass can provide its own implementation of a method that is already defined in the superclass. The correct method is chosen at runtime based on the actual object type, a process known as dynamic binding.

方法重写是实现多态的关键技术。子类可以提供超类中已定义方法的自己的实现。正确的方法在运行时根据实际对象类型选择，这一过程称为动态绑定。

Polymorphism promotes flexibility and extensibility. You can write code that works with superclass references, and it will automatically invoke the appropriate subclass behaviour without modification.

多态提高了灵活性和可扩展性。你可以编写使用超类引用的代码，它将在不修改的情况下自动调用适当的子类行为。

9. Overriding and Overloading | 方法重写与重载

Overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method signature (name and parameters) must be the same.

重写发生在子类提供其超类中已定义方法的特定实现时。方法签名（名称和参数）必须相同。

Overloading, on the other hand, refers to defining multiple methods with the same name but different parameter lists within the same class. This is not directly related to inheritance but is a form of compile-time polymorphism.

另一方面，重载指的是在同一个类中定义多个同名但参数列表不同的方法。这与继承没有直接关系，但属于编译时多态的一种形式。

Understanding the distinction is critical for designing flexible class hierarchies in OOP. Overriding enables dynamic behaviour based on the actual object, while overloading offers convenience by allowing methods to handle different types or numbers of arguments.

理解这一区别对于设计灵活的类层次结构至关重要。重写可根据实际对象启用动态行为，而重载通过允许方法处理不同类型或数量的参数提供便利。

10. Abstract Classes | 抽象类

An abstract class is a class that cannot be instantiated on its own and is designed to be a base class for other classes. It may contain abstract methods—methods without a body that must be implemented by non-abstract subclasses.

抽象类是不能独立实例化的类，旨在作为其他类的基类。它可以包含抽象方法——没有方法体的方法，这些方法必须由非抽象子类实现。

For instance, an abstract class Shape might declare an abstract method calculateArea(). Concrete subclasses like Circle and Rectangle must provide their own implementations. This enforces a common interface while allowing different behaviours.

例如，一个抽象类Shape可以声明一个抽象方法calculateArea()。像Circle和Rectangle这样的具体子类必须提供自己的实现。这在允许不同行为的同时强制规定了公共接口。

Abstract classes are useful for defining a template for a group of related classes. They support polymorphism and prevent direct creation of generic objects that lack specific functionality.

抽象类可用于定义一组相关类的模板。它们支持多态，并防止直接创建缺乏特定功能的泛化对象。

Published by TutorHao | Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Combined Operations in Programming: A Bitwise Approach with 204 | 编程中的组合运算：以204为例的位操作

In A-Level Programming, mastering combined operations – particularly bitwise manipulation – is essential for efficient, low-level data handling. This article explores the power of combining logical, arithmetic and bitwise operators, using the decimal number 204 (0xCC, 0b11001100) as a unifying example. We will examine how to set, clear, toggle and mask bits, and how shift operators accelerate multiplication and division. Each technique is paired with real-world coding relevance and Edexcel exam-ready reasoning.

在A-Level编程中，掌握组合运算——尤其是位操作——对高效、底层的数据处理至关重要。本文以十进制数204（0xCC，0b11001100）作为贯穿示例，探讨如何组合逻辑、算术与位运算符。我们将演示位的设置、清除、翻转与掩码，以及移位运算符如何加速乘除运算。每个技巧都配有实际编码场景与适合爱德思考试的推理过程。

1. Introduction to Combined Operations | 组合运算简介

Combined operations refer to the use of multiple operators within a single expression to achieve a complex logical or arithmetic result. In programming, this often involves mixing relational, arithmetic and bitwise operators. Proper understanding of operator precedence and associativity is vital to avoid subtle bugs. For instance, the expression (x & 0xF0) >> 4 + 3 might not behave as expected without parentheses, because + has higher precedence than >>.

组合运算指在单个表达式中使用多个运算符以实现复杂的逻辑或算术结果。编程中常涉及混合关系、算术与位运算符。正确理解运算符优先级与结合性对避免隐晦错误至关重要。例如，表达式 (x & 0xF0) >> 4 + 3 若不加括号可能不如预期运行，因为 + 的优先级高于 >>。

2. Understanding Bitwise Operators | 理解位运算符

Bitwise operators work directly on the binary representations of integers. The primary operators in languages like Python, Java and C++ are: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift) and >> (right shift). These operators treat each bit independently, making them ideal for flags, masks, graphics and embedded systems. Edexcel specifications expect you to trace and predict the outcome of such operations on given bit patterns.

位运算符直接作用于整数的二进制表示。在Python、Java和C++等语言中，主要运算符包括：&（与）、|（或）、^（异或）、~（非）、<<（左移）和>>（右移）。这些运算符独立处理每个比特位，使其非常适合标志、掩码、图形与嵌入式系统。爱德思大纲要求你能够跟踪并预测此类操作在给定比特模式上的结果。

3. Binary Representation of 204 | 204的二进制表示

Decimal 204 converts to binary as 11001100, which is 0xCC in hexadecimal. This pattern is symmetric and rich with alternating blocks of 1s and 0s, making it an excellent specimen for bit manipulations. In 8-bit representation, bit positions from left (most significant) to right (least significant) are b7=1, b6=1, b5=0, b4=0, b3=1, b2=1, b1=0, b0=0.

十进制204转换为二进制为11001100，十六进制为0xCC。该模式对称且含有交替的1和0块，使其成为位操作的绝佳范例。在8位表示中，从左边（最高有效位）到右边（最低有效位）的位位置为：b7=1, b6=1, b5=0, b4=0, b3=1, b2=1, b1=0, b0=0。

4. Setting Specific Bits Using OR | 使用 OR 设置特定位

The bitwise OR operator | is used to set (turn to 1) specific bits. To set the lower nibble (bits 3-0) of a number, you OR it with 0x0F (00001111). If we take 204 (11001100) and OR with 0x0F, the result is 11001111 (decimal 207). This leaves the high nibble untouched while forcing the low nibble to all 1s.

位运算符|（或）用于设置（变为1）特定位。要将一个数的低半字节（第3-0位）设置为1，可将其与0x0F（00001111）进行OR运算。若用204（11001100）与0x0F进行OR，结果为11001111（十进制207）。此操作保持高半字节不变，同时将低半字节强制变为全1。

result = 204 | 0x0F   # 11001100 | 00001111 = 11001111 (207)

5. Clearing Bits with AND and NOT | 使用 AND 和 NOT 清除位

To clear (turn to 0) certain bits, you use AND with a mask where target bits are 0, typically created by complementing (~) the set mask. To clear the high nibble of 204, AND it with 0x0F (00001111). The operation 204 & 0x0F yields 00001100 (decimal 12), effectively zeroing out bits 7-4.

要清除（变为0）某些位，你需要用一个目标位为0的掩码进行AND运算，通常通过反转（~）设置掩码来创建。要清除204的高半字节，将其与0x0F（00001111）进行AND运算。操作 204 & 0x0F 得到00001100（十进制12），有效将第7-4位清零。

result = 204 & 0x0F   # 11001100 & 00001111 = 00001100 (12)

6. Toggling Bits via XOR | 通过 XOR 翻转位

XOR (^) flips bits where the mask contains 1s. XOR with 0xFF (or -1 in two’s complement) toggles all bits, producing the one’s complement. For 204: 204 ^ 0xFF = 00110011 (51). A more targeted toggle: 204 ^ 0xF0 flips the high nibble, giving 00111100 (60). This is useful in animation and encryption algorithms.

XOR（^）在掩码为1的位置翻转对应的位。与0xFF（或补码中的-1）进行XOR可翻转所有位，产生反码。对于204：204 ^ 0xFF = 00110011（51）。更有针对性的翻转：204 ^ 0xF0 会翻转高半字节，得到00111100（60）。这在动画与加密算法中很有用。

toggled = 204 ^ 0xF0  # 11001100 ^ 11110000 = 00111100 (60)

7. Bit Masking Techniques | 位掩码技术

Bit masking involves extracting, setting or clearing a group of bits using a mask value. The mask is designed such that desired bits are preserved while others are suppressed. For instance, to extract bits 5-2 from 204 (11001100), you can right-shift and then mask: (204 >> 2) & 0x0F = (00110011) & 0x0F = 00000011 (decimal 3). This technique underpins many low-level data parsing tasks.

位掩码技术涉及使用掩码值来提取、设置或清除一组位。掩码的设计确保需要的位被保留，其他被抑制。例如，从204（11001100）中提取第5-2位，你可以先右移再掩码：(204 >> 2) & 0x0F = (00110011) & 0x0F = 00000011（十进制3）。该技术是许多底层数据解析任务的基础。

8. Shift Operators for Efficient Multiplication/Division | 移位运算符实现高效乘除

Left shift (<<) multiplies a number by 2ⁿ; right shift (>>) divides by 2ⁿ (integer division). 204 << 1 = 408 (×2), 204 << 2 = 816 (×4). Right shift: 204 >> 2 = 51. When combined with masking, you can implement quick fixed-point arithmetic. Note: right shift on signed integers is implementation-defined in some languages; logical vs arithmetic shift matters.

左移（<<）将数字乘以2ⁿ；右移（>>）除以2ⁿ（整数除法）。204 << 1 = 408（×2），204 << 2 = 816（×4）。右移：204 >> 2 = 51。结合掩码使用时，可以实现快速的定点算术。注意：有符号整数的右移在某些语言中是实现定义的；逻辑移位与算术移位有区别。

9. Combining Arithmetic and Bitwise Operations | 组合算术与位运算

Mixing arithmetic and bitwise operators can produce compact, efficient code. For example, to round up to the nearest multiple of 16, use (num + 15) & ~15. Applying to 204: (204+15)=219, ~15 is …11110000 (depending on word size), yielding 208. This approach is common in memory alignment and buffer management. Always use parentheses to enforce intended order because bitwise operators often have lower precedence than arithmetic.

混合算术与位运算符可以生成紧凑高效的代码。例如，要向上舍入到最接近的16的倍数，可使用 (num + 15) & ~15。应用于204：(204+15)=219，~15 为…11110000（取决于字长），结果为208。此方法常见于内存对齐与缓冲区管理。务必使用括号以强制执行预期顺序，因为位运算符的优先级常低于算术运算符。

10. Practical Example: Extracting Color Channels | 实践示例：提取颜色通道

In graphics programming, a 24-bit RGB value stores red, green and blue in a single integer. Suppose we have a color encoded as 0xCC34A0. The red channel is the high byte: (color >> 16) & 0xFF = 0xCC (204). Green: (color >> 8) & 0xFF = 0x34 (52). Blue: color & 0xFF = 0xA0 (160). This demonstrates combined shift and mask operations, directly examinable under data representation and bitwise manipulation topics.

在图形编程中，24位RGB值用单个整数存储红、绿、蓝通道。假设有一颜色编码为0xCC34A0。红色通道是高字节：(color >> 16) & 0xFF = 0xCC (204)。绿色：(color >> 8) & 0xFF = 0x34 (52)。蓝色：color & 0xFF = 0xA0 (160)。这展示了组合移位与掩码操作，直接对应数据表示与位操作主题的考试要求。

11. Common Pitfalls and Debugging Tips | 常见陷阱与调试技巧

• Operator Precedence: Bitwise &, ^, | have lower precedence than == and !=. Use parentheses liberally. 运算符优先级：位运算 &、^、| 的优先级低于 == 和 !=，应大量使用括号。
• Sign Extension: Right-shifting a negative number may insert 1s (arithmetic shift), breaking bit-mask logic. Use unsigned types if available. 符号扩展：对负数右移可能会插入1（算术移位），破坏掩码逻辑。若可能请使用无符号类型。
• Mask Width: Ensure masks match the variable width (8, 16, 32 bits) to prevent unintended high-order bit retention. 掩码宽度：确保掩码与变量宽度匹配（8、16、32位），防止意外保留高位。
• Debugging: Print values in binary or hex using format specifiers (e.g., bin() in Python, printf(“%x”) in C) to visualise bit patterns. 调试：使用格式化说明符（如Python的bin()，C的printf(“%x”)）以二进制或十六进制打印值，可视化位模式。

12. Summary and Key Takeaways | 总结与关键要点

Combined bitwise operations empower programmers to write compact, high-performance code. The number 204 has served as our demonstration canvas, highlighting how OR, AND, XOR, shifts and masks interact. From setting and clearing nibbles to extracting RGB channels, these techniques are directly aligned with Edexcel A-Level programming assessment objectives. Cultivate the habit of tracing operations on paper to internalise bit-level reasoning.

组合位运算使程序员能够编写紧凑、高性能的代码。数字204是我们的演示画布，突出了OR、AND、XOR、移位和掩码如何相互作用。从设置和清除半字节到提取RGB通道，这些技巧直接符合爱德思A-Level编程的评估目标。培养在纸上跟踪操作的习惯，以内化位级推理。

Published by TutorHao | Programming Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Process Scheduling in Operating Systems | 操作系统中的进程调度

In any multitasking operating system, the CPU must switch between processes rapidly to create the illusion of parallelism. Process scheduling is the mechanism that decides which process gets the CPU, when, and for how long. It is a core topic in A‑Level Computer Science, directly influencing system performance, responsiveness, and fairness.

在任何多任务操作系统中，CPU 必须在各个进程之间快速切换，以营造并行处理的错觉。进程调度正是决定哪个进程获得 CPU、何时获得以及获得多长时间的核心机制。这是 A‑Level 计算机科学中的关键主题，直接影响系统性能、响应速度和公平性。

1. The Role of the Scheduler | 调度器的角色

The scheduler is a component of the operating system kernel that selects the next process to run from the ready queue. Its main objectives are to keep the CPU busy, minimise waiting time, maximise throughput, and ensure fair access for all processes.

调度器是操作系统内核的一个组件，负责从就绪队列中选择下一个要运行的进程。其主要目标是保持 CPU 忙碌、最小化等待时间、最大化吞吐量，并确保所有进程公平访问 CPU。

2. Preemptive vs Non‑preemptive Scheduling | 抢占式与非抢占式调度

Non‑preemptive scheduling allows a process to run until it voluntarily yields the CPU, either by terminating or entering a waiting state. Preemptive scheduling can interrupt a running process and force a context switch, typically triggered by a timer interrupt or a higher‑priority process becoming ready.

非抢占式调度允许进程一直运行，直到它主动放弃 CPU（例如终止或进入等待状态）。抢占式调度可以中断正在运行的进程并强制进行上下文切换，这通常由定时器中断或更高优先级的进程变为就绪状态触发。

3. First Come First Served (FCFS) | 先来先服务

FCFS is the simplest scheduling algorithm: processes are executed in the order they arrive in the ready queue. It is non‑preemptive and easy to implement with a FIFO data structure. However, it suffers from the “convoy effect”, where short processes get stuck behind long CPU‑bound processes.

FCFS 是最简单的调度算法：进程按其到达就绪队列的顺序执行。它是非抢占式的，使用 FIFO 数据结构即可实现。但其存在“护航效应”，即短进程被长 CPU 密集型进程阻挡，导致平均等待时间变长。

4. Shortest Job First (SJF) | 最短作业优先

SJF selects the process with the smallest estimated CPU burst time next. It is provably optimal in minimising average waiting time. Preemptive SJF (also called Shortest Remaining Time First, SRTF) further reduces waiting time. The main challenge is predicting burst lengths, which can be done using exponential averaging.

SJF 选择下一个预计 CPU 执行时间最短的进程。它在最小化平均等待时间上是可证明最优的。抢占式 SJF（又称最短剩余时间优先，SRTF）能进一步缩短等待时间。主要难点在于预测执行时长，可借助指数平均法进行估算。

5. Priority Scheduling | 优先级调度

Each process is assigned a priority, and the CPU is allocated to the highest‑priority process in the ready queue. Priority scheduling can be preemptive or non‑preemptive. A major risk is starvation, where low‑priority processes may never execute. Ageing (gradually increasing priority over time) solves this problem.

每个进程被分配一个优先级，CPU 分配给就绪队列中优先级最高的进程。优先级调度可以是抢占式也可以是非抢占式。一个主要风险是饥饿现象，即低优先级进程可能永远得不到执行。老化机制（随时间逐渐提升优先级）可以解决此问题。

6. Round Robin (RR) Scheduling | 轮转调度

Round Robin is a preemptive algorithm designed for time‑sharing systems. Each process is given a small time quantum (typically 10–100 ms). The CPU cycles through the ready queue, allowing each process to run for at most one quantum. If a process does not finish, it is returned to the tail of the queue.

轮转调度是一种为分时系统设计的抢占式算法。每个进程获得一小段的时间片（通常为 10–100 毫秒）。CPU 循环遍历就绪队列，每个进程最多运行一个时间片。若进程未完成，则被放回队列尾部。

7. Performance Trade‑offs of RR | 轮转调度的性能权衡

The choice of time quantum critically impacts performance. Too large a quantum makes RR behave like FCFS; too small a quantum causes excessive context‑switching overhead. A common guideline is that 80% of CPU bursts should be shorter than the quantum to maintain good response times and efficiency.

时间片的选择对性能至关重要。时间片过大，RR 会退化为 FCFS；时间片过小，上下文切换开销会过高。常见的指导原则是让 80% 的 CPU 突发时间短于时间片，以保持良好的响应时间和效率。

8. Multilevel Queue Scheduling | 多级队列调度

The ready queue is partitioned into separate queues based on process type (e.g., foreground interactive, background batch). Each queue has its own scheduling algorithm, and there is fixed priority scheduling between queues. This allows the system to prioritise interactive tasks while still serving batch jobs.

就绪队列根据进程类型（例如前台交互式、后台批处理）被划分为多个独立队列。每个队列可以使用自己的调度算法，队列之间采用固定优先级调度。这样系统可以优先处理交互式任务，同时仍能为批处理作业服务。

9. Multilevel Feedback Queue (MLFQ) | 多级反馈队列

MLFQ adds the ability to move processes between queues based on their CPU‑use history. A process that uses too much CPU time in a high‑priority queue is demoted to a lower‑priority queue; a process that waits too long can be promoted. This adaptive scheme balances responsiveness and throughput without prior knowledge of process behaviour.

MLFQ 增加了根据 CPU 使用历史在队列间移动进程的能力。在高优先级队列中使用过多 CPU 时间的进程会被降级到更低优先级的队列；等待过久的进程可以被提升。这种自适应方案在无需预先了解进程行为的情况下，能很好地平衡响应性和吞吐量。

10. Comparison of Scheduling Algorithms | 调度算法对比

This table highlights that no single algorithm is universally best; the choice depends on system goals, workload characteristics, and the balance between fairness and efficiency.

上表说明没有哪一种算法是普遍最优的；选择取决于系统目标、工作负载特征以及公平性与效率之间的平衡。

11. Real‑World Implementations | 实际应用中的实现

Modern operating systems use hybrid approaches. Linux employs a Completely Fair Scheduler (CFS) based on red‑black trees, approximating ideal fair scheduling. Windows uses a priority‑based scheme with 32 levels and automatic priority boosting. These real‑world schedulers incorporate MLFQ concepts to serve interactive, batch, and real‑time processes.

现代操作系统采用混合式方法。Linux 使用基于红黑树的完全公平调度器 (CFS)，试图逼近理想的公平调度。Windows 使用基于 32 级优先级并自动提升优先级的方案。这些实际调度器都融入了 MLFQ 的思想，以同时服务交互式、批处理和实时进程。

12. Summary and Exam Tips | 总结与备考提示

Process scheduling is a fundamental OS responsibility. Be prepared to calculate average waiting times and turnaround times for FCFS, SJF, Priority, and RR given a set of processes with arrival and burst times. Remember to distinguish between preemptive and non‑preemptive versions and to explain starvation/ageing clearly.

进程调度是操作系统的基本职责。考试中，能够针对一组给定到达时间和执行时间的进程，计算 FCFS、SJF、优先级调度和 RR 的平均等待时间和周转时间。记住区分抢占式与非抢占式版本，并能清晰地解释饥饿和老化机制。

Published by TutorHao | Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Edexcel A-Level Programming Fundamentals: Data Types, Operators and Control Structures | Edexcel A-Level编程基础：数据类型、运算符与控制结构

Programming forms the backbone of the Edexcel A-Level Computer Science specification, particularly in Paper 1: Principles of Computer Science. Mastery of fundamental concepts such as data types, operators, and control structures is essential for designing algorithms, writing pseudocode, and developing solutions in a high-level language like Python. This article provides a thorough revision of these building blocks, aligned with the Edexcel assessment objectives.

编程是Edexcel A-Level计算机科学课程（特别是Paper 1：计算机科学原理）的基础。掌握数据类型、运算符和控制结构等基本概念，对于设计算法、编写伪代码以及使用 Python 等高级语言开发解决方案至关重要。本文对这些构建模块进行全面梳理，紧扣 Edexcel 考核目标。

1. Introduction to Programming Concepts | 编程概念概述

In the Edexcel syllabus, programming is assessed through both theoretical understanding and practical application. Candidates are expected to interpret, trace, and write algorithms using Edexcel pseudocode or Python. The core programming constructs – sequence, selection, and iteration – are universal, but the precise syntax varies. A clear grasp of how data flows and how decisions are made in a program is vital for tackling algorithm design, dry runs, and debugging tasks in the exam.

在 Edexcel 课程大纲中，编程既考查理论理解，也考查实际应用。考生需要使用 Edexcel 伪代码或 Python 来解释、追踪和编写算法。核心编程结构——顺序、选择和迭代——是通用的，但具体语法有所不同。清晰掌握数据如何流动以及程序如何做出决策，对于应对考试中的算法设计、干运行和调试任务至关重要。

2. Data Types and Variables | 数据类型与变量

Data types classify the kind of information a variable can hold. Edexcel recognises five primitive types: INTEGER (whole numbers), REAL (numbers with decimals, also called float), BOOLEAN (TRUE/FALSE), CHAR (a single character), and STRING (a sequence of characters). Declaring variables explicitly helps the programmer reason about memory and type compatibility. In pseudocode, this is done as DECLARE age : INTEGER. Variables are mutable stores that can be updated during execution.

数据类型对变量可保存的信息种类进行了分类。Edexcel 认可五种原始类型：INTEGER（整数）、REAL（带小数的数字，也称为浮点数）、BOOLEAN（TRUE/FALSE）、CHAR（单个字符）和 STRING（字符序列）。显式声明变量有助于程序员思考内存和类型兼容性。在伪代码中，声明方式为 DECLARE age : INTEGER。变量是可更改的存储空间，可在执行期间更新。

Constant values cannot be altered once set; they are declared with CONSTANT pi = 3.14. Casting allows conversion between compatible types, e.g., turning a REAL into an INTEGER truncates the fractional part. Common string operations include concatenation using +, finding length with LEN(str), and extracting substrings with LEFT, RIGHT, or MID. Understanding these operations is crucial for processing text and user input efficiently.

常量值一旦设定便无法更改；使用 CONSTANT pi = 3.14 声明。类型转换（casting）允许在兼容类型之间进行转换，例如将 REAL 转为 INTEGER 会截断小数部分。常见字符串操作包括使用 + 进行拼接，用 LEN(str) 获取长度，以及用 LEFT、RIGHT 或 MID 提取子串。理解这些操作对于高效处理文本和用户输入至关重要。

3. Arithmetic Operators | 算术运算符

Arithmetic operators perform mathematical computations. The Edexcel pseudocode uses + (addition), – (subtraction), * (multiplication), / (division) and ^ (exponentiation). For integer-specific operations, DIV returns the quotient and MOD returns the remainder. For instance, 17 DIV 5 = 3, and 17 MOD 5 = 2. These are particularly useful in algorithms dealing with cycles, digit extraction, and hashing. Division (/) with REAL operands yields a REAL result, while integer division truncates.

算术运算符执行数学计算。Edexcel 伪代码使用 +（加）、-（减）、*（乘）、/（除）和 ^（幂）。对于整数特有操作，DIV 返回商，MOD 返回余数。例如，17 DIV 5 = 3，17 MOD 5 = 2。这些运算符在处理循环、数字提取和哈希算法中特别有用。REAL 型操作数的除法（/）产生 REAL 结果，而整数除法会截断。

Care must be taken with operator precedence; exponentiation is evaluated first, followed by multiplication, division, DIV, MOD, and finally addition and subtraction. Parentheses override the default order and should be used liberally to avoid ambiguity. In an exam dry-run question, forgetting precedence can lead to an incorrect trace table.

必须注意运算符优先级；首先计算幂运算，然后是乘、除、DIV、MOD，最后是加和减。括号覆盖默认顺序，应自由使用以避免歧义。在考试的干运行题目中，忘记优先级可能导致追踪表错误。

4. Relational and Boolean Operators | 关系运算符与布尔运算符

Relational operators compare two values and return a Boolean result. Standard operators are = (equal), <> or != (not equal), <, >, <=, and >=. Boolean operators combine or negate conditions using AND, OR, and NOT. In Python, these are written in lowercase. Short-circuit evaluation improves efficiency: in an AND expression, if the left operand is FALSE, the right is not evaluated because the whole expression must be FALSE.

关系运算符比较两个值并返回布尔结果。标准运算符有 =（等于）、<> 或 !=（不等于）、<、>、<= 和 >=。布尔运算符使用 AND、OR 和 NOT 组合或取反条件。在 Python 中它们使用小写。短路求值提高了效率：在 AND 表达式中，如果左操作数为 FALSE，则不会计算右侧，因为整个表达式必定为 FALSE。

Complex conditions can be built using parentheses for clarity. Examiners expect candidates to construct correct conditional expressions and to simplify them using logical identities, such as De Morgan’s laws: NOT (A AND B) is equivalent to (NOT A) OR (NOT B).

复杂条件可通过括号清晰构建。考官期望考生能构造正确的条件表达式，并利用逻辑恒等式（如德摩根律：NOT (A AND B) 等价于 (NOT A) OR (NOT B)）进行简化。

5. Operator Precedence | 运算符优先级

Operator precedence defines the order in which operations are evaluated. In Edexcel pseudocode, the hierarchy (highest to lowest) is: parentheses, arithmetic operators (^, then * / DIV MOD, then + -), relational operators, NOT, AND, and finally OR. When in doubt, use brackets to make the intended order explicit.

运算符优先级定义了运算的求值顺序。在 Edexcel 伪代码中，层次结构（从高到低）为：括号、算术运算符（^，然后是 * / DIV MOD，然后是 + -）、关系运算符、NOT、AND，最后是 OR。如有疑问，请使用括号使意图顺序明确。

For example, the expression NOT 5 > 3 AND 2 < 4 would be evaluated as (NOT (5 > 3)) AND (2 < 4). First the relational operators are evaluated, then NOT, then AND. Becoming fluent in precedence ensures that dry-run trace tables are accurate, a skill frequently tested.

例如，表达式 NOT 5 > 3 AND 2 < 4 将被求值为 (NOT (5 > 3)) AND (2 < 4)。首先计算关系运算符，再是 NOT，然后是 AND。熟练运用优先级可确保干运行追踪表准确无误，这是经常考查的技能。

6. Sequence and Selection: IF Statements | 顺序与选择：IF 语句

Sequence is the default mode: statements execute one after another. Selection introduces decision-making. The single-branch IF condition THEN … ENDIF runs a block only when the condition is TRUE. A dual-branch IF … ELSE … ENDIF provides an alternate path when the condition is FALSE. Edexcel pseudocode uses explicit ENDIF, while Python employs indentation without a closing keyword. Understanding block structure is essential for tracing and writing correct logic.

顺序是默认模式：语句逐条执行。选择引入了决策机制。单分支 IF condition THEN … ENDIF 仅在条件为 TRUE 时运行一个代码块。双分支 IF … ELSE … ENDIF 在条件

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

📚 Mastering Combined Operations: Arithmetic, Relational, and Logical Operations | 掌握组合运算：算术、关系与逻辑运算

In A-Level Edexcel Programming, understanding and correctly applying combined operations is essential. Operations such as arithmetic, relational, logical, and bitwise form the core of decision-making and data manipulation in code. This article provides a thorough exploration of these operations, including their precedence, evaluation, and practical use in Python, the language often used in the Edexcel specification.

在A-Level Edexcel编程中，理解并正确应用组合运算至关重要。算术、关系、逻辑和位运算构成了代码中决策和数据处理的核心。本文全面探讨这些操作，包括它们的优先级、求值方式以及在Edexcel规范中常用的Python语言中的实际应用。

1. Arithmetic Operations | 算术运算

Arithmetic operations perform basic mathematical calculations. In Python, the main arithmetic operators are addition (+), subtraction (-), multiplication (*), division (/), floor division (//), modulus (%), and exponentiation (**). For example, 7 // 2 evaluates to 3, and 2 ** 3 yields 8.

算术运算执行基本的数学计算。在Python中，主要的算术运算符有加法 (+)、减法 (-)、乘法 (*)、除法 (/)、整除 (//)、取模 (%) 和幂运算 (**)。例如，7 // 2 的结果为 3，2 ** 3 得到 8。

Division (/) always returns a float, while floor division (//) truncates towards negative infinity. Modulus (%) gives the remainder of a division, which is extremely useful for tasks like checking divisibility or cycling through arrays.

除法 (/) 始终返回浮点数，而整除 (//) 向负无穷方向截断。取模 (%) 返回除法余数，这在检查整除性或循环遍历数组等任务中非常有用。

In many algorithms, integer arithmetic must be handled with care to avoid overflow, though Python integers have arbitrary precision. However, understanding the difference between true division and floor division is vital for porting code from other languages.

在许多算法中，必须小心处理整数运算以避免溢出，尽管Python整数具有任意精度。然而，理解真除法和整除之间的区别对于从其他语言移植代码至关重要。

2. Relational Operations | 关系运算

Relational operators compare two values and produce a Boolean result (True or False). The standard operators are equal to (==), not equal to (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=). These are fundamental in forming conditions.

关系运算符比较两个值并产生布尔结果（True 或 False）。标准运算符包括等于 (==)、不等于 (!=)、大于 (>)、小于 (<)、大于等于 (>=) 和小于等于 (<=)。它们是构成条件的基础。

When combined with arithmetic operators, relational expressions can test computed values. For instance, (a + b) >= c checks if the sum of a and b is at least c. It is crucial to distinguish = (assignment) from == (equality test) to avoid logical errors.

当与算术运算符结合时，关系表达式可以测试计算出的值。例如，(a + b) >= c 检查 a 与 b 之和是否至少为 c。务必区分 =（赋值）和 ==（相等测试），以避免逻辑错误。

Floating-point comparisons can be tricky due to precision errors. Direct equality of floats is discouraged; instead, check if the absolute difference is within a small tolerance, often using the expression abs(a – b) < 1e-9.

由于精度误差，浮点数比较可能很棘手。不建议直接对浮点数进行相等判断；而应检查绝对差是否在很小的容差范围内，通常使用表达式 abs(a – b) < 1e-9。

3. Logical Operations | 逻辑运算

Logical operators combine Boolean values. In Python, the keywords are and, or, and not. They follow short-circuit evaluation: for a and b, if a is False, b is not evaluated. Similarly, for a or b, if a is True, b is skipped.

逻辑运算符组合布尔值。在Python中，关键词是 and、or 和 not。它们遵循短路求值：对于 a and b，如果 a 为 False，则不计算 b。类似地，对于 a or b，如果 a 为 True，则跳过 b。

Below is the truth table for basic logical operations:

以下是基本逻辑运算的真值表：

更多咨询请联系16621398022（同微信）

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def show_info(self):
        return f"{self.name} achieved grade {self.grade}"

s1 = Student("Ali", "A")
print(s1.show_info())

class BankAccount:
    def __init__(self, initial):
        self.__balance = initial

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

class Vehicle:
    def __init__(self, make):
        self.make = make

class Car(Vehicle):
    def __init__(self, make, model):
        super().__init__(make)
        self.model = model

    def details(self):
        return f"{self.make} {self.model}"

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        return "Drawing a circle"

class Square(Shape):
    def draw(self):
        return "Drawing a square"

shapes = [Circle(), Square()]
for s in shapes:
    print(s.draw())

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Bark"

# a = Animal()  # this would raise TypeError
d = Dog()
print(d.sound())

class Loggable:
    def log(self, msg):
        print(f"LOG: {msg}")

class Database:
    def save(self, data):
        print("Saving", data)

class App(Loggable, Database):
    def run(self):
        self.log("App started")
        self.save("result")

CLASS Dog
    PRIVATE name : STRING
    PUBLIC PROCEDURE new(givenName)
        name ← givenName
    ENDPROCEDURE
    PUBLIC FUNCTION bark()
        RETURN name + " says woof!"
    ENDFUNCTION
ENDCLASS

myDog ← NEW Dog("Rex")
OUTPUT myDog.bark()

CLASS BankAccount
    PRIVATE balance : REAL
    PUBLIC PROCEDURE deposit(amount : REAL)
        IF amount > 0 THEN
            balance ← balance + amount
        ENDIF
    ENDPROCEDURE
    PUBLIC FUNCTION getBalance() RETURNS REAL
        RETURN balance
    ENDFUNCTION
ENDCLASS

CLASS Cat INHERITS Animal
    PUBLIC FUNCTION speak() RETURNS STRING
        RETURN "Meow"
    ENDFUNCTION
ENDCLASS

animals ← [NEW Dog("Fido"), NEW Cat("Whiskers")]
FOR EACH animal IN animals
    OUTPUT animal.speak()
ENDFOR

ABSTRACT CLASS Shape
    PUBLIC ABSTRACT FUNCTION area() RETURNS REAL
ENDCLASS

CLASS Circle INHERITS Shape
    PRIVATE radius : REAL
    PUBLIC FUNCTION area() RETURNS REAL
        RETURN 3.14159 * radius * radius
    ENDFUNCTION
ENDCLASS

10. Exam-Focused OOP Design Principles | 面向考试的 OOP 设计原则

Edexcel will expect you to apply good design principles: encapsulation of what varies, favour composition over inheritance where appropriate, and program to interfaces not implementations. Questions often provide a scenario (e.g., a vehicle rental system) and ask you to design a class diagram or pseudocode. You must be able to identify which classes should inherit, which should be abstract, and where polymorphism is useful.

Edexcel 期望你运用良好的设计原则：封装变化的部分，在适当时优先使用组合而非继承，并面向接口编程而不是面向实现。考题常常提供一个场景（如车辆租赁系统），要求你设计类图或伪代码。你必须能够识别哪些类应该继承，哪些应该是抽象的，以及多态在何处发挥作用。

11. Common Pitfalls and Tips for Edexcel OOP Questions | Edexcel OOP 考题常见陷阱与技巧

Pitfall: confusing aggregation and composition. Pitfall: forgetting to make attributes PRIVATE, thus breaking encapsulation. Pitfall: assuming inheritance always simplifies code — use it only for genuine ‘is-a’ relationships. Tip: always consider access modifiers and explain the rationale. Tip: in long-answer pseudocode, include validation in setters. Edexcel rewards clear reasoning and syntactically correct class definitions.

陷阱：混淆聚合与组合。陷阱：忘记将属性设为 PRIVATE，从而破坏封装。陷阱：假设继承总能简化代码——仅在真正的“is-a”关系中使用它。技巧：始终考虑访问修饰符并解释其原因。技巧：在长篇伪代码中，在设置器中包含验证。Edexcel 青睐清晰的推理和语法正确的类定义。

Published by TutorHao | Programming Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）