计算机编程 - 快速指南

---

---

计算机编程 - 概述

计算机程序介绍

在深入学习计算机编程之前，让我们先了解一下计算机程序及其作用。

计算机程序是用计算机编程语言编写的一系列指令，用于让计算机执行指定的任务。

我们在上述定义中使用了两个重要的术语：

• 指令序列
• 计算机编程语言

为了理解这些术语，假设有人问你如何去附近的肯德基。你究竟会怎么做才能告诉他去肯德基的路呢？

你会使用人类语言来告诉他去肯德基的路，例如：

先直走，走半公里后，在红绿灯处左转，然后继续行驶一公里，你就会在右边看到肯德基。

在这里，你使用了英语来提供到达肯德基的分步指南。如果按照以下顺序执行这些步骤，你就能到达肯德基：

1.	Go straight
2.	Drive half kilometer
3.	Take left
4.	Drive around one kilometer
5.	Search for KFC at your right side

现在，尝试将这种情况与计算机程序进行映射。上述指令序列实际上是一个用**英语**编写的**人类程序**，它指示如何从给定的起点到达肯德基。同样的序列可以用西班牙语、印地语、阿拉伯语或任何其他人类语言来表达，前提是寻求方向的人知道其中任何一种语言。

现在，让我们回到计算机程序，它是一系列用计算机语言编写的指令，用于让计算机执行指定的任务。下面是用**Python**编程语言编写的一个简单程序：

print "Hello, World!"

上述计算机程序指示计算机在屏幕上打印“Hello, World！”。

• 计算机程序也称为**计算机软件**，它可以包含从两行到数百万行指令。

• 计算机程序指令也称为程序源代码，**计算机编程**也称为**程序编码**。

• 没有计算机程序的计算机只是一个空盒子；正是程序使计算机变得活跃。

正如我们开发了许多语言来进行相互交流一样，计算机科学家也开发了几种计算机编程语言来向计算机提供指令（即编写计算机程序）。我们将在后续章节中看到几种计算机编程语言。

计算机编程介绍

如果你理解了什么是**计算机程序**，那么我们可以说：*编写计算机程序的行为称为计算机编程*。

正如我们前面提到的，有数百种编程语言可用于编写计算机程序，以下是一些例子：

• Java
• C
• C++
• Python
• PHP
• Perl
• Ruby

计算机程序的用途

如今，计算机程序几乎应用于各个领域，包括家庭、农业、医疗、娱乐、国防、通信等。以下是计算机程序的一些应用：

• MS Word、MS Excel、Adobe Photoshop、Internet Explorer、Chrome等都是计算机程序的例子。

• 计算机程序被用于开发电影制作中的图形和特效。

• 计算机程序被用于执行超声波、X光和其他医学检查。

• 计算机程序被用于我们的手机进行短信、聊天和语音通信。

计算机程序员

能够编写计算机程序的人，或者换句话说，能够进行计算机编程的人，称为计算机程序员。

根据计算机编程语言的专业知识，我们可以将计算机程序员命名如下：

• C 程序员
• C++ 程序员
• Java 程序员
• Python 程序员
• PHP 程序员
• Perl 程序员
• Ruby 程序员

算法

从编程的角度来看，**算法**是解决任何问题的逐步过程。算法是一种用有限的、明确定义的指令表达的有效方法。

因此，计算机程序员在编写实际代码之前会列出解决问题所需的所有步骤。下面是一个从给定数字列表中找出最大数字的简单算法示例：

1. Get a list of numbers L1, L2, L3....LN
2. Assume L1 is the largest, Largest = L1
3. Take next number Li from the list and do the following
4. If Largest is less than Li
5. Largest = Li
6. If Li is last number from the list then
7. Print value stored in Largest and come out
8. Else repeat same process starting from step 3

上述算法以一种粗略的方式编写，以帮助初学者理解这个概念。随着你进入计算机编程的高级阶段，你会遇到更多标准化的计算机算法编写方式。

计算机编程 - 基础

我们假设你对英语很熟悉，英语是一种众所周知的**人机交互语言**。英语有预定义的语法，需要遵循这些语法才能正确地编写英语语句。同样，大多数人机交互语言（印地语、英语、西班牙语、法语等）都由多种元素组成，例如动词、名词、形容词、副词、介词和连词等。

与人机交互语言类似，计算机编程语言也由多种元素组成。我们将带你了解这些元素的基础知识，并让你能够在各种编程语言中舒适地使用它们。这些基本元素包括：

• 编程环境
• 基本语法
• 数据类型
• 变量
• 关键字
• 基本运算符
• 决策制定
• 循环
• 数字
• 字符
• 数组
• 字符串
• 函数
• 文件I/O

我们将在后续章节中使用不同的编程语言举例说明所有这些元素。首先，我们将尝试理解所有这些术语的一般含义，然后我们将了解如何在不同的编程语言中使用这些术语。

本教程旨在让你了解以下最流行的编程语言：

• C 编程
• Java 编程
• Python 编程

教程的大部分内容都是以C作为编程语言进行解释的，然后我们展示了类似的概念如何在Java和Python中工作。因此，完成本教程后，你将对这些流行的编程语言非常熟悉。

计算机编程 - 环境

尽管环境设置不是任何编程语言的元素，但它是开始编写程序之前要遵循的第一步。

当我们说环境设置时，它仅仅意味着一个基础，我们可以在其上进行编程。因此，我们需要拥有所需的软件设置，即在我们PC上的安装，这些软件将用于编写计算机程序、编译和执行它们。例如，如果你需要浏览互联网，那么你的机器上需要以下设置：

• 连接到互联网的工作互联网连接
• 网络浏览器，例如Internet Explorer、Chrome、Safari等。

如果你是一位PC用户，那么你将识别以下屏幕截图，我们是在浏览tutorialspoint.com时从Internet Explorer中截取的。

同样，你需要以下设置才能开始使用任何编程语言进行编程。

• 文本编辑器来创建计算机程序。
• 编译器将程序编译成二进制格式。
• 解释器直接执行程序。

如果你对计算机的了解不足，你将无法设置其中任何一个软件。因此，我们建议你寻求周围任何技术人员的帮助，以便在你的机器上设置编程环境，从那里开始。但对你来说，重要的是要了解这些项目是什么。

文本编辑器

文本编辑器是一种用于编写计算机程序的软件。你的Windows机器必须有一个记事本，可以用它来键入程序。你可以按照以下步骤启动它：

Start Icon → All Programs → Accessories → Notepad → Mouse Click on Notepad

它将启动记事本，并显示以下窗口：

你可以使用此软件键入你的计算机程序并将其保存在任何位置的文件中。你可以下载并安装其他优秀的编辑器，例如**Notepad++**，它是免费提供的。

如果你是一位Mac用户，那么你将拥有**TextEdit**，或者你可以安装一些其他商业编辑器，例如**BBEdit**来开始使用。

编译器？

你使用你喜欢的编程语言编写计算机程序，并将其保存在名为程序文件的文本文件中。

现在让我们尝试更详细地了解计算机如何理解你使用编程语言编写的程序。实际上，计算机无法直接理解以文本格式提供的程序，因此我们需要将此程序转换为计算机可以理解的二进制格式。

从文本程序到二进制文件的转换由另一个称为编译器的软件完成，而从文本格式程序到二进制格式文件的转换过程称为程序编译。最后，你可以执行二进制文件来执行已编程的任务。

我们不会深入探讨编译器和编译的不同阶段的细节。

以下流程图说明了该过程：

因此，如果你要使用任何需要编译的语言（如C、C++、Java和Pascal等）编写程序，则需要在开始编程之前安装其编译器。

解释器

我们刚刚讨论了编译器和编译过程。如果你要使用需要先编译成二进制格式才能执行的编程语言编写程序，那么就需要编译器。

还有一些其他的编程语言，比如 Python、PHP 和 Perl，它们不需要编译成二进制格式，而是可以使用解释器逐行读取这些程序并直接执行，无需任何进一步的转换。

所以，如果你打算用 PHP、Python、Perl、Ruby 等语言编写程序，那么在开始编程之前需要安装它们的解释器。

在线编译

如果你无法在你的机器上设置任何编辑器、编译器或解释器，那么tutorialspoint.com 提供了一个方便的功能，可以轻松地一键在线编译和运行几乎所有程序。

所以不用担心，让我们继续前进，体验一下成为一名计算机程序员的激动过程，我们将以简单易懂的步骤进行学习。

计算机编程 - 基本语法

让我们从一点代码开始，这将真正让你成为一名计算机程序员。我们将编写一个单行计算机程序，在你的屏幕上输出Hello, World!。让我们看看如何使用不同的编程语言编写它。

C语言中的Hello World程序

尝试使用我们在 www.compileonline.com 上提供的在线编译器选项来运行以下示例。

在本教程中给出的大多数示例中，你都会在网站代码部分的右上角找到一个尝试一下选项，它会将你带到在线编译器。

尝试更改 printf() 内的内容，例如，在Hello World! 的位置输入任何内容，然后检查其结果。它只会打印你在两个双引号内输入的内容。

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
}

