Python 练习

1. 填空题

Python 是一种面向对象的高级语言。
Python 可以在多种平台运行，这体现了 Python 语言的可移植性特性。
Python 3.x 默认使用的编码是UTF-8。
在 Python 中，int 表示的是数据类型是整型。
布尔类型的值包括True 和False。
如果想知道变量的类型，可以使用type( ) 函数来实现。
字符串是一种表示文本数据的类型。
Python 3 提供了input函数从控制台读入一行文本。
Python 序列类型包括字符串、列表和元组三种，字典是 Python 中唯一的映射类型。
Python 中的可变数据类型有字典和列表。
判断列表中是否存在该元素时可以使用not in和 in 运算符。
如果要从小到大地排列列表的元素，可以使用sort方法实现。
元组使用小括号存放元素，列表使用的是方括号。
在循环体中使用break语句可以跳出循环体。
elif 语句是 else 语句和 if 语句的组合。
在循环体中可以使用continue语句跳过本次循环后面的代码，重新开始下一次循环。
如果希望循环是无限的，我们可以通过设置条件表达式永远为True来实现无限循环。
函数可以有多个参数，参数之间使用逗号分隔。
使用return语句可以返回函数值并退出函数。
通过return结束函数，从而选择性地返回一个值给调用方。
函数能处理比声明时更多的参数，它们是不定长参数。
在函数里面调用另外一个函数，这就是函数递归（嵌套） 调用。
在函数内部定义的变量称作局部变量。
全局变量定义在函数外，可以在整个程序范围内访问。
如果想在函数中修改全局变量，需要在变量的前面加上global关键字。
要调用 random 模块的 randint 函数，书写形式为random.randint。
每个 Python 文件都可以作为一个模块，模块的名字就是文件的名字。
每个模块都有一个__name__属性，使程序块只能在模块自身运行时执行。
为了更好地组织模块，通常会把多个模块放在一个包中。
当程序中需要引入外部模块时，需要从外面下载并安装。
如果要搜索模块的路径，可以使用 sys 模块的path变量。
Python 源代码被解释器转换后的格式为字节码（.pyc）。
Python 中的pass表示的是空语句。
在 Python 中，可以使用class关键字来声明一个类。
面向对象需要把问题划分为多个独立的对象，然后调用其方法解决问题。
对象的方法中必须有一个self参数，位于参数列表的开头。
类的方法中必须有一个cls参数，位于参数列表的开头。
Python 提供了名称为__init__的初始化方法，实现让类的对象完成初始化。
如果想修改属性的默认值，可以在初始化方法中使用参数设置。
如果属性名的前面加了两个__（下划线），就表明它是私有属性。
在现有类基础上构建新类，新的类称作子类，现有的类称作父类。
父类的私有属性和方法是不能被子类继承的，更不能被子类访问。
Python 语言既支持单继承，也支持多继承。
子类想按照自己的方式实现方法，需要重写从父类继承的方法。
子类通过super()可以成功地访问父类的成员。
位于类内部、方法外部的方法是 类方法。
类方法是类拥有的方法，使用修饰器@classmethod来标识。
内部函数引用了外部函数作用域的变量，那么内部函数叫作闭包。
装饰器本质上是一个函数。
装饰器函数需要接收一个参数，这个参数表示被修饰的函数。
在函数定义的前面添加装饰器名和@符号，实现对函数的包装。
支持参数的装饰器函数需要再多一层内嵌函数。
map函数会根据提供的函数对指定的序列做映射。
map 的两个序列的元素个数不一致，那么元素少的序列会以None补齐。
filter函数会对指定序列执行过滤操作。
filter 传入的函数的返回值是布尔值。
reduce 传入的是带有两个参数的函数。

2. 判断题

