python基础面试集锦(51-100)

目录

• 51、把aaabbbcccdd这种形式的字符串压缩成a3b3c3d2的形式？
• 52、给你一个字符串'abc'，打印出该字符串的所有排列组合？
• 53、执行以下代码后,x的值为？
• 54、对于一个非空字符串,判断其是否可以有一个子字符串重复多次组成,字符串 只包含小写字母且长度不超过 10000
• 55、从0-99这100个数中随机取出10个不重复的值？
• 56、介绍一下try except的用法和作用？
• 57、在python中如何抛出，捕获，处理异常？
• 58、enumerate的作用是什么？
• 59、python递归最大深度？
• 60、列举常见的内置函数？
• 61、filter、map、reduce的作用？
• 62、一行代码实现9x9乘法表？
• 63、什么是闭包？
• 64、用装饰器，限制函数被调用的频率，如1秒一次
• 65、请实现一个装饰器，通过 一次调用时函数重复执行5次
• 66、一行代码输出1-100偶数列表。（列表推导式，filter）
• 67、解释生成器与函数的不同，并实现和简单使用generator
• 68、写出打印结果？
• 69、简述yield和yieldfrom关键字
• 70、以下代码输出的结果？
• 71、以下代码输出结果？
• 72、从一个列表中剔除重复的，然后求和
• 73、map(str,[1,2,3])输出是什么？
• 74、请简述标准库中functools.wraps的作用
• 75、请把以下函数转化成python lambda匿名函数
• 76、下面程序输出结果？
• 77、谈谈你对闭包函数的理解？
• 78、python函数调用的时候参数的传递方式是值传递还是引用传递？
• 79、对缺省参数的理解？
• 80、为什么函数的名字可以当作参数使用？
• 81、python中pass语句的作用是什么？
• 82、map函数和reduce函数？
• 83、递归函数停止的条件？
• 84、回调函数是如何通信的？
• 85、python中主要的内置数据类型？
• 86、dir方法输出内建方法
• 87、反射hasattr(objext,name)？
• 88、反射getattr(object,name[,default])?
• 89、反射setattr(object,name,values)?
• 90、反射delattr(object,name)?
• 91、什么是lambda函数？有什么好处？
• 92、写一个匿名函数求两数和？
• 93、def(a,b=[])这种写法有什么陷阱？
• 94、如何判断一个值是函数还是方法？

51、把aaabbbcccdd这种形式的字符串压缩成a3b3c3d2的形式？

b={}
c=""
a="aaabbbcccdd"
for i in a:
    b[i]=b.get(i,0)+1
print(b)  # {'a': 3, 'b': 3, 'c': 3, 'd': 2}
for i,t in b.items():
    c+=str(i)
    c+=str(t)
print(c)
# a3b3c3d2

52、给你一个字符串'abc'，打印出该字符串的所有排列组合？

def perm(s=''):
    if len(s) <= 1:
        return [s]
    sl = []
    for i in range(len(s)):
        for j in perm(s[0:i] + s[i + 1:]):
            sl.append(s[i] + j)
    return sl

def main():
    perm_nums = perm('abc')
    no_repeat_nums = list(set(perm_nums))  # 去重
    print('perm_nums', len(perm_nums), perm_nums)
    print('no_repeat_nums', len(no_repeat_nums), no_repeat_nums)

if __name__ == '__main__':
    main()

#  perm_nums 6 ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
#  no_repeat_nums 6 ['acb', 'bca', 'cab', 'cba', 'bac', 'abc']

53、执行以下代码后,x的值为？

x = 10
x += x
x -= x - x
print(x)

"""
20
"""

54、对于一个非空字符串,判断其是否可以有一个子字符串重复多次组成,字符串 只包含小写字母且长度不超过 10000

示例 1:

\1. 输入"abab"
\2. 输出True
\3. 样例解释: 输入可由"ab"重复两次组成

示例 2:

\1. 输入"abcabcabc"
\2. 输出True
\3. 样例解释: 输入可由"abc"重复三次组成

示例 3:
\1. 输入"aba"

\2. 输出False

