Linux自我小结（硬性语法，少量含编程思维）

1. 对于计算机的访问

1.1 目录

ls /home/che	   	 	会显示出che目录下的文件和目录
ls /                	根目录下的文件和目录
ls -l 			    	详细模式查看，例如文件所有者
pwd                 	当前所在目录路径
cd /home/che	    	切换到/home/che
cd ~			    	切换到主目录
cd ..               	返回上一级

#绝对路径：/home/che/test
#相对路径：最前面不是/或~，例如cd test

---

---

1.2 开关机

shutdown -h now	    	(⽴刻进⾏关机)
shutdown -h 1	    	(1分钟之后关机)
shutdown -r now	    	(现在重新启动计算机)

1.3 Root

切换用户，家目录跟着改变。
根目录是根源，每个用户都能操作
根目录下有许多家目录，你在哪个家就能访问哪个家

su root     	    #然后输入root的密码，验证成功即可切换到root用户。
useradd -m 用户名   	#添加用户
passwd 用户名       	#设置用户密码

1.4 mkdir 创建目录

mkdir 要创建的目录  	创建目录
mkdir /home/tom     	home文件夹下多了一个tom文件夹
mkdir -p /home/tony/lisa这样就可以创建多级目录

rmdir 要删除的空目录
#目录下无文件无文件夹时可以删除，否则报错。
rm -rf /home/tony   	r代表递归的删除目录下的所有文件和文件夹 f代表强制

1.5 touch创建空文件 cp拷贝文件

touch 文件名			称创建空文件
touch /home/che/cluster1.py。可以把文件创建到指定的目录下

cp 原文件 指定目录		拷贝文件到指定目录
cp /home/che/cluster1.py /home/che/test  也可以

1.6 chown 修改文件所有者

首先看各文件目录属性

1.第0位确定文件类型(d, -, l, c, b)。

l是链接，相当于windows的快捷⽅式。

d是⽬录，相当于windows的⽂件夹。

c是字符设备⽂件，⽐如：⿏标，键盘。

b是块设备，⽐如：硬盘。

-是⽂件。

2.第1-3位确定所有者(该文件的所有者)拥有该⽂件的权限。

⽐如：上图中的hello.py文件，所有者为che，che⽤户对hello.py⽂件的权限为rw。

3.第4-6位确定所在组，同⽤户组的成员，拥有该⽂件的权限。

⽐如：上图中的hello.py文件，所在组为che，那么组che下⾯的⽤户，对linux⽬录的权限都为：rwx。

4.第7-9位确定其他⽤户拥有该⽂件的权限。

chown 用户名 文件名     修改文件的所有者
sudo chown james cluster3.py

sudo chown -R james     同时修改⽬录和⽬录下⽂件的所有者

1.7 groupadd 创建组   用户放入组 charp修改文件所在组

groupadd 组名           创建组

useradd -g monster -m fox  把fox用户放入组monster中

id fox                  可以看到fox的组为monster，fox为创建的，再给fox上密码，就完成了fox的创建

chgrp 组名 文件名		修改文件所在组

1.8 rwx

作用到文件：

[ r ]代表可读(read)		验证：cat hello.py

[ w ]代表可写(write)：可以修改。但是不代表可以删除该⽂件，删除这个文件的前提条件是对该文件所在的目录有写权限，才能删除该文件。

[ x ]代表可执行(execute)       

che用户并没有执行权限执行python3户并没有执⾏权限执⾏python3 hello.py，发现可以打印出结果，并没报错，这是因为python3是解释器，只需要有读的权限，就可以执行hello.py

如果不用python3解释器，简单来说，需要两步：

1.编辑hello.py⽂件，并在开头加上#!/usr/bin/python3；

2.执⾏./hello.py。执行后，会出现报错，权限不够。这是因为che⽤户并没有执行权限。
 

rwx作用的目录：

rwx作⽤到⽬录

[ r ]代表可读(read)：可以读取，ls -l查看⽬录内容

[ w ]代表可写(write)：可以修改，在⽬录内，创建+删除+重命名⽂件/⽬录

[ x ]代表可执⾏(execute)：可以进⼊该⽬录。
#可以⽤数字表示：r=4, w=2, x=1。因此rwx=4+2+1=7。

1.9 chmod修改属性

下⾯将提到u、g、o、a，其中，u：所有者；g：所在组；o：其他⼈；a：所有⼈(u、g、o的总和)
chmod u=rwx,g=rx,o=x ⽂件/⽬录名；

