来源：https://www.cnblogs.com/lmx123/p/9230589.html

1、Python基础

Q1. 什么是Python?

答：Python是一种面向对象的、交互式的、解释型的计算机程序设计语言。
Python具有高可读性，它使用英语关键词而非标点符号，语法结构也比其他语言简单。

Q2. Python的主要功能是什么？

• （1）Python是一种解释型语言；
• （2）声明变量和类似变量时，不需要重复声明变量的类型；
• （3）Python非常适合面向对象的编程，因为它允许类的定义以及组合和继承；
• （4）函数是第一类对象，这意味着它们可以分配给变量，从其他函数返回并传递给函数，类也是第一类对象；
• （5）用于许多领域，包括Web应用程序、自动化、科学建模、大数据应用程序等。

Q3. 一行代码实现1-100的和

print(sum(range(1,101)))

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

答：利用global修改全局变量

>>> a = 5
>>> def fun():
    global a
    a = 4

>>> fun()
>>> print(a)
4

Q5. 列出5个标准Python库

答：

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

答：del和update方法

>>> dic = {'name':'zs','age':'18'}
>>> del dic['name'] # 删除键
>>> dic
{'age': '18'}
>>> dic2 = {'name':'lm'}
>>> dic.update(dic2)
>>> dic
{'age': '18', 'name': 'lm'}

Q7. 谈一下python的GIL

答：GIL是python的全局解锁器，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内其他线程无法运行，等该线程运行完成后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器解开，使其他线程运行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。

多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大。

Q8. python实现列表去重的方法

答：先通过集合去重，再转列表。

>>> list = [11,12,13,12,15,16,13]
>>> a = set(list)
>>> a
{11, 12, 13, 15, 16}
>>> [x for x in a]
[11, 12, 13, 15, 16]

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

def demo(args_f,*args_v):
    print(args_f)
    a = []
    for x in args_v:
        a.append(x)
    print(a)
demo('a','b','c','d')

a
['b', 'c', 'd']

kwargs允许你将不定长度的键值对，作为参数传递给一个函数。如果你想要在一个函数里处理带名字的参数，你应该使用kwargs。这里有个例子帮你理解这个概念：

def demo(**args_v):
    for k,v in args_v.items():
        print(k,v)

demo(name='njcx')
#输出
name njcx

Q10. python2 和 python3 的range(100)的区别

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

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

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

Q12. python内建数据类型有哪些？

答：

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

答：__init__是初始化方法，创建对象后，就立刻被默认调用了，可接收参数，如下示例：

class Bike:

    def __init__(self,newWheelNum,newColor): # __init__方法自动被调用，可以创建对象接收参数
        self.wheelNum = newWheelNum
        self.color = newColor

    def move(self):
        print('车会跑')
# 创建对象
BM = Bike(2,'green')

print('车的颜色为：%s' %BM.color)
print('车轮子的数量为：%d' %BM.wheelNum)

#输出 只打印__init__方法执行的结果，move方法未执行
车的颜色为：green
车轮子的数量为：2 

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__函数。

class A(object):
    def __init__(self):
        print('这是 init 方法',self)

    def __new__(cls):
        print('这是cls的ID',id(cls))
        print('这是 new 方法',object.__new__(cls))
        return object.__new__(cls)
A()
print('这是类A的ID',id(A))
    
#输出
这是cls的ID 2880637165512  
这是 new 方法 <__main__.A object at 0x0000029EB39222E8>
这是 init 方法 <__main__.A object at 0x0000029EB39222E8>        #init方法和new方法中返回值地址一样，说明返回值是对象
这是类A的ID 2880637165512    #cls和类ID一样，说明指向同一个类，也就是cls就是创建的实例类

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

答：

f = open("./1.txt","wb")
try:
    f.write("hello world")
except:
    pass
finally:
    f.close()

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

with open("./2.txt","w") as f:
    f.write("hello python")

（当然还有其他自定义功能，有兴趣可以研究with方法源码）

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

答：map（）函数第一个参数是fun，第二个参数是一般是list，第三个参数可以写list，也可以不写，根据需求

