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
选择了IT,必定终身学习