python笔试110题（Interview questions）

python笔试110题–详解

1. 一行代码实现1—100之和
   解：

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

2. 如何在一个函数内部修改全局变量
   解：
   1）函数内部用global声明，global x。
   2）全局变量的类型是容器：字典，列表等

   # 2. 如何在一个函数内部修改全局变量
   dict1 = {}
   print("函数调用前为空", dict1)
   
   def write_in_dict():
       dict1['name'] = '张娃'
       dict1['age'] = 28
       dict1['sex'] = '男'
   
   
   write_in_dict()  # 调用
   print("函数调用后：", dict1)
   

   打印输出：函数调用前为空 {}

   函数调用后： {'name': '张娃', 'age': 28, 'sex': '男'}

3. 列出5个python标准库
   解：
   os，sys，re，math， random ，datetime ，urllib，datetime ，zlib

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

   # 4、字典如何删除键和合并两个字典
   dict1 = {'name': 'pei',
            'age': 28,
            'sex': '男'}
   dict2 = {'工号': '123',
            '工时': 10,
            'gen': '女'}
   print("原数据：", dict1, dict2)
   
   # 合并两个字典用dict的update方法：
   dict1.update(dict2)
   print("两个字典合并：", dict1)
   
   # del指定键名字就可以删除键
   del dict1['name']
   del dict2['gen']
   print("删除键name后：", dict1, dict2)
   

   

5. 谈下python的GIL

   GIL的全称是 Global Interpreter Lock，全局解释器锁。之所以叫这个名字，是因为Python的执行依赖于解释器。Python最初的设计理念在于，为了解决多线程之间数据完整性和状态同步的问题，设计为在任意时刻只有一个线程在解释器中运行。而当执行多线程程序时，由GIL来控制同一时刻只有一个线程能够运行。即Python中的多线程是表面多线程，也可以理解为fake多线程，不是真正的多线程。

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

   list1 = [1, 2, 3, 4, 4, 4, 5]
   list2 = ["apple", "pear", "pear"]
   print("原数据：", list1, list2)
   
   list1 = list(set(list1))
   list2 = list(set(list2))
   print("去重后：", list1, list2)
   

   

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

   args,**kwargs分别表示将不定长的位置参数和键值参数，传递给方法。
   位置参数args 用来将参数打包成tuple给函数体调用;
   键值参数**kwargs 打包关键字参数成dict给函数体调用;
   参数arg、*args、**kwargs三个参数的位置必须是一定的。必须是(arg,*args,**kwargs)这个顺序，否则程序会报错。

8. python2和python3的range（100）的区别

   2中range（100）返回列表[0-99]
   3中range（100）返回迭代器range(0, 10)

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

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

   注：python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象（函数的指针）。装饰器函数的外部函数传入我要装饰的函数名字，返回经过修饰后函数的名字；内层函数（闭包）负责修饰被修饰函数。

   import time
   
   
   def decorator(func):
       def wrapper(*args, **kwargs):
           start_time = time.time()
           func()
           end_time = time.time()
           print(end_time - start_time)
   
       return wrapper
   
   
   @decorator
   def func():
       time.sleep(0.8)
   
   
   func()  # 函数调用
   

   输出：0.8007323741912842

10. python内建数据类型有哪些?

    Python3 的六个标准数据类型中：
    不可变数据（3 个）：Number（数字: int、float、bool、complex）、String（字符串）、Tuple（元组）；
    可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

    int(x [,base])：将x转换为一个整数
    float(x)：将x转换到一个浮点数
    complex(real [,imag])：创建一个复数
    str(x)：将对象 x 转换为字符串
    repr(x)：将对象 x 转换为表达式字符串
    eval(str)：用来计算在字符串中的有效Python表达式,并返回一个对象
    tuple(s)：将序列 s 转换为一个元组
    list(s)：将序列 s 转换为一个列表
    set(s)：转换为可变集合
    dict(d)：创建一个字典。d 必须是一个 (key, value)元组序列。
    frozenset(s)：转换为不可变集合
    chr(x)：将一个整数转换为一个字符
    ord(x)：将一个字符转换为它的整数值
    hex(x)：将一个整数转换为一个十六进制字符串
    oct(x)：将一个整数转换为一个八进制字符串

11. 简述面向对象中__new__和__init__区别
    __init__是初始化方法，创建类实例后默认调用__init__方法，该方法可接收参数。
    __new__方法正是创建这个类实例的方法。

    __init__ 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
    __new__通常用于控制生成一个新实例的过程。它是类级别的方法。

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

    with语句即“上下文管理器”，在程序中用来表示代码执行过程中所处的前后环境。
    上下文管理器：含有enter和exit方法的对象就是上下文管理器。
    enter()：在执行语句之前，首先执行该方法，通常返回一个实例对象，如果with语句有as目标，则将对象赋值给as目标。
    exit()：执行语句结束后，自动调用exit()方法，用户释放资源，若此方法返回布尔值True，程序会忽略异常。 使用环境：文件读写、线程锁的自动释放等。

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

    # 13. 列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]
    def square(x):  # 计算平方数
        return x ** 2
    
    
    print([i for i in list(map(square, [1, 2, 3, 4, 5])) if i>10])
    

    输出：[16, 25]
    注1：map(function, iterable, …)，python3中，map函数返回的是迭代器。python2中返回的是list。
    注2：list comprehension列表推导式，列表解析式，语法：out_list = [out_express for out_express in input_list if out_express_condition]

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

    # 14. python中生成随机整数、随机小数、0—1之间小数方法
    import random
    import numpy as np
    print(random.random())  # 生成一个0-1之间的小数
    print(random.random()*random.randint(1, 9))  # 生成随机小数
    print(random.randint(1, 9))  # 生成一个0-1之间的小数
    print(np.random.randn(15))  # 生成15个随机小数
    

    结果：

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

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

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

    import re
    
    strings = '<div class="nam1">中国</div>'
    reg = '<div class=".*">(.*?)</div>'
    result = re.findall(reg, strings)
    print(result)
    
    