r=4，w=2，x=1，rwx=4+2+1=7。chmod u=rwx,g=rx,o=x ⽂件/⽬录名，相当于chmod 751 ⽂件/⽬录名。

chmod o+w ⽂件/⽬录名

chmod a-x ⽂件/⽬录名     对于所有⼈，都失去了x权限

chmod a+x hello.py，会发现，hello.py⽂件，对于所有⼈，都增加了x权限(可执⾏)。

2.0 作业测试：

1.登录Linux系统后，打开终端，切换到root⽤户。
2.使⽤root⽤户，添加⼀个新⽤户，并且给新⽤户修改密码。
3.注销当前登录账号，并使⽤新⽤户登录Linux系统。
4.使⽤命令关机。

一、文件目录

1). 先进入到主目录

2). 创建/home/用户名/bigdata/linux目录，然后进入到/home/用户名/bigdata/linux目录中，创建hello.py的文件

3). 将hello.py文件复制到/home/用户名/test目录中。

二、用户管理

1).使用root用户，在/home/用户名/test， 目录中创建一个linux.py的文件

2).退出root用户

3).将linux.py文件的所有者从root改为当前用户。(当前用户是什么意思呢？比如：我的虚拟机名称为che，那么退出root用户后，我的当前用户应该就变为了che)

1.使⽤root⽤户创建⼀个⽂件hello1.py；
2.查看hello1.py⽂件的所有者和所在组；
3.将hello1.py⽂件的所有者修改为fox(当然了也可以修改为其他⽤户)；
4.将hello1.py⽂件的所在组修改为monster(当然了也可以修改为其他组)。

(1).使⽤touch指令先创建⼀个hello.py⽂件，然后给hello.py⽂件的所有者读、写、执⾏的权限，给所在组读、执⾏权限，给其它⼈读、执⾏权限。
(2).给hello.py⽂件的所有者去除执⾏的权限，增加所在组写的权限。
(3).给hello.py⽂件的所有⽤户添加写的权限。

到⽬前为⽌我们已经掌握了创建⽤户，创建组，以及修改权限。
(1).使⽤root⽤户，创建⼀个组monster，并且为这个组创建两个⽤户：fox，tiger。
(2).切换到che⽤户，并切换到家⽬录，创建⼀个空⽂件practice.py⽂件，并编辑该⽂件，内容可以⾃定义。
(3).使得che⽤户，对该⽂件有rwx权限。
(4).修改该⽂件的组为monster，并使得monster组对该⽂件也有rwx权限。
(5).切换到fox⽤户，通过./practice.py或者/home/⽤户名/practice.py的⽅式，执⾏practice.py⽂件。

---

2. Shell编程

2.1脚本的创建

脚本的格式要求： 1 .脚本以#!/bin/bash开头； 2 .脚本需要有可执⾏权限。

创建名为hello.sh的shell脚本：

创建好hello.sh脚本后，会发现che⽤户对该脚本没有 x(可执⾏)权限 。

2.2 vim编辑

编辑shell脚本，命令为：vim hello.sh。编写shell脚本中的内容。脚本中的内容如下：

2.3 脚本的运行

基本语法：./文件名

有两种⽅式：

( 1 ).⾸先要赋予hello.sh脚本 x权限 ，再执⾏脚本。

( 2 ).不⽤赋予脚本x权限，直接运⾏ sh hello.sh 执⾏即可。

( 1 )我们使⽤第⼀种⽅式，赋予hello.sh脚本x权限，再执⾏脚本。从下图中会发现，直接执⾏脚本会报错：

权限不够。赋予x权限后，就成功输出了hello world~

2.4 Shell的变量

Linux Shell中的变量分为：系统变量和⽤户⾃定义变量

系统变量 $：

$HOME、$PWD、$SHELL、$USER等等，⽐如：echo $HOME等等

⽤户⾃定义变量：

基本语法：

1 . 定义变量：变量名=值 。如下图， A= 100 表示定义变量A， echo A=$A 表示输出A的值。

具体执⾏步骤，以及输出结果如下

2 . 撤销变量：unset 变量 。如下图，执⾏unset A之后，就会把之前定义好的A撤销

继续执⾏上述shell脚本，会发现撤销变量A之后，继续执⾏echo A=$A，变量A就⽆法输出了。

3 . 声明静态变量：readonly 变量 ，注意：静态变量不能unset。如下图，通过 readonly B= 2 ，声明静态变量B。

再执⾏ unset B ，会发现⽆法撤销B。

