python面试题110道

1 、一行代码实现1–100之和

# 等差数列求和
print((1+100)*100/2)
# 列表推导式＋sum()函数
print(sum([i for i in range(1,101)]))

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

# 在函数内部将该变量声明为全局变量
count = 30888 #麦叔粉丝数

# 关注
def guanzhu():
    global count
    count = count + 1
    print('麦叔的粉丝数是{}'.format(count))

# 取关
def quguan():
    global count
    count = count - 1
    print('麦叔的粉丝数是{}'.format(count))

3 、列出5个python标准库

os,random,math,zipfile,gzip,time,re,sys

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

# 删除
dict.pop()
# 合并
d = {**dict1, **dict2}	# python3.5+

import collections.ChainMap
d = dict(ChainMap(dict1, dict2))

import itertools.chain
d = dict(chain(dict1.items(), dict2.items()))

# 字典推导式
d = {k:v for d in [d1, d2] for k,v in d.items()} 

5 、谈下python的GIL

GIL是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器(加了一把锁即GIL)，使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程遇到IO操作、time tick到期，主动释放GIL。
在一个现代多核心的处理器上，原来只能等待的线程任务，现在可以在其它空闲的核心上调度并发执行。由于古老GIL机制，如果线程2需要在CPU 2 上执行，它需要先等待在CPU 1 上执行的线程1释放GIL（记住：GIL是全局的）。如果线程1是因为 IO阻塞让出的GIL，那么线程2必定拿到GIL。但如果线程1是因为timer ticks计数满100让出GIL，那么这个时候线程1和线程2公平竞争。

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

l = list(set(list1))	# 无序

old_list = [2, 3, 4, 5, 1, 2, 3]
new_list = list(set(old_list))
new_list.sort(key=old_list.index)

l = list(dict.fromkeys(list1))	# 借助字典

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

*args 用来存放元组参数
**kwargs 用来存放字典参数

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

python2中range(100)生成一个0-99的列表
python3中range(100)生成一个迭代器，利用迭代器的惰性加载原理，当发生实际调用时才开辟内存空间，可以节约很多内存。

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

能够实现闭包的语言，理论上都可以用装饰器。
闭包：如果在一个外函数中定义了一个内函数，内函数中引用了外函数的临时变量，并且外函数的返回值是对内函数的引用。这样就构成了闭包。

10 、python内建数据类型有哪些

数字（整数，浮点，布尔，复数），序列对象（字符串，元组，列表），字典，文件，集合
可变数据类型：字典，列表，集合
不可变数据类型：数字，元组，字符串

11 、简述面向对象中 __ new __ 和 __ init __ 区别

__new__ 在创建对象实例时使用，
__init__ 在创建对象实例后，对实例初始化时调用

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

常规的f.open()写法中需要try,except,finally,不管什么情况最终都会执行finally f.close()，
with方法帮我们实现了finally中的 f.close()

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

l = [1,2,3,4,5]
l = map(lambda x : x**2, l)
l = [i for i in l if i > 10]
print(l)

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

import random as rd
import numpy as np
i = rd.randint(a, b)
j = np.random.randn()
k = rd.random()

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

r

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

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

17 、python中断言方法举例

a = 9
assert(a > 5)
print("断言成功，继续执行。")

b = 3
assert(b >5)
print("断言失败，程序报错。")

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

select distinct name
from student

19 、10个Linux常用命令

cd 切换盘符
ls 列目录清单
touch 创建文件
chmod 修改文件权限
sudo 以超级用户身份执行命令
cat 查看文件内容
more 查看文件内容
mv 移动文件
tree 树形展示文件目录
ps 
grep 匹配
echo 提取变量
rm 删除
mkdir 创建目录

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

1. python3中print必须使用()包裹打印内容，python2中print可以不用()包裹
2. python3中range()返回迭代器，python2中range()返回列表，xrange()返回迭代器
3. python3中使用'utf-8'编码，python2中使用'ASCII'编码
4. python2中为正常显示中文，引入coding声明，python3中不需要
5. python3中str表示字符串序列，byte表示字节序列，python2中unicode表示字符串序列，str表示字节序列
6. python3中用input(),python2中是raw_input()

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

可变数据类型：列表，字典，集合
允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
不可变数据类型：数字，元组，字符串
不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址）

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

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

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

a = 1
b = 2
c = lambda x,y : x*y

24 、字典根据键从小到大排序

dict1 = sorted(dict1.items(), key = lambda kv : kv[0])
dict1 = dict(dict1)
print(dict1)

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

from collections import Counter
res = Counter(str1)
print(res)

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

