Interview

Python和Java、PHP、C、C#、C++等其他语言的对比？

# C语言：通过指针可直接靠近硬件的操作，但指针操作不做保护，带来很多不安全的因素。
# C++：C语言的继承，编译型语言。
# C#：微软发布的，和Java比较相似，如单一继承、接口等
# Java：简单、面向对象、分布式、解释型、健壮、安全与系统无关、可移植、高性能、多线程和动态语言。
# PHP语言：用于web开发领域
# Python：胶水语言、面向对象、简洁而优雅

简述解释型和编译型语言？

# 编译型：要编译器，相当于谷歌翻译，执行快，跨平台差，开发效率慢，调试麻烦
# 解释型：要解释器，相当于同生传译，跨平台好，执行慢，开发效率快，方便调试

Python解释器种类及特点？

# CPython:C语言开发，官方版本
# IPython：基于CPython之上，跟国产浏览器差不多，虽外观不同，但内核都是调用IE
# PyPy：目标是执行速度，采用JIT（just in time）技术，对代码进行动态编译。
# Jython：运行在Java平台的Python解释器，将代码编译成Java字节码执行

位bit、字节B、KB、MB、GB的关系？
```
8bit=1B;1024B=1KB;1024KB=1MB;1024MB=1GB
```

请至少列举5个PEP8规范

1.使用空格（space）表示缩进而不是用tab（制表符）
2.每行的字符数不应超过79
3.函数与类之间应该用两个空行隔开
4.在同一个类中，各方法之间应该用一个空行隔开
5.函数、变量及属性应该用小写字母拼写，各单词之间以下划线相连

求以下结果

print(1 or 3)  # 1
print(1 and 3)  # 3
print(0 and 1)  # 0
print(0 and 2 and 1)  # 0
print(0 and 2 or 1)  # 1
print(0 and 2 or 1 or 4)  # 1
print(0 or False and 1)  # False，先计算and
# 逻辑操作符and，如果两者为真，则返回第二个值，反之，返回第一个值
# 逻辑操作符or，如果两者为真，则返回第一个值，反之，返回第二个值
# False:0、None、False、空数据类型，其余全为True
# and的优先级大于or

ASCII、Unicode、utf-8、gbk的区别？

# ASCII：英文字符与二进制进行联系，规定了128个字符，如大写字母（65-90），小写字母（97-122）.
# Unicode：一种所有符号的编码，规定每个符号用2个字节表示
# utf-8:可変长编码，1-4字节表示一个符号。
# gbk：对GB2312的扩展并兼容，大部分汉字占两个字节

字节码和机器码的区别？

字节码是一种中间状态（中间码）的二进制代码，需要直译器转义后才能成为机器码

三元运算、交叉赋值、解压取值编写格式

条件成立 if 条件 else 条件不成立
a,b=b,a
a,b,c=[1,2,3]
a,_,c=[1,2,3]

Python2和Python的区别？

# 打印方式
py2：print "hello"
py3：print("hello")
# 用户输入方式
py2：input_raw()
py3：input()
# 默认编码方式
py2：ASCII
py3：utf-8
# 字符串
py2：Unicode表示字符串，str表示字节
py3：str表示字符串，byte表示字节
# int和long
py2:int整型，long长整型
py3：只有int类型，无long类型
# xrange和range
py2：xrange生成器，range列表对象
py3：range生成器，无xrange

如何实现字符串的反转？
```
s = "hello world"
print(s[::-1])
```

文件操作时，xrealines和readlines的区别？

# readlines():把文件的全部内容读到内存，并返回一个列表，每一行为一个元素，当文件过大，占用过多内存。
# readline():读取文件中的第一行到内存中，并以字符串形式返回
# read():读取文件中的全部内容到内存，并以字符串形式返回每一行数据
# xreadlines():直接返回一个iter()迭代器，已弃用，直接for循环迭代文件对象即可。
f = open("test.txt", 'r', encoding='utf-8')
data = f.readlines()
print(data)  # ['hello
', 'world']

is和==的区别？

is比较的是内存地址，而==比较的是值

哪些情况下，y!=x-(x-y)会成立？

# x,y是两个不相等的非空集合
# 集合符号：&交集、|并集、-差集、^对称差集、>父集、<子集
y = {1, 2, 3}
x = {4, 5, 6}
print(x - y)  # {4, 5, 6}
print(y != x - (x - y))  # True

现有字典dic={"a":23,"b":51,"c":11,"d":34}，请按字典中的value值进行降序排序？

dic = {"a": 23, "b": 51, "c": 11, "d": 34}
print(sorted(dic, key=lambda i: dic[i], reverse=True))
# ['b', 'd', 'a', 'c']
print(dic.items())
# dict_items([('a', 23), ('b', 51), ('c', 11), ('d', 34)])
print(sorted(dic.items(), key=lambda i: i[1], reverse=True))
# [('b', 51), ('d', 34), ('a', 23), ('c', 11)]

简要说明字典和json的区别？

字典是一种数据结构，key值必须能hash即唯一，而json是一种数据的表现形式，必须是字符串

什么是可变类型、不可变类型？