2.5 变量命名规则

定义变量的规则：

1 .变量名称可以由字⺟、数字和下划线组成，但是不能以数字开头。不可以是： 5 B= 10 。

2 . 等号两侧不能有空格

3 .变量名称⼀般习惯为⼤写。

将命令的返回值赋给变量

1 .A=`date`。相当于运⾏⾥⾯的date命令，并把结果返回给变量A。

直接在命令⾏执⾏date，会输出： 2022 年 04 ⽉ 07 ⽇ 星期四 09 : 31 : 00 CST 。

执⾏上⾯的Shell脚本，会输出如下内容： A= 2022 年 04 ⽉ 07 ⽇ 星期四 09 : 32 : 59 CST

2 .A=$(date)等价于A=`date`。

2.6位置参数变

获取到命令⾏的参数信息，就可以使⽤到位置参数变量。

⽐如：./myshell.sh 100 200

$n (功能描述：n为数字，$0代表命令本身，$1-$9代表第⼀到第九个参数，⼗以上的参数需要⽤⼤括 号包含，⽐如：${10})

$* (功能描述：这个变量代表命令⾏中所有的参数，$*把所有的参数看成⼀个整体)

$@ (功能描述：这个变量也代表命令⾏中所有的参数，不过$@把每个参数区分对待)

$# (功能描述：这个变量代表命令⾏中所有参数的个数)

案例：在命令⾏执⾏./myshell.sh 100 200，希望在Shell脚本中获取到100和200。

1.执⾏touch myshell.sh；

2.执⾏vim myshell.sh，编辑内容如下：

3.执⾏chmod u+x myshell.sh；4.执⾏./myshell.sh 100 200。运⾏结果如下：

运算符：

⼀、$((运算式))：   $(())

$((2+3 ))的意思是 2 + 3

$(((2+3)*4 ))的意思是 ( 2 + 3 )* 4

案例：计算(2+3)*4的值。

1.执⾏touch oper.sh；2.执⾏vim oper.sh，编辑内容如下：其中，RES代表定义的变量。

3 .执⾏chmod u+x oper.sh； 4 .执⾏./oper.sh。运⾏结果如下：可以看到，成功输出了( 2 + 3 )* 4 的值。

⼆、$[运算式]

$[ 2 + 3 ]的意思是 2 + 3

$[( 2 + 3 )* 4 ]的意思是( 2 + 3 )* 4

案例：计算(2+3)*4的值

1 .执⾏touch oper 1 .sh； 2 .执⾏vim oper 1 .sh，编辑内容如下：其中，RES代表定义的变量。

3 .执⾏chmod u+x oper 1 .sh； 4 .执⾏./oper 1 .sh。运⾏结果如下：可以看到，成功输出了( 2 + 3 )* 4 的值。

三、expr m + n

注意：
1.expr后⾯的运算符之间要有空格。⽐如：expr 2 + 3 的意思是 2 + 3 ；

2 .如果希望将expr的结果赋给某个变量，使⽤ `` 。⽐如：TEMP=`expr 2 + 3 `表示定义了TEMP，并且把 expr 2 + 3 的结果赋值给TEMP，所以TEMP的值应该是 5 。

3 .expr后⾯的 \*代表乘，/代表除，%代表取余。

案例：计算(2+3)*4的值。

1 .执⾏touch oper 2 .sh；

2 .执⾏vim oper 2 .sh，编辑内容如下：其中，RES代表定义的变量。

需要注意的是： ⼩括号也需要转义 ，即使⽤ \( 以及 \) 。

3 .执⾏chmod u+x oper 2 .sh；

4 .执⾏./oper 2 .sh。运⾏结果如下：可以看到，成功输出了( 2 + 3 )* 4 的值。

案例练习：在命令⾏执⾏./opertest.sh 20 50。请求出两个参数20+50的值。

2.7 if判断语句

单分⽀基本语法 ：

if [ condition ];then

        command1

fi

---

[ condition ]为判断语句。注意：condition前后要有空格。⾮空返回

---

if [ condition ]

then

        command1

fi

多分⽀基本语法：

if [ condition ];then

        command1

elif [ condition ];then

        command2

else

        command3

fi

---

if [ condition ]

then

        command1

elif [ condition ]

then

        command2

else

        command3

fi

---

常用判断条件

1.  =

2. -lt -eq -gt -ne

-lt：⼩于；           little

-le：⼩于等于；   little equal

-eq：等于；         equal

-gt⼤于；             great

