Python单选题库
一、python语法基础
1、Python 3.x 版本的保留字总数是
A.27
B.29
C.33
D.16
以下选项中，不是Python 语言保留字的是
A while
B pass
C do
D except
关于Python 程序格式框架，以下选项中描述错误的是
A Python 语言不采用严格的“缩进”来表明程序的格式框架
B Python 单层缩进代码属于之前最邻近的一行非缩进代码，多层缩进代码根据缩进关系决定所属范围
C Python 语言的缩进可以采用Tab 键实现
D 判断、循环、函数等语法形式能够通过缩进包含一批Python 代码，进而表达对应的语义
下列选项中不符合Python语言变量命名规则的是
A TempStr
B I
C 3_1
D _AI
以下选项中，关于Python字符串的描述错误的是
A Python语言中，字符串是用一对双引号""或者一对单引号'' 括起来的零个或者多个字符
B 字符串包括两种序号体系：正向递增和反向递减
C 字符串是字符的序列，可以按照单个字符或者字符片段进行索引
D Python字符串提供区间访问方式，采用[N:M]格式，表示字符串中从N到M 的索引子字符串（包含N和M）
给出如下代码
TempStr ="Hello World"
可以输出“World”子串的是
A . print(TempStr[–5:0])
B print(TempStr[–5:])
C print(TempStr[–5: –1])
D print(TempStr[–4: –1])
关于赋值语句，以下选项中描述错误的是
A a,b = b,a 可以实现a 和b值的互换
B a,b,c = b,c,a 是不合法的
C在Python语言中，“=”表示赋值，即将“=”右侧的计算结果赋值给左侧变量，包含“=”的语句称为赋值语句
D 赋值与二元操作符可以组合，例如&=
关于eval函数，以下选项中描述错误的是
A eval函数的定义为：eval(source, globals=None, locals=None, /)
B 执行“>>> eval("Hello")”和执行“>>> eval("'Hello'")”得到相同的结果
C eval函数的作用是将输入的字符串转为Python语句，并执行该语句
D 如果用户希望输入一个数字，并用程序对这个数字进行计算，可以采用
eval(input(<输入提示字符串>))组合
关于Python语言的注释，以下选项中描述错误的是
A Python语言有两种注释方式：单行注释和多行注释
B Python语言的单行注释以#开头
C Python语言的多行注释以'''（三个单引号）开头和结尾
D Python语言的单行注释以单引号' 开头
关于Python语言的特点，以下选项中描述错误的是
A Python语言是脚本语言
B Python语言是非开源语言
C Python语言是跨平台语言
D Python语言是多模型语言
关于import引用，以下选项中描述错误的是
A 可以使用from turtle import setup 引入turtle库
B 使用import turtle as t引入turtle库，取别名为t
C 使用import turtle引入turtle库
D import保留字用于导入模块或者模块中的对象
12.下面代码的输出结果是
print（0.1+0.2==0.3）
A false
B True
C False
D true
13.下面代码的输出结果是
print(round(0.1 + 0.2,1) == 0.3)
A 0
B 1
C False
D True
14. 在一行上写多条Python语句使用的符号是
A 点号
B 冒号
C 分号
D 逗号
给出如下代码
s = 'Python is beautiful!'
可以输出“python”的是
A print(s[0:6].lower())
B print(s[:–14])
C print(s[0:6])
D print(s[–21: –14].lower)
给出如下代码
s = 'Python is Open Source!'
print(s[0:].upper())
上述代码的输出结果是
A PYTHON
B PYTHON IS OPEN SOURCE
C Python is Open Source!
D PYTHON IS OPEN SOURCE!
以下选项中，符合Python语言变量命名规则的是
A Templist
B ！1
C (VR)
D 5_1
下列选项中可以准确查看Python代码的语言版本（3.5.3）的是
A >>> import sys
B >>> import sys
>>> sys.version >>> sys.exc_info()
C >>> import sys
D >>> import sys
>>> sys.version—info >>> sys.path
下列选项中可以获取Python整数类型帮助的是
A >>> help(float)
B >>> dir(str)
C >>> help(int)
D >>> dir(int)
给出如下代码：
>>> x = 3.14
>>> eval('x + 10')
上述代码的输出结果是
A TypeError: must be str, not int
B 系统错
C 13.14
D 3.1410
Python语言的主网站网址是
A https://https://www.doczj.com/doc/bd7817712.html,/
B https://https://www.doczj.com/doc/bd7817712.html,/
C https://www.python123.io/
D https://https://www.doczj.com/doc/bd7817712.html,/pypi
下列Python保留字中，用于异常处理结构中用来捕获特定类型异常的是
A def
B except
C while
D pass
23.关于Python注释，以下选项中描述错误的是
A Python注释语句不被解释器过滤掉，也不被执行
B 注释可用于标明作者和版权信息
C 注释可以辅助程序调试
D 注释用于解释代码原理或者用途
以下选项中，不是Python数据类型的是
A 实数
B 列表
C 整数
D 字符串
下列Python保留字中，不用于表示分支结构的是
A elif
B in
C if
D else
以下选项中，不属于Python保留字的是
A def
B import
C type
D elif
27.以下选项中，对程序的描述错误的是
A 程序是由一系列函数组成的
B 通过封装可以实现代码复用
C 可以利用函数对程序进行模块化设计
D 程序是由一系列代码组成的
利用print()格式化输出，能够控制浮点数的小数点后两位输出的是
A {.2}
B {:.2f}
C {:.2}
D {.2f}
以下选项中可用作Python标识符的是
A 3B9909
B class
C ____
D it's
关于Python赋值语句，以下选项中不合法的是
A x=(y=1)
B x,y=y,x
C x=y=1
D x=1;y=1
31.以下选项中，不是Python语言保留字的是
A int
B del
C try
D None
关于Python程序中与“缩进”有关的说法中，以下选项中正确的是
A 缩进统一为4个空格
B 缩进可以用在任何语句之后，表示语句间的包含关系
C 缩进在程序中长度统一且强制使用
D 缩进是非强制性的，仅为了提高代码可读性
以下选项中可访问字符串s从右侧向左第三个字符的是
A s[3]
B s[：-3]
C s[-3]
D s[0：-3]
Python3.0正式发布的年份是
A 1990
B 2018
C 2002
D 2008
以下选项中，不是IPO模型一部分的是
A Program
B Input
C Output
D Process
以下选项中，不是Python语言合法命名的是
A 5MyGod
B MyGod5
C _MyGod_
D MyGod
在Python函数中，用于获取用户输入的是
A input()
B print()
C Eval()
D get()
给标识符关联名字的过程是
A 赋值语句
B 命名
C 表达
D 生成语句
I DLE菜单中创建新文件的快捷键是
A Ctrl+]
B Ctrl+F
C Ctrl+N
D Ctrl+[
IDLE菜单中将选中区域缩进的快捷键是
A Ctrl+]
B Ctrl+S
C Ctrl+A
D Ctrl+C
IDLE菜单中将选中区域取消缩进的快捷键是
A Ctrl+O
B Alt+
C C Ctrl+V
D Ctrl+[
IDLE菜单中将选中区域注释的快捷键是
A Alt+3
B Alt+G
C Alt+Z
D Alt+4
IDLE菜单中将选中区域取消注释的快捷键是
A Alt+Z
B Alt+3
C Alt+G
D Alt+4
I DLE菜单将选中区域的空格替换为Tab的快捷键是
A Alt+V
B Alt+
C C Alt+5
D Alt+6
I DLE菜单将选中区域的Tab替换为空格的快捷键是
A Alt+0
B Alt+5
C Alt+6
D Alt+C
以下选项中，不是Python打开方式的是
A Office
B Windows系统的命令行工具
C 带图形界面的Python Shell-IDLE
D 命令行版本的Python Shell-Python 3.x
查看Python是否安装成功的命令是
A Win + R
B PyCharm
C python3.4 –v
D exit()
以下选项中，不是Python IDE的是
A PyCharm
B Jupyter Notebook
C Spyder
D R studio
Python为源文件指定系统默认字符编码的声明是
A #coding:cp936
B #coding:GB2312
C #coding:utf-8
D #coding:GBK
下面代码的语法错误显示是
print "Hello World!"
A SyntaxError: Missing parentheses in call to 'print
B
C NameError: name 'raw_print' is not defined
D SyntaxError: invalid character in identifier
二、基本数据类型
关于Python的数字类型，以下选项中描述错误的是
A 复数类型虚部为0时，表示为1+0j
B 1.0是浮点数，不是整数
C 浮点数也有十进制、二进制、八进制和十六进制等表示方式
D 整数类型的数值一定不会出现小数点
下面代码的输出结果是
x = 12.34
print(type(x))
A
B
C
D
下面代码的输出结果是
print(pow(2,10))
A 100
B 12
C 1024
D 20
下面代码的输出结果是
x=0b1010
print(x)
A 1024
B 10
C 16
D 256
下面代码的输出结果是
x=0o1010
print(x)
A 10
B 1024
C 520
D 2768
下面代码的输出结果是
x=0x1010
print(x)
A 4112
B 520
C 10
D 1024
关于Python的浮点数类型，以下选项中描述错误的是
A 浮点数类型与数学中实数的概念一致，表示带有小数的数值
B sys.float_info可以详细列出Python解释器所运行系统的浮点数各项参数
C Python语言的浮点数可以不带小数部分
D 浮点数有两种表示方法：十进制表示和科学计数法
关于Python的复数类型，以下选项中描述错误的是
A 复数类型表示数学中的复数
B 对于复数z，可以用z.imagl获得实数部分
C 复数的虚数部分通过后缀“J”或“j”来表示
D 对于复数z，可以用z.real获得实数部分
下面代码的输出结果是
z = 12.12 + 34j
print(z.real)
A 34
B 34.0
C 12.12
D 12
10.下面代码的输出结果是
z = 12.34 + 34j
print(z.imag)
A 12.12
B 34.0
C 12
D 34
下面代码的输出结果是
x=10
y=–1+2j
print(x+y)
A （9+2j）
B 11
C 2j
D 9
下面代码的输出结果是
x=10
y=3
print(x%y,x**y)
A 1 1000
B 3 30
C 3 1000
D 1 30
下面代码的输出结果是
x=10
y=4
print(x/y,x//y)
A 2 2.5
B 2.5 2.5
C 2.5 2
D 2 2
下面代码的输出结果是
x=10
y=3
print(divmod(x,y))
A 3,1
B （3,1）
C （1,3）
D 1,3
15.下面代码的输出结果是
x=3.1415926
print(round(x,2) ,round(x))
A 2 2
B 6.28 3
C 3.14 3
D 3 3.14
下面代码的输出结果是
a = 5
b = 6
c = 7
print(pow(b,2) –4*a*c)
A 104
B 系统报错
C -104
D 36
关于Python字符串，以下选项中描述错误的是
A 字符串可以保存在变量中，也可以单独存在
B 字符串是一个字符序列，字符串中的编号叫“索引”
C 可以使用datatype()测试字符串的类型
D 输出带有引号的字符串，可以使用转义字符\
下面代码的执行结果是
a = 123456789
b = "*"
print("{0:{2}>{1},}\n{0:{2}^{1},}\n{0:{2}<{1},}".format(a,20,b ))
A *********123,456,789
B ****123,456,789*****
****123,456,789***** *********123,456,789
123,456,789********* 123,456,789*********
C ****123,456,789*****
D *********123,456,789
123,456,789********* 123,456,789*********
*********123,456,789 ****123,456,789*****
下面代码的执行结果是
a = 10.99
print(complex(a))
A 10.99
B (10.99+0j)
C 10.99+0j
D 0.99
下面代码的执行结果是
>>> x = "Happy Birthday to you!"
>>> x * 3
A 系统报错
B Happy Birthday to you!
C 'Happy Birthday to you!Happy Birthday to you!Happy Birthday to you!'
D Happy Birthday to you!
Happy Birthday to you!
Happy Birthday to you!
关于Python字符编码，以下选项中描述错误的是
A ord(x)和chr(x)是一对函数
B Python默认采用Unicode字符编码
C chr(x)将字符转换为Unicode编码
D Python可以处理任何字符编码文本
给出如下代码
s = "Alice"
print(s[::–1])
上述代码的输出结果是
A ecilA
B ALICE
C Alice
D Alic
给出如下代码
s= "abcdefghijklmn"
print(s[1:10:3])
上述代码的输出结果是
A behk
B adgj
C beh
D adg
给出如下代码
for i in range(12):
print(chr(ord("?")+i),end="")
以下选项描述错误的是
A 输出结果为????????????
B 系统报错
C chr(x)函数返回Unicode编码对应的字符
D ord("?")返回"?"字符对应的Unicode编码
下面代码的输出结果是
>>> hex(255)
A '0eff'
B '0off'
C '0xff'
D '0bff'
下面代码的输出结果是
>>> oct(–255)
A '0d–377'
B '0o–377'
C '–0d377'
D '–0o377'
下面代码的输出结果是
>>> bin(10)
A '0o1010'
B '0d1010'
C '0b1010'
D '0x1010'
给出如下代码以下选项中描述正确的是
for i in range(6):
print(chr(ord(9801)+i),end="")
A chr ("a")返回"a"字符对应的Unicode编码
B 系统报错
C 输出结果为??????
D ord(x)函数返回x的Unicode编码对应的字符
给出如下代码：如下描述错误的是
for i in range(10):
print(chr(ord("！")+i),end="")
A 系统报错
B ord("!")返回"!"字符对应的Unicode编码
C 输出结果为！＂＃＄％＆＇（）＊
D chr(x)函数返回Unicode编码对应的字符
下列选项中输出结果是True的是
A >>> isinstance(255,int)
B >>> chr(13).isprintable()
C >>> "Python".islower()
D >>> chr(10).isnumeric()
下面代码的输出结果是
s1 = "The python language is a scripting language."
s1.replace('scripting','general')
print(s1)
A The python language is a scripting language.
B 系统报错
C ['The', 'python', 'language', 'is', 'a', 'scripting', 'language.']
D The python language is a general language.
32.下面代码的输出结果是
s1 = "The python language is a scripting language." s2 = s1.replace('scripting','general')
print(s2)
A The python language is a scripting language.
B ['The', 'python', 'language', 'is', 'a', 'scripting', 'language.']
C 系统报错
D The python language is a general language.
下面代码的输出结果是
s = "The python language is a cross platform language." print(s.find('language',30))
A 系统报错
B 40
C 11
D 10
下面代码的输出结果是
s = "The python language is a multimodel language."
print(s.split(' '))
A Thepythonlanguageisamultimodellanguage.
B ['The', 'python', 'language', 'is', 'a', 'multimodel', 'language.']
C The python language is a multimodel language.
D 系统报错
下面代码的输出结果是
a ="Python"
b = "A Superlanguage"
print("{:->10}:{:-<19}".format(a,b))
A ----Python:A Superlanguage----
B ----Python:----A Superlanguage
C The python language is a multimodel language.
D Python----:----A Superlanguage
以下选项中，输出结果为False的是
A >>> 5 is 5
B >>> False !=0
C >>> 5 is not 4
D >>> 5 != 4
下面代码的输出结果是
>>> True - False
A 1
B -1
C True
D 0
下面代码的输出结果是
a = 2
b = 2
c = 2.0
print(a == b, a is b, a is c)
A True False False
B True False True
C False False True
D True True False
#以下选项中，输出结果为False的是
A >>> 'python' < 'pypi'
B >>> 'ABCD' == 'abcd'.upper()
C >>> 'python123' > 'python'
D >>> ''<'a'
下面代码的输出结果是
>>> a,b,c,d,e,f = 'Python'
>>> b
A 1
B 出错
C ‘y’
D 0
下面代码的输出结果是
>>> a = b = c =123
>>> print(a,b,c)
A 0 0 123
B 出错
C 1 1 123
D 123 123 123
下面代码的输出结果是
>>> True / False
A True
B -1
C 0
D 系统报错
下面代码的输出结果是
x = 1
x *= 3+5**2
print(x)
A 29
B 28
C 13
D 14
下面代码的输出结果是
a = 5/3+5//3
print(a)
A 5.4
B 2.666666666666667
C 3.333333
D 14
下面代码的输出结果是
a = "alex"
b = a.capitalize()
print(a,end=",")
print(b)
A alex,ALEX
B ALEX,alex
C alex,Alex
D Alex,Alex
下面代码的输出结果是
a = 20
b = a | 3
a &= 7
print(b ,end=",")
print(a)
A 6.66667,4
B 4,6.66667
C 4,23
D 23,4
下面代码的输出结果是
a = "ac"
b = "bd"
c = a + b
print(c)
A dbac
B abcd
C acbd
D bdac
下面代码的输出结果是
str1 = "mysqlsqlserverPostgresQL"
str2 = "sql"
ncount = str1.count(str2)
print(ncount)
A 2
B 5
C 4
D 3
下面代码的输出结果是
>>> True / False
A True
B 1
C 出错
D False
下面代码的输出结果是
str1 = "mysqlsqlserverPostgresQL"
str2 = "sql"
ncount = str1.count(str2,10)
print(ncount)
A 0
B 3
C 4
D 2
三、程序的控制结构
1．关于Python的分支结构，以下选项中描述错误的是
A Python中if-elif-else语句描述多分支结构
B 分支结构使用if保留字
C Python中if-else语句用来形成二分支结构
D 分支结构可以向已经执行过的语句部分跳转
2．关于Python循环结构，以下选项中描述错误的是
A break用来跳出最内层for或者while循环，脱离该循环后程序从循环代码后继续执行
B 每个continue语句只有能力跳出当前层次的循环
C 遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
D Python通过for、while等保留字提供遍历循环和无限循环结构
3．关于Python循环结构，以下选项中描述错误的是
A continue结束整个循环过程，不再判断循环的执行条件
B 遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
C Python通过for、while等保留字构建循环结构
D continue用来结束当前当次语句，但不跳出当前的循环体
4．下面代码的输出结果是
for s in "HelloWorld":
if s=="W":
continue
print(s,end="")
A Hello
B HelloWorld
C Helloorld
D World
#下面代码的输出结果是
for s in "HelloWorld":
if s=="W":
break
print(s,end="")
A HelloWorld
B Helloorld
C World
D Hello
6．于程序的异常处理，以下选项中描述错误的是
A 编程语言中的异常和错误是完全相同的概念
B 程序异常发生后经过妥善处理可以继续执行
C 异常语句可以与else和finally保留字配合使用
D Python通过try、except等保留字提供异常处理功能
7．关于Python遍历循环，以下选项中描述错误的是
A 遍历循环通过for实现
B 无限循环无法实现遍历循环的功能
C 遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于所提取的每个元素只执行一次语句块
D 遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
8．关于Python的无限循环，以下选项中描述错误的是
A 无限循环一直保持循环操作，直到循环条件不满足才结束
B 无限循环也称为条件循环
C 无限循环通过while保留字构建
D 无限循环需要提前确定循环次数
9．下面代码的输出结果是
for i in "Python":
print(i,end=" ")
A P,y,t,h,o,n,
B P y t h o n
C Python
D P y t h o n 10．给出如下代码：
import random
num = random.randint(1,10)
while True:
guess = input()
i = int(guess)
if i == num:
print("你猜对了")
break
elif i < num:
print("小了")
elif i > num:
print("大了")
以下选项中描述错误的是
A random.randint(1,10) 生成[1,10]之间的整数
B “import random”这行代码是可以省略的
C 这段代码实现了简单的猜数字游戏
D “while True:”创建了一个永远执行的While循环
11．给出如下代码：
a=3
while a > 0:
a -= 1
print(a,end=" ")
以下选项中描述错误的是：
A a -= 1 可由 a = a – 1实现
B 条件a > 0 如果修改为a < 0 程序执行会进入死循环
C 使用while 保留字可创建无限循环
D 这段代码的输出内容为2 1 0
12．下列快捷键中能够中断（Interrupt Execution）Python程序运行的是A F6 B Ctrl + Q C Ctrl + C D Ctrl + F6 13．给出如下代码：
sum = 0
for i in range(1,11):
sum += i
print(sum)
以下选项中描述正确的是：
A 循环内语句块执行了11次
B sum += i 可以写为 sum + = i
C 如果print(sum) 语句完全左对齐，输出结果不变
D 输出的最后一个数字是55
14．关于break语句与continue语句的说法中，以下选项中不正确的是
A continue语句类似于break语句，也必须在for、while循环中使用
B break语句结束循环，继续执行循环语句的后续语句
C 当多个循环语句嵌套时，break语句只适用于最里层的语句
D continue语句结束循环，继续执行循环语句的后续语句
15． random.uniform(a,b)的作用是
A 生成一个[a, b]之间的随机整数
B 生成一个(a, b)之间的随机数
C 生成一个均值为a，方差为b的正态分布
D 生成一个[a, b]之间的随机小数
16．实现多路分支的最佳控制结构是
A if
B try
C if-elif-else
D if-else 17．给出下面代码：
age=23
start=2
if age%2!=0:
start=1
for x in range(start,age+2,2):
print(x)
上述程序输出值的个数是：
A 10
B 12
C 16
D 14 18．下面代码的执行结果是
print(pow(3,0.5)*pow(3,0.5)==3)
A True
B pow(3,0.5)*pow(3,0.5)==3
C False
D 3
19．给出下面代码：
k=10000
while k>1:
print(k)
k=k/2
上述程序的运行次数是：
A 14
B 1000
C 15
D 13 20．关于Python语句P=–P，以下选项中描述正确的是
A P的绝对值
B 给P赋值为它的负数
C P=0
D P等于它的负数
21．以下选项中能够实现Python循环结构的是
A loop
B do...for
C while
D if 22．用来判断当前Python语句在分支结构中的是
A 引号
B 冒号
C 大括号
D 缩进23．以下选项中描述正确的是
A 条件24<=28<25是合法的，且输出为False
B 条件35<=45<75是合法的，且输出为False
C 条件24<=28<25是不合法的
D 条件24<=28<25是合法的，且输出为True
24．于while保留字，以下选项中描述正确的是
A while True: 构成死循环，程序要禁止使用
B 使用while必须提供循环次数
C 所有while循环功能都可以用for循环替代
D 使用while能够实现循环计数
25．random库中用于生成随机小数的函数是
A randrange()
B random()
C randint()
D getrandbits() 26．以下选项中能够最简单地在列表['apple','pear','peach','orange']中随机选取一个元素的是
A sample()
B random()
C choice()
D shuffle() 27．Python异常处理中不会用到的关键字是
A finally
B else
C try
D if
28．下面代码的输出结果是
for i in range(1,6):
if i%3 == 0:
break
else:
print(i,end =",")
A 1,2,3,
B 1,2,3,4,5,6
C 1,2,
D 1,2,3,4,5, 29．下面代码的输出结果是
for i in range(1,6):
if i/3 == 0:
break
else:
print(i,end =",")
A 1,2,3,
B 1,2,3,4,5,
C 1,2,3,4,
D 1,2,
30．下面代码的输出结果是
sum = 0
for i in range(2,101):
if i % 2 == 0:
sum += i
else:
sum -= i
print(sum)
A -50
B 51
C 50
D 49
31．下面代码的输出结果是
sum=0
for i in range(0,100):
if i%2==0:
sum-=i
else:
sum+=i
print(sum)
A -50
B 49
C 50
D -49 32．下面代码的输出结果是
for i in range(1,10,2):
print(i,end=",")
A 1,4,
B 1,4,7,
C 1,3,5,7,9,
D 1,3,
33．下面代码的输出结果是
sum = 1
for i in range(1,101):
sum += i
print(sum)
A 5052
B 5051
C 5049
D 5050 34．下面代码的输出结果是
a = []
for i in range(2,10):
count = 0
for x in range(2,i-1):
if i % x == 0:
count += 1
if count != 0:
a.append(i)
print(a)
A [3 ,5 ,7 ,9]
B [4, 6, 8, 9]
C [4 ,6 ,8 ,9 ,10]
D [2 ,3 ,5 ,7] 35．下面代码的输出结果是
x2 = 1
for day in range(4,0,-1):
x1 = (x2 + 1) * 2
x2 = x1
print(x1)
A 46
B 23
C 94
D 190
36．下面代码的输出结果是
for num in range(2,10):
if num > 1:
for i in range(2,num):
if (num % i) == 0:
break
else:
print(num)
A 4,6,8,9
B 2,4,6,8,10
C 2,4,6,8
D 2,3,5,7,
37．下面代码的输出结果是
for n in range(100,200):
i = n // 100
j = n // 10 % 10
k = n % 10
if n == i ** 3 + j ** 3 + k ** 3:
print(n)
A 159
B 157
C 152
D 153 38．下面代码的输出结果是
a = 2.0
b = 1.0
s = 0
for n in range(1,4):
s += a / b
t = a
a = a + b
b = t
print(round(s,2))
A 5.17
B 8.39
C 3.5
D 6.77 39．下面代码的输出结果是
for a in ["torch","soap","bath"]:
print(a)
A torch
soap
bath
B torch,soap,bath
C torch soap bath
D torch,soap,bath,
40．下面代码的输出结果是
for a in 'mirror':
print(a, end="")
if a == 'r':
break
A mir
B mirror
C mi
D mirror 41．下面代码的输出结果是
s = 0
while(s<=1):
print('计数：',s)
s = s + 1
A 计数：1
B 计数：0 计数：1
C 计数：0
D 出错
42．下面代码的输出结果是
s = 1
while(s<=1):
print('计数：',s)
s = s + 1
A 计数：0
B 出错
计数：1
C 计数：0
D 计数：1
43．下面代码的输出结果是
for i in ["pop star"]:
pass
print(i,end = "")
A 无输出
B pop star
C 出错
D popstar
44．给出下面代码：
i = 1
while i < 6:
j = 0
while j < i:
print("*",end='')
j += 1
print("\n")
i += 1
以下选项中描述错误的是：
A 第i行有i个星号*
B 输出5行
C 执行代码出错
D 内层循环j用于控制每行打印的*的个数45．给出下面代码：
for i in range(1,10):
for j in range(1,i+1):
print("{}*{}={}\t".format(j,i,i*j),end = '')
print("")
以下选项中描述错误的是：
A 内层循环i用于控制一共打印 9 列
B 也可使用While嵌套循环实现打印九九乘法表
C 执行代码，输出九九乘法表
D 执行代码出错
46．下面代码的输出结果是
a = 1.0
if isinstance(a,int):
print("{} is int".format(a))
else:
print("{} is not int".format(a))
A 出错
B 1.0 is int
C 无输出
D 1.0 is not int 47．下面代码的输出结果是
a = {}
if isinstance(a,list):
print("{} is list".format(a))
else:
print("{} is {}".format("a",type(a)))
A a is list
B 出错
C 无输出
D a is
a = [1,2,3]
if isinstance(a,float):
print("{} is float".format(a))
else:
print("{} is not float".format(a))
A a is float
B a is
C [1, 2, 3] is not float
D 出错49．给出下面代码：
a = input("").split(",")
if isinstance(a,list):
print("{} is list".format(a))
else:
print("{} is not list".format(a))
代码执行时，从键盘获得1,2,3，则代码的输出结果是：
A 执行代码出错
B 1,2,3 is not list
C ['1', '2', '3'] is list
D 1,2,3 is list
50．给出下面代码：
a = input("").split(",")
x = 0
while x < len(a):
print(a[x],end="")
x += 1
代码执行时，从键盘获得a,b,c,d，则代码的输出结果是：
A 执行代码出错
B abcd
C 无输出
D a,b,c,d
四、函数和代码复用
1．关于递归函数的描述，以下选项中正确的是
A 函数名称作为返回值
B 包含一个循环结构
C 函数比较复杂
D 函数内部包含对本函数的再次调用
2．关于递归函数基例的说明，以下选项中错误的是
A 递归函数必须有基例
B 递归函数的基例不再进行递归
C 每个递归函数都只能有一个基例
D 递归函数的基例决定递归的深度
3．以下选项中，不属于函数的作用的是
A 提高代码执行速度
B 增强代码可读性
C 降低编程复杂度
D 复用代码
4．假设函数中不包括global保留字，对于改变参数值的方法，以下选项中错误的是
A 参数是列表类型时，改变原参数的值
B 参数是组合类型（可变对象）时，改变原参数的值
C 参数的值是否改变与函数中对变量的操作有关，与参数类型无关
D 参数是整数类型时，不改变原参数的值
5在Python中，关于函数的描述，以下选项中正确的是
A 函数eval()可以用于数值表达式求值，例如eval("2*3+1")
B Python函数定义中没有对参数指定类型，这说明，参数在函数中可以当作任意类型使用
C 一个函数中只允许有一条return语句
D Python中，def和return是函数必须使用的保留字
6．给出如下代码：
def func(a,b):
c=a**2+b
b=a
return c
a=10
b=100
c=func(a,b)+a
以下选项中描述错误的是
A 执行该函数后，变量a的值为10
B 执行该函数后，变量b的值为100
C 执行该函数后，变量c的值为200
D 该函数名称为func
7．在Python中，关于全局变量和局部变量，以下选项中描述不正确的是
A 一个程序中的变量包含两类：全局变量和局部变量
B 全局变量不能和局部变量重名
C 全局变量在程序执行的全过程有效
D 全局变量一般没有缩进
8．关于面向对象和面向过程编程描述，以下选项中正确的是
A 面向对象编程比面向过程编程更为高级
B 所有面向对象编程能实现的功能采用面向过程同样能完成
C 面向对象和面向过程是编程语言的分类依据
D 模块化设计就是面向对象的设计
9．以下选项中，对于递归程序的描述错误的是
A 书写简单
B 执行效率高
C 递归程序都可以有非递归编写方法
D 一定要有基例
10．下面代码的输出结果是
>>>f=lambda x,y:y+x
>>>f(10,10)
A 100
B 10
C 20
D 10,10
11．关于形参和实参的描述，以下选项中正确的是
A 参数列表中给出要传入函数内部的参数，这类参数称为形式参数，简称形参
B 程序在调用时，将形参复制给函数的实参
C 函数定义中参数列表里面的参数是实际参数，简称实参
D 程序在调用时，将实参复制给函数的形参
12．关于lambda函数，以下选项中描述错误的是
A lambda不是Python的保留字
B 定义了一种特殊的函数
C lambda函数也称为匿名函数
D lambda函数将函数名作为函数结果返回
13以下选项中，对于函数的定义错误的是
A def vfunc(a,b=2):
B def vfunc(*a,b):
C def vfunc(a,b):
D def vfunc(a,*b):
14．关于函数的参数，以下选项中描述错误的是
A 在定义函数时，如果有些参数存在默认值，可以在定义函数时直接为这些参数指定默认值
B 在定义函数时，可以设计可变数量参数，通过在参数前增加星号（*）实现
C 可选参数可以定义在非可选参数的前面
D 一个元组可以传递给带有星号的可变参数
15．关于return语句，以下选项中描述正确的是
A 函数必须有一个return语句
B 函数中最多只有一个return语句
C return只能返回一个值
D 函数可以没有return语句
16．关于函数，以下选项中描述错误的是
A 函数是一段具有特定功能的、可重用的语句组
B Python使用del保留字定义一个函数
C 函数能完成特定的功能，对函数的使用不需要了解函数内部实现原理，只要了解函数的输入输出方式即可。
D 使用函数的主要目的是降低编程难度和代码重用
17．关于Python的全局变量和局部变量，以下选项中描述错误的是
A 使用global保留字声明简单数据类型变量后，该变量作为全局变量使用
B 简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放
C 全局变量指在函数之外定义的变量，一般没有缩进，在程序执行全过程有效
D 局部变量指在函数内部使用的变量，当函数退出时，变量依然存在，下次函数调用可以继续使用
18．关于Python的lambda函数，以下选项中描述错误的是
A f = lambda x,y:x+y 执行后，f的类型为数字类型
B lambda用于定义简单的、能够在一行内表示的函数
C 可以使用lambda函数定义列表的排序原则
D lambda函数将函数名作为函数结果返回
19．下面代码实现的功能描述为
1：Python如何实现单例模式？ Python有两种方式可以实现单例模式，下面两个例子使用了不同的方式实现单例模式： 1. class Singleton(type): def __init__(cls, name, bases, dict): super(Singleton, cls).__init__(name, bases, dict) cls.instance = None def __call__(cls, *args, **kw): if cls.instance is None: cls.instance = super(Singleton, cls).__call__(*args, **kw) return cls.instance class MyClass(object): __metaclass__ = Singleton print MyClass() print MyClass() 2. 使用decorator来实现单例模式 def singleton(cls): instances = {} def getinstance(): if cls not in instances: instances[cls] = cls() return instances[cls] return getinstance @singleton class MyClass: … 2：什么是lambda函数？ Python允许你定义一种单行的小函数。定义lambda函数的形式如下：labmda 参数：表达式lambda函数默认返回表达式的值。你也可以将其赋值给一个变量。lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个：>>> g = lambda x, y: x*y >>> g(3,4) 12 >>> g = lambda x, y=0, z=0: x+y+z >>> g(1) 1
P y t h o n面试题及答案 TTA standardization office【TTA 5AB- TTAK 08- TTA 2C】
2018年最新P y t h o n面试题及答案找工作是每个学习Python人员的目标，为了更好的找到工作，刷面试题是必不可少的，了解最新企业招聘试题，可以让你面试更加的顺利。小编整理了一些20XX年最新的Python面试题，来测测你技术的掌握度吧。 1、Python里面如何拷贝一个对象（ 赋值，浅拷贝，深拷贝的区别） 答：赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。 浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数} 深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的()函数} 2、Python里面match()和search()的区别？ 答：re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。 re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。 >>>print(‘super’, ‘superstition’).span())
(0, 5) >>>print(‘super’, ‘insuperable’)) None >>>print(‘super’, ‘superstition’).span()) (0, 5) >>>print(‘super’, ‘insuperable’).span()) (2, 7) 3、有没有一个工具可以帮助查找python的bug和进行静态的代码分析？ 答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告 Pylint是另外一个工具可以进行codingstandard检查 4、简要描述Python的垃圾回收机制（garbage collection）。 答案 这里能说的很多。你应该提到下面几个主要的点： Python在内存中存储了每个对象的引用计数（reference count）。如果计数值变成0，那么相应的对象就会小时，分配给该对象的内存就会释放出来用作他用。 偶尔也会出现引用循环（reference cycle）。垃圾回收器会定时寻找这个循环，并将其回收。举个例子，假设有两个对象o1和o2，而且符合 == o2和 == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。
Python基础知识笔试 1 2 3 一、单选题（2.5分*20题） 4 1. 下列哪个表达式在Python中是非法的？ B 5 A. x = y = z = 1 6 B. x = (y = z + 1) 7 C. x, y = y, x 8 D. x += y 9 2. python my.py v1 v2 命令运行脚本，通过 from sys impor t argv如何获得v2的参数值? C 10 11 A. argv[0] 12 B. argv[1] 13 C. argv[2] 14 D. argv[3] 15 3. 如何解释下面的执行结果? B 16 print 1.2 - 1.0 == 0.2 17 False 18 A. Python的实现有错误 19 B. 浮点数无法精确表示 20 C. 布尔运算不能用于浮点数比较 D. Python将非0数视为False 21 22 4. 下列代码执行结果是什么? D
23 x = 1 24 def change(a): 25 x+= 1 26 print x 27 change(x) 28 A. 1 29 B. 2 30 C. 3 D. 报错 31 32 5. 下列哪种类型是Python的映射类型？ D 33 A. str 34 B. list 35 C. tuple 36 D. dict 6. 下述字符串格式化语法正确的是？ D 37 38 A. 'GNU's Not %d %%' % 'UNIX' 39 B. 'GNU\'s Not %d %%' % 'UNIX' C. 'GNU's Not %s %%' % 'UNIX' 40 41 D. 'GNU\'s Not %s %%' % 'UNIX' 42 7. 在Python 2.7中，下列哪种是Unicode编码的书写方式?C A. a = ‘中文’ 43 44 B. a = r‘中文’
2018年最新Python面试题及答案 找工作是每个学习Python人员的目标，为了更好的找到工作，刷面试题是必不可少的，了解最新企业招聘试题，可以让你面试更加的顺利。小编整理了一些2017年最新的Python面试题，来测测你技术的掌握度吧。 1、Python里面如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别） 答：赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。 浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数} 深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的()函数} 2、Python里面match()和search()的区别？ 答：re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。 re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。 >>>print(‘super’, ‘superstition’).span()) (0, 5) >>>print(‘super’, ‘insuperable’)) None
>>>print(‘super’, ‘superstition’).span()) (0, 5) >>>print(‘super’, ‘insuperable’).span()) (2, 7) 3、有没有一个工具可以帮助查找python的bug和进行静态的代码分析？ 答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python 代码的bug, 会对代码的复杂度和格式提出警告 Pylint是另外一个工具可以进行codingstandard检查 4、简要描述Python的垃圾回收机制（garbage collection）。 答案 这里能说的很多。你应该提到下面几个主要的点： Python在内存中存储了每个对象的引用计数（reference count）。如果计数值变成0，那么相应的对象就会小时，分配给该对象的内存就会释放出来用作他用。 偶尔也会出现引用循环（reference cycle）。垃圾回收器会定时寻找这个循环，并将其回收。举个例子，假设有两个对象o1和o2，而且符合 == o2和 == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。 Python中使用了某些启发式算法（heuristics）来加速垃圾回收。例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代（generation）。每个对象都会被分配一个代，而被分配更年轻代的对象是优先被处理的。
对于机器学习算法工程师而言，Python是不可或缺的语言，它的优美与简洁令人无法自拔。那么你了解过Python编程面试题吗？今天我们就来了解一下！ 1、python下多线程的限制以及多进程中传递参数的方式 python多线程有个全局解释器锁（global interpreter lock），这个锁的意思是任一时间只能有一个线程使用解释器，跟单cpu跑多个程序一个意思，大家都是轮着用的，这叫“并发”，不是“并行”。 多进程间共享数据，可以使用 multiprocessing.Value和multiprocessing.Array。 2、什么是lambda函数？它有什么好处？ lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数。lambda 函数不能包含命令，它们所包含的表达式不能超过一个。不要试图向lambda 函数中塞入太多的东西；如果你需要更复杂的东西，应该定义一个普通函数，然后想让它多长就多长。 3、Python是如何进行类型转换的？ ①函数描述 ② int(x [,base ]) 将x转换为一个整数 ③long(x [,base ]) 将x转换为一个长整数 ④float(x ) 将x转换到一个浮点数 ⑤complex(real [,imag ]) 创建一个复数 ⑥str(x ) 将对象 x 转换为字符串 ⑦repr(x ) 将对象 x 转换为表达式字符串 ⑧eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象 ⑨tuple(s ) 将序列 s 转换为一个元组 ⑩list(s ) 将序列 s 转换为一个列表 ?chr(x ) 将一个整数转换为一个字符 ?unichr(x ) 将一个整数转换为Unicode字符 ?ord(x ) 将一个字符转换为它的整数值 ?hex(x ) 将一个整数转换为一个十六进制字符串 ?oct(x ) 将一个整数转换为一个八进制字符串 4、python多线程与多进程的区别
最常见的35 个Python 面试题及答案（2018 版） 1. Python 面试问题及答案 作为一个Python 新手，你必须熟悉基础知识。在本文中我们将讨论一些Python 面试的基础问题和高级问题以及答案，以帮助你完成面试。包括 Python 开发问题、编程问题、数据结构问题、和 Python 脚本问题。让我们来深入研究这些问题 Python 面试问题 . Python 的特点和优点是什么 Python 可以作为编程的入门语言，因为他具备以下特质： 1. 解释性 2. 动态特性 3. 面向对象 4. 语法简洁 5. 开源 6. 丰富的社区资源 实际上Python 的优点远不止这些，更详细的介绍可以阅读Introduction to Python （ blogs/python-tutorial/） . 深拷贝和浅拷贝的区别是什么 深拷贝是将对象本身复制给另一个对象。这意味着如果对对象的副本进行更改时不会影响原对象。在 Python 中，我们使用 deepcopy（）函数进行深拷贝，使用方法如下： 深拷贝-Python 面试问题及答案 浅拷贝是将对象的引用复制给另一个对象。因此，如果我们在副本中进行更改，则会影响原对象。使用 copy（）函数进行浅拷贝，使用方法如下： 浅拷贝—Python 面试问题及答案 . 列表和元祖有什么不同 主要区别在于列表是可变的，元祖是不可变的。看下面的例子： 会出现以下错误提示： TypeError: ‘tuple’ object does not support item assignment 关于列表和元祖的更多内容参考 Tuples vs Lists（ blogs/python-tuples-vs-lists/）2. Python 面试基础题 到是新手经常会被问到的一些 Python 基础题，有经验的人也可以参考这些问题来复习这些概念。 . 解释 Python 中的三元表达式 与 C++不同, 在 Python 中我们不需要使用符号，而是使用如下语法： [on true] if [expression]else [on false] 如果 [expression] 为真, 则 [on true] 部分被执行。如果表示为假则 [on false] 部分被执行 下面是例子:
Python语言特性 1 Python的函数参数传递 看两个如下例子，分析运行结果: 代码一： a = 1 def fun(a): a = 2 fun(a) print(a) # 1 代码二： a = [] def fun(a): a.append(1) fun(a) print(a) # [1] 所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。 这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples,
和numbers是不可更改的对象，而list,dict等则是可以修改的对象。(这就是这个问题的重点) 当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改. 2 Python中的元类(metaclass) 元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象，但是我们已经学习到了Python中的类也是对象。好吧，元类就是用来创建这些类（对象）的，元类就是类的类 这个非常的不常用,详情请看：《深刻理解Python中的元类(metaclass)》 3 @staticmethod和@classmethod Python其实有3个方法,即静态方法(staticmethod),类方法(classmethod)和实例方法,如下: class A(object): def foo(self,x): print "executing foo(%s,%s)"%(self,x) @classmethod def class_foo(cls,x): print( "executing class_foo(%s,%s)"%(cls,x)) @staticmethod def static_foo(x):
1.Python 线程池原理？ 我理解为线程池是一个存放很多线程的单位，同时还有一个对应的任务队列。整个执行过程其实就是使用线程池中已有有限的线程把任务队列中的任务做完。这样做的好处就是你不需要为每个任务都创建一个线程，因为当你创建第100 个线程来执行第100个任务的时候，可能前面已经有50个线程结束工作了。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。因此重复利用线程来执行任务，减少系统资源的开销。 2.Python合并字典，相同key的value如何相加？ 利用collections.Counter可轻松办到 >>> x = { 'apple':1, 'banana':2 } >>> y = { 'banana':10, 'pear':11 } >>> from collections import Counter >>> X,Y = Counter(x), Counter(y) >>> z = dict(X+Y) >>> z {'apple': 1, 'banana': 12, 'pear': 11} 另一种写法 >>>from collections import Counter >>>dict(Counter(x)+Counter(y)) ( 合并两个字典的方法 方法1： dictMerged1=dict(dict1.items()+dict2.items()) 方法2： dictMerged2=dict(dict1, **dict2) 方法2等同于： dictMerged=dict1.copy() dictMerged.update(dict2) 或者 dictMerged=dict(dict1) dictMerged.update(dict2) 3.解释GUI和GPL？ GUI图形用户（Graphical User Interface，简称GUI，又称图形）是指采用图形方式显示的计算机操作用户。 GPL() GPL同其它的自由软件许可证一样，许可社会公众享有：运行、复制软件的自由，发行传播软件的自由，获得软件源码的自由，改进软件并将自己作出的改进版本向社会发行传播的自由。 4.简述爬虫的基本步骤和流程？
Python基础知识笔试 一、单选题（分*20题） 1. 下列哪个表达式在Python中是非法的 B A. x = y = z = 1 B. x = (y = z + 1) C. x, y = y, x D. x += y 2. python v1 v2 命令运行脚本，通过 from sys imp ort argv如何获得v2的参数值 C A. argv[0] B. argv[1] C. argv[2] D. argv[3] 3. 如何解释下面的执行结果B print - == False A. Python的实现有错误 B. 浮点数无法精确表示 C. 布尔运算不能用于浮点数比较 D. Python将非0数视为False
4. 下列代码执行结果是什么 D x = 1 def change(a): x+= 1 print x change(x) A. 1 B. 2 C. 3 D. 报错 5. 下列哪种类型是Python的映射类型 D A. str B. list C. tuple D. dict 6. 下述字符串格式化语法正确的是 D A. 'GNU's Not %d %%' % 'UNIX' B. 'GNU\'s Not %d %%' % 'UNIX' C. 'GNU's Not %s %%' % 'UNIX' D. 'GNU\'s Not %s %%' % 'UNIX'
7. 在Python 中，下列哪种是Unicode编码的书写方式C A. a = ‘中文’ B. a = r‘中文’ C. a = u’中文’ D. a = b’中文’ 8. 下列代码的运行结果是 D print 'a' < 'b' < 'c' A. a B. b C. c D. True E. False 9. 下列代码运行结果是 C a = 'a' print a > 'b' or 'c' A. a B. b C. c D. True E. False
1 请教一下列表与元组的区别是什么.分别在什么情况下使用 列表中的项目应该包括在方括号中，你可以添加、删除或是搜索列表中的项目。由于你可以增加或 删除项目，所以列表是可变的数据类型，即这种类型是可以被改变的。 元组和列表十分类似，但是元组是不可变的.也就是说你不能修改元组。元组通过圆括号中用逗号分 割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候， 即被使用的元组的值不会改变。 2 字典 键值对的集合(map)字典是以大括号“{}”包围的数据集合。 与列表区别：字典是无序的，在字典中通过键来访问成员。字典是可变的，可以包含任何其他类型。 3 Python是如何进行内存管理的？ Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。另外Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。 也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。 在Python中，许多时候申请的内存都是小块的内存，这些小块内存在申请后，很快又会被释放，由 于这些内存的申请并不是为了创建对象，所以并没有对象一级的内存池机制。这就意味着Python在运 行期间会大量地执行malloc和free的操作，频繁地在用户态和核心态之间进行切换，这将严重影响Python的执行效率。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内 存的申请和释放。这也就是之前提到的Pymalloc机制。 4 如何在一个function里面设置一个全局的变量？ 解决方法是在function的开始插入一个global声明 5 Python中pass语句的作用是什么？ pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作，比如：while False: pass pass通常用来创建一个最简单的类： class MyEmptyClass: pass pass在软件设计阶段也经常用来作为TODO，提醒实现相应的实现，比如： def initlog(*args): pass #please implement this 6 Python里面如何拷贝一个对象？
2018 年最新Python 面试题及答案 找工作是每个学习Python 人员的目标，为了更好的找到工作，刷面试题是必不可 少的，了解最新企业招聘试题，可以让你面试更加的顺利。小编整理了一些20XX年最新的Python 面试题，来测测你技术的掌握度吧。 1、Python 里面如何拷贝一个对象？(赋值，浅拷贝，深拷贝的区别) 答：赋值( =)，就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。 浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象，另外一个也会修改改变) {1, 完全切片方法；2，工厂函数，如list() ；3，copy 模块的copy() 函数} 深拷贝：创建一个新的对象，并且递归的复制它所包含的对象(修改其中一个，另外一个不会改变) {copy 模块的() 函数} 2、Python 里面match() 和search() 的区别？ 答：re 模块中match(pattern,string[,flags]), 检查string 的开头是否与 pattern 匹配。 re 模块中research(pattern,string[,flags]), 在string 搜索pattern 的第一个 匹配值。 >>>print( ‘super', ‘superstition ').span()) (0, 5) >>>print( ‘super', ‘insuperable '))
None >>>print( ‘super', ‘superstition ').span()) (0, 5) >>>print( ‘super ', ‘insuperable ').span()) (2, 7) 3、有没有一个工具可以帮助查找python 的bug 和进行静态的代码分析？ 答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码 的bug, 会对代码的复杂度和格式提出警告 Pylint 是另外一个工具可以进行codingstandard 检查 4、简要描述Python 的垃圾回收机制( garbage collection )。 答案 这里能说的很多。你应该提到下面几个主要的点： Python在内存中存储了每个对象的引用计数(referenee count )。如果计数值变成0，那么相应的对象就会小时，分配给该对象的内存就会释放出来用作他用。 偶尔也会出现引用循环( reference cycle )。垃圾回收器会定时寻找这个循环， 并将其回收。举个例子，假设有两个对象o1和02,而且符合==02和==o1这两个 条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。 Python 中使用了某些启发式算法( heuristics )来加速垃圾回收。例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代 (generation )。每个对象都会被分配一个代，而被分配更年轻代的对象是优先被处理的。
经典Python面试题之数据库和缓存 1. 列举常见的关系型数据库和非关系型都有那些？ 2. MySQL常见数据库引擎及比较？ 3. 简述数据三大范式？ 4. 什么是事务？MySQL如何支持事务？ 5. 简述数据库设计中一对多和多对多的应用场景？ 6. 如何基于数据库实现商城商品计数器？ 7. 常见SQL（必备） 8. 简述触发器、函数、视图、存储过程？ 9. MySQL索引种类 10. 索引在什么情况下遵循最左前缀的规则？ 11. 主键和外键的区别？ 12. MySQL常见的函数？ 13. 列举创建索引但是无法命中索引的8种情况。 14. 如何开启慢日志查询？ 15. 数据库导入导出命令（结构+数据）？ 16. 数据库优化方案？ 17. char和varchar的区别？ 18. 简述MySQL的执行计划？ 19. 在对name做了唯一索引前提下，简述以下区别： select * from tb where name = ‘Oldboy-Wup eiqi’
select * from tb where name = ‘Oldboy-Wupeiqi’ limit 1 20. 1000w条数据，使用limit offset 分页时，为什么越往后翻越慢？如何解决？ 21. 什么是索引合并？ 22. 什么是覆盖索引？ 23. 简述数据库读写分离？ 24. 简述数据库分库分表？（水平、垂直） 25. redis和memcached比较？ 26. redis中数据库默认是多少个db 及作用？ 27. python操作redis的模块？ 28. 如果redis中的某个列表中的数据量非常大，如果实现循环显示每一个值？ 29. redis如何实现主从复制？以及数据同步机制？ 30. redis中的sentinel的作用？ 31. 如何实现redis集群？ 32. redis中默认有多少个哈希槽？ 33. 简述redis的有哪几种持久化策略及比较？ 34. 列举redis支持的过期策略。 35. MySQL 里有 2000w 数据，redis 中只存 20w 的数据，如何保证 redis 中都是热点数据？ 36. 写代码，基于redis的列表实现先进先出、后进先出队列、优先级队列。
1、MySQL 数据库总结 MySQL 可以建多少个数据库，理论上是没有限制的，每一个数据库可以有上亿的对象，但是一般基于硬件要求、效率问题一般不超过64个， 超过64个会对数据处理速度造成影响，每一张表建议不超过过1亿条数据。 2、Python 话题 1.最受欢迎的Python开源框架1：Django2：Twisted 3：Tornado除了以上三种常用的开源框架外还有： Diesel、Flask、Cubes、Kartograph、Pulsar、Web2py、Falcon、DPark、Buildbot、Zerorpc、Bottle、webpy、Scrapy 3、python常用的web框架1：Django2：Tornado3：Bottle4：web.py 5：web2py 6：Quixote（豆瓣网就是基于该框架开发的） 4、python几种流行框架的比较 https://https://www.doczj.com/doc/bd7817712.html,/question/1047367767941211939.html 国内著名网基于Python开发的豆瓣、知乎、美团、咕咚网、快玩游戏。 5、Python常用的内置模块 multiprocessing (多进程模块) Queue（多线程编程）os (用于获取环境变量、路径，判断文件等)functools（包含一些常用的函数） collection（集合、常用数据结构算法）re（正则匹配，字符的查询替换等操作） 6、python中re模块的match（）和search（）函数的区别 re模块中match（pattern，string，[flags]），检查string的开头是否与patter匹配 re模块中search(pattern,string,[flags]),在string搜索pattern的第一个配置值 7、python2和python3的区别 Python2中使用ASCII 码作为默认编码方式导致string有两种类型str和unicode，Python3只支持unicode的string Python2中采用相对路径的import Python3采用的是绝对路径的方式进行import python3的缩进更加的严格python3采用的是print函数exec函数python2采用的是print 语句和exec语句
第一题 以下两段代码，运行结束后的结果是什么？是否相同？原因是什么？ 代码一 代码二 第二题 4G内存怎么读取一个5G的数据？ 第三题 浅述深浅拷贝 答案 第一题 结果不相同 第一段结果为: [{'num':0},{'num':1},{'num':2},{'num':3},{'num':4},{'num':5},{'num':6},{'num':7},{'n um':8},{'num':9}] 第二段结果为: [{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'n um':9},{'num':9}]
字典是可变类型，这里l.append(a)相当于执行了浅拷贝,每改变一次a中num的值,所有a的值都将改变 第二题 实现方法有两种。 实现方法一: 方法一的实现思路是通过生成器,一次读取少量数据,标准答案是根据文件实现，这里给出的例子是咸鱼学习bobby老师的课程时记录的例子,不知道如何使用生成器完成这个需求的朋友可以参考: 实现方法二: 在linux系统下使用split可以分割文件,对于多行文件可以使用按行分割的方式,对于单行的大文件可以采用按文件大小分割。 按文件行数分割:split -l 300 large_file.log smallfile_prefix 按文件大小分割:split -b 10m large_file.log smallfile_prefix 之后再按文件读取即可。 第一题 下图中的打印结果分别是什么？
第二题 Python中静态方法、类方法、成员函数作用是什么？ 第三题 说说对缺省参数的理解？* args是什么？** kwargs是什么？ 答案 第一题 前三个是True,最后一个会报错。 具前三个为什么输出True,不了解的可以参考下图: 图来源于bobby老师的异步IO编程课件 最后一个为什么报错，我们可以先看下issubclass的用法: issubclass方法用于判断参数 class 是否是类型参数 classinfo 的子类 issubclass(class, classinfo) 参数
1. Python是如何进行内存管理的？ 答:从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制 一、对象的引用计数机制 python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。 引用计数增加的情况： 1，一个对象分配一个新名称 2，将其放入一个容器中（如列表、元组或字典） 引用计数减少的情况： 1，使用del语句对对象别名显示的销毁 2，引用超出作用域或被重新赋值 sys.getrefcount( )函数可以获得对象的当前引用计数 多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。 二、垃圾回收 1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。 2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。 三、内存池机制 Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。 1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。 2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。 2. 什么是lambda函数？它有什么好处? 答：lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数 lambda函数：首要用途是指点短小的回调函数 lambda [arguments]:expression >>> a=lambdax,y:x+y >>> a(3,11) 3. Python里面如何实现tuple和list的转换？ 答：直接使用tuple和list函数就行了，type()可以判断对象的类型 4. 请写出一段Python代码实现删除一个list里面的重复元素 答： 1,使用set函数，set(list) 2，使用字典函数， >>>a=[1,2,4,2,4,5,6,5,7,8,9,0] >>> b={} >>>b=b.fromkeys(a) >>>c=list(b.keys()) >>> c 5. 编程用sort进行排序，然后从最后一个元素开始判断 a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]
Python基本面试题|深入解答 分享给大家的11道Python面试题，好多小伙伴都很积极的去思考分析，给我留言的同学非常多,非常欣慰有这么多好学的小伙伴，大家一起学习，一起加油，把Python学好,今天我就把11道面试题细细解答一下 1.单引号，双引号，三引号的区别 分别阐述3种引号用的场景和区别 1),单引号和双引号主要用来表示字符串 比如: 单引号:'python' 双引号:"python" 2).三引号 三单引号:'''python ''',也可以表示字符串一般用来输入多行文本,或者用于大段的注释 三双引号："""python"""，一般用在类里面,用来注释类,这样省的写文档,直接用类的对象__doc__访问获得文档 区别: 若你的字符串里面本身包含单引号,必须用双引号 比如:"can't find the log\n" 2.Python的参数传递是值传递还是引用传递 举例说明Python函数参数传递的几种形式，并说明函数传参是值传递还是引用传递 1).Python的参数传递有： 位置参数
默认参数， 可变参数, 关键字参数 2).函数的传值到底是值传递还是引用传递，要分情况 a.不可变参数用值传递： 像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变不可变对象 b.可变参数是用引用传递的 比如像列表，字典这样的对象是通过引用传递，和C语言里面的用指针传递数组很相似，可变对象能在函数内部改变. 3.什么是lambda函数？它有什么好处? 举例说明lambda的用法，并说明用lambda的优点 1).lambda的用法： lambda是匿名函数，用法如下:lambda arg1,arg2..argN:expression using args 2).优点 lambda能和def做同样种类的工作，特别是对于那些逻辑简单的函数，直接用lambda会更简洁，而且省去取函数名的麻烦(给函数取名是个技术活) 4.字符串格式化:%和.format的区别 字符串的format函数非常灵活，很强大,可以接受的参数不限个数，并且位置可以不按顺序，而且有较为强大的格式限定符(比如:填充，对齐,精度等) 5.Python是如何进行内存管理的 引用计数：引用计数加一，del删除减一 内存池 垃圾回收
Python 经典面试题详解（共53题） 1. 列表（list）和元组（tuple）有什么区别？ 在我每一次应聘Python数据科学家的面试中，这个问题都会被问到。所以对这个问题的答案，我可以说是了如指掌。 ?列表是可变的。创建后可以对其进行修改。 ?元组是不可变的。元组一旦创建，就不能对其进行更改。 ?列表表示的是顺序。它们是有序序列，通常是同一类型的对象。比如说按创建日期排序的所有用户名，如["Seth", "Ema", "Eli"]。 ?元组表示的是结构。可以用来存储不同数据类型的元素。比如内存中的数据库记录，如(2, "Ema", "2020–04–16")（#id, 名称,创建日期）。 2. 如何进行字符串插值？ 在不导入Template类的情况下，有3种方法进行字符串插值。 3. “is”和“==”有什么区别？ 在我的Python职业生涯的早期，我认为它们是相同的，因而制造了一些bug。所以请大家听好了，“is”用来检查对象的标识(id)，而“==”用来检查两个对象是否相等。我们将通过一个例子说明。创建一些列表并将其分配给不同的名字。请注意，下面的b指向与a相同的对象。 下面来检查是否相等，你会注意到结果显示它们都是相等的。
但是它们具有相同的标识（id）吗？答案是不。 我们可以通过打印他们的对象标识（id）来验证这一点。 你可以看到：c和a和b具有不同的标识（id）。 4. 什么是装饰器（decorator）？ 这是每次面试我都会被问到的另一个问题。它本身就值得写一篇文章。如果你能自己用它编写一个例子，那么说明你已经做好了准备。 装饰器允许通过将现有函数传递给装饰器，从而向现有函数添加一些额外的功能，该装饰器将执行现有函数的功能和添加的额外功能。 我们将编写一个装饰器，该装饰器会在调用另一个函数时记录日志。 编写装饰器函数logging。它接受一个函数f un c作为参数。它还定义了一个名为log_f un c tion_c alled的函数，它先执行打印出一些“函数 f un c被调用”的信息（p r int(f'{f un c}c alled.')），然后调用函数 f un c()。最后返回定义的函数。 让我们编写其他两个函数，我们最终会将装饰器添加到其中（但还没有）。
2020年python的面试题整理Web篇Flask 140.对Flask蓝图(Blueprint)的理解？ 蓝图的定义 蓝图/Blueprint 是Flask应用程序组件化的方法，可以在一个应用内或跨越多个项目共用蓝图。使用蓝图可以极大简化大型应用的开发难度，也为Flask扩展提供了一种在应用中注册服务的集中式机制。 蓝图的应用场景： 把一个应用分解为一个蓝图的集合。这对大型应用是理想的。一个项目可以实例化一个应用对象，初始化几个扩展，并注册一集合的蓝图。 以URL前缀和/或子域名，在应用上注册一个蓝图。URL前缀/子域名中的参数即成为这个蓝图下的所有视图函数的共同的视图参数（默认情况下）在一个应用中用不同的URL规则多次注册一个蓝图。 通过蓝图提供模板过滤器、静态文件、模板和其他功能。一个蓝图不一定要实现应用或视图函数。 初始化一个Flask扩展时，在这些情况中注册一个蓝图。 蓝图的缺点： 不能在应用创建后撤销注册一个蓝图而不销毁整个应用对象。 使用蓝图的三个步骤 1.创建一个蓝图对象 2.在这个蓝图对象上进行操作，例如注册路由、指定静态文件夹、注册模板过滤器... 3.在应用对象上注册这个蓝图对象
141.Flask 和Django 路由映射的区别？ 在django中，路由是浏览器访问服务器时，先访问的项目中的url，再由项目中的url找到应用中url，这些url是放在一个列表里，遵从从前往后匹配的规则。在flask中，路由是通过装饰器给每个视图函数提供的，而且根据请求方式的不同可以一个url用于不同的作用。 Django 142.什么是wsgi,uwsgi,uWSGI? WSGI: web服务器网关接口，是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架。 实现wsgi协议的模块：wsgiref,本质上就是编写一socket服务端，用于接收用户请求（django) werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask) uwsgi: 与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议，用于定义传输信息的类型。uWSGI: 是一个web服务器，实现了WSGI的协议，uWSGI协议，http协议143.Django、Flask、Tornado的对比？ 1、Django走的大而全的方向，开发效率高。它的MTV框架，自带的ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器，给开发者提高了超高的开发效率。重量级web框架，功能齐全，提供一站式解决的思路，能让开发者不用在选择上花费大量时间。 自带ORM和模板引擎，支持jinja等非官方模板引擎。 自带ORM使Django和关系型数据库耦合度高，如果要使用非关系型数据库，需要使用第三方库 自带数据库管理app