a = "not 404 found 张三 99 深圳"
a_list = a.split(' ')
import re
res = re.findall("\d+|[a-zA-Z]+",a)
#
b = " ".join(list(set(a_list)-set(res)))
print(b)
#
chinese = '[\u4e00-\u9fa5]+'
res = re.findall(chinese, a)
print(" ".join(res))
#

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

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in filter(lambda i : i%2 == 1, a) :
    print(i, end = ' ')

#
迭代器优点：
1. 提供了一种通用不依赖索引的迭代取值方式；
2. 节省内存，迭代器在内存中相当于只占一个数据的空间：因为每次取值都上一条数据会在内存释放，加载当前的此条数据。
迭代器缺点：
1. 因为有next方法，即只能往后取值,不能往前，取值不如按照索引的方式灵活，不能取指定的某一个值；
2. 无法预测迭代器的长度

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

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

29 、正则re.complie作用

re.compile()将正则表达式编译成一个对象，加快速度并实现复用

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

a 是元组
b 是int数字类型
c 是str字符串类型

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

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

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

os.remove(文件名)

rm

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

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

34 、数据库优化查询方法

使用索引；优化sql语句；优化数据库对象：优化表的数据类型，垂直拆分与水平拆分

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

matplotlib

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

class myException(Exception) :
    def __init__(self, message) :
        self.message = message
        
    def __str__(self) :
        return self.message
    
try :
    raise myException("这是一个自定义异常类！")
except myException as e:
    print(e)

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

（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配
import re
str1 = "<a>哈哈</a><a>呵呵</a>"
a = re.findall("<a>(.*)</a>",str1)
b = re.findall("<a>(.*?)</a>", str1)
print(a)
print(b)

38 、简述Django的orm

ORM即对象关系映射，通俗地讲，就是将模型类转化成数据库中的关系表，建立起模型类与数据库之间的关系。

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

list1 = [j for i in [[1,2],[3,4],[5,6]] for j in i]

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

x.join(y): dabceabcf
x.join(z): dabceabcf

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

try用来捕获程序可能发生的异常，except捕获发生异常的类型，给出一些异常信息，
else是在程序未抛出异常时才会执行，finally无论程序是否抛出异常都会执行。

42 、python中交换两个数值

a=1
b=2
a,b = b,a

43 、举例说明zip（）函数用法

a = (a,b,c)
b = (1,2,3)
c = zip(a,b)
将两个等长的可迭代对象两两结合成一个元组

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

import re
a="张明98分"
a = re.sub(r'[0-9]+','100', a )
print(a)

45 、写5条常用sql语句

select *
from table_name

insert into table_name
values(column1 = value1, column2 = value2, ...)

delete from table_name
where column1 = value1, column2 = value2, ...

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

create table table_name

46 、a="hello"和b="你好"编码成bytes类型

a="hello"
b="你好"
print(a.encode('utf-8'))
print(b.encode('utf-8'))

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

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

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

多线程，进程并行编程；优化算法的时间；优化循环

49 、简述mysql和redis区别

mysql是关系型数据库，用表格存储数据，支持SQL结构化查询语言，有多种变量类型，持久性存储在磁盘。
Redis是键值对数据库，键值对存储数据，通过一组命令操作数据，提供基本的变量类型，存储在内存中，主要用于高并发场景，缓存和实时数据处理。

50 、遇到bug如何处理

首先应分析错误日志，大概定位问题；
其次可以通过打断点调试，找到代码的逻辑问题；
通常也可以加入一些打印信息或注释掉一些代码来确定问题在哪里出错。

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

r"[\d]+-[\d]+-[\d]"

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

# 任选一种排序算法 ——快排

# 法一
list=[2,3,5,4,9,6]
def quick_sort(list):
    if len(list)<2:
        return list
    else:
        pivot=list[0]
        less=[i for i in list[1:] if i<=pivot]
        greater=[i for i in list[1:] if i>pivot]
        return quick_sort(less)+[pivot]+quick_sort(greater)

print(quick_sort(list))

# 法二
list=[2,3,5,4,9,6]
def partition(list, low, high):
    pivot = list[low]
    while low < high:
        while low < high and list[high] >= pivot:
            high -= 1
        list[low] = list[high]
        while low < high and list[low] <= pivot:
            low += 1
        list[high] = list[low]
        
    list[low] = pivot
    return low


def quick_sort(list, low, high):
    if low < high:
        pivot_index = partition(list, low, high)
        quick_sort(list, low, pivot_index - 1)
        quick_sort(list, pivot_index + 1, high)

quick_sort(list,0,len(list)-1)
print(list)

