Python 基础面试题

实现题

一行代码实现1–100之和

print(sum(range(1, 100)))

如何在一个函数内部修改全局变量

a = 1


def main():
    global a
    a = 2

if __name__ == '__main__':
    main()
    print(a) # 2

字典如何删除键和合并两个字典

a = dict(a=1, b=2)
b = dict(c=3, d=4)
a.pop("a")
a.update(b)
print(a) # {'b': 2, 'c': 3, 'd': 4}

python实现列表去重的方法

l1 = [1, 1, 2, 2, 3, 3]
print(list(set(l1))) # [1, 2, 3]

列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]

print(list(map(lambda x: x ** 2, l1))) # [1,4,9,16,25]

print([i for i in map(lambda x: x ** 2, l1) if i > 10]) # [16,25]

python中生成随机整数、随机小数、0–1之间小数方法

import random
print(random.randint(1, 100))
print(random.random())

python中断言方法举例

assert 1 == 2

中国

，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的

import re

a = re.findall("
(.*?)
", "
中国
")
print(a) # ["中国"]

s = 'ajldjlajfdljfddd'，去重并从小到大排序输出'adfjl'

s = list(set('ajldjlajfdljfddd'))
s.sort()
print("".join(s)) # adfjl

利用collections库的Counter方法统计字符串每个单词出现的次数'kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h'

from collections import Counter

res = Counter('kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h')
print(res) # Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'g': 1, 'b': 1})

字符串a = ‘not 404 found 张三 99 深圳’，每个词中间是空格，用正则过滤掉英文和数字，最终输出’张三 深圳’

import re
a = "not 404 found 张三 99 深圳"
res = re.findall("\d+|[a-zA-Z]+", a)

a_l = a.split(" ")
for i in res:
    if str(i) in a_l:
        a_l.remove(i)
        
print(" ".join(a_l)) # 张三 深圳

filter方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(list(filter(lambda x: x % 2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))) # [1, 3, 5, 7, 9]

列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print([i for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if i % 2 != 0]) # [1, 3, 5, 7, 9]

两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,5,6,7,8,9]

l1 = [1,5,7,9] + [2,2,6,8]
l1.sort()
print(l1) # [1,2,2,5,6,7,8,9]

log日志中，我们需要用时间戳记录error,warning等的发生时间，请用datetime模块打印当前时间戳 “2018-04-01 11:38:54”

import datetime
print(datetime.datetime.strptime("2018-04-01 11:38:54", "%Y-%m-%d %H:%M:%S").timestamp()) # 1522553934.0
print(datetime.datetime.now().timestamp()) # 1616583378.423873
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+'星期:'+str(datetime.datetime.now().isoweekday())) # 2018-07-30 15:20:13星期:1

写一段自定义异常代码

class MyError(Exception):
    pass

raise MyError()

[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]

print([j for i in [[1, 2], [3, 4], [5, 6]] for j in i]) # [1,2,3,4,5,6]

x=‘abc’,y=‘def’,z=[‘d’,‘e’,‘f’],分别求出x.join(y)和x.join(z)返回的结果

x = 'abc'
y = 'def'
z = ['d', 'e', 'f']
print(x.join(y)) # dabceabcf
print(x.join(z)) # dabceabcf

python中交换两个数值

a = 1
b = 2

a, b = b, a
print(a, b) # 2 1

举例说明zip（）函数用法

"""
zip()函数在运算时，会以一个或多个序列（可迭代对象）做为参数，返回一个元组的列表。同时将这些序列中并排的元素配对。

zip()参数可以接受任何类型的序列，同时也可以有两个以上的参数;当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组
"""
# 列表
a = [1, 2]
b = [3, 4]
res = [i for i in zip(a, b)]
print(res) # [(1, 3), (2, 4)]
# 元组
a = (1, 2)
b = (3, 4)
res = [i for i in zip(a, b)]
print(res) # [(1, 3), (2, 4)]
# 字符串
a = "ab"
b = "xyz"
res = [i for i in zip(a, b)]
print(res) # [('a', 'x'), ('b', 'y')]

a=‘张明 98分’，用re.sub，将98替换为100

import re
a="张明 100分"
ret=re.sub(r"\d+","100",a)
print(ret) # 张明 100分

