Python 乃是当下编程领域极受欢迎的语言。在此文中,我会对 Python 面试里最为常见的 50 个问题加以总结。每一道题均给出参考答案,期望可以助力你于 2024 年求职面试时崭露头角,觅得一份高薪工作。这些面试题涵盖了 Python 的基础知识、Python 编程、数据分析以及 Python 函数库等诸多方面。
Python 是最成功的解释型语言之一。当编写 Python 脚本时,它不需要在执行前进行编译。很少有其他解释语言是 PHP 和 Javascript。
Python 编程的好处
参考答案如下:
Python 是一种动态类型语言。这意味着需要在声明时提及变量的数据类型。它允许设置变量,如 var1=101 和 var2 ='You are an engineer.'没有任何错误。
Python 支持面向对象的编程,因为可以定义类以及组合和继承。它不使用诸如 public 或 private 之类的访问说明符)。
Python 中的函数就像一流的对象。它建议可以将它们分配给变量,从其他方法返回并作为参数传递。
使用 Python 开发速度很快,但运行它通常比编译语言慢。幸运的是,Python 能够包含“C”语言扩展,因此您可以优化您的脚本。
Python 有多种用途,例如基于 Web 的应用程序、测试自动化、数据建模、大数据分析等等。或者可以将其用作“胶水”层来使用其他语言。
PEP 8
PEP 8 是最新的 Python 编码标准,一组编码建议。它指导提供更具可读性的 Python 代码。
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print 'list1 = %s' % list1
print 'list2 = %s' % list2
print 'list3 = %s' % list3
参考答案如下:
上述 Python 代码片段的结果是:
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
Shell
可能错误地认为 list1 等于 [10] 并且 list3 与 ['a’] 匹配,认为每次调用 extendList 时列表参数都会初始化为其默认值 []。
但是,流程就像在定义函数后创建了一个新列表。每当有人在没有列表参数的情况下调用 extendList 方法时,都会使用相同的方法。它的工作原理是这样的,因为表达式的计算(在默认参数中)发生在函数定义时,而不是在调用期间。
因此 list1 和 list3 在同一个默认列表上运行,而 list2 在它自己创建的单独对象上运行(通过传递一个空列表作为 list 参数的值)。
extendList 函数的定义可以通过以下方式进行更改。
def extendList(val, list=None):
if list is None:
list = []
list.append(val)
return list
Python
通过这个修改后的实现,输出将是:
list1 = [10]
list2 = [123]
list3 = ['a']
参考答案如下:
pass 语句是一个空操作。执行时没有任何反应。应该使用小写的pass关键字。如果写Pass,会遇到像“NameError: name Pass is not defined”这样的错误。Python 语句区分大小写。
letter = 'hai sethuraman'\nfor i in letter:
if i == 'a':
pass
print('pass statement is execute ..............')
else:
print(i)
参考答案如下:
需要导入 os 模块,然后只需一行即可完成其余工作。
import os
print (os.path.expanduser('~'))
Python
运行结果如下:
/home/runner
参考答案如下:
以下是 Python 支持的最常用的内置类型列表:
Python的不可变内置数据类型:
Numbers
Strings
Tuples
Python 的可变内置数据类型
列表
字典
集合
参考答案如下:
可以使用 PyChecker,它是一个静态分析器。它识别 Python 项目中的错误,并揭示与样式和复杂性相关的错误。另一个工具是 Pylint,它检查 Python 模块是否满足编码标准。
参考答案如下:
Python装饰器是在 Python 语法中为了快速调整函数而进行的相对更改。
参考答案如下:
列表和元组之间的主要区别在于前者是可变的,而元组不是。
允许对元组进行散列处理,例如,将其用作字典的键。
参考答案如下:
Python 使用私有堆来维护它的内存,所以堆包含所有的 Python 对象和数据结构。这个区域只有 Python 解释器可以访问;程序员不能使用它。
处理私有堆的是 Python 内存管理器,它为 Python 对象分配所需的内存。
Python 使用内置的垃圾收集器,它回收所有未使用的内存并将其卸载到堆空间。
参考答案如下:
def 可以保存多个表达式,而 lambda 是一个单表达式函数。
def 生成一个函数并指定一个名称以便稍后调用它。Lambda 形成一个函数对象并返回它。
def 可以有一个 return 语句。Lambda 不能有 return 语句。
lambda 支持在列表和字典中使用。
参考答案如下:
Python 有一个正则表达式模块re。查看可以检查 .com 和 .co.in 子域的电子邮件 ID 的re表达式。
import re
print(re.search(r'[0-9a-zA-Z.]+@[a-zA-Z]+\.(com|co\.in)$','yiibai.com@qq.com'))
参考答案如下:
以上几行代码的结果是[]。不会出现像 IndexError 这样的错误。
尝试使用超出成员计数的索引从列表中获取成员(例如,尝试访问问题中给出的 list[10])会产生 IndexError。顺便说一句,只检索起始索引处超过编号的切片。列表中的项目不会导致 IndexError。它只会返回一个空列表。
参考答案如下:
没有。Python 没有 Switch 语句,但可以编写一个 Switch 函数然后使用它。
参考答案如下:
range() 生成一个数字列表,用于迭代 for 循环。
for i in range(5):
print(i)
Python
range() 函数附带两组参数 :
range(stop) - stop 要生成并从零开始的整数。例如: range(3) == [0, 1, 2]。
range([start], stop[, step])
参考答案如下:
可以在 try-except 块中使用两个可选子句:
“else”字句 - 如果想在 try 块不创建异常时运行一段代码,这将非常有用。
“finally”字句 - 当想要执行一些运行的步骤时,它很有用,无论是否发生异常。
参考答案如下:
Python 中的字符串是一系列字母数字字符,它们是不可变的对象。这意味着一旦被分配了值就不允许修改。Python 提供了几种方法,例如:join()、replace() 或 split() 来更改字符串。但是这些都没有改变原始对象。
参考答案如下:
切片是一种字符串操作,用于提取字符串的一部分或列表的一部分。在 Python 中,字符串(比如文本)从索引 0 开始,第 n 个字符存储在位置 text[n-1]。Python 还可以在负数的帮助下执行反向索引,即反向索引。在 Python 中, slice() 也是一个生成切片对象的构造函数。结果是 range(start, stop, step) 提到的一组索引。
slice() 方法允许三个参数:
start - 切片开始的起始编号。
stop - 表示切片结束的数字。
step – 每个索引后要增加的值(默认值 = 1)。
参考答案如下:
Python 支持将任何值格式化为字符串,它可能包含相当复杂的表达式。一种常见的用法是使用 %s 格式说明符将值推送到字符串中。Python 中的格式化操作具有与 C 函数 printf() 类似的语法。
参考答案如下:
Python 字符串确实是不可变的。举个例子,假设有一个str变量保存一个字符串值。不能改变容器,即字符串,但可以修改它包含的内容,这意味着变量的值。
参考答案如下:
索引是一种整数数据类型,表示有序列表或字符串中的位置。在 Python 中,字符串也是字符列表。可以使用从零开始到长度减一的索引来访问它们。例如,在字符串Program中,索引是这样进行的:
Program 0 1 2 3 4 5
参考答案如下:
文档字符串是一个独特的文本,恰好是以下 Python 结构中的第一条语句:
模块、函数、类或方法定义。
一个文档字符串被添加到字符串对象的 __doc__ 属性中。
参考答案如下:
函数是表示代码块的对象,是可重用的实体。它为程序带来了模块化和更高程度的代码可重用性。Python 为我们提供了许多内置函数,例如 print(),并提供了创建用户定义函数的能力。
参考答案如下:
Python 为我们提供了两种基本类型的函数:
内置
用户自定义
内置函数恰好是 Python 语言的一部分。其中一些是:print()、dir()、len() 和 abs()等。
参考答案如下:
可以通过以下方式创建 Python 函数:
第 1 步:开始函数,以关键字 def 开始编写,然后提及函数名称。
第 2 步:现在可以传递参数并使用括号将它们括起来。最后,冒号表示函数头的结束。
第 3 步:回车后,可以添加想要执行的 Python 语句。
参考答案如下:
Python 中的函数被视为可调用对象。它可以允许一些参数,也可以以元组的形式返回一个或多个值。除了函数之外,Python 还有其他构造,例如:属于同一类别的类或类实例。
参考答案如下:
函数的目的是接收输入并返回一些输出。return 是一个 Python 语句,我们可以在函数中使用它来将值发送回其调用者。
参考答案如下:
在按值调用中,无论是表达式还是值的参数都绑定到函数中的相应变量。Python 会将该变量视为函数级范围内的本地变量。对该变量所做的任何更改都将保持在本地,并且不会反映在函数之外。
参考答案如下:
在Python中经常交替使用“call-by-reference”和“pass-by-reference”。当通过引用传递参数时,它可以作为对函数的隐式引用,而不是简单的副本。在这种情况下,对参数的任何修改也将对调用者可见。
引用传递参数方案还具有带来更多时间和空间效率的优势,因为它不需要创建本地副本。但是,缺点可能是在函数调用期间变量可能会意外更改。因此,程序员需要在代码中处理以避免这种不确定性。
参考答案如下:
Python trunc() 函数执行数学运算以从特定表达式中删除十进制值,并提供一个整数值作为其输出。
方法math.trunc()用于截断浮点值。对于正值,它将用作math.floor()方法;对于负值,它将用作math.ceil()方法。
示例
# importing math module
import math
# floor value
print(math.floor(4.5))
# trunc for positive number
print(math.trunc(4.5))
Python
输出结果
4
4
参考答案如下:
函数根本不需要返回任何值。但是,如果需要,也可以使用 None 作为返回值。
参考答案如下:
continue 是 Python 中的跳转语句,它移动控件以执行循环中的下一次迭代,使块中的所有剩余指令都未执行。
continue 语句适用于while和for循环。
参考答案如下:
id() 是 Python 中的内置函数之一。
Signature: id(object)
Python
它接受一个参数并返回与输入对象关联的唯一标识符。
参考答案如下:
在函数头中使用 *args 作为参数,它使我们能够传递 N(可变)个参数给函数。请注意,这种类型的参数语法不允许将命名参数传递给函数。
使用 *args 的示例:
# Python code to demonstrate
# *args for dynamic arguments
def fn(*argList):
for argx in argList:
print (argx)
fn('I', 'am', 'Learning', 'Python', 'form', 'yii/bai')
Python
运行输出:
I
am
Learning
Python
form
yii/bai
参考答案如下:
我们还可以在 Python 函数声明中使用 **kwargs 语法。它可以让我们传递 N(可变)个可以命名或关键字的参数(字典类型)。
使用 **kwargs 的示例:
#
Python code to demonstrate
# **kwargs for dynamic + named arguments
def fn(**kwargs):
for emp, age in kwargs.items():
print ('%s's age is %s.' %(emp, age))
fn(User1=25, User2=22, Yiibai=32)
Python
运行结果:
User1's age is 25.
User2's age is 22.
Yiibai's age is 32.
参考答案如下:
main()方法/函数是大多数编程语言中最先调用的入口点函数。由于 Python 是基于解释器的,所以它按顺序逐行执行代码。Python 也有一个 main() 方法。但是,只要通过直接单击它或从命令行启动它来运行 Python 脚本,它就会被执行。
我们还可以使用 Python if 语句覆盖 Python 默认的 main() 函数。请看下面的代码。
print('Welcome To Yiibai.com')
print('__name__ contains: ', __name__)
def main():
print('Testing the main function')
if __name__ == '__main__':
main()
Python
运行结果如下:
Welcome To Yiibai.com
__name__ contains: __main__
Testing the main function
参考答案如下:
__name__是一个唯一的变量。由于Python没有公开main()函数,所以当它的解释器要运行脚本时,它首先执行缩进到第0级的代码。为了查看main()是否被调用,我们可以在if子句中使用__name__变量与'__main__'值进行比较。
参考答案如下:
Python 的 print() 函数总是在最后打印一个换行符。print() 函数接受一个称为end的可选参数。默认情况下,它的值是 。可以使用此参数将打印语句中的结束字符更改为选择的值。
# Example: Print a instead of the new line in the end.
print('Let's learn' , end = ' ')
print('Python')
# Printing a dot in the end.
print('Learn to code from yii\bai' , end = '.')
print('com', end = ' ')
Python
运行结果如下:
Let's learn Python
Learn to code from yii\bai.com
参考答案如下:
Python 提供了一个 break 语句来退出循环。每当代码中出现中断时,程序的控制立即从循环体中退出。嵌套循环中的 break 语句使控件从内部迭代块中退出。
参考答案如下:
Python continue 语句使循环从下一次迭代中恢复。相反, pass 语句指示什么都不做,其余代码照常执行。
参考答案如下:
在 Python 中,len() 是一个主要的字符串函数。它确定或计算字符串的长度。示例代码:
#print('Welcome To Yiibai.com')
#print('__name__ contains: ', __name__)
def main():
tips = 'Welcome To Yiibai.com'\n print('len of '', tips, '' is :' ,len(tips))
if __name__ == '__main__':
main()
Python
运行结果如下:
len of ' Welcome To Yiibai.com ' is : 21
参考答案如下:
在 Python 3.2 中重新添加了 chr() 函数。在 3.0 版中,它被删除了。它返回表示其 Unicode 代码点为整数的字符的字符串。
例如,chr(122) 返回字符串“z”,而 chr(1212) 返回字符串“Ҽ”。
参考答案如下:
Python 中的 ord(char) 接受大小为 1 的字符串,如果是 Unicode 类型对象,则返回一个整数,表示字符的 Unicode 代码格式,如果参数是 8 位字符串类型,则返回字节的值。
示例:
>>> ord('z')
122
参考答案如下:
Python 提供了 rstrip() 方法,该方法复制了字符串,但从末尾剔除了空格字符。rstrip() 根据参数值从右端转义字符,即一个字符串,其中提到要排除的字符组。
rstrip() 的签名是:
str.rstrip([char sequence/pre>
Python
示例:
#Example
test_str = 'Programming '
# The trailing whitespaces are excluded
print(test_str.rstrip())
参考答案如下:
空白用于间距和分隔的字符。它们具有“空”表示。在 Python 中,它可以是制表符或空格。
参考答案如下:
Python 为字符串处理提供了这个内置的 isalpha() 函数。如果字符串中的所有字符都是字母类型,则返回 True,否则返回 False。
参考答案如下:
Python 的 split() 函数作用于字符串,将一大块分割成更小的块或子字符串。可以指定一个分隔符来开始拆分,或者默认使用空格作为一个分隔符。
示例代码:
#Example
str = 'pdf csv json yiibai'
print(str.split(' '))
print(str.split())
Python
运行结果如下:
['pdf', 'csv', 'json', 'yiibai']
['pdf', 'csv', 'json', 'yiibai']
参考答案如下:
Python 提供了适用于字符串、列表和元组的 join() 方法。它将它们结合起来并返回一个统一的值。
参考答案如下:
Python 提供了 title() 方法将每个单词中的第一个字母转换为大写格式,而其余的则转换为小写。
示例:
#Example
str = 'Yii bai com'
print(str.title())
Python
运行结果如下:
Yii Bai Com
参考答案如下:
CPython 的核心是用 C 开发的。前缀“C”代表了这一事实。它运行一个解释器循环,用于将 Python-ish 代码翻译成 C 语言。
参考答案如下:
PyPy 提供最大的兼容性,同时利用 CPython 实现来提高其性能。测试证实 PyPy 比 CPython 快近五倍。它目前支持 Python 2.7。
参考答案如下:
Python 支持 GIL(全局解释器锁),它是一个互斥锁,用于保护对 Python 对象的访问,同步多个线程以同时运行 Python 字节码。
参考答案如下:
Python 确保对线程的安全访问。它使用 GIL 互斥锁来设置同步。如果一个线程在任何时候失去了 GIL 锁,那么必须要使代码线程安全。
例如,许多 Python 操作以原子方式执行,例如在列表上调用 sort() 方法。
参考答案如下:
Python 在内部实现了一个堆管理器,它保存了它的所有对象和数据结构。这个堆管理器为对象分配/取消分配堆空间。
参考答案如下:
元组是 Python 中不可变的集合类型数据结构。它们类似于序列,就像列表一样。但是,元组和列表之间存在一些差异;前者不允许修改,而列表允许。此外,元组使用括号括起来,但列表的语法中有方括号。
参考答案如下:
字典是一种数据结构,在 Python 中称为关联数组,用于存储对象的集合。集合是一组具有单个关联值的键。可以称它为哈希、映射或哈希映射,因为它在其他编程语言中被调用。5
参考答案如下:
集合是 Python 中的无序集合对象。它们存储唯一且不可变的对象。Python 的实现源自数学。
参考答案如下:
字典有一组对象(键)映射到另一组对象(值)。Python 字典表示唯一键到值的映射。它们是可变的,因此不会改变。与键关联的值可以是任何 Python 类型。
参考答案如下:
Python 列表是一个可变长度数组,它不同于 C 风格的链表。在内部,它有一个用于引用其他对象的连续数组,并将指向数组变量的指针及其长度存储在列表头结构中。
参考答案如下:
Python支持面向对象的编程,并提供了几乎所有的 OOP 特性以在程序中使用。Python 类是创建对象的蓝图。它定义成员变量并获取与它们相关联的行为。可以使用关键字class来实现它。从构造函数创建一个对象。该对象表示类的实例。在 Python 中,我们通过以下方式生成类和实例。
>>>class Human: # Create the class
... pass
>>>man = Human() # Create the instance
>>>print(man)
<__main__.Human object at 0x0000000003652E11>
参考答案如下:
如果一个类没有定义任何功能,它是没有什么用处的,可以通过添加属性来做到这一点。它们充当数据和功能的容器。我们可以在类体内添加一个直接指定的属性。
>>> class Human:
... profession = 'programmer' # specify the attribute 'profession' of the class
>>> man = Human()
>>> print(man.profession)
programmer
Python
添加属性后,可以继续定义功能。通常称它们为方法。在方法签名中,总是必须为第一个参数提供一个 self 关键字。
>>> class Human:
profession = 'programmer'\n def set_profession(self, new_profession):
self.profession = new_profession
>>> man = Human()
>>> man.set_profession('Manager')
>>> print(man.profession)
Manager
参考答案如下:
可以在运行时指定属性的值。需要添加一个 __init__ 方法并将输入传递给对象构造函数。请参阅以下示例:
>>> class Human:
def __init__(self, profession):
self.profession = profession
def set_profession(self, new_profession):
self.profession = new_profession
>>> man = Human('Manager')
>>> p
rint(man.profession)
Manager
参考答案如下:
继承是一种 OOP 机制,它允许对象访问其父类功能。它将基类功能和属性传递给子类。
我们有意抽象出不同类中的相似代码。公共代码依赖于基类,子类对象可以通过继承访问它。看看下面的例子 -
class PC: # Base class
processor = 'Xeon' # Common attribute
def set_processor(self, new_processor):
processor = new_processor
class Desktop(PC): # Derived class
os = 'Mac OS High Sierra' # Personalized attribute
ram = '32 GB'\n
class Laptop(PC): # Derived class
os = 'Windows 10 Pro 64' # Personalized attribute
ram = '16 GB'\n
desk = Desktop()
print(desk.processor, desk.os, desk.ram)
lap = Laptop()
print(lap.processor, lap.os, lap.ram)
Python
运行结果:
Xeon Mac OS High Sierra 32 GB
Xeon Windows 10 Pro 64 16 GB
参考答案如下:
组合也是 Python 中的一种继承。它打算从基类继承,但略有不同,即使用基类的实例变量作为派生类的成员。
见下图:
为了演示组合,需要实例化类中的其他对象,然后使用这些实例。
class PC: # Base class
processor = 'Xeon' # Common attribute
def __init__(self, processor, ram):
self.processor = processor
self.ram = ram
def set_processor(self, new_processor):
processor = new_processor
def get_PC(self):
return '%s cpu & %s ram' % (self.processor, self.ram)
class Tablet():
make = 'Intel'\n def __init__(self, processor, ram, make):
self.PC = PC(processor, ram) # Composition
self.make = make
def get_Tablet(self):
return 'Tablet with %s CPU & %s ram by %s' % (self.PC.processor, self.PC.ram, self.make)
if __name__ == '__main__':
tab = Tablet('i7', '16 GB', 'Intel')
print(tab.get_Tablet())
Python
运行结果如下:
Tablet with i7 CPU & 16 GB ram by Intel
参考答案如下:
错误是程序中的编码问题,可能导致程序异常退出。相反,异常是由于外部事件的发生而中断了程序的正常
参考答案如下:
Python 制定了 Try、Except、Finally 构造来处理错误和异常。我们将缩进的不安全代码附在 try 块下。可以将后备代码保留在 except 块中。任何打算最后执行的指令都应该在 finally 块下。
try:
print('Executing code in the try block')
print(exception)
except:
print('Entering in the except block')
finally:
print('Reached to the final block')
Python
运行结果:
Executing code in the try block
Entering in the except block
Reached to the final block
参考答案如下:
我们可以根据某些条件引发异常。例如,如果希望用户只输入奇数,否则将引发异常。
# Example - Raise an exception
while True:
try:
value = int(input('Enter an odd number- '))
if value%2 == 0:
raise ValueError('Exited due to invalid input!!!')
else:
print('Value entered is : %s' % value)
except ValueError as ex:
print(ex)
break
Python
运行结果:
Enter an odd number- 2
Exited due to invalid input!!!
Enter an odd number- 1
Value entered is : 1
Enter an odd number-
参考答案如下:
Python 中的迭代器是类似数组的对象,允许在下一个元素上移动。在遍历循环时使用它们,例如在for循环中。Python库没有迭代器。例如,一个列表也是一个迭代器,可以在它上面开始一个 for 循环。
参考答案如下:
像列表、元组、字典和集合这样的集合类型都是可迭代对象(Iterable),而它们也是可迭代容器,在遍历时会返回一个迭代器(Iterator)。
参考答案如下:
生成器是一种函数,它允许指定一个函数,该函数的作用类似于迭代器,因此可以在for循环中使用。在生成器函数中,yield 关键字替代了 return 语句。
# Simple Python function
def fn():
return 'Simple Python function.'\n
# Python Generator function
def generate():
yield 'Python Generator function.'\n
print(next(generate()))
Python
运行得到结果:
Python Generator function.
参考答案如下:
Python 闭包是一个函数返回另一个函数对象,使用它们来消除代码冗余。在下面的示例中,我们编写了一个用于乘法的简单闭包。
def multiply_number(num):
def product(number):
'product() here is a closure'
return num * number
return product
num_2 = multiply_number(2)
print(num_2(11))
print(num_2(24))
num_6 = multiply_number(6)
print(num_6(1))
Python
输出结果:
22
48
6
参考答案如下:
Python装饰器使我们能够动态地向给定对象添加新行为。在下面的示例中,我们编写了一个简单的示例来在函数执行前后显示消息。
def decorator_sample(func):
def decorator_hook(*args, **kwargs):
print('Before the function call')
result = func(*args, **kwargs)
print('After the function call')
return result
return decorator_hook
@decorator_sample
def product(x, y):
'Function to multiply two numbers.'\n return x * y
print(product(3, 3))
Python
运行结果:
Before the function call
After the function call
9
参考答案如下:
这里以建筑工地统计为例。为此,我们首先需要使用冒号(:)分解键值对。键应该是不可变类型,也就是说将使用不允许在运行时更改的数据类型。从 int、string 或 tuple 中进行选择。但是可以采用任何类型的值。为了区分数据对,可以使用逗号(,)并将整个内容保存在花括号({...})中。
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> type(site_stats)
<class 'dict'>
>>> print(site_stats)
{'type': 'organic', 'site': 'yiibai.com', 'traffic': 10000}
参考答案如下:
要从字典中获取数据,可以使用键直接访问。在提到与字典对应的变量名之后,可以使用括号 […] 将“键”括起来。
示例:
>>> site_stats = {'site': 'yiib\ai.com', 'traffic': 10000, 'type': 'organic'}
>>> print(site_stats['traffic'])
Python
运行结果:
yiib\ai.com
Shell
甚至可以调用 get 方法从字典中获取值。它还让设置一个默认值。如果未能找到键,则会发生 KeyError。
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> print(site_stats.get('site'))
yiibai.com
参考答案如下:
可以使用“for”和“in”循环来遍历字典对象。参考以下示例:
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> for k, v in site_stats.items():
print('The key is: %s' % k)
print('The value is: %s' % v)
print('++++++++++++++++++++++++')
Python
运行结果如下:
The key is: type
The value is: organic
++++++++++++++++++++++++
The key is: site
The value is: yiibai.com
++++++++++++++++++++++++
The key is: traffic
The value is: 10000
++++++++++++++++++++++++
参考答案如下:
可以通过使用新键修改字典来添加元素,然后为其设置值。
>>> # Setup a blank dictionary
>>> site_stats = {}
>>> site_stats['site'] = 'yiibai.com'
>>> site_stats['traffic'] = 10000000000
>>> site_stats['type'] = 'Referral'
>>> print(site_stats)
{'type': 'Referral', 'site': 'yiibai.com', 'traffic': 100000000
00}
Shell
甚至可以在 update() 方法的帮助下加入两个字典以获得更大的字典。
>>> site_stats['site'] = 'vsdiffer.com'
>>> print(site_stats)
{'site': 'vsdiffer.com'}
>>> site_stats_new = {'traffic': 1000000, 'type': 'blog site'}
>>> site_stats.update(site_stats_new)
>>> print(site_stats)
{'type': 'blog site', 'site': 'vsdiffer.com', 'traffic': 100000
0}
参考答案如下:
可以使用 del() 方法删除字典中的键。
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> del site_stats['type']
>>> print(site_stats)
{'site': 'yiibai.com', 'traffic': 1000000}
Python
可以使用的另一种方法是 pop() 函数,它接受键作为参数。另外,第二个参数,如果键不存在,可以传递一个默认值。
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> print(site_stats.pop('type', None))
organic
>>> print(site_stats)
{'site': 'yiibai.com', 'traffic': 10000}
参考答案如下:
可以使用 Python 的“in”运算符来测试 dict 对象中是否存在键。参考以下代码:
>>> site_stats = {'site': 'yiibai.com', 'traffic': 10000, 'type': 'organic'}
>>> 'site' in site_stats
True
>>> 'traffic' in site_stats
True
>>> 'type' in site_stats
True
Shell
早期,Python 还提供了已弃用的 has_key() 方法。
参考答案如下:
列表推导的签名如下:
[ expression(var) for var in iterable ]
Python
例如,下面的代码将返回从 10 到 20 的所有数字并将它们存储在一个列表中。
>>> alist = [var for var in range(10, 20)]
>>> print(alist)
参考答案如下:
字典的语法与列表推导式的语法相同,但不同之处在于它使用花括号:
{ aKey, itsValue for aKey in iterable }
Python
例如,下面的代码将返回所有数字 10 到 20 作为键,并将这些数字的相应平方存储为值。
>>> adict = {var:var**2 for var in range(10, 20)}
>>> print(ad
参考答案如下:
生成器表达式的语法与列表推导匹配,但不同之处在于它使用括号:
( expression(var) for var in iterable )
Python
例如,下面的代码将创建一个生成器对象,在使用它时生成从 10 到 20 的值。
>>> (var for var in range(10, 20))
at 0x0000000003668728>
>>> list((var for var in range(10, 20)))
参考答案如下:
可以将以下单个语句用作条件表达式。default_statment if Condition else another_statement,示例代码如下:
>>> no_of_days = 366
>>> is_leap_year = 'Yes' if no_of_days == 366 else 'No'\n>>> print(is_leap_year)
Yes
参考答案如下:
在使用迭代器时,有时可能会有一个用例来存储迭代次数。Python 通过提供 enumerate() 内置方法很容易完成这项任务。enumerate() 函数将一个计数器变量附加到一个可迭代对象,并将其作为“枚举”对象返回。
可以直接在“for”循环中使用该对象,或者通过调用 list() 方法将其转换为元组列表。它具有以下签名:
enumerate(iterable, to_begin=0)
#Arguments:
# iterable: array type object which enables iteration
# to_begin: the base index for the counter is to get started,
its default value is 0
Python
示例代码:
# Example - enumerate function
alist = ['apple','mango', 'orange']
astr = 'banana'\n
# Let's set the enumerate objects
list_obj = enumerate(alist)
str_obj = enumerate(astr)
print('list_obj type:', type(list_obj))
print('str_obj type:', type(str_obj))
print(list(enumerate(alist)) )
# Move the starting index to two from zero
print(list(enumerate(astr, 2)))
Python
运行结果如下:
list_obj type: <class 'enumerate'>
str_obj type: <class 'enumerate'>
[(0, 'apple'), (1, 'mango'), (2, 'orange')]
[(2, 'b'), (3, 'a'), (4, 'n'), (5, 'a'), (6, 'n'), (7, 'a')]
参考答案如下:
Python 中的 globals() 函数将当前全局符号表作为字典对象返回。Python 维护一个符号表来保存有关程序的所有必要信息。此信息包括程序使用的变量、方法和类的名称。
该表中的所有信息都保留在程序的全局范围内,Python 允许使用 globals() 方法检索它。
Signature: globals()
Arguments: None
Python
示例代码:
# Example: globals() function
x = 9
def fn():
y = 3
z = y + x
# Calling the globals() method
z = globals()['x'] = z
return z
# Test Code
ret = fn()
print(ret)
Python
输出结果:
12
参考答案如下:
zip 方法用于映射多个容器的相应索引,以便可以将它们作为一个单元使用。
方法签名:
Signature:
zip(*iterators)
Arguments:
Python iterables or collections (e.g., list, string, etc.)
Returns:
A single iterator object with combined mapped values
Python
示例代码:
# Example: zip() function
emp = [ 'tom', 'john', 'jerry', 'jake' ]
age = [ 32, 28, 33, 44 ]
dept = [ 'HR', 'Accounts', 'R&D', 'IT' ]
# call zip() to map values
out = zip(emp, age, dept)
# convert all values for printing them as set
out = set(out)
# Displaying the final values
print ('The output of zip() is : ',end='')
print (out)
Python
运行结果:
The output of zip() is : {('jerry', 33, 'R&D'), ('jake', 44,'IT'), ('john', 28, 'Accounts'), ('tom', 32, 'HR')}
参考答案如下:
在 Python 中,所有对象共享公共类或静态变量。但是对于不同的对象,实例或非静态变量是完全不同的。C++、Java等编程语言需要使用static关键字将变量作为类变量。然而,Python 有一种独特的方式来声明一个静态变量。在类声明中使用值初始化的所有名称都成为类变量。在类方法中获得赋值的那些成为实例变量。
# Example
class Test:
aclass = 'programming' # A class variable
def __init__(self, ainst):
self.ainst = ainst # An instance variable
# Objects of CSStudent class
test1 = Test(1)
test2 = Test(2)
print(test1.aclass)
print(test2.aclass)
print(test1.ainst)
print(test2.ainst)
# A class variable is also accessible using the class name
print(Test.aclass)
Python
运行结果:
programming
programming
1
2
programming
参考答案如下:
三元运算符是条件语句的替代方案,它将真或假值与需要测试的语句组合在一起。
语法如下所示:
[onTrue] if [Condition] else [onFalse]
Python
示例代码:
x, y = 35, 75
smaller = x if x < y else y
print(smaller)
参考答案如下:
self 是一个 Python 关键字,它表示一个保存对象实例的变量。在几乎所有面向对象的语言中,它都作为隐藏参数传递给方法
参考答案如下:
在 Python 中有两种复制对象的方法。
copy.copy()函数
它将文件从源复制到目标。
它将返回参数的浅拷贝。
copy.deepcopy()函数
它还生成从源到目标的对象副本。
它将返回可以传递给函数的参数的深层副本。
参考答案如下:
在 Python 中,文档字符串就是我们所说的文档字符串。它设置了记录 Python 函数、模块和类的过程。
参考答案如下:
要将数字转换为字符串,可以使用内置函数 str()。如果想要八进制或十六进制表示,请使用内置函数 oct() 或 hex()。
参考答案如下:
是的,我们可以使用 Python 调试器 (pdb) 来调试任何 Python 程序。如果使用 pdb 启动一个程序,那么它是可以单步执行代码的。
参考答案如下:
这里有一些 PDB 命令可以用于调试 Python 代码。
添加断点 (b)
恢复执行 (c)
一步一步调试(s)
移动到下一行 (n)
列出源代码(l)
打印表达式 (p)
参考答案如下:
以下命令有助于在调试模式下运行 Python 程序。
$ python -m pdb python-script.py
参考答案如下:
在 Python 中,可以使用 sys 模块的 settrace() 方法来设置跟踪挂钩并监控程序内部的函数。需要定义一个跟踪回调方法并将其传递给 settrace() 函数。回调应指定三个参数,如下所示:
import sys
def trace_calls(frame, event, arg):
# The 'call' event occurs before a function gets executed.
if event != 'call':
return
# Next, inspect the frame data and print information.
print 'Function name=%s, line num=%s' % (frame.f_code.co_name, frame.f_lineno)
return
def demo2():
print 'in demo2()'
def demo1():
print 'in demo1()'
demo2()
sys.settrace(trace_calls)
demo1()
参考答案如下:
Python 中的生成器是一个返回可迭代对象的函数。可以使用 yield 关键字迭代生成器对象。但是只能这样做一次,因为它们的值不会保留在内存中,它们会即时获取值。
生成器使我们能够保持函数或步骤的执行,只要想保留它。但是,这里有一些使用生成器有益的示例。
可以用生成器替换循环,以有效地计算涉及大型数据集的结果。
当不想要所有结果并希望保留一段时间时,生成器很有用。
可以用生成器代替它,而不是使用回调函数。可以在函数内部编写一个循环,执行与回调相同的操作,并将其转换为生成器。
参考答案如下:
yield 关键字可以将任何函数变成生成器,它就像一个标准的return关键字。但它总是会返回一个生成器对象。此外,一个方法可以多次调用 yield 关键字。
请参见下面的示例:
def testgen(index):
weekdays = ['sun','mon','tue','wed','thu','fri','sat']
yield weekdays[index]
yield weekdays[index+1]
day = testgen(0)
print next(day), next(day)
#output: sun mon
参考答案如下:
有时,我们不会按原样使用列表。而是需要将它们转换为其他类型。
将列表转换为字符串
可以使用 .join() 方法将所有元素组合成一个并作为字符串返回。
示例代码:
weekdays = ['sun','mon','tue','wed','thu','fri','sat']
listAsString = ' '.join(weekdays)
print(listAsString)
#output: sun mon tue wed thu fri sat
Python
将列表变成元组
调用 Python 的 tuple() 函数将列表转换为元组。此函数将列表作为其参数。但是请记住,将列表转换为元组后我们无法更改列表,因为它变得不可变。
weekdays = ['sun','mon','tue','wed','thu','fri','sat']
listAsTuple = tuple(weekdays)
print(listAsTuple)
#output: ('sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat')
Python
把一个列表变成一个集合
将列表转换为集合会带来两个副作用。
集合不允许重复条目,因此转换将删除任何此类项目。
集合是有序集合,因此列表项的顺序也会发生变化。
但是,可以使用 set() 函数将列表转换为集合。
weekdays = ['sun','mon','tue','wed','thu','fri','sat','sun','tue']
listAsSet = set(weekdays)
print(listAsSet)
#output: set(['wed', 'sun', 'thu', 'tue', 'mon', 'fri', 'sat'])
Python
将列表变成字典
在字典中,每个项目代表一个键值对。因此,转换列表并不像转换其他数据类型那样简单。但是,可以通过将列表分成一组对然后调用 zip() 函数将它们作为元组返回来实现转换。将元组传递给 dict() 函数最终会将它们变成字典。
weekdays = ['sun','mon','tue','wed','thu','fri']
listAsDict = dict(zip(weekdays[0::2], weekdays[1::2]))
print(listAsDict)
#output: {'sun': 'mon', 'thu': 'fri', 'tue': 'wed'}
参考答案如下:
与集合不同,列表可以包含具有相同值的项目。在 Python 中,列表有一个 count() 函数,它返回特定项目的出现次数。
计算单个项目的出现次数
weekdays = ['sun','mon','tue','wed','thu','fri','sun','mon','mon']
print(weekdays.count('mon'))
#output: 3
Python
计算列表中每个项目的出现次数
我们使用列表推导和 count() 方法,它将打印每个项目的频率。
weekdays = ['sun','mon','tue','wed','thu','fri','sun','mon','mon']
print([[x,weekdays.count(x)] for x in set(weekdays)])
#output: [['wed', 1], ['sun', 2], ['thu', 1], ['tue', 1], ['mon',3], ['fri', 1]]
参考答案如下:
NumPy 是一个用于科学计算的 Python 包,可以处理大数据量。它包括一个强大的 N 维数组对象和一组高级函数。
此外,NumPy 数组优于内置列表。有一个没有索引编号的原因。
NumPy 数组比列表更紧凑。
使用 NumPy 读取和写入项目更快。
使用 NumPy 比使用标准列表更方便。
NumPy 数组更有效,因为它们增强了 Python 中列表的功能。
参考答案如下:
可以应用两种方法来创建空的 NumPy 数组。第一种方法是创建一个空数组,示例代码:
import numpy
numpy.array([])
Python
第二种方法创建一个空数组:
# Make an empty NumPy array
numpy.empty(shape=(0,0))
联系客服