可变类型：值变id不变，如列表、字典、集合
不可变类型：值变id变，如数值、字符串、元组

字典推导式、列表推导式和生成器推导式？

lis = [1, 2, 3]
# 字典推导式
print({k: v for (k, v) in enumerate(lis)})  # {0: 1, 1: 2, 2: 3}
# 列表推导式
print([i for i in range(3)])  # [0, 1, 2]
# 生成器推导式
print((i for i in range(3)))  # <generator object <genexpr> at 0x0000000002171E60>
for j in (i for i in range(3)):
    print(j)
#需求：产生一个公差为11的等差数列
print([i * 11 for i in range(10)])

描述字典中的item()方法与iteritems()的不同

item():将字典中的所有项以列表无序的形式返回。
iteritem():py2中使用，返回一个迭代器，已弃用。

将字符串"k:1|k1:2|k2:3|k3:4"处理成字典{k:1,k1:2,k2:3,k3:4}

s = "k:1|k1:2|k2:3|k3:4"
dic = {}
for i in s.split('|'):
    k, v = i.split(':')
    dic[k] = v
print(dic)

常见的字符串格式化有哪几种？

name = "allen"
# 占位符
print("hello,%s" % name)
# format
print("hello,{}".format(name))
# f-string
print(f"hello,{name}")

简述字符串驻留机制？

对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本，长字符串不遵守驻留机制。
驻留适用范围：由数字、字符和下划线组成的python标识符以及小整数池[-5,256]。

下面代码的输出结果是什么？

lis = ['a', 'b', 'c', 'd', 'e']
print(lis[10])  # IndexError
print(lis[10:])  # []

实现删除一个list里面的重复元素？

# 方式一
lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
lis1 = list(set(lis))
print(lis1)
# 方式二：保持原来的顺序
lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
lis1 = list(set(lis))
lis2 = lis1.sort(key=lis.index)
print(lis1) #['b', 'c', 'd', 'a']
# 方式三：保持原来的顺序
lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
lis1 = sorted(set(lis), key=lis.index)
print(lis1)
# 方式四：保持原来的顺序-遍历
lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
new_lis = []
for i in lis:
    if i not in new_lis:
        new_lis.append(i)
print(new_lis)

下面这段代码的输出结果是什么？并解释。

def extendlist(val, lis=[]):
    lis.append(val)
    return lis
lis1 = extendlist(10)
lis2 = extendlist(123, [])
lis3 = extendlist('a')
print(f'lis1={lis1}')  # lis1=[10, 'a']
print(f'lis2={lis2}')  # lis2=[123]
print(f'lis3={lis3}')  # lis3=[10, 'a']

def extend_dic(key, dic={}):
    dic[key] = 1
    return dic
dic1 = extend_dic('a')
dic2 = extend_dic('b', {})
dic3 = extend_dic('c')
print(f'dic1={dic1}')  # dic1={'a': 1, 'c': 1}
print(f'dic2={dic2}')  # dic2={'b': 1}
print(f'dic3={dic3}')  # dic3={'a': 1, 'c': 1}
# 新的默认列表只在函数被定义那一刻创建一次，当extendlist被没有指定特定参数lis调用时，这组lis的值随后将被使用，因为带有默认参数的表达式在函数定义阶段时被计算，不是在调用时被计算。

将以下3个函数按照执行效率高低排序？

import random
import cProfile
def f1(x):
    l1 = sorted(x)
    l2 = [i for i in l1 if i < 0.5]
    return [i * i for i in l2]
def f2(x):
    l1 = [i for i in x if i < 0.5]
    l2 = sorted(l1)
    return [i * i for i in l2]
def f3(x):
    l1 = [i * i for i in x]
    l2 = sorted(l1)
    return [i for i in l2 if i < (0.5 * 0.5)]
x = [random.random() for i in range(100000)]
cProfile.run('f1(x)')
cProfile.run('f2(x)')
cProfile.run('f3(x)')
# 执行效率：f2、f1、f3
# 利用cProfile模块分析代码的性能

列举字符串、列表、元组、字典常用方法

字符串：replace、strip、split、reverse、upper、join、lower
列表：append、pop、insert、remove、sort、count、index
元组：index、count、len、dir
字典：get、keys、values、pop、clear、update、items

什么是反射以及应用场景？

在绝大多数语言当中都有反射机制，是很多框架的基石，用字符串形式访问对象的属性，调用对象的方法，但不能去访问方法，python一切皆对象，都可以使用反射。

简述Python的深浅拷贝？

在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量时，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。注意：拷贝、浅拷贝、深拷贝都是针对可变类型数据而言的。

# 拷贝：如果l2是l1的拷贝对象，l1内部的任何数据类型的元素变化，那么l2内部的元素也会跟着改变，因为可变类型值变id不变。
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1
l1.append('g')
print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
# 浅拷贝：如果l2是l1的浅拷贝对象，l1内的不可变元素发生了改变，l2不变；但是l1内的可变元素发生了改变，l2也会跟着改变。
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('h')
print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h']]
# 深拷贝：如果l2是l1的深拷贝对象，那么l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1变化而变化。
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('h')
print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]