这将产生以下结果：

Hello, World!

这个小小的 Hello World 程序将帮助我们理解与 C 编程相关的各种基本概念。

程序入口点

现在，先不用管#include <stdio.h> 语句，但请记住，你必须将此语句放在 C 程序的顶部。

每个 C 程序都以 main() 开始，它被称为主函数，然后后面跟着一个左花括号。程序的其余指令写在两个花括号之间，最后用右花括号结束程序。

这两个花括号内的编码部分称为程序体。左花括号可以与 main(){ 在同一行，也可以在新的一行，就像上面程序中提到的那样。

函数

函数是程序的小单元，用于执行特定的任务。例如，上面的程序使用了两个函数：main() 和 printf()。这里，函数 main() 为程序执行提供入口点，另一个函数 printf() 用于在计算机屏幕上打印信息。

你可以编写自己的函数，我们将在单独的章节中介绍，但 C 编程本身提供了各种内置函数，如 main()、printf() 等，我们可以根据需要在程序中使用这些函数。

一些编程语言使用子程序代替函数，但它们的功能大体相同。

注释

C 程序可以包含包含在/*.....*/ 中的语句。这些语句称为注释，它们用于使程序更友好、更易于理解。注释的好处是它们会被编译器和解释器完全忽略。所以你可以使用任何你想要的语言来编写注释。

空白字符

当我们使用任何编程语言编写程序时，我们会使用各种可打印字符来准备编程语句。这些可打印字符是a, b, c,......z, A, B, C,.....Z, 1, 2, 3,...... 0, !, @, #, $, %, ^, &, *, (, ), -, _, +, =, \, |, {, }, [, ], :, ;, <, >, ?, /, \, ~. `. ", '。希望我没有遗漏你键盘上的任何可打印字符。

除了这些字符之外，还有一些字符我们经常使用，但它们在你的程序中是不可见的，这些字符是空格、制表符(\t)、换行符(\n)。这些字符称为空白字符。

这三个重要的空白字符在所有编程语言中都很常见，并且在你的文本文档中是不可见的：

仅包含空白字符（可能带有注释）的行称为空行，C 编译器会完全忽略它。空白字符是 C 中用于描述空格、制表符、换行符和注释的术语。因此，你可以像下面这样编写printf("Hello, World!" );。这里“Hello, World!”周围创建的所有空格都是无用的，编译器在编译时会忽略它们。

#include <stdio.h>

int main() {

   /* printf() function to write Hello, World! */
   
   printf(    "Hello, World!"      );
   
}

这将产生以下结果：

Hello, World!

如果我们将所有这些空白字符都显示出来，那么上面的程序将如下所示，并且你将无法编译它：

#include <stdio.h>\n
\n
int main()\n
{
   \n
   \t/* printf() function to write Hello, World! */
   \n 
   \tprintf(\t"Hello, World!"\t);\n
   \n
}\n

分号

C 程序中的每个单独语句都必须以分号 (;) 结尾，例如，如果你想输出两次“Hello, World!”，则可以按如下方式编写：

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!\n" );
   printf( "Hello, World!" );
}

此程序将产生以下结果：

Hello, World! 
Hello, World!

这里，我们在第一个 printf() 函数中使用换行符\n来创建新行。让我们看看如果我们不使用此换行符会发生什么：

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
   printf( "Hello, World!" );
}

此程序将产生以下结果：

Hello, World! Hello, World!

我们将在接下来的几章中学习标识符和关键字。

程序解释

让我们了解一下上面 C 程序是如何工作的。首先，上面的程序使用 C 编译器转换为二进制格式。所以让我们将这段代码放在 test.c 文件中，并按如下方式编译：

$gcc test.c -o demo

如果有任何语法错误（计算机术语中的语法错误），那么我们在将其转换为二进制格式之前修复它。如果一切正常，则会生成一个名为demo的二进制文件。最后，我们按如下方式执行生成的二进制文件 demo：

$./demo

这将产生以下结果：

Hello, World!

这里，当我们执行二进制文件a.out时，计算机从 main() 开始进入程序，并遇到一个 printf() 语句。请注意，/*....*/ 内部的行是注释，在编译时会被过滤掉。因此，printf() 函数指示计算机在计算机屏幕上打印给定的行。最后，它遇到一个右花括号，表示 main() 函数的结束，并退出程序。

语法错误

如果你没有遵循编程语言定义的规则，那么在编译时，你将遇到语法错误，程序将无法编译。从语法的角度来看，即使是一个点或逗号或一个分号也很重要，你应该注意这些小的语法细节。在下面的示例中，我们省略了一个分号，让我们尝试编译程序：

#include <stdio.h>

main() {
   printf("Hello, World!")
}

此程序将产生以下结果：

main.c: In function 'main':
main.c:7:1: error: expected ';' before '}' token
 }
 ^

所以底线是，如果你没有在程序中遵循编程语言定义的正确语法，那么你将遇到语法错误。在尝试另一次编译之前，你需要修复它们，然后继续。

Java语言中的Hello World程序

以下是使用 Java 编写的等效程序。此程序也将产生相同的结果Hello, World!。

public class HelloWorld { 
   public static void main(String []args) {
      /* println() function to write Hello, World! */
      System.out.println("Hello, World!");     
   }
}

这将产生以下结果：

Hello, World!

Python语言中的Hello World程序

以下是使用 Python 编写的等效程序。此程序也将产生相同的结果Hello, World!。

#  print function to write Hello, World! */
print "Hello, World!"

这将产生以下结果：

Hello, World!

希望你注意到，对于 C 和 Java 示例，我们首先编译程序，然后执行生成的二进制文件，但在 Python 程序中，我们直接执行它。正如我们在上一章中解释的那样，Python 是一种解释型语言，它不需要称为编译的中间步骤。

Python 不需要分号 (;) 来终止语句，换行符始终表示语句的终止。

计算机编程 - 数据类型

让我们讨论一个非常简单但非常重要的概念，它几乎存在于所有编程语言中，称为数据类型。顾名思义，数据类型表示你可以使用计算机程序处理的数据的类型。它可以是数字、字母数字、小数等。

让我们暂时搁置计算机编程，举一个简单的例子，将两个整数 10 和 20 相加，这可以简单地按如下方式完成：

10 + 20

让我们再举一个例子，我们想将两个小数 10.50 和 20.50 相加，这将按如下方式编写：

10.50 + 20.50

这两个例子都很简单。现在让我们再举一个例子，我们想在一个笔记本上记录学生信息。这里我们想记录以下信息：

Name:
Class:
Section:
Age:
Sex:

现在，让我们根据给定的要求放入一个学生记录：

Name: Zara Ali
Class: 6th
Section: J
Age: 13
Sex: F

第一个例子处理的是整数，第二个例子加了两个小数，而第三个例子处理的是不同数据的混合。让我们将其表示如下：

• 学生姓名“Zara Ali”是一系列字符，也称为字符串。

• 学生班级“6th”由整数和两个字符的字符串混合表示。这种混合称为字母数字。

• 学生所在班级由单个字符“J”表示。

• 学生年龄由整数 13 表示。

• 学生性别由单个字符“F”表示。

这样，我们意识到在日常生活中，我们处理不同类型的数据，例如字符串、字符、整数和小数（浮点数）。

同样，当我们编写计算机程序来处理不同类型的数据时，我们需要明确指定其类型；否则计算机无法理解如何对给定的数据执行不同的操作。不同的编程语言使用不同的关键字来指定不同的数据类型。例如，C 和 Java 编程语言使用int来指定整型数据，而char则指定字符型数据类型。

后续章节将向你展示如何在不同情况下使用不同的数据类型。现在，让我们检查一下 C、Java 和 Python 中可用的重要数据类型以及我们将用于指定这些数据类型的关键字。

C 和 Java 数据类型

C 和 Java 支持几乎相同的 数据类型集，尽管 Java 支持其他数据类型。现在，我们正在使用这两种编程语言都支持的一些常用数据类型：

这些数据类型称为基本数据类型，您可以使用这些数据类型构建更复杂的数据类型，称为用户定义数据类型，例如字符串将是一系列字符。

Python 数据类型

Python 有五种标准数据类型，但这种编程语言不使用任何关键字来指定特定的数据类型，而是 Python 足够智能，可以自动理解给定的数据类型。

• 数字
• 字符串
• 列表
• 元组
• 字典

这里，数字指定所有类型的数字，包括十进制数，字符串表示长度为 1 个或多个字符的字符序列。目前，让我们继续使用这两种数据类型，并跳过列表、元组和字典，它们是 Python 中的高级数据类型。

计算机编程 - 变量

变量是在计算机程序中用于存储值的计算机内存位置所赋予的名称。

例如，假设您想在程序中存储两个值 10 和 20，并在稍后阶段使用这两个值。让我们看看您将如何做到这一点。以下是三个简单的步骤：

• 创建具有适当名称的变量。
• 将您的值存储在这些两个变量中。
• 检索并使用变量中存储的值。

创建变量

在 C 编程中，创建变量也称为**声明变量**。不同的编程语言在程序内部创建变量的方式不同。例如，C 编程有以下创建变量的简单方法：