>>> print(list(map(lambda x:x**2,[1,2,3,4,5])))
[1, 4, 9, 16, 25]
>>> a = [1, 4, 9, 16, 25]
>>> b = [i for i in a if i>10]
>>> b
[16, 25]

Q16. python中生成随机整数、随机小数、0--1之间小数方法。

答：

• 随机整数：random.randint(a,b),生成区间内的整数
• 随机小数：习惯用numpy库，利用np.random.randn(5)生成5个随机小数
• 0-1随机小数：random.random(),括号中不传参

import random
import numpy as np
result = random.randint(10,20)
res = np.random.randn(5)
ret = random.random()
print('随机正整数',result)
print('5个随机小数',res)
print('0-1随机一个小数',ret)

#输出：
随机正整数 16
5个随机小数 [ 0.60713108  0.31552514 -1.38000673 -0.5888923   0.1802922 ]
0-1随机一个小数 0.09464817136015036

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

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

Q18. <div class="nam">中国</div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的。

答：

import re

str = '<div class="nam">中国</div>'
res = re.findall(r'<div class=".*">(.*?)</div>',str)
print(res)

# . 代表可有可无
# * 代表任意字符，满足类名可以变化
# (.*?)提取文本

补充：常用正则匹配规则

image.png

Q19. Python中断言方法举例

答:

a = 3
assert(a>1)
print("断言成功，程序继续向下执行")

b = 4
assert(b>7)
print("断言失败，程序报错（这条不会被执行）")

输出：

断言成功，程序继续向下执行
Traceback (most recent call last):
  File "C:/Users/dybhh/Desktop/pypractice/q18.py", line 6, in <module>
    assert(b>7)
AssertionError

Q20. 数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句。

答：SELECT DISTINCT name FROM student

Q21. 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()函数

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

答：

• 不可变数据类型：数值型、字符串型string和元组tuple

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

image.png

• 可变数据类型：列表list和字典dict；

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

image.png

Q23. s = 'ajldjlajfdljfddd'，去重并从小到大排序输出“adfjl”。

答:

>>> s = 'ajldjlajfdljfddd'
>>> s = set(s)
>>> s
{'d', 'a', 'f', 'j', 'l'}
>>> s = list(s)
>>> s
['d', 'a', 'f', 'j', 'l']
>>> s.sort()
>>> s
['a', 'd', 'f', 'j', 'l']
>>> res = "".join(s)
>>> res
'adfjl'

Q24. 用lambda实现两个数相乘。

答：

>>> sum = lambda x,y:x*y
>>> sum(5,4)
20

Q25. 字典根据键从小到大排序。

答：

dict  = {"name":"zs","age":"18","city":"深圳","tel":"1818181818"}
list = sorted(dict.items(),key=lambda i:i[0],reverse=False)
print("sorted根据字典键排序",list)
new_dict = {}
for i in list:
    new_dict[i[0]]=i[1]
print("新字典是：",new_dict)
#输出
>>> sorted根据字典键排序 [('age', '18'), ('city', '深圳'), ('name', 'zs'), ('tel', '1818181818')]
新字典是： {'age': '18', 'city': '深圳', 'name': 'zs', 'tel': '1818181818'}

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

答：

from collections import Counter
a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
res = Counter(a)
print(res)

>>>Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'g': 1, 'b': 1})

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

答：

import re
a = "not 404 found 张三 99 深圳"
list = a.split(" ")
print(list)
res = re.findall('\d+|[a-zA-Z]+',a)
for i in res:
    if i in list:
        list.remove(i)

new_str = " ".join(list)
print(res)
print(new_str)

>>>['not', '404', 'found', '张三', '99', '深圳']
['not', '404', 'found', '99']
张三 深圳

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

答：filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件组成的新列表。接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到新列表。

a = [1,2,3,4,5,6,7,8,9,10]
def fn(a):
    return a%2 == 1

newlist = filter(fn,a)
newlist = [i for i in newlist]
print(newlist)

>>>[1, 3, 5, 7, 9]

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

答：

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

>>>[1, 3, 5, 7, 9]

Q30. 正则re.complie作用？

答：re.complie是将正则表达式编译成一个对象，加快速度，并重复使用。
例如：

import re