Python 是开源的，它可以被移植到许多平台上。（对）
Python 的优点之一是具有伪代码的本质。（对）
Python 可以开发 Web 程序，也可以管理操作系统。（对）
Python 3.x 版本的代码完全兼容 Python 2.x。（错）
PyCharm 是开发 Python 的集成开发环境。（对）
Python 使用符号 # 表示单行注释。（对）
标识符可以以数字开头。（错）
type() 方法可以查看变量的数据类型。（对）
Python 中的代码块使用缩进来表示。（对）
Python 中的多行语句可以使用反斜杠来连接。（对）
Python 中的标识符不区分大小写。（错）
Python 中的标识符不能使用关键字。（对）
Python 中的成员运算符 in 用于判断指定序列中是否包含某个值。（对）
比较运算符用于比较两个数，其返回的结果只能是 True 或 False。（对）
无论使用单引号或双引号包含字符，使用 print 输出的结果都一样。（对）
Python 中字符串的下标是从 1 开始的。（错）
切片选取的区间范围是从起始位开始，到结束位结束，不包含结束位置。（对）
无论 input 接收任何的数据，都会以字符串的方式进行保存。（对）
列表的索引是从 0 开始的。（对）
通过 insert 方法可以在指定位置插入元素。（对）
使用下标能修改列表的元素。（对）
列表的嵌套指的是一个列表的元素是另一个列表。（对）
通过下标索引可以修改和访问元组的元素。（错）
字典中的值只能是字符串类型。（错）
在字典中，可以使用 count 方法计算键值对的个数。（错）
elif 可以单独使用。（错）
每个 if 条件后面都要使用冒号。（对）
循环语句可以嵌套使用。（对）
函数的名称可以随意命名。（错）
不带 return 的函数代表返回 None。（对）
默认情况下，参数值和参数名称是跟函数声明定义的顺序匹配的。（对）
函数定义完成后，系统会自动执行其内部的功能。（错）
函数体以冒号起始，并且是缩进格式的。（对）
带有默认值的参数一定位于参数列表的末尾。（对）
局部变量的作用域是整个程序，任何时候使用都有效。（错）
每个 Python 文件都是一个模块。（对）
当__name__属性的值为__main__时，代表该模块自身在运行。（对）
包目录下必须有一个__init__.py 文件。（对）
Python 程序被解释器转换后的文件格式后缀名为 .pyc。（对）
使用 help() 函数可以查看帮助。（对）
pass 语句的出现是为了保持程序结构的完整性。（对）
面向对象是基于面向过程的。（错）
通过类可以创建对象，有且只有一个对象实例。（错）
方法和函数的格式是完全一样的。（错）
创建类的对象时，系统会自动调用初始化方法进行初始化。（对）
创建完对象后，其属性的初始值是固定的，外界无法进行修改。（错）
使用 del 语句删除对象，可以手动释放它所占用的资源。（对）
Python 中没有任何关键字区分公有属性和私有属性。（对）
继承会在原有类的基础上产生新的类，这个新类就是父类。（错）
带有两个下划线的方法一定是私有方法。（对）
子类能继承父类的一切属性和方法。（错）
子类通过重写继承的方法，覆盖掉跟父类同名的方法。（对）
如果类属性和实例属性重名，对象优先访问类属性的值。（错）
使用类获取的值一定是类属性的值。（对）
静态方法中一定不能访问实例变量的值。（对）
使用下标可以访问字符串中的每个字符。（对）
如果 index 方法没有在字符串中找到子串，则会返回 −1。（错）
闭包是内部函数对外部作用域的变量进行引用。（错）
当外部函数执行结束，其内部闭包引用的变量一定会立即释放。（错）
装饰器是一个变量。（错）
装饰器函数至少要接收一个参数。（对）
装饰器既能装饰带参数的函数，也能自己带参数。（对）
如果 map 函数传入的两个序列个数不同，那么个数多的序列会把多余的元素删除。（错）
map 函数只能传递一个序列。（错）
map 传入函数的参数个数必须跟序列的个数一样。（对）
filter 传入的函数可以为 None。（对）
filter 函数只能对序列执行过滤操作。（错）
filter 函数的返回值为字符串，它的序列类型一定是字符串。（对）

3. 选择题

以下（A）不是 Python 的特性。

A. 收费使用

B. 跨平台

C. 可拓展

D. 可嵌入
Python 程序的文件扩展名是（C）。

A. .python

B. .p

C. .py

D. .pyth
Python 语言源程序的执行方式是（B）。

A. 编译执行

B. 解释执行

C. 直接执行

D. 边编译边执行
以下关于 Python 语言中注释说法错误的是（A）。

A. 注释语句可以被执行

B. 注释语句以#符号开头