#include <stdio.h>

int main() {
   int a;
   int b;
}

以上程序创建了两个变量，以使用名称**a**和**b**保留两个内存位置。我们使用**int**关键字创建了这些变量来指定变量**数据类型**，这意味着我们希望在这两个变量中存储整数值。类似地，您可以创建变量来存储**long**、**float**、**char**或任何其他数据类型。例如：

/* variable to store long value */
long a;

/* variable to store float value */
float b;

您可以通过将相似类型的变量放在一行中并用逗号分隔来创建它们，如下所示：

#include <stdio.h>

int main() {
   int a, b;
}

以下是关于变量的一些关键要点，您需要注意：

• 一个变量名只能保存一种类型的值。例如，如果变量**a**已定义为**int**类型，则它只能存储整数。

• C 编程语言要求在程序中使用变量之前创建变量，即声明。您不能在程序中使用变量名而无需创建它，尽管像 Python 这样的编程语言允许您在不创建变量名的情况下使用它。

• 您只能在程序中使用一次变量名。例如，如果变量**a**已定义为存储整数值，则您不能再次定义**a**来存储任何其他类型的值。

• 有一些编程语言，如 Python、PHP、Perl 等，不需要您在创建变量时指定数据类型。因此，您可以存储整数、浮点数或长整数，而无需指定其数据类型。

• 您可以为变量赋予任何名称，例如**age**、**sex**、**salary**、**year1990**或任何您喜欢的名称，但大多数编程语言只允许在变量名中使用有限的字符。目前，我们建议您仅在变量名中使用**a....z、A....Z、0....9**，并以字母开头而不是数字。

• 几乎没有编程语言允许变量名以数字开头，因此**1990year**不是有效的变量名，而**year1990**或**ye1990ar**是有效的变量名。

每种编程语言都提供了更多与变量相关的规则，当您深入了解该编程语言时，您将学习它们。

在变量中存储值

您已经了解了如何在上一节中创建变量。现在，让我们在这些变量中存储一些值：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
}

以上程序有两个额外的语句，我们在其中将 10 存储在变量**a**中，并将 20 存储在变量**b**中。几乎所有编程语言都以类似的方式在变量中存储值，我们将在等号 = 的左侧保留变量名，并且我们将要存储在变量中的任何值，我们都将其保存在右侧。

现在，我们已经完成了两个步骤，首先我们创建了两个变量，然后我们在这些变量中存储了所需的值。现在变量**a**的值为 10，变量**b**的值为 20。换句话说，我们可以说，当执行上述程序时，名为**a**的内存位置将保存 10，内存位置**b**将保存 20。

访问变量中存储的值

如果我们不使用变量中存储的值，那么创建变量并在其中存储值就没有意义。我们知道以上程序有两个变量**a**和**b**，它们分别存储值 10 和 20。所以让我们尝试打印存储在这两个变量中的值。以下是一个 C 程序，它打印存储在其变量中的值：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d\n", a );
   printf( "Value of b = %d\n", b );
}

当执行上述程序时，它会产生以下结果：

Value of a = 10
Value of b = 20

您一定在上一章中看到了**printf()**函数，我们之前曾使用它来打印“Hello, World！”。这一次，我们使用它来打印变量的值。我们正在使用**%d**，它将被**printf()**语句中给定变量的值替换。我们可以使用单个**printf()**语句打印这两个值，如下所示：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

当执行上述程序时，它会产生以下结果：

Value of a = 10 and value of b = 20

如果要在 C 编程中使用**float**变量，则必须使用**%f**而不是**%d**，如果要打印字符值，则必须使用**%c**。类似地，可以使用不同的 % 和字符打印不同的数据类型。

Java 中的变量

以下是使用 Java 编程语言编写的等效程序。此程序将创建两个变量**a**和**b**，并且与 C 编程非常相似，它将在这些变量中分别赋值 10 和 20，最后以两种方式打印这两个变量的值：

public class DemoJava {
   public static void main(String []args) {
      int a;
      int b;
   
      a = 10;
      b = 20;
   
      System.out.println("Value of a = " + a);
      System.out.println("Value of b = " + b);
      System.out.println("Value of a = " + a + " and value of b = " + b);     
   }
}

当执行上述程序时，它会产生以下结果：

Value of a = 10
Value of b = 20
Value of a = 10 and value of b = 20

Python 中的变量

以下是使用 Python 编写的等效程序。此程序将创建两个变量**a**和**b**，并在同时将 10 和 20 分配给这些变量。

Python 不需要您在创建变量时指定数据类型，并且无需预先创建变量。

a = 10
b = 20
   
print "Value of a = ", a
print "Value of b = ", b
print "Value of a = ", a, " and value of b = ", b

当执行上述程序时，它会产生以下结果：

Value of a =  10
Value of b =  20
Value of a =  10  and value of b =  20

您可以在 C 和 Java 编程中使用以下语法来同时声明变量和赋值：

#include <stdio.h>

int main() {
   int a = 10;
   int b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

当执行上述程序时，它会产生以下结果：

Value of a = 10 and value of b = 20

计算机编程 - 关键字

到目前为止，我们已经涵盖了两个重要的概念，即变量及其数据类型。我们讨论了如何使用**int**、**long**和**float**来指定不同的数据类型。我们还学习了如何命名变量以存储不同的值。

虽然本章不需要单独列出，因为保留关键字是基本编程语法的组成部分，但我们将其单独列出以便在数据类型和变量之后立即解释，以便于理解。

像 int、long 和 float 一样，C 编程语言支持许多其他关键字，我们将用于不同的目的。不同的编程语言提供不同的保留关键字集，但所有编程语言中都有一个重要且通用的规则，即我们不能使用保留关键字来命名我们的变量，这意味着我们不能将变量命名为**int**或**float**，而这些关键字只能用于指定变量数据类型。

例如，如果您尝试将任何保留关键字用于变量名，则会收到语法错误。

#include <stdio.h>

int main() {
   int float;
   float = 10;
   
   printf( "Value of float = %d\n", float);
}

当您编译以上程序时，它会产生以下错误：

main.c: In function 'main':
main.c:5:8: error: two or more data types in declaration specifiers
   int float;
......

现在让我们为我们的整数变量赋予一个合适的名称，然后以上程序应该可以成功编译和执行：

#include <stdio.h>

int main() {
   int count;
   count = 10;

   printf( "Value of count = %d\n", count);
}

C 编程保留关键字

这是一个包含 C 编程语言支持的几乎所有关键字的表格：

Java 编程保留关键字

这是一个包含 Java 编程语言支持的几乎所有关键字的表格：

Python 编程保留关键字

这是一个包含 Python 编程语言支持的几乎所有关键字的表格：

我们知道您无法记住所有这些关键字，但我们已将其列出以供您参考并解释**保留关键字**的概念。因此，在为变量命名时请小心，您不应为该编程语言使用任何保留关键字。

计算机编程 - 运算符

编程语言中的运算符是一个符号，它告诉编译器或解释器执行特定的数学、关系或逻辑运算并产生最终结果。本章将解释**运算符**的概念，并带您了解 C、Java 和 Python 中可用的重要算术和关系运算符。

算术运算符

计算机程序广泛用于数学计算。我们可以编写一个可以进行简单计算（如加两个数 (2 + 3)）的计算机程序，我们还可以编写一个可以求解复杂方程（如 P(x) = x⁴ + 7x³ - 5x + 9）的程序。即使您是一个差生，您也必须知道在第一个表达式中 2 和 3 是操作数，+ 是运算符。计算机编程中也存在类似的概念。

请看以下两个示例 -

2 + 3

P(x) = x4 + 7x3 - 5x + 9. 

这两个语句在编程语言中被称为算术表达式，并且这些表达式中使用的加号、减号被称为算术运算符，表达式中使用的值，例如 2、3 和 x 等，被称为操作数。它们最简单的形式是产生数值结果。

类似地，编程语言提供了各种算术运算符。下表列出了 C 编程语言中一些重要的算术运算符。假设变量 A 包含 10，变量 B 包含 20，则 -

以下是一个简单的 C 编程示例，用于理解上述数学运算符 -

#include <stdio.h>

int main() {
   int a, b, c;
   
   a = 10;
   b = 20;
   
   c = a + b;   
   printf( "Value of c = %d\n", c);
   
   c = a - b;   
   printf( "Value of c = %d\n", c);
   
   c = a * b;   
   printf( "Value of c = %d\n", c);
   
   c = b / a;   
   printf( "Value of c = %d\n", c);
   
   c = b % a;   
   printf( "Value of c = %d\n", c);
}

当执行上述程序时，它会产生以下结果：

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0

关系运算符

考虑这样一种情况，我们创建两个变量并为它们分配一些值，如下所示 -

A = 20
B = 10

在这里，很明显变量 A 的值大于 B。因此，我们需要一些符号来编写这样的表达式，这些表达式称为关系表达式。如果我们使用 C 编程语言，则将如下编写 -

(A > B)

这里，我们使用了符号 >，它被称为关系运算符，它们最简单的形式是产生布尔结果，这意味着结果要么为真，要么为假。类似地，编程语言提供了各种关系运算符。下表列出了 C 编程语言中一些重要的关系运算符。假设变量A包含 10，变量B包含 20，则 -

在这里，我们将向您展示一个使用if 条件语句的 C 编程示例。尽管此语句将在后面的单独章节中讨论，但简而言之，我们使用if 语句来检查条件，如果条件为真，则执行if 语句的主体，否则跳过if 语句的主体。

#include <stdio.h>

int main() {
   int a, b;
   
   a = 10;
   b = 20;
   
   /* Here we check whether a is equal to 10 or not */
   if( a == 10 ) {
	   
      /* if a is equal to 10 then this body will be executed */
      printf( "a is equal to 10\n");
   }
   
   /* Here we check whether b is equal to 10 or not */
   if( b == 10 ) {
	
      /* if b is equal to 10 then this body will be executed */
      printf( "b is equal to 10\n");
   }
   
   /* Here we check if a is less b than or not */
   if( a < b ) {
	
      /* if a is less than b then this body will be executed */
      printf( "a is less than b\n");
   }
   
   /* Here we check whether a and b are not equal */
   if( a != b ) {
	
      /* if a is not equal to b then this body will be executed */
      printf( "a is not equal to b\n");
   }
}

当执行上述程序时，它会产生以下结果：

a is equal to 10
a is less than b
a is not equal to b

逻辑运算符

逻辑运算符在任何编程语言中都非常重要，它们帮助我们根据某些条件做出决策。假设我们想组合两个条件的结果，那么逻辑 AND 和 OR 逻辑运算符将帮助我们产生最终结果。

下表显示了 C 语言支持的所有逻辑运算符。假设变量A包含 1，变量B包含 0，则 -

尝试以下示例以了解 C 编程语言中可用的所有逻辑运算符 -

#include <stdio.h>

int main() {
   int a = 1;
   int b = 0;

   if ( a && b ) {
	
      printf("This will never print because condition is false\n" );
   }
   if ( a || b ) {
	
      printf("This will be printed print because condition is true\n" );
   }
   if ( !(a && b) ) {
	
      printf("This will be printed print because condition is true\n" );
   }
}

编译并执行上述程序时，将产生以下结果 -

This will be printed print because condition is true
This will be printed print because condition is true

Java 中的运算符

以下是 Java 中编写的等效程序。C 编程和 Java 提供几乎相同的运算符和条件语句集。此程序将创建两个变量a和b，与 C 编程非常相似，然后我们在这些变量中分别赋值 10 和 20，最后，我们将使用不同的算术和关系运算符 -

您可以尝试执行以下程序以查看输出，该输出必须与上述示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      int a, b, c;
   
      a = 10;
      b = 20;
   
      c = a + b;   
      System.out.println("Value of c = " + c );
   
      c = a - b;
      System.out.println("Value of c = " + c );
   
      c = a * b;   
      System.out.println("Value of c = " + c );
   
      c = b / a;   
      System.out.println("Value of c = " + c );
   
      c = b % a;   
      System.out.println("Value of c = " + c );
      
      if( a == 10 ) {
		
         System.out.println("a is equal to 10" );
      }
   }
}

