面试题 基础

面试题 基础

Comments 0 Comment

自己不会的做记录

如何实现字符串的反转？name=”lzx”,请反转为name=’xzl’

name = 'lzx'
name = list(name)
name.reverse()
name ="".join(name)
print(name)

1,2,3,4,5 能组成多少互不相同且无重复的三位数

counter=0
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if i !=j and j !=k and k !=i:
                print("{}{}{}".format(i,j,k),end=" ")
                counter +=1
print("")
print("共{}种组合".format(counter))

什么是反射,应用场景是什么

通过字符串映射object对象的方法或者属性 https://www.jianshu.com/p/628f61f01a54

直观点的例子 需求是这样的 需要从列表创建两个类的对象

深浅拷贝

python 垃圾回收机制

1 引用计数

2标记清除

3 分代

python 的可变与不可变类型

可变的 数组 和字典

不可变

求结果

v = {key1:666,key2:666]}
v = {key1:777,key2:666]}

一行代码删除列表中重复的值

set(list)

如何实现 “1,2,3,变成[1,2,3]

split()

如何用一行代码生存[1,4,9,16,25,36,49,64,81,100]

print([x**2 for x in range(11)])

常用的字符格式化有哪几种

1 format

2 %

什么是断言

assert

a = 8
assert(a>10)
print("被中断")
Traceback (most recent call last):
  File "2.py", line 2, in <module>
    assert(a>10)
AssertionError

有一个多层嵌套的列表A=[1,2,[3,4,[“434″,”323”]]] 请写一段代码遍历A中的元素

def extract_list(x):
    for item in x:
        if isinstance(item, list):
            for i in extract_list(item):
                yield i
        else:
            yield item

A=[1,2,[3,4,["434","323"]]]
print ([item for item in extract_list(A)])

a = range(10),a[::-3]的结果是

你以为的结果是

a = [0,1,2,3,4,5,6,7,8,9]
print(a[::-3])
[9, 6, 3, 0]

其实的结果的
range(9, -1, -3)

下面哪个命令可以从虚拟环境退出

exit

将列表内相同的元素合并成字典

lst = [1,2,4,8,16,32,64,128,256,512,1024,32769,65536,4294967296]
newdic={}
for i in lst:
    keys = len(str(i))
    if keys in newdic:
        newdic[keys].append(i)
    else:
        newdic[keys] = [i,]
print(newdic)

请尽量用简洁的方法将二维数组转化成一唯数组

lst = [[1,2,3], [4,5,6], [7,8,9]]

print([i for item in lst for i in item])

import operator
from functools import reduce
a = [[1,2,3], [4,6], [7,8,9,8]]
print(reduce(operator.add, a))

将列表按下列规则排序，补全代码

1 正数在前负数在后
2 正数从小到大
3 负数从小到大

lst = [7, -8, 5, 4, 0, -2, -5]
print(sorted(lst,key=lambda x:(x<0, abs(x)) ))

哈希冲突回避算法有哪几种，分别有什么特点

https://zhuanlan.zhihu.com/p/29520044

简述Python的字符串驻留机制

字符串驻留是一种仅保存一份相同且不可变字符串的方法。
https://zhuanlan.zhihu.com/p/35362912

以下代码输出的是什么 ？list=[‘a’,’b’,’c’,’e’] print list [10:]

[]

Python 语言哪些可以 作为字典的key

一个对象能不能作为字典的key，就取决于其有没有hash方法。所以所有python自带类型中，除了list、dict、set和内部至少带有上述三种类型之一的tuple之外，其余的对象都能当key。

比如数值/字符串/完全不可变的元组/函数(内建或自定义)/类(内建或自定义)/方法/包等等你能拿出手的，不过有的实际意义不高。还有数值型要注意，因为两个不同的相等数字可以有相同的哈希值，比如1和1.0。

range xrange不一样

python2 中一个生成 list 一个是一个生成器

如下代码段的结果

import copy
a = [1,2,3,[4,5],6]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
b.append(10)
c[3].append(11)
d[3].append(12)
print(a) # [1,2,3,[4,5,11],6,11]
print(b) # 同a
print(c) # [1,2,3,[4,5,11],6]
print(d) # [1,2,3,[4,5,12],6]