def main():
    content = 'Hello, I am Jerry, from Chongqing, a montain city, nice to meet you……'
    regex = re.compile('\w*o\w*') # 查找所有含有“o”的单词
    x = regex.findall(content)
    print(x)

if __name__ == '__main__':
    main()

>>>['Hello', 'from', 'Chongqing', 'montain', 'to', 'you']

Q31. a = (1,) b = (1) c = ('1') 分别是什么类型的数据？

答：

>>> type((1))
<class 'int'>
>>> type((1,))
<class 'tuple'>
>>> type(('1'))
<class 'str'>

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

答：

list1 = [1,5,7,9]
list2 = [2,2,6,8]
list1.extend(list2)
print(list1)

list1.sort(reverse=False)
print(list1)

>>>[1, 5, 7, 9, 2, 2, 6, 8]
[1, 2, 2, 5, 6, 7, 8, 9]

Q33. 用python和Linux命令删除文件的方法。

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

Q34. log 日志种，我们需要时间戳记录error,warning等发生的时间，请用datetime模块打印当前时间戳“ ”。

答：顺便把星期的代码也贴上：

import datetime
a = str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) + ' 星期' + str(datetime.datetime.now().isoweekday())
print(a)

>>>2019-10-22 09:06:26 星期2

Q35. 数据库优化查询方法？

答：外键、索引、联合查询、选择特定字段等。

Q36. 写一段自定义异常代码。

答：自定义异常使用raise抛出异常：

def fn():
    try:
        for i in range(5):
            if i >2:
                raise Exception('数字大于2了')
    except Exception as ret:
        print(ret)
fn()

>>>数字大于2了

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

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

import re
s = '<a>哈哈</a><a>呵呵</a>'
res1 = re.findall('<a>(.*)</a>',s)
print('贪婪匹配',res1)

res2 = re.findall('<a>(.*?)</a>',s)
print('非贪婪匹配',res2)

>>>贪婪匹配 ['哈哈</a><a>呵呵']
非贪婪匹配 ['哈哈', '呵呵']

Q38. 简述Django的orm。

image.png

Q39. 一行代码展开列表a = [[1,2],[3,4],[5,6]],得出[1, 2, 3, 4, 5, 6]。

答:

#一行代码展开列表
a = [[1,2],[3,4],[5,6]]
x = [j for i in a for j in i]
print(x)

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

Q40. x = 'abc', y = 'def', z = ['d','e','f']，分别求出x.join(y)和 x.join(z)的结果。

答：join()括号里面的是可迭代对象，x插入可迭代对象中间，结果一致。

x = 'abc'
y = 'def'
z = ['d','e','f']

m = x.join(y)
n = x.join(z)
print(m)
print(n)

>>>dabceabcf
dabceabcf

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

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

try:
    num = 100
    print(num)
except NameError as errorMsg:
    print('产生错误了：%s' %errorMsg)
else:
    print('没有捕获到异常，则执行该语句')

try:
    num = 100
    print(num)
except NameError as errorMsg:
    print('产生错误了：%s' %errorMsg)
finally:
    print('不管是否捕获到异常，都执行该句')

>>>100
没有捕获到异常，则执行该语句
100
不管是否捕获到异常，都执行该句

Q42. python中交换两个数值。

答：

>>> a,b = 3,4
>>> print(a,b)
3 4
>>> a,b = b,a
>>> print(a,b)
4 3

Q43. 举例说明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')]

Q44. a="hello"和b="你好"编码成bytes类型.

答:

>>> a = b'hello'
>>> b = '你好'.encode()
>>> print(a,b)
b'hello' b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> print(b)
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> print(type(a),type(b))
<class 'bytes'> <class 'bytes'>

Q45. a = [1,2,3]和 b = [4,5,6]相加的结果是多少？

答：两个列表相加，等价于extend。

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> res = a + b
>>> print(res)
[1, 2, 3, 4, 5, 6]

Q46. 提高python运行效率的方法。

答：

• 1、使用生成器，因为可以节约大量内存

• 2、循环代码优化，避免过多重复代码的执行

• 3、核心模块用Cython PyPy等，提高效率

• 4、多进程、多线程、协程

• 5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率

Q47. 简述mysql和redis区别。

