python后端开发面试-语言基础篇

Python是动态语言还是静态？强类型还是弱类型？

python 是动态语言，怎么区分呢？关键看类型检测是在运行时检查还是编译时检查，Python是运行时检查，所以是动态语言，像java、golang是静态语言，它们在编译的时候检查类型
Python 是强类型，怎么区分呢？看它会不会发生隐式类转换，比如运算b = a + 1 在python中会报错，因为字符串不能与int类型相加，所以是强类型，但是在javascript结果为a1,因为javascript会把1自动转为字符串，所以javascript是弱类型

用推导式生成一个字典，俗称字典解析式

注意列表推导式外面是[]，字典是{}

dict_data = {x:2*x for x in range(10) }

Python中is和==的区别

== 比较的是值是否相等
is 不仅比较值是否相等，还比较所引用的对象地址是否一致，可以理解为比较id(x)==id(y)

高阶函数Map、reduce、filter区别

他们都是高阶函数，第一个参数传递的是一个函数或者lambda表达式

map 遍历第二个参数的列表，并把每个参数传递给第一个参数，显然第一个参数是一个函数表达式

>>> a = map(lambda x:x*2,[1,2,3])
>>> list(a)
[2, 4, 6]

reduce 在python3中需要从functools导入reduce，它负责的功能是将前一次的计算结果作为后一次的参数，再做计算，需要注意的是，这里的lambda需要两个参数x，y；x，y第一次传递进去的是1，2（来自[1,2,3]中的1，2），第一次传递的是3，2（来自[1,2,3]中的3，和前面计算的结果2）

from functools import  reduce
>>> a = reduce(lambda x,y:x*y,[1,2,3])
6

filter 就是一个过滤函数类似js的filter,下面的功能是过滤%2不等于的数，也就是求奇数

>>> a = filter(lambda x: x % 2, [1,2,3,4,5,6])
In [12]: list(a)
Out[12]: [1, 3, 5]

lambda函数的用法

lambda函数是一种匿名函数，也就是当你不想给函数命名的时候，且函数比较简单，就可以考虑使用lambda表达式

In [17]: a = lambda x: x * 2
In [18]: a(10)
Out[18]: 20

*args,**kwargs区别和用法

*args 是列表参数，接受的是一个可变列表
**kwargs 是字典参数，接受的是一个可变字典

单下划线函数和双下划线函数的区别

_xx：前置单下划线，私有化属性或方法，一般来讲，变量名_xx被看作是“私有的”，在模块或类外不可以使用。类似java中的protect
__xx：前置双下划线，私有化属性或方法，无法在外部直接访问（名字重整所以访问不到,只能是允许这个类本身进行访问了。连子类也不可以）类似java中的private
__xx__：前后双下划线，这被称为魔法方法，也是系统定义的名字，因为变量名__xxx__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

可变类型和不可变类型

怎么区分呢？记住可变类型就行，可变类型会有各种方法，比如list类型有append、remove，set有add；其余的基本是不可变

可变类型：list、set、dict
不可变类型：int、bool、float、str、tuple

python2和python3有什么区别

区别挺多的。下面说下python3的新特性

python3默认是Unicode编码，不像python2默认是ASCII str() 类型，unicode() 是单独的，头部还需要加上# utf-8 才能使用s = u”中国”
print是函数，需要print()才能调用
除法运算默认是浮点类型，在python2中除法默认是整数
python3合并range和xrange成range函数，都是迭代器
python3新增原生协程，asyncio

深拷贝和浅拷贝

复制不可变数据类型，不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。

In [59]: c = (1,2,3)

In [60]: c1 = copy.copy(c)

In [61]: c
Out[61]: (1, 2, 3)

In [62]: c1
Out[62]: (1, 2, 3)

In [63]: id(c)
Out[63]: 4611674400

In [64]: id(c1)
Out[64]: 4611674400

In [65]: c2 = copy.copy(c)

In [66]: c2
Out[66]: (1, 2, 3)

In [67]: id(c2)
Out[67]: 4611674400

In [68]: c = (1,2,3,4)

In [69]: c1
Out[69]: (1, 2, 3)

In [70]: c2
Out[70]: (1, 2, 3)

In [71]: c
Out[71]: (1, 2, 3, 4)

复制的值是可变对象（列表和字典）
浅拷贝copy有两种情况：

第一种情况：复制的对象中无复杂子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂子对象 （例如列表中的一个子元素是一个列表），改变原来的值中的复杂子对象的值，会影响浅复制的值。

In [40]: b = [9,0,1]
In [41]: b1 = [b,3,4]
In [43]: b1
Out[43]: [[9, 0, 1], 3, 4]
In [44]: b2 = copy.copy(b1)
In [45]: b2
Out[45]: [[9, 0, 1], 3, 4]

In [46]: b.append(3)
In [47]: b
Out[47]: [9, 0, 1, 3]

In [48]: b1
Out[48]: [[9, 0, 1, 3], 3, 4]

In [49]: b2
Out[49]: [[9, 0, 1, 3], 3, 4]

In [50]: id(b1)
Out[50]: 4616205448

In [51]: id(b2)
Out[51]: 4616489736

深拷贝deepcopy：完全复制独立，包括内层列表和字典,例子中的b如果再append 一个20，深拷贝的数据不会变

In [52]: b3 = copy.deepcopy(b2)

In [53]: b3
Out[53]: [[9, 0, 1, 3], 3, 4]

In [54]: b.append(20)

In [55]: b
Out[55]: [9, 0, 1, 3, 20]

In [56]: b3
Out[56]: [[9, 0, 1, 3], 3, 4]

In [57]: b1
Out[57]: [[9, 0, 1, 3, 20], 3, 4]

原创文章，作者：站长，如若转载，请注明出处：https://wsppx.cn/611/%e7%bd%91%e7%bb%9c%e5%bc%80%e5%8f%91/%e5%90%8e%e7%ab%af/

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30