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

2019/06/26 12:00 分类： 技术交流 浏览：1

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

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

列表推导式的语法：

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 进一步处理后生成新的元素放在新的字典中

获取 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. 赋值、浅 拷贝 、深拷贝的区别

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

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

赋值： 传递对象的引用而已 , 原始列表改变，被赋值的 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]

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

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

3. >>> d=copy.deepcopy(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. str = "abcdefg"

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

3. gfedcba

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

2. l = list(s)

3. l.reverse()

4. result = "".join(l)

5. print (result)

6. gfedcba

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

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

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

. 使用列表的 reverse 反转方法

2. l.reverse()

3. print (l)

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