53 、写一个单列模式

# 单例模式
class OnePattern:
    # 通过类属性来记录是否已经有对象被初始化
    # 类属性是共享的，当创建第一个对象时，类属性得到初始化，可以作为单例模式的依据
    instance = None
    # 记录是否执行过初始化动作
    init_flag = False
    
    def __new__(cls):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance
    
    def __init__(self):
        if not OnePattern.init_flag:
            print("初始化对象")
            OnePattern.init_flag = True

player1 = OnePattern()
print(player1, OnePattern.instance)
player2 = OnePattern()
print(player2, OnePattern.instance)

54 、保留两位小数

a = 0.775
a = round(a,2)

55 、求三个方法打印结果

print(f'{v1,v2}')
print('%d,%s',v1,v2)
print("{},{}".format(v1,v2))

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

200 请求成功
204 请求成功，但服务器未返回内容 
301 资源被永久转移到其它URL
404 请求资源不存在
500 服务器错误

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

前端：减少http请求。
后端：采用异步ajax方式；设计合理的浏览器缓存的内容；代码上进行优化，减少循环和判断。
数据库：内存数据库Redis，建立索引外键等。

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

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

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

InnoDB是MySQL默认的存储引擎，它支持事务处理、外键约束和并发控制。它是一个可靠的选择，适用于大多数应用，特别是需要数据完整性和事务支持的应用。
Aria引擎是MySQL 5.5版本后引入的一种存储引擎，它支持事务和数据表级锁定，可以作为InnoDB的替代品。
MyISAM是一个较早的存储引擎，它不支持事务处理和外键约束，但在读取频繁的应用中性能较好。它适用于只读或很少更新的数据表。
MEMORY引擎将数据存储在内存中，因此读取速度非常快。但由于数据存储在内存中，如果MySQL服务重新启动，数据将丢失。这个引擎适用于缓存数据或临时存储。

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

alpha = ['a','b','c','d','e']
digits = [1,2,3,4,5]
res = list(zip(alpha, digits))

61 、简述同源策略

与同源策略相对的是跨域访问，跨域访问是指前端访问与其不同源的后端，通常被浏览器禁止。同源策略是浏览器的一项基本的安全功能，同源是指协议、域名、端口号三者相同。在前后端分离的开发中通常需要在项目中设置非安全浏览器进行调试。

62 、简述cookie和session的区别

cookie存储在客户端；session存储在服务器端。
cookie保存用户的一些信息，在向服务器发起请求时浏览器会携带cookie一并发送，cookie可以设置过期时间；session代表服务器和客户端一次会话的过程，当客户端关闭会话，或者Session超时失效时会话结束。

63 、简述多线程、多进程

多线程是指一个进程启动多个子线程来执行，线程必须依赖于进程存在，多线程共享同一个进程的资源，更轻量级，切换速度比进程快，在多核cpu上多线程可以真正意义上实现并行执行，python中由于GIL限制，所以同一个进程的多个线程无法在多核上同时运行。
多进程是指多个可以并行执行的进程，多进程之间的资源相互独立，进程之间不共享资源，切换速度慢，可以实现的并行执行。

64 、简述any()和all()方法

any()当迭代器有一个元素为真就返回True,all()当迭代器所有元素都为真返回True，否则返回False。

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

IOError是IO读写异常，通常发生在读写磁盘时。
AttributeError是属性异常，代表调用的对象属性或方法不存在。
ImportError是导入异常，导入的包名或模块名不存在。
IndentationError是缩进异常，代码的某行缩进没有符合规范。
IndexError取下标异常，索取下标不存在或越界。
KeyError关键字异常，可能是字典键不存。
SyntaxError语法异常，代码编写不符合语法要求。
NameError命名异常，使用一个还没有赋予对象的变量（未创建的变量）。

66 、python中copy和deepcopy区别

copy做的是浅拷贝，只拷贝第一层。
deepcopy做的是深拷贝，它会逐层拷贝。

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

__new__用于为初始化对象分配地址空间，可以用来编写单例模式。
__init__用于初始化对象的构造函数，当创建新对象时，该方法会自动调用。
__str__用于返回用户可以看懂的对象字符串描述。
__repr__返回为开发人员调试的对象字符串提示信息。
__next__返回迭代器的下一个元素。
__iter__返回一个迭代器对象，用于在对象上进行迭代。
__call__允许对象像函数一样被调用，对象+()的方式来调用这个函数。
__del__在对象被销毁时调用，一般用来在这个方法里记录一些日志。
__module__查看对象属于哪个模块，如果在本模块中调用，就为__main__。
__doc__提供文档描述信息。

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

