《Linux与Python 编程 R》--实验指导书（2020）

实验一 Linux系统安装与使用基础

linux复习笔记-建议收藏

【目的与要求】

（一） 目的
本实验的目的是使学生学会Linux的安装、配置和基础使用；掌握Linux常用命令的格式和操作以及系统管理、设备管理、用户管理和文件存取权限管理的基本方法；熟悉编译工具GCC的作用，学会在Linux环境下进行工作。
（二） 要求
熟悉并完成Linux（CentOS 7）的安装和基本配置的操作过程；

1. 了解Linux的基本操作命令的格式，掌握基本操作命令功能和使用；
2. 了解Linux的文本编辑器vi的3种工作模式，掌握3种工作模式的转换并学会利用vi进行文本编辑；
3. 掌握Linux下存储设备的挂载与卸载的方法，并学会如何控制文件和目录的存取权限。
4. 熟悉编译工具GCC的作用和基本使用方法。

【实验内容】

1. 安装并配置Linux(CentOS 7)操作系统。
   要求将主机名设置为用户姓名的全拼，并建立一个用户名为姓名简拼的普通用户。
   略
   

2. 熟悉Linux操作系统vi编辑器、编译工具GCC的使用并掌握文件、目录基本操作命令的使用。

1）首先查看用户配置文件/etc/passwd中普通用户的记录。

[lyh@liuyuhang ~]$ cat /etc/passwd

2）在用户主目录下建立一个名字为“班级姓名”（例如“rj1701zhangsan”）的子目录，使用ls显示该子目录的详细信息。

[lyh@liuyuhang ~]$ mkdir rj2029liuyuhang
[lyh@liuyuhang ~]$ ls -l

3）然后在用户主目录下使用vi编辑器编辑一个C语言源程序hello.c，并使用编译工具GCC编译该源程序，可执行文件的文件名为hello，运行编译成功的可执行程序hello，并将运行结果重定位到“班级姓名”（例如“rj1701zhangsan”）的子目录下的一个名为“姓名”（例如：“zhangsan”的文件中，然后显示该文件的内容。
hello.c源程序代码：

#include <stdio.h>
main(){
  char name[20];
  printf("Please input your name:");
  scanf("%s",name);
  printf("Welcome %s!\n",name);
  return 0;
}

命令：

[lyh@liuyuhang ~]$ vi hello.c
[lyh@liuyuhang ~]$ gcc hello.c -o hello
[lyh@liuyuhang ~]$ ./hello > ./rj2029liuyuhang/liuyuhang
[lyh@liuyuhang ~]$ cat ./rj2029liuyuhang/liuyuhang

4. 控制文件和目录的存取权限。
1）将/usr/bin目录中的cal文件和/bin目录中的cat文件复制到rj1701zhangsan子目录中，并分别命名为zhangsancal和zhangsancat。使用ls查看rj1701zhangsan子目录中的各个文件的详细信息。

[lyh@liuyuhang ~]$ cp /usr/bin/{cal*,cat*} ./rj2029liuyuhang/
[lyh@liuyuhang ~]$ rename cal liuyuhangcal ./rj2029liuyuhang/cal*
[lyh@liuyuhang ~]$ rename cat liuyuhangcat ./rj2029liuyuhang/cat*
[lyh@liuyuhang ~]$ ll ./rj2029liuyuhang/

2）使用长列表命令ls查看/usr/bin目录中的cal文件和/bin目录中的cat文件，并把它们与rj1701zhangsan子目录中的文件进行比较。

[lyh@liuyuhang ~]$ ll /usr/bin/cal
[lyh@liuyuhang ~]$ ll /usr/bin/cat
[lyh@liuyuhang ~]$ diff /usr/bin/cal ./rj2029liuyuhang/liuyuhangcal
[lyh@liuyuhang ~]$ diff /usr/bin/cat ./rj2029liuyuhang/liuyuhangcat
[lyh@liuyuhang ~]$ ln hello ./rj2029liuyuhang/hello.link
[lyh@liuyuhang ~]$ ./rj2029liuyuhang/hello.link

3）通过建立硬链接在rj1701zhangsan子目录中以hello.link的文件名来运行文件hello。

比较链接文件和被链接文件有什么不同？文件的硬链接数是多少？执行hello.link的执行结果是什么？

(1) 链接分为：硬链接与软链接。
软链接是包含一个绝对路径的字符串的文件，但是硬链接指向的是文件索引节点。
硬链接只能在同一个文件系统中，但是软连接可以跨文件系统；
硬链接不能链接到目录，但是软连接可以链接到目录。
(2)文件的硬链接一般而言有一个，但是可以使用ln命令来为文件创建多个硬链接。因为这里为hello文件创建了新硬链接，所以hello文件的硬链接数为2
(3)执行hello.link的结果与直接执行文件本身效果是一致的, 输出Please input your name: ,输入liuyuhang,输出Welcome liuyuhang。

