史上最全python面试题详解（一）上【黑马python培训】

更新时间:2019年07月26日 10时48分38秒来源:黑马程序员论坛

1、简述解释型和编译型编程语言？
概念：
编译型语言：把做好的源程序全部编译成二进制代码的可运行程序。然后，可直接运行这个程序。
解释型语言：把做好的源程序翻译一句，然后执行一句，直至结束！
区别：
编译型语言，执行速度快、效率高；依赖编译器、跨平台性差些。如C、C++、Delphi、Pascal，Fortran。
解释型语言，执行速度慢、效率低；依赖解释器、跨平台性好。如Java、Basic.
2、Python解释器种类以及特点
CPython
c语言开发的使用最广的解释器
IPython
基于cpython之上的一个交互式计时器交互方式增强功能和cpython一样
PyPy
目标是执行效率采用JIT技术对python代码进行动态编译，提高执行效率
JPython
运行在Java上的解释器直接把python代码编译成Java字节码执行
IronPython
运行在微软 .NET 平台上的解释器，把python编译成. NET 的字节码
3、python常见的PEP8规范
每级缩进用4个空格
Python 3中不允许混合使用Tab和空格缩进。
限制所有行的最大行宽为79字符。
在核心Python发布的代码应该总是使用UTF-8(ASCII在Python 2)。
推荐绝对路径导入，因为它们通常更可读
4、通过代码实现如下进制转换：
hex()
转换一个整数对象为十六进制的字符串

>>> hex(16)
'0x10'
>>> hex(18)
'0x12'
>>> hex(32)
'0x20'
oct()
转换一个整数对象为八进制的字符串

>>> oct(8)
'0o10'
>>> oct(166)
'0o246'
bin()
转换一个整数对象为二进制字符串

>>> bin(10)
'0b1010'
>>> bin(255)
'0b11111111'
chr()
转换一个[0, 255]之间的整数为对应的ASCII字符

>>> chr(65)
'A'
>>> chr(67)
'C'
>>> chr(90)
'Z'
>>> chr(97)
'a'
ord()
将一个ASCII字符转换为对应整数

>>> ord('A')
65
>>> ord('z')
122
16进制转10进制
>>> int('10', 16)
16
>>> int('0x10', 16)
16

8进制转10进制
>>> int('0o10', 8)
8
>>> int('10', 8)
8

2进制转10进制
>>> int('0b1010', 2)
10
>>> int('1010', 2)
10
5、python递归的最大层数
import sys
sys.setrecursionlimit(100000)

def foo(n):
print(n)
n += 1
foo(n)

if __name__ == '__main__':
foo(1)
得到的最大数字在3925-3929之间浮动，这个是和计算机有关系的，不然也不会是一个浮动的数字了（数学逻辑讲求严谨）

6、三元运算规则以及应用场景
      三元运算符就是在赋值变量的时候，可以直接加判断，然后赋值
      三元运算符的功能与'if....else'流程语句一致，它在一行中书写，代码非常精炼，执行效率更高
      格式：[on_true] if [expression] else [on_false]
      res = 值1 if 条件 else 值2
7、列举 Python2和Python3的区别
print　　
input
问题：如何获取编码方式的信息？
获取目标bytes的编码方式
这一情况可以通过chardet模块的detect()函数来获取信息，chardet是第三方库，可以通过pip来安装

b是待检测的bytes变量

import chardet
print(chardet.detect(b))
######output####
{'confidence': 1.0, 'encoding': 'ascii'}
1
2
3
4
5
confidence是指匹配程度，encoding是指可能的编码方式

获取当前环境的编码方式
这一情况可以使用sys模块下的getdefaultencoding()函数来获取信息

import sys
print(sys.getdefaultencoding())

######## output#####
utf-8
问题在控制台上看到的到底是什么
写上面的东西的时候产生了一个疑问，现在已经知道Python内部存储str的方式是使用unicode字符集，但是我们在屏幕上看到的并不是unicode字符集
s = "你好"
print(s)
#########output#############
你好
s的 unicode 是 \u4f60\u597d
1
那么，这中间应该是进行了某种转换
实际上，在执行print(str)的时候，python内部执行了encoding操作，控制台拿到的其实是一个bytes变量
之后，控制台又根据环境内部的编码方式，将所得到的bytes内容进行decoding的操作，就显示了原先str的内容
打开文件不再支持 file 方法，只能用 open
range不再返回列表，而是一个可迭代的range对象
除法 / 不再是整除，而是得到浮点数，整除需要用双斜杠 //
urllib和urllib2合并成了urllib，常用的urllib2.urlopen()变成了urllib.request.urlopen()
字符串及编码相关有大变动，简单来说就是原来的str变成了新的bytes，原来的unicode变成了新的str。
8、xrange和range的区别
　　python2中 xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。

9、python的read() 、readline()、readlines()、xreadlines()
read()会读取整个文件，将读取到底的文件内容放到一个字符串变量，返回str类型。
readline()读取一行内容，放到一个字符串变量，返回str类型。
readlines() 读取文件所有内容，按行为单位放到一个列表中，返回list类型。
xreadlines()返回一个生成器，来循环操作文件的每一行。
10、列举布尔值为False的常见值
　　None、""、0、[]、()、{}