现有字典d = {“a”:26,”g”:20,”e”:20,”c”:24,”d”:23} 请按照字段中的value 进行排序

#排序keys
d = {"a":26,"g":20,"e":20,"c":24,"d":23}
#排序keys
ret = sorted(d.items(), reverse=True)
print(ret)

给定两个listA,B请用Python找出相同元素，和不同元素

a=[1,2,3,4]
b=[1,5,6]
print(set(a)&set(b))
print(set(a)^set(b))

下列描述中错误的是C

线性结构是一个有序数据元素的集合。 其中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。
常用的线性结构有：线性表，栈，队列，双队列，数组，串。

非线性结构中各个数据元素不再保持在一个线性序列中，每个数据元素可能与零个或者多个其他数据元素发生联系。根据关系的不同，可分为层次结构和群结构。
常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。（其中多维数组是由多个一维数组组成的，所以不再是线性结构）

A 栈是线性的

B 队列是线性的

C 二叉树是线性结构

D 线性列表是线性结构

一个栈的输入序列为1,2,3,4,5 则下列序列中不可能是栈的输出序列的是

B

A 1 5 4 3 2

B 2 3 4 1 5

C 1 5 4 2 3

D 2 3 1 4 5

那个PEP被认为涉及到代码规范

PEP8

下面哪些是python的合法标识符 那些是关键字

1 int32 关键字

2 40Xl 不能数字开头

3 saving$ 特殊符号

4 print 关键字

5 this 合法的 python 没有 this

6 self 合法的

7 0x40l 不能数字开头

8 true 合法的

9 big-daddy

10 True 关键字

11 if 关键字

12 do 合法的

13 yield 关键字

从0-99这100个数中随机取出10个，要求不能重复，可以设计数据结果

import random
a = [ x for x in range(100)]
while len(a) > 90:
    print(a.pop(random.randint(0, 99)))

python 判断一个字典中是否有这些key:”AAA”,”BB”,”C”,”DD”,”EEE”

k in dic.keys()

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

lst = ["This","is","a","Boy"]
print(sorted(x.lower()for x in lst ))
print(sorted(lst, key = lambda x:x.lower()))

描述下dict的item()方法与iteritems()的不同

  • 字典的items方法作用：是可以将字典中的所有项，以列表方式返回。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。
  • 字典的iteritems方法作用：与items方法相比作用大致相同，只是它的返回值不是列表，而是一个迭代器。iteritems()方法在需要迭代结果的时候使用最适合，而且它的工作效率非常的高。
  • 在Python 3.x 里面，iteritems()方法已经废除了。

请列举你所知道的Pytho代码检测工具以及他们之间的不同

  • pylint — 源代码分析器，可以分析python代码中的错误
  • pyflakes — 检查源文件错误的简单程序，不会检查代码风格。
  • pep8 — 检查代码规范的工具
  • pyhecker是一个python代码静态分析工具，它可以帮助python代码找bug会对代码的复杂度提出警告

介绍一下try except 的用法和作用

用于 异常处理

输入一个字符串，返回倒序排列的结果

（1）切片（2）列表的reverse（3）reduce函数

阅读以下代码，并写出程序的输出结果

alist = [2, 4, 5, 6, 7]
for var in alist:
    print(var%2)
    if var %2  == 0:
        alist.remove(var)
print(alist)
[4,5,7]

现有列表alist=[3,1,-4,-2],按照元素的绝对值进行排序

alist=[3,1,-4,-2]
print(sorted(alist, key=lambda x: abs(x)))

填空题

1 表达式 3<4<5 是哪个表达式的缩写** 3<4 and 4<5**

2 获取Python 解析器的版本的方法是  python3 -V

3 如果模块是导入的,__name__ 的值是 **模块的名字**
如果是被执行的__name__的值是 **__main__**

4 Python 的内存管理中，为了追踪内存的对象，使用了 **引用计数** 这一简单技术

现有字典mydic和变量onekey 请写出从mydic中取出onekey值的方法（不止一种写法，多写加分，并请描述不同写法的区别，mydic中是否存在onekey的键值不确定）