['C:\Users\ry-wu.junya\Desktop>python', 22, 33]

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

def generator(num):
    i = 0
    if i < num:
        yield i
    i += 1
generator(3)

70 、a = " hehheh ",去除收尾空格

a = " hehheh "
a = a.strip()

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

list1=[0,-1,3,-10,5,9]
print(sorted(list1)) # 返回排序好的列表
list1=[0,-1,3,-10,5,9]
list1.sort() # 就地排序，返回None

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]
sorted(foo, key = lambda x: x)

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]
sorted(foo, key = lambda x: (x<0, abs(x))) # 先按正负性排，再按绝对值大小排序

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

from operator import itemgetter
dic = [
        {"name": "Bob", 'age': 24},
        {"name": "xiao", 'age': 26},
        {"name": "job", 'age': 28},
        {"name": "luke", 'age': 22},
    ]
dic = sorted(dic, key=itemgetter('age','name'))
print(dic)

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

mylist = [
    ('a', 2),
    ('b', 1),
    ('d', 3),
    ('d', 2),
    ('c', 10)
]
mylist = sorted(mylist, key=lambda x: (x[0],x[1]))
print(mylist)

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

年龄数字相同时可以按照其他字段排序。

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

mydict = {
    'name': 'Bob',
    'age': 23,
    'email': '123@qq.com',
    'fan': 'kkk'
}
mydict = dict(sorted(zip(mydict.keys(), mydict.values())))
print(mydict)

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

mydict = {
    'name': 'Bob',
    'age': 23,
    'email': '123@qq.com',
    'fan': 'kkk'
}
mydict = dict(sorted(mydict.items(), key=lambda x: x[0]))
print(mydict)

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

[i for i in range(10)]
{i: i+1 for i in range(10)}
函数里用yield替换return

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

sorted(str, key=lambda x: len(x))

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

# cursor是连接到数据库后返回的对象
sql = "1 or 1"
count = cursor.execute("select * from classes where id = " + sql)  # sql注入

# python支持传参数的方式来自动检测sql注入
args = ('2',)
count = cursor.execute("select * from classes where id = %s",args)

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

import re
s = "info:xiaoZhang 33 shandong"
result = re.split(r'[:\s]+', s)
print(result)

83 、正则匹配以http://***163.com结尾的邮箱

import re
s = "http://****163.com"
result = re.match(r'http://.+163.com$', s)
print(result.group())

84 、递归求和

def digui(nums):
    if not nums:
        return 0
    else:
        return nums[0] + digui(nums[1:]) # 切片时取不到返回空列表
l = [1,2,3,4,5]
print(digui(l))

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

import json
# JSON字符串
json_string = '{"name": "John", "age": 30, "city": "New York"}'
# 将JSON字符串转换为字典
data = json.loads(json_string)
print(data)

import json
# 从JSON文件加载数据到字典
with open('data.json', 'r') as json_file:
    data = json.load(json_file)
print(data)

import json
# 要保存的字典数据
data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}
# 将字典保存到JSON文件
with open('data.json', 'w') as json_file:
    json.dump(data, json_file)

86 、MyISAM 与 InnoDB 区别：

InnoDB是MySQL默认的存储引擎，它支持事务处理、外键约束和并发控制。它是一个可靠的选择，适用于大多数应用，特别是需要数据完整性和事务支持的应用。
MyISAM是一个较早的存储引擎，它不支持事务处理和外键约束，但在读取频繁的应用中性能较好。它适用于只读或很少更新的数据表。

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

s = 'asrfdasdasdasda'
s.count('a')

88 、字符串转化大小写

s = 'asrfdasdasdasda'
s.upper()
s.lower()

89 、用两种方法去空格

s = ' asrfdasdasdasda '

s.replace(" ", '')

l = s.split(" ")
s = ''.join(l)

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

import re 
phone_numbers = [
    "1234567890",
    "9876543214",
    "5556667774",
    "8889990007",
    "1234567000",
]
for s in phone_numbers:
    res = re.match(r'[0-9]+[0-35689]$', s)
    if not res:
        continue
    print(res.group())

91 、简述python引用计数机制

引用计数：对于同一个对象，每增加一个引用则引用计数加1，引用计数为0，对象就会释放。

对于整型数，python设计了一个常量池，取-5-255之间的值只会增加引用计数。
对于字符串，python维护一个字典，每次创建新的字符串对象都会与已有字典比较，如果没有则创建，重复就直接引用。
对于浮点数，每次创建都开辟新的内存空间。
对于tuple，一般情况重新分配空间，如果以t1=(xxx)的形式创建，地址空间一致。
可变数据类型每次创建都会重新开辟地址空间。

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