-ge⼤于等于；     great equal

-ne：不等于。     not equal

---

练习：

请写一个Shell脚本，如果输入的数字大于等于90，则输出“greater”，如果小于90但大于等于60，则输出“pass”，如果小于60但大于等于40，则输出“fail”，如果小于40，则输出“it is too bad”。

Remake:

2.8 case语句

基本语法：

case $变量名 in

"值1")

[#如果变量的值等于值1，则执⾏程序1]

;;

"值2")

[#如果变量的值等于值2，则执⾏程序2]

;;

...其他分⽀...

*)

[#如果变量的值都不是以上的值，则执⾏此程序]

1;;

esac

案例：

当命令⾏参数是1时，输出"周⼀"；当命令⾏参数是2时，输出"周⼆"；其他情况输出"other"。

1.执⾏touch case.sh；2.执⾏vim case.sh，编辑内容如下：

3.执⾏chmod u+x case.sh；

4.分别执⾏：

(1)./case.sh；

(2)./case.sh 1；

(3)./case.sh 2；

(4)./case.sh 3；

(5)./case.sh 4，

运⾏结果如下：

匹配多个条件

使⽤ | 符号将条件分隔开来

 

#!/bin/bash

read -p "请输⼊⼀个数字（1~5）：" num

case $num in
    1|2|3)
        echo "你输⼊的数字是1、2或3"
        ;;
    4|5)
        echo "你输⼊的数字是4或5"
        ;;
    *)
        echo "输⼊的数字不在1~5之间"
        ;;
esac

在上述代码中，使⽤ | 符号将条件分隔开来，如果⽤户输⼊的数字是1、2或3，则会进⼊第⼀个分⽀；如

果是4或5，则会进⼊第⼆个分⽀；否则进⼊默认分⽀。

模糊匹配

即使⽤通配符进⾏匹配。

Shell脚本中常⽤的通配符是 * 号。

下⾯是⼀个使⽤通配符进⾏匹配的例⼦：

#!/bin/bash

read -p "请输⼊⼀个⽂件名：" filename

case $filename in
     *.txt)
         echo "该⽂件是⽂本⽂件"
         ;;
     *.sh)
         echo "该⽂件是Shell脚本⽂件"
         ;;
     *.pdf)
         echo "该⽂件是PDF⽂件"
         ;;
     *)
         echo "该⽂件不是⽂本、Shell脚本或PDF⽂件"
         ;;
esac

在上述代码中，使⽤了星号 * 进⾏模糊匹配。如果⽤户输⼊的⽂件名以 .txt、.sh 或 .pdf 结尾，则会进

⼊相应的分⽀，否则进⼊默认分⽀。

read -p ''输出显示的语句'' 赋给哪个变量

2.9 if语句中的and和or

1 and  &&

在if语句中，如果想要表达and，需要使⽤&&。

⽐如下⾯代码中的第7⾏，表达的意思就是：⼩于90，并且⼤于等于60。

#!/bin/bash

read -p "please enter your score: " score

if [ $score -ge 90 ];then
  echo "greater"
elif [[ $score -ge 60 && $score -lt 90 ]];then
  echo "pass"
else
    echo "fail"
fi

2 or   ||

在if语句中，如果想要表达or，需要使⽤||。

⽐如下⾯代码中的第7⾏，表达的意思就是：⼤于等于60，或者⼩于50。

#!/bin/bash
 
read -p "please enter your score: " score

if [ $score -ge 90 ];then
    echo "greater"
elif [[ $score -ge 60 || $score -lt 50 ]];then
     echo "pass"
else
     echo "fail"
fi

2.10 随堂练习

1. 从命令⾏传⼊两个参数，并且在Shell脚本中接收这两个参数

2. 使⽤read -p传⼊⼀个数字，如果数字的值为：1，则将第⼀步中的两个参数进⾏相加，并把相加

后的值赋予变量C。如果数字的值为：2，则将第⼀步中的两个参数进⾏相乘，并把相乘后的值也

赋予变量C。如果字符串的值为：3，则将第⼀步中的两个参数进⾏相减，并把相减后的值也赋予

变量C。

3. 如果第⼆步中得到的C的值⼤于0，则输出C的值，并且输出“C is greater than zero ”

4. 如果第⼆步中得到的C的值⼩于0，则输出C的值，并且输出“C is less than zero ”

5. 如果第⼆步中得到的C的值等于0，则输出C的值，并且输出“C is equal to zero ”

先自己码，功能可以实现再看答案。

#!/bin/bash

