原文链接：https://blog.csdn.net/hihell/article/details/89344558

 

一、Python里面如何实现tuple和list的转换？

函数tuple(seq)可以把所有可迭代的(iterable)序列转换成一个tuple, 元素不变，排序也不变

list转为tuple：

temp_list = [1,2,3,4,5]

将temp_list进行强制转换：tuple(temp_list)
确定是否转换成功：print(type(temp_list))

 

函数list(seq)可以把所有的序列和可迭代的对象转换成一个list,元素不变，排序也不变

tuple 转为list：

temp_tuple = (1,2,3,4,5)

方法类似，也是进行强制转换即可：list(temp_tuple)
确定是否转换成功：print(type(temp_tuple))

 

二、Python里面search()和match()的区别？

它们两个都在re模块中

• match()函数是在string的开始位置匹配，如果不匹配，则返回None;
• search()会扫描整个string查找匹配;

 

>>> import re
>>> print(re.match('hello','helloworld').span())  # 开头匹配到
(0, 5)
>>> print(re.match('hello','nicehelloworld').span()) # 开头没有匹配到
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    print(re.match('hello','nicehelloworld').span())
AttributeError: 'NoneType' object has no attribute 'span'
>>> 

>>> print(re.search('a','abc'))
<_sre.SRE_Match object; span=(0, 1), match='a'>
>>> print(re.search('a','bac').span())
(1, 2)
>>> 

三、 如何用Python删除一个文件？

os模块的使用

删除文件

os.remove(path)

删除文件 path，删除时候如果path是一个目录， 抛出 OSError错误。如果要删除目录，请使用rmdir()。

remove() 同 unlink() 的功能是一样的

 os.remove('a.txt')

os.removedirs(path)

 

递归地删除目录。类似于rmdir(), 如果子目录被成功删除， removedirs() 将会删除父目录；但子目录没有成功删除，将抛出错误。

例如， os.removedirs(“a/b/c”) 将首先删除c目录，然后再删除b和a, 如果他们是空的话，则子目录不能成功删除，将抛出 OSError异常

os.rmdir(path)
删除目录 path，要求path必须是个空目录，否则抛出OSError错误

四、 is 和 == 的区别？

python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)

4.1、id 身份标识，就是在内存中的地址

4.2、Python的字符串驻留机制。对于较小的字符串，为了提高系统性能Python会保留其值的一个副本。

4.3、Python 为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。而Python 对小整数的定义是 [-5, 257)

>>> a = 'hello'
>>> b = 'hello'
>>> print(a is b)
True
>>> print(a==b)
True
>>> a = 'hello world'
>>> b = 'hello world'
>>> print(a is b)
False
>>> print(a == b)
True
>>> a = [1,2,3]
>>> b = [1,2,3]
>>> print(a is b)
False
>>> print(a == b)
True
>>> a = [1,2,3]
>>> b = a
>>> print(a is b)
True
>>> print(a == b)
True
>>> 

• ==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等
• is也被叫做同一性运算符（对象标示符），这个运算符比较判断的是对象间的唯一身份标识，也就是id（内存中的地址）是否相同

我们在检查 a is b 的时候，其实相当于检查 id(a) == id(b)。而检查a == b 的时候，实际是调用了对象 a 的 __eq()__ 方法，a == b 相当于 a.__eq__(b)。

这里还有一个问题，为什么 a 和 b 都是 “hello” 的时候，a is b 返回True，而 a 和 b都是 “hello world” 的时候，a is b 返回False呢？

这是因为前一种情况下Python的字符串驻留机制起了作用。对于较小的字符串，为了提高系统性能Python会保留其值的一个副本，当创建新的字符串的时候直接指向该副本即可。

所以 “hello” 在内存中只有一个副本，a 和 b 的 id 值相同，而 “hello world” 是长字符串，不驻留内存，Python中各自创建了对象来表示 a 和 b，所以他们的值相同但 id 值不同。

试一下当a=247,b=247时它们的id还是否会相等。事实上Python 为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。而Python 对小整数的定义是 [-5, 257)，只有数字在-5到256之间它们的id才会相等，超过了这个范围就不行了。

 

>>> a = 247
>>> b = 247
>>> print(a is b)
True
>>> a = 258
>>> b = 258
>>> print(a is b)
False
>>> 

is 是检查两个对象是否指向同一块内存空间，而 ==是检查他们的值是否相等。is比==更加严格

 

五、a=1, b=2, 不用中间变量交换a和b的值？

>>> a = 5
>>> b = 6
>>> a = a+b
>>> b = a-b
>>> a = a-b

 

a,b = b,a

六、说说你对zen of python的理解，你有什么办法看到它?python之禅

The Zen of Python

在python命令行运行 Import this就会显示上面的诗歌：

>>> import this

The Zen of Python, by Tim Peters

 

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren't special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently.

Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one-- and preferably only one --obvious way to do it.

Although that way may not be obvious at first unless you're Dutch.

Now is better than never.

Although never is often better than *right* now.

If the implementation is hard to explain, it's a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea -- let's do more of those!

 

中文翻译：

 

优美胜于丑陋

明了胜于晦涩

简单胜于复杂

复杂胜于杂乱

扁平胜于嵌套

间隔胜于紧凑

可读性很重要

特例不足以特殊到违背这些原则

不要忽视错误，除非程序需要这样做

面对模棱两可，拒绝猜测

解决问题最直接的方法应该有一种，最好只有一种

可能这种方法一开始不够直接，因为你不是范罗苏姆

做也许好过不做，但不想就做还不如不做

如果方案难以描述明白，那么一定是个糟糕的方案

如果容易描述，那么可能是个好方案

命名空间是一种绝妙的理念，多加利用