mydict[‘onekey’] 这种获取方式如果键不存在就会报错mydict.get(‘onekey’)
　　

这种获取方式如果键不存在就返回None 我们可以自定义返回值
　　mydict.setdefault(‘onekey’)

这种方式也是查看键在字典中是否存在,不存在就返回None
　　if ‘onekey’ in mydict: 这种方式是利用字典的键来进行校验是否存在

现有一列表alist，请写出两种去除alist重复元素的方法

其中 要保持原有列表中的元素的排列顺序 无需考虑原有列表中元素的排列顺序

alist=[2,34,6,8,9,7,3,2]
2 # 　　– 要求保持原有列表中元素的排列顺序。
3 L=[]
4 for i in alist:
5     if i not in L:
6         L.append(i)
7 
8 # 　　– 无需考虑原有列表中元素的排列顺序。
9 list(set(alist))

那些情况下, y! = x-(x-y) 成了

x，y是两个不相等的非空集合

用 Python 实现 99 乘法表(用两种不同的方法实现)

1 #方式一：for循环
 2 for i in range(1,10):
 3     for j in range(1,i+1):
 4         print(f"{i}x{j}={i*j}\t",end='\n' if j==i else '' )
 5 #方式二：while循环
 6 i=1
 7 while i <10:
 8     j=1
 9     while j<=i:
10         print(f"{i}x{j}={i*j}\t",end='\n' if j==i else '' )
11         j+=1
12     i+=1
13 #方式三：列表的推导式
14 print('\n'.join(['\t'.join([f"{i}x{j}={i*j}" for j in range(1,i+1)]) for i in range(1,10) ]))

获取list中元素的个数，和向末尾追加所有用的分别是什么

len()
append()

判断dict中有没有某个key用的方法是什么

has_key 现在没有了 现在用 key in dict 的方法

填空

l = range(100)

1 如何取第一到第三元素用的是 l[0:3]

2 如何取倒数第二个元素 l[-2]

3 如何取后十个 l[-10:-1]

如何判断一个变量是否是字符串

type()

isinstance()

list tuple 有什么的

list是一个可变的数据结构,能够进行增删改

tuple是一个不可变的数据结构,不能够进行增删改,可以存放一些重要的数据

a = dict(zip((“a”,”b”,”c”,”d”,”e”),(1,2,3,4,5))) 请问 a 是什么？

　{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5}

一行代码 生成列表[1,4,9,16,25,36,49,64,81,100]

x**2 for x in range(1,101)

以下描述正确的是 B

A continue 语句的作用是结束整个循环的执行 continue 只是结束单次

B 只能在循环体和switch 语句内使用break 语句

C. 在循环体内使用 break语句或者 continue语句的作用相同 Break 全部跳出

D. 从多层循环嵌套中退出时, 只能使用 goto语句

写结果

x = "foo"
y = 2
print(x+y)

会爆错

求结果

kvps = {“1″:1,”2”:2}
2. theCopy = kvps
3. kvps[“1”] = 5
4. sum = kvps[“1”] + theCopy [“1”]
5. print sum
浅拷贝
10

python 里如何实现tuple 和list的转化

list(tuple)

tuple(list)

type(1+2L*3.14)的结果是

float

若K为整型，下列while循环的执行次数是

2 * 2 10次数1024

1. k = 1000
2. while k>1:
3.     print k
4.     k = k/2

python3中 循环执行次数是10次
python2中 循环执行次数是9次

以下哪个不是合法的布尔表达式

3=a == 比值 = 是赋值运算

python 不支持的数据类型有

char

如何在 Python 中拷贝一个对象, 并说明他们之间的区别？

用[:]这样就可以进行拷贝一个对象,这个是浅拷贝
使用copy模块 copy.copy这是浅拷贝
使用copy模块 copy.deepcopy 这是深拷贝
浅拷贝就是拷贝对象的一层元素.
深拷贝是拷贝对象里的多层元素

99（10进制）的八进制

print(oct(99))

下列Python 语句正确的是

1 min = x is x<y = y

2 max = x>y?x:y python 没有三元

3 if(x>y) print x 少：

4 while True:pass