11、字符串、列表、元组、字典每个常用的5个方法（整型，浮点，字符串，布尔型，列表、元组、字典、集合、日期）
字符串：

# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 15:10'

# 1. 去掉空格和特殊符号
name = " abcdefgeyameng  "
name1 = name.strip()  # 并不会在原来的字符串上操作,返回一个去除了两边空白的字符串
print(name1, len(name1), name, len(name))
# abcdefgeyameng 14  abcdefgeyameng 17

# 去掉左边的空格和换行符
name2 = name.lstrip()
print(name2, len(name2))# print(name2, len(name2))#

# 去掉右边的空格和换行符
name3 = name.rstrip()
print(name3, len(name3)) # abcdefgeyameng 15

# 2.字符串的搜索和替换
name.count('e')  # 查找某个字符在字符串中出现的次数
name.capitalize() # 首字母大写
name.center(100,'-') # 把字符串方中间,两边用-补齐,100表示占位多少
name.find('a') # 找到这个字符返回下标,多个时返回第一个,不存在时返回-1
name.index('a') # 找到这个字符返回下标,多个时返回第一个,不存在时报错
print(name.replace(name,'123')) # 字符串的替换
name.replace('abc','123') # 注意字符串的替换的话,不是在原来的字符串上进行替换.而是返回一个替换后的字符串.

# 3.字符串的测试和替换函数
name.startswith("abc") # 是否以abc开头
name.endswith("def") # 是否以def结尾
name.isalnum() # 是否全是字母和数字,并且至少包含一个字符
name.isalpha() # 是否全是字母,并至少包含一个字符
name.isdigit() # 是否全是数字,并且至少包含一个字符
name.isspace() # 是否全是空白字符,并且至少包含一个字符
name.islower() # 是否全是小写
name.isupper() # 是否全是大写
name.istitle() # 是否是首字母大写

# 4.字符串的分割
name.split('') # 默认按照空格进行分隔,从前往后分隔
name.rsplit() # 从后往前进行分隔

# 5.连接字符串
'.'.join(name) # 用.号将一个可迭代的序列拼接起来

name = 'geyameng'
# 6.截取字符串(切片)
name1 = name[0:3] # 第一位到第三位的字符,和range一样不包含结尾索引
name2 = name[:] # 截取全部的字符
name3 = name[6:] # 截取第6个字符到结尾
name4 = name[:-3] # 截取从开头到最后一个字符之前
name5 = name[-1] # 截取最后一个字符
name6 = name[::-1] # 创造一个与原字符串顺序相反的字符串
name7 = name[:-5:-1] # 逆序截取
列表：

# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 16:26'

# 1.创建一个列表
list1 = ['1', '2', '3', '4']
list2 = list("1234")
print(list1, list2)
print(list1 == list2)
# 以上创建的两个列表是等价的,都是['1', '2', '3', '4']

# 2.添加新元素
# 末尾追加
a = [1, 2, 3, 4, 5]
a.append(6)
print(a)

# 指定位置的前面插入一个元素
a.insert(2, 100)  # 在下标为2的前面插入一个元素100
print(a)

# 扩展列表list.extend(iterable),在一个列表上追加一个列表
a.extend([10, 11, 12])
print(a)

# 3.遍历列表
# 直接遍历
for i in a:
print(i)

# 带索引的遍历列表
for index, i in enumerate(a):
print(i, index)

# 4.访问列表中的值,直接通过下标取值.list[index]
print(a[2])

# 从list删除元素
# List.remove() 删除方式1:参数object 如果重复元素,只会删除最靠前的.
a = [1,2,3]
a.remove(2) # 返回值是None

# List.pop()  删除方式2:pop 可选参数index,删除指定位置的元素默认为最后一个元素
a = [1,2,3,4,5]
a.pop()
print(a)

a.pop(2)
print(a)

# 终极删除,可以删除列表或指定元素或者列表切片,list删除后无法访问
a = [1,2,3,4,5,6]
del  a[1]
print(a) # 1, 3, 4, 5, 6]

del a[1:]
print(a) # 1

del a
# print(a) # 出错,name a is not defined

# 排序和反转代码
# reverse 反转列表
a = [1,2,3,4,5]
a.reverse()
print(a)

# sort 对列表进行排序,默认升序排列.有三个默认参数cmp = None,key = None,reverse = False

# 7.Python的列表的截取与字符串操作类型相同,如下所示
L = ['spam','Spam','SPAM!']
print(L[-1]) # ['SPAM']

# 8.Python列表操作的函数和方法
len(a)  # 列表元素的个数
max(a)  # 返回列表元素最大值
min(a)  # 返回列表元素最小值
list(tuple) #将一个可迭代对象转换为列表

# 列表常用方法总结
a.append(4)
a.count(1)
a.extend([4,5,6])
a.index(3)
a.insert(0,2)
a.remove()
a.pop()
a.reverse()
a.sort()
元组：

1.用一个可迭代对象生成元组
T = tuple('abc')
对元组进行排序
注意
当对元组进行排序的时候,通常先得将它转换为列表并使得它成为一个可变对象.或者使用sorted方法,它接收任何序列对象.

