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

回到目录