答：

• redis： 内存型非关系数据库，数据保存在内存中，速度快
• mysql：关系型数据库，数据保存在磁盘中，检索的话，会有一定的Io操作，访问速度相对慢。

Q48. 遇到bug如何处理？

答：

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

Q49. 正则匹配日期2018-03-20,

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'
答：提取一段特征语句，用(.*?)即可。

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=(.*?)%7C(.*?)&',url)
print(result)

>>>[('2018-03-20', '2018-03-20')]

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

答：利用min()方法求出最小值，原列表删除最小值，新列表加入最小值，递归调用获取最小值的函数，反复操作。

list = [2,3,5,4,9,6]
new_list = []

def get_min(list):
    # 获取列表最小值
    a = min(list)
    # 删除最小值
    list.remove(a)
    # 将最小值加入新列表
    new_list.append(a)
    # 保证最后列表里面有值，递归调用获取最小值
    # 直到所有值获取完，并加入新列表返回
    if len(list)>0:
        get_min(list)
    return new_list

new_list = get_min(list)
print(new_list)

>>>[2, 3, 4, 5, 6, 9]

Q51. 保留两位小数。

答：round(x,n)方法：返回浮点数x的四舍五入值(保留小数点后n位)。

a = '%.03f' %1.3335    # 3前面的0表示补0
print(a,type(a))
b = round(float(a),1)
print(b)
c = round(float(a),2)
print(c)

>>>1.333 <class 'str'>
1.3
1.33

Q52. 求三个方法打印结果.

答：

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

def fn(k,v,dic={}):
    dic[k] = v
    print(dic)

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

>>>
{'one': 1}
{'one': 1, 'two': 2}
{'three': 3}

Q53. 列出常见的状态码和意义。

答：

Q54. 分别从前端、后端、数据库阐述web项目的性能优化。

答:
前端优化：

• 减少http请求、例如制作精灵图
• html和CSS放在页面上部，javascript放在页面下面，因为js加载比HTML和Css加载慢，所以要优先加载html和css,以防页面显示不全，性能差，也影响用户体验差
  后端优化：
• 缓存存储读写次数高，变化少的数据，比如网站首页的信息、商品的信息等。应用程序读取数据时，一般是先从缓存中读取，如果读取不到或数据已失效，再访问磁盘数据库，并将数据再次写入缓存。
• 异步方式，如果有耗时操作，可以采用异步，比如celery
• 代码优化，避免循环和判断次数太多，如果多个if else判断，优先判断最有可能先发生的情况
  数据库优化：
• 如有条件，数据可以存放于redis，读取速度快
• 建立索引、外键等

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

答：

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

Q56. 列出常见MYSQL数据存储引擎

答：
InnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。

MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比 较低，也可以使用。

MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表。

Q57. 计算一些代码运行结果。

答：

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)
print(list(zip(('a','b','c','d','e'),(1,2,3,4,5))))
print('A2:',A2)
print('A3:',A3)

>>>
A0: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
A2: []
A3: [1, 2, 3, 4, 5]

dict()创建字典新方法

#创建字典新方法
#列表
s = dict([['name','zs'],['age',18]])
print(s)

# 元组
a = dict([('name','zs'),('age',18)])
print(a)

>>>
{'name': 'zs', 'age': 18}
{'name': 'zs', 'age': 18}

Q58. 简述同源策略.

答: 同源策略需要同时满足以下三点要求：

• 协议相同
• 域名相同
• 端口相同

http:www.test.com与https:www.test.com 不同源——协议不同
http:www.test.com与http:www.admin.com 不同源——域名不同
http:www.test.com与http:www.test.com:8081 不同源——端口不同

只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”

Q59. 简述cookie和session的区别

答:

• 1. session 在服务器端，cookie 在客户端（浏览器）。
• 2. session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效，存储Session时，键与Cookie中的sessionid相同，值是开发人员设置的键值对信息，进行了base64编码，过期时间由开发人员设置。
• 3. cookie安全性比session差。

Q60. 简述多进程、多线程。

答：
进程：

• 操作系统进行资源分配和调度的基本单位，多个进程之间相互独立。
• 稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制。

线程：

• CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源。
• 如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃。

应用：

• IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间。
• CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势。

Q61. 简述any()和all()方法。

答：

• any():只要迭代器中有一个元素为真就为真
• all():迭代器中所有的判断项返回都是真，结果才为真
  python中什么元素为假？
  （0，空字符串，空列表、空字典、空元组、None, False）

Q62. 常见异常类型及其说明。

答：

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

答:

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

答：生成器是特殊的迭代器

• 列表表达式 [] 改为 () 即可变成生成器。
• 函数在返回值的时候出现yield就变成生成器，而不是函数了。

>>> a = [i for i in range(3)]
>>> type(a)
<class 'list'>
>>> b = (i for i in range(3))
>>> type(b)
<class 'generator'>

Q65. 去除字符串的空格。

答：

>>> a = ' hehehe '
>>> a
' hehehe '
>>> a.strip()
'hehehe'

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

答：

list = [0,-1,3,-10,5,9]
list.sort(reverse=False) # 一种方法
print('list.sort在list基础上修改，无返回值',list)

list2 = [0,-1,3,-10,5,9]
res = sorted(list2,reverse=False) #一种函数
print('sorted有返回值是新的list2',list2)
print('返回值',res)

>>>
list.sort在list基础上修改，无返回值 [-10, -1, 0, 3, 5, 9]
sorted有返回值是新的list2 [0, -1, 3, -10, 5, 9]
返回值 [-10, -1, 0, 3, 5, 9]

Q67. 对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]
a = sorted(foo,key=lambda x:x)
print(a)

>>>
[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]

Q68. 使用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]

答：传两个条件，x<0和abs(x)

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

>>>[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]

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

答：

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