当执行上述程序时，它会产生以下结果：

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0
a is equal to 10

Python 中的运算符

以下是 Python 中编写的等效程序。此程序将创建两个变量a和b，并同时在这些变量中赋值 10 和 20。幸运的是，C 编程和 Python 编程语言提供了几乎相同的运算符集。此程序将创建两个变量a和b，与 C 编程非常相似，然后我们在这些变量中分别赋值 10 和 20，最后，我们将使用不同的算术和关系运算符。

您可以尝试执行以下程序以查看输出，该输出必须与上述示例生成的输出相同。

a = 10
b = 20
   
c = a + b   
print "Value of c = ", c

c = a - b   
print "Value of c = ", c

c = a * b   
print "Value of c = ", c

c = a / b   
print "Value of c = ", c

c = a % b   
print "Value of c = ", c

if( a == 10 ):
   print "a is equal to 10"

当执行上述程序时，它会产生以下结果：

Value of c =  30
Value of c =  -10
Value of c =  200
Value of c =  0
Value of c =  10
a is equal to 10

决策语句

决策制定对于计算机编程至关重要。在许多情况下，您将获得两个或多个选项，并且您必须根据给定的条件选择一个选项。例如，我们希望根据学生获得的分数打印关于学生的评语。以下是这种情况 -

Assume given marks are x for a student:

If given marks are more than 95, then
Student is brilliant

If given marks are less than 30, then
Student is poor

If given marks are less than 95 and more than 30, then
Student is average

现在，问题是如何编写编程代码来处理这种情况。几乎所有编程语言都提供条件语句，这些语句的工作原理基于以下流程图 -

让我们使用if 条件语句编写一个 C 程序，将上述给定情况转换为编程代码 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   }
   if( x < 30) {
	
      printf( "Student is poor\n");
   }
   if( x < 95 && x > 30 ) {
	
      printf( "Student is average\n");
   }
}

当执行上述程序时，它会产生以下结果：

Student is average

上述程序使用了if 条件语句。这里，第一个if 语句检查给定条件，即变量 x 是否大于 95，如果发现条件为真，则进入条件体执行给定的语句。这里我们只有一个printf()语句来打印关于学生的评语。

类似地，第二个if 语句工作。最后，执行第三个if 语句，这里我们有两个条件 -

• 第一个条件是x > 95

• 第二个条件是x < 30

计算机评估这两个给定的条件，然后，使用二元运算符&&组合最终结果。如果最终结果为真，则执行条件语句，否则不执行任何语句。

本教程将为您提供有关各种形式的if 语句以及 C 编程语言中switch语句的介绍的基本概念。不同的编程语言提供不同类型的决策语句，但基本概念与本教程中解释的相同。

if...else 语句

一个if语句后面可以跟一个可选的else语句，当布尔表达式为假时执行该语句。C 编程语言中if...else语句的语法如下 -

if(boolean_expression) {
   
   /* Statement(s) will execute if the boolean expression is true */
} else {
  
  /* Statement(s) will execute if the boolean expression is false */
}

上述语法可以表示为如下所示的流程图 -

当我们必须从两个选项中做出决策时，if...else语句非常有用。例如，如果学生的分数超过 95 分，则该学生很优秀，否则无法编码这种情况，如下所示 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   } else {
      printf( "Student is not brilliant\n");
   }
}

当执行上述程序时，它会产生以下结果：

Student is not brilliant

if...elseif...else 语句

一个if语句后面可以跟一个可选的else if...else语句，这对于测试各种条件非常有用。

使用if、else if、else语句时，需要注意以下几点 -

• 一个if可以有零个或一个else，并且它必须出现在else if之后。

• 一个if可以有零到多个else…if，并且它们必须出现在else之前。

• 一旦else…if成功，就不会测试任何剩余的else…if或else。

C 编程语言中if...else if...else语句的语法如下 -

if(boolean_expression 1) {

   /* Executes when the boolean expression 1 is true */
}
else if( boolean_expression 2) {

   /* Executes when the boolean expression 2 is true */
}
else if( boolean_expression 3) {

   /* Executes when the boolean expression 3 is true */
} else {
   
   /* Executes when the none of the above condition is true */
}

现在，借助if...elseif...else语句，第一个程序可以编码如下 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
      printf( "Student is brilliant\n");
   } 
   else if( x < 30) {
      printf( "Student is poor\n");
   } 
   else if( x < 95 && x > 30 ) {
      printf( "Student is average\n");
   }
}

当执行上述程序时，它会产生以下结果：

Student is average

Switch 语句

switch语句是if 语句的替代方案，它允许将变量与值列表进行相等性测试。每个值称为一个case，并且正在切换的变量将针对每个 switch case 进行检查。它具有以下语法 -

switch(expression){
   case ONE :
      statement(s);
      break;
   case TWO:
      statement(s);
      break;
   ......
   
   default :
      statement(s);
}

switch语句中使用的表达式必须给出整数值，该值将与给定的不同 case 进行相等性比较。在表达式的值与某个 case 的值匹配的地方，将执行该 case 的主体，最后，将使用break语句终止 switch。如果没有提供 break 语句，则计算机将继续执行下面可用的其他语句，直到匹配的 case。如果没有任何 case 匹配，则执行 default case 的主体。

上述语法可以表示为如下所示的流程图 -

现在，让我们考虑另一个示例，我们希望为给定的数字编写等效的英文单词。然后，可以将其编码如下 -

#include <stdio.h>

int main() {
   int x = 2;
   
   switch( x ){
      case 1 :
         printf( "One\n");
         break;
      case 2 :
         printf( "Two\n");
         break;
      case 3 :
         printf( "Three\n");
         break;
      case 4 :
         printf( "Four\n");
         break;
      default :
         printf( "None of the above...\n");
   }
}

当执行上述程序时，它会产生以下结果：

Two

Java 中的决策

以下是 Java 中编写的等效程序，它也支持if、if...else、if...elseif...else和switch语句。

