python面试题(二)

一行代码实现将 1-N 的整数列表以 3为单位分组

[[x for x in range(1,N+1)][i:i+3] for i in range(0,len(N),3)]

用Python匹配HTML tag的时候，<.>和<.?>有什么区别？

术语叫贪婪匹配( <.> )和非贪婪匹配(<.?> )

例如:

test

<.*> :

test

<.*?> :

单引号，双引号，三引号的区别

答：单引号和双引号是等效的，如果要换行，需要符号(),三引号则可以直接换行，并且可以包含注释

如果要表示Let’s go 这个字符串

单引号：s4 = ‘Let\’s go’

双引号：s5 = “Let’s go”

s6 = ‘I realy like“python”!’

这就是单引号和双引号都可以表示字符串的原因了

4G内存怎么读取一个5G的数据？

方法一： 可以通过生成器，分多次读取，每次读取数量相对少的数据（比如500MB）进行处理，处理结束后 在读取后面的 500MB的数据。
方法二： 可以通过linux命令split切割成小文件，然后再对数据进行处理，此方法效率比较高。可以按照行 数切割，可以按照文件大小切割。

现在考虑有一个jsonline格式的文件file.txt大小约为10K，之前处理文件的代码如下所示

> 1. def get_lines(): 
> 2. l = [] 
> 3. with open(‘file.txt’，‘rb’) as f: 
> 4. 		for eachline in f: 
> 5. 			l.append(eachline) 
> 6. 		return l 
> 7. if __name__ == ‘__main__’: 
> 8. 		for e in get_lines(): 
> 9. 			process(e) #处理每一行数据 

现在要处理一个大小为 10G 的文件，但是内存只有 4G，如果在只修改 get_lines 函数而其他代
码保持不变的情况下，应该如何实现？需要考虑的问题都有哪些？

1. def get_lines(): 
2. l = [] 
3. with open(‘file.txt’，’rb’) as f: 
4. data = f.readlines(60000) 
5. 		l.append(data) 
6. 		yield l

要考虑到的问题有：
内存只有4G无法一次性读入10G的文件，需要分批读入。分批读入数据要记录每次读入数据的位
置。分批每次读入数据的大小，太小就会在读取操作上花费过多时间。

python文件操作

1．def print_directory_contents(sPath): 
2． """ 
3． 这个函数接收文件夹的名称作为输入参数 
4． 返回该文件夹中文件的路径 
5． 以及其包含文件夹中文件的路径 
6． """ 
7． # 补充代码 
8． ------------代码如下-------------------
9． import os 
10．for sChild in os.listdir(sPath): 
11． 	sChildPath = os.path.join(sPath, sChild) 
12． 	if os.path.isdir(sChildPath): 
13． 		print_directory_contents(sChildPath) 
14． 	else: 
15． 		print(sChildPath)

赋值、浅拷贝和深拷贝的区别

一、赋值
在Python中，对象的赋值就是简单的对象引用，这点和C++不同，如下所示：
a = [1,2,“hello”,[‘python’, ‘C++’]]
b = a
在上述情况下，a和b是一样的，他们指向同一片内存，b不过是a的别名，是引用。
二、浅拷贝(shallow copy)
浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象的引用。
浅拷贝有三种形式:切片操作、工厂函数、copy模块中的copy函数。
比如上述的列表a；
切片操作：b = a[:] 或者 b = [x for x in a]；
工厂函数：b = list(a)；
copy函数：b = copy.copy(a)；
浅拷贝产生的列表b不再是列表a了，使用is判断可以发现他们不是同一个对象，使用id查看，
他们也不指向同一片内存空间。但是当我们使用id(x) for x in a 和 id(x) for x in b来查看a和b 中元
素的地址时，可以看到二者包含的元素的地址是相同的。
在这种情况下，列表a和b是不同的对象，修改列表b理论上不会影响到列表a。
但是要注意的是，浅拷贝之所以称之为浅拷贝，是它仅仅只拷贝了一层，在列表a中有一个嵌套的
list，如果我们修改了它，情况就不一样了。
比如：a[3].append(‘java’)。查看列表b，会发现列表b也发生了变化，这是因为，我们修改了嵌
套的list，修改外层元素，会修改它的引用，让它们指向别的位置，修改嵌套列表中的元素，列表的地
址并未发生变化，指向的都是用一个位置。
三、深拷贝(deep copy)
深拷贝只有一种形式，copy模块中的deepcopy()函数。
深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空
间开销要高。
同样的对列表a，如果使用 b = copy.deepcopy(a)，再修改列表b将不会影响到列表a，即使嵌
套的列表具有更深的层次，也不会产生任何影响，因为深拷贝拷贝出来的对象根本就是一个全新的对象，
不再与原来的对象有任何的关联。

打乱一个排好序的list对象 alist

1. import random
2. random.shuffle(alist)

Python是强语言类型还是弱语言类型

Python 是强类型的动态脚本语言。
强类型：不允许不同类型相加。
动态：不使用显示数据类型声明，且确定一个变量的类型是在第一次给它赋值的时候。
脚本语言：一般也是解释型语言，运行代码只需要一个解释器，不需要编译。

Python中的作用域？

Python中，一个变量的作用域总是由在代码中被赋值的地方所决定。当Python遇到一个变量的话
它会按照这的顺序进行搜索：
本地作用域(Local)—>当前作用域被嵌入的本地作用域(Enclosing locals)—>全局/模块作用域
(Global)—>内置作用域(Built-in)。

在linux中find和grep的区别

Linux系统中grep命令是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行
打印出来。
grep全称是Global Regular Expression Print，表示全局正则表达式版本，它的使用权限
是所有用户。
linux下的find：
功能：在目录结构中搜索文件，并执行指定的操作。此命令提供了相当多的查找条件，功能很强大。
语法：find 起始目录寻找条件操作
说明：find命令从指定的起始目录开始，递归地搜索其各个子目录，查找满足寻找条件的文件并对
之采取相关的操作。
简单点说说，grep是查找匹配条件的行，find是搜索匹配条件的文件

git合并文件有冲突，如何处理?

1、git merge 冲突了，根据提示找到冲突的文件，解决冲突如果文件有冲突，那么会有类似的标
记
2、修改完之后，执行 git add 冲突文件名
3、git commit 注意:没有-m 选项 进去类似于 vim 的操作界面，把conflict 相关的行删除掉
直接 push 就可以了，因为刚刚已经执行过相关 merge 操作了。

现有字典 d={‘a’:24，‘g’:52，‘i’:12，‘k’:33}请按字典中的 value值进行排序？

sorted(d.items()，key = lambda x:x[1]) 。

说一下字典和json的区别？

字典是一种数据结构，json是一种数据的表现形式，字典的key值只要是能hash的就行，json的 必须是字符串。

什么是可变、不可变类型

可变不可变指的是内存中的值是否可以被改变，不可变类型指的是对象所在内存块里面的值不可以
改变，有数值、字符串、元组；可变类型则是可以改变，主要有列表、字典。

请反转字符串"aStr"

print(‘aStr’[::-1])

请按alist中元素的age由大到小排序

1. alist [{‘name’:‘a’，‘age’:20}，{‘name’:‘b’，‘age’:30}，{‘name’:‘c’，‘age’:25}]
   2.def sort_by_age(list1):
   return sorted(alist，key=lambda x:x[‘age’]，reverse=True)

给定两个list A ,B，请用找出 A ,B中相同的元素，A ,B中不同的元素

A、B 中相同元素：print(set(A)&set(B))
A、B 中不同元素：print(set(A)^set(B))