list 对象 alist =[{‘name’:’a’,’age’:20},{‘name’:’b’,’age’:30},{‘name’:’v’,’age’:25},]按 alist 中元素的 age 由大到小排序。

alist = [{'name': 'a', 'age': 20}, {'name': 'b', 'age': 30}, {'name': 'v', 'age': 25}, ]
2 print(sorted(alist,key=lambda x:x['age']))

关于Python程序的运行性能方面，有什么手段提升性能

  • 多进程，充分利用机器的多核性能
  • 性能影响较大的部分代码，可以使用C或C++编写
  • IO阻塞造成的性能影响，可以使用IO多路复用来解决
  • 使用Python的内建函数5、尽量使用局部变量

Python是如何进行内存管理的？Python的程序会内存泄漏嘛，说说有没有什么方面阻止或检测内存泄漏

Python GC主要使用 引用计数 来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”解决容器对象可能产生的循环引用问题。通过分代
以空间换时间的方法提高垃圾回收效率

引用计数： 每个对象中都有ob-refcnt来做引用计数。当一个对象…,ob-refcnt就会增加，当引用的对象删除，那么ob-refcnt就会减少当ob-refcnt为零，就会释放该对象的内存空间
标记清除： 解决循环引用的问题。先按需分配，等到没有空闲内存的时候，从寄存器和程序栈上的引用出发，遍历所有对象和引用把所有能访问的打标记，最后将没有标记的对象释放掉
分代技术： 提高效率，提高垃圾回收的效率，按照存活时间，分成不同的集合。将内存块按照其存活时间划分为不同的集合。每个集合就称为一个“代”，垃圾回收的频率随代的存活时间增大而减小。Python默认定义分代对象集合，引用数越大，对象的存活时间越长
Python也会内存泄露，Python本身的垃圾回收机制无法回收重写了del的循环引用的对象.

程序员管理好每个python对象的引用，尽量在不需要使用对象的时候，断开所有引用
尽量少通过循环引用组织数据，可以改用weakref做弱引用或者用id之类的句柄访问对象
通过gc模块的接口可以检查出每次垃圾回收有哪些对象不能自动处理，再逐个逐个处理

详细说说tuple，list ，dict 的用法，他们的特点

list 是常用的数据结构 一个列表可以切片，删除，添加，排序元素

tuple 是不可变的列表

dict 是字典 利用键值段儿进行取值

一个大小为10g 的文件etl_log.txt,要读取文件中的内容，写出具体过程代码

可以使用生成器的方式节约内存

xreadlines

with open("",'r') as f:
    for line in f:
        print(line)

已知Alist = [1,2,3,1,2,1,3] 如果根据Alist 得到[1,2,3]

Alist = [1,2,3,1,2,1,3]

print(list(set(Alist)))

已知Alist[“a”,”b”,”c”],将Alist 转化为a，b，c的实现过程

Alist = ["a","b","c"]
s = ",".join(Alist)
print(s)

已知ip = ‘192.168.0.100’ 代码实现提取各部分并写入列表

ip = '192.168.0.100'
print(ip.split('.'))

python 代码如何获取命令行参数

args

写代码

tupleA = ('a', 'b', 'c', 'd', 'e')
tupleB = (1, 2, 3, 4, 5)
dic = {}
for i in range(len(tupleA)):
    dic[tupleA[i]] = tupleB[i]
print(dic)
RES = {"a":1,"b":2,"c":4,"d":4,"e":5}

tupleA = ('a', 'b', 'c', 'd', 'e')
tupleB = (1, 2, 3, 4, 5)

print(dict(zip(tupleA,tupleB)))

选出一下表达式正确的选项

k = {1:0,2:0,3:0}
k2 = {'1':0,'2':0,'3':0}
# k3 = {(1,2):0,(4,3):0}
# k4 = {[1,2]:0,[4,3]:0}
# k5 =  {{1,2}:0,{4,3}:0}

what get printed()?

kvps = {"1":1,"2":2}
theCopy = kvps.copy()
kvps["1"] = 5
sum = kvps["1"]+theCopy["1"]
print(sum) 6

what get printed()?

