python基础知识的重点面试题

1、解释型和编译型

"""
- 编译型（需要编译器，相当于用谷歌翻译）：编译型语言执行速度快，不依赖语言环境运行，跨平台差，如C，C++执行速度快，调试麻烦

- 解释型（需要解释器，相当于同声传译）：解释型跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行，如python，JAVA执行速度慢，调试方便 
"""

2、python2和python3的区别(重点)

"""
1、python2有长整型long,python3没有长整型全为int
2、python3中的input全是str类型，而python2得声明你输入的类型
3、python2的str本质是8个bit的序列，python3本质是Unicode
4、python2的默认编码是ascll，python3默认编码是utf-8
5、python2中没有nonlocal,python3中新增了nonlocal使得非局部变量变得可能
"""

3、实现字符串的反转（重点）

"""
name='张全蛋'
name[::-1]
"""

4、文件操作时：xreadlines和readlines的区别？（重点）

"""
readlines()是把文件的全部内容读到内存，并解析成一个list，单文件的体积很大的时候，需占用很大的内存
xreadlines()则是直接返回一个iter迭代器，在python2.3之后就不推荐使用这种写法，直接for循环迭代文件对象
"""

5、is和==的区别？（重点）

"""
is比较的是id（id相同值一定相同）
==比较的是值（值相同id不一定相同）

"""

6、dict={'a':24, 'g':52, 'i':12, 'k':33},按字典中的value值进行排序(重点)

"""
sorted(dict.items(), key=lambda x:x[1])
"""

7、什么是可变，不可变类型？()

"""
可变不可变指的是内存中的值能否被改变
不可变类型指的是对象所在的内存中的值是不可以被改变的，有数字类型（int、float），字符串，元祖
可变类型主要有：列表，字典，集合
"""

8、请将list1中的元素按照age由大到小排序（重点）

"""
list1 = [{'name':'a','age':20}, {'name':'b','age':30}, {'name':'c','age':25}]

sorted(list1，key=lambda x:x['age']，reverse=True)  # reverse默认是false
"""

9、下面代码的输出结果是什么？（重点）

"""
list = ['a'， 'b'， 'c'， 'd'， 'e']
print(list[10:])  # []

print(list[10])  # IndexError
'''
下面的代码将输出[]，不会产生IndexError错误。

不像所期望的那样，尝试用超出成员的个数的index
来获取某个列表的成员。例如，尝试获取list[10]和之后的成员，会导致IndexError。
'''
"""

10、写一个列表生成式，产生一个公差为11的等差数列(重点)

"""
print([x*11 for x in range(10)])
"""

11、给定两个列表，找出相同的元素和不同的元素？

"""
1. list1 = [1,2,3]
2. list2 = [3,4,5]
3. set1 = set(list1)
4. set2 = set(list2)
5. print(set1&set2)  # 或者 print(set1.intersection(set2))  交集
6. print(set1^set2)  # 或者 print(set1.difference(set2)) 差集
"""

12、请写一段python代码实现list去重(重点)

"""
l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
"""

如果还想要保持原来的排序

用list的sort方法

"""
l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index)
print(l2)
"""

13、下面的这段代码的输出结果是什么？请解释？（重点）

"""
def extendlist(val, list=[]):
	list.append(val)
	return list
list1 = extendlist(10)
list2 = extendlist(123, []
list3 = extendlist('a')
print("list1 = %s" %list1)
print("list2 = %s" %list2)
print("list3 = %s" %list3)  # 其实用的还是第一次默认的那个列表
 # 输出结果：
 list1 = [10, 'a']
 list2 = [123]
 list3 = [10, 'a']
"""

14、有一个list['This', 'is', 'a', 'Boy', '!'],所有的元素都是字符串，对他进行大小写无关的排序

"""
l1 = ['This','is','a','Boy','!']
print(sorted(l1))
"""

15、列举字符串，列表，元祖，字典每个常用的5个方法？

"""
字符串：strip, split, len, index, replace,join,upper,lower...
列表：append, pop,insert, extend, remove,sort,count...
元祖：index,count, len, dir,in,
字典：get,keys,values, pop, items,update,popitem,setdefault
"""

16、什么是反射？以及反射的应用场景？（重点）

"""
反射指的是可以通过字符串对对象的属性或方法进行操作
-hasattr:通过字符串判断对象的属性或方法是否存在
-getattr:通过字符串获取对象的属性或方法
-setattr:通过字符串设置对象的属性或方法
-delattr:通过字符串删除对象的属性或方法

应用场景：
反射在很多框架中都被大量使用，比如django的高级文件配置，以及flask的源码中
"""

17、python的深浅拷贝？(重点)

"""
copy()：浅copy，浅拷贝指仅仅拷贝数据集合的第一层数据

deepcopy():深copy,深拷贝指拷贝数据集合的所有层
"""

18、python垃圾回收机制(GC)（重点）

"""
1)引用计数
	当一个对象的引用被创建或者复制时，对象的引用计数加一
	当一个对象的引用被销毁时，对象的引用计数减一
	当对象的引用计数减少为0时，就意味着对象没有被任何人引用，就可以将所占用的内存释放了
优点：简单直观，实时性：没有引用就释放资源
缺点：循环引用时，无法回收，也正是因为这个原因才需要通过标记清除，分代回收来辅助引用计数

2)标记清除
	标记清除是一种基于追踪回收技术实现的一种垃圾回收的算法，该算法分为两个阶段：第一阶段是标记阶段，GC会把所有的活动对象打上标记，第二个阶段：就是把那些没有别标记的非活动对象进行回收
	活动对象：对象之间通过引用连在一起，构成一个有向的图，对象构成这个图的节点，引用关系构成这个图的边。从根节点出发，沿着有向边遍历对象，可达的对象称之为活动对象
	非活动对象：对象之间通过引用连在一起，构成一个有向的图，对象构成这个图的节点，引用关系构成这个图的边。从根节点出发，沿着有向边遍历对象，不可达的对象称之为非活动对象
优点：解决循环引用
缺点：清除非活动对象前，必须先扫描整个内存，哪怕只剩下小部分的活动对象也要扫描所有的对象

3)分代回收
	将系统中的所有内存根据其存活时间的不同划分为不同的集合
	每一个集合就是一个“代”,垃圾的收集频率会随着代的存活时间而减少，活的时间越长的对象，就越不可能是垃圾
	
"""