您可以尝试执行以下程序以查看输出，该输出必须与上述 C 示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      int x = 45;
   
      if( x > 95) {
         System.out.println( "Student is brilliant");
      } 
      else if( x < 30) {
         System.out.println( "Student is poor");
      } 
      else if( x < 95 && x > 30 ) {
         System.out.println( "Student is average");
      }
   }
}

当执行上述程序时，它会产生以下结果：

Student is average

Python 中的决策

以下是 Python 中编写的等效程序。Python 提供if、if...else、if...elif...else和switch语句。在这里，您必须注意 Python 不使用花括号作为条件体，而是简单地使用语句的缩进来识别块的主体。

您可以尝试执行以下程序以查看输出 -

x = 45

if x > 95:
   print "Student is brilliant"
elif x < 30:
   print "Student is poor"
elif x < 95 and x > 30:
   print "Student is average"

print "The end"

当执行上述程序时，它会产生以下结果：

Student is average
The end

计算机编程 - 循环

让我们考虑这样一种情况，您希望打印Hello, World!五次。这是一个简单的 C 程序来完成同样的操作 -

#include <stdio.h>

int main() {
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
}

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

这很简单，但再次，让我们考虑另一种情况，您希望写入Hello, World!一千次。我们当然不能将 printf() 语句写一千次。几乎所有编程语言都提供了一个称为循环的概念，它有助于将一个或多个语句执行到所需的次数。所有高级编程语言都提供各种形式的循环，这些循环可用于重复执行一个或多个语句。

让我们使用while 循环编写上述 C 程序，稍后我们将讨论此循环的工作原理

#include <stdio.h>

int main() {
   int i = 0;
   
   while ( i < 5 ) {
      printf( "Hello, World!\n");
      i = i + 1;
   }
}

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

上述程序使用了while 循环，该循环用于执行包含在 {....} 中的一组编程语句。在这里，计算机首先检查给定条件，即变量“a”是否小于 5，如果发现条件为真，则进入循环体执行给定的语句。这里，我们在循环体中有以下两个语句 -

• 第一个语句是printf()函数，它打印 Hello World!

• 第二个语句是i = i + 1，用于增加变量i的值。

执行完循环体中所有语句后，计算机将返回到while( i < 5)，并再次检查给定的条件(i < 5)，如果条件成立，则再次执行循环。这个过程会重复，直到给定的条件保持为真，这意味着变量“a”的值小于5。

总之，循环语句允许我们多次执行一个语句或一组语句。下面是在大多数编程语言中循环语句的一般形式：

本教程旨在向非程序员介绍编程的基本概念，因此让我们讨论一下C编程语言中提供的两个最重要的循环。一旦您了解了这两个循环，您就可以选择C编程教程或参考书，并检查C中提供的其他循环及其工作方式。

while循环

C编程语言中提供的while循环具有以下语法：

while ( condition ) {
   /*....while loop body ....*/
}

以上代码可以用流程图表示，如下所示：

关于while循环，需要注意以下几点：

• while循环以关键字while开头，后跟用( )括起来的条件。

• 在while()语句之后，您将拥有用花括号{...}括起来的循环体。

• while循环体可以有一行或多行要重复执行的源代码。

• 如果while循环体只有一行，则可以使用花括号{...}，也可以不使用。

• while循环会一直执行其循环体，直到给定的条件为真。一旦条件变为假，while循环就会退出，并继续从while循环体之后的下一条语句开始执行。

• 条件通常是一个关系语句，其结果要么为真，要么为假。值为零被视为假，任何非零值都被视为真。

do...while循环

while循环会在执行循环体中任何语句之前检查给定的条件。C编程提供另一种形式的循环，称为do...while，它允许在检查给定条件之前执行循环体。它具有以下语法：

do {
   /*....do...while loop body ....*/
} 
while ( condition );

以上代码可以用流程图表示，如下所示：

如果您使用do...while循环编写上述示例，则Hello, World将产生相同的结果：

#include <stdio.h>

int main() {
   int i = 0;
   
   do {
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

break语句

当在循环内遇到break语句时，循环会立即终止，程序控制权会恢复到循环之后的下一条语句。C中break语句的语法如下：

break;

break语句可以用流程图表示，如下所示：

以下是上述程序的一个变体，但它只打印三次Hello World!后就会退出：

#include <stdio.h>

int main() {
   int i = 0;
   do {
      printf( "Hello, World!\n");
      i = i + 1;
      
      if( i == 3 ) {
         break;
      }
   }
   while ( i < 5 );
}

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!

continue语句

C编程语言中的continue语句在某种程度上类似于break语句。continue不是强制终止，而是强制执行循环的下一轮迭代，跳过中间的任何代码。C中continue语句的语法如下：

continue;

continue语句可以用流程图表示，如下所示：

以下是上述程序的一个变体，但当变量的值等于3时，它将跳过打印：

#include <stdio.h>

int main() {
   int i = 0;
   do {
      if( i == 3 ) {
         i = i + 1;
         continue;
      }
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!

Java中的循环

以下是使用Java编写的等效程序，它也支持while和do...while循环。以下程序打印Hello, World!五次，就像我们在C编程中所做的那样：

您可以尝试执行以下程序以查看输出，该输出必须与上述示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      int i = 0;
   
      while ( i < 5 ) {
         System.out.println("Hello, World!");
         i = i + 1;
      }
   }
}

Java编程中的break和continue语句的工作方式与C编程中的工作方式完全相同。

Python中的循环

以下是使用Python编写的等效程序。Python也支持while和do...while循环。以下程序打印Hello, World!五次，就像我们在C编程中所做的那样。在这里，您必须注意，Python不使用花括号来表示循环体，而是简单地使用语句的缩进识别循环体。

您可以尝试执行以下程序以查看输出。为了显示差异，我们使用了另一个print语句，该语句将在循环结束后执行。

i = 0

while (i < 5):
   print "Hello, World!"
   i = i + 1
print "Loop ends"

当执行上述程序时，它会产生以下结果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Loop ends

Python中的break和continue语句的工作方式与C编程中的工作方式完全相同。

计算机编程 - 数字

每种编程语言都提供对操作不同类型数字的支持，例如简单的整数和浮点数。C、Java和Python根据数字的性质将这些数字分为几类。

让我们回到并检查数据类型章节，我们在其中列出了与数字相关的核心数据类型：

这些数据类型称为基本数据类型，您可以使用这些数据类型来构建更多数据类型，这些数据类型称为用户定义数据类型。

在讨论运算符时，我们已经看到了对数字的各种数学和逻辑运算。所以我们知道如何加数字、减数字、除数字等等。

首先让我们看看如何在C编程语言中打印各种类型的数字：

#include <stdio.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   s = 10;
   i = 1000;
   l = 1000000;
   f = 230.47;
   d = 30949.374;

   printf( "s: %d\n", s);
   printf( "i: %d\n", i);
   printf( "l: %ld\n", l);
   printf( "f: %.3f\n", f);
   printf( "d: %.3f\n", d);
}

其余的编码非常明显，但我们使用了%.3f来打印float和double，这表示要打印小数点后的位数。当执行上述程序时，它会产生以下结果：

s: 10
i: 1000
l: 1000000
f: 230.470
d: 30949.374

数字的数学运算

下表列出了C编程语言中可用于各种重要数学计算的各种有用的内置数学函数。

例如，如果您想计算一个数字的平方根，例如2304，那么您有一个内置函数可以计算平方根。

以下是一个简单的示例，用于显示一些数学运算。要利用这些函数，您需要在程序中包含数学头文件<math.h>，就像您包含stdio.h一样：

#include <stdio.h>
#include <math.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   printf( "sin(s): %f\n", sin(10));
   printf( "abs(i): %f\n", abs(1000));
   printf( "floor(f): %f\n", floor(230.47));
   printf( "sqrt(l): %f\n", sqrt(1000000));
   printf( "pow(d, 2): %f\n", pow(2.374, 2));
}

当执行上述程序时，它会产生以下结果：

sin(s): -0.544021
abs(i): -0.544021
floor(f): 230.000000
sqrt(l): 1000.000000
pow(d, 2): 5.635876

除了以上用法外，您还将在循环计数、标志表示、C编程中的真假值中使用数字。

Java中的数字

以下是使用Java编写的等效程序。Java提供了几乎所有在C编程中提供的数字数据类型。

您可以尝试执行以下程序以查看输出，该输出与上述C示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      short  s;
      int    i;
      long   l;
      float  f;
      double d;

      s = 10;
      i = 1000;
      l = 1000000L;
      f = 230.47f;
      d = 30949.374;

      System.out.format( "s: %d\n", s);
      System.out.format( "i: %d\n", i);
      System.out.format( "l: %d\n", l);
      System.out.format( "f: %f\n", f);
      System.out.format( "d: %f\n", d);
   }
}

当执行上述程序时，它会产生以下结果：

s: 10
i: 1000
l: 1000000
f: 230.470001
d: 30949.374000

Java还提供了一系列用于数学计算的内置函数，您可以像在C编程中一样使用它们。

Python中的数字

Python与C和Java略有不同；它将数字分为int、long、float和complex。以下是一些Python中数字的示例：

