Python笔试面试题目及答案

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')