python 基础

基础

1.python的解释器和特点

Python是一门解释器语言，代码想运行，必须通过解释器执行，Python存在多种解释器，分别基于不同语言开发，每个解释器有不同的特点，但都能正常运行Python代码，以下是常用的五种Python解释器：

CPython

当 从Python官方网站下载并安装好Python2.7后，就直接获得了一个官方版本的解释器：Cpython，这个解释器是用C语言开发的，所以叫 CPython，在命名行下运行python，就是启动CPython解释器，CPython是使用最广的Python解释器。

IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器虽然外观不同，但内核其实是调用了IE。

PyPy

PyPy是另一个Python解释器，它的目标是执行速度，PyPy采用JIT技术，对Python代码进行动态编译，所以可以显著提高Python代码的执行速度。

Jython

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

在Python的解释器中，使用广泛的是CPython，对于Python的编译，除了可以采用以上解释器进行编译外，技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码，十分的方便！

2.什么是解释型语言 和编译型语言

解释型：
使用专门的解释器对源程序逐行解释成特定平台的机器码(专门python的)，python解释器能够识别 然后可以执行。python等
编译型：
在编译型语言写的程序执行之前，需要一个专门的编译过程，把

源代码——》编译成.s汇编代码（通过编译器、 编译过程）——》目标代码.o文件（汇编器、汇编过程）-》编译成机器语言的文件

，如exe格式的文件，以后要再运行时，直接使用编译结果即可，如直接运行exe文件。因为只需编译一次，以后运行时不需要编译，所以编译型语言执行效率高。 c、c++语言

3.PEP8规范

是python的编程规范 以及命名、空格、缩进等

4.is和== 的区别

is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同

== 是判断两个value（值）是否相等

5.python的可变对象与不可变

不可变：
Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。

可变：
列表list、字典dict、集合set是可变类型。

6.字节码和机器码的区别

解释器能够是别的是字节码，能够通过操作系统的不同生成不同的机器码

7.python如何进行内存管理的

从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制。

1、对象的引用计数机制

Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。

引用计数增加的情况：

1，一个对象分配一个新名称
2，将其放入一个容器中（如列表、元组或字典）

引用计数减少的情况：

1，使用del语句对对象别名显示的销毁
2，引用超出作用域或被重新赋值

sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

2、垃圾回收

1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。

2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

3、内存池机制

Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。

1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。

2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。

3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

8.python中深浅拷贝的区别？

浅拷贝没有拷贝子对象，所以原对象发生改变，其子对象也发生了改变，而深拷贝拷贝了子对象，原对象发生改变，其本身也不会改变。

浅拷贝：（数据半共享

l1 = [1,2,3,[11,22,33]]
l2 = l1.copy()
print(l2) #[1,2,3,[11,22,33]]
l2[3][2]='aaa'
print(l1) #[1, 2, 3, [11, 22, 'aaa']]
print(l2) #[1, 2, 3, [11, 22, 'aaa']]

深拷贝：（数据完全不共享

import copy
l1 = [1, 2, 3, [11, 22, 33]]
# l2 = copy.copy(l1)  浅拷贝
l2 = copy.deepcopy(l1)

9.python下多线程的限制（全局解释锁）

一个线程就是一个轻量级进程，多线程能让我们一次执行多个线程。我们都知道，Python是多线程语言，其内置有多线程工具包。

Python中的GIL（全局解释器锁）确保一次执行单个线程。一个线程保存GIL并在将其传递给下个线程之前执行一些操作，这会让我们产生并行运行的错觉。但实际上，只是线程在CPU上轮流运行（并发）。当然，所有的传递会增加程序执行的内存压力。

10.用Python匹配HTML tag的时候，<.>和<.?>有什么区别？（贪婪匹配）

前者是贪婪匹配，会从头到尾匹配 xyz，而后者是非贪婪匹配，只匹配到第一个 >。

代码

1.字符串分隔函数split()

str1 = "3w.gorly.test.com.cn"

#使用默认分隔符分割字符串str1
>>> print str1.split()
['3w.gorly.test.com.cn']

#指定分隔符为'.'，进行分割字符串str1
>>> print str1.split('.')
['3w', 'gorly', 'test', 'com', 'cn']

2.去除列表重复元素

set() 函数

l1 = ['b','c','d','b','c','a','a'] 
l2 = list(set(l1)) 
print l2

还有一种据说速度更快的，没测试过两者的速度差别

l1 = ['b','c','d','b','c','a','a'] 
l2 = {}.fromkeys(l1).keys() 
print l2

这两种都有个缺点，祛除重复元素后排序变了：

[‘a’, ‘c’, ‘b’, ‘d’]

如果想要保持他们原来的排序：

用list类的sort方法

l1 = ['b','c','d','b','c','a','a'] 
l2 = list(set(l1)) 
l2.sort(key=l1.index) 
print l2

或者

l1 = ['b','c','d','b','c','a','a'] 
l2 = sorted(set(l1),key=l1.index) 
print l2

3.一行代码实现数值交换

a = 'sire'
b = 23
a,b = b,a

4.序列元素合并拼接

a = ['aaaa','bbb','cccc']
a = ' '.join(a)
print a
aaaa bbb cccc

5.python的三元运算

python 没有？：

可以使用如下

[on true] if [expression] else [on false]

如果表达式为True，就执行[on true]中的语句。否则，就执行[on false]中的语句。

下面是使用它的方法：

>>> a,b=2,3
>>> min=a if a<b else b
>>> min

运行结果：

2

6. 请解释使用args和*kwargs的含义

当我们不知道向函数传递多少参数时，比如我们向传递一个列表或元组，我们就使用*args。

>>> def func(*args):
    for i in args:
        print(i)  
>>> func(3,2,1,4,7)

运行结果为：

3 2 1 4 7

在我们不知道该传递多少关键字参数时，使用**kwargs来收集关键字参数。

>>> def func(**kwargs):
    for i in kwargs:
        print(i,kwargs[i])
>>> func(a=1,b=2,c=7)

运行结果为：

a.1 b.2 c.7

7.python如何实现单例对象

#使用__metaclass__（元类）的高级python用法

class Singleton2(type):  
    def __init__(cls, name, bases, dict):  
        super(Singleton2, cls).__init__(name, bases, dict)  
        cls._instance = None  
    def __call__(cls, *args, **kw):  
        if cls._instance is None:  
            cls._instance = super(Singleton2, cls).__call__(*args, **kw)  
        return cls._instance  
 
class MyClass3(object):  
    __metaclass__ = Singleton2  
 
one = MyClass3()  
two = MyClass3()  
 
two.a = 3  
print one.a  
#3  
print id(one)  
#31495472  
print id(two)  
#31495472  
print one == two  
#True  
print one is two  
#True

8.如何用Python删除一个文件？

使用os.remove(filename)或者os.unlink(filename);