numbers = [1,2,3,4]
numbers.append([5,6,7,8])
print(len(numbers))
5

what get printed()?

names1 = ["Amir", "Barry", "Chaies", "Dao"]
if "amir" in names1:
    print(1)
else:
    print(2)

2

what getsprint() Asssuming python verson2.x

>>> print(type(1/2))
<type 'int'>

用来管理Python库管理工具的是

pip

which numbers are printed ？

for i in range(2):
    print(i)

for i in range(4,6):
    print(i)
0,1,4,5

求结果

Math.floor() === 向下取整

import math
print(math.floor(5.5))

5

关于Python的内存管理，下列说法错误

B

A 变量不用事先声明

B 变量无需先创建和赋值而直接使用 必然报错啊

C 变量无需指定类型

D 可以使用del释放资源

下面那个不是Python合法的标识符

B

A int32

B 40xl

C self

D name

下列表达为True的是

c 只在2.x 版本
A 5+4j >2-3j

B 3>2>2

C (3,2)<(“a”,”b”)

D ” abc” > “xyz”

关于Python的复数，下列说法错误的是

C

A 表示复数的语法岁real+imagej

B 实部和虚部都是浮点数

C 虚部后缀必须是j,并且小写

D 方法conjugate 返回复数的共轭复数

关于字符串说法错误的是 A

A 字符应该视为长度位1的字符串

B 字符串以\0的标志字符串的结束

C 即可以用单引号们，也可以用双引号创建字符串

D

以下不能创建一个字典的语句是

C D

A dic1 = {}

B dic2 = {3:5}

C dic3 = {[1,2,3],”usetc”}

D dic4 = {(1,2,3):”usetc”}

描述在Python中的元祖，列表，字典的区别

选择结果

names1 = ["Amir", "Barry", "Chales", "Dao"]
names2 = names1
#拷贝
names3 = names1[:]
names2[0] = "Alice"
names3[1] = "Bob"
sum = 0

for ls in (names1, names2,names3):
    if ls[0] == "Alice":
        sum += 1
    if ls[1] == "Bob":

        sum+=10
print(sum)

#12 两次 一样的值

下面程序的输出结果是

x = True
y = False
z =True

if x or y and z:
    print("yes")
else:
    print("No")
yes

1 or 2 和 1 and 2 的输出分别是什么 为什么

print(1 or 2)
print(1 and 2)

1 
2

1 <(2==2) 和 1<2 ==2 的结果分别是什么

print(1 <(2==2)) false
print(1 <2 == 2) true

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

import random
alist= [1, 2, 3, 4, 5]
random.shuffle(alist)
print(alist)   # alist会被改变

import random
alist = [1, 2, 3, 4, 5]
blist = random.sample(alist, len(alist))
print(blist)  # alist未改变

如何查找一个字符串中特定字符？find 和index的差异？

find()方法：查找子字符串，若找到返回从0开始的下标值，若找不到返回-1


info = 'abca'
print info.find('a')##从下标0开始，查找在字符串里第一个出现的子串，返回结果：0

info = 'abca'
print info.find('a',1)##从下标1开始，查找在字符串里第一个出现的子串：返回结果3

info = 'abca'
print info.find('333')##返回-1,查找不到返回-1

python 的index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1


info = 'abca'
print info.index('a')
print info.index('33')

把aaabbcccd 这种形式的字符串压缩成a3b2d1这种形式

Python 一个数如果恰好等于它的因子之和，这个数称为完数例如 6 = 1+2+3 编程找出1000以内的所有完数

for i in range(2, 1000):
  4     l1 = []
  5     for j in range(1,i):
  6         if i % j == 0:
  7             l1.append(j)
  8     num = sum(l1)
  9     if num == i:
 10         print "%d ="%i,
 11         for i in range(len(l1)):
 12             if i == len(l1) - 1:
 13                 print l1[i]
 14             else:
 15                 print "%d +"%l1[i],

输入一个字符串，输出该字符串中字符的所有组合

执行以下代码后 i 和 n 的值为

int i =10
int n = i++ %5

i = 11

n = 1

执行以下代码后，x的值为

Post Views: 0

发表评论

电子邮件地址不会被公开。 必填项已用*标注