Python笔试面试题目及答案

时间:2021-08-12 08:12:54

1.is 和==的区别?

is:比较的是两个对象的id值是否相等,也就是比较俩对象是否为同一个实例对象。是否指向同一个内存地址

== : 比较的两个对象的内容/值是否相等,默认会调用对象的eq()方法

2.python中内置的数据结构有几种?

4种
列表 字典 字符串 集合 元祖

3.Python中变量的作用域?(变量查找顺序)

函数作用域的LEGB顺序

1.什么是LEGB?

L: local 函数内部作用域

E: enclosing 函数内部与内嵌函数之间

G: global 全局作用域

B: build-in 内置作用

python在函数里面的查找分为4种,称之为LEGB,也正是按照这是顺序来查找的

4.python新式类和经典类的区别

在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式类”,都会获得所有“新式类”的特性;
反之,不由任意内置类型派生出的类,则称之为“经典类”。
“新式类”和“经典类”的区分在Python 3之后就已经不存在,在Python 3.x之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承object类型),即所有的类都是“新式类”。

5.super函数的具体用法和场景

https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html

6.一行代码实现1-100之和

print(sum(range(1,101)))

7.用一行python代码写出实现四个数之和

rom functools import reduce
#使用sum内置函数求和
print(sum([1,2,3,10248]))
#使用reduce函数
print(reduce(lambda x,y : x + y, [1,2,3,10248])) '''
reduce() 函数会对参数序列中元素进行累积。 函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:
用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,
得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
'''

8.一行代码生成指定列表

'''
用一行代码生成[1,4,9,16,25,36,49,64,81,100]
'''
print([i * i for i in range(1,11)])
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

9.全字母短语判断

'''
全字母短句 PANGRAM 是包含所有英文字母的句子,
比如:A QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
定义并实现一个方法 get_missing_letter, 传入一个字符串采纳数,
返回参数字符串变成一个 PANGRAM 中所缺失的字符。应该忽略传入字符串参数中的大小写,
返回应该都是小写字符并按字母顺序排序(请忽略所有非 ACSII 字符)
''' def get_missing_letter(a):
s1 = set('abcdefghijklmnopqrstuvwxyz')
s2 = set(a)
ret = ''.join(sorted(s1-s2))
return ret print(get_missing_letter('Lions, and tigers, and bears, oh my'))

10.列表切片下标超限