a='hello’和b='你好’编码成bytes类型

a = "hello"
print(bytes(a.encode("utf-8"))) # b'hello'
b = "你好"
print(bytes(b.encode("utf-8"))) # b'\xe4\xbd\xa0\xe5\xa5\xbd'

[1,2,3]+[4,5,6]的结果是多少？

[1, 2, 3, 4, 5, 6]

正则匹配，匹配日期2018-03-20

import re
url='https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462'
result=re.findall(r'dateRange=(.*?)&',url)
print(result) # ['2018-03-20%7C2018-03-20']

list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]

li = [2, 3, 5, 4, 9, 6]
new_li = []


def get_min(li):
    a = min(li)
    li.remove(a)
    new_li.append(a)
    if len(li) > 0:
        get_min(li)
    return new_li

get_min(li)
print(new_li) # [2,3,4,5,6,9]

写一个单列模式

"""
因为创建对象时__new__方法执行，并且必须return 返回实例化出来的对象所cls.__instance是否存在，
不存在的话就创建对象，存在的话就返回该对象，来保证只有一个实例对象存在（单列），打印ID，值一样，说明对象同一个
"""


class Singleton(object):
    __instance = None

    def __new__(cls, age, name):
        # 如果类属性__instance的值为None,
        # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时能够知道之前已经创建过对象了，这样就保证了只有1个对象

        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance


a = Singleton(18, "dongGe")
b = Singleton(8, "dongGe")

# id(a) == id(b)
print(id(a))
print(id(b))

# 给a指向的对象添加一个属性
a.age = 19

# 获取b指向的对象的age属性
print(b.age) # 19  

保留两位小数

print(round(1.333, 2)) # 1.33

求三个方法打印结果

"""
fn("one", 1）直接将键值对传给字典；fn("two", 2)
因为字典在内存中是可变数据类型，所以指向同一个地址，传了新的参数后，会相当于给字典增加键值对；fn("three", 3, {})
因为传了一个新字典，所以不再是原先默认参数的字典
"""
def fn(k, v, dic={}):
    dic[k] = v
    print(dic)

fn("one", 1) # {'one': 1}
fn("two", 2) # {'one': 1, 'two': 2}
fn("three", 3, {}) # {'three': 3}

使用pop和del删除字典中的’name’字段，dic={‘name’:‘zs’,‘age’:18}

# pop
dic = {"name":"zs","age" :18}
dic.pop("name" )
print(dic) # {'age': 18}
# del
dic = {"name":"zs","age" :18}
del dic["name"]
print(dic) # {'age': 18}

计算代码运行结果，zip函数历史文章已经说了，得出[(‘a’,1),(‘b’,2)，(‘c’,3),(‘d’,4),(‘e’,5)]

A = zip(("a", "b", "c", "d", "e"), (1, 2, 3, 4, 5))
A0 = dict(A)
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
print('A0', A0) # A0 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(list(zip(("a", "b", "c", "d", "e"), (1, 2, 3, 4, 5)))) # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
print(A2) # []
print(A3) # [1, 2, 3, 4, 5]

C:\Users\ry-wu.junya\Desktop>python 1.py 22 33命令行启动程序并传参，print(sys.argv)会输出什么数据？

print(sys.argv) # ['1.py', '22', '33']

请将[i for i in range(3)]改成生成器

