最后
你要问前端开发难不难，我就得说计算机领域里常说的一句话，这句话就是『难的不会，会的不难』，对于不熟悉某领域技术的人来说，因为不了解所以产生神秘感，神秘感就会让人感觉很难，也就是『难的不会』；当学会这项技术之后，知道什么什么技术能做到什么做不到，只是做起来花多少时间的问题而已，没啥难的，所以就是『会的不难』。
我特地针对初学者整理一套前端学习资料
开源分享：docs.qq.com/doc/DSmRnRG…
"""
*arg 表示传入的是非键值对的数据，即元祖类型
**kwargs 表示传入的是键值对数据，即字典类型
如果你有其他语言基础的话，你应该听说过重载的概念，对Python 为了避免这种繁琐的情况发生，引入了 args 和 kwargs；
args 用来接受非键值对的数据，即元组类型，而 kwargs 则用来接受键值对数据，即字典类型。
“”"
**8. Python2 和 Python3 的 range（100）的区别？**
#8、Python2 和 Python3 的 range（100）的区别？
python2返回的是列表 python3返回的是迭代器，节约资源
**9. 生成一个16位的随机字符串**
#9、生成一个16位的随机字符串 import random import string # string.printable 随机生成字符串，长度是100 res='' for i in range(16): res=res+random.choice(string.printable) print(res) #G)_$U/#h@EhfL;6#
print(''.join((random.choice(string.printable)) for i in range(16))) #I@}Z+Z(CS~5 AZ!+ 【方法2】
**10、一句话解释什么样的语言能够用装饰器?**
#10、一句话解释什么样的语言能够用装饰器?
函数可以作为参数传递
**11、python内建的数据类型**
#11、python内建的数据类型 #整型 int 布尔型 bool 字符串 str 列表 list 元祖 tuple 字典 dict
**12、简述面向对象中new和init区别？**
#12、简述面向对象中new和init区别？ （1）__new__至少要一个参数cls，代表当前类，此参数在实例化由python解释器自动识别 （2）__new__必须要有一个返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意！ 可以return 父类（通过super(当前类名,cls)）.__new__出来的实例，或者直接是object的__new__出来的实例。 （3）__new__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作， __init__不需要返回值 （4）如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例， 如果是其他类的类名，那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数
"""#【下面举例说明】 #__init__和__new__的区别 class Person(object): def __new__(cls,name,age): print('__new__ called') return super(Person,cls).__new__(cls) def __init__(self,name,age): print('__init__ called') self.name=name self.age=age def __str__(self): return 'Person:{}-{}'.format(self.name,self.age) child=Person('psy',18) print(child) """结果显示： new called init called Person:psy-18
表明：
__new__的调用优于__init__方法； __new__方法负责创建一个实例对象，__init__方法负责将该实例对象进行初始化； __new__方法正式创建这个类实例的方法，返回额的对象正式__init__的self参数； __init__用于实例化对象，__new__用于继承，是类别级的方法 #__new__的应用场景 #__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径 class PositiveInt(int): def __new__(cls,value): return super(PositiveInt,cls).new(cls,abs(value)) print(PositiveInt(-55)) #55 class RoundFloat(float): def __new__(cls,value): return super(RoundFloat,cls).new(cls,round(value,2)) print(RoundFloat(3.1415926))
**13、简述 with 方法打开处理文件帮我我们做了什么？**
""" 打开文件在进行读写操作时，可能会出现一些异常状况，如果按照常规的f.open写法，我们需要try,except，finally，做异常判断， 并且文件最终不管遇到什么情况，都要执行finally f.close()关闭文件。 其中利用with方法帮我们实现了finally中的f.close()。 """
**14、列表[1,2,3,4,5]，请使用 map() 函数输出[1,4,9,16,25]，并使用列表推导式提取出大于 10 的数，最终输出 [16,25]？**
#14、列表[1,2,3,4,5]，请使用 map() 函数输出[1,4,9,16,25]，并使用列表推导式提取出大于 10 的数，最终输出 [16,25]？ l1=[1,2,3,4,5] print(list(map(lambda x:x*x,l1))) #[1, 4, 9, 16, 25] print([x for x in list(map(lambda x:x*x,l1)) if x>10]) #[16, 25]
**15、python 中生成随机整数、随机小数、2-6 之间小数方法？**
#15、python 中生成随机整数、随机小数、2-6 之间小数方法？ print(random.randint(1,10)) #随机整数 print(random.random()) #随机小数 print(random.uniform(2,6)) #2-6之间的小数
**16、避免转义给字符串加哪个字母表示原始字符串？**
#16、避免转义给字符串加哪个字母表示原始字符串？ res=b'input\n' #bytes字节符，打印以b开头 print(res) #b'input\n' res=r'input\n' # 非转义原生字符，经处理'\n'变成了''和'n'。也就是\n表示的是两个字符，而不是换行。 print(res) #input\n res=u'input\n' # unicode编码字符，python3默认字符串编码方式。 print(res) #input + 换行
17、 < di v class=“nam”> Python，用正则匹配出标签里面的内容（“Python”），其中 class 的类名是不确定的。
#17、
**18、Python 中断言方法举例？**
#18、Python 中断言方法举例？ age = 10 #assert 0 < age < 10 """ 结果显示： Traceback (most recent call last): File "E:/000文章的代码/27/python面试题.py", line 157, in assert 0 < age < 10 AssertionError """
**19、dict 中 fromkeys 的用法**
#19、dict 中 fromkeys 的用法 keys=('info1','info2') res=dict.fromkeys(keys,['psy',18,'girl']) print(res) #{'info1': ['psy', 18, 'girl'], 'info2': ['psy', 18, 'girl']}
**20、请用正则表达式输出汉字**
import re s="not 404 found 中国 2018 我爱你" r1='[a-zA-Z0-9’!"#$%&'()*+,-./:;<=>?@，。?★、…【】《》？“”‘’！[\]^_`{|}~]+\s?' res=re.sub(r1,'',s) print(res) #中国 我爱你
**21、Python2 和 Python3 区别？列举 5 个**
#21、Python2 和 Python3 区别？列举 5 个 """ （1）去除<>，全部使用!= （2）print都要加() （3）xrange()改为range() （4）内存操作cStringIO改为StringIO （5）加入nonlocal 作用：可以引用外部非全局变量 （6）zip() map() 和filter()都返回迭代器，而不是生成器，更加节约内存 """
**22、列出 Python 中可变数据类型和不可变数据类型，为什么？**
""" 不可变类型：int str tuple 可变类型：list dict set 原理：可变数据类型即公用一个内存空间地址，不可变数据类型即每场一个对象就会产生一个内存地址 """
**23、dict的内部实现？**
""" 在 Python 中，字典是通过哈希表实现的。也就是说，字典是一个数组，而数组的索引是键经过哈希函数处理后得到的。 哈希函数的目的是使键均匀地分布在数组中。由于不同的键可能具有相同的哈希值，即可能出现冲突，高级的哈希函数能够使冲突数目最小化。 """
**24、s = “ajldjlajfdljfddd”，去重并从小到大排序输出"adfjl"？**
s='ajldjlajfdljfddd' res1=sorted(list(set(s))) #['a', 'd', 'f', 'j', 'l'] res=''.join(res1) print(res) #adfjl
**25、用 lambda 函数实现两个数相乘？**
mul=lambda x,y:x*y print(mul(2,5)) #10
**26、字典根据键从小到大排序？**
info = {'name': 'Gage', 'location':'nj', 'sex': 'man'} res_key=sorted(info.items(),key=lambda x:x[0]) #根据键排序 print(res_key) #[('location', 'nj'), ('name', 'Gage'), ('sex', 'man')] res_value=sorted(info.items(),key=lambda x:x[1]) #根据值排序 print(res_value) #[('name', 'Gage'), ('sex', 'man'), ('location', 'nj')]
#若对列表中的字典进行排序 l=[{'name':'psy','age':18},{'name':'xk','age':24},{'name':'pyg','age':55}] #按年龄进行排序 l.sort(key=lambda item:item['age']) print(l) #[{'name': 'psy', 'age': 18}, {'name': 'xk', 'age': 24}, {'name': 'pyg', 'age': 55}]
salaries={'psy':200,'xk':180,'gyp':300,'pyg':250} #将salaries按照薪资的高低进行排序 res=sorted(salaries,key=lambda item:salaries[item],reverse=True) print(res) #['gyp', 'pyg', 'psy', 'xk']
**27、Python 获取当前日期？**
import time import datetime print(datetime.datetime.now()) #2019-04-03 17:06:16.347417 print(time.strftime('%Y-%m-%d %H:%M:%S')) #2019-04-03 17:06:51
**28、简述5条：Python的pep8-代码规范**
不要在行尾加分号, 也不要用分号将两条命令放在同一行
不要使用反斜杠连接行
不要在返回语句或条件语句中使用括号
顶级定义之间空2行, 方法定义之间空1行，顶级定义之间空两行
如果一个类不继承自其它类, 就显式的从object继承
**29、Fibonacci 数列**
def func(n): a,b=0,1 while n: yield b a,b=b,a+b n-=1 print(list(func(10))) #[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
**30、Python 三目运算**
#res=a-b if a>b else b-a #解释：如果a>b成立，返回a-b，否则返回b-a
**31、单例模式 【后面会有文章重点介绍单例模式】**
class Single(): __isstance=None __first_init=False def __new__(cls, *args, **kwargs): if not cls.__isstance: cls.__isstance=object.new(cls) def __init__(self,name): if not self.__first_init: self.name=name Single.__first_init=True
**32、递归**
def digui(n): if n==1: return 1 else: return (n*digui(n-1)) print(digui(4)) #24
**33、统计字符串每个单词出现的次数**
from collections import Counter s3='kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h' print(Counter(s3)) #Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'b': 1, 'g': 1})
**34、正则 re.complie 作用**
#re.complie是将正则表达式编程成一个对象，加快速度，并且可以重复使用 content = 'Hello, I am Jerry, from Chongqing, a montain city, nice to meet you……' regex=re.compile('\w*o\w*') res=regex.findall(content) print(res) #['Hello', 'from', 'Chongqing', 'montain', 'to', 'you']
**35、filter 方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]**
a=[1,2,3,4,5,6,7,8,9,10] res=list(filter(lambda x:x%2,a)) print(res) #[1, 3, 5, 7, 9]
**36、列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]**
a=[1,2,3,4,5,6,7,8,9,10] res=[x for x in a if x%2==1] print(res) #[1, 3, 5, 7, 9]
37、a=（1，）b=(1)，c=(“1”) 分别是什么类型的数据？
a=(1,) print(type(a)) #<class 'tuple'> b=(1) print(type(b)) #<class 'int'> c=("1") print(type(c)) #<class 'str'>
**37、两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9] 【归并排序】
l1=[1,5,7,9]
l2=[2,2,6,8]**
def merge_sort(l1,l2): left_p,right_p=0,0 result=[] while left_p<len(l1) and right_p<len(l2): if l1[left_p]<l2[right_p]: result.append(l1[left_p]) left_p+=1 else: result.append(l2[right_p]) right_p+=1 result+=l1[left_p:] result+=l2[right_p:] return result print(merge_sort(l1,l2))
**38、用 python 删除文件和用 linux 命令删除文件方法**
""" python删除文件： os.remove(文件名) linux命令删除文件： rm 文件名 """
**39、logging 模块的使用？**
#logging是日志模块，爬虫时可能用到 import logging logging.basicConfig(level=logging.INFO,format='%(asctime)s-%(name)s-%(levelname)s-%(message)s') logger=logging.getLogger('psy') #psy我设置的文件名 logger.info('Start log') logger.debug('Do something') logger.warning('Something maybe fail') logger.error('Somthing exists error') logger.critical('Break down')
**40、写一段自定义异常代码**
def func(): try: for i in range(5): if i>2: raise Exception('数字大于2') except Exception as e: print(e) func() #数字大于2
**41、正则表达式匹配中，（.）和（.?）匹配区别？**
#（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配 #（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配 s = "哈哈呵呵" import re res1 = re.findall("(.*)", s) print("贪婪匹配", res1) #贪婪匹配 ['哈哈呵呵'] res2 = re.findall("(.*?)", s) print("非贪婪匹配", res2) #非贪婪匹配 ['哈哈', '呵呵']
**42、[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]**
a=[[1,2],[3,4],[5,6]] new_a=[] for item in a: new_a.extend(item) print(new_a) #[1, 2, 3, 4, 5, 6]
res=[j for i in a for j in i] print(res) #[1, 2, 3, 4, 5, 6]
**43、x=“abc”,y=“def”,z=[“d”,“e”,“f”]，分别求出 x.join(y) 和 x.join(z) 返回的结果**
#join()括号里面的是可迭代对象，x插入可迭代对象中间，形成字符串，结果一致 x="abc" y="def" z=["d","e","f"] print(x.join(y)) #dabceabcf print(x.join(z)) #dabceabcf
**44、举例说明异常模块中 try except else finally 的相关意义**
""" try..except..else没有捕获到异常，执行else语句 try..except..finally不管是否捕获到异常，都执行finally语句 """ #45、python中两个值交换 a,b=1,2 a,b=b,a print(a,b) #2 1
**46、举例说明 zip() 函数用法 zip()函数实质就是整合**
l1=[1,2,3,4] l2=[4,5,6] res=list(zip(l1,l2)) print(res) #[(1, 4), (2, 5), (3, 6)]
**47、a=“张明 98分”，用 re.sub，将 98 替换为 100**
import re a="张明 98分" res=re.sub(r'\d+','100',a) print(res) #张明 100分
**48、a="hello"和b="你好"编码成 bytes 类型**
a=b"hello" b="你好".encode() print(type(a)) #<class 'bytes'> print(type(b)) #<class 'bytes'>
**49、[1,2,3]+[4,5,6]的结果是多少**
print([1,2,3]+[4,5,6]) #[1, 2, 3, 4, 5, 6]
**50、提高 python 运行效率的方法**
（1）使用生成器，因为可以节约大量内存
（2）循环代码优化，避免过多重复代码的执行
（3）核心模块用Cython PyPy等，提高效率
（4）多线程、多进程、协程
（5）多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序的判断次数，提高效率
**51、遇到 bug 如何处理**
（1）细节上的错误，通过print()打印，能执行到print()说明一般上面的代码没有问题，分段检测程序是否有问题，如果是js的话可以alter活console.log
（2）如果涉及一些第三方的框架，会去查找光放文档或者一些技术博客
（3）对于bug的管理与归类总结，一般测试将测试出的bug用teambin等bug管理工具进行记录，然后我们会一条一条进行修改，修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法，然后自己再做一些笔记记录。
（4）导包问题、城市定位多音字造成的显示错误问题
**52、list=[2,3,5,4,9,6]，从小到大排序，不许用 sort，输出[2,3,4,5,6,9]**
#若使用sort l=[2,3,5,4,9,6] print(sorted(l)) #[2, 3, 4, 5, 6, 9] #不使用sorted，自己定义函数 def quicksort(old_list): if len(old_list)<2: return old_list else: temp=old_list[0] lowbeforetemp=[i for i in old_list[1:] if i<=temp] bigbeforetemp=[i for i in old_list[1:] if i>temp] final_list=quicksort(lowbeforetemp)+[temp]+quicksort(bigbeforetemp) return final_list print(quicksort([2,3,5,4,9,6])) #[2, 3, 4, 5, 6, 9]
**53、两个数相除，保留两位小数**
print(round(10/3,2)) #3.33
**54、正则匹配，匹配日期 2018-03-20**
s='Date：2018/03/20' import re res1=re.findall('(\d+)',s) #['2018', '03', '20'] res='-'.join(res1) print(res) #2018-03-20
**55、使用 pop 和 del 分别删除字典中的"name"和"age"字段，dic={“name”:“zs”,“age”:18,“sex”:“girl”}**
dic={"name":"zs","age":18,"sex":"girl"} dic.pop("name") print(dic) #{'sex': 'girl', 'age': 18} del dic["age"] print(dic) #{'sex': 'girl'}
**56、简述多线程、多进程**
进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。
线程是程序执行时的最小单位，它是进程的一个执行流。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非诚昂贵。
【所以各个进程有自己的地址空间，彼此互相不打扰】
线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费比进程要小很多，同时创建一个线程的开销也比进程要小很多。
**57、简述 any() 和 all() 方法**
#连个返回的都是bool值 all如果存在0 None False返回False,否则返回
True;any与之相反 print(all([0,1,2,3])) #False print(all([1,2,3])) #True print(any([0,1,2,3])) #True print(any([0,False,None])) #False
**58、异常分类**
""" IOError 输入输出异常 AttributeError 试图访问一个对象没有的属性 ImportError 无法引入模块或包，基本都是路径的问题 IndentationError 语法错误，代码没有正确的对齐 KeyError 试图访问你字典里不存在的键 SyntaxError Python代码逻辑语法出错，不能执行 NameError 使用一个还未赋予对象的变量 """
**59、Python 中 copy 和 deepcopy 区别 【深拷贝和浅拷贝】**
import copy #copy的使用 l1=[1,2,[3,4]] l2=copy.copy(l1) print(id(l1)==id(l2)) #False 两者id不相同 l1.append(5) l1[2].append(5) print(l1) #[1, 2, [3, 4, 5], 5] print(l2) #[1, 2, [3, 4, 5]] #deepcopy的使用 l1=[1,2,[3,4]] l2=copy.deepcopy(l1) print(id(l1)==id(l2)) #False 两者id不相同 l1.append(5) l1[2].append(5) print(l1) #[1, 2, [3, 4, 5], 5] print(l2) #[1, 2, [3, 4]] """ copy()和deepcopy()是Python语言copy模块中的两个method，copy()其实是与deep copy相对的shallow copy。 对于简单的object,用shallow copy和deep copy没区别。 复杂的Object,如list中套着list的情况,shallow copy中的子list并未从原object真的独立出来，因此如果你改变原object的子list中的一个元素，你的copy就会跟着一起改变。 deep copy则更加符合我们对复制的直觉定义：一旦复制出来了，就应该是独立的了。 """
**60、在python数据处理中的复制方法（下面介绍3种，需要导入numpy库）**
import numpy as np
**方法一：b=a 【此时：b和a实际指向同一个东西，改变a或b，两者一起发生变化】**
a=np.arange(12) b=a b.shape=(3,4) print(a.shape) #(3, 4) print(id(a)==id(b)) #True
**方法二：c=a.view() 【此时：c和a不是指向同一个东西，但是共用一堆值】**
a=np.arange(12)
c=a.view() c.shape=(3,4) print(a.shape) #(12,) print(id(a)==id(c)) #False
**方法三：d=a.copy() 【此时：d和a各自为各自的值，没有一点关系】**
a=np.arange(12) d=a.copy() d[0]=5 print(a) #[ 0 1 2 3 4 5 6 7 8 9 10 11] print(d) #[ 5 1 2 3 4 5 6 7 8 9 10 11] print(id(a)==id(d)) #False
**61、列出几种魔法方法并简要介绍用途**
""" __init__ 对象初始化方法 __new__ 创建对象时执行的方法，单例模式会用到 __str__ 当时用print输出对象时，只要自己定义了__str__(self)方法，则就打印在这个方法中return的数据 【必须要有return】 __del__ 删除对象执行的方法 """
**62、上下文管理器 with…as 的实现**
上下文管理器(context manager)用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 比如为对象分配或者释放内存)。
它的语法形式是with…as…
常用的上下文管理器： with open(‘test.txt’,‘w’)as f:f.write(‘Hello World!’)
open函数既能够当做一个简单的函数使用，又能够作为上下文管理器。这是因为open函数返回了一个文件类型变量。
要实现上下文管理器，必须实现两个方法：一个负责进入语句块的准备操作（**enter** 方法），另一个负责离开语句块的善后操作（**exit** 方法）。
当一个对象被用作上下文管理器时：
**enter** 方法将在进入代码块前被调用。
**exit** 方法则在离开代码块之后被调用(即使在代码块中遇到了异常)。
自己实现的上下文管理方法，
class PypixOpen: def __init__(self, filename, mode): self.filename = filename self.mode = mode def __enter__(self): self.openedFile = open(self.filename, self.mode) return self.openedFile def __exit__(self, *unused): self.openedFile.close() with PypixOpen(filename, mode) as writer: writer.write("Hello World from our new Context Manager!")
**注意：**
（1）我们完全忽视了语句块内部可能出现的问题。
（2）如果语句块内部发生了异常，\_\_exit\_\_方法将被调用，而异常将会被重新抛出(re-raised)。
当处理文件写入操作时，大部分时间你肯定不希望隐藏这些异常，所以这是可以的。
而对于不希望重新抛出的异常，我们可以让\_\_exit\_\_方法简单的返回True来忽略语句块中发生的所有异常(大部分情况下这都不是明智之举)。
（3）上面代码\*unused 指向exc\_type, exc\_value, traceback三个参数，当程序块中出现异常(exception)，这三个参数用于描述异常。
我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是None。
**给出的答案**
class Close(): def __init__(self,obj): self.obj=obj def __enter__(self): return self.obj #返回作为as目标 def __exit__(self, exc_type, exc_val, exc_tb): try: self.obj.close() except AttributeError: print(exc_type)
63、python arg.py 1 2 命令行启动程序并传参，print(sys.argv) 会输出什么数据？
#[arg.py 1 2]
**64、请将[i for i in range(3)]改成生成器**
class iter(): def __init__(self,data): self.data=data self.loop=-1 def __iter__(self): return self def __next__(self): if self.loop>=self.data: raise StopIteration self.loop+=1 return self.loop Iter=iter(range(3)) print(Iter) #<__main__.iter object at 0x000001BA9D92F898> print(Iter.iter()) #<__main__.iter object at 0x0000016888BDF898> print(Iter.data) #range(0, 3) print(Iter.next) #<bound method iter.__next__ of <__main__.iter object at 0x0000016888BDF898>>
""" #列表解析生成列表 [x*x for x in range(3)] 结果：[0,1,4] #生成器表达式 (x*x for x in range(3)) 结果：(0,1,4) #两者之间的转换 list(x*x for x in range(3)) 结果[0,1,4] """
**65、字符串转化大小写？**
s='MyDay' print(s.upper()) #MYDAY print(s.lower()) #myday
**66、请说明 sort 和 sorted 对列表排序的区别**
l=[2,4,1,3,8,6,5] l.sort() print(l) #[1, 2, 3, 4, 5, 6, 8] l=[2,4,1,3,8,6,5] print(sorted(l)) #[1, 2, 3, 4, 5, 6, 8] """
（1）sort()与sorted()的不同在于：sort()是在原位重新排列列表，而sorted()是产生一个新的列表
sorted(L)返回一个排序后的L，不改变原始的L；L.sort()是对原始的L进行操作，调用后原始的L会改变，没有返回值
所以a=a.sort()是错的，a=sorted(a)才对！
（2）sorted()适用于任何可迭代容器，list.sort()仅支持list
（3）基于以上两点，sorted的使用频率比list.sort()更高些
**67、对 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 进行排序，使用 lambda 函数从小到大排序**
#方法一：直接使用list.sort() foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] foo.sort() print(foo) #[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9] #方法二：使用lambda函数 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] res=sorted(foo,key=lambda x:x) print(res) #[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9] 68、对 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 进行排序，将正数从小到大，负数从大到小 foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4] res=sorted(foo,key=lambda x:(x<0,abs(x))) print(res) #[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20] #69、Python 传参数是传值还是传址？
""" Python 中函数参数是引用传递（注意不是值传递）。 对于不可变类型（数值型、字符串、元组），因变量不能修改，所以运算不会影响到变量自身； 而对于可变类型（列表字典）来说，函数体运算可能会更改传入的参数变量。 """
**70、w、w+、r、r+、rb、rb+ 文件打开模式区别**
r 以只读方式打开文件。文件的指针会被放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖，如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件存在，文件指针将会放在文件的结尾。也就是说：新的内容会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针会放在文件的开头。这是默认模式。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是：新的内容会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会时追加模式。
如果该文件不存在，创建新文件进行写入。
rb+ 以二进制格式打开一个文件用于读写。文件指针会放在文件的开头。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+ 以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。
如果该文件不存在，创建新文件进行写入。
**71、int(“1.4”)、int(1.4)的输出结果？**
print(int("1.4")) #报错ValueError: invalid literal for int() with base 10: '1.4' print(int(1.4)) #1
**72、Python 垃圾回收机制？**
“”"
**（1）引用计数**
import sys str1='hello world' print(sys.getrefcount(str1)) #在python解释器下运行，为2 创建一次，调用一次
**（2）分代计数**
Python默认定义了三代对象集合，索引数越大，对象存活时间越长
Python中使用了某些启发式算法（heuristics）来加速垃圾回收。
【例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代（generation）。每个对象都会被分配一个代，而被分配更年轻代的对象是优先被处理的。】
**（3）引用循环**
垃圾回收器会定时寻找这个循环，并将其回收。
举个例子，假设有两个对象o1和o2，而且符合o1.x == o2和o2.x == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。
“”"
**73、Python 字典和 json 字符串相互转化方法 【序列化和反序列化】**
import json dic={"name":"psy","age":18} #序列化 把python的对象编码转换为json格式的字符串 res1=json.dumps(dic) print(res1,type(res1)) #{"age": 18, "name": "psy"} <class 'str'> 【json中一般使用""】 #反序列化 把json格式字符串解码为python数据对象。 res2=json.loads(res1) print(res2,type(res2)) #{'name': 'psy', 'age': 18} <class 'dict'>
**74、Python 正则中 search 和 match 的区别**
""" match() 从第一个字符开始找, 如果第一个字符就不匹配就返回 None, 不继续匹配. 用于判断字符串开头或整个字符串是否匹配,速度快。 search() 会整个字符串查找,直到找到一个匹配。 """ import re str1='superman' str2='hello superman' print(re.match('super',str1)) #<_sre.SRE_Match object; span=(0, 5), match='super'> print(re.match('super',str1).span()) #(0, 5) print(re.match('super',str2)) #None
print(re.search('super',str1)) #<_sre.SRE_Match object; span=(0, 5), match='super'> print(re.search('super',str1).span()) #(0, 5) print(re.search('super',str2)) #<_sre.SRE_Match object; span=(6, 11), match='super'> print(re.search('super',str2).span()) #(6, 11)
**75、Python 中读取 Csv、Excel 文件的方法？**
import pandas as pd #read_csv=pd.read_csv('test1.csv') #read_excel=pd.read_excel('test2.xlsx')
**76、输入日期， 判断这一天是这一年的第几天？**
import datetime def DayOfYear(): year=input('请输入年份：').strip() mon=input('请输入月份：').strip() day=input('请输入日：').strip() data1=datetime.date(year=int(year),month=int(mon),day=int(day)) data2=datetime.date(year=int(year),month=1,day=1) return (data1-data2).days+1 print(DayOfYear()) """运行结果： 请输入年份：2019 请输入月份：4 请输入日：18 108 """
**77、什么是 lambda 函数？有什么好处？**
lambda 函数是一个可以接收任意多个参数（包括可选参数）并且返回单个表达式值的匿名函数
好处：
（1）lambda 函数比较轻便，即用即删除，很适合需要完成一项功能，但是此功能只在此一处使用，连名字都很随意；
（2）匿名函数，一般用来给filter，map这样的函数式编程服务；
（3）作为回调函数，传递给某些应用，比如消息处理
**78、求两个列表的交集、差集、并集**
**set()集合中有关于交集、差集、并集的方法 交集intersection() 差集difference 并集union**
a=[1,2,3,4] b=[4,3,5,6] jj1=[i for i in a if i in b] jj2=list(set(a).intersection(set(b))) print('交集：',jj1,jj2) #交集： [3, 4] [3, 4] cj1=list(set(a).difference(set(b))) cj2=list(set(b).difference(set(a))) print('差集：',cj1,cj2) #差集： [1, 2] [5, 6] bj=list(set(a).union(set(b))) print('并集',bj) #并集 [1, 2, 3, 4, 5, 6] **79、什么是负索引？** #与正索引不同，负索引是从右边开始检索
**80、正则匹配不是以4和7结尾的手机号？**
import re tels=["13100001234","18912344321","10086","18800007777"] #方法1： for item in tels: if len(item)!=11 or item.endswith('4') or item.endswith('7'): print('{}不是想要的手机号'.format(item)) else: print('{}是想要的手机号'.format(item)) #方法二： for item in tels: res=re.match("1\d{9}[0-3,5-6,8-9]",item) if res: print('{}是想要的手机号'.format(res.group())) else: print('{}不是想要的手机号'.format(item))
**81、用两种方法去空格？**
str="hello world ha ha" res1=str.replace(' ','') print(res1) #helloworldhaha res2_l=str.split(' ') res2=''.join(res2_l) print(res2) #helloworldhaha
**82、统计字符串中某字符出现次数？**
str="张三 哈哈 张三 呵呵 张三" from collections import Counter l=str.split(' ') res=Counter(l) print(res) #Counter({'张三': 3, '哈哈': 1, '呵呵': 1}) print(Counter(l)['张三']) #3 print(str.count('张三')) #3
**83、正则表达式匹配 URL**
str = 'Its after 12 noon, do you know where your rooftops are? import re pattern=re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*(),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+') url=re.findall(pattern,str) print(url)
**84、正则匹配以 163.com 结尾的邮箱？**
email_list= ["sdgaozhe@163.com","xiaoWang@163.comheihei", ".com.602556194g@qq.com" ] import re for item in email_list: res=re.match('[\w]{4,20}@163.com$',item) if res: print('{}符合规定的邮件地址，匹配的结果是：{}'.format(item,res.group())) else: print('{}不符合规定的邮件地址'.format(item))
**85、s=“info:xiaoZhang 33 shandong”,用正则切分字符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]**
s="info:xiaoZhang 33 shandong" import re res=re.split(r":| ",s) #|表示或，根据:或 切分 print(res) #['info', 'xiaoZhang', '33', 'shandong']
**86、两个有序列表，l1,l2，对这两个列表进行合并不可使用 extend 【很前面的一题很像…】**
l1=[1,4,7] l2=[2,5,6] l1.extend(l2) print(l1) #[1, 4, 7, 2, 5, 6] 【无序】
l1=[1,4,7] l2=[2,5,6] def merge_sort(l1,l2): left_p,right_p=0,0 result=[] while left_p<len(l1) and right_p<len(l2): if l1[left_p]<l2[right_p]: result.append(l1[left_p]) left_p+=1 else: result.append(l2[right_p]) right_p+=1 result+=l1[left_p:] result+=l2[right_p:] return result print(merge_sort(l1,l2)) #[1, 2, 4, 5, 6, 7]
**87、代码描述列表推导式、字典推导式、生成器？**
import random tds_list=[i for i in range(10)] print('列表推导式',tds_list,type(tds_list)) #列表推导式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'> tds_dict={k:random.randint(4,9) for k in ["a","b","c","d"]} print('字典推导式',tds_dict,type(tds_dict)) #字典推导式 {'d': 9, 'c': 6, 'a': 9, 'b': 7} <class 'dict'> generate=(i for i in range(10)) print('生成器',generate,type(generate)) #生成器 <generator object at 0x0000021C8A507410> <class 'generator'>
**88、根据键对字典排序，不可使用zip？**
dic = {"name":"zs","sex":"man" ,"city":"bj"} #对字典按键key进行排序 res1=sorted(dic.items(),key=lambda x:x[0]) print(res1) #[('city', 'bj'), ('name', 'zs'), ('sex', 'man')] #对字典的值value进行排序 res2=sorted(dic.items(),key=lambda x:x[1]) print(res2) #[('city', 'bj'), ('sex', 'man'), ('name', 'zs')]
**89、阅读一下代码他们的输出结果是什么？**
def multi(): return [lambda x : i*x for i in range(4)] print([m(2) for m in multi()]) #[6, 6, 6, 6] """ **分析：这是一个闭包,下面是闭包定义： 1、闭包是一个嵌套函数 2、闭包必须返回嵌套函数 3、嵌套函数必须引用一个外部的非全局的局部自由变量** def multi(): func_list=[] for i in range(4): def lam(x): return i*x func_list.append(lam) return func_list 在python里，相对而言的局部变量绑定的是值，非局部变量绑定的是空间， 而不是值本身。 所以，for循环生成的i，相对于函数lam来说，是全局变量，所以绑定的是i所在的内存地址，但i最后变成了3，lam绑定的是3。 所以导致了,生成的四个函数所得值时相同的.
那实现结果为[0,2,4,6]呢? 按照刚才的思路,我们只需将lam函数中的i变成局部变量,则函数lam绑定的就是值,而不是内存地址： def mul(): func_list=[] for i in range(4): def lam(x,n=i): #这时候因为n是局部变量，所以绑定的是n的值 return x*n func_list.append(lam) return func_list print([m(2) for m in mul()]) #[0, 2, 4, 6] """
**90、代码实现 Python 的线程同步，在屏幕上依次打印10次“ABC”**
from threading import Thread,Lock mutex=Lock() def print1(lock): lock.acquire() print('A') lock.release() def print2(lock): lock.acquire() print('B') lock.release() def print3(lock): lock.acquire() print('C') lock.release() for i in range(10): t1=Thread(target=print1,args=(mutex,)) t1.start() t1.join() t2 = Thread(target=print2, args=(mutex,)) t2.start() t2.join() t3 = Thread(target=print3, args=(mutex,)) t3.start() t3.join()
**91、简述 read、readline、readlines 的区别？**
read 读取整个文件
readline 读取下一行，使用生成器方法
readlines 读取整个文件到一个迭代器以供我们遍历
**92、a=" hehheh "去除首尾空格**
a=" hehheh " print(a.strip()) #hehheh
**93、yield方法**
yield就是保存当前程序执行状态。
你用for循环的时候，每次取一个元素的时候就会计算一次。用yield的函数叫generator,和iterator一样。
它的好处是不用一次计算所有元素，而是用一次算一次，可以节省很多空间，generator 每次计算需要上一次计算结果，所以用yield,否则一旦return，上次计算结果就没了。
**94、字符串 “123” 转换成 123，不使用内置 API，例如 int()**
def change(s): num=0 for item in s: n=eval(item) #此时n为int类型 num=num*10+n return num res=change('123') print(res,type(res)) #123 <class 'int'>
**95、is 和 == 的区别**
**is 比较的是内存地址 == 比较内容和数据类型** a=[1,2,3] b=a print(id(a),id(b)) #1753026079880 1753026079880 print(a is b) #True print(a == b) #True
import copy c=copy.deepcopy(a) print(id(a),id(c)) #1753026079880 1753026098120 print(a is c) #False print(a==c) #True
**96、有没有一个工具可以帮助查找 python 的 bug 和进行静态的代码分析？**
PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug，会对代码的复杂度和格式提出警告Pylint是另外一个工具可以进行codingstandard检查
**97、文件递归**
import os def print_directory_contents(s_path): """ 这个函数接收文件夹的名称作为输入参数 返回该文件夹中文件的路径 以及其包含文件夹中文件的路径 """ for s_child in os.listdir(s_path): s_child_path = os.path.join(s_path, s_child) if os.path.isdir(s_child_path): print_directory_contents(s_child_path) else: print(s_child_path) print_directory_contents('D:\QQ') #D:\QQ\QQ_Setup.exe
**98、Python 如何copy一个文件？**
JavaScript 和 ES6
在这个过程你会发现，有很多 JS 知识点你并不能更好的理解为什么这么设计，以及这样设计的好处是什么，这就逼着让你去学习这单个知识点的来龙去脉，去哪学？第一，书籍，我知道你不喜欢看，我最近通过刷大厂面试题整理了一份前端核心知识笔记，比较书籍更精简，一句废话都没有，这份笔记也让我通过跳槽从8k涨成20k。
