1、文件操作时：xreadlines和readlines的区别？
readlines返回一个list，xreadlines方法返回一个生成器
2、列举布尔值为False的常见值？
0, [] , () , {} , '' , False , None
3、字符串、列表、元组、字典每个常用的5个方法？
字符串：repleace,strip,split,reverse,upper,lower,join.....
列表：append,pop,insert,remove,sort,count,index.....
元组：index,count,__len__(),__dir__()
字典：get,keys,values,pop,popitems,clear,update,items.....
4、lambda表达式格式以及应用场景？
表达式格式：lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。冒号前是参数，冒号后是返回值。例如：lambda x : 2x
应用场景：经常与一些内置函数相结合使用，比如说map(),filter(),sorted(),reduce()等
5、pass的作用？
1、空语句 do nothing
2、保证格式完整
3、保证语义完整
6、 arg和 *kwarg作用？
万能参数，解决了函数参数不固定的问题
*arg：会把位置参数转化为tuple
**kwarg：会把关键字参数转化为dict
7、is和==的区别？
is:判断内存地址是否相等
==：判断数值是否相等
8、简述Python的深浅拷贝以及应用场景？
copy()：浅copy，浅拷贝指仅仅拷贝数据集合的第一层数据
deepcopy():深copy,深拷贝指拷贝数据集合的所有层
9、Python垃圾回收机制？
python采用的是引用计数机制为主，标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略
计数机制
Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”
解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。
标记-清除：
标记-清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象
缺点：该机制所带来的额外操作和需要回收的内存块成正比。
隔代回收
原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，
垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，
就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，
如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。
10、python的可变类型和不可变类型？
不可变类型（数字、字符串、元组、不可变集合）
可变类型（列表、字典、可变集合）
11、求结果：
v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)
v['k1'] = 777
print(v)
答案：{'k1':[666],'k2':[666]}
{'k1':777,'k2':[666]}
解析：formkeys()默认参数为可变数据类型时有坑
12、求结果：
def num():
return [lambda x: i*x for i in range(4)]
print([m(2) for m in num()])
答案：[6, 6, 6, 6]
解析： 问题的本质在与python中的属性查找规则，LEGB（local，enclousing，global，bulitin），
在上面的例子中，i就是在闭包作用域（enclousing），而Python的闭包是 迟绑定 ，
这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的
所以：[lambda x: i*x for i in range(4)]打印出来是含有四个内存地址的列表，每个内存地址中的i
在在本内存中都没有被定义，而是通过闭包作用域中的i值，当for循环执行结束后，i的值等于3，所以
再执行[m(2) for m in num()]时，每个内存地址中的i值等于3，当x等于2时，打印出来的结果都是6，
从而得到结果[6, 6, 6, 6]。
13、列举常见的内置函数？
map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,str,list,tuple,dict,range,next,hash,help,id.....
14、filter、map、reduce的作用？
filter(function，iterable)过滤函数
map(function，iterable)循环函数
reduce(function, iterable)累积函数
15、一行代码实现9*9乘法表。
lis = ['%s*%s=%s'%(i,j,i*j) for i in range(1,10) for j in range(i,10)]
16、如何安装第三方模块？以及用过哪些第三方模块？
pip3 imstall 模块名
django，Matplotlib，Tornado，PyGame
17、至少列举8个常用模块都有那些？
os,sys,time,random,re,hashlib,logging,json,pickle....
18、re的match和search区别？
match:从字符串的开头位置匹配，必须以此为开头
search:从开头开始查，找到符合的就返回结果
19、什么是正则的贪婪匹配？
正则表达式一般趋向于最大长度匹配
20、求结果：
a. [ i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1]
b. ( i % 2 for i in range(10) )===>返回一个生成器的内存地址
21、求结果：
a. 1 or 2 =========>1
b. 1 and 2 ========>2
c. 1 < (2==2)======>false
d. 1 < 2 == 2======>ture
22、def func(a,b=[]) 这种写法有什么坑？
def func(a,b=[]):
b.append(a)
print(b)
函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，
第二次执行还是用第一次执行的时候实例化的地址存储，以后每次实例化都是
23、如何实现 "1,2,3" 变成 ['1','2','3'] ?
a = "1,2,3"
li = a.split(',')
43、如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
li = ['1','2','3']
lis = list(map(lambda x:int(x) li))
24、比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
a = [1,2,3]正常的列表
b = [(1),(2),(3)] 虽然列表的每个元素加上了括号，但是当括号内只有一个元素并且没有逗号时，其数据类型是元素本身的数据类型
b = [(1,),(2,),(3,)]列表中的元素类型都是元组类型
23、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
li = [x*x for x in range(1,11)]
24、一行代码实现删除列表中重复的值 ?
li = [1, 1, 1, 23, 3, 4, 4]
new_li = list(set(li))
new_li.sort(key=li.index)
25、如何在函数中设置一个全局变量 ?
使用python的内置语法 globals 全局变量
26、logging模块的作用？以及应用场景？
logging模块的作用：
1、程序调试
2、了解软件程序运行情况，是否正常
3、软件程序运行故障分析与问题定位
应用场景：网站的运维工作，程序实时监控
27、请用代码简答实现stack 。
def Stack(object):
def __init__(self):
self.stack = []
def push(self,value):
# 进栈
self.stack.append(value)
def pop(self):
# 出栈
if self.stack:
self.stack.pop()
else:
raise LookupError('stack is empty!')
def is_empty(self):
# 查看stack是否为空
reture bool(self.stack)
def top(self):
# 取出stack中最新的值
return self.stack[-1]
28、常用字符串格式化哪几种？
1、%s %d
2、format格式化输出
3、print(f'内容{变量名}')
29、简述 生成器、迭代器、可迭代对象 以及应用场景？
生成器：在 Python 中，一边循环一边计算的机制，称为 生成器（generator），
通过next()取值，两种表现形式1、将列表生成式的[]改为()2、含有yield关键字的函数
应用场景：优化代码，节省内存
迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法
可迭代对象：只要实现了__iter__方法的对象就是可迭代对象
30、用Python实现一个二分查找的函数。
lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]
def two_find(x, lis, start=0, end=None):
if end == None:end = len(lis) - 1
num = (end - start) // 2 + start
if end > start:
if lis[num] > x:
return two_find(x, lis, start=start, end=num)
elif lis[num] < x:
return two_find(x, lis, start=num + 1, end=end)
elif lis[num] == x:
return num
elif lis[end] == x:return end
else:return None
print(two_find(17, lis))
31、谈谈你对闭包的理解？
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。
但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
32、os和sys模块的作用？
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
33、如何生成一个随机数？
import random
def rdm(n):
lis = []
for i in range(n):
n = random.randint(1,9)
lis.append(str(n))
s = ''.join(lis)
return int(s)
34、如何使用python删除一个文件？
import os
os.remove(r'path')
35、谈谈你对面向对象的理解？
面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，
不存在的也可以创造出来。对象是特征和技能的结合，其中特征和技能分别对应对象的数据属性和方法属性。
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，
面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。
36、Python面向对象中的继承有什么特点？
1：在继承中基类的构造(__init__()方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。
区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
(先在本类中查找调用的方法，找不到才去基类中找)。
37、面向对象深度优先和广度优先是什么？
Python的类可以继承多个类，那么其寻找类方法的方式有两种：
当类是经典类时(主要在python2版本中的没有主动继承object的类)，多继承情况下，会按照深度优先方式查找
当类是新式类时(python3版本中的所有类和python2中主动继承object的类)，多继承情况下，会按照广度优先方式查找
简单点说就是：经典类是纵向查找，新式类是横向查找
38、面向对象中super的作用？
1、super在面向对象继承类中代指父类，书写方法super(类名,self).属性或者方法或super().属性或者方法
2、super方法可以增加类之间调用的灵活性，当父类名发生变化时不必修改
3、super方法在类的多继承时可以简化代码，避免代码冗余
4、super机制里可以保证公共父类仅被执行一次，执行的顺序遵循MRO，广度优先查询方法
39、是否使用过functools中的函数？其作用是什么？
functools用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是
可以被当做函数调用的对象就是这个模块的目标。
40、列举面向对象中带双下划线的特殊方法，如： new 、 init
__new__：构造方法，创建一个对象，实例化时第一个被执行，返回一个创建好的对象及__init__(self)的self，
只有继承了object的类才会有这个方法
__init__：初始化方法，__init__在__new__的基础上完成一些其它初始化的动作，__init__没有返回值
41、如何判断是函数还是方法？
函数和方法都封装了一些独立的功能，如果在类中定义的函数那就是方法(对象或者类名点方法名调用)，
否则就是函数(函数名()直接调用)
42、静态方法和类方法区别？
静态方法：是既不是用类中的属性又不使用对象中的属性，由类或者对象调用的方法，依赖python装饰器@staticmethod来实现
类方法：只使用类中的静态变量，一般都是由类调用，依赖python装饰器@classmethod来实现
43、列举面向对象中的特殊成员以及应用场景？
__call__：对象的构造方法，对象加上()，可以触发这个类的__call__方法。
__len__：内置函数的len函数是依赖类中的__len__方法
__eq__：判断值是否相等的时候依赖__eq__方法
__hash__:判断hash值是否相等的时候依赖__hash__方法(拓展：set的去重机制其实就是根据__hash__和__eq__方法实现的)
__str__：和str() print() %s 都是息息相关的，返回值一定是字符串类型
__repr__：和 repr() %r都是息息相关的，在没有__str__方法时，__repr__可以完全取代__str__。
__del__ 析构方法，对应着一个对象的删除之前执行的内容
44、1、2、3、4、5 能组成多少个互不相同且无重复的三位数
count = 0
for i in range(1,6):
for j in range(1,6):
for k in range(1,6):
if (i != j) and (i != k) and (j != k):
count += 1
if count % 6:
print(f'{i}{j}{k}', end='|')
else:
print(f'{i}{j}{k}')
print(count)
45、什么是反射？以及应用场景？
定义：通过用字符串数据类型的变量名来访问这个变量的值，在python面向对象中的反射,通过字符串的形式操作对象相关的属性或方法.
应用场景：用于处理通过用户输入，文件读取，或者网络传输所得到的字符串形式的指令来完成对应的操作
46、metaclass作用？以及应用场景？
metaclass，直译为元类，简单的解释就是：当我们定义了类以后，就可以根据这个类创建出实例，
所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据metaclass创建出类，
所以：先定义metaclass，然后创建类。换句话说，你可以把类看成是metaclass创建出来的“实例”
47、用尽量多的方法实现单例模式。
1、基于__new__()方法
class Person:
def __new__(cls, *args, **kwargs):
if not hasattr(cls,cls._instance):
# cls._instance = object.__new__(cls)
cls._instance = super().__new__(cls)
return cls._instance
2、基于模块导入方式，现在一个py文件中写好一个类，实例化一个对象。以后用这个类直接导入这个模块就是单例模式。
3、基于装饰器方法实现
def singleton(cls, *args, **kwargs):
instance_dic = {}
def inner(*args, **kwargs):
if cls not in instance_dic:
instance_dic['cls'] = cls(*args, **kwargs)
return instance_dic['cls']
return inner
@singleton
class Person:
pass
48、装饰器的写法以及应用场景。
装饰器的写法：
def wrapper(func):
def inner(*args,**kwargs):
'被装饰之前的操作'
ret = func(*args,**kwargs)
'被装饰之后的操作'
return ret
return inner
装饰器的应用场景：
比如注册登录、插入日志，性能测试，事务处理，缓存等等场景
49、异常处理写法以及如何主动跑出异常（应用场景）
异常处理的常规写法：
try:
执行的主体函数
except Exception as e:
print(str(e))
主动抛出异常：
raise TypeError('出现了不可思议的异常')#TypeError可以是任意的错误类型
50、什么是面向对象的mro
MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法，
它是基于算法来实现的，不同的算法实现的MRO的顺序不同
51、isinstance作用以及应用场景？
isinstance作用是来判断一个对象是否是一个已知的类型
52、写代码并实现：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.
You may assume that each input would have exactly one solution, and you may not use the same element twice.
Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1]
代码实现
def func(li,target):
try:
for i in range(0,len(li)):
num = target-li[i]
if num in li:
return [i,li.index(num)]
except:print('li类型为数组类型，内的元素需是整型，target也为整型，请检查')
else:return None
53、json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？
1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null
2、定制支持datetime类型
--------------------------官方文档的memo-----------------------------------------------
>>> import json
>>> class ComplexEncoder(json.JSONEncoder):
... def default(self, obj):
... if isinstance(obj, complex):
... return [obj.real, obj.imag]
... return json.JSONEncoder.default(self, obj)
...
>>> dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
['[', '2.0', ', ', '1.0', ']']
----------------------------------------------------------------------------------------
import json
import datetime
ret = datetime.datetime.now()
class CJsonEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime.date):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return json.JSONEncoder.default(self, obj)
print(json.dumps(ret,cls=CJsonEncoder))
54、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？
在序列化是将json.dumps中的默认参数ensure_ascii改为False就可以保留中文了
json.dumps(obj,ensure_ascii=False)
55、什么是断言？应用场景？
assert 条件,'自定义错误提示(可有可无)' 例：assert 1 == 0,'这是一个低级的错误'
合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。
56、使用代码实现查看列举目录下的所有文件。
方法一：递归处理
import os
url = r'C:UsersMr.WangPycharmProjects\\untitled前段学习'
def check_file(url,li = []):
if os.path.isdir(url):
file_list = os.listdir(url)
for ret in file_list:
base_url = os.path.join(url,ret)
if os.path.isfile(base_url):
li.append(ret)
else: check_file(base_url)
return li
else:return os.path.basename(url)
方法二：堆栈的思想处理
import os
url = r'C:UsersMr.WangPycharmProjects\\untitledpython基础'
lis = [url]
while lis:
url = lis.pop()
ret_list = os.listdir(url)
for name in ret_list:
abs_path = os.path.join(url,name)
if os.path.isdir(abs_path):
lis.append(abs_path)
else:print(name)
57、简述 yield和yield from关键字。
yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候，
函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，当你使用for进行迭代的时候，
函数中的代码才会执行
yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，
这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。
有了这个结构，协程可以通过以前不可能的方式委托职责。
更多解析详见：http://blog.gusibi.com/post/python-coroutine-yield-from/
58、代码实现六位随机验证码
import random
s = ''
for i in range(6):
num = random.randint(0,9)
alpha1 = chr(random.randint(65,90))
alpha2 = chr(random.randint(97,122))
ret = random.choice([num,alpha1,alpha2])
s += str(ret)
print(s)
59、代码实现随机发红包功能
import random
def red_packge(money,num):
li = random.sample(range(1,money*100),num-1)
li.extend([0,money*100])
li.sort()
return [(li[index+1]-li[index])/100 for index in range(num)]
ret = red_packge(100,10)
print(ret)
--------------------------生成器版-------------------------------------------
import random
def red_packge(money,num):
li = random.sample(range(1,money*100),num-1)
li.extend([0,money*100])
li.sort()
for index in range(num):
yield (li[index+1]-li[index])/100
ret = red_packge(100,10)
print(ret)
60、请尽可能列举python列表的成员方法，并给出列表操作的答案：
（1） a=[1, 2, 3, 4, 5], a[::2]=？ a[-2:]=？
a[::2]=[1,3,5],
a[-2:] = [4,5]
（2）一行代码实现对列表a中的偶数位置的元素进行加3后求和？
sum([i+3 for i in a[::2]])
（3）将列表a的元素顺序打乱，再对a进行排序得到列表b，然后把a和b按元素顺序构造一个字典d。
import random
random.shuffle(a)
b=a.sort()
d={}
for i in range(len(a)):d[a[i]] = b[i]
下面是小编整理的全套Python学习教程，入门——进阶——精通各个阶段都有，希望大家都能在学习的过程中收获更多的实用知识！
重要的事情说三遍！！转发+转发+转发！无套路，进阶资料+视频教程免费送！
记得私信小姐姐哟！！
私信方式：点击小姐姐头像，再点私信，编辑“资料”即可马上获得！
| 留言与评论（共有 0 条评论） |