print(type(i for i in range(3)) # 

a = ' hehheh ',去除收尾空格

print(' hehheh '.strip()) # hehheh

举例sort和sorted对列表排序，list=[0,-1,3,-10,5,9]

"""
sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。sorted(L)返回一个排序后的L，不改变原始的L；
L.sort()是对原始的L进行操作，调用后原始的L会改变，没有返回值。【所以a = a.sort()是错的啦！a = sorted(a)才对！

sorted()适用于任何可迭代容器，list.sort()仅支持list（本身就是list的一个方法）

基于以上两点，sorted使用频率比list.sort()更高些，所以Python中更高级的排序技巧便通过sorted()来演示。
"""
li = [0, -1, 3, -10, 5, 9]
li.sort()
print(li)  # [-10, -1, 0, 3, 5, 9]
li = [0, -1, 3, -10, 5, 9]
res = sorted(li)
print(li)  # [0, -1, 3, -10, 5, 9]
print(res)  # [-10, -1, 0, 3, 5, 9]

对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函数从小到大排序

foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
print(sorted(foo, lambda x: x)) # 

使用lambda函数对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，输出结果为[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正数从小到大，负数从大到小

foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4]
res = sorted(foo, key=lambda x: (x < 0, abs(x)))  # abs()函数返回绝对值,传两个条件，x<0和abs(x)
print(res) # [0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]

列表嵌套字典的排序，分别根据年龄和姓名排序

foo = [{"name": "zs", "age": 19}, {"name": "ll", "age": 54}, {"name": "wa", "age": 17}, {"name": "df", "age": 23}]
# 年龄从大到小
a = sorted(foo, key=lambda x: x['age'], reverse=True)
print(a) # [{'name': 'll', 'age': 54}, {'name': 'df', 'age': 23}, {'name': 'zs', 'age': 19}, {'name': 'wa', 'age': 17}]
# 姓名从小到大
b = sorted(foo, key=lambda x: x['name'])
print(b) # [{'name': 'df', 'age': 23}, {'name': 'll', 'age': 54}, {'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}]

列表嵌套元组，分别按字母和数字排序

foo = [("zs", 19), ("ll", 54), ("wa", 17), ("df", 23)]
# 按数字由大到小
a = sorted(foo, key=lambda x: x[1], reverse=True)
print(a) # [('ll', 54), ('df', 23), ('zs', 19), ('wa', 17)]
# 按字母由小到大
a = sorted(foo, key=lambda x: x[0])
print(a) # [('df', 23), ('ll', 54), ('wa', 17), ('zs', 19)]

列表嵌套列表排序，年龄数字相同怎么办？

foo = [["zs", 19], ["ll", 54], ["wa", 23], ["df", 23], ["xf", 23]]
# 年龄相同，添加参数按字母排序
a = sorted(foo, key=lambda x: (x[1], x[0]))
print(a) # [['zs', 19], ['df', 23], ['wa', 23], ['xf', 23], ['ll', 54]]
# 按字母由小到大
a = sorted(foo, key=lambda x: x[0])
print(a) # [['df', 23], ['ll', 54], ['wa', 23], ['xf', 23], ['zs', 19]]

根据键对字典排序（方法一，zip函数）

dic = {"name": "zs", "sex": "man", "city": "bj"}
# 字典转列表嵌套元组
foo = zip(dic.keys(), dic.values())
foo = [i for i in foo]
print("字典转成列表嵌套元组", foo) # 字典转成列表嵌套元组 [('name', 'zs'), ('sex', 'man'), ('city', 'bj')]
# 字典嵌套元组排序
b = sorted(foo, key=lambda x: x[0])
print("根据键排序", b) # 根据键排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
# 排序完构造新字典
new_dic = {i[0]: i[1] for i in b}
print("字典推导式构造新字典", new_dic) # 字典推导式构造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

根据键对字典排序（方法二,不用zip)

dic = {"name": "zs", "sex": "man", "city": "bj"}
print(dic.items()) # dict_items([('name', 'zs'), ('sex', 'man'), ('city', 'bj')])
b = sorted(dic.items(), key=lambda x: x[0])
print("根据键排序", b) # 根据键排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
new_dic = {i[0]: i[1] for i in b}
print("字典推导式构造新字典", new_dic) # 字典推导式构造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

列表推导式、字典推导式、生成器

import random

td_list = [i for i in range(10)]
print("列表推导式", td_list, type(td_list)) # 列表推导式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

ge_list = (i for i in range(10))
print("生成器", ge_list) # 生成器  at 0x0000027A7F20D3C0>

dic = {k: random.randint(4, 9) for k in ["a", "b", "c", "d"]}
print("字典推导式", dic, type(dic)) # 字典推导式 {'a': 6, 'b': 9, 'c': 7, 'd': 7} 

最后出一道检验题目，根据字符串长度排序，看排序是否灵活运用