list = ['a','b','c','d','e']
print(list[10:]) #[]
print(list[10]) #IndexError: list index out of range '''
代码将输出[],不会产生IndexError错误,
就像所期望的那样,尝试用超出成员的个数的index来获取某个列表的成员。
例如,尝试获取list[10]和之后的成员,会导致IndexError。
然而,尝试获取列表的切片,开始的index超过了成员个数不会产生IndexError,而是仅仅返回一个空列表。
这成为特别让人恶心的疑难杂症,因为运行的时候没有错误产生,导致Bug很难被追踪到。
'''

11.列表合并

'''
两个有序列表,l1,l2,对这两个列表进行合并不可使用extend
''' def loop_merge_sort(l1, l2):
tem = []
while len(l1) > 0 and len(l2) > 0:
if l1[0] < l2[0]:
tem.append(l1[0])
del l1[0]
else:
tem.append(l2[0])
del l2[0]
return tem l1 = [1,3,5,9,8,2,68,12,35]
l2 = [5,6,8,7,2,65,12,45,36]
listed = loop_merge_sort(l1, l2)
print(listed)

12.请写出一段python代码实现删除list里面的重复元素?


l1 = ['b','c','d','c','a','a']

'''
方法一使用集合去重 set
'''
l2 = list(set(l1)) #set集合元素不重复 可以去重 然后再转化为list
print(l2) #集合set是无序的 会打乱原来list列表顺序 '''
方法二 用list的sort方法 避免打乱list顺序
'''
l1 = ['b','c','d','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index) # 保存顺序和原list一致 今天才发现python的sort有个key参数,我好圡...
#key=l1.index表示按照l1列表中的数值对应的下标进行排序,也就是按照原先的顺序排序
print(l2) '''
方法三 方法二 可以视作一个
'''
l1 = ['b','c','d','c','a','a']
l2 = sorted(set(l1), key=l1.index)
print(l2) '''
sort 和 sorted 主要的区别在于:
list.sort()是对已经存在的列表进行操作,进而可以改变进行操作的列表。
而内建函数sorted返回的是一个新的list,而不是在原来的基础上进行的操作.
''' '''
方法四 将一个列表的数据取出来放到另外一个列表中,之间做判断
'''
l1 = ['b','c','d','c','a','a']
l2 = []
for i in l1:
if not i in l2:
l2.append(i)
print(l2) '''
方法五 使用字典
'''
b = {}
b = b.fromkeys(l1)
# print(b)
c = list(b.keys())
print(c) #Python 字典 fromkeys() 函数用于创建一个新字典,
# 以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。
#seq -- 字典键值列表。
#value -- 可选参数, 设置键序列(seq)的值。不指定默认值none

13.阅读一下代码他们的输出结果是什么?


def multi():
return[lambda x:i*x for i in range(4)]
print([m(3) for m in multi()]) '''
正确答案是[9,9,9,9],而不是[0,3,6,9]
产生的原因是Python的闭包的后期绑定导致的,这意味着在闭包中的变量是在内部函数被调用的时候被查找的,
因为,最后函数被调用的时候,for循环已经完成, i 的值最后是3,
因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]
'''

14.列表生成式生成新的列表

'''
该列表只包含满足以下条件的值,元素为原始列表中偶数切片(下标为偶数并且值也为偶数)
''' alist = [1,2,5,8,10,3,18,6,20]
# num = [0,1,2,3,4,5,6,7,8,9,10]
res = [i for i in alist[::2] if i % 2 == 0]
print(res) '''
这两道题相同
该函数的输入是一个仅包含数字的list,输出一个新的list,其中每一个元素要满足以下条件: 1、该元素是偶数 2、该元素在原list中是在偶数的位置(index是偶数)
'''

15.单例模式的实现方式

'''
单例模式(Singleton Pattern)是一种常用的软件设计模式,
该模式的主要目的是确保某一个类只有一个实例存在。
当你希望在整个系统中,某个类只能出现一个实例时,单例对象就能派上用场。
'''
#python如何实现单例模式?请写出两种实现方式? #方式一 使用装饰器
def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton class foo(object):
pass
foo1 = foo()
foo2 = foo()
print(foo1 is foo2) #方法二 使用基类 New 是真正创建实例对象的方法,所以重写基类的new 方法,以此保证创建对象的时候只生成一个实例
class Singleton2(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton2, cls).__new__(cls, *args, **kwargs)
return cls._instance class foo(Singleton2):
pass foo1 = foo()
foo2 = foo() print (foo1 is foo2) #方法三 类
'''
元类,元类是用于创建类对象的类,类对象创建实例对象时一定要调用call方法,
因此在调用call时候保证始终只创建一个实例即可,type是python的元类
'''
class singleton3(type):
def __call__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(singleton3, cls).__call__(*args, **kwargs)
return cls._instance class foo(object):
__metaclass__ = singleton3 foo1 = foo()
foo2 = foo()
print(foo1 is foo2)

16.将一个整数反转

'''
反转一个整数,例如-123 --> -321
''' class solution(object):
def reverse(self, x):
if -10 < x < 10:
return x
str_x = str(x)
if str_x[0] != "-":
str_x = str_x[::-1]
x = int(str_x)
else:
str_x = str_x[1:][::-1]
x = int(str_x)
x = -x
return x if -2147483648 < x < 2147483648 else 0 if __name__ == '__main__':
s = solution()
reverse_int = s.reverse(-125)
print(reverse_int)

17.将一个字符串反转

print('String'[::-1])

18.python中的可变类型与不可变类型

'''
1,可变类型有list,dict.不可变类型有string,number,tuple. 2,当进行修改操作时,可变类型传递的是内存中的地址,也就是说,直接修改内存中的值,并没有开辟新的内存。 3,不可变类型被改变时,并没有改变原内存地址中的值,而是开辟一块新的内存,将原地址中的值复制过去,对这块新开辟的内存中的值进行操作。
'''

19.字典推导式

d = {'a':24,'g':52,'i':12,'k':33}

dd = {key: value for key, value in d.items()}

print(dd)

'''
快速更换key和value
''' dv = {v:k for k,v in d.items()}
print(dv)

20.统计一段字符串中字符出现的次数


'''
统计一段字符串中字符出现的次数
'''
#方法一
def count_str(str2):
'''
定义一个字符出现次数的函数
:param str2:
:return:
'''
dict_str = {}
for i in str2:
dict_str[i] = dict_str.get(i, 0) + 1
return dict_str dict_str = count_str("AAABBCCAC")
# print(dict_str)
# {'C': 3, 'B': 2, 'A': 4} # str_count_data = ''
for k, v in dict_str.items():
# str_count_data += k + str(v)
print('%s出现的次数是%d' %(k,v))

21.字符串转化为字典

'''
将字符串 "k:1 |k1:2|k2:3|k3:4",处理成字典 {k:1,k1:2,...}
'''
#方法一 :函数
str1 = 'k:1|k1:2|k2:3|k3:4'
def str2dict(str1):
dict1 = {}
for i in str1.split('|'):
key,value = i.split(':')
dict1[key] = int(value)
return dict1 d = str2dict(str1)
print(d.items()) #方法二:字典推导式
d = {k:int(v) for t in str1.split('|') for k,v in (t.split(':'), )}
print(d)

22.字符串转化为整数

'''
字符串 "123" 转换成 123,不使用内置api,例如 int()
''' #方法一 利用str函数
def strtoint(s):
num = 0
for i in s:
for j in range(10):
if i == str(j):
num = num*10 + j
return num # s = "123"
# print(strtoint(s)) #方法二 利用ord函数
'''
它以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值
如:
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
ord('2')
50
'''
def strtoint2(s):
num = 0
for i in s:
num = num * 10 + ord(i) - ord('')
return num # s = "123"
# print(strtoint2(s)) #方法三 利用eval方法
'''
eval() 函数用来执行一个字符串表达式,并返回表达式的值。
'''
'''
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
'''
def strtoint3(s):
num = 0
for i in s:
t = "%s * 1" % i
n = eval(t)
num = num * 10 + n
return num
# s = "123"
# print(strtoint3(s)) #方法四: 结合方法二,使用 reduce,一行解决
from functools import reduce
def strtoint4(s):
return reduce(lambda num,i:num * 10 + ord(i)-ord(''), s, 0 )
s = ""
print(strtoint4(s))

23.对字典按value值进行排序


'''
现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
'''
d = {'a':24, 'h':43, 'c':54, 'k':66}
print(d.items()) # items() 函数以列表返回可遍历的(键, 值) 元组数组。
#[('h', 43), ('k', 66), ('a', 24), ('c', 54)] dd = sorted(d.items(), key=lambda x:x[1])
print(dd) '''
先将字典转换为list,这里的匿名函数里面的 x 表示一个元组,x[1]表示元组里面的第二个元素,
按照第二个元素排序
'''

24.给定一个整数数组和一个目标值,找出数组中和为目标值的两个数


'''
给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用。
示例:给定nums = [2,7,11,15],target=9 因为 nums[0]+nums[1] = 2+7 =9,所以返回[0,1]
''' #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,
# 同时列出数据和数据下标,一般用在 for 循环当中。
class Solution:
def twoSum(self, list1, target):
'''
:param list: List[int]
:param target: int
:return: List[int]
'''
for i, j in enumerate(list1):#返回元素j及下标i(下标从0开始)
k = i + 1 #i的后一个元素开始计算累计出现的次数
if list1[k:].count(target - j) > 0: #count() 方法用于统计某个元素在列表中出现的次数
for n in range(list1[k:].count(target - j)):
b = list1.index(target - j, k)#k的存在可以去重 每次从k开始
print(i ,b)
k = b + 1 solution = Solution()
# list1 = [2,7,11,15]
list1 = [1, 3, 4, 6, -3, 4, 1, 3, 8, 9, 3, 0, -3, 6, 0, 2, 9]
target = 9
nums = solution.twoSum(list1, target)
# print(nums)
# print(list(enumerate(list1)))
# print(list1[0:])
# print(list1.index(3,1)) '''
List.index(obj[,start=0[,stop=len(L)]])
obj -- 查找的对象。
start -- 可选参数,开始索引,默认为0。(可单独指定)
stop -- 可选参数,结束索引,默认为列表的长度。(不能单独指定)
'''

25.给定两个列表,怎么找出他们相同的元素和不同的元素?


'''
给定两个列表,怎么找出他们相同的元素和不同的元素?
''' list1 = [1,2,3]
list2 = [3,4,5] set1 = set(list1)
set2 = set(list2) print(set1 & set2) #相同的
print(set1 ^ set2) #不同的

26.求出列表所有奇数并构造新列表


a = [1,2,3,4,5,6,7,8,9,10]
list1 = [i for i in a if i%2 == 1]
print(list1)

27.找出整数数组中的第二大

def find_second_large_num(num_list):
'''
找出数组中第二大数字
:param num_list:
:return:
'''
#方法一:直接排序 输出倒数第二个
temp_list = sorted(num_list)
print('方法一\nSecond_large_num is :',temp_list[-2]) #方法二:
#设置两个标志位,一个存储最大数,一个存储次大数
#one 存储最大值,two 存储次大值.遍历一次数组即可
# 先判断是否大于 one,若大于将 one 的值给 two 将 num_list[i] 的值给 one,
# 否则比较是否大于two,若大于直接将 num_list[i] 的值给two,否则pass
one = num_list[0]
two = num_list[0]
for i in range(1, len(num_list)):
if num_list[i] > one:
two = one
one = num_list[i]
elif num_list[i] > two:
two = num_list[i]
print('方法二\nSecond_large_num is :', two)
# 方法三
# 用 reduce 与逻辑符号 (and, or)
# 基本思路与方法二一样,但是不需要用 if 进行判断。
from functools import reduce
num = reduce(lambda ot, x: ot[1] < x and (ot[1], x) or ot[0] < x and (x, ot[1]) or ot, num_list, (0,0))[0]
print("方法三\nSecond_large_num is :", num) if __name__== '__main__':
num_list = [34, 11, 23, 56, 78, 0, 9, 12, 3, 7, 5]
find_second_large_num(num_list)

28.按照list中指定的元素排序

'''
请按alist中元素的age由大到小排序
''' alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}] def sort_by_age(list1):
return sorted(alist, key=lambda x:x['age'], reverse=True) print(sort_by_age(alist))

29.产生一个公差为11的等差数列


'''
写一个列表生成式,产生一个公差为11的等差数列
''' print([x*11 for x in range(10)])

30.输入某年某月某日,判断这一天是这一年的第几天?


'''
输入某年某月某日,判断这一天是这一年的第几天?
'''
import datetime y = int(input('请输入4位数字的年份:'))
m = int(input('请输入月份:'))
d = int(input('请输入那一天:')) targetDay = datetime.date(y, m, d)
dayCount = targetDay - datetime.date(targetDay.year - 1,12,31)#减的是上一年最后一天
# print(dayCount) #98 days, 0:00:00
print('%s是%s年的第%s天。'%(targetDay, y, dayCount.days))

31.对列表中的字典排序

'''
给列表中的字典排序:假设有如下list对象,alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}],
将alist中的元素按照age从大到小排序
'''
alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}]
alist_sort = sorted(alist, key=lambda x:x.__getitem__('age'),reverse=True)
print(alist_sort)

32.统计一个文本中单词频次最高的10个单词


#方法一 正则 + 字典
import re file = '6_10.txt'
distone = {}#定义存放结果字典
with open(file) as f :
for line in f:
line = re.sub("\W+", " ", line)#正则
lineone = line.split( )#空格分割
for keyone in lineone:
if not distone.get(keyone):
distone[keyone] = 1
else:
distone[keyone] += 1 num_ten = sorted(distone.items(), key = lambda x:x[1], reverse=True)[:10]
num_ten = [x[0] for x in num_ten]
print(num_ten) #方法二 使用 built-in 的 Counter 里面的 most_common
import re
from collections import Counter with open(file) as f:
alist = list(map(lambda c:c[0], Counter(re.sub('\W+', ' ', f.read()).split( )).most_common(10)))
print(alist)

33.编写函数 实现以下功能:

该函数的输入是一个仅包含数字的list,输出一个新的list,其中每一个元素同时要满足以下条件:
1、该元素是偶数
2、该元素在原list中是在偶数的位置(index是偶数)

def num_list(num):
return [i for i in num if i % 2 == 0 and num.index(i) % 2 == 0] num = [0,1,2,3,4,5,6,7,8,9,10]
result = num_list(num)
print(result)

34.自定义函数,让所有奇数都在偶数前面,而且奇数升序排列,偶数降序排序


'''
给定一个任意长度数组,实现一个函数
让所有奇数都在偶数前面,而且奇数升序排列,偶数降序排序,
如字符串'1982376455',变成'1355798642'
''' '''
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。 isinstance() 与 type() 区别: type() 不会认为子类是一种父类类型,不考虑继承关系。 isinstance() 会认为子类是一种父类类型,考虑继承关系。 如果要判断两个类型是否相同推荐使用 isinstance()。
'''
'''
isinstance(object, classinfo)
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
''' #方法一
def func1(b):
if isinstance(b, str):
b = [int(i) for i in b]
b.sort(reverse=True)#倒序排列
for i in range(len(b)):
if b[i] % 2 > 0:
b.insert(0, b.pop((i)))#insert() 函数用于将指定对象插入列表的指定位置。
#pop() 函数用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。
print(''.join(str(e) for e in b))
'''
将序列中的元素以指定的字符连接生成一个新的字符串。 语法
语法: ‘sep’.join(seq) 参数说明:
sep:分隔符。可以为空
seq:要连接的元素序列、字符串、元组、字典
''' str2 = ''
func1(str2) #方法二
def func2(b):
print(''.join(sorted(b, key=lambda x:int(x) % 2 == 0 and 20 - int(x) or int(x))))
func2(str2)

35.遍历列表时删除元素的正确做法


'''
Python-遍历列表时删除元素的正确做法
'''
#方法一:遍历在新在列表操作,删除时在原来的列表操作
a = [1,2,3,4,5,6,7,8]
# b = id(a)
# c = id(a[:])
'''
b=a与b=a[:]的区别
b=a将两者指向同一个对象
而b=a[:]会创建一个新的与a完全相同的对象,但是与a并不指向同一对象。
在计算机中,不同的对象即不同的内存地址。
可理解为:b=a将创建a与b两个快捷方式并指向同一文件;
而b=a[:]先将a指向的文件复制一份作为副本,然后创建一个指向该副本的快捷方式b。
二者不同表现为当两者指向同一对象时,改变其中任意一个,都会改变对象的值,也就是同时改变a,b的值。 '''
print(id(a))
print(id(a[:]))
#两个不同的地址 19126472 19126920 for i in a[:]:
# print(i)#
if i > 5:
pass
else:
a.remove(i)
print(a)
print('------------')
print(id(a)) #方法二 列表推导式
a = [1,2,3,4,5,6,7,8]
b = [i for i in a if i > 5]
print(b) #方法三 filter
a = [1,2,3,4,5,6,7,8]
b = filter(lambda x: x > 5, a)
print(list(b)) #方法四
'''
倒序删除 因为列表总是‘向前移’,所以可以倒序遍历,即使后面的元素被修改了,还没有被遍历的元素和其坐标还是保持不变的
'''
a = [1,2,3,4,5,6,7,8]
print(id(a))
for i in range(len(a) - 1, -1, -1):
if a[i] > 5:
pass
else:
a.remove(a[i]) print(id(a))
print('-------')
print(a)

36.设计实现遍历目录与子目录,抓取.pyc文件


'''
设计实现遍历目录与子目录,抓取.pyc文件
''' #方法一
import os def get_files(dir, suffix):
res = []
for root, dirs, files in os.walk(dir): #是一个简单易用的文件、目录遍历器 取得该文件夹下的所有文件
for filename in files:
name, suf = os.path.splitext(filename) #splitext 分离文件名与扩展名
if suf == suffix:
res.append(os.path.join(root, filename)) print(res) get_files('D:\Software\Anaconda3\envs','.pyc') #方法二
def pick(obj):
if obj.endswith('.pyc'):
print(obj) def scan_path(ph):
file_list = os.listdir(ph) #os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
for obj in file_list:
if os.path.isfile(obj):
pick(obj)
elif os.path.isdir(obj):
scan_path(obj) if __name__ == '__main__':
# path = input('请输入目录')
scan_path("D:\Software\Anaconda3\envs") #方法三
from glob import iglob
def func(fp, postfix):
for i in iglob("f{fp}/**/*{postfix}", recursive=True):
print(i) if __name__ == '__main__':
postfix = '.pyc'
func('D:\Software\Anaconda3\envs','.pyc')