以下是使用Python编写的等效程序：

s = 10
i = 1000
l = 1000000
f = 230.47
d = 30949.374

print "s: ", s
print "i: ", i
print "l: ", l
print "f: ", f
print "d: ", d

当执行上述程序时，它会产生以下结果：

s:  10
i:  1000
l:  1000000
f:  230.47
d:  30949.374

Python还提供了一系列用于数学计算的内置函数，您可以像在C编程中一样使用它们。

计算机编程 - 字符

如果在计算机编程中使用数字很容易，那么使用字符就更容易了。字符是简单的字母，如a、b、c、d……、A、B、C、D……，但有一个例外。在计算机编程中，任何一位数字，如0、1、2……以及特殊字符，如$、%、+、-……等，也被视为字符，要在字符类型变量中分配它们，您只需将它们放在单引号中。例如，以下语句定义了一个字符类型变量ch，我们为其赋值'a'：

char ch = 'a';

这里，ch是字符类型的变量，可以容纳实现的字符集中的一个字符，而'a'称为字符字面量或字符常量。不仅是a、b、c……，当任何数字，如1、2、3……或任何特殊字符，如!、@、#、#、$……放在单引号中时，它们将被视为字符字面量，并且可以分配给字符类型的变量，因此以下是一个有效的语句：

char ch = '1';

字符数据类型占用8位内存，这意味着您可以在字符中存储任何内容，其ASCII值介于-127到127之间，因此它可以容纳256个不同的值中的任何一个。字符数据类型可以存储键盘上提供的任何字符，包括特殊字符，如!、@、#、#、$、%、^、&、*、(、)、_、+、{、}等。

请注意，您只能在单引号中保留一个字母或一个数字，并且不允许在单引号中使用多个字母或数字。因此，以下语句在C编程中无效：

char ch1 = 'ab';
char ch2 = '10';

下面是一个简单的示例，它展示了如何在C编程语言中定义、赋值和打印字符：

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = 'a';      
   ch2 = '1';
   ch3 = '$';
   ch4 = '+';  

   printf( "ch1: %c\n", ch1);
   printf( "ch2: %c\n", ch2);
   printf( "ch3: %c\n", ch3);
   printf( "ch4: %c\n", ch4);
}

这里，我们使用%c来打印字符数据类型。当执行上述程序时，它会产生以下结果：

ch1: a
ch2: 1
ch3: $
ch4: +

转义序列

许多编程语言都支持称为转义序列的概念。当字符前缀为反斜杠(\)时，它称为转义序列，并且对编译器具有特殊含义。例如，以下语句中的\n是一个有效字符，它被称为换行符：

char ch = '\n';

这里，字符n前缀为反斜杠(\)，它具有特殊的含义，即换行，但请记住，反斜杠(\)仅对少数字符具有特殊含义。以下语句在C编程中不会传达任何含义，它将被视为无效语句：

char ch = '\1';

下表列出了C编程语言中提供的转义序列：

以下示例演示了编译器如何在 print 语句中解释转义序列：

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = '\t';      
   ch2 = '\n';

   printf( "Test for tabspace %c and a newline %c will start here", ch1, ch2);
}

当执行上述程序时，它会产生以下结果：

Test for tabspace     and a newline 
will start here

Java 中的字符

以下是使用 Java 编写的等效程序。Java 处理字符数据类型的方式与我们在 C 编程中看到的方式非常相似。但是，Java 为字符操作提供了额外的支持。

您可以尝试执行以下程序以查看输出，该输出必须与上述 C 示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      char  ch1;
      char  ch2;
      char  ch3;
      char  ch4;
   
      ch1 = 'a';      
      ch2 = '1';
      ch3 = '$';
      ch4 = '+';  

      System.out.format( "ch1: %c\n", ch1);
      System.out.format( "ch2: %c\n", ch2);
      System.out.format( "ch3: %c\n", ch3);
      System.out.format( "ch4: %c\n", ch4);
   }
}

当执行上述程序时，它会产生以下结果：

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Java 也以与你在 C 编程中使用相同的方式支持转义序列。

Python 中的字符

Python 不支持任何字符数据类型，但所有字符都被视为字符串，字符串是字符序列。我们将在单独的章节中学习字符串。在 Python 中使用单个字符时，无需进行任何特殊安排。

以下是使用Python编写的等效程序：

ch1 = 'a';      
ch2 = '1';
ch3 = '$';
ch4 = '+'; 

print "ch1: ", ch1
print "ch2: ", ch2
print "ch3: ", ch3
print "ch4: ", ch4

当执行上述程序时，它会产生以下结果：

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Python 以与你在 C 编程中使用相同的方式支持转义序列。

计算机编程 - 数组

假设我们需要存储五个整数。如果我们使用编程的简单变量和数据类型概念，那么我们需要五个 int 数据类型的变量，程序将如下所示：

#include <stdio.h>

int main() {
   int number1;
   int number2;
   int number3;
   int number4;
   int number5;
   
   number1 = 10;      
   number2 = 20;   
   number3 = 30;   
   number4 = 40; 
   number5 = 50;     

   printf( "number1: %d\n", number1);
   printf( "number2: %d\n", number2);
   printf( "number3: %d\n", number3);
   printf( "number4: %d\n", number4);
   printf( "number5: %d\n", number5);
}

这很简单，因为我们只需要存储五个整数。现在假设我们必须存储 5000 个整数。我们要使用 5000 个变量吗？

为了处理这种情况，几乎所有编程语言都提供了一个称为 数组的概念。数组是一种数据结构，可以存储相同数据类型的固定大小的元素集合。数组用于存储数据集合，但通常将其视为相同类型变量的集合更有用。

与其声明单独的变量，例如 number1、number2、...、number99，不如声明一个整数类型的数组变量 number，并使用 number1[0]、number1[1] 和 ...、number1[99] 来表示各个变量。这里，0、1、2、.....99 是与 var 变量关联的索引，它们用于表示数组中可用的各个元素。

所有数组都由连续的内存位置组成。最低地址对应于第一个元素，最高地址对应于最后一个元素。

创建数组

要在 C 中创建数组变量，程序员需要指定元素的类型以及要存储在该数组中的元素数量。下面是 C 编程中创建数组的简单语法：

type arrayName [ arraySize ];

这称为一维数组。arraySize 必须是大于零的整数常量，type 可以是任何有效的 C 数据类型。例如，现在要声明一个名为 number 的 10 元素数组，其类型为 int，请使用以下语句：

int number[10];

这里，number 是一个数组变量，足以容纳最多 10 个整数。

初始化数组

你可以在 C 中逐个初始化数组，也可以使用以下单个语句进行初始化：

int number[5] = {10, 20, 30, 40, 50};

花括号 { } 中的值的数量不能大于我们在方括号 [ ] 中为数组声明的元素的数量。

如果你省略数组的大小，则会创建一个足够大的数组来容纳初始化。因此，如果你编写：

int number[] = {10, 20, 30, 40, 50};

你将创建与前面示例中完全相同的数组。以下是如何为数组分配单个元素的示例：

number[4] = 50;

上述语句将数组中的第 5 个元素赋值为 50。所有数组的第一个元素的索引都为 0，也称为基索引，数组的最后一个索引将是数组的总大小减 1。下图显示了我们上面讨论的数组的图形表示：

访问数组元素

通过索引数组名称来访问元素。这是通过在数组名称后面方括号中放置元素的索引来完成的。例如：

int var = number[9];

上述语句将从数组中获取第 10 个元素并将该值赋给 var 变量。以下示例使用了上述所有三个概念，即创建、赋值和访问数组：

#include <stdio.h>
 