A=$1
B=$2

read -p "please enter your number: " nums

case $nums in

    1)
         C=$[$A+$B]
         ;;
    2)
         C=$[$A*$B]
         ;;
    3)
         C=$[$A-$B]
         ;;
    *)
         echo "we only accept nums 1 2 or 3"
         exit
         ;;
esac

if [ $C -lt 0 ];then
    echo C=$C
    echo "C is less than zero"
elif [ $C -gt 0 ];then
    echo C=$C
    echo "C is greater than zero"
else
    echo C=$C
    echo "C is equal to zero"
fi

2.11 for循环

基本语法⼀

for 变量 in 值1 值2 值3

do

        程序/代码

done

使⽤$*接收命令⾏输⼊的参数，并打印出来。

1.执⾏touch fortest.sh；

2.执⾏vim fortest.sh，编辑内容如下：

3.执⾏chmod u+x fortest.sh；

4.执⾏：./fortest.sh 1 2 3 4，运⾏结果如下：

使⽤$@接收命令⾏输⼊的参数，并打印出来。

---

---

循环输出数字1-9。

这个案例我们准备⽤两种⽅式实现。

第⼀种⽅式：

第⼆种⽅式：

在使⽤第⼆种⽅式之前，我们先介绍⼀个指令seq。

seq：⽤于产⽣某个数到另外⼀个数之间的所有整数。

基本语法：

1.seq [选项]... 尾数

2.seq [选项]... ⾸数 尾数

3.seq [选项]... ⾸数 增量 尾数

⽐如：输出 1 - 5

⽐如：输出 1 - 5

需要注意的是，seq后⾯可以接⼀些选项 。因为本⽂主要介绍for循环，所以

只介绍seq最基本的⽤法，不再对seq后⾯的选项做过多介绍。

---

接下来，我们我们将使⽤for循环输出 1 - 9 。

具体步骤：

1 .执⾏：vim fortest.sh，编辑内容如下：

`      `

2 .执⾏：./fortest.sh，运⾏结果如下：

基本语法⼆

for ((初始值;循环条件;变量变化))

do

        程序/代码

done

案例⼀：计算从1加到100的值，并输出结果。

---

案例⼆：使⽤N接收从命令⾏传⼊的变量，并计算从1加到N的值。

2.12 while循环

基本语法

while [ 条件判断式 ]

do

        程序/代码

done

从命令⾏输⼊⼀个数n，统计从1+...+n的值是多少。

1.执⾏touch whiletest.sh；2.执⾏vim whiletest.sh，编辑内容

3.执⾏chmod u+x whiletest.sh；

4.执⾏：./whiletest.sh 100，运⾏结果如下：

要求⽤户输⼊⼀个年份，判断该年份是否为闰年，如果

为闰年则可以继续输⼊数字，否则程序运⾏结束。

1.使⽤read -p "please enter a year: " year，接收⽤户输⼊的年份；

2.使⽤以下三个参数分别年份能否被4、100或者400整除。

one=$[$year%4]、

two=$[$year%100]、

three=$[$year%400]

3.使⽤while语句判断year是否满⾜闰年的条件，代码如下：

read -p "please enter a year: " year

one=$[$year%4]
two=$[$year%100]
three=$[$year%400]

while [[ $one -eq 0 && $two -ne 0 ]] || [[ $three -eq 0 ]]
do
    echo "$year is runnian"
    read -p "please enter a year: " year
    one=$[$year%4]
    two=$[$year%100]
    three=$[$year%400]
done

2.13 函数

基本语法

function_name() {

        #函数体

        [return int;]

}

调⽤直接写函数名：function_name [值]

定义⼀个函数：getSum，计算输⼊两个参数的和。

#!/bin/bash
getSum(){
    #$1和$2代表传⼊的参数
    SUM=$[$1+$2]
    echo "$1 plus $2 equal to $SUM"
}


getSum 1 2

需要注意的是：

上述代码中的$1和$2指的是调⽤getSum函数时传⼊的参数，⽽不是从命令⾏传⼊的参数。

如何给getSum函数传⼊动态的参数呢？

#!/bin/bash
getSum(){
    #$1和$2代表传⼊的参数
    SUM=$[$1+$2]
    echo "$1 plus $2 equal to $SUM"
}

read -p "please enter a num n1: " n1
read -p "please enter a num n2: " n2

getSum $n1 $n2

如何接收getSum函数的返回值呢？

#!/bin/bash
 