17. python中断言方法举例
    语法：assert 表达式，参数，当表达式为真，继续往下执行；表达式为假，报错AssertionError，并输出参数内容。

    # 17. python中断言方法举例
    assert 1, 404
    
    
    def foo(s):
        assert isinstance(s, str), 's is not string!'
        return s
    
    
    print("assert的表达式为真", foo('0'))
    print("assert的表达式为假", foo(0))
    

    

18. 数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句
    select distinct name From student
select * from student group by name

19. 10个Linux常用命令

    poweroff,–help,cd,ls,mkdir,rm,mv,touch,vi或vim,chmod

    1）基本命令
    poweroff,shutdown -h now,shutdown -h 2,2分钟后关机
    --help:ifconfig --help，帮助
    ls,ls -a,ls -l,ls /dir,目录查看 ls [-al]
    cd ..,cd ~,cd -,目录切换 cd
    su用于用户之间的切换
    pwd:查看当前目录
    ps -ef 查看所有正在运行的进程
    kill pid 或者 kill -9 pid
ifconfig：查看网卡信息
    ping
ctrl + l:清屏
    2）目录操作【增，删，改，查】
    mkdir,创建目录【增】
    rm [-rf] 目录,删除目录或文件【删】，rm -rf *删除当前所有目录和文件，rm -rf /* 【自杀命令！慎用！慎用！慎用！】将根目录下的所有文件全部删除
    mv 当前目录 新目录:目录修改【改】
    cp -r 目录名称 目录拷贝的目标位置 -r代表递归
find 目录 参数 文件名称，【查】，示例：find /usr/tmp -name ‘a*’ 查找/usr/tmp目录下的所有以a开头的目录或文件
    su,sudo,help,restart,
    3） 文件操作命令
    新建文件【增】touch 文件名
    删除文件 【删】 rm
    修改文件【改】 vi或vim
    文件的查看【查】 cat 文件名
    4）权限修改(rwx：r代表可读，w代表可写，x代表该文件是一个可执行文件，如果rwx任意位置变为-则代表不可读或不可写或不可执行文件。)
    chmod +x aaa.txt,chmod 777
    5)压缩文件操作
    命令：tar -zcvf 打包压缩后的文件名 要打包的文件
    其中：z：调用gzip压缩命令进行压缩
    c：打包文件
    v：显示运行过程
    f：指定文件名
    示例：tar -zcvf ab.tar aa.txt bb.txt 或：tar -zcvf ab.tar *
    6)解压
    命令：tar [-zxvf] 压缩文件
    其中：x：代表解压
    示例：tar -xvf ab.tar -C /usr------C代表指定解压的位置
    更多命令请参看此博客。

20. python2和python3区别？列举5个

    1. 内置函数有些不同
       print “string”；print(“string”)；
       Python2 中的 range 和 xrange 函数在python3中合并成了 range；
       python2高阶函数 map、filter、zip 返回列表对象，python3返回迭代器；
       Python2的迭代器必须实现 next 方法，而 Python3 改成了 next
    2. 默认编码不同
       Python2 的默认编码是 asscii,需要在文件顶部写 # coding=utf-8。
       Python 3 默认采用了 UTF-8 作为默认编码。
    3. True和False
       True 和 False 在 Python2 中是两个全局变量（名字），在数值上分别对应 1 和 0.
       Python3中，True 和 False 变为两个关键字，永远指向两个固定的对象，不允许再被重新赋值。
    4. Python3中新的字符串格式化方法format取代Python2 中%
    5. 整除
       Python2 中 / 的结果是整型，Python3 中是浮点类型。
    6. 通过input()解析用户的输入
       在 python2 中 raw_input() 和 input()，两个函数都存在，其中区别为：raw_input()—将所有输入作为字符串看待，返回字符串类型； input()-----只能接收"数字"的输入，在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（int, float ）。
       在 python3 中 raw_input() 和 input() 进行了整合，去除了 raw_input()，仅保留了 input() 函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型.
       7.For 循环变量和全局命名空间泄漏
       在 Python3 中 for 循环变量不会再导致命名空间泄漏。
       

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

    不可变数据类型:数值,字符,元组,不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址），如下图用id()方法可以打印对象的id。
    可变数据类型:list,set,dict
    可变数据类型，如list,允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

    python中，一切皆对象。对象具有三要素：标志(identity)，类型(type)，值（value）。
    不可变对象表示，不支持原地修改。一旦修改就是重新创建对象。
    可变对象，支持原地修改，不改变原对象。
    变量是指向对象的一个引用。变量只是一个临时标签，没有类型。

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

    思路：利用集合元素唯一性，去重；再用快速列表排序或自带sorted排序方法；最后用空字符，join排好队的字符为字符串。

    # 22. s = “ajldjlajfdljfddd”，去重并从小到大排序输出”adfjl”
    s = "ajldjlajfdljfddd"
    result = list(set(s))
    max_ = len(result)
    print(result)
    
    
    def quicksort(array):
        if len(array) < 2:
            # 跳出递归循环的条件。
            return array
        else:
            # 递归内容：找出比pivot小和大的团伙
            pivot = array[0]
            # 小于pivot的集合
            less = [i for i in array[1:] if i <= pivot]
            # 大于pivot的集合
            greater = [i for i in array[1:] if i > pivot]
    
            # 返回比pivot小的集合快速排序，[pivot]，以及比pivot大的集合快速排序
            return quicksort(less) + [pivot] + quicksort(greater)
    
    
    print("".join(quicksort(result)))
    print("".join(sorted(result)))
    

    

23. 用lambda函数实现两个数相乘

    匿名函数：lambda a,b：a*b为一个表达式，需要赋值给一个变量，调用该函数，使用变量名加（参数）调用

    result = lambda a, b: a * b
    print(result(3, 3))
    

    

24. 字典根据键从小到大排序dict={“name”:”zs”,”age”:18,”city”:”深圳”,”tel”:”1362626627”}

    # 24. 字典根据键从小到大排序dict={“name”:”zs”,”age”:18,”city”:”深圳”,”tel”:”1362626627”}
    dic = {"name": "zs", 'age': 18, 'city': "深圳", 'tel': "1362626627"}
    print(dic.items()) # 打印键值对
    result = sorted(dic.items(), key=lambda i:i[0], reverse=False)  # dic.items()待排序的列表， key参数为提供自定义键函数来自定义排序顺序，当循环列表时，以第一个参数i[0]为排序对象，排序。不反向，升序
    print(dict(result))
    

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

    个人以为题目要修改一下，统计字符串每个字符出现的次数，因为看哪个都不像单词。
    在结合24题，排个序，更有意思！

    # 25. 利用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)
    result = sorted(res.items(), key=lambda i:i[0], reverse=False)
    print(dict(result))
    

    

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

    用正则表达式匹配中文字符：[^\x00-\xff],表示出了0-255的ascii码，但里面还有其他比如标点符号的字符。只想匹配中文字符应该是unicode编码[\u4e00-\u9fa5]，[\u4e00-\u9fa5]+ 其中“+” 表示匹配连续多个中文字符。

    # 26. 字符串a = “not 404 found 张三 99 深圳”，每个词中间是空格，用正则过滤掉英文和数字，最终输出”张三  深圳”
    import re
    a = "not 404 found 张三 99 深圳"
    reg = re.compile('[\u4e00-\u9fa5]+')
    result = reg.findall(a)
    print(result)
    print(" ".join(result))
    

    

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

    # 27. filter方法求出列表所有奇数并构造新列表，a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    # print(divmod(8, 5)) #divmod(被除数，除数)返回（商，余数）
    # print(8 % 5)  # %求余
    remainder = lambda num: num % 2
    print(list(filter(remainder, a)))
    

    
    注：匿名函数返回的时对2求余的结果，本来就只有1，0；
    filter过滤出a中元素传入remainder返回为真的a的元素。有点歪打正着的感觉！

28. 列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,15]
    参照27题的匿名函数

    # 28. 列表推导式求列表所有奇数并构造新列表，a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,15]
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15]
    remainder = lambda num: num % 2  # 匿名函数返回的时对2求余的结果，本来就只有1，0
    print([i for i in a if remainder(i)])
    

    

29. 正则re.complie作用

    编译正则表达式。将正则表达式编译成一个对象，运算加速，便于复用

30. a=（1，）b=(1)，c=(“1”) 分别是什么类型的数据？

    a=（1，）元组，仅一个元素时必须要加逗号
    b=(1)，整型
    c=(“1”)，字符串

    

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

    # 31. 两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]
    a = [1, 5, 7, 9]
    b = [2, 2, 6, 8]
    
    print(sorted(a+b))
    # 方法二
    a.extend(b)
    print(sorted(a))
    

    

32. 用python删除文件和用linux命令删除文件方法
    python: os.remove(file_name)
linux: rm file_name

    import os
    os.remove('./1.txt')
    

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

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

34. 数据库优化查询方法
    外键、索引、联合查询、选择特定字段等等
    参考

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

    import matplotlib.pyplot as plt
    import warnings
    warnings.filterwarnings("ignore")
    x = [i for i in range(15)]
    x2 = [i+0.2 for i in range(15)]
    
    y1 = [10, 13, 15, 12, 14, 34, 35, 34, 27, 29, 21, 27, 20, 21, 10]
    y2 = [24, 20, 25, 26, 24, 21, 20, 27, 26, 25, 28, 19, 23, 21, 27]
    
    plt.figure(figsize=(10, 5))
    # plt.plot(x, y1, label='A')  # 折线图
    # plt.plot(x, y2, label='B')
    # plt.scatter(x, y1, color='#990099')  # 点状图
    # plt.boxplot([y1, y2])  # 盒状图
    plt.bar(x, y1, label='B', color='#9999ff', width=0.2)  # 柱状图
    # plt.bar(x, y2, label='B', color='#0099ff', width=0.2)
    plt.bar(x2, y2, label='B', color='#009900', width=0.2)
    plt.title('Weight change in 15 months')
    plt.xlabel('Month')
    plt.ylabel('pv')
    plt.show()
    

    

36. 写一段自定义异常代码

    class newException(Exception): # 继承异常类
        def __init__(self, msg):
            self.msg = msg
    
    try:
        raise newException("own error")
    except newException as e:
        print(e)
    	
    

37. 正则表达式匹配中，（.）和（.?）匹配区别？
    '.'是匹配除了'\n'之外的任意一个字符; '?'是匹配前一个字符1次或0次

38. 简述Django的orm

    Django的ORM(Object-Relation Mapping,对象关系映射)：在使用Django进行网站类项目开发时，只需面向对象编程，不需要写SQL代码面向数据库编程，其对数据库的操作都转化成对类属性和方法的操作；ORM实现了数据模型与数据库的解耦, 屏蔽了不同数据库操作上的差异。在Django上只需简单的配置数据库参数就可以轻松更换数据库, 而不需要修改操作数据的代码。

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

    # 39. [[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
    import torch
    import numpy
    
    a = [[1, 2], [3, 4], [5, 6]]
    
    # 方法一
    li = torch.IntTensor(a).view(1, -1).squeeze().tolist()
    print(li)
    
    # 方法二
    lj = numpy.array(a).flatten().tolist()
    print(lj)
    
    # 方法三
    lk = [j for i in a for j in i]
    print(lk)
    

    输出结果
    
    注释：torch的tensor相关维数变换参照此博客。

40. x=”abc”,y=”def”,z=[“d”,”e”,”f”],分别求出x.join(y)和x.join(z)返回的结果
    x.join(y):dabceabcf
x.join(z):dabceabcf
    将x的内容作为字符串和数组join的分隔符，得出相同的结果。字符串里面的元素也是可以切面和索引来检索的。

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

try except……else/finally，这个组合可以捕获异常，并继续执行后续。避免遇到异常就中断程序。

	try:
		{执行语句1}
	except:
		{执行语句2}
	else:
		{执行语句3}

try…except…else没有捕获到异常，执行else语句。

	try:
		{执行语句1}
	except:
		{执行语句2}
	finally:
		{执行语句3}

执行语句1没有发生异常，则执行语句3；执行语句1异常，则执行语句2，再只执行语句3。
try…except…finally不管是否捕获到异常，都执行finally语句。

42. python中交换两个数值

    # 42. python中交换两个数值
    left, right = 5, 9
    print(left, right)
    left, right = right, left
    print(left, right)
    

    

43. 举例说明zip（）函数用法
    zip()记忆法：齐头并进

zip()函数在运算时，会以一个或多个序列（可迭代对象）做为参数，返回一个来自不同可迭代对象构成元组的列表。
当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。

# 43. 举例说明zip（）函数用法
string1 = "12345"
string2 = "Hello"
list1 = ['你', '我', '他']
list2 = ['乖巧', '聪明', '勇敢']
tuple1 = ('a', 'b', 'c')
tuple2 = ('A', 'B', 'C')

# zip()函数在运算时，会以一个或多个序列（可迭代对象）做为参数，返回一个来自不同可迭代对象构成元组的列表。
s1 = zip(string1, string2)
s2 = zip(tuple1, tuple2)
s3 = zip(list1, list2)
s4 = zip(string1, string2, list1, list2, tuple1, tuple2)  #当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。

print(s1, type(s1))
print([i for i in s1])
print([i for i in s2])
print([i for i in s3])
print([i for i in s4])

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

    re是正则的表达式,sub是substitute表示替换
    re.sub实现正则的替换:re.sub(pattern, repl, string, count=0, flags=0)
    pattern可以是一个字符串也可以是一个正则，用于匹配要替换的字符.
    count是pattern被替换的最大次数，默认是0会替换所有。

    # 44. a=”张明 98分”，用re.sub，将98替换为100
    import re
    a = "张明 98分"
    print(re.sub(r'(\d+)', '100', a))
    

    

45. 写5条常用sql语句

    操作数据库，对数据库、表、字段行，分别都有增删改查的操作。

    SHOW VARIABLES LIKE "%char%";
    create database db1 charset utf8;
    show databases;
    drop database db1;
    create table t1(id int,name char(10) );
    show tables;
    drop table t1;
    insert into t1 values(1,'dsb1'),(2,'dsb2'),(3,'dsb3');
    delete from t1 where id=2;
    

    参考博客：此博客获得更多。

46. a=”hello”和b=”你好”编码成bytes类型

    编码：encode

    # 46. a=”hello”和b=”你好”编码成bytes类型
    a = "hello".encode()
    b = "你好".encode()
    b1 = "你好".encode('utf-8')
    b2 = "你好".encode('gbk')
    
    print(a, type(a))
    print(b, type(b))
    print(b1, type(b1))
    print(b2, type(b2))
    
    

    

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

48. 提高python运行效率的方法

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

49. 简述mysql和redis区别
    mysql是关系型数据库；数据保存在磁盘中，检索有Io操作，访问速度相对慢。
    redis是非关系型数据库。数据保存在内存中，速度快。

    redis是一个高性能的key-value数据库。redis支持的存储value类型相对更多，包括string（字符串）、list（链表）、set（集合）和zset（有序集合）等。这些数据类型都支持push/pop、add/remove及取交集、并集和差集及更丰富的操作，而且这些操作都是原子性的。提供了Python、Ruby、Erlang、PHP客户端，使用方便。

50. 遇到bug如何处理

    遇到bug需要定位调试，找到问题的原因。分析问题，解决问题。
    通过IDE工具，设置断点，打印数据，分段检测和分析报错信息、错误码等定位bug。根据提示信息，和上下文逻辑、数据类型等修改bug。
    还可以，网络搜索第三方技术框架论坛或技术博客，找寻解决问题的方法。

51. 正则匹配，匹配日期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‘

    # 51. 正则匹配，匹配日期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'
    reg = re.compile(r'\d{4}-\d{2}-\d{2}')
    result = re.findall(reg, url)
    print(result)
    

    

52. list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]
    冒泡排序法：参见此博客。
    

53. 写一个单列模式

    # 53. 写一个单例模式
    
    # 解：单例类只能有一个实例
    # 因为创建对象时__new__方法执行
    # 并且必须return 返回实例化出来的对象所cls.__instance是否存在
    # 不存在的话就创建对象，存在的话就返回该对象，来保证只有一个实例对象存在（单列）
    # 打印ID，值一样时，说明为同一个对象
    class Singleton(object):
        __instance = None
    
        # __new__是默认创建当前类的实例，属于类方法；__init__是对实例的初始化方法。
        # 所以设置__new__方法永远只返回一个实例，解决单列模型问题。
        def __new__(cls, age):
            # 如果类属性的值__instance为None
            # 那么就创建一个对象，并且赋值为这个对象的引用；
            # 保证下次调用这个方法时，能够知道之前已经创建对象了，这样就保证只有一个对象。
            if not cls.__instance:
                cls.__instance = object.__new__(cls)
            return cls.__instance  # 如果先前创建了对象就返回该对象
    
    first_obj1 = Singleton(18)
    first_obj2 = Singleton(28)
    
    print("__new__构建单列模型，两个对象实质为一个id:\n", id(first_obj1))
    print(id(first_obj2))
    
    

    class Add(object):
        __instance = None
    
        # __new__是默认创建当前类的实例，属于类方法；__init__是对实例的初始化方法。
        # 所以设置__new__方法永远只返回一个实例，解决单列模型问题。
        def __init__(self, age):
            self.age = age
    
    add1 = Add(18)
    add2 = Add(18)
    print("__init__正常类实例化，生成不同实例:\n", id(add1))
    print(id(add2))
    

    输出：

54. 保留两位小数
    题目本身只有a=”%.03f”%1.3335,让计算a的结果，为了扩充保留小数的思路，提供round方法（数值，保留位数）

    直接a = “%.02f” % 1.3335

    # 54. 保留两位小数
    # 题目本身只有a=”%.03f”%1.3335,让计算a的结果，
    # 为了扩充保留小数的思路，提供round方法（数值，保留位数）
    a = "%.03f" % 1.3335
    print(a)
    print(round(float(a), 2))
    
    

55. 求三个方法打印结果

    不要误导，题目确实没明白。

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

    200 OK：请求成功
    404 Not Found：请求失败
    301 Moved Permanently ：永久重定向，资源已永久分配新URI
    500 Internal Server Error :服务器故障或Web应用故障

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

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

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

    此题有一个重要知识点：关于python的del
    python的del不同于C的free和C++的delete。
    由于python都是引用，而python有GC机制，所以，del语句作用在变量上，而不是数据对象上。
    举例说明：m = 'a' # 表示对象 ‘a’ 被变量m引用，对象'a'的引用计数器+1;如果再进行赋值，n = m, l = m; #表示对象 ‘a’ 被变量n和l引用，对象'a'的引用计数器为+1再+1；当使用del删除时：del m; # 删除变量m，是解除m对'a的引用；不会真正删除数据'a'；故del删除的是变量，而不是数据。
    同样，对于列表li=[1,2,3,4,5] #列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4] ； first=li[0]； #拷贝列表，也不会有数据对象的复制，而是创建新的变量引用

    dic = {"name":"zs","age":18}
    # print(dic.pop("name"))  # 字典调用pop，可以加键名
    del dic["name"] # 字典调用pop，可以加键名
    print(dic.items())
    
    

    

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

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

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

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

60. 使用zip函数，构建字典dict.

    # 60. 计算代码运行结果，zip函数历史文章已经说了，得出[(“a”,1),(“b”,2)，(“c”,3),(“d”,4),(“e”,5)]
    # 60题也有毛病，改了改了
    # 60. 使用zip函数，构建字典dict.
    keyY = "mynaistx"
    list1 = [1, [2, 5], (3,), '谭', '翛', True, False, "thy"]
    result = dict(zip(keyY, list1))
    print(result)
    

    

61. 简述同源策略

    同源指的是一个请求路径中的请求协议、ip及端口和另一个请求路径中的请求协议、ip及端口保持一致。所谓同源是指"协议+域名+端口"三者相同。同源策略是浏览器的一个安全功能，不同源的客户端脚本在没有明确授权的情况下，不能读写对方资源。同源策略是为了安全，确保一个应用中的资源只能被本应用的资源访问。

62. 简述cookie和session的区别

    1、数据存放位置不同：cookie数据存放在客户的浏览器上，session数据放在服务器上。
    2、安全程度不同：cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,考虑到安全应当使用session。
    3、性能使用程度不同：session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能,考虑到减轻服务器性能方面，应当使用cookie。
    4、数据存储大小不同：单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie，而session则存储与服务端，浏览器对其没有限制。

63. 简述多线程、多进程

    1. 多进程是指将许多任务分配到计算机的多个cpu核上，实现并行多进程依赖多CPU；且多进程适合计算密集型的任务，它会充分利用多个CPU。(操作系统进行资源分配和调度的基本单位，多个进程之间相互独立,如果一个进程崩溃，不影响其他进程，进程消耗资源大，开启进程数量有限制)
    2. 多线程：一个进程可以拥有多个线程，多线程实现并发。（CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源，但是，如果一个线程崩溃，则会造成该进程的崩溃。）
       如果只有一个cpu，那么多个线程可以交叉重叠执行，这时就是并发。有多个cpu，多个线程也是可以同时执行的，这时就是并行。
    3. 多进程和多线程比较起来，多线程一般适用于IO密集型的任务。多进程适用于计算密集型的任务。

    最后，python多线程为什么不能利用多核cpu

64. 简述any()和all()方法
    1. any(x)是判断x对象的元素是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
2. all(x) 是针对x对象的元素而言，如果all(x)参数x对象的所有元素不为0、”、False或者x为空对象，则返回True，否则返回False
    注：python中表示假的元素:（0，’ '，空列表、空字典、空元组、None, False）

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

    IOError：输入输出错误；输入输出异常
    AttributeError：属性错误；试图访问一个对象没有的属性
    ImportError：导入包错误；无法引入模块或包，和路径问题
    IndentationError：对齐缩进类语法错误；
    IndexError：索引错误；越界
    KeyError：键值错误；试图访问字典里不存在的键
    SyntaxError：代码逻辑类语法错误；
    NameError：变量名错误；使用还未赋予对象的变量

66. python中copy和deepcopy区别

    复制不可变数据类型时，copy和deepcopy没有区别。
    区别在于，复制的值是可变对象（列表和字典），copy的对象会受原对象对内层可变对象元素修改的影响；深拷贝deepcopy：完全复制独立，包括内层列表和字典，不受原对像的影响。
    copy复制了一个新对象，但内层的可变对象还藕断丝连。
    deepcopy复制的新对象，与母本彻底斩断前因后果。

    # 66. python中copy和deepcopy区别
    import copy
    ori = {"不可变":'abc', "不可":3, "可变":[1,3,5], "可":[[2,2],[4,4]]}
    
    cop = copy.copy(ori)
    
    decop = copy.deepcopy(ori)
    

    
    

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

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

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

    文件名和参数构成的列表
    [‘1.py’, ‘22’, ‘33’]
    没有传参时，默认会有一个参数就是文件。

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

70. a = “ hehheh “,去除首尾空格
    Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列,不能删除中间部分的字符。
    

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

    # 71. 举例sort和sorted对列表排序，list=[0,-1,3,-10,5,9]
    # sort是列表对象的方法，直接修改列表，没有返回值
    
    lis = [0,-1,3,-10,5,9]
    print(sorted(lis)) # sorted是python的内置函数，返回一个新的列表，原列表不变。
    
    lis.sort(reverse=False)
    print(lis)
    
    

    

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

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

    
    注：将lambda函数当作标志，key表示按关谁排序，比如24题。

    # 拓展
    # 24. 字典根据键从小到大排序dict={“name”:”zs”,”age”:18,”city”:”深圳”,”tel”:”1362626627”}
    dic = {"name": "zs", 'age': 18, 'city': "深圳", 'tel': "1362626627"}
    print(dic.items()) # 打印键值对
    result = sorted(dic.items(), key=lambda i:i[0], reverse=False)  # dic.items()待排序的列表， key参数为提供自定义键函数来自定义排序顺序，当循环列表时，以第一个参数i[0]为排序对象，排序。不反向，升序
    print(dict(result))
    
    

73. 使用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]，正数从小到大，负数从大到小

    # 73. 使用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]
    resultZ = sorted(foo, key=lambda x: x)
    resultF = sorted(foo, key=lambda x: x, reverse=True)
    for i in range(len(resultF)):
        if resultF[i] < 0:
            resultZ[:i] = resultZ[len(resultF)-i:]
            resultZ[i:] = resultF[i:]
            break
    print(resultZ)
    

    

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

    # 74. 列表嵌套字典的排序，分别根据年龄和姓名排序
    student = [{"name": "Jinjin", "age": 28}, {"name": "Caiyue", "age": 12}, {"name": "Jane", "age": 20}, {"name": "Lily", "age": 15}]
    result_0 = sorted(student, key=lambda x: x["name"])  # 排序student里的元素，key表示元素中，按谁的次序为准
    result_1 = sorted(student, key=lambda x: x["age"])
    
    print(result_0)
    print(result_1)
    

    

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

    # 75. 列表嵌套元组，分别按字母和数字排序
    student = [('Jin', 28), ("Cai", 12), ("Jane", 20), ("Lily", 15), ]
    result_0 = sorted(student, key=lambda x: x[0])
    result_1 = sorted(student, key=lambda x: x[1])
    
    print(result_0)
    print(result_1)
    
    

    

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

    再添加一个参数，按字母排序

    # 76. 列表嵌套列表排序，年龄数字相同怎么办？添加参数，按字母排序
    student = [['Win', 20], ["Cai", 12], ["Sane", 20], ["Lily", 15], ]
    result_1 = sorted(student, key=lambda x: (x[1], x[0]))
    
    print(result_1)
    

    

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

    采用zip函数将字典的键和值组成元组对。zip(iter,iter,…),
    字典的keys(),values()，刚好返回可迭代对象

    # 77. 根据键对字典排序（方法一，zip函数）
    personal = {"name": "Jinjin", "age": 28, "sex": "female", "score": 96.5}
    # 采用zip函数将字典的键和值组成元组对。zip(iter,iter,...),
    # 字典的keys(),values()，刚好返回可迭代对象
    # print(personal.keys())
    # print(personal.values())
    # print([x for x in zip(personal.keys(), personal.values())])
    result = sorted(zip(personal.keys(), personal.values()), key=lambda x: x[0])
    personal = {x[0]: x[1] for x in result}  # 字典里面的顺序也要轮一遍
    # print(result)
    print(personal)
    

    

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

    字典内个元素排序，没有数字索引，需要变成列表签到元组的方式，采用dict的items()

    # 78. 根据键对字典排序（方法二,不用zip)
    personal = {"name": "Jinjin", "age": 28, "sex": "female", "score": 96.5}
    # 字典内个元素排序，没有数字索引，需要变成列表签到元组的方式，采用dict的items
    # print(personal.items())
    result = sorted(personal.items(), key=lambda x: x[0])  # x[0]按 键 排序
    personal = {x[0]: x[1] for x in result}  # 字典里面的顺序也要轮一遍
    print(personal)
    

    

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

    # 79. 列表推导式、字典推导式、生成器
    import random
    li = [x for x in range(5)]
    dic = {k: random.randint(60, 100) for k in ["Jane", "Alex", "Jane", "Simon", "Junilo", "Lucy"]}
    gen = (x for x in range(6, 10))
    print(li)
    print(dic)
    print(gen)
    
    

    

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

    # 80. 最后出一道检验题目，根据字符串长度排序，看排序是否灵活运用
    name = ["Janefully", "Floopy", "Simon", "Alex"]
    
    # 方法一
    # result = sorted(name, key=lambda x: len(x)) # sorted不改变原列表本身
    result = sorted(name, key=len)  # key=函数，或匿名函数都可以
    print(result)
    
    # 方法二
    name.sort(key=len)  # key等于一个函数
    print(name)
    

    

81. 举例说明SQL注入和解决办法

    看注释

    #81. 举例说明SQL注入和解决办法
    
    # 当以字符串格式化书写方式的时候，如果用户输入的有;
    # +SQL语句，后面的SQL语句会执行，比如例子中的SQL注入会删除数据库demo。
    input_name = "Jane"
    sql = 'select * from demo where name="%s"' % input_name
    print("SQL语句：", sql)   # 正常查询
    
    input_name  = "Jane\"; drop database demo;"
    sql = 'select * from demo where name="%s"' % input_name  # 注入了数据库风险操作，SQL注入
    print("SQL语句：", sql)
    

    

    解决方式：通过传参数方式解决SQL注入
    方式二：检查参数里面是否含有分号“;”，有分号不接收。

82. s=”info:xiaoZhang 33 shandong”,用正则切分字符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]

    # 82. s=”info:xiaoZhang 33 shandong”,用正则切分符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]
    import re
    s = "info:xiaoZhang 33 shandong"
    result = re.split(r":| ", s)
    print(result)
    
    

    

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

    # 83. 正则匹配以163.com结尾的邮箱
    import re
    s = "我以前的邮箱地址为beau_thy@163.com，现在的邮箱地址17778388888@163.com"
    email = "neauthy@163.com"
    reg = re.compile("([a-zA-Z_\d]+@163\.com)")
    result = re.findall(reg, s)
    ret = re.match("[a-zA-Z_\d]+@163\.com$", email)  # 匹配失败返回None;匹配成功返回一个正则对象<re.Match object>
    print(result)
    print(ret, ret.group())
    

    

84. 递归求和

    关键在递归结束的控制。

    # 84. 递归求和
    def sumRound(num):
        assert isinstance(num, int), "you should put in int type!"
        if num == 0:
            return num
        elif num > 0:
            return num+sumRound(num-1)
        else:
            return num+sumRound(num+1)
    
    print("-100-0累加求和等于：", sumRound(-100))
    

    

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

    # 85. python字典和json字符串相互转化方法
    import json
    dic = {"name": 'Simon', "class": 'Apple1', "number": '202009', "score": '99.0'}
    result = json.dumps(dic) # dumps将字典转换为json自负床
    print(result, type(result))
    
    d = json.loads(result) # loads将json字符串转换为字典。
    print(d, type(d))
    

    

86. MyISAM 与 InnoDB 区别：

1、MyISAM 适合查询以及插入为主的应用，InnoDB 适合频繁修改以及涉及到安全性较高的应用；
2、InnoDB 支持事务，MyISAM 不支持;
事务是一种高级的处理方式，如在一些列增删改中，哪个出错可以回滚还原，而 MyISAM不可以。
3、InnoDB 支持外键，MyISAM 不支持；
4、对于自增长的字段，InnoDB 中必须包含只有该字段的索引，但是在 MyISAM表中可以和其他字段一起建立联合索引；
5、清空整个表时，InnoDB 是一行一行的删除，效率非常慢。MyISAM 则会重建表；

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

    字符串对象自带count()方法。

    # 87. 统计字符串中某字符出现次数
    s = "my hobby is reading."
    num = s.count('i')
    print(num)
    

    输出：2

88. 字符串转化大小写

    字符串对象自带upper(),lower()方法。

    # 88. 字符串转化大小写
    s = "my hobby is reading."
    res = s.upper()
    print(res)
    res = res.lower()
    print(res)
    

    

89. 用两种方法去空格

    方式一，用空格拆分字符串，再组合。
    方式二，字符串对象的replace(old, new)方法

    # 89. 用两种方法去空格
    s = "用 两种 方式 去掉 空格"
    
    # 方式一，用空格拆分字符串，再组合。
    result = "".join(s.split(" "))
    print(result)
    
    # 方式二，字符串对象的replace(old, new)方法
    result1 = s.replace(" ", "")
    print(result1)
    

    

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

    # 90. 正则匹配不是以4和7结尾的手机号
    import re
    telList = ["13368259999", "13340331607", "13368259991", "", "13368259994", "13368259997"]
    reg = r"\d{10}[^4,7]$"
    result = [tel for tel in telList if re.match(reg, tel)]
    print(result)
    

91. 简述python引用计数机制

    python内部使用引用计数，来保持追踪内存中的对象，
    Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。

92. int(“1.4”),int(1.4)输出结果？

    int(“1.4”)会报错，ValueError:是对int()函数无效文字
    int(1.4)输出1

93. 列举3条以上PEP8编码规范

    1.类的命名采用驼峰命名法，即每个单词的首字母大写。
    2.函数名称应该是小写的，为了提高可读性，必须使用由下划线分隔的单词。如果函数参数的名称与保留关键字冲突，通常最好追加一个尾部下划线，而不是使用缩写或拼写损坏。
    3.用两个空白行分隔顶层函数和类定义。类中的方法定义用一个空行分隔。
    4.导入应按以下顺序进行：① 标准库导入;② 有关的第三方库进口;③ 本地应用程序库特定的导入。
    5.统一缩进，每个缩进级别使用4个空格。
    6.避免无关的空格。

94. 正则表达式匹配第一个URL

    # 94. 正则表达式匹配第一个URL
    import re
    site = "simon最常用的搜索引擎有https://www.google.com以及https://www.baidu.com？simon请匹配第一个网址"
    rex = re.compile(r"https?://www\.\w+\.[cojmnprg]+")
    
    # 方法一：findall
    result = re.findall(rex, site)[0]
    print(result)
    
    # 方法二：search
    result1 = re.search(rex, site)  # 搜到返回一个正则对象，没搜到返回None
    print(result1, result.group())
    

    

95. 正则匹配中文

    # 95. 正则匹配中文
    import re
    site = "simon最常用的搜索引擎有https://www.google.com以及https://www.baidu.com？simon请匹配第一个网址"
    rex = '[\u4e00-\u9fa5]+'
    result = re.findall(rex, site)
    print(result)
    
    

    

96. 简述乐观锁和悲观锁

    1. 当要对数据库中的一条数据进行修改的时候，为了避免同时被其他人修改，最好的办法就是直接对该数据进行加锁以防止并发。这种借助数据库锁机制，在修改数据之前先锁定，再修改的方式被称之为悲观并发控制【Pessimistic Concurrency Control，缩写“PCC”，又名“悲观锁”】。
    2. 乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则返回给用户错误的信息，让用户决定如何去做。乐观锁适用于读操作多的场景，这样可以提高程序的吞吐量。

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

    r: 打开文件，只读。
    r+：打开文件，读写。
    rb：以二进制格式打开文件，只读。
    rb+：以二进制格式打开文件，读写。

98. Linux命令重定向 > 和 >>

    Linux 允许将命令执行结果重定向到一个文件，将本应显示在终端上的输出内容覆盖或追加到指定文件中。
    > 表示输出内容会覆盖文件原有的内容；
    >>表示追加，将输出内容追加到已有文件的末尾。

    假设脚本里有输出打印的操作。python test.py > log1.txt
python test.py >> log1.txt

99. 正则表达式匹配出一下html源代码中的大标题。
    

    # 99. 正则表达式匹配出 <html><h1>www.itcast.cn</h1></html>
    # 改题目：提取网页里的标题
    import re
    labels = """
    <html>
    <div class="article-header">
                <div class="article-title-box">
                    <h1 class = "xxx">PEP8编码规范</h1>
                </div>
                <div class="article-info-box">
                    <div class="article-bar-top">...
                    <div class="article-title-box">
                    <h1 class = "xxx">匹配标题</h1>
                </div>
    </html>
    """
    reg = re.compile("<h1 .*?>(.*?)</h1>", re.S)
    result = re.findall(reg, labels)
    print(result)
    

    

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

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

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

# 101. 求两个列表的交集、差集、并集
list1 = [1, 3, 4, 5, 6, 7, 8, 9]
list2 = [2, 3, 4, 5, 7, 10, 11]

interS = list(set(list1).intersection(set(list2)))
diff = list(set(list1).difference(set(list2)))
uni = list(set(list1).union(set(list2)))

print("交集intersection:", interS)
print("差集difference:", diff)
print("并集union:", uni)

102. 生成0-100的随机数

# 102. 生成0-100的随机数
import random
print(random.randint(0, 100))  # 包括0和100，随机整数
print(100*random.random())  # 随机笑数

103. lambda匿名函数好处

>精简代码，lambda省去了定义函数
在map，filter， sort，sorted等接收函数为参数的方法中，有循环的作用。

# 103. lambda匿名函数好处
dic = {"name": "zs", 'age': 18, 'city': "深圳", 'tel': "1362626627"}

result = sorted(dic.items(), key=lambda i:i[0], reverse=False)  # dic.items()待排序的列表， key参数为提供自定义键函数来自定义排序顺序，当循环列表时，以第一个参数i[0]为排序对象，排序。不反向，升序
print(dict(result))

result2 = list(map(lambda x: x+"+miaomiaomiao", dic.keys()))
print(result2)

result3 = list(filter(lambda x: x == "name", dic.keys()))
print(result3)

104. 常见的网络传输协议

UDP、TCP/IP协议、FTP、HTTP、SMTP(电子邮件传输的协议)、DNS

物理层：以太网 · 调制解调器 · 电力线通信(PLC) · SONET/SDH · G.709 · 光导纤维 · 同轴电缆 · 双绞线等
数据链路层：Wi-Fi(IEEE 802.11) · WiMAX(IEEE 802.16) ·ATM · DTM · 令牌环 · 以太网 ·FDDI · 帧中继 · GPRS · EVDO ·HSPA · HDLC · PPP · L2TP ·PPTP · ISDN·STP · CSMA/CD等
网络层协议：IP (IPv4 · IPv6) · ICMP· ICMPv6·IGMP ·IS-IS · IPsec · ARP · RARP · RIP等
传输层协议：TCP · UDP · TLS · DCCP · SCTP · RSVP · OSPF 等
应用层协议：DHCP ·DNS · FTP · Gopher · HTTP· IMAP4 · IRC · NNTP · XMPP ·POP3 · SIP · SMTP ·SNMP · SSH ·TELNET · RPC · RTCP · RTP ·RTSP· SDP · SOAP · GTP · STUN · NTP· SSDP · BGP 等

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

1.单引号和双引号分别单独使用效果一样。
2.单双引号一起使用时：双引号要嵌套单引号，不能嵌套双引号；单引号也要嵌套双引号，不能嵌套单引号。
3.三引号可以直接书写多行，通常用于大段，大篇幅的字符串

106. python垃圾回收机制

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

107. HTTP请求中get和post区别

POST和GET差异：
1.POST和GET是HTTP协议定义的与服务器交互的方法。GET一般用于获取/查询资源信息，而POST一般用于更新资源信息。另外，还有PUT和DELETE方法。
2.POST和GET都可以与服务器完成查，改，增，删操作。
3.GET提交，请求的数据会附在URL之后，以？分割URL和传输数据，多个参数用&连接；
POST提交，把提交的数据放置在HTTP包的包体中；因此，GET提交的数据会在地址栏中显示出来，而POST提交，地址栏不会改变。
HTTP协议没有对传输的数据大小进行限制，HTTP协议规范也没有对URL长度进行限制。但是，特定浏览器和服务器对URL长度有限制，如IE对URL长度的限制是2083字节。因此，GET提交时，传输数据就会受到URL长度的限制。
4.对于GET方式，服务器端用Request.QueryString获取变量的值，对于POST方式，服务器端用Request.Form获取提交的数据。
判断法方法： if request.method == ‘GET’:

108. python中读取Excel文件的方法

pandas(应用数据分析库pandas)

# 108. python中读取Excel文件的方法
import pandas as pd
dir_excel = r"E:\Tanxxx_work\谭xx--个人工作报表.xlsx"
result = pd.read_excel(dir_excel)
print(result)

109. 简述线程、进程

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

110. python正则中search和match

>search搜索字符串对象中是否存在对应正则表达式的内容，存在则返回匹配到的第一个，结束。不存在返回None；
match匹配字符串，从头开始，符合正则表达式的要求，返回匹配到的内容，否则返回None.
两个函数都返回None或者正则对象。

# 110. python正则中search和match
import re
content = ["抓人", "capture抓", "怎的个愁字了得125", "1 1怎么", "full"]
# 测试search和match
rex = re.compile("[\u4e00-\u9fa5]+")  # 正则表达式要求匹配汉字
result1 = map(lambda x: re.search(rex, x) if re.search(rex, x) == None else re.search(rex, x).group(), content)
result2 = map(lambda x: re.match(rex, x) if re.match(rex, x) == None else re.match(rex, x).group(), content)

print(list(result1))
print(list(result2))

参考文献：

1. 题目来源参考CSDN博主「水是睡着的冰」的原创文章: https://blog.csdn.net/javahuazaili/article/details/87927181
2. 正则学习，很重要。

总结

110笔试题手撕完，要是不能用IDE，纯手写，估计只能勉强及格。
总结一下重点。

1. 数据类型（对象），可变，不可变，以及他们这些对象自带的方法；基础知识要牢固；
2. python常见内置函数的用法map(),filter(),匿名函数；python本身要熟悉；
3. python标准库，需要掌握常用库和常用函数。像random,re，os,sys等；内库很重要；
   正则是重点
4. 了解前后端，网络架构项目；Django,flask,自少掌握一种。
5. 数据库知识,越熟练越好；
6. 进程、线程、多进程和多线程是重点；
7. 代码注释书写很重要，代码优美人缘好。