19、*args和**kwargs

"""
*args是用来接收所有的溢出的位置参数，将接收的参数组织成元祖
**kwargs是用来接收所有的溢出的关键字参数，将接收的参数组织成字典
"""

20、enumerate的作用（重点）

"""
enumerate函数是将一个可迭代对象中的每一个元素，在每一个元素的前面给它增加一个索引值，将其组成一个索引序列，利用它就可以同时获取索引以及索引对应的值，这样做的目的就是为了便于操作
"""

21、列表推导式（重点）

"""
[i for i in range(10)]  列表推导式是用[]表示，得到的是一个新的列表
(i for i in range(10))  生成器表达式使用()表示，得到的是一个生成器对象，可通过list 将其打印出来
"""

22、filter、map、reduce的作用（重点）

"""
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 
filter(lambda x: x>3, [1,2,3,4,5,6]) 
>>> <filter object at 0x0000000003813828>

map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, 
map(lambda a,b: a+b, [1,2,3,4], [5,6,7])
>>> [6,8,10]
                       
reduce(): 函数会对参数序列中元素进行累积。
reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数                                                
>>> 15


map: 映射
    map(函数地址, 可迭代对象) ---> map对象
    map会将可迭代对象中的每一个值进行修改，然后映射一个map对象中，
    可以再将map对象转换成列表/元组。(以第一次要转的类型为主)
    注意: 只能转一次。

reduce: 合并
    reduce(函数地址, 可迭代对象, 初始值默认为0)
    reduce(函数地址, 可迭代对象, 初始值)

filter: 过滤
    filter(函数地址, 可迭代对象) --> filter 对象
"""

23、什么是闭包？（重点）

"""
闭包函数指的是定义在一个函数内部的函数，被外层函数包裹着，其特点是可以引用外层函数的名字，列如下面的inner函数就是一个闭包函数

def outer():
    num = 1
    def inner():
        print(num) # 内层函数中不存在num 但可以访问到外层的num
    return inner # 基于函数对象的概念我们可以将内层函数返回到外界使用，从而打破函数调用的层级限制，但无论在何处调用，作用域的嵌套关系都是以定义阶段为准的，所以外界得到的不仅仅是一个函数对象（inner），在该函数外还包裹了一层作用域，这使得该函数无论在何处调用，都是访问自己外层包裹的作用域中的名字num

func = outer() # func == inner  func指向的是inner的内存地址，但是func本身确实一个全局变量，可以在任意位置调用func，但无论在何处调用func，都需要按照定义阶段作用域的嵌套关系去查找名字

num=1000
func() #输出结果：1 
"""

24、请写一个装饰器，限制该函数被调用的频率如10秒一次(重点)

"""
import time
def time_wrapper(func):
	
	def inner(*args, **kwargs):
		for line in range(10):
			print(line+1)
			time.sleep(1)
		res = func(*args,**kwargs)
		
		return res
	return inner

@time_wrapper
def func1():
	print('from func1...')

func1()
"""

25、生成器迭代器的区别(重要)

"""
生成器：但凡在函数内部调用了yield关键字，在调用函数的时候，函数体代码是不会执行的，会返回一个结果，该结果就是一个生成器，生成器的本质其实也是一个迭代器

迭代器：要想知道什么是迭代器以及迭代器对象，我们得先知道什么是可迭代对象；
	可迭代对象：在python中内置有__iter__方法的都是可迭代对象
	迭代器对象: 执行该方法会得到一个返回值，该返回值就是迭代器对象
				有两个方法__next__,__iter__,所以说迭代器对象一定是可迭代对象，反过来不行
	迭代器： 迭代取值的工具

装饰器：装饰器必须遵循开放封闭的原则
	开放：对函数功能的添加是开放的
	封闭：对函数功能的修改是封闭的
装饰器的作用：在不修改被装饰对象源代码以及调用方式的情况下，添加新的功能
"""

26、请把以下函数转化成python的lambda匿名函数

"""
def add(x,y):
	return x+y
	
# 答：
print(lambda x,y: x+y)
"""

27、日志加装饰器(待考察)

"""

"""

28、谈谈你对闭包的理解

"""
闭包是一个函数式编程的一个重要的语法结构。当一个内嵌函数引用其外部的作用域的变量，我们就会得到一个闭包
创建闭包必须满足一下几点：
	- 必须有一个内嵌函数
	- 内嵌函数必须引用外部函数的变量
	- 外部函数的返回值必须是内嵌函数
"""

29、python函数调用的时候参数传递到底是值传递还是引用传递

"""
函数的传递到底是值传递还是引用传递要分情况：
	不可变的参数用值传递：像整数和字符串
	可变参数是引用传递:像列表字典这些对象是引用传递的
"""

30、为什么函数名可以当做参数用？

"""
python一切皆对象，函数名是函数在内存中的空间，也是一个对象
"""

31、递归函数的停止条件

"""
递归的终止条件一般定义在递归函数的内部
1、判断递归的次数是否达到某一个限定值
2、判断运算的结果是否达到某个范围
"""