超详细整理python面试题（基础前30道）

---

1.一行代码实现1-100之和

利用sum（）函数求和

sum(range(1,101))

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

利用global在函数声明修改全局变量

a=5
def fn():
	global a
	a=4
fn()
print(a)

全局变量：在函数外或全局空间中生命的变量成为全局变量
局部变量：在函数内声明的任何变量都称为局部变量。

3.列出5个标准python库

os:提供了不少与操作系统有关的函数
sys:通常用于命令行参数
re:正则匹配
math：数字运算
datatime：处理日期时间

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

del 和update 方法

dic={"name":"2s","age":18}
del dic["name"]
dic

{'age':18}

dict2={"name":"ls"}
dic.update(dict2)
dic

{'age':18,'name':'ls'}

5.python中列表和元组的区别？

（1）列表是动态数组，可变且可以重新设定长度
（2）元组是静态数组，不可变且长度一旦设定创建无法改变

从设计上来说：
列表是用来保存多个独立对象的数据集合
元组设计初衷是为了描述一个不会改变的事物的多个属性

列表常见操作：

1. 增加一项append:
2. 统计某个元素在列表中出现的次数count
3. 列表扩展，将一个列表追加到另一个原来的列表上 extend
4. 获取列表的索引 index（第一次出现的索引）
5. 向指定索引处插入指定元素insert（index，element）
6. 删除指定的元素pop（）并且返回的是删除之后的元素
7. 反转整个列表reverse
8. 对列表进行排序，直接在原列表上进行排序，默认按照元素的首字母进行排序sort，默认是升序排序。

元组常见操作：

1. 创建空元组 tup=()

2. 创建只有一个元素的元组时，需要在后面加逗号tup=(1,)

3. 将列表转换为元组，使用tuple()

4. 查询：tup[1:]
   tup[:-1] 包括前面，不包括后面
   tup[1::-1] 没有结尾，表示切片到最后一位
   tup[::-1] 表示倒序，从结尾到开头

5. 删除元组的元素不支持删除，但是可以删除整个元祖对象
   del tup[0] 不支持
   del tup 支持

6. 统计元祖中某个元素出现的个数 count tup.count

7. 查询元素的索引位置 tup.index

8. 元组的更新：元组是不可变得，元组一旦被定义，里面的元素和个数就不能改变了。

结论
列表中声明使用中括号，元组使用小括号，并且元组只有一个元素时要加逗号

列表是可变的，元组不可变，元组一旦被定义，里面的元素和个数就不能改变了。

补充：
数组和列表区别：
数组和列表具有相同的存储数据格式，但是，数组只能包含单个数据类型的元素，而列表可以包含任何数据类型和元素。

6.谈下Python的GIL

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

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

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

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

lis=[11,12,13,12,15,16,13]
a=set(lis)
a

{11,12,13,15,16}

[x for x in a]

[11,12,13,15,16]