C. 多行注释可以用'''将其包围起来

D. 单行注释可以和非注释语句的同一行，并出现在非注释语句之后
下列选项中，（D）的布尔值不是 False。

A. []

B. 0

C. ()

D. 1
假设 a = 9，b = 2，那么下列运算中，错误的是（D）。

A. a + b 的值是 11

B. a // b 的值是 4

C. a % b 的值是 1

D. a ** b 的值是 18
Python 3 支持多行语句，下面对于多行语句描述有误的是（D）。

A. 一行可以书写多个语句

B. 一个语句可以分多行书写

C. 一行多语句可以用分号隔开

D. 一个语句多行书写时直接按回车即可
标识符可以用于变量、函数、对象等的命名，对于标识符描述有误的的是（C）。

A. 标识符不可以以数字开头

B. 标识符可以由数字、字母和下划线组成

C. 标识符不区分大小写

D. 保留字符做标识符时会出错
下列标识符中，合法的是（D）。

A. hello World

B. 2ndObj

C. hello#world

D. _helloworld
下列符号中，表示 Python 中单行注释的是（A）。

A. #

B. //

C. 

D. ""
下列选项中，符合 Python 命名规范的标识符是（C）。

A. user-Passwd

B. if

C. _name

D. setup.exe
实际应用中变量的使用是避免不了的，而在 Python 中，如下变量使用正确的是（A）。

A. numvalue = 10

B. numSum += 10，不需要事先声明变量

C. Val 和 val 是同一个变量

D. yield = 'str'
下列选项中，Python 不支持的数据类型有（B）。

A. int

B. char

C. float

D. dict
下列表达式中，返回 True 的是（B）。

A. a = 2

B. 3 > 2 > 1

C. True and False

D. 2 != 2
下列语句中，（B）在 Python 中是非法的。

A. x = y = z = 1

B. x = (y = z + 1)

C. 2 < 3 == 2 < 4
下列选项中，幂运算的符号为（D）。

A. *

B. ++

C. %

D. **
如下对于字符串拼接有误的是（C）。

A. "Life is short, " "you need Python."

B. "Life is short, " + "you need Python."

C. "Life is short, " 2 * "you need Python."

D." "Life is short, " + 2 * "you need Python."
当需要在字符串中使用特殊字符时，Python 使用（A）作为转义字符。

A. \

B. /

C. #

D. %
下列数据中，不属于字符串的是（D）。

A. 'ab'

B. '''perfect'''

C. "52wo"

D. abc
下列数据类型中，不支持切片操作的是（C）。

A. 字符串

B. 列表

C. 字典

D. 元组
Python 中的序列类型数据结构元素的切片操作非常灵活且功能强大，对于列表 Letter=['a', 'b', 'c', 'd', 'e']，下述操作会正常输出结果的是（A）。

A. Letter[-4:-1:-1]

B. Letter(:3:2)

C. Letter[1:3:0]

D. Letter['a':'d':2]
关于列表的说法，描述错误的是（D）。

A. list 是一个有序集合，没有固定大小

B. list 可以存放任意类型的元素

C. 使用 list 时，其下标可以是负数

D. list 是不可变的数据类型
以下程序的输出结果是（B）。
```
list = [1, 2, 3, 4, 5, 'a', 'b']
print(list[1], list[5])
```
A. 1　5

B. 2　a

C. 1　97

D. 2　97
列表类型数据结构拥有很多方法和函数，可以实现对列表对象的常用处理，对于列表对象 names=['Lucy', 'Lily', 'Tom', 'Mike', 'David']，下述列表方法和函数使用正确的是（D）。

A. names.append('Helen', 'Mary')

B. names.remove(1)

C. names.index('Jack')

D. names[2]='Jack'
执行下面的操作后，list2 的值为（C）。
```
list1 = [4, 5, 6]
list2 = list1
list1[2] = 3
```
A. [4, 5, 6]

B. [4, 3, 6]

C. [4, 5, 3]

D. A，B，C 都不正确
Python 中的数据结构可分为可变类型与不可变类型，下面属于不可变类型的是（C）。

A. 字典

B. 列表

C. 字典中的键

D. 集合（set 类型）
阅读下面的程序：
```
list = [1, 2, 1, 3]
nums = set(list)
for i in nums:
    print(i, end="")
```
程序执行的结果为（D）。

A. 1213

B. 213

C. 321

D. 123
下列选项中，正确定义了一个字典的是（D）。

A. a=['a', 1, 'b', 2, 'c', 3]

B. b=('a', 1, 'b', 2, 'c', 3)

C. c={'a', 1, 'b', 2, 'c', 3}

D. d={'a':1, 'b':2, 'c':3}
下列选项中，不能使用下标运算的是（C）。

A. 列表（list）

B. 元组（tuple）

C. 集合（set）

D. 字符串（str）
下列程序执行后输出的结果为（A）。
```
x = 'abc'
y = x
y = 100
print(x)
```
A. ”abc”

B. 100

C. 97, 98, 99

D. 以上三项均是错误的
删除列表中最后一个元素的函数是（B）。

A. del

B. pop

C. remove

D. cut
下列函数中，用于返回元组中元素最小值的是（C）。

A. len

B. max

C. min

D. tuple
在 Python 中实现多个条件判断需要用到（B）语句与 if 语句的组合。

A. else

B. elif

C. pass

D. 以上均不正确
循环中可以用（C）语句来跳出深度循环。

A. pass

B. continue

C. break

D. 以上均可以
可以使用（B）语句跳出当前循环的剩余语句，继续进行下一轮循环。

A.pass

B.continue

C.break

D. 以上均可以
在 for i in range(6) 语句中，i 的取值是（D）。

A. [1, 2, 3, 4, 5, 6]

B. [1, 2, 3, 4, 5]

C. [0, 1, 2, 3, 4]

D. [0, 1, 2, 3, 4, 5]

下列选项中，会输出 1，2，3 三个数字的是（C）。

for i in range(3):
    print(i)

for i in range(2):
    print(i + 1)

aList = [0, 1, 2]
for i in aList:
    print(i + 1)

i = 1
while i < 3:
    print(i)
    i = i + 1

阅读下面的代码：

sum=0

for i in range(100):
    if i % 10:
        continue
    sum = sum + i

print(sum)

上述程序的执行结果是（C）。

A. 5050

B. 4950

C. 450

D. 45

已知 x = 10，y = 20，z = 30；以下语句执行后 x，y，z 的值是（C）。
```
if x < y:
    z = x
    x = y
    y = z
```
A. 10，20，30

B. 10，20，20

C. 20，10，10

D. 20，10，30
列表解析式 [i + 6 for i in range(0, 3)] 返回的结果是（C）。

A. [1, 2, 3]

B. [0, 1, 2]

C. [6, 7, 8]

D. [7, 8, 9]
有一个列表 L = [4, 6, 8, 10, 12, 5, 7, 9]，列表解析式 [x for x in L if x % 2 == 0] 返回的结果是（C）。

A. [4, 8, 12, 7]

B. [6, 10, 5, 9]

C. [4, 6, 8, 10, 12]

D. [5, 7, 9]
如下代码中可以正确运行出结果的是（C）。

A. [n for i in range(0, 3)]

B. [n = I for I in range(0, 3)]

C. [j for j in range(0, 3)]

D. 以上均可以
可变参数 *args 传入函数时的存储方式为（A）。

A. 元组

B. 列表

C. 字典

D. 数据框
可变参数 **kwargs 传入函数时的存储方式为（B）。

A. 元组

B. 字典

C. 列表

D. 数据框

有一个函数关系表如下所示：

x	y
`x < 0`	`x - 1`
`x = 0`	`x`
`x > 0`	`x + 1`

下面程序段中，能正确表示上面关系的是（C）。

y = x + 1
if x >= 0:
    if x == 0:
        y = x
    else:
        y = x - 1

y = x - 1
if x != 0:
    if x > 0:
        y = x + 1
    else:
        y = x

if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x
else:
    y = x + 1

y = x
if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x + 1

阅读下面的程序：
```
def func():
    print(x)
    x = 100

func()
```
执行上述语句后，输出的结果为（C）。

A. 0

B. 100

C. 程序出现异常

D. 程序编译失败
下面关于函数的说法，错误的是（C）。

A. 函数可以减少代码的重复，使得程序更加模块化

B. 在不同的函数中可以使用相同名字的变量

C. 调用函数时，位置传参的顺序和函数定义时的顺序可以不同

D. 函数体中如果没有 return 语句，也会返回一个 None 值
下列有关函数的说法中，正确的是（C）。

A. 函数的定义必须在程序的开头

B. 函数定义后，其中的程序就可以自动执行

C. 函数定义后需要调用才会执行

D. 函数体与关键字 def 必须左对齐
下列函数调用使用的参数传递方式是（A）。
```
result = sum(1, 2)
```
A. 位置

B. 关键字

C. 变量类型

D. 变量名称
使用（C）关键字创建自定义函数。

A. function

B. func

C. def

D. procedure
下列关键字中，用来引入模块的是（C）。

A. include

B. from

C. import

D. continue
关于引入模块的方式，错误的是（D）。

A. import math

B. from fib import fibonacci

C. from math import *

D. from * import fib
关于__name__的说法，下列描述错误的是（A）。

A. 它是 Python 提供的一个方法

B. 每个模块内部都有一个 __name__ 属性

C. 当它的值为 __main__ 时，表示模块自身在运行

D. 当它的值不为 __main__ 时，表示模块被引用
在面向对象程序设计的发展中引入了对象、对象类、方法、实例等概念和术语，采用动态联编和单继承机制，以至于被视为面向对象的基础的语言是（A）。

A. Simula

B. Smautalk

C. BASIC

D. Java
关于面向过程和面向对象，下列说法错误的是（B）。

A. 面向过程和面向对象都是解决问题的一种思路

B. 面向过程是基于面向对象的

C. 面向过程强调的是解决问题的步骤

D. 面向对象强调的是解决问题的对象
关于类和对象的关系，下列描述正确的是（D）。

A. 类是面向对象的核心

B. 类是现实中事物的个体

C. 对象是根据类创建的，并且一个类只能对应一个对象

D. 对象描述的是现实的个体，它是类的实例
以下关于 self 的说法不正确的是（A）。

A. self 可有可无，它的参数位置也不确定

B. self 是可以修改的

C. self 代表当前对象的地址

D. self 不是关键词，也不用赋值
构造方法的作用是（D）。

A. 一般成员方法

B. 类的初始化

C. 对象的初始化

D. 对象的建立
初始化方法是类的一个特殊方法，Python 中它的名称为（C）。

A. 与类同名

B. _construct

C. __init__

D. init
Python 类中包含一个特殊的变量（A），它表示当前对象自身，可以访问类的成员。

A. self

B. me

C. this

D. 与类同名
下列选项中，符合类的命名规范的是（A）。

A. HolidayResort

B. Holiday Resort

C. holidayResort

D. holidayresort
Python 中用于释放类占用资源的方法是（B）。

A. __init__

B. __del__

C. _del

D. delete
Python 中定义私有属性的方法是（D）。

A. 使用 private 关键字

B. 使用 public 关键字

C. 使用 __XX__ 定义属性名

D. 使用 __XX 定义属性名
下列选项中，不属于面向对象程序设计的三个特征的是（A）。

A. 抽象

B. 封装

C. 继承

D. 多态
以下 C 类继承 A 类和 B 类的格式中，正确的是（C）。

A. class C A, B:

B. class C(A: B):

C. class C(A, B):

D. class C A and B:
下列关于类属性和实例属性的说法中，描述正确的是（B）。

A. 类属性既可以显式定义，又能在方法中定义

B. 公有类属性可以通过类和类的实例访问

C. 通过类可以获取实例属性的值

D. 类的实例只能获取实例属性的值
下列选项中，用于标识为静态方法的是（C）。

A. @classmethod

B. @instancemethod

C. @staticmethod

D. @privatemethod
下列选项中，用于标识为类方法的是（A）。

A. @classmethod

B. @instancemethod

C. @staticmethod

D. @privatemethod
下列方法中，不可以使用类名访问的是（A）。

A. 实例方法

B. 类方法

C. 静态方法

D. 以上 3 项都不符合
生成器都是 Iterator 对象，但 list、dict、str 虽然都是 Iterable，却不是 Iterator。若要把 Iterable 变成 Iterator，在 Python 中应该使用（D）。

A. capitalize 函数

B. Iterable 函数

C. Iterator 函数

D. iter 函数
下列方法中，能够返回某个子串在字符串中出现次数的是（C）。

A. length

B. index

C. count

D. find
下列方法中，能够让所有单词的首字母变成大写的方法是（B）。

A. capitalize

B. title

C. upper

D. ljust
字符串的 strip 方法的作用是（A）。

A. 删除字符串头尾指定的字符

B. 删除字符串末尾的指定字符

C. 删除字符串头部的指定字符

D. 通过指定分隔符对字符串切片
使用（D）关键字声明匿名函数。

A. function

B. func

C. def

D. lambda
关于装饰器，下列说法错误的是（B）。

A. 装饰器是一个包裹函数

B. 装饰器只能有一个参数

C. 通过在函数定义的前面加上 @ 符号和装饰器名，使得装饰器函数生效

D. 如果装饰器支持参数，其必须再嵌套一层函数
下列函数中，用于使用函数对指定序列进行过滤的是（C）。

A. map 函数

B. select 函数

C. filter 函数

D. reduce 函数
下列选项中，不能作为 filter 函数参数的是（D）。

A. 列表

B. 元组

C. 字符串

D. 整数
阅读下面一段程序：
```
def foo():
    a = 1

    def bar():
        a = a + 1
        return a

    return bar

print(foo()())
```
上述程序执行的结果为（B）。

A. 程序出现异常

B. 2

C. 1

D. 没有输出结果

4. 简答题

简述 Python 中标识符的命名规则。
点我看分析
第一个字符只能是字母、下划线（_）、Unicode 字符（中文）

标识符的其他部分可以有字母、下划线、数字、Unicode 字符组成

标识符严格区分大小写

标识符不允许为关键字

标识符建议为有意义的命名
请简述元组、列表和字典的区别。
点我看分析
外形：列表是中括号括起来的数据；元组是圆括号括起来的数据；字典是花括号括起来的数据

存储结构：列表可以存储多个不同类型的数据，以逗号分隔；元组同样能存储多个不同类型的数据，以逗号分隔；字典能存储多个键值对，以逗号分隔，键是唯一的，值是任何类型的。

访问方式：列表可以通过下标索引访问元素，索引从 0 开始；元组可以通过下标索引访问值，索引从 0 开始；字典通过键来访问值。

是否可变类型：列表是可变类型，列表是不可变类型，字典是可变类型。
简述 break 和 continue 的区别。

点我看分析
break 语句用于结束整个循环；continue 的作用是用来结束本次循环，紧接着执行下一次的循环。
请简述局部变量和全局变量的区别。
点我看分析
局部变量：

函数内部定义的变量；

作用域是函数的内部。

全局变量：

函数外部定义的变量；

作用域是整个程序。
请简要说明函数定义的规则。
点我看分析
以 def 关键字开头，后面接函数标识符名称和圆括号；

给函数起名字的时候，规则跟变量的名字是一样的；

任何传入参数和自变量必须放在圆括号中间；

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明；

函数内容以冒号起始，并且缩进；

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
解释 Python 脚本程序的 __name__ 的作用。

点我看分析
每个 Python 脚本在运行时都有一个__name__属性。如果脚本作为模块被导入，则其__name__属性的值被自动设置为模块名；如果脚本独立运行，则其__name__属性值被自动设置为__main__属性。利用__name__属性即可控制 Python 程序的运行方式。
请简述模块的概念。

点我看分析
.py 文件都是一个模块，
请简述导入模块的方法。
点我看分析
在 Python 中用关键字 import 来引入某个模块：

导入模块，使用import 模块引入；

导入模块中的某个函数，使用from 模块名 import 函数名引入；

导入模块的全部内容，使用from 模块 import *；

从模块包中导入模块，使用from 模块包 import 模块。
简述 Python 中 pass 语句的作用。

点我看分析
Pass 语句 Python 中的 pass 是空语句，它的出现是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
请简述 self 在类中的意义。

点我看分析
不用实例化对象就能够在本类中访问自身的属性或方法。
类是由哪三个部分组成的？

点我看分析
类名，属性，方法
请简述构造方法和析构方法的作用。

点我看分析
分别用于初始化对象的属性和释放类所占用的资源。
什么是继承？

点我看分析
类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类的属性和方法。
请简述私有属性或私有方法无法访问的原理。

点我看分析
当在一个类的内部定义了私有方法或者私有属性的时候，Python 在运行的过程中，把属性或者方法的名字进行了修改，即在属性或者方法名称的前面加上__类名，导致原有的方法无法访问到。
什么是多态？

点我看分析
在 Python 中，多态是指在不考虑对象类型的情况下使用对象。
多态的体现：对不同对象调用同一方法，自动根据对象所属类不同，而做出不同的响应。
请简述实例方法、类方法和静态方法的区别。

点我看分析
类方法需要使用 @classmethod 进行标识，该方法可以访问类属性，无法访问实例属性，可以通过类实例和类进行调用。
静态方法使用 @staticmethod 进行标识，该方法无法访问实例属性和类属性，起到类似于函数的作用，使用类或者类实例进行调用。
实例方法直接在类中使用 def 进行定义，可以访问其实例属性和类属性，使用类实例进行调用。
如果要修改实例属性的值，就直接使用实例方法；如果要修改类属性的值，就直接使用类方法；如果是辅助功能，比如打印菜单，这时可以考虑使用静态方法，可以在不创建对象的前提下使用。
请简述 Python 中以下划线开头的变量名的特点。
点我看分析
在 Python 中，以下划线开头的变量名有着特殊的含义，尤其是在类的定义中。用下划线作为变量前缀和后缀来表示类的特殊成员：

_xx：这样的对象叫做保护变量，可用，但不建议用，只有类对象和子类对象能够访问这些变量。

__xx__：系统定义的特殊成员名字。

__xx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员。
请简述闭包满足的三个条件。
点我看分析
存在于嵌套关系的函数中；

嵌套的内部函数引用了外部函数的变量；

嵌套的外部函数会将内部函数名作为返回值返回。
请简述装饰器的应用场景。
点我看分析
引入日志；

函数执行时间统计；

执行函数前预备处理；

执行函数后清理功能；

权限校验；

缓存。
请简述 map、filter、reduce 函数的作用。
点我看分析
map 函数会根据提供的函数对指定的序列做映射。

filter 函数会对指定序列执行过滤操作。

reduce 函数会对参数序列中的元素进行累积。
正则表达式的主要作用是什么？

点我看分析
正则表达式主要用于快速地搜索、替换或验证具有特殊形式或格式的文本，可以应用于文本编辑、查找，也可以应用于 web 数据处理与分析等领域。
什么是线程？

点我看分析
线程是 CPU 使用的基本单元，由主线程来创建，并使用这个进程的资源，因此线程创建成本低而且可以实现并行处理，充分利用 CPU。
什么是进程？

点我看分析
进程是应用程序正在执行的实体，当程序执行时，也就创建了一个主线程。进程在创建和执行时需要一定的资源，比如内存、文件、I/O 设备等。
在 Python3 中使用进程与使用线程相比有什么优点？

点我看分析
Python 虽然支持多线程应用程序的创建，但是 Python 解释器使用了内部的全局解释器锁定（GIL），在任意指定的时刻只允许单个线程执行，并限制了 Python 程序只能在一个处理器上运行。而现代 CPU 已经以多核为主，但 Python 的多线程程序无法使用。使用 Python 的多进程模块可以将工作分派给不受锁定限制的单独子进程。

5. 编程题

已知直角三角形的两个直角边的长度 a = 3、b = 4，求斜边 c 的长度。

点我看分析

import math

a = float(input("请输入直角边 1 的长度:"))
b = float(input("请输入直角边 2 的长度:"))
c = a * a + b * b
c = math.sqrt(c)  # 开方，得到的是斜边长

print("斜边长为:", c)

编写一个程序，用于实现两个数的交换。

点我看分析

x = input('输入 x 值: ')
y = input('输入 y 值: ')

x, y = y, x

print(f'交换后 x 的值为: {x}\ty 的值为: {y}')

请根据下述需求，编写一个程序。

用户输入一个字符串，将下标为偶数的字符提出来合并成一个新的字符串 A，再将下标为奇数的字符提出来合并成一个新的字符串 B，再将字符串 A 和 B 连接起来并输出。
点我看分析
arr = [] even_A = "" odd_B = "" message = input("请输入任意字符串：") for string in message: arr.append(string) for s in (arr[::2]): even_A = even_A + s for s in (arr[1::2]): odd_B = odd_B + s print(even_A + odd_B)
请编写一个程序，用于统计字符串中每个字符的出现次数（字母忽略大小写，a 和 A 看做是同一个字母），统计出的结果，请按照 ['a':3, 'b':2] 的格式输出。
点我看分析
message = input("请输入字符串：").lower() a = {} for s in set(message): if message.count(s) >= 1: a[s] = message.count(s) print(a)
请根据下列需求，编写一个程序。

用户输入一个字符串，请将字符串中的所有字符全部向后移动一位，最后一个字符放到字符串的开头，最后将新的字符串输出。
点我看分析
message = list(input("请输入字符串：")) new = "".join([message[-1]] + message[:-1]) print(new)
假设有个列表存储了奇数个无序数字 arr = [2, 1, 4, 3, 6, 7, 5]，请编写程序，输出数值居中的数字 4。
点我看分析
arr = [2, 1, 4, 3, 6, 7, 5] arr.sort() print(arr[len(arr) // 2])

已知 info = [1, 2, 3, 4, 5]，请通过两种编程方法，将列表编程为 info = [5, 4, 3, 2, 1]。

点我看分析

# 第一种
info_1 = [1, 2, 3, 4, 5]

info_1.sort(reverse=True)
print(info_1)

# 第二种
info_2 = [1, 2, 3, 4, 5]

info_2.reverse()
print(info_2)

用户输入 n，然后输入 n 个整数到列表中，列表中的 n 个整数需要使用冒泡进行排序，并将排序后的结果输出。

点我看分析

n = int(input("请输入一个整数 n："))
arr = []
for i in range(n):
    t = int(input(f"请输入第 {n} 个整数："))
    arr.append(t)

print(f"原始列表：{arr}")

for i in range(1, len(arr)):
    for j in range(0, len(arr) - i):
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]

print(f"排序后列表：{arr}")

实现删除列表 info = [1, 2, 3, 2, 1] 重复元素。
点我看分析
info = [1, 2, 3, 2, 1] print(set(info))
假设有两个 3 x 3 的矩阵 \(a = \begin{bmatrix}3 & -1 & 2 \\ 1 & 5 & 7 \\ 2 & 4 & 5 \end{bmatrix}\) \(b = \begin{bmatrix}7 & 5 & -2 \\ 5 & 1 & 9 \\ 4 & 2 & 1 \end{bmatrix}\)，请编写一个程序，计算这两个矩阵的和并输出。
点我看分析
a = [[3, -1, 2], [1, 5, 7], [2, 4, 5]] b = [[7, 5, -2], [5, 1, 9], [4, 2, 1]] c = [] for i in range(3): c.append(list(map(lambda x: sum(x), zip(a[i], b[i])))) for a1 in c: for a2 in a1: print(a2, end="\t") print()

请编写一个程序，使用字典存储学生信息，学生信息包括学号和姓名，请根据学生学号从小到大输出学生的信息。

点我看分析

dic = {}
for i in range(3):
    number = input("输入学生学号：")
    name = input("输入学生姓名：")
    dic.setdefault(number, name)

print(f"排序前：{dic}")

new = {k: v for k, v in sorted(dic.items(), key=lambda a: a[0])}

print(f"排序后：{new}")

已知一个字典包含若干员工信息（姓名和性别）dic = {"小明": "男", "小红": "女", "小兰": "女", "小白": "男"}，请编写一个函数，删除性别为男的员工信息。
点我看分析
def del_male(infos): return dict(filter(lambda x: x[1] != "男", infos.items())) dic = {"小明": "男", "小红": "女", "小兰": "女", "小白": "男"} print(f"删除后：{del_male(dic)}")

已知一个列表存储了多个整数 arr = [12, 3, 37, 7, 91, 67, 27, 45, 6]，请编写函数，删除列表中的素数。

点我看分析

arr = [12, 3, 37, 7, 91, 67, 27, 45, 6]


def del_prime(info):
    for element in info:
        # 素数大于 1
        if element > 1:
            # 查看因子
            for i in range(2, element):
                if (element % i) == 0:
                    break
            else:
                info.remove(element)


del_prime(arr)
print(arr)

编写一个程序，使用 for 循环输出 0～10 之间的偶数。
点我看分析
for i in range(0, 11, 2): print(i)

编写一个程序，判断用户输入的数是正数还是负数。

点我看分析

a = int(input("请输入一个数："))

if a > 0:
    print(f"{a} 是一个正数")
elif a < 0:
    print(f"{a} 是一个负数")
else:
    print(f"{a} 等于0")

编写一个程序，输出九九乘法表。

点我看分析

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} * {i} = {i*j}", end="\t")
    print()

定义一个 get_max 函数，返回三个数（从键盘输入的整数）中的最大值。

例如：
- 请输入第 1 个整数：10
- 请输入第 2 个整数：15
- 请输入第 3 个整数：20
- 其中最大值为：20
点我看分析
def get_max(): arr = [] for i in range(1, 4): arr.append(int(input(f"请输入第 {i} 个数："))) return max(arr) print(get_max())

编写函数，求出 1/(1×2)−1/(2×3)+1/(3×4)−1/(4×5)+⋯ 前 n 项的和，函数以 n 为参数，它是用户输入的。

点我看分析

def compute(n):
    res = 0
    for i in range(1, n + 1):
        if i % 2 == 0:
            res -= 1.0 / (i * (i + 1))
        else:
            res += 1.0 / (i * (i + 1))
    return res


num = int(input("请输入一个整数："))
print(compute(num))

回文数是一个正向和逆向都相同的整数，如 123454321、9889。编写函数判断一个整数是否是回文数。
点我看分析
def palindrome(n): s = str(n) return f"{n} 是回文" if s[:] == s[::-1] else f"{n} 不是回文" print(palindrome(12321))

编写函数，判断输入的三个数字是否能构成三角形的三条边。

点我看分析

def is_triangle(a, b, c):
    if a + b > c and a + c > b and b + c > a:
        print("YES")
    else:
        print("NO")


is_triangle(3, 4, 5)

编写函数，求两个正整数的最小公倍数。

点我看分析

def lcm(x, y):
    for i in range(max(x, y), x * y + 1):
        if i % x == 0 and i % y == 0:
            return i


num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))

print(num1, "和", num2, "的最小公倍数为", lcm(num1, num2))

设计一个 Circle（圆）类，包括圆心位置、半径、颜色等属性。编写初始化方法和其他方法，计算周长和面积。请编写程序验证类的功能。

点我看分析

from math import pi


class Circle(object):
    def __init__(self, tup, radius, color):
        self.center = tup
        self.radius = radius
        self.color = color

    def perimeter(self):
        return 2 * pi * self.radius

    def area(self):
        return pi * self.radius ** 2


circle = Circle((0, 0), 5, "蓝色")
print(circle.perimeter())
print(circle.area())

设计一个表示学生的（Student）类，该类的属性有姓名（name）、年龄（age）、成绩（scores）（类型为列表，成绩包含语文、数学和英语三科成绩，每科成绩的类型为整数），另外有 3 个方法：

获取学生姓名的方法：get_name()
获取学生年龄的方法：get_age()
返回 3 门科目中最高的成绩：get_score()

写好类以后用 li = Student("李四", 20, [69, 88, 100]) 测试，并输出结果。

点我看分析

class Student(object):
    """学生类"""

    def __init__(self, name, age, scores):
        """初始化方法

        :param name: 姓名
        :param age: 年龄
        :param scores: 三科成绩（语文、数学、英语）
        :type name: str
        :type age: int
        :type scores: list[int, int, int]
        """
        self.name = name
        self.age = age
        self.scores = scores

    def get_name(self):
        """获取名字

        :return: 名字
        :rtype: str
        """
        return self.name

    def get_age(self):
        """获取年龄

        :return: 年龄
        :rtype: int
        """
        return self.age

    def get_score(self):
        """三科最高成绩

        :return: 三科最高成绩
        :rtype: int
        """
        return max(self.scores)

li = Student("李四", 20, [69, 88, 100])
print(li.get_name())
print(li.get_age())
print(li.get_score())

设计一个表示动物（Animal）的类，该类包括颜色（color）属性和叫（call）方法。再设计一个表示鱼（Fish）的类，包括尾巴（tail）和颜色（color）两个属性，及叫（call）方法。

提示：让 Fish 类继承自 Animal 类，重写__init__() 和 call 方法。

点我看分析

class Animal(object):
    def __init__(self, color):
        """初始化动物

        :param color: 颜色
        """
        self.color = color

    def call(self):
        """叫"""
        print("动物叫")


class Fish(Animal):
    def __init__(self, color, tail):
        """初始化鱼

        :param color: 颜色
        :param tail: 尾巴
        """
        super().__init__(color)
        self.tail = tail

    def call(self):
        """叫"""
        print("鱼叫")

已知有个列表 [1, 2, 3, 4, 5]，让列表的每个元素加 1，把结果不能被 2 整除的元素筛选出来。
点我看分析
arr = [1, 2, 3, 4, 5] print(list(filter(lambda x: x % 2 != 0, map(lambda x: x + 1, arr))))

6. 程序分析题

阅读下面的程序，分析代码输出结果。

代码：
```
tup = ('a', 'b', 'c')
tup[3] = 'd'
print(tup)
```
点我看分析
程序运行错误，元组不能使用下标增加元素。

代码：

dic = {"a": 1, "b": 2, "a": 3}
print(dic['a'])

点我看分析

代码：

arr = [10, 23, 66, 26, 35, 1, 76, 88, 58]
arr.reverse()
print(arr[3])
arr.sort()
print(arr[3])

点我看分析

代码：

num1 = input("请输入一个整数：")
num2 = input("请输入一个整数：")

if num1 % num2 == 0:
    print("验证码正确")

点我看分析

TypeError 异常，num1 和 num2 属于字符串类型，不能执行取余操作

代码：
```
name = 'Steve Jobs'

print(name[6])
```
点我看分析
抛出 ValueError 异常

代码：

def func():
    x = 200

    def func2():
        print(x)

    func2()


x = 100

func()

print(x)

点我看分析

200

100

代码：

def my_fun():
    pass


print(my_fun())

点我看分析

None

Python 练习

Python 练习

1. 填空题

2. 判断题

3. 选择题

4. 简答题

5. 编程题

6. 程序分析题

结果匹配 ""

没有匹配的结果 ""