>>>根据年龄从大到小排序: [{'name': 'ss', 'age': 54}, {'name': 'df', 'age': 23}, {'name': 'zs', 'age': 19}, {'name': 'wa', 'age': 17}]
根据姓名从小到大排序： [{'name': 'df', 'age': 23}, {'name': 'ss', 'age': 54}, {'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}]

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

答：

foo = [('zs',19),('ss',54),
       ('wa',17),('df',23)]
# 根据年龄从大到小排序
a = sorted(foo,key = lambda x:x[1],reverse=True)
print('根据年龄从大到小排序:',a)
# 根据姓名从小到大
b = sorted(foo,key = lambda x:x[0])
print('根据姓名从小到大排序：',b)

>>> 根据年龄从大到小排序: [('ss', 54), ('df', 23), ('zs', 19), ('wa', 17)]
根据姓名从小到大排序： [('df', 23), ('ss', 54), ('wa', 17), ('zs', 19)]

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

答：

foo =[['zs',19],['zl',54],
      ['wa',23],['df',23],['xf',23]]
a = sorted(foo,key=lambda x:(x[1],x[0])) #年龄相同，按字母排序
print(a)
b = sorted(foo,key=lambda x:x[0])
print(b)

>>>[['zs', 19], ['df', 23], ['wa', 23], ['xf', 23], ['zl', 54]]
[['df', 23], ['wa', 23], ['xf', 23], ['zl', 54], ['zs', 19]]

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

答：

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

>>>
字典转成列表嵌套元组 [('name', 'zs'), ('sex', 'man'), ('city', 'bj')]
根据键排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
字典推倒式构造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

Q73. 根据键对字典排序（方法二，不用zip）

答：

dic = {'name':'zs','sex':'man','city':'bj'}
print('字典转成列表嵌套元组',dic.items())

b = sorted(dic.items(),key=lambda x:x[0])
print('根据键排序',b)
new_dic = {i[0]:i[1] for i in b}
print('字典推倒式构造新字典',new_dic)

>>>字典转成列表嵌套元组 dict_items([('name', 'zs'), ('sex', 'man'), ('city', 'bj')])
根据键排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
字典推倒式构造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

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

答：

>>> 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] <class 'list'>
>>> ge_list=(i for i in range(10))
>>> print('生成器',ge_list)
生成器 <generator object <genexpr> at 0x00000200A4BD4570>
>>> dic = {k:random.randint(4,9) for k in ['a','b','c','d']}
>>> print('字典推导式',dic,type(dic))
字典推导式 {'a': 7, 'b': 5, 'c': 8, 'd': 5} <class 'dict'>

Q75. 根据字符串长度进行排序。

答：

>>> s = ['ab','abc','a','djsk']
>>> b = sorted(s,key=lambda x:len(x))
>>> print(b,s)
['a', 'ab', 'abc', 'djsk'] ['ab', 'abc', 'a', 'djsk']
>>> s.sort(key=len) #sort无返回值，在s自身修改
>>> print(s)
['a', 'ab', 'abc', 'djsk']

Q76. 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']

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

答：

import re
email_list = ['xiaowang@163.com','xiaowang@163.comhei','xiaowang@qq.com','xiaos@163.com']

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

    else:
        print('%s 不符合要求'% email)

>>>
xiaowang@163.com 是符合规定的邮箱地址，匹配后的结果是：xiaowang@163.com
xiaowang@163.comhei 不符合要求
xiaowang@qq.com 不符合要求
xiaos@163.com 是符合规定的邮箱地址，匹配后的结果是：xiaos@163.com

Q78. 递归求和

答：

# 递归求1—10累加的和
def get_sum(num):
    if num>=1:
        res = num + get_sum(num-1)
    else:
        res = 0
    return res
res = get_s
um(10)
print(res)

>>>55

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

答：json.dumps()：字典转json字符串 ，json.loads()：json转字典

import json
dic = {'name':'zs'}
res = json.dumps(dic) # 字典转json字符串
print(res,type(res))
ret = json.loads(res) # json字符串转字典
print(ret,type(ret))

>>>
{"name": "zs"} <class 'str'>
{'name': 'zs'} <class 'dict'>

Q80. 统计字符串中某字符出现的次数

答：

str = '张三 美国 张三 哈哈 张 三'
res = str.count('张三')
print(res)

>>>2

Q81. 字符串转换大小写。

答：

str = 'HHHuuu'
print(str.upper())
print(str.lower())

>>>
HHHUUU
hhhuuu

Q82. 用两种方法去空格。

答：

str = 'hello world ha ha'
res = str.replace(' ','')
print(res)

list = str.split(' ')
print(list)
ret = ''.join(list)
print(ret)

>>>
helloworldhaha
['hello', 'world', 'ha', 'ha']
helloworldhaha

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

答：

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

>>>
13100001234 不是想要的手机号
想要的结果 18936774821
10086 不是想要的手机号
17389274827 不是想要的手机号

Q84. 正则表达式匹配第一个url。

答：findall结果无需加group()，search需要加group()提取。

import re
s = '<img data-original="https://ridc.sfhfh.cn/sffha/dghha/shams.jpg" src="https://shfsk/safj.jpg" dhdfksk;>'
res = re.findall(r"https://.*?\.jpg",s)[0]
print(res)
ret = re.search(r"https://.*?\.jpg",s)
print(ret.group())

>>>
https://ridc.sfhfh.cn/sffha/dghha/shams.jpg
https://ridc.sfhfh.cn/sffha/dghha/shams.jpg

Q85. 正则匹配中文。

答：

import re
title = '你好，hello,世界'
pattern = re.compile(r'[\u4e00-\u9fa5]+') # 中文的 unicode 编码范围 主要在 [u4e00-u9fa5]
result = pattern.findall(title)

print(result)

>>>['你好', '世界']

Q86. r、r+、rb、rb+文件打开模式区别

答：

image.png

Q87. 正则表达式匹配出<html><h1>www.itcast.cn</h1></html>

答：

import re
labels = ['<html><h1>www.itcast.cn</h1></html>','<html><h1>www.itcast.cn</h2></html>']
for label in labels:
    ret = re.match(r'<(\w*)><(\w*)>.*?</\2></\1>',label)
    if ret:
        print('%s 是符合要求的标签'% ret.group())
    else:
        print('%s 不符合要求'% label)

>>>
<html><h1>www.itcast.cn</h1></html> 是符合要求的标签
<html><h1>www.itcast.cn</h2></html> 不符合要求

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

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

def selfAdd(a):
    a += a

a_int = 1
print(a_int)
selfAdd(a_int)
print(a_int)

a_list = [1,2]
print(a_list)
selfAdd(a_list)
print(a_list)

>>>
1
1
[1, 2]
[1, 2, 1, 2]

Q89. 求两个列表的交集、差集、并集。

答：

>>> a = [1,2,3,4]
>>> b = [4,3,5,6]
>>> jj1 = [i for i in a if i in b] # 在a中的i,并且也在b中，就是交集
>>> print('交集',jj1)
交集 [3, 4]
>>> jj2 = list(set(a).intersection(set(b))) #求交集的函数
>>> print('交集',jj2)
交集 [3, 4]
>>> bj1 = list(set(a).union(set(b))) # 用union求并集
>>> print('并集',bj1)
并集 [1, 2, 3, 4, 5, 6]
>>> cj1 = list(set(b).difference(set(a))) # b中有而a中没有
>>> print('差集，b中有而a中没有：',cj1)
差集，b中有而a中没有： [5, 6]
>>> cj1 = list(set(a).difference(set(b))) # a中有而b中没有
>>> print('差集，a中有而b中没有：',cj1)
差集，a中有而b中没有： [1, 2]

Q90. 生成0~100的随机数

答：random.random()生成0~1之间的随机小数，所以乘100.

import random
res1 = 100*random.random() #随机小数
res2 = random.choice(range(0,101)) #随机整数
res3 = random.randint(1,100) #随机整数
print(res1)
print(res2)
print(res3)

>>>
95.76401356168898
40
30

Q91. lambda匿名函数的好处

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

>>> a = ['苏州','中国','','hh','','效率','']
>>> res = list(map(lambda x:'填充值' if x == '' else x,a))
>>> print(res)
['苏州', '中国', '填充值', 'hh', '填充值', '效率', '填充值']

Q92. 常见的网络传输协议。

答：UDP、TCP、FTP、HTTP、SMTP等等。

Q93. HTTP请求中get和post区别。

答：

• GET请求是通过URL直接请求数据，数据信息可以在URL中直接看到，比如浏览器访问；而POST请求是放在请求头中的，我们是无法直接看到的；
• GET提交有数据大小的限制，一般是不超过1024个字节，而这种说法也不完全准确，HTTP协议并没有设定URL字节长度的上限，而是浏览器做了些处理，所以长度依据浏览器的不同有所不同；POST请求在HTTP协议中也没有做说明，一般来说是没有设置限制的，但是实际上浏览器也有默认值。总体来说，少量的数据使用GET，大量的数据使用POST。
• GET请求因为数据参数是暴露在URL中的，所以安全性比较低，比如密码是不能暴露的，就不能使用GET请求；POST请求中，请求参数信息是放在请求头的，所以安全性较高，可以使用。在实际中，涉及到登录操作的时候，尽量使用HTTPS请求，安全性更好。

Q94. python中读取Excel文件的方法。

答：应用数据分析库pandas

import pandas as pd
df = pd.read_excel('123.xlsx')
print(df)

Q95. 简述多线程、多进程。

答:
进程

• 操作系统进行资源分配和调度的基本单位，多个进程之间相互独立。
• 稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制。
  线程
• CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源；
• 如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃。
  应用
• IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间；
• CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势。

Q96. python正则中search和match

答：

import re
s = '小明年龄18岁 工资10000'
res = re.search(r'\d+',s).group() 
print('search结果(匹配到第一个匹配的数据)',res)

res = re.findall(r'\d+',s)
print('findall结果(满足正则，都匹配，不用加group())',res)

res = re.match('小明',s).group()
print('match结果(匹配‘小明’开头的字符串，并匹配出小明)',res) 

res = re.match('工资',s).group()
print('match结果(‘工资’不是字符串开头，匹配不到，报错)',res) 

>>>
search结果(匹配到第一个匹配的数据) 18
findall结果(满足正则，都匹配，不用加group()) ['18', '10000']
match结果(匹配‘小明’开头的字符串，并匹配出小明) 小明
Traceback (most recent call last):
  File "C:/Users/dybhh/Desktop/pypractice/100-96.py", line 12, in <module>
    res = re.match('工资',s).group()
AttributeError: 'NoneType' object has no attribute 'group'