a = ['ab', 'abc', 'a', 'djkj']
# sorted有返回值，不改变a本身
b = sorted(a, key=lambda x: len(x))
print(a, b) # ['ab', 'abc', 'a', 'djkj'] ['a', 'ab', 'abc', 'djkj']
# sort无返回值，在a自身修改
a.sort(key=len)
print(a) # ['a', 'ab', 'abc', 'djkj']

s='info:xiaoZhang 33 shandong',用正则切分字符串输出['info', 'xiaoZhang', '33', 'shandong']

import re

s = "info:xiaoZhang 33 shandong"
# |表示或，根据冒号或者空格切分
res = re.split(r":| ", s)
print(res) # ['info', 'xiaoZhang', '33', 'shandong']

正则匹配以163.com结尾的邮箱

import re

email_list = ["[email protected]", "[email protected]", "[email protected]"]
for email in email_list:
    ret = re.match("[\w]{4,20}@163\.com$", email)
    if ret:
        print("%s 是符合规定的邮件地址，匹配后结果是:%s" % (email, ret.group())) # [email protected]
    else:
        print("%s 不符合要求" % email) # [email protected] [email protected]

递归求和

def get_sum(num):
    if num >= 1:
        res = num + get_sum(num - 1)
    else:
        res = 0
    return res


print(get_sum(10)) # 55

python字典和json字符串相互转化方法

import json

dic = {"name": "zs"}
res = json.dumps(dic)
print(res, type(res)) # {"name": "zs"} 

ret = json.loads(res)
print(ret, type(ret)) # {'name': 'zs'} 

统计字符串中某字符出现次数

str = "张三 哈哈 张三 呵呵 张三"
res = str.count("张三")
print(res) # 3

字符串转化大小写

s = "HHaa"
print(s.upper()) # HHAA
print(s.lower()) # hhaa

用两种方法去空格

str = "hello world ha ha"

res = str.replace(" ", "")
print(res) # helloworldhaha

list = str.split(" ")
res = "".join(list)
print(res) # helloworldhaha

正则匹配不是以4和7结尾的手机号

tels = ["13100001234", "18912344321", "10086", "18800007777"]

for tel in tels:
    ret = re.match("1\d{9}[0-3,5-6,8-9]", tel)
    if ret:
        print("结果是：", ret.group()) # 13100001234 18800007777
    else:
        print("%s不是想要的手机号" % tel) # 18912344321 10086

正则匹配中文

import re

title = "你好，hello，世界"
res = re.compile(r'[\u4e00-\u9fa5]+')
result = res.findall(title)
print(result) # ['你好', '世界']

正则表达式匹配出

itcast.cn

import re