4）改变文件hello.link的权限，使拥有者只具有读的权限。试着再运行hello.link，它运行了吗？为什么？

答：不能运行，因为执行者为拥有者，当修改拥有者权限后，只有r读的权力，并没有x执行文件的权限。

[lyh@liuyuhang ~]$ ll ./rj2029liuyuhang/hello.link
[lyh@liuyuhang ~]$ chmod 475 ./rj2029liuyuhang/hello.link
[lyh@liuyuhang ~]$ ll ./rj2029liuyuhang/hello.link

5）删除hello.link，这样做也删除了hello文件吗？为什么？

答：不能,因为hello.link是硬链接。

[lyh@liuyuhang ~]$ rm -f ./rj2029liuyuhang/hello.link
[lyh@liuyuhang ~]$ ls ./rj2029liuyuhang/

5. 掌握Linux下存储设备的挂载与卸载的方法。
1）建立挂载点/mnt/usb。
2）使用#fdisk -l命令查看设备的连接情况，主要查看U盘的名称及文件系统类型。

[lyh@liuyuhang ~]$ su
密码：
[root@liuyuhang lyh]# ll /mnt/
总用量 0
[root@liuyuhang lyh]# mkdir /mnt/usb
插入U盘ing
[root@liuyuhang lyh]# fdisk -l

可能会遇到的问题：


3）使用mount命令手工挂载本地磁盘（U盘）。
4）用ls -l查看U盘中文件的详细信息。
5）使用umount命令手工卸载本地磁盘（U盘）。

[root@liuyuhang lyh]# mount -t vfat /dev/sdb1 /mnt/usb
[root@liuyuhang lyh]# ll /mnt/usb
[root@liuyuhang lyh]# umount /mnt/usb

实验二 Python程序运行方式和程序流程控制

python复习资料

【目的与要求】

（一） 目的
本实验的目的是使学生熟悉Python程序运行方式和程序流程控制，在熟练掌握Python语言基础知识的基础上，能应用控制流程编写程序，培养学生对应用软件的认知、结构、设计及实施能力。
（二） 要求

1. 能熟练掌握Python的安装、执行Python命令和脚本文件的方法、集成开发环境Pycharm。
2. 了解Python语言的基本语法和编码规范。
3. 掌握Python语言的数据类型、运算符、常量、变量、表达式和常用语句等基础知识。
4. 掌握Python语言控制语句。

【实验内容】

1. 下载并安装Python。

2. 安装Python集成开发环境Pycharm。

3. 下载并安装至少一个第三方模块。
   略
   win7:
   
   win10:
   

4. 请编写一个程序，能接收用户输入的一个复数的实部和虚部，输出其复数表示形式，并求其模。

import math
a, b = map(int, input("请输入实部和虚部：\n").split())
print(a, "+", b, "i, 模长为：", math.sqrt(a*a + b*b), sep="")

5. 编写一个程序，根据输入的3个成绩，计算平均分。

x, y, z = map(int, input("请输入三个成绩：\n").split())
print((x + y + z) / 3.0)

6. 输出1000以内的素数以及这些素数只和。

import math
sum, num, flag = 0, 2, True
while(num <= 1000):
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            flag = False
            break
    if(flag):
        sum += num
        print(num, end=" ")
    num = num + 1
    flag = True
print("\n素数和为", sum)

鉴于前不久一道 剑指 Offer 49. 丑数，给出另解：

MAX = 1000
f = [0] * MAX  # 0:素数，1:合数
sum = 0
f[0] = f[1] = 1
for i in range(2, MAX):
    if (f[i] == 0):
        print(i, end=" ")
        sum += i
        for j in range(i * i, MAX, i):
            f[j] = 1

print("\n素数和为", sum)

大致思路：布尔数组f[i]=0表示i为素数，初始化f[0]=f[1]=1,因为0,1都不是素数，若f[i]=0,则i * 2, i * 4 ,…, i * (i-1) ,…均不是素数，又[1,i)筛选过程中 i * 2, i * 4 ,…, i * (i-1) 必定会被标记合数，故我们只需要从 i * i开始计算。
虽然有两层嵌套轮询，但第二个循环，只有在i为素数时执行，时间复杂度远小于O(N * 2), 近似为O(CN),C近取2

剑指 Offer 49. 丑数解题报告： 链接

---