int main () {
   int number[10]; /* number is an array of 10 integers */
   int i = 0;
 
   /* Initialize elements of array n to 0 */         
   while( i < 10 ) {
	
      /* Set element at location i to i + 100 */
      number[ i ] = i + 100;
      i = i + 1;
   }
   
   /* Output each array element's value */
   i = 0;
   while( i < 10 ) {
	
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
   
   return 0;
}

当以上代码编译并执行时，会产生以下结果：

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

Java 中的数组

以下是使用 Java 编写的等效程序。Java 支持数组，但它们在 Java 中使用 new 运算符创建的方式略有不同。

您可以尝试执行以下程序以查看输出，该输出必须与上述 C 示例生成的输出相同。

public class DemoJava {
   public static void main(String []args) {
      int[] number = new int[10];
      int i = 0;
      
      while( i < 10 ) {
		
         number[ i ] = i + 100;
         i = i + 1;
      }

      i = 0;
      while( i < 10 ) {
         System.out.format( "number[%d] = %d\n", i, number[i] );
         i = i + 1;
      }
   }
}

当执行上述程序时，它会产生以下结果：

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

Python 中的数组（列表）

Python 没有数组的概念，而是提供了另一种称为 列表的数据结构，它提供了与任何其他语言中的数组类似的功能。

以下是使用Python编写的等效程序：

# Following defines an empty list.
number = []
i = 0

while i < 10:
   # Appending elements in the list
   number.append(i + 100)
   i = i + 1

i = 0
while i < 10:
   # Accessing elements from the list
   print "number[", i,  "] = ", number[ i ]
   i = i + 1

当执行上述程序时，它会产生以下结果：

number[ 0 ] =  100
number[ 1 ] =  101
number[ 2 ] =  102
number[ 3 ] =  103
number[ 4 ] =  104
number[ 5 ] =  105
number[ 6 ] =  106
number[ 7 ] =  107
number[ 8 ] =  108
number[ 9 ] =  109

计算机编程 - 字符串

在我们关于字符的讨论中，我们了解到字符数据类型处理单个字符，你可以将键盘上的任何字符赋给字符类型变量。

现在，让我们稍微深入一点，考虑一种需要在变量中存储多个字符的情况。我们已经看到 C 编程不允许在字符类型变量中存储多个字符。因此，以下语句在 C 编程中无效，并且会产生语法错误：

char ch1 = 'ab';
char ch2 = '10';

我们还了解了如何使用数组的概念在变量中存储多个相同数据类型的值。以下是存储和打印 int 类型数组中的五个数字的语法：

#include <stdio.h>

main() {
   int number[5] = {10, 20, 30, 40, 50};
   int i = 0;
        
   while( i < 5 ) {
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
}

当以上代码编译并执行时，会产生以下结果：

number[0] = 10
number[1] = 20
number[2] = 30
number[3] = 40
number[4] = 50

现在，让我们以与数字相同的方式定义一个包含五个字符的数组，并尝试打印它们：

#include <stdio.h>

main() {
   char ch[5] = {'H', 'e', 'l', 'l', 'o'};
   int i = 0;
        
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

这里，我们使用 %c 打印字符值。当以上代码编译并执行时，会产生以下结果：

ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

如果你完成了以上示例，那么我认为你已经理解了 C 编程中字符串的工作原理，因为C 中的字符串表示为字符数组。C 编程简化了字符串的赋值和打印。让我们再次检查同一个示例，使用简化的语法：

#include <stdio.h>

main() {
   char ch[5] = "Hello";
   int i = 0;
    
   /* Print as a complete string */
   printf("String = %s\n", ch);  

   /* Print character by character */
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

这里，我们使用 %s 使用数组名称 ch 打印完整的字符串值，ch 实际上是保存 ch 变量的内存地址的开头，如下所示：

尽管从以上示例中看不出来，但 C 程序在内部将空字符 '\0' 作为每个字符串的最后一个字符。它表示字符串的结尾，这意味着如果你想在数组中存储一个 5 个字符的字符串，那么最好将数组大小定义为 6，尽管 C 不会对此报错。

如果以上代码编译并执行，会产生以下结果：

String = Hello
ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

基本字符串概念

根据以上讨论，我们可以得出关于 C 编程语言中字符串的一些重要结论：

• C 中的字符串表示为字符数组。

• 我们可以通过将字符逐个分配到字符数组中来构成 C 编程中的字符串。

• 我们可以通过分配用双引号括起来的完整字符串来构成 C 编程中的字符串。

• 我们可以使用数组下标逐个打印字符串字符，或者使用不带下标的数组名称打印完整字符串。

• 每个字符串的最后一个字符都是空字符，即 ‘\0’。

• 大多数编程语言都提供内置函数来操作字符串，即你可以连接字符串、搜索字符串、从字符串中提取子字符串等。更多信息，你可以查看我们关于 C 编程或任何其他编程语言的详细教程。

Java 中的字符串

虽然你可以使用字符数组来存储字符串，但 Java 是一种高级编程语言，其设计者试图提供额外的功能。Java 将字符串作为与其他数据类型相同的内置数据类型提供。这意味着你可以直接定义字符串，而不是将其定义为字符数组。

以下是使用 Java 编写的等效程序。Java 使用 new 运算符创建字符串变量，如以下程序所示。

您可以尝试执行以下程序以查看输出 -

public class DemoJava {
   public static void main(String []args) {
      String str = new String("Hello");  
      System.out.println( "String = " + str );
   }
}

当执行上述程序时，它会产生以下结果：

String = Hello

Python 中的字符串

在 Python 中创建字符串就像使用单引号或双引号将字符串分配给 Python 变量一样简单。

下面是一个简单的程序，它创建两个字符串并使用 print() 函数打印它们：

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1 = ", var1
print "var2 = ", var2

当执行上述程序时，它会产生以下结果：

var1 =  Hello World!
var2 =  Python Programming

Python 不支持字符类型；这些被视为长度为一的字符串，因此也被视为子字符串。

要访问子字符串，请使用方括号进行切片，以及索引或索引来获取子字符串。请查看以下代码段：

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

当以上代码执行时，会产生以下结果：

var1[0]:  H
var2[1:5]:  ytho

计算机编程 - 函数

函数是一块组织良好的、可重用的代码，用于执行单个相关的操作。函数为你的应用程序提供了更好的模块化和高度的代码重用。你已经看到了各种函数，例如 printf() 和 main()。这些是语言本身提供的内置函数，但我们也可以编写自己的函数，本教程将教你如何在 C 编程语言中编写和使用这些函数。

函数的好处在于它们有很多名称。不同的编程语言对它们的称呼不同，例如函数、方法、子例程、过程等。如果你遇到任何此类术语，只需想象一下我们在本教程中将要讨论的相同概念即可。

让我们从一个程序开始，在这个程序中我们将定义两个数字数组，然后从每个数组中找到最大的数字。以下是找出给定数字集中最大数字的步骤：

1. Get a list of numbers L1, L2, L3....LN
2. Assume L1 is the largest, Set max = L1
3. Take next number Li from the list and do the following
4.    If max is less than Li
5.       Set max = Li
6.    If Li is last number from the list then
7.       Print value stored in max and come out
8. Else prepeat same process starting from step 3

让我们将以上程序翻译成 C 编程语言：

#include <stdio.h>

int main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int i, max;
   
   /* Process first set of numbers available in set1[] */
   max = set1[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set1[i] ) {
         max = set1[i];
      }
      i = i + 1;
   }
   
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = set2[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set2[i] ) {
         max = set2[i];
      }
      i = i + 1;
   }
   printf("Max in second set = %d\n", max );
}

当以上代码编译并执行时，会产生以下结果：

Max in first set = 50
Max in second set = 501

如果您理解了上面的例子，那么理解为什么我们需要函数就会变得很容易。在上面的例子中，只有两组数字，set1 和 set2，但是考虑这样一种情况，我们有 10 组或更多类似的数字集需要找出每组中的最大数字。在这种情况下，我们将不得不重复处理 10 次或更多次，最终程序将变得太大，并且代码重复。为了处理这种情况，我们编写函数，在函数中，我们尝试保留将在我们的编程中反复使用的源代码。

现在，让我们看看如何在 C 编程语言中定义一个函数，然后在后续章节中，我们将解释如何使用它们。

定义函数

C 编程语言中函数定义的一般形式如下所示：

return_type function_name( parameter list ) {
   body of the function
   
   return [expression];
}

C 编程语言中的函数定义由一个函数头和一个函数体组成。以下是函数的所有部分：

• 返回类型 - 函数可能会返回值。return_type 是函数返回值的数据类型。有些函数执行所需的运算而不返回值。在这种情况下，return_type 是关键字void。

• 函数名称 - 这是函数的实际名称。函数名称和参数列表共同构成函数签名。

• 参数列表 - 参数就像一个占位符。当调用函数时，您将值作为参数传递。此值称为实际参数或实参。参数列表指的是函数的参数的类型、顺序和数量。参数是可选的；也就是说，函数可能不包含任何参数。

• 函数体 - 函数体包含定义函数作用的一组语句。

调用函数

在创建 C 函数时，您会给出函数必须执行的操作的定义。要使用函数，您必须调用该函数以执行定义的任务。

现在，让我们使用函数编写上面的例子：

#include <stdio.h>

int getMax( int set[] ) {
   int i, max;
   
   max = set[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set[i] ) {
         max = set[i];
      }
      i = i + 1;
   }
   return max;
}
main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int max;

   /* Process first set of numbers available in set1[] */
   max = getMax(set1);
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = getMax(set2);
   printf("Max in second set = %d\n", max );
}

当以上代码编译并执行时，会产生以下结果：

Max in first set = 50
Max in second set = 501

Java 中的函数

如果您了解 C 编程中的函数，那么在 Java 中理解它们也很容易。Java 编程将它们命名为方法，但其余的概念或多或少保持不变。

以下是 Java 中编写的等效程序。您可以尝试执行它以查看输出：

public class DemoJava {
   public static void main(String []args) {
      int[] set1 = {10, 20, 30, 40, 50};
      int[] set2 = {101, 201, 301, 401, 501};
      int max;

      /* Process first set of numbers available in set1[] */
      max = getMax(set1);
      System.out.format("Max in first set = %d\n", max );

      /* Now process second set of numbers available in set2[] */
      max = getMax(set2);
      System.out.format("Max in second set = %d\n", max );
   }
   public static int getMax( int set[] ) {
      int i, max;
      max = set[0];
      i = 1;    
      
      while( i < 5 ) {
         if( max <  set[i] ) {
            max = set[i];
         }
         i = i + 1;
      }
      return max;
   }
}

