python面试准备练习题21-40

目录:
21.字典和json的区别
22.什么是可变、不可变类型
23.存入字典里的数据有没有先后排序
24.字典推导式
25.描述下dict的item()方法与iteritems()的不同
26.请反转字符串“aStr”
27.请按list1中元素的age由大到小排序
28.常用的字符串格式化哪几种
29.简述字符串驻留机制
30.下面代码的输出结果将是什么?
31.写一个列表生成式,产生一个公差为11的等差数列
32.给定两个列表,怎么找出他们相同的元素和不同的元素?
33.请写出一段Python代码实现删除一个list里面的重复元素
34.下面这段代码的输出结果是什么?请解释?
35.将以下3 个函数按照执行效率高低排序
36.有一个list[“This”,“is”,“a”,“Boy”,"!"],所有元素都是字符串,对他进行大小写 无关的排序
37.列举字符串、列表、元组、字典每个常用的5个方法
38.什么是反射?以及应用场景?
39.简述Python的深浅拷贝
40.Python 垃圾回收机制

21.字典和json的区别

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

22.什么是可变、不可变类型

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

23.存入字典里的数据有没有先后排序?

存入的数据不会自动排序,可以使用sort函数对字典进行排序

24.字典推导式

dict = {key: value for (key, value) in iterable}

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

字典的items方法作用:是可以将字典中的所有项,以列表方式返回。因为字典是无序的,所以用items方法返回字典的所有项,也是没有顺序的。

字典的iteritems方法作用:与items方法相比作用大致相同,只是它的返回值不是列表,而是一个迭代器。

在Python2.x中,iteritems() 用于返回本身字典列表操作后的迭代器【Returns an iterator on all items(key/value pairs) 】,不占用额外的内存。

在Python 3.x 里面,iteritems()方法已经废除了。在3.x里用 items()替换iteritems() ,可以用于 for 来循环遍历。

回到目录

26.请反转字符串“aStr”

print("aStr"[::-1])

27.请按list1中元素的age由大到小排序

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

In [4]: sorted(list1, key=lambda x: x['age'])                                                                                                   
Out[4]: [{'name': 'a', 'age': 20}, {'name': 'c', 'age': 25}, {'name': 'b', 'age': 30}]

In [5]: sorted(list1, key=lambda x: x['age'],reverse=True)                                                                                      
Out[5]: [{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]

28.常用的字符串格式化哪几种

name = '张三'

1)占位符
s1 = "%s DSB 你好" % name

2)format
s2 = '{} DSB 你好'.format(name)

3)f-string(python3.6之后才有的特性)
s3 = f'{name} DSB 你好'

29.简述字符串驻留机制

对于短字符串,将其赋值给多个不同的对象时,内存中只有一个副本,多个对象共享该副 
本。长字符串不遵守驻留机制。

驻留适用范围: 由数字,字符和下划线(_)组成的python标识符以及整数[-5,256]。 

30.下面代码的输出结果将是什么?

list = ['a', 'b', 'c', 'd', 'e']
print(list[10:])

下面的代码将输出[],不会产生IndexError错误。就像所期望的那样,尝试用超出成员的个数的index
来获取某个列表的成员。例如,尝试获取list[10]和之后的成员,会导致IndexError。

回到目录

31.写一个列表生成式,产生一个公差为11的等差数列

In [6]: [i*11 for i in range(10)]                                                                                                               
Out[6]: [0, 11, 22, 33, 44, 55, 66, 77, 88, 99]

32.给定两个列表,怎么找出他们相同的元素和不同的元素?

In [7]: list1 = [1,2,3]                                                                                                                         

In [8]: list2 = [3,4,5]                                                                                                                         

In [9]: print(set(list1)&set(list2))                                                                                                            
{3}

In [10]: print(set(list1)^set(list2))                                                                                                           
{1, 2, 4, 5}

33.请写出一段Python代码实现删除一个list里面的重复元素

# 最简单的
In [12]: list1 = [1, 3, 5, 6, 2, 6, 2, 1]                                                                                                       

In [13]: print(list(set(list1)))                                                                                                                
[1, 2, 3, 5, 6]

# 需要字母排序的
In [14]: list2 = ['a', 'b', 'c', 'd', 'b', 'c', 'a']

