*2021年《Linux与Python 编程R》复习大纲*

*适用于软件18级*
新做的一套题附带源代码：
https://blog.csdn.net/qq_51443459/article/details/117046643

一、 *Linux部分*

1． 简述Linux内核的基本功能。

内核主要有以下4个基本功能：系统内存管理；软件程序管理；硬件管理；文件系统管理

2． Linux终端的数量及工作方式。

3． 什么是shell？简述shell的命令解释过程。

​ shell是系统的用户界面，提供了用户与内核进行交互操作的一种接口(命令解释器) 。它接收用户输入的命令并把它送入内核去执行。起着用户与系统之间进行交互的作用。

命令解释过程：

shell命令分为
<mark>内部（内置）命令</mark>
内部命令是shell本身包含的一些命令，这些内部命令的代码是整个shell代码的一个组成部分；
内部命令的执行是shell通过执行自己的代码中的相应部分来完成的。
<mark>外部（外置）命令</mark>
外部命令的代码则存放在一些二进制的可执行文件或者shell脚本中；
外部命令执行时，shell会在文件系统中指定的一些目录去搜索相应的文件，然后调入内存执行。

4． Linux的文件目录结构（系统目录：/home、/var、/usr、/tmp 、 /dev、/bin、/etc的作用，目录：/home/用户名　～，“.”、“…”目录的含义）

. 代表目录自己

… 代表目录的父目录

5． 基本操作命令：cat、more、less、cp -rf、rm -r、mv、mkdir -p、rmdir -p、cd、pwd、ls -al

6． 链接命令ln -s的使用及其不同链接类型之间的区别，链接的作用，

ln -s 建立软连接

• 硬链接
  链接文件和被链接文件必须位于同一个文件系统内
  不能建立指向目录的硬链接
• 软链接
  链接文件和被链接文件可以位于不同文件系统
  可以建立指向目录的软链接

链接的作用：

为文件在另外一个位置建立一个同步的链接，当在不同目录需要该问题时，就不需要为每一个目录创建同样的文件，通过 ln 创建的链接（link）减少磁盘占用量。

7． 什么是重定向，并说明。

Linux重定向是指修改原来默认的一些东西，对原来系统命令的默认执行方式进行改变，

重定向可以分为输入重定向以及输出重定向这两种类型。

8． 挂载一个存储设备需要的信息

在挂载过程中需要明确指出所挂载的文件系统的类型、文件系统所在的设备名称以及在已有文件系统中的挂载点等挂载信息

9． Linux所支持的文件系统类型

• ext2与ext3文件系统
• swap文件系统
• vfat文件系统
• NFS文件系统
• ISO 9660文件系统

10． Linux系统中常用设备的名称

IDE hd[a-d]

SCIS/STAT/USE sd[a-p]

软盘 fd[0-2]

打印机 25针：lp[0-2]

USB：usb/lp[0-15]

鼠标 USB:usb/mouse[0-15]

PS2：psaux

当前CDROM/DVD cdrom

当前鼠标 mouse

磁带机 IDE：ht0

SCSI：st0

11． 文件权限

<mark>与权限相关的命令</mark>：

chmod
改变文件或目录的权限
chown
改变文件或目录的属主（所有者）
chgrp
改变文件或目录所属的组

二、 *Python部分*

12． Python交互式方式、代码文件方式

交互式编程，就是在命令行中输入python 命令即可启动交互式编程

通过脚本参数调用解释器开始执行脚本，直到脚本执行完毕。当脚本执行完成后，解释器不再有效，简单来说就是创建一个.py的文件，对其进行编写，然后运行，测试。

13． Python 语言集成开发环境IDLE

14． 导入模块的对象的几种方式

• import 模块名 as 别名 导入模块，并给该模块起别名
• from 模块名 import 对象名 as 别名 只导入模块中的指定对象，并给该对象起别名
• from 模块名 import* 导入模块中的所有对象

15． Python输入与输出

输入：input(“给用户的提示信息”) 无论输入什么一律返回字符串，可以使用强制类型转换

