Python自动化测试常见面试题（二）

​

1.   Python中推导式(生成器)

 

1.1.  概述：

Python推导式是从一个数据集合构建另外一个新的数据结构的语法结构. 最常见的就是列表的推导式

 

1.2.  详细描述：

列表推导式的语法：

1.   [expr for value in collection ifcondition]

2.   collection： 原始列表

3.   value：列表中的原始数据

4.   ifcondition： 过滤value的条件,满足条件再传入expr. 可选表达

5.expr： 对满足条件的value进一步处理后生成新的元素放在新的列表中

 

字典推导式的语法：

1.   { key_expr: value_expr for key_expr,value_expr in collection if condition }

2.   collection：可迭代对象

3.   key_expr： 键表达式

4.   value_expr：值表达式

5.   ifcondition： 过滤value的条件,满足条件再传入expr. 可选表达式

6.   expr： 对满足条件的value进一步处理后生成新的元素放在新的字典中

 

1.3.  应用场景：

 

获取0-100的奇数.

1.   list = range(0, 101)  

2.   new_list = [value for value in list if value % 2]  

3.   print(new_list)  

 

将第一个列表中的元素作为键,第二个列表中的元素作为值生成新的字典

1.   questions = ['name', 'quest', 'favorite color']  

2.   answers = ['lancelot', 'the holy grail', 'blue']  

3.   new_dict = {q: a for q, a in zip(questions, answers) if not q == "name"}  

4.   print(new_dict)  

5.   #zip()函数可以成对读取元素  

 

得到当前目录下所有的文件

1.   import os  

2.   print("*" * 1000)  

3.  result = [filename for filename in os.listdir("./") if os.path.isfile("./" + filename)]  

4.   for v in result:  

5.   print(v)  

 

2.   赋值、浅拷贝、深拷贝的区别

 

2.1.  概述：

在python中一般对于可变数据类型来说，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给

个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。

 

2.2.  详细描述：

赋值： 传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变

1.   >>> alist=[1,2,3,['a','b']]  

2.   >>> b=alist  

3.   >>> print(b)  

4.   [1, 2, 3, ['a', 'b']]  

5.   >>> alist.append(5)  

6.   >>> print(alist);  

7.   >>> print(b);  

   

8. [1, 2, 3, ['a', 'b'], 5]  

9. [1, 2, 3, ['a', 'b'], 5]  

 

浅拷贝： 没有拷贝子对象，所以原始数据改变，子对象会改变

1.   >>> import copy  

2.   >>> alist=[1, 2, 3, ['a', 'b'], 5]  

3.   >>> c=copy.copy(alist)  

4.   >>> print(alist)  

    

5.   [1, 2, 3, ['a', 'b'], 5]  

  

6.   >>> print(c)  

   

7. [1, 2, 3, ['a', 'b'], 5]  

   

8. >>> alist.append(6)  

9. >>> print(alist)  

10. >>> print(c)   

   

11. [1, 2, 3, ['a', 'b'], 5, 6]  

12. [1, 2, 3, ['a', 'b'], 5]  

   

 

   

13. >>> alist.append('itsource.cn')  

14. >>> print(alist)  

16. >>> print(c)  

   

17. [1, 2, 3, ['a', 'b'], 5, 6, 'itsource.cn']  

18. [1, 2, 3, ['a', 'b'], 5]  

   

19. >>> print(alist[3])  

   

20. ['a', 'b']  

   

21. # 改变子对象中的内容  

22. >>>alist[3].append('itsource.cn')  

23. >>>print(alist)  

24. >>>print(c)  

   

25. [1, 2, 3, ['a', 'b', 'itsource.cn'], 5, 6, 'itsource.cn']  

26. [1, 2, 3, ['a', 'b', 'itsource.cn'], 5]  

 

深拷贝：包含对象里面的子对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子对象的改变

 

1.   >>> import copy  

2.   >>> alist=[1,2,3,['a','b']]  

3.   >>> d=copy.deepcopy(alist)  

4.   >>> print(alist)  

5.   >>> print(d)  

  

6.   [1, 2, 3, ['a', 'b']]  

7.   [1, 2, 3, ['a', 'b']]  

   

  

8. #发现始终没有改变  

9. >>> alist.append(5)  

10. >>> print(alist)  

11. >>> print(d)  

   

11. [1, 2, 3, ['a', 'b'], 5]  

12. [1, 2, 3, ['a', 'b']]  

  

13. #发现始终没有改变  

14. >>> alist=[1,2,3,['a','b']]  

15. >>> print(alist[3])  

   

16. ['a', 'b']  

  

17. >>> alist[3].append('itsource.cn')  

18. >>> print(alist)  

19. >>> print(d)  

   

20. [1, 2, 3, ['a', 'b', 'itsource.cn']]  

21. [1, 2, 3, ['a', 'b']]  

 

总结：

1. 赋值是将一个对象的地址赋值给一个变量，让变量指向该地址（ 旧瓶装旧酒 ）。

 

2. 浅拷贝是在另一块地址中创建一个新的变量或容器，但是容器内的元素的地址均是源对象的元素的

的拷贝。也就是说新的容器中指向了旧的元素（ 新瓶装旧酒 ）。

 

3. 深拷贝是在另一块地址中创建一个新的变量或容器，同时容器内的元素的地址也是新开辟的，仅仅

相同而已，是完全的副本。也就是说（ 新瓶装新酒 ）。

 

2.3.  应用场景：

在python的大部分操作都是浅拷贝，比如：

1. 使用切片方法[]操作；

2. 使用构造函数（list/dict/set）；

3. 使用copy.copy方法；

 

3.   反转列表或者字符串

 

3.1.  概述：

大概有两种实现方式： 自身的方法 和 切片 。

 

3.2.  详细描述：

字符串反转：

 

1. 切片

1.   str = "abcdefg"  

2.   print(str[::-1])  

   

3.   gfedcba  

 

2. 先将其转换为列表， 使用列表的reverse反转方法，然后再连接成字符串

1.   str = "abcdefg"  

2.   l = list(s)  

3.   l.reverse()  

4.   result = "".join(l)  

5.   print(result)  

   

6.   gfedcba  

 

列表反转：

 

1. 切片

1.   l = ["a", "b", "c", "d", "e"]  

2.   print(l[::-1])  

          

           

3.   ['e', 'd', 'c', 'b', 'a']  

 

. 使用列表的reverse反转方法

1.   l = ["a", "b", "c", "d", "e"]  

2.   l.reverse()  

3.   print(l)  

           

          

4.   ['e', 'd', 'c', 'b', 'a']