7. 按公式s=12+22+32+…+n2,求累计加和，s不超过1000的最大项数n,程序运行结果如下所示：
   n s
   1 1
   2 5
   3 14
   4 30
   …
   累计和不超过1000的最大项数是n=13

s = 0
n = 1
print("n", "s")
while True:
    s = s + n * n
    if s <= 1000: print(n, s)
    else: break
    n += 1

实验三 Python函数

【目的与要求】

（一） 目的
通过函数的设计，熟练掌握函数的使用，进一步了解函数的各类参数、及参数传递过程，实现减少程序的代码量，同时提高程序执行时的效率和可维护性。
（二） 要求
1． 掌握函数的定义
2． 掌握函数的调用
3． 掌握函数的形参、实参及返回值
4． 掌握位置参数
5． 掌握序列作为参数

【实验内容】

1. 编写函数，求出一个数除1和自身以外的因子。从键盘输入一个数，调用该函数输出除1和它自身以外的所有因子。

def fun(num):
    for i in range(2, num//2 + 1):
        if num % i == 0:
            print(i, end=" ")

fun(12)

2. 编写两个函数，分别求两个整数的最大公约数和最小公倍数，在主函数调用这两个函数，并输出结果。两个整数由键盘输入。

暴力枚举（略）
辗转相除法（取模性能差）：

def gcd(a, b):
    big = max(a, b)
    small = min(a, b)
    if(big % small == 0): return small
    return gcd(big % small, small)

def lcm(a, b):
    return a * b // gcd(a, b)

print(gcd(4, 6))
print(lcm(4, 6))

更相减损术版（不稳定）：

def gcd(a, b):
    if(a == b): return a
    return gcd(abs(a - b), min(a, b))

def lcm(a, b):
    return a * b // gcd(a, b)

print(gcd(4, 6))
print(lcm(4, 6))

更相减损术与位移结合版（稳定）：

def gcd(a, b):
    if a == b: return a
    if (a & 1) == 0 and (b & 1) == 0:
        return gcd(a >> 1, b >> 1) << 1
    elif (a & 1) == 0 and (b & 1) != 0:
        return gcd(a >> 1, b)
    elif (a & 1) != 0 and (b & 1) == 0:
        return gcd(a, b >> 1)
    else:
        return gcd(abs(a - b), min(a, b))

def lcm(a, b):
    return a * b // gcd(a, b)

print(gcd(4, 6))
print(lcm(4, 6))

3. 编写程序，利用元组作为函数的返回值，求系列类型的最大值、最小值和元素个数，并编写测试代码。假设测试数据分别为:
   S1=[9,7,8,3,2,1,55,6]
   S2=[“apple”,“pear”,“melon”,“kiwi”]
   S3=”TheQuickBrownFox”。
   程序运行效果如下所示：
   List =[9,7,8,3,2,1,55,6]
   最大值=55，最小值=1，元素个数=8
   List =[“apple”,“pear”,“melon”,“kiwi”]
   最大值= pear，最小值= apple，元素个数=4
   List =“TheQuickBrownFox”
   最大值=x，最小值=B，元素个数=16
   提示：
   函数形参为系列类型，返回值形如“（最大值，最小值，元素个数）”

def fun(args):
    return (max(args), min(args), len(args))

s1 = [9, 7, 8, 3, 2, 1, 55, 6]
s2 = ["apple", "pear", "melon", "kiwi"]
s3 = "TheQuickBrownFox"

s1Max, s1Min, s1Len = fun(s1)
print(s1)
print("最大值=%s，最小值=%s，元素个数=%d" %(s1Max, s1Min, s1Len))
s2Max, s2Min, s2Len = fun(s2)
print(s2)
print("最大值=%s，最小值=%s，元素个数=%d" %(s2Max, s2Min, s2Len))
s3Max, s3Min, s3Len = fun(s3)
print(s3)
print("最大值=%s，最小值=%s，元素个数=%d" %(s3Max, s3Min, s3Len))

实验四 Python面向对象程序设计

【目的与要求】

（一） 目的
面向对象程序设计的方法是从日常处理问题思路中形成的一种新的设计方法。通过了解对象、类、封装、继承、方法、构造函数和析构函数等面向对象的程序设计的基本概念，掌握Python类的定义、类的方法、类的继承等，为解决复杂现实问题，培养编程能力及工程应用技能，打下坚实的基础。
（二） 要求
1． 了解面向对象的程序设计思想
2． 掌握Python对象、类、封装、继承、方法、构造函数和析构函数等.
3． 掌握Python的类的继承与组合

【实验内容】

1. 设计一个Circle类来表示园，这个类包含圆的半径以及求周长和面积的函数。再使用这个类创建半径为1~100的圆，并计算出相应的周长及面积。

import math

class Circle(object):
    def __init__(self, r):
        self.r = r
        self.perimeter = 2 * math.pi * r
        self.area = math.pi * r ** 2
    def describe(self):
        print("圆的半径为：%d, 周长为：%.2f，面积为：%.2f" %(self.r, self.perimeter, self.area))

circle = Circle(4)
circle.describe()

2. 编写程序并测试，有一个汽车类Vehicle，类中的私有数据成员为车轮个数wheels和车重weight；小车类Car是汽车类vehicle派生类，其中包含载客人数passenger_load，默认4人；卡车类Truck是汽车类vehicle派生类，其中包含载客人数passenger_load和载重量payload。
   提示：编写类时要使用get和set方法，Vehicle类定义display()显示车轮和重量，Car和Truck中要对display()进行同名覆盖。

class Vehicle(object):
    __wheels = 0
    __weight = 0

    def setWheels(self, wheels):
        self.__wheels = wheels

    def getWheels(self):
        return self.__wheels

    def setWeight(self, weight):
        self.__weight = weight

    def getWeight(self):
        return self.__weight

    def display(self):
        print("车轮数量为：%d 个, 车轮重量为：%d Kg" %(self.__wheels, self.__weight))


class Car(Vehicle):
    passenger_load = 4
    def display(self):
        print("Car：车轮数量为：%d 个, 车轮重量为：%d Kg" %(self.getWheels(), self.getWeight()))


class Truck(Vehicle):
    passenger_load = 10
    payload = 10
    def display(self):
        print("Truck：车轮数量为：%d 个, 车轮重量为：%d Kg" %(self.getWheels(), self.getWeight()))

car = Car()
car.setWeight(5)
car.setWheels(4)
car.display()

truck = Truck()
truck.setWeight(10)
truck.setWheels(8)
truck.display()

3. 编写一个学生和教师数据输入和输出的程序。学生数据包括编号、姓名、班号、和成绩；教师的数据含有编号、姓名、职称和部门。要求设计一个person类，作为学生数据操作类student和教师数据操作类teacher的基类。

class Person(object):
    def __init__(self, id, name):
        self.id = id
        self.name = name

class Student(Person):
    def __init__(self, stu):
        Person.__init__(self, stu[0], stu[1])
        self.classId = stu[2]
        self.score = stu[3]
    def showInfo(self):
        print("学生的编号：%s, 姓名: %s, 班号：%s, 成绩：%s" %(self.id, self.name, self.classId, self.score))

class Teacher(Person):
    def __init__(self, tea):
        Person.__init__(self, tea[0], tea[1])
        self.job = tea[2]
        self.section = tea[3]
    def showInfo(self):
        print("教师的编号：%s, 姓名: %s, 班号：%s, 成绩：%s" %(self.id, self.name, self.job, self.section))

stu = input("请输入学生的编号、姓名、班号和成绩：").split()
student = Student(stu)
student.showInfo()

tea = input("请输入教师的编号、姓名、班号和成绩：").split()
teacher = Teacher(tea)
teacher.showInfo()

内容小结大全：

重定向：不使用系统的标准输入端口、标准输出端口或者标准错误端口，而进行重新的指定。在shell中，实现重定向主要依靠重定向符实现。（shell检查命令行有无重定向符来决定是否实施重定向）

• 输出重定向：>（覆盖式） , >>（追加式）
• 输入重定向：<
• 错误重定向：

硬链接：

• 链接文件和被链接文件必须位于同一个文件系统内（不可跨越文件系统）

• 普通用户不能建立指向目录的硬链接

• 创建目录项，在文件系统中允许不止一个目录项指向同一个文件

• 几乎不占用空间
  软链接：

• 链接文件和被链接文件可以位于不同的文件系统内（可跨越文件系统）

• 可以建立指向目录的硬链接

• 将一个文件指向另外一个文件的文件名

• 占用少量的空间存放索引节点和路径信息

• 如果链接指向的文件被移走，则无法通过软链接进行访问

Python3 支持 int、float、bool、complex（复数）。

Python 支持三种不同的数值类型：

• 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

函数：

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2. 在 python 中，类型属于对象，变量是没有类型的
3. 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

面向对象：

1. 类定义了 init() 方法，类的实例化操作会自动调用 init() 方法。
2. 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
3. 在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
4. 如果父类方法的功能不能满足需求，可以在子类重写父类的方法
5. Python同样有限的支持多继承形式
6. 类对象支持两种操作：属性引用和实例化。