当执行上述程序时，它会产生以下结果：

Max in first set = 50
Max in second set = 501

Python 中的函数

再次，如果您了解 C 和 Java 编程中的函数概念，那么 Python 并没有太大区别。下面是 Python 中定义函数的基本语法：

def function_name( parameter list ):
   body of the function
   
   return [expression]

使用 Python 中的此函数语法，上面的示例可以写成如下：

def getMax( set ):
   max = set[0]
   i = 1   
   
   while( i < 5 ):
      if( max <  set[i] ):
         max = set[i]
      
      i = i + 1
   return max

set1 = [10, 20, 30, 40, 50]
set2 = [101, 201, 301, 401, 501]

# Process first set of numbers available in set1[]
max = getMax(set1)
print "Max in first set = ", max
    
# Now process second set of numbers available in set2[]
max = getMax(set2)
print "Max in second set = ", max

当以上代码执行时，会产生以下结果：

Max in first set =  50
Max in second set =  501

计算机编程 - 文件I/O

计算机文件

计算机文件用于以数字格式存储数据，例如纯文本、图像数据或任何其他内容。计算机文件可以组织在不同的目录中。文件用于保存数字数据，而目录用于保存文件。

计算机文件可以被视为纸质文档的数字对应物。在编程时，您将源代码保存在具有不同扩展名的文本文件中，例如，C 编程文件以扩展名.c结尾，Java 编程文件以.java结尾，Python 文件以.py结尾。

文件输入/输出

通常，您使用文本编辑器（如记事本、MS Word、MS Excel 或 MS Powerpoint 等）创建文件。但是，很多时候，我们也需要使用计算机程序创建文件。我们可以使用计算机程序修改现有文件。

文件输入是指写入文件的数据，文件输出是指从文件读取的数据。实际上，输入和输出术语更多地与屏幕输入和输出相关。当我们在屏幕上显示结果时，称为输出。类似地，如果我们从命令提示符向程序提供一些输入，则称为输入。

现在，记住写入文件是文件输入，从文件读取是文件输出就足够了。

文件操作模式

在我们使用计算机程序处理任何文件之前，我们需要创建一个新文件（如果它不存在）或打开一个已经存在的文件。在这两种情况下，我们都可以以下列模式打开文件：

• 只读模式 - 如果您只想读取现有文件并且不想在文件中写入任何其他内容，则将以只读模式打开文件。几乎所有编程语言都提供以只读模式打开文件的语法。

• 只写模式 - 如果您要写入现有文件或新创建的文件，但不想从该文件读取任何写入的内容，则将以只写模式打开文件。所有编程语言都提供以只写模式打开文件的语法。

• 读写模式 - 如果您要读取和写入同一文件，则将以读写模式打开文件。

• 追加模式 - 当您打开文件进行写入时，它允许您从文件开头开始写入；但是，它会覆盖任何现有内容（如果有）。假设我们不想覆盖任何现有内容，那么我们将以追加模式打开文件。追加模式最终是一种写入模式，它允许在文件末尾追加内容。几乎所有编程语言都提供以追加模式打开文件的语法。

在以下章节中，我们将学习如何打开一个新的文件、如何向其中写入内容，以及随后如何读取和追加更多内容到同一文件中。

打开文件

您可以使用fopen()函数创建新文件或打开现有文件。此调用将初始化类型为FILE的对象，其中包含控制流所需的所有信息。以下是此函数调用的原型，即签名：

FILE *fopen( const char * filename, const char * mode );

这里，filename 是字符串文字，您将使用它来命名您的文件，并且access mode 可以具有以下值之一：

关闭文件

要关闭文件，请使用fclose( )函数。此函数的原型为：

 int fclose( FILE *fp );

fclose( )函数在成功时返回零，或者如果关闭文件时出错，则返回EOF特殊字符。此函数实际上将缓冲区中仍挂起的所有数据刷新到文件，关闭文件，并释放用于文件的任何内存。EOF 是在头文件stdio.h中定义的常量。

C 标准库提供了各种函数来逐个字符或以固定长度字符串的形式读取和写入文件。让我们在下一节中了解其中的一些函数。

写入文件

以下是将单个字符写入流的最简单函数：

int fputc( int c, FILE *fp );

fputc()函数将参数 c 的字符值写入fp引用的输出流。如果成功，它将返回写入的字符，否则如果出错，则返回EOF。您可以使用以下函数将以 null 结尾的字符串写入流：

int fputs( const char *s, FILE *fp );

fputs()函数将字符串s写入fp引用的文件。如果成功，它将返回一个非负值，否则如果发生任何错误，则返回EOF。您还可以使用函数int fprintf(FILE *fp,const char *format, ...)将字符串写入文件。尝试以下示例：

#include <stdio.h>

int main() {
   FILE *fp;

   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}

当编译并执行上述代码时，它将在/tmp目录中创建一个名为test.txt的新文件，并使用两个不同的函数写入两行。让我们在下一节中读取此文件。

读取文件

以下是逐个字符读取文本文件的最简单函数：

int fgetc( FILE * fp );

fgetc()函数从fp引用的输入文件读取一个字符。返回值是读取的字符；或者如果发生任何错误，则返回EOF。以下函数允许您从流中读取字符串：

char *fgets( char *buf, int n, FILE *fp );

fgets()函数从fp引用的输入流中读取最多 n - 1 个字符。它将读取的字符串复制到缓冲区buf中，并附加一个null字符以终止字符串。

如果此函数在读取最大字符数之前遇到换行符'\n'或 EOF，则它只返回读取到该点的字符，包括换行符。您还可以使用int fscanf(FILE *fp, const char *format, ...)从文件读取字符串，但它会在遇到第一个空格字符后停止读取。

#include <stdio.h>

main() {

   FILE *fp;
   char buff[255];

   fp = fopen("/tmp/test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1 : %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("2: %s\n", buff );
   
   fgets(buff, 255, (FILE*)fp);
   printf("3: %s\n", buff );
   fclose(fp);
}

当编译并执行上述代码时，它会读取上一节中创建的文件并产生以下结果：

1 : This
2 : is testing for fprintf...

3 : This is testing for fputs...

让我们分析一下这里发生了什么。首先，fscanf()方法读取This，因为之后它遇到了一个空格。第二个调用用于fgets()，它读取剩余的行直到遇到行尾。最后，最后一个调用fgets()完全读取第二行。

Java 中的文件 I/O

Java 提供了更丰富的函数集来处理文件 I/O。有关此主题的更多信息，我们建议您查看我们的 Java 教程。

在这里，我们将看到一个简单的 Java 程序，它等效于上面解释的 C 程序。此程序将打开一个文本文件，向其中写入几行文本，然后关闭文件。最后，打开同一个文件，然后从已创建的文件中读取。您可以尝试执行以下程序以查看输出：

import java.io.*;

public class DemoJava {
   public static void main(String []args) throws IOException {
      File file = new File("/tmp/java.txt");
      
      // Create a File
      file.createNewFile();
      
      //  Creates a FileWriter Object using file object
      FileWriter writer = new FileWriter(file); 
      
      // Writes the content to the file
      writer.write("This is testing for Java write...\n");
      writer.write("This is second line...\n");
      
      // Flush the memory and close the file
      writer.flush();
      writer.close();
      
      // Creates a FileReader Object
      FileReader reader = new FileReader(file); 
      char [] a = new char[100];
      
      // Read file content in the array
      reader.read(a);
      System.out.println( a );
      
      // Close the file
      reader.close();
   }
}

当执行上述程序时，它会产生以下结果：

This is testing for Java write...
This is second line...

Python 中的文件 I/O

以下程序显示了相同的功能，用于打开一个新文件，向其中写入一些内容，最后读取同一个文件：

# Create a new file
fo = open("/tmp/python.txt", "w")

# Writes the content to the file
fo.write( "This is testing for Python write...\n");
fo.write( "This is second line...\n");

# Close the file
fo.close()

# Open existing file
fo = open("/tmp/python.txt", "r")

# Read file content in a variable
str = fo.read(100);
print str

# Close opened file
fo.close()

当以上代码执行时，会产生以下结果：

This is testing for Python write...
This is second line...

计算机编程 - 总结

感谢您耐心阅读本教程。我们试图保持简洁，但由于本主题包含多个主题，因此我们详细展示了一些示例。

如果您没有理解任何概念，那么我们建议您再次阅读本教程，并且一旦您对本教程中解释的概念感到满意，您就可以继续学习。

还有许多其他与计算机编程相关的主题，我们有意没有涵盖，以避免任何混淆，但我们相信只要您对本教程中解释的概念感到满意，这些概念就不会难以理解。

在 tutorialspoint，我们投入了大量精力来准备关于 C、Java 和 Python 编程语言的全面教程，我们强烈建议您在完成本教程后开始学习其中任何一种。

请与我们分享您对本教程的看法，在主题行中提及教程名称，发送至[email protected]。如果您有任何建议可以进一步改进本教程，我们非常乐意收到您的反馈。