class Solution(object):
    def repeatedSubstringPattern(self, s):
        """
        :type s: str
        :rtype: bool
        """
        n = len(s)
        for i in range(1, n // 2 + 1):
            if n % i == 0:
                a = s[:i]
                j = i
                while j < n and s[j:j + i] == a:
                    j += i
                if j == n: return True

        return False

a = Solution()
print(a.repeatedSubstringPattern('abab'))  # True
print(a.repeatedSubstringPattern('ababc'))  # False

55、从0-99这100个数中随机取出10个不重复的值？

import random

list1 = []  # 0-99的容器
list2 = []  # 从list1中选出10个不同的数
for i in range(0,100):
    list1.append(i)

i = 0
while i<10:
    i+=1
    a = random.choice(list1)
    list1.remove(a)
    list2.append(a)

print(list2)  # [19, 14, 40, 38, 42, 87, 28, 11, 71, 79]

56、介绍一下try except的用法和作用？

Python的except用来捕获所有异常， 因为Python里面的每次错误都会抛出 一个异常，所以每个程序的错误都被当作一个运行时错误。

try:
    pass
except BaseException as e:

    print(e)

finally:

    pass

57、在python中如何抛出，捕获，处理异常？

raise Exception 触发抛出异常
用try和except语句来捕获异常
处理异常的方法有：
try ... except...else语句
finally子句，
with语句

58、enumerate的作用是什么？

# 枚举
'''
enumerate函数是将一个可迭代对象中元素，按元素顺序每个增加一个索引值，将其组成一个索引序列，利用它可以同时获得索引和值，这样做的目的是为了将一个可迭代对象中元素组成一个“索引,值”对便于后续操作。
'''
list1 = [1,2,3,4]
for index,j in enumerate(list1):
    print(index,j)
'''
0 1
1 2
2 3
3 4
'''

59、python递归最大深度？

'''
    最大数为998或1000
'''

import sys
print(sys.getrecursionlimit())  # 1000  # 不是很精确

60、列举常见的内置函数？

'''
数学类型
abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

类型转换
int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符
为相应的数字。 ord('A') >>> 65

相关操作
eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']
'''

61、filter、map、reduce的作用？

filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。
filter(lambda x: x>3, [1,2,3,4,5,6])
>>> <filter object at 0x0000000003813828>

map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b,
map(lambda a,b: a+b, [1,2,3,4], [5,6,7])
>>> [6,8,10]

reduce(): 函数会对参数序列中元素进行累积。
reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
>>> 15

62、一行代码实现9x9乘法表？

print('\n'.join(['\t'.join([f'{j}*{i}={i*j}' for j in range(1,i+1)]) for i in range(1,10)]))

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

63、什么是闭包？

闭包函数（closure function）指的是定义在一个函数内部的函数，被外层函数包裹着，其特点是可以访问到外层函数中的名字，如下inner函数就是一个闭包函数。

def outer():
    num = 1
    def inner():
        print(num) # 内层函数中不存在num 但可以访问到外层的num
    return inner # 基于函数对象的概念我们可以将内层函数返回到外界使用，从而打破函数调用的层级限制，但无论在何处调用，作用域的嵌套关系都是以定义阶段为准的，所以外界得到的不仅仅是一个函数对象（inner），在该函数外还包裹了一层作用域，这使得该函数无论在何处调用，都是访问自己外层包裹的作用域中的名字num

func = outer() # func == inner  func指向的是inner的内存地址，但是func本身确实一个全局变量，可以在任意位置调用func，但无论在何处调用func，都需要按照定义阶段作用域的嵌套关系去查找名字

num=1000
func() #输出结果：1

64、用装饰器，限制函数被调用的频率，如1秒一次

# 答案
import time
def time_pay(func):

    def inner(*args, **kwargs):
        for line in range(10):
            print(line + 1)
            time.sleep(1)

        res = func(*args, **kwargs)

        return res

    return inner

@time_pay
def func1():
    print('from func1...')

func1()

65、请实现一个装饰器，通过 一次调用时函数重复执行5次

# 答案
def again_func(func):

    def inner(*args, **kwargs):

        for line in range(5):

            func(*args, **kwargs)

    return inner

@again_func
def func1():
    print('from func1...')

func1()

66、一行代码输出1-100偶数列表。（列表推导式，filter）

# 答案
print([i for i in range(1, 101) if i % 2 == 0])

print(list(filter(lambda x: x % 2 == 0, range(1, 101))))

67、解释生成器与函数的不同，并实现和简单使用generator

# 答案
'''
生成器和函数的主要区别在于函数return avalue，生成器yield  a  value，同事标记或记忆point of the yield 以便在下次调用时从标记点恢复执行，yield使用函数转换成生成器，而生成器反过来有返回迭代器。
'''

68、写出打印结果？

# 例 1
def func(a,b=[]):
    b.append(a)
    print(b)
func(1)
func(1)
func(1)
func(1)

# 例 2
def func(a,b={}):
    b[a] = 'v'
    print(b)

func(1)
func(2)

# 答案:
'''
例1:
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]

例2:
{1: 'v'}
{1: 'v', 2: 'v'}

'''

69、简述yield和yieldfrom关键字

# 答案:
'''
yield:
    当一个函数中出现yield关键字的时候，那么这个函数就是一个生成器。可以用for循环或者next()函数来迭代。

yield from:
    简单地说，yield from  generator 。实际上就是返回另外一个生成器
''

70、以下代码输出的结果？

# 调用上下文如下
collapse = True
processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
print(processFunc("i\tam\ntest\tobject !"))

collapse = False
processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
print(processFunc("i\tam\ntest\tobject !"))
# 以上代码会在控制台输出什么?

# 答案：
'''
i am test object !
i   am
test    object !
'''

71、以下代码输出结果？

a = 1
def fun(a):
    a=2

fun(a)
print(a)

a = []
def fun(a):
    a.append(1)
fun(a)
print(a)

# 答案
1
[1]

72、从一个列表中剔除重复的，然后求和

def func(list1):
    res = []
    sum = 0
    for i in list1:
        if i not in res:
            res.append(i)
            sum += i
    return sum

kk = [1,1,2,2,3,3,4,4,5]

print(func(kk))  # 15

73、map(str,[1,2,3])输出是什么？

print(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))  # <map object at 0x101f59748>

k = [1,2,3]
a = list(map(lambda x:x+1,k))
print(a) # [2, 3, 4]

74、请简述标准库中functools.wraps的作用

装饰器再装上@wraps(func)，更完美。查看注释也是查看的原有函数的注释
语法糖
'''
Python装饰器（decorator）在实现的时候，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。这样有时候会对程序造成一些不便，例如笔者想对flask框架中的一些函数添加自定义的decorator，添加后由于函数名和函数的doc发生了改变，对测试结果有一些影响。

所以，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和docstring。
'''

75、请把以下函数转化成python lambda匿名函数

def add(x,y):
     return x+y

# 答案
print((lambda x, y: x + y)(1,2))

lambda x,y : x+y
解释：左边的相当于函数的形参，右边相当于函数的返回值

76、下面程序输出结果？

d = lambda p:p*2
t = lambda p:p*3

x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)

# 答案
24

77、谈谈你对闭包函数的理解？

闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点:

	1.必须有一个内嵌函数
	2.内嵌函数必须引用外部函数中的变量
	3.外部函数的返回值必须是内嵌函数

78、python函数调用的时候参数的传递方式是值传递还是引用传递？

Python的参数传递有：位置参数、默认参数、可变参数、关键字参数。
函数的传值到底是值传递还是引用传递，要分情况：
不可变参数用值传递：
	像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变
不可变对象：
	可变参数是引用传递的：
	比如像列表，字典这样的对象是通过引用传递、和C语言里面的用指针传递数组很相似，可变对象
能在函数内部改变。

79、对缺省参数的理解？

缺省参数指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时，
所传入的参数会替代默认参数。
*args 是不定长参数，他可以表示输入参数是不确定的，可以是任意多个。
**kwargs 是关键字参数，赋值的时候是以键 = 值的方式，参数是可以任意多对在定义函数的时候
不确定会有多少参数会传入时，就可以使用两个参数

80、为什么函数的名字可以当作参数使用？

python中一切皆对象，函数名是函数再内存中的空间，也是一个对象

81、python中pass语句的作用是什么？

在编写代码时致谢框架思路，具体实现还未编写就可以用pass占位，使程序不会报错，不会进行任何的操作。
大白话：框架快速布局

82、map函数和reduce函数？

①从参数方面来讲：
map()包含两个参数，第一个参数是一个函数，第二个是序列（列表 或元组）。其中，函数（即 map
的第一个参数位置的函数）可以接收一个或多个参数。
reduce()第一个参数是函数，第二个是序列（列表或元组）。但是，其函数必须接收两个参数。
②从对传进去的数值作用来讲：
map()是将传入的函数依次作用到序列的每个元素，每个元素都是独自被函数“作用”一次 。
reduce()是将传人的函数作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用
（累积计算）。

83、递归函数停止的条件？

递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择
是继续调用自身，还是 return;返回终止递归。
终止的条件：
1.判断递归的次数是否达到某一限定值
2.判断运算的结果是否达到某个范围等，根据设计的目的来选择

84、回调函数是如何通信的？

回调函数是把函数的地址作为参数传递给另一个函数，将整个函数当作一个对象，赋值给调用的函
数。

85、python中主要的内置数据类型？

内建类型：布尔类型、数字、字符串、列表、元组、字典、集合；

86、dir方法输出内建方法

a = []
print(dir(a))

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

87、反射hasattr(objext,name)？

判断一个对象里面是否有name属性或者name方法，返回bool值，有name属性方法返回true,否则返回false

class function_demo(object):
    name = 'demo'
    def run(self):
        return "hello function"
functiondemo = function_demo()
res = hasattr(functiondemo, 'name')  #判断对象是否有name 属性，True
res = hasattr(functiondemo, "run") #判断对象是否有run方法，True
res = hasattr(functiondemo, "age") #判断对象是否有age属性，Falsw
print(res)

88、反射getattr(object,name[,default])?

获取对象的属性或者方法，如果存在打印出来，不存在打印默认值。
注意：如果返回的是对象的方法，则打印的是：方法的内存地址，如果需要运行该方法，在后面加括号执行。

class function_demo(object):
    name = 'demo'
    def run(self):
        return "hello function"
functiondemo = function_demo()
getattr(functiondemo, 'name') #获取name属性，存在就打印出来--- demo
getattr(functiondemo, "run") #获取run方法，存在打印出 方法的内存地址---<bound method function_demo.run of <__main__.function_demo object at 0x10244f320>>
getattr(functiondemo, "age") #获取不存在的属性，报错如下：AttributeError: 'function_demo' object has no attribute 'age'

getattr(functiondemo, "age", 18)  #获取不存在的属性，返回一个默认值

89、反射setattr(object,name,values)?

给对象的属性赋值，若属性不存在，则先创建再赋值

class function_demo(object):
    name = 'demo'
    def run(self):
        return "hello function"
functiondemo = function_demo()
res = hasattr(functiondemo, 'age')  # 判断age属性是否存在，False
print(res) # False
setattr(functiondemo, 'age', 18 )  #对age属性进行赋值，无返回值
res1 = hasattr(functiondemo, 'age') #再次判断属性是否存在，True
print(res1)  # True

90、反射delattr(object,name)?

删除对象的属性，若属性不存在，则报错。若存在则删除
class function_demo():
    name = 'demo'
    def run(self):
        return "hello function"

jeff = function_demo()
setattr(jeff,'age',18)  #  添加age属性
print(hasattr(jeff,'age'))  # True，age属性存在
delattr(jeff,'age')  # 删除age属性
print(hasattr(jeff,'age'))  # False，age属性已删除

91、什么是lambda函数？有什么好处？

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数
1、lambda 函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，
连名字都很随意的情况下；
2、匿名函数，一般用来给 filter， map 这样的函数式编程服务;
3、作为回调函数，传递给某些应用，比如消息处理

92、写一个匿名函数求两数和？

"""
lambda 函数是匿名函数；使用 lambda 函数能创建小型匿名函数。这种函数得名于省略了用 def
声明函数的标准步骤；
"""

# 答案
f = lambda x，y:x+y
print(f(2017，2018))

93、def(a,b=[])这种写法有什么陷阱？

# 答案
'''
函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第二次执行还是用第一次执行的时候实例化的地址存储，所以三次执行的结果就是 [1, 1, 1] ，想每次执行只输出[1] ，默认参数应该设置为None。
'''

94、如何判断一个值是函数还是方法？

from types import MethodType,FunctionType

print(isinstance('1', FunctionType))  # False
print(isinstance(lambda x:x, FunctionType))  # True