8.fun(args,**kwargs）中的args,**kwargs是什么意思？

   args是arguments的缩写，表示位置参数；kwargs是keyword arguments的缩写，表示关      
   键字参数，这其实就是python中可变参数的两种形式，并且*args必须放在**kwargs的前
   面， 因为未知参数在关键字参数前面。

*args的用法：
args就是传递一个参数列表给函数实参，这个参数列表的数目未知，甚至长度可以为0

def test_args(first,*args):
	print('Required argument:',first)
	print(type(args))
	for v in args:
		print('Optional argument:',v)
test_args(1,2,3,4)

第一个参数是必须传入的参数，所以使用了第一个形参，而后面三个参数则作为可变参数列
表传入了实参，并且是作为元组tuple来使用的。

Required argument:1
<'class tuple'>
Optional argument:2
Optional argument:3
Optional argument:4

**kwargs的用法
**kwargs 则是将一个可变的关键字参数的字典传给函数实参，同样参数列表长度可以为0或其他值

def test_kwargs(first,*args,**kwargs):
	print('Required argument:',first)
	print(type(kwargs))
	for v in args:
		print('Optional argument args):',v)
	for k,v in kwargs.items():
		print('Optional argument %s(kwargs):%s'%(k,v))
test_kwargs(1,2,3,4,k1=5,k2=6)

正如之前所说的，args类型是一个tuple，而kwargs则是一个字典dict,并且args只能位于kwargs前面

Required argument:1
<class 'dict'>
Optional argument(args):2
Optioanl argument(args):3
Optioanl argument(args):4
Optional argument k2 (kwargs):6
Optional argument k1 (kwargs):5

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

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

10.python内建数据类型

整型–int
布尔型–bool
字符串–str
列表–list
元组–tuple
字典–dict

11.一句话解释什么的语言能够使用装饰器

函数可以作为参数传递的语言

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

f=open(".//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(".//txt","wb")as f:
	cncent=f.read()

with方法保证在打开文件的前提下，无论是文件的读写过程中是否出现错误，最终都会调用close方法，避免文件描述符被占用，浪费系统资源，如果我们不适用with方法，就要用try方法来避免错误。

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

man()函数第一个参数是fun,第二个参数一般是list,第三个参数可以写List，也可以不写

lis=[1,2,3,4,5]
def fn(x):
	return x**2
res=map(fn,lis)
res


res=[i for i in res if i>10]
res

list1=[1,2,3,4,5]
list2=list(map(lambda x: x*x,list1))
print(list2)
list3=[x for x in list2 if x>10]
print(list3)

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

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

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

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

在字符串的前面加上字母r,例如r"/n"，表示的就是反斜杠和字母n的组合

16.

中国

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

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

17.python中断言方法举例

assert（）方法，断言成功，则程序继续执行，断言失败，则程序报错

a=3
assert(a>1)
print("断言成功，程序继续向下执行”）
b=4
assert(b>7)
print("断言失败，程序报错”）

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

select distinct name from student

19.10个linux常用命令

1. ls命令
   就是list的缩写，通过ls命令不仅可以查看linux文件夹中包含的文件，而且可以查看文件权限（包括字母，文件夹，文件权限）查看目录信息等等。

2. cd命令
   cd[目录名] 切换当前目录至dirName

3. pwd命令
   查看当前工作目录路径

4. mkdir命令
   用于创建文件夹

5. rm命令
   删除一个目录中的一个或多个文件或目录。如果没有一r选项，则rm不会删除目录，如果使用rm来删除文件，通常可以将文件恢复原状。

6. rmdir命令
   从一个目录中删除一个或多个子目录项，删除某目录时也必须具有对其父目录的写权限。
   注意：不能删除非空目录

7. mv命令
   移动文件或修改文件名，根据第二参数类型（如目录，则移动文件；如为文件则重命令该文件）

当第二个参数为目录时，第一个参数可以是多个以空格分隔的文件或目录，然后移动第一个参数指定的多个文件到第二参数指定的目录中。

1. cp命令
   将源文件复制至目标文件，或将多个源文件复制至目标目录。
   注意：命令行复制，如果目标文件已经存在会提示是否覆盖，而在shell脚本中，如果不加-i参数，则不会提示，而是直接覆盖。

2. cat命令
   cat主要有三大功能：
   （1）一次显示整个文件
   （2）从键盘创建一个文件
   （3）将几个文件合并为一个文件

3. head命令
   用来显示档案的开头至标准输出中，默认head命令打印其相应文件的开头10行。

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

1. python3使用print必须要以小括号包裹打印内容，比如print（‘hi’）
   python2既可以使用带小括号的方式，也可以使用一个空格来分割打印内容，比如‘print hi’

2. python 2 range(1,10)返回列表，python3中返回迭代器，节约内存

3. Python2 中使用ascii 编码，python3中使用utf-8编码

4. Python 2中unicode 表示字符串序列，str表示字节序列
   python3中str表示字符串序列，byte表示字节序列

5. python2中为正常显示中文，引入coding声明，python3中不需要

6. Python2中是raw_input()函数，python3中是Input（）函数

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

1.不 可变数据类型：数值型，字符串型，和元组
不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，通过增加引用计数，来表示引用方式的增加而实际上在内存中则只有一个对象（一个地址），即这些引用都指向同一个地址。

a=1
b=1  #不会新建对象，数值1内存增加一个引用计数，此时a,b均指向同一个地址，即a,b引用共享内存
c=2   #新建对象
id(a),id(b),id(c)


(1932714840,193274840,1932749872)

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

a=[1,2]
b=[1,2]   #为b开辟新的内存区，而不是增加引用计数；a,b是两个独立的对象
print(id(a),id(b)
c=[1,2,3]   #不同的值，当然是独立的
id(c)

411517650760        411517650696
41141750504

22.s=‘ajldjlajfdljfddd’,去重并从小到大排序输出“adfil”

set去重，去重转换成list,利用sort方法排序，reverse=False是从小到大排

s='ajldjlajfdljfddd'
s=set(s)
s=list(s)
s.sort(reverse=False)
res="".join(s)
print(res)

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

sum=lambda a,b :a*b
print(sum(5,4))

24.字符串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)

25.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)

out:[1,3,5,7,9]

26.列表推导法求列表所有奇数并构造新列表

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

out:[1,3,5,7,9]

27.正则re.complie作用

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

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

type((1))

out:int

type(("1"))

out:str

type((1,))

out:tuple

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

extend可以将另一个集合中的元素逐一添加到列表中，区别于append整体添加

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

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


out:[1,5,7,9,2,2,6,8]
    [1,2,2,5,6,7,8,9]
    

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

python：os.remove(文件名）

linux: rm 文件名