int('1.4')会报错，无法将小数字符串变为整型数。
int(1.4)输出1，浮点数可以强制截断。

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

类名与异常名用大驼峰命名
变量名，函数名等下划线命名
全局常量与全局变量用全大写单词命名

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

s = "Here is a URL: https://www.example.com and some text afterwards."
import re 
res = re.search(r"http[s]?://www[a-zA-Z0-9$-_@.&+]+", s)
print(res.group())

95 、正则匹配中文

import re
s = "这是一段包含中文的文本。asdasd"

pattern = r'[\u4e00-\u9fa5]+'
res = re.findall(pattern, s)
print(res)

96 、简述乐观锁和悲观锁

使用乐观锁通常适用于并发冲突较少的情况，可以提高性能，但需要额外的冲突解决机制。
使用悲观锁通常适用于并发冲突较常见或对数据一致性要求较高的情况，但可能会导致性能瓶颈。

乐观锁（Optimistic Locking）：
假设多个线程或进程之间的冲突是不常见的，因此先进行读取操作，然后在更新资源时才会检查是否发生了冲突。
在进行更新之前，通常会记录资源的版本号或时间戳。在提交更新时，会检查当前资源的版本号是否与之前记录的版本号相匹配。
如果版本号匹配，说明没有冲突，可以成功更新。如果版本号不匹配，说明其他线程已经修改了资源，操作失败，需要进行冲突解决。
乐观锁通常用于读多写少的情况，可以减少锁的争用，提高并发性能。

悲观锁（Pessimistic Locking）：
假设多个线程或进程之间的冲突是常见的，因此在访问资源之前就会加锁，以防止其他线程同时访问。
在悲观锁下，资源被锁定，其他线程必须等待锁的释放才能访问资源，这可能导致竞争和性能下降。

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

r模式只读
r+模式读写
rb模式以字节流读
rb+模式以字节流读写

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

> 标准输出重定向，将输出内容重定向文件（覆盖方式）
>> 标准追加输出重定向，将输出内容重定向文件（追加方式）

99 、正则表达式匹配出

http://www.cskaoyan.com

import re
s = '<html><h1>http://www.cskaoyan.com</h1></html>'
ret = re.match(r'<([a-zA-Z0-9]*)><([a-zA-Z0-9]*)>.*</\2></\1>', s)
print(ret.group())

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

Python参数传递采用的是“传对象引用”的方式。 实际上，这种方式相当于传值和传址的一种综合。 如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于传址。 如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于传值。当然不可变对象也是对象，如果广义的理解，可以都理解为传地址，只是有些地址的值不可以修改（不可变对象）而有些可以（可变对象）。

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

list1 = [1,3,5,7,9]
list2 = [2,1,4,8,10]
# 交集
res = list(set(list1)&set(list2))
print(res)
# 并集
res = list(set(list1)|set(list2))
print(res)
# 差集
res = list(set(list1)-set(list2))
print(res)
res = list(set(list2)-set(list1))
print(res)

102 、生成0-100的随机数

import random
n = random.randint(0, 100)

103 、lambda匿名函数好处

可以使代码变得简洁
lambda函数只是在某个特定的地方的需求，不需要在为其单独定义一个函数，方便了代码编写与查看。

104 、常见的网络传输协议

HTTP超文本传输协议，是互联网上运用最为广泛的协议。
TCP、UDP协议
FTP文本传输协议
DHCP动态主机配置协议

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

单引号和双引号都可以表示字符串，若要表示的字符串中有单引号外层就用双引号引用，反之就用单引号
三引号可以用来表示有换行的段落文本。

106 、python垃圾回收机制

当一个对象的引用计数为0时，python会自动回收销毁对象。

107 、HTTP请求中get和post区别

get是请求信息，不携带网页内容。
post请求时会携带网页中用户输入的内容。

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

import pandas as pd
pd.read_excel('data.xlsx')

109 、简述多线程、多进程

多线程是指一个进程启动多个子线程来执行，线程必须依赖于进程存在，多线程共享同一个进程的资源，更轻量级，切换速度比进程快，在多核cpu上多线程可以真正意义上实现并行执行，python中由于GIL限制，所以同一个进程的多个线程无法在多核上同时运行。
多进程是指多个可以并行执行的进程，多进程之间的资源相互独立，进程之间不共享资源，切换速度慢，可以实现的并行执行。

110 、python正则中search和match

search查找不用从头匹配，
而match匹配时要求从开始匹配。