输出：print(value1, value2, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

sep参数之前为需要输出的内容（可以有多个）；
sep参数用于指定数据之间的分隔符，默认为空格；
end参数用于指定输出完数据之后再输出什么字符，默认是换行；

16． 标识符、赋值语句

标识符：用于变量、函数、类、模块等的名称。标识符有如下特定规则

1. 区分大小写
2. 第一个字符必须是字母、下划线、其后的字符是：字母、数字、下划线
3. 不能使用关键字。比如：if/or/while等
4. 尽量避免双下划线开头和结尾的名称通常有特殊含义。如：__int__是类的构造函数

17． 数据类型及运算

• int 整数
• float 浮点数
• complex 复数
• str 字符串
• list 列表
• dict 字典
• tuple 元组
• set 集合
• bool 布尔值 True False

运算：

运算符：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pvoBY71u-1621222806844)(C:\Users\ww\Desktop\笔记\img\image-20210507133952872.png)]

• 由于精度的问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据。
• 在数字的算术运算表达式求值时会进行隐式的类型转换，如果存在复数则都变成复数，如果没有复数但是有实数就都变成实数，如果都是整数则不进行类型转换。
• Python 3.6.x支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。
  在Python数字中单个下划线可以出现在中间任意位置，但不能出现开头和结尾位置，也不能使用多个连续的下划线。
• python 不支持++运算符 比如i++ 会报错

18． 控制语句

就是if语句 if else while语句等 看这个例子就行了

编写程序，实现人机对战的尼姆游戏。
from random import randint