T = ('c','a','d','b')
tmp = list(T)
tmp.sort()  ==> ['a','b','c','d']
T = tunple(tmp)
sorted(T)

字典：

以下实例展示了 fromkeys()函数的使用方法：

实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
seq = ('Google', 'Runoob', 'Taobao')
dict = dict.fromkeys(seq)
print "新字典为 : %s" % str(dict)
dict = dict.fromkeys(seq, 10)
print "新字典为 : %s" % str(dict)
以上实例输出结果为：

新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None}
新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}
通过zip函数构建字典
D = dict(zip(keyslist,valueslist))
通过赋值表达式元组构造字典(键必须是字符串,因为如果不是字符串,构造的时候也会当成是字符串处理)
D = dict(name='Bob',age=42)  ==> {'name':'Bob,'age':42}
列出所有的键,值.注意得到的是一个可迭代对象,而不是列表.用的时候需要转换
D.keys()
D.values()
D.items()  --> 键 + 值
删除字典(根据键)以及长度
D.pop(key)
len(D)
del D[key]
新增或者是修改键对应的值
D[key] = value  # 如果key已经存在则修改,如果不存在就创建.
字典推导式
D = [x:x**2 for x in range(10) if x %2 == 0]
12、lambda表达式格式以及应用场景
1、lambda函数与list的结合使用

list = lambda:x for x in range(10)
print (list[0])
>>>9

list = lambda x:x for x in range(10)
print (list[0])
>>>0
2、map,filter,reduce函数

例子：
a = [('a',1),('b',2),('c',3),('d',4)]
a_1 = list(map(lambda x:x[0],a))
如上例子，map函数第一个参数是一个lambda表达式，输入一个对象，返回该对象的第一个元素。第二个就是需要作用的对象，此处是一个列表。Python3中map返回一个map对象，我们需要人工转为list，得到的结果就是[‘a’,’b’,’c’,’d’]
例子：
a = [1,2,3,4]
b = [2,3,4,5]
a_1 = list(map(lambda x,y:x+y,a,b))
上边这个例子是为了说明,lambda表达式参数可以是多个。返回结果是[3,5,7,9]
例子：
a = [1,2,3,4,5,6,7]
a_1 = filter(lambda x:x<4,a)
如上例子，定义lambda表达式，筛选a列表中小于4的元素，结果为[1,2,3]。filter函数直接返回一个列表，无需再进行转换，第三个是初始值，我们没给初始值，那么开始操作的两个元素就是序列的前两个。否则将使用我们给出的初始值和序列第一个元素操作，然后结果再与第三个元素操作，以此类推。上个例子结果是28

例子：
from functools import reduce #python3需要导入此模块
a = [1,2,3,4,5,6,7]
a_1 = reduce(lambda x,y:x+y,a)
reduce中使用的lambda表达式需要两个参数，reduce函数共三个参数，
第一个是就是lambda表达式，第二个是要累计的序列，第三个是初始值，
我们没给初始值，那么开始操作的两个元素就是序列的前两个。否则将使
用我们给出的初始值和序列第一个元素操作，然后结果再与第三个元素操
作，以此类推。上个例子结果是28

3、字典多条件排序

例子：
dict = {'a':1,'b':2,'c':3,'d':4,'e':3,'f':1,'g':7}
sorted_dict_asc = sorted(dict.items(),key=lambda item:item[0])
sorted_dict_dsc = sorted(dict.items(),key=lambda item:item[0],reverse=True)

输出（第一个升序，第二个降序）：
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 3), ('f', 1), ('g', 7)]
[('g', 7), ('f', 1), ('e', 3), ('d', 4), ('c', 3), ('b', 2), ('a', 1)]]

13、pass的作用
　　pass是空语句占位符，是为了保持程序结构的完整性。

14、*arg和**kwarg作用
定义函数时，使用*arg和**kwarg
*arg和**kwarg 可以帮助我们处理上面这种情况，允许我们在调用函数的时候传入多个实参
def exmaple2(required_arg, *arg, **kwarg):
if arg:
      print "arg: ", arg

if kwarg:
      print "kwarg: ", kwarg

exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")
>> arg:  (1, 2, 3)
>> kwarg:  {'keyword2': 'foo', 'keyword1': 'bar'}
从上面的例子可以看到，当我传入了更多实参的时候
*arg会把多出来的位置参数转化为tuple
**kwarg会把关键字参数转化为dict

15、is和==的区别
Python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。
==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等
is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同。
　　　　只有数值型和字符串型的情况下，a is b才为True，当a和b是tuple，list，dict或set型时，a is b为False。

16、简述Python的深浅拷贝以及应用场景
深浅拷贝用法来自copy模块。

导入模块：import copy

浅拷贝：copy.copy

深拷贝：copy.deepcopy

　　对于数字和字符串而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

　　字面理解：浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等.

　　字典（列表）的深浅拷贝

　　　　赋值：

import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n2 = n1
---------------------

上海中心

史上最全python面试题详解（一）上【黑马python培训】

相关阅读