labels=["
python编程:887934385
","
python编程:887934385
"]

for label in labels:
    ret=re.match(r"<(\w*)><(\w*)>.*?",label)
    if ret:
        print("%s是符合要求的标签"%ret.group()) # 
python编程:887934385
    else:
        print("%s不符合要求"%label) # 
python编程:887934385

int(‘1.4’),int(1.4)输出结果？

print(int("1.4")) # 报错ValueError
print(int(1.4)) # 1

求两个列表的交集、差集、并集

a = [1, 2, 3, 4]

b = [4, 3, 5, 6]

jj1 = [i for i in a if i in b]  # 在a中的i，并且也在b中，就是交集
jj2 = list(set(a).intersection(set(b)))
bj1 = list(set(a).union(set(b)))
cj1 = list(set(b).difference(set(a)))
cj2 = list(set(a).difference(set(b)))

print("交集", jj1) # 交集 [3, 4]
print("交集", jj2) # 交集 [3, 4]
print("并集", bj1) # 并集 [1, 2, 3, 4, 5, 6]
print("差集", cj1) # 差集 [5, 6]
print("差集", cj2) # 差集 [1, 2]

生成0-100的随机数

import random

# 随机小数 random.random()生成0-1之间的随机小数，所以乘以100
res1 = 100 * random.random()
# 随机整数
res2 = random.choice(range(0, 101))
# 随机整数
res3 = random.randint(1, 100)
print(res1)
print(res2)
print(res3)

描述题

列出5个python标准库

os, sys, re, math, datetime

谈下python的GIL

银行四个窗口(进程),四个队伍的客户在排队办理业务,

python中的"全局GIL锁"的意思是:

一旦有一个窗口在办理客户的业务,其他三个窗口必须停止办理,直到这个窗口办理完业务,其他窗口才有机会给客户办理业务.

多个窗口有客户在排队,但是所有窗口后面共享一个客服,客服只能轮流办理业务.

fun(*args,**kwargs)中的*args,**kwargs什么意思？

位置参数（positional argument）: 位置参数只能由参数位置决定
关键词参数（keyword argument）: 关键词参数只需要用 keyword = somekey 的方法即可传参

python2和python3的range（100）的区别

python2返回列表，python3返回迭代器，节约内存

一句话解释什么样的语言能够用装饰器?

函数可以作为参数传递的语言，可以使用装饰器

python内建数据类型有哪些

python内置的常用数据类型有：数字、字符串、Bytes、列表、元组、字典、集合、布尔等
Python3 支持 int、float、bool、complex（复数）

简述面向对象中__new__和__init__区别

1、__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别

2、__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例

3、__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

4、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。

简述with方法打开处理文件帮我我们做了什么？

打开文件在进行读写的时候可能会出现一些异常状况，如果按照常规的 f.open 写法，我们需要try,except,finally，做异常判断，并且文件最终不管遇到什么情况，都要执行finally f.close()关闭文件，with方法帮我们实现了finally中f.close

避免转义给字符串加哪个字母表示原始字符串？

 r，表示需要原始字符串，不转义特殊字符

python2和python3区别？列举5个

1、Python3 使用 print 必须要以小括号包裹打印内容，比如 print('hi') Python2 既可以使用带小括号的方式，也可以使用一个空格来分隔打印内容，比如 print 'hi'
2、python2 range(1,10)返回列表，python3中返回迭代器，节约内存
3、python2中使用ascii编码，python3中使用utf-8编码
4、python2中unicode表示字符串序列，str表示字节序列,python3中str表示字符串序列，byte表示字节序列
5、python2中为正常显示中文，引入coding声明，python3中不需要
6、python2中是raw_input()函数，python3中是input()函数

列出python中可变数据类型和不可变数据类型，并简述原理

可变: list, set, dict
原理: 不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址），如下图用id()方法可以打印对象的id：

不可变: int, str, bool, None, tuple, float
原理: 允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

正则re.complie作用

re.compile是将正则表达式编译成一个对象，加快速度，并重复使用

a=（1，）b=(1)，c=(‘1’) 分别是什么类型的数据？

a: tuple
b: int
c: str

用python删除文件和用linux命令删除文件方法

python：os.remove(文件名)
linux: rm 文件名

请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行

pychart、matplotlib

正则表达式匹配中，（.）和（.?）匹配区别？

（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配

（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配

简述Django的orm

ORM，全拼Object-Relation Mapping，意为对象-关系映射

实现了数据模型与数据库的解耦，通过简单的配置就可以轻松更换数据库，而不需要修改代码只需要面向对象编程,orm操作本质上会根据对接的数据库引擎，翻译成对应的sql语句,所有使用Django开发的项目无需关心程序底层使用的是MySQL、Oracle、sqlite....，如果数据库迁移，只需要更换Django的数据库引擎即可

举例说明异常模块中try except else finally的相关意义

try..except..else没有捕获到异常，执行else语句
 
try..except..finally不管是否捕获到异常，都执行finally语句

提高python运行效率的方法

1、使用生成器，因为可以节约大量内存
2、循环代码优化，避免过多重复代码的执行
3、核心模块用Cython  PyPy等，提高效率
4、多进程、多线程、协程
5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率

遇到bug如何处理

1、细节上的错误，通过print（）打印，能执行到print（）说明一般上面的代码没有问题，分段检测程序是否有问题，如果是js的话可以alert或console.log
2、如果涉及一些第三方框架，会去查官方文档或者一些技术博客。
3、对于bug的管理与归类总结，一般测试将测试出的bug用teambin等bug管理工具进行记录，然后我们会一条一条进行修改，修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法，我也都会收藏做一些笔记记录。
4、导包问题、城市定位多音字造成的显示错误问

简述any()和all()方法

any():只要迭代器中有一个元素为真就为真
all():迭代器中所有的判断项返回都是真，结果才为真

python中什么元素为假？
答案：（0，空字符串，空列表、空字典、空元组、None, False）

IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常

IOError：输入输出异常
AttributeError：试图访问一个对象没有的属性
ImportError：无法引入模块或包，基本是路径问题
IndentationError：语法错误，代码没有正确的对齐
IndexError：下标索引超出序列边界
KeyError:试图访问你字典里不存在的键
SyntaxError:Python代码逻辑语法出错，不能执行
NameError:使用一个还未赋予对象的变量

python中copy和deepcopy区别

1、复制不可变数据类型，不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。

2、复制的值是可变对象（列表和字典）
浅拷贝copy有两种情况：
第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。
第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表）， 改变原来的值 中的复杂子对象的值 ，会影响浅复制的值。

深拷贝deepcopy：完全复制独立，包括内层列表和字典

列出几种魔法方法并简要介绍用途

__init__:对象初始化方法
__new__:创建对象时候执行的方法，单列模式会用到
__str__:当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
__del__:删除对象执行的方法

简述python引用计数机制

python垃圾回收主要以引用计数为主，标记-清除和分代清除为辅的机制，其中标记-清除和分代回收主要是为了处理循环引用的难题。

引用计数算法

当有1个变量保存了对象的引用时，此对象的引用计数就会加1

当使用del删除变量指向的对象时，如果对象的引用计数不为1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除

列举3条以上PEP8编码规范

1、顶级定义之间空两行，比如函数或者类定义。
2、方法定义、类定义与第一个方法之间，都应该空一行
3、三引号进行注释
4、使用Pycharm、Eclipse一般使用4个空格来缩进代码

python传参数是传值还是传址？

Python中函数参数是引用传递（注意不是值传递）。
对于不可变类型（数值型、字符串、元组），因变量不能修改，所以运算不会影响到变量自身；
而对于可变类型（列表字典）来说，函数体运算可能会更改传入的参数变量。

lambda匿名函数好处

精简代码，lambda省去了定义函数，map省去了写for循环过程

单引号、双引号、三引号用法

1、单引号和双引号没有什么区别，不过单引号不用按shift，打字稍微快一点。表示字符串的时候，单引号里面可以用双引号，而不用转义字符,反之亦然。'She said:"Yes." ' or "She said: 'Yes.' "

2、但是如果直接用单引号扩住单引号，则需要转义，像这样： ' She said:\'Yes.\' '

3、三引号可以直接书写多行，通常用于大段，大篇幅的字符串

python垃圾回收机制

Python的GC模块主要运用了引用计数来跟踪和回收垃圾。
当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁时，对象的引用计数减1，当对象的引用计数减少为0时，就意味着对象已经再没有被使用了，可以将其内存释放掉。

python正则中search和match

、match
re.match(pattern, string[, flags])
从首字母开始开始匹配，string如果包含pattern子串，则匹配成功，返回Match对象，失败则返回None，若要完全匹配，pattern要以$结尾。

2、search
re.search(pattern, string[, flags])
若string中包含pattern子串，则返回Match对象，否则返回None，注意，如果string中存在多个pattern子串，只返回第一个。

3、findall
re.findall(pattern, string[, flags])
返回string中所有与pattern相匹配的全部字串，返回形式为数组。

4、finditer
re.finditer(pattern, string[, flags])
返回string中所有与pattern相匹配的全部字串，返回形式为迭代器。

内存池

Python为了避免频繁的申请和删除内存所造成系统切换于用户态和核心态的开销，从而引入了内存池机制，专门用来管理小内存的申请和释放。

python中的异步与同步

异步：多任务，多个任务之间执行没有先后顺序，可以同时运行，执行的先后顺序不会有什么影响，存在的多条运行主线

同步：多任务，多个任务之间执行的时候要求有先后顺序，必须一个先执行完成之后，另一个才能继续执行， 只有一个主线

简述Python进程、线程和协程的区别及应用场景？

1.进程拥有自己独立的堆和栈，堆和栈都不共享，进程由操作系统调度
2.线程拥有自己独立的栈，但是堆却是共享的，标准的线程是由操作系统调度的
3.协程共享堆却不共享栈，协程是由程序员在协程的代码块里显示调度