getSum(){
    #$1和$2代表传⼊的参数
    SUM=$[$1+$2]
    echo "$1 plus $2 equal to $SUM"
}

read -p "please enter a num n1: " n1
read -p "please enter a num n2: " n2


#把getSum函数的返回值赋值给result
result=`getSum $n1 $n2`
echo "result value is: $result"

案例⼆：

1.定义⼀个函数getSum，计算输⼊两个参数的和；

2.定义⼀个函数getMultiply，计算输⼊两个参数的乘积；

3.在while循环中，接收⽤户输⼊的值：

(1).如果⽤户输⼊的值为：sum，则调⽤getSum。并输出getSum返回的值；

(2).如果⽤户输⼊的值为：mul，则调⽤getMultiply。并输出getMultiply返回的值；

(3).如果⽤户输⼊的值不是sum或者mul，则退出程序。

#!/bin/bash
getSum(){
    #$1和$2代表传⼊的参数
    SUM=$[$1+$2]
    echo $SUM
}

getMultiply(){
    MUL=$[$1*$2]
    echo $MUL
}

while true
do
    read -p "please enter your selection: " sel
    if [ $sel == "sum" ];then
        read -p "please enter a num n1: " n1
        read -p "please enter a num n2: " n2
        result=`getSum $n1 $n2`
        echo result=$result
    elif [ $sel == "mul" ];then
        read -p "please enter a num n1: " n1
            read -p "please enter a num n2: " n2
        result=`getMultiply $n1 $n2`
        echo result=$result
    else
        echo "byebye"
        exit
    fi
done

在 if 条件中，将 "$dd"="sum" 改为 "$dd" = "sum"。注意等号两边的空格，这是正确的字符串比较语法。

代码优化：

2.14 题目练习

第⼀题

请设计⼀个学⽣信息管理系统，⽬前系统的功能如下：

但是当前系统功能并不完善，主要存在以下两个问题：

1. 当输⼊除了"yes"之外的任意键后，并不能继续输⼊学⽣成绩，系统直接退出了；

2. 当第⼀次输⼊james⽤户后，第⼆次却依然可以输⼊james。

如何判断输⼊的⽤户已经存在于txt⽂件中？

我们不妨把这个问题进⾏拆分：

1.如何取出txt⽂件中的内容。代码如下：

for line in `cat "grades.txt"`
do
    echo $line
done

执⾏结果如下：

通过上⾯的代码可以获取到txt⽂件中的每⼀⾏内容。

2.如何判断姓名和txt⽂件中的内容是否匹配。代码如下：

read -p "please enter your name: " name
for line in `cat "grades.txt"`
do
    echo $line
    if [ $name == ${line%:*} ];then
        echo "$name exit in txt file"
    fi
done

完整代码：

#!/bin/bash
manage_grades() {
    local file="grades.txt"
    read -p "请输⼊学⽣姓名: " name
 
     while true
     do
         found=0
         for line in `cat "grades.txt"`
         do
             if [ $name == ${line%:*} ];then
                 found=$[$found+1]
             fi
         done
 
         if [ $found -ge 1 ];then
             read -p "该姓名已经存在，请重新输⼊学⽣姓名：" name
         else
             break
         fi
     done
 
     read -p "请输⼊学⽣成绩: " score
     echo "$name:$score" >> "$file"
     echo "所有学⽣信息如下："
     cat "$file"
}

echo "欢迎进⼊学⽣成绩管理系统！"
for ((i=0;i<=1;i))
do
    manage_grades
    read -p "是否退出系统？（输⼊ 'yes' 退出，其他任意键继续）: " choice
     if [[ $choice == "yes" ]]; then
         echo "系统已退出，再⻅！"
         exit
     fi

    echo "返回到主菜单..."
done

2.15练习

第一题：

编写一个 Shell 脚本，使用 for 循环计算 1 到 100 中所有偶数的和，并输出结果。

要求：

1. 使用 for 循环计算偶数的和。

2. 输出结果应该只包含一个数字，即 1 到 100 中所有偶数的和。

第二题：

编写一个 Shell 脚本，使用 for 循环输出 1 到 10 的数字，但如果数字能同时被 3 和 5 整除，则输出 "ThreeFive"，如果只能被 3 整除，则输出 "Three"，如果只能被 5 整除，则输出 "Five"，否则输出数字本身。

第三题：

编写一个Shell脚本，使用for循环遍历从命令行传入的参数。

要求：

1. 可以判断参数为奇数还是偶数；

2. 可以判断参数是否为数字。