n = int(input('请输入一个正整数：'))
while n > 1:
    #人类玩家先走
    print("该你拿了，现在剩余物品数量为：{0}".format(n))
    #确保人类玩家输入合法整数值
    while True:
        try:
            num = int(input('输入你要拿走的物品数量：'))
            #确保拿走的物品数量不超过一半
            assert 1 <= num <= n//2
            break
        except:
            print('最少必须拿走1个，最多可以拿走{0}个。'.format(n//2))
    n -= num
    if n == 1:
        print('恭喜,你赢了！')
        break
    #计算机玩家随机拿走一些，randint()用来生成指定范围内的一个随机数
    n -= randint(1, n//2)            
else:
    print('哈哈，你输了。')

19． 常用数据结构，序列：列表(列表推导式会计算)、元组、字符串、字典、集合

• 列表：

  • 列表（list）是最重要的Python内置对象之一，是包含若干元素的有序连续内存空间。

  • 在形式上，列表的所有元素放在一对方括号[]中，相邻元素之间使用逗号分隔

  • 在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。

  • 如果只有一对方括号而没有任何元素则表示空列表。

  • 例如：

    [10, 20, 30, 40]
    [‘crunchy frog’, ‘ram bladder’, ‘lark vomit’]
    [‘spam’, 2.0, 5, [10, 20]]
    [[‘file1’, 200,7], [‘file2’, 260,9]]
    [{3}, {5:6}, (1, 2, 3)]

  • 列表的创建

    • 可以直接赋值，也可以先创建一个空列表

  • 列表的删除

    • del 列表名

  • 列表访问：

    • 使用下标访问 从0开始

  • 列表常用方法：

    • append(x)	将x追加至列表尾部
      insert(index, x)	在列表index位置处插入x，该位置后面的所有元素后移并且在列表中的索引加1，如果index为正数且大于列表长度则在列表尾部追加x，如果index为负数且小于列表长度的相反数则在列表头部插入元素x
      remove(x)	在列表中删除第一个值为x的元素，该元素之后所有元素前移并且索引减1，如果列表中不存在x则抛出异常
      pop([index])	删除并返回列表中下标为index的元素，如果不指定index则默认为-1，弹出最后一个元素；如果弹出中间位置的元素则后面的元素索引减1；如果index不是[-L, L]区间上的整数则抛出异常
      clear()	清空列表，删除列表中所有元素，保留列表对象
      index(x)	返回列表中第一个值为x的元素的索引，若不存在值为x的元素则抛出异常
      count(x)	返回x在列表中的出现次数
      reverse()	对列表所有元素进行原地逆序，首尾交换
      sort(key=None, reverse=False)	对列表中的元素进行原地排序，key用来指定排序规则，reverse为False表示升序，True表示降序

  • 列表推导式：

    • 列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性

    • 列表推导式语法形式为：
      [expression for expr1 in sequence1 if condition1
      for expr2 in sequence2 if condition2
      for expr3 in sequence3 if condition3
      …
      for exprN in sequenceN if conditionN]

    • 例如：

      aList = [x*x for x in range(10)]

      相当于
      aList = []
      for x in range(10):
      aList.append(x*x)

  • 在列表推导式中使用if过滤不符合条件的元素：

    • 例如：

      aList = [-1, -4, 6, 7.5, -2.3, 9, -11]
      [i for i in aList if i>0] #所有大于0的数字
      [6, 7.5, 9]

  • 切片：

    • 在形式上，切片使用2个冒号分隔的3个数字来完成。
      [start​：end：​step]

    • 第一个数字start表示切片开始位置，默认为0；
      第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；
      第三个数字step表示切片的步长（默认为1）。
      当start为0时可以省略，当end为列表长度时可以省略，当step为1时可以省略，省略步长时还可以同时省略最后一个冒号。
      当step为负整数时，表示反向切片，这时start应该在end的右侧才行。

• 元组：

  • 形式上，元组的所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素则必须在最后增加一个逗号。

  • >>> x = (1, 2, 3)       #直接把元组赋值给一个变量
    >>> type(x)             #使用type()函数查看变量类型
    <class 'tuple'>
    >>> x[0]                #元组支持使用下标访问特定位置的元素
    1
    >>> x[-1]               #最后一个元素，元组也支持双向索引
    3
    >>> x[1] = 4            #元组是不可变的
    TypeError: 'tuple' object does not support item assignment
    >>> x = (3)             #这和x = 3是一样的
    >>> x
    3
    >>> x = (3,)            #如果元组中只有一个元素，必须在后面多写一个逗号
    >>> x
    (3,)
    创建空元组的方式：
    1: x = ()
    2: x =tuple()
    3: tuple(range(5)) 把其他迭代对象加入元组
    

    <mark>元组是不可变的，不可以为元组添加或减少元素也不可以直接修改元组的值，也可以进行切片操作</mark>

  • 列表和元组都属于有序序列，都支持使用双向索引访问其中的元素，以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引，len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。

  • <mark>元组的速度比列表快，所以当遍历访问一些元素而不需要对其进行操作修改时可以使用元组，而且元组比列表更加安全</mark>

• 字典

  • • 字典（dictionary）是包含若干“键:值”元素的无序可变序列，字典中的每个元素包含用冒号分隔开的“键”和“值”两部分，表示一种映射或对应关系，也称关联数组。定义字典时，每个元素的“键”和“值”之间用冒号分隔，不同元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
    • 字典中元素的“键”可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。
    • 字典中的“键”不允许重复，“值”是可以重复的。

  • 使用赋值运算符“=”将一个字典赋值给一个变量即可创建一个字典变量。
    >>> aDict = {
           'server': 'db.diveintopython3.org', 'database': 'mysql'}
    
    也可以使用内置类dict以不同形式创建字典。
    >>> x = dict()                               #空字典
    >>> type(x)                                  #查看对象类型
    <class 'dict'>
    >>> x = {
           }                                   #空字典
    >>> keys = ['a', 'b', 'c', 'd']
    >>> values = [1, 2, 3, 4]
    >>> dictionary = dict(zip(keys, values))     #根据已有数据创建字典
    >>> d = dict(name='Dong', age=39)            #以关键参数的形式创建字典
    >>> aDict = dict.fromkeys(['name', 'age', 'sex'])
                                 #以给定内容为“键”，创建“值”为空的字典
    >>> aDict
    {
           'age': None, 'name': None, 'sex': None}
    
    

  • 字典中的每个元素表示一种映射关系或对应关系，根据提供的“键”作为下标就可以访问对应的“值”，如果字典中不存在这个“键”会抛出异常。
    
    >>> aDict = {
           'age': 39, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
    >>> aDict['age']                     #指定的“键”存在，返回对应的“值”
    39
    >>> aDict['address']                 #指定的“键”不存在，抛出异常
    KeyError: 'address'
    
    

  • • 使用字典对象的items()方法可以返回字典的键、值对。
    • 使用字典对象的keys()方法可以返回字典的键。
    • 使用字典对象的values()方法可以返回字典的值。
    • 使用get方法可以获得键对应的值
  • • 当以指定“键”为下标为字典元素赋值时，有两种含义：
      若该“键”存在，则表示修改该“键”对应的值；
      若不存在，则表示添加一个新的“键:值”对，也就是添加一个新元素

  • update()方法可以将另一个字典的“键:值”一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。

  • 删除字典元素：

    • 如果需要删除字典中指定的元素，可以使用del命令。
      del aDict[‘age’] #删除字典元素
    • 使用字典对象的pop()和popitem()方法弹出并删除指定的元素

• 集合

  • 集合（set）属于Python无序可变序列，使用一对大括号作为定界符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不允许重复。
  • 创建
    • 直接将集合赋值给变量即可创建一个集合对象
    • 使用函数set()函数将列表、元组、字符串、range对象等其他可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个；如果原序列或迭代对象中有不可哈希的值无法转换成为集合，抛出异常
  • 集合的操作与运算
    • 添加元素：
      • add() 如果元素已存在则忽略
      • update 方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。
      • pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；
      • remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常；
      • discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
      • clear()方法清空集合删除所有元素。
    • 集合运算

• 字符串

  • 在Python中，字符串属于不可变有序序列，使用单引号、双引号、三单引号或三双引号作为定界符，并且不同的定界符之间可以互相嵌套。

  • 除了支持序列通用方法（包括双向索引、比较大小、计算长度、元素访问、切片、成员测试等操作）以外，字符串类型还支持一些特有的操作方法，例如字符串格式化、查找、替换、排版等等。

  • 字符串属于不可变序列，不能直接对字符串对象进行元素增加、修改与删除等操作，切片操作也只能访问其中的元素而无法使用切片来修改字符串中的字符。

  • Python 3.x完全支持中文字符，默认使用UTF8编码格式，无论是一个数字、英文字母，还是一个汉字，在统计字符串长度时都按一个字符对待和处理。

  • 为了避免对字符串中的转义字符进行转义，可以使用原始字符串，在字符串前面加上字母r或R表示原始字符串，其中的所有字符都表示原始的含义而不会进行任何转义

  • path = 'C:\Windows\notepad.exe'
    >>> print(path)                       #字符\n被转义为换行符
    C:\Windows
    otepad.exe
    >>> path = r'C:\Windows\notepad.exe'  #原始字符串，任何字符都不转义
    >>> print(path)
    C:\Windows\notepad.exe
    
    

  • 字符串对象是不可变的，所以字符串对象提供的涉及到字符串“修改”的方法都是返回修改后的新字符串，并不对原始字符串做任何修改，无一例外。

  • 字符串的常用方法

    • find()和rfind方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果不存在则返回-1；

    • index()和rindex()方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则抛出异常；

    • count()方法用来返回一个字符串在当前字符串中出现的次数。

    • split()和rsplit()方法分别用来以指定字符为分隔符，把当前字符串从左往右或从右往左分隔成多个字符串，并返回包含分隔结果的列表；

    • partition()和rpartition()用来以指定字符串为分隔符将原字符串分隔为3部分，即分隔符前的字符串、分隔符字符串、分隔符后的字符串，如果指定的分隔符不在原字符串中，则返回原字符串和两个空字符串。

    • 对于split()和rsplit()方法，如果不指定分隔符，则字符串中的任何空白符号（空格、换行符、制表符等）都将被认为是分隔符，把连续多个空白字符看作一个分隔符，还可以指定分割次数，如果大于最大分割次数则无效。

    • 字符串连接join()

      >>> li = ["apple", "peach", "banana", "pear"]
      >>> ','.join(li)
      'apple,peach,banana,pear'
      >>> '.'.join(li)
      'apple.peach.banana.pear'
      >>> '::'.join(li)
      'apple::peach::banana::pear'
      
      

    • lower()、upper()、capitalize()、title()、swapcase()

      >>> s = "What is Your Name?"
      s.lower()                   #返回小写字符串
      'what is your name?'
      s.upper()                   #返回大写字符串
      'WHAT IS YOUR NAME?'
      s.capitalize()              #字符串首字符大写
      'What is your name?'
      s.title()                   #每个单词的首字母大写
      'What Is Your Name?'
      s.swapcase()                #大小写互换
      'wHAT IS yOUR nAME?'
      

    • 查找替换replace()，类似于Word中的“全部替换”功能

      s = "中国，中国"
      >>> print(s)
      中国，中国
      >>> s2 = s.replace("中国", "中华人民共和国")  #两个参数都作为一个整理
      >>> print(s2)
      中华人民共和国，中华人民共和国
      
      

    • strip()、rstrip()、lstrip()

      >>> s = " abc "
      >>> s.strip()                             #删除空白字符
      'abc'
      >>> '\n\nhello world \n\n'.strip()      #删除空白字符
      'hello world'
      >>> "aaaassddf".strip("a")                #删除指定字符
      'ssddf'
      >>> "aaaassddf".strip("af")
      'ssdd'
      >>> "aaaassddfaaa".rstrip("a")            #删除字符串右端指定字符
      'aaaassddf'
      >>> "aaaassddfaaa".lstrip("a")            #删除字符串左端指定字符
      'ssddfaaa'
      
      

  • 字符串对象支持运算符

    • 乘法就是表示序列重复，也就是字符串内容的重复，得到新字符串。

  • 内置函数eval()用来把任意字符串转化为Python表达式并进行求值。

20． 经典算法编程实现（排序、矩阵与极值【不使用内置函数模式】）

21． 函数的定义、调用、形参、实参、返回值, 位置参数、关键参数、可变长度参数、全局变量global

• 定义：def 函数名([参数列表]):
  ‘’‘注释’’’
  函数体

• 注意事项：

  • 函数形参不需要声明类型，也不需要指定函数返回值类型

  • 即使该函数不需要接收任何参数，也必须保留一对空的圆括号

  • 括号后面的冒号必不可少

  • 函数体相对于def关键字必须保持一定的空格缩进

  • Python允许嵌套定义函数

• 函数的调用：

  • 先定义函数：比如定义一个计算斐波那契数列的函数：def fib(n):
    a, b = 1, 1
    while a < n:
    print(a, end=’ ')
    a, b = b, a+b
    print()

  • 调用函数：函数名(参数值) fib(1000)

  • 递归调用：

    • 函数的递调用是函数自己调用自己然后自己再调用自己。。。。当某个条件得到满足时就不再调用然后一层一层返回到函数第一次调用的位置 比如利用递归计算阶乘：

      def factor(i):
          if(i==0):
          return 1
      	else:
          return i*factor(i-1)
      

  • 函数的参数：

    • 函数定义时圆括弧内是使用逗号分隔开的形参列表（parameters），函数可以有多个参数，也可以没有参数，但定义和调用时一对圆括弧必须要有，表示这是一个函数并且不接收参数。

    • 调用函数时向其传递实参（arguments），根据不同的参数类型，将实参的引用传递给形参。

    • 定义函数时不需要声明参数类型，解释器会根据实参的类型自动推断形参类型。

    • 位置参数（positional arguments）是比较常用的形式，调用函数时实参和形参的顺序必须严格一致，并且实参和形参的数量必须相同。

    • 在调用带有默认值参数的函数时，可以不用为设置了默认值的形参进行传值，此时函数将会直接使用函数定义时设置的默认值，当然也可以通过显式赋值来替换其默认值。在调用函数时是否为默认值参数传递实参是可选的。

    • 在定义带有默认值参数的函数时，任何一个默认值参数右边都不能再出现没有默认值的普通位置参数，否则会提示语法错误。

      def 函数名(...,形参名 = 默认值)
      	函数体
      

    • 关键参数：关键参数主要指调用函数时的参数传递方式，与函数定义无关。通过关键参数可以按参数名字传递值，明确指定哪个值传递给哪个参数，实参顺序可以和形参顺序不一致，但不影响参数值的传递结果，避免了用户需要牢记参数位置和顺序的麻烦，使得函数的调用和参数传递更加灵活方便。

      def demo(a ,b ,c=5):
          print(a, b, c)
      demo(3, 5, 7)
      >>> 3,5,7
      demo(a=2, b=4, c=6)
      >>>2,4,6
      demo(b=3, c=6, a=9)
      >>>9,3,6
      

    • 可变长度参数：可变长度参数主要有两种形式：在参数名前加1个*或2个**

      • *parameter用来接收多个位置参数并将其放在一个元组中

      • **parameter接收多个关键参数并存放到字典中

      • *parameter用法：
        def demo(*p):
        	print(p)
        demo(1,2,3)
        >>>1,2,3
        demo(1,2)
        >>>1,2
        **parameter用法:
        def demo(**p):
        	for item in p.item:
                print(item)
        demo(x=1, y=2, z=3)
        >>> ('y', 2)
        	('x', 1)
        	('z', 3)      
        

  • lambda表达式

    • lambda表达式可以用来声明匿名函数，也就是没有函数名字的临时使用的小函数，尤其适合需要一个函数作为另一个函数参数的场合。也可以定义具名函数。

    • lambda表达式只可以包含一个表达式，该表达式的计算结果可以看作是函数的返回值，不允许包含复合语句，但在表达式中可以调用其他函数。

    • p = lambda x, y : x+y
      p(1, 2)
      3
      

  • 全局变量global

    • python的全局变量的用法为：python的全局变量的作用域为特定模块之内；

    • 在函数内，如不加global关键字，则该变量为局部变量，如该变量未声明，如对变量进行修改，会出问题。

23． 类的定义、属性（公有、私有）、方法、构造函数

• 类的定义：Python使用class关键字来定义类，class关键字之后是一个空格，接下来是类的名字，如果派生自其它基类的话则需要把所有基类放到一对圆括号中并使用逗号分隔，然后是一个冒号，最后换行并定义类的内部实现。

• 类名的首字母一般要大写，当然也可以按照自己的习惯定义类名，但是一般推荐参考惯例来命名，并在整个系统的设计和实现中保持风格一致。

• class Car(object):              #定义一个类，派生自object类
      def infor(self):            #定义成员方法
          print("This is a car")
  
  

• 定义了类之后，就可以用来实例化对象，并通过“对象名.成员”的方式来访问其中的数据成员或成员方法。

• • 公有属性和私有属性

    • 私有成员在类的外部不能直接访问，一般是在类的内部进行访问和操作，或者在类的外部通过调用对象的公有成员方法来访问，而公有成员是可以公开使用的，既可以在类的内部进行访问，也可以在外部程序中使用。
    • 从形式上看，在定义类的成员时，如果成员名以两个下划线开头但是不以两个下划线结束则表示是私有成员，否则就不是私有成员。
    • Python并没有对私有成员提供严格的访问保护机制，通过一种特殊方式“对象名._类名__xxx”也可以在外部程序中访问私有成员，但这会破坏类的封装性，不建议这样做。

• 方法：

  • Python类的成员方法大致可以分为公有方法、私有方法、静态方法、类方法这几种类型。
  • 公有方法、私有方法一般是指属于对象的实例方法，私有方法的名字以两个开始，而抽象方法一般定义在抽象类中并且要求派生类必须重新实现。每个对象都有自己的公有方法和私有方法，在这两类方法中都可以访问属于类和对象的成员。公有方法通过对象名直接调用，私有方法不能通过对象名直接调用，只能在其他实例方法中通过前缀self进行调用或在外部通过特殊的形式来调用。
  • 所有实例方法都必须至少有一个名为self的参数，并且必须是方法的第一个形参（如果有多个形参的话），self参数代表当前对象。
  • 在实例方法中访问实例成员时需要以self为前缀，但在外部通过对象名调用对象方法时并不需要传递这个参数。
  • 如果在外部通过类名调用属于对象的公有方法，需要显式为该方法的self参数传递一个对象名，用来明确指定访问哪个对象的成员
  • 静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
  • 静态方法和类方法不属于任何实例，不会绑定到任何实例，当然也不依赖于任何实例的状态，与实例方法相比能够减少很多开销。
  • 类方法一般以cls作为类方法的第一个参数表示该类自身，在调用类方法时不需要为该参数传递值，静态方法则可以不接收任何参数。

• 构造函数：

  • Python中类的构造函数是__init__()，一般用来为数据成员设置初值或进行其他必要的初始化工作，在创建对象时被自动调用和执行。如果用户没有设计构造函数，Python将提供一个默认的构造函数用来进行必要的初始化工作。
    

24． 类的继承

• 继承：

  • 继承是用来实现代码复用和设计复用的机制，是面向对象程序设计的重要特性之一。设计一个新类时，如果可以继承一个已有的设计良好的类然后进行二次开发，无疑会大幅度减少开发工作量。

  • 在继承关系中，已有的、设计好的类称为父类或基类，新设计的类称为子类或派生类。派生类可以继承父类的公有成员，但是不能继承其私有成员。如果需要在派生类中调用基类的方法，可以使用内置函数super()或者通过“基类名.方法名()”的方式来实现这一目的。

  • Python支持多继承，如果父类中有相同的方法名，而在子类中使用时没有指定父类名，则Python解释器将从左向右按顺序进行搜索。

  • class Person(object): 
        def __init__(self, name='', age=20, sex='man'):
            #通过调用方法进行初始化，这样可以对参数进行更好地控制
            self.setName(name)
            self.setAge(age)
            self.setSex(sex)
    
        def setName(self, name):
            if not isinstance(name, str):
                raise Exception('name must be string.')
            self.__name = name
    
        def setAge(self, age):
            if type(age) != int:
                raise Exception('age must be integer.')
            self.__age = age
    
        def setSex(self, sex):
            if sex not in ('man', 'woman'):
                raise Exception('sex must be "man" or "woman"')
            self.__sex = sex
    
        def show(self):
            print(self.__name, self.__age, self.__sex, sep='\n')
            派生类
    class Teacher(Person):
        def __init__(self, name='', age=30,
                      sex='man', department='Computer'):
            #调用基类构造方法初始化基类的私有数据成员
            super(Teacher, self).__init__(name, age, sex)
            #也可以这样初始化基类的私有数据成员
            #Person.__init__(self, name, age, sex)
            #调用自己的方法初始化派生类的数据成员
            self.setDepartment(department)
    
        #在派生类中新增加的方法
        def setDepartment(self, department):
            if type(department) != str:
                raise Exception('department must be a string.')
            self.__department = department
    
        #覆盖了从父类中继承来的方法
        def show(self):
            #先调用父类的同名方法，显示从父类中继承来的数据成员
            super(Teacher, self).show()
            #再显示派生类中的私有数据成员
            print(self.__department)
    
    

属性：

• 只读属性：

  • class Test:
    	    def __init__(self, value):
    		self.__value = value
    
    	    @property
    	    def value(self):               #只读，无法修改和删除
    		return self.__value
    >>> t = Test(3)
    >>> t.value
    3
    >>> t.value = 5                        #只读属性不允许修改值
    AttributeError: can't set attribute
    >>> t.v=5                              #动态增加新成员
    >>> t.v
    5
    >>> del t.v                            #动态删除成员
    >>> del t.value                        #试图删除对象属性，失败
    AttributeError: can't delete attribute
    >>> t.value
    3
    
    

• 可读可写属性

  • class Test:
        def __init__(self, value):
            self.__value = value	
    
        def __get(self):
            return self.__value
    
        def __set(self, v):
            self.__value = v
        value = property(__get, __set)
    
        def show(self):
            print(self.__value)
    >>> t = Test(3)
    >>> t.value      #允许读取属性值
    3
    >>> t.value = 5  #允许修改属性值
    >>> t.value
    5
    >>> t.show()     #属性对应的私有变量也得到了相应的修改
    5
    >>> del t.value  #试图删除属性，失败
    AttributeError: can't delete attribute
    
    

*《Linux与Python 编程R********》试卷题型*

一、填空题（每空1分，共20分）

二、程序阅读(每题2分，共20分)

三、判断题(每题1分，共10分)

四、简答题（本大题共4小题，每小题5分，共20分） *按要点给分*

*包括：2题，程序写结果*

五、编程题（本大题共3小题，每小题10分共30分）

*Linux（20%）,Python（80%）*