In [19]: list1 = list(set(list2))                                                                                                               

In [20]: sorted(list1)                                                                                                                          
Out[20]: ['a', 'b', 'c', 'd']

34.下面这段代码的输出结果是什么?请解释?

  1 def extendlist(val, list1=[]):
  2     list1.append(val)
  3     return list1
  4 list1 = extendlist(10)
  5 list2 = extendlist(123, [])
  6 list3 = extendlist('a')
  7 print("list1 = %s" % list1)
  8 print("list2 = %s" % list2)
  9 print("list3 = %s" % list3)

list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
新的默认列表只在函数被定义的那一刻创建一次。当extendList被没有指定特定参数list调用时,这组list的值
随后将被使用。这是因为带有默认参数的表达式在函数被定义的时候被计算,不是在调用的时候被计算。

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

# 可以使用cprofile来分析执行效率
  1 def f1(lIn):
  2      l1 = sorted(lIn)
  3      l2 = [i for i in l1 if i<0.5]
  4      return [i*i for i in l2]
  5 def f2(lIn):
  6      l1 = [i for i in lIn if i<0.5]
  7      l2 = sorted(l1)
  8      return [i*i for i in l2]
  9 def f3(lIn):
 10      l1 = [i*i for i in lIn]
 11      l2 = sorted(l1)
 12      return [i for i in l1 if i<(0.5*0.5)]
 13 
 14 import random
 15 import cProfile
 16 lIn = [random.random() for i in range(100000)]
 17 cProfile.run('f1(lIn)')
 18 cProfile.run('f2(lIn)')
 19 cProfile.run('f3(lIn)')

回到目录

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

In [3]: list1 = ["This","is","a","Boy","!"]                                                                                                     

In [4]: sorted(list1)                                                                                                                           
Out[4]: ['!', 'Boy', 'This', 'a', 'is']

37.列举字符串、列表、元组、字典每个常用的5个方法

字符串:repleace,strip,split,reverse,upper,lower,join.....

列表:append,pop,insert,remove,sort,count,index.....

元组:index,count,len(),dir()

字典:get,keys,values,pop,popitems,clear,update,items.....

38.什么是反射?以及应用场景?

在绝大多数语言当中都有反射机制的存在, 可以用字符串的方式去访问对象的属性,调用对象的方法(但是不能去访问方法),Python中一切皆对象,都可以使用反射

#python中涉及四个内置函数
# hasattr
# getattr
# setattr
# delattr

1. 可以获取模块的属性
2. 框架中使用

39.简述Python的深浅拷贝

copy():浅copy,浅拷贝指仅仅拷贝数据集合的第一层数据
deepcopy():深copy,深拷贝指拷贝数据集合的所有层


参考:Python 中的深浅复制

40.Python 垃圾回收机制

垃圾回收机制是自动帮助我们管理内存,清理垃圾的一种工具

1)、引用计数
当一个对象的引用被创建或者复制时,对象的引用计数加1;
当一个对象的引用被销毁时,对象的引用计数减1;
当对象的引用计数减少为0时,就意味着对象已经没有被任何人使用了,可以将其所占用的内存释放了。

优点:
简单、直观
实时性,只要没有了引用就释放资源。

缺点:
维护引用计数需要消耗一定的资源
循环应用时,无法回收。也正是因为这个原因,才需要通过标记-清理和分代收集机制来辅助引用计数机制。

2)、标记-清除
“标记-清除”不改动真实的引用计数,而是将
集合中对象的引用计数复制一份副本,改动该对象引用的副本。对于副
本做任何的改动,都不会影响到对象生命走起的维护。

3)、分代回收
将系统中的所有内存块根据其存活时间划分为不同的集合,
每一个集合就成为一个“代”,垃圾收集的频率随着“代”的存活时间的增大而减小。
也就是说,活得越长的对象,就越不可能是垃圾,就应该减少对它的垃圾收集频率。
那么如何来衡量这个存活时间:通常是利用几次垃圾收集动作来衡量,
如果一个对象经过的垃圾收集次数越多,可以得出:该对象存活时间就越长。

回到目录

你可能感兴趣的:(面试题,python,面试题)