Python

Python是如何进行内存管理的？

Python得解释器负责的；对python语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称python语言为动态类型的原因。
引用计数为主，标记-清除和分代回收主要是为了处理循环引用的难题。
1.对象的引用计数机制；2.垃圾回收机制；3.内存池
python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。所有这些都是自动完成
一、对象的引用计数机制
Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。
引用计数增加的情况：
1，一个对象分配一个新名称
2，将其放入一个容器中（如列表、元组或字典）
引用计数减少的情况：
1，使用del语句对对象别名显示的销毁
2，引用超出作用域或被重新赋值
sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。
二、垃圾回收
1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。
三、内存池机制
python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。
python的内存机制成金字塔形：第-1，-2层主要有操作系统进行操作；第0层是C中的malloc，free等内存分配和释放函数进行操作；第1层和第2层是内存池，有python的接口函数PyMem_Malloc函数实现，当对象小于256字节时由该层直接分配内存；第三层是最上层，也就是我们对python对象的直接操作；

什么是lambda函数？它有什么好处?

匿名函数，利用回调使用；lambda是一个表达式，而并非语句；因为lambda是一个表达式，所以在python语言中可以出现在def语句所不能出现的位置上；lambda与def语句相比较，后者必须在一开始就要将新函数命名；而前者返回一个新函数，可以有选择性的赋值变量名；lambda主体只是单个表达式，并而一个代码块。
“lambda有起到速写函数的作用，允许在使用的代码内嵌入一个函数的定义。在仅需要嵌入一小段可执行代码的情况 下，就可以带来更简洁的代码结构。”
当程序代码很短，且该函数只使用一次，为了程序的简洁，及节省变量内存占用空间，引入了匿名函数这个概念

请写出一段Python代码实现删除一个list里面的重复元素

答：
1,使用set函数，set(list)
2，使用循环，加入另一个列表 if i not in list：newlist.append(i)

[L2.append(i) for i in L1 if i not in L2]

Python里面如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别）

答：赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用
浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}。浅拷贝没有拷贝子对象，所以原对象发生改变，其子对象也发生了改变，
深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}；而深拷贝拷贝了子对象，原对象发生改变，其本身也不会改变。
python中copy和deepcopy区别
1、复制不可变数据类型，不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。

2、复制的值是可变对象（列表和字典）
浅拷贝copy有两种情况：
第一种情况：复制的 对象中无复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。
第二种情况：复制的对象中有复杂子对象 （例如列表中的一个子元素是一个列表）， 改变原来的值中的复杂子对象的值 ，会影响浅复制的值。
深拷贝deepcopy：完全复制独立，包括内层列表和字典

介绍一下except的用法和作用？

try…except…except…[else…][finally…]

执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行如果存在finally语句，最后总是会执行。

Python中pass语句的作用是什么？

答：pass语句不会执行任何操作，一般作为占位符或者创建占位程序，whileFalse:pass

介绍一下Python下range()函数的用法？

答：列出一组数据，经常用在for in range()循环中

如何用Python来进行查询和替换一个文本字符串？

答：可以使用re模块中的sub()函数或者subn()函数来进行查询和替换
格式：sub(replacement, string[,count=0])（replacement是被替换成的文本，string是需要被替换的文本，count是一个可选参数，指最大被替换的数量）

import re
p=re.compile(''red|blue|black')
print(p.sub('color','blue shoes and red skirts')
print(p.sub(‘colour’,'blue socks and red shoes’, count=1))

输出：

colour socks and colour shoes
colour socks and red shoes

**subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量**

例如：

import re
p = re.compile(‘(blue|white|red)’)
print(p.subn(‘colour’,'blue socks and red shoes’))
print(p.subn(‘colour’,'blue socks and red shoes’, count=1))

输出

(‘colour socks and colour shoes’, 2)

(‘colour socks and red shoes’, 1)

字符串：
.find();.replace()

words = 'Python is a very funny language!'  
>>> words.find('Python')             # 返回的为0或正数时，为其索引号  
0  
>>> words.find('is')  
7  
>>> words.find('dafa')               # 返回-1表示查找失败  
-1  
>>> words.replace('Python', 'Perl')  # replace()替换  
'Perl is a very funny language!'  

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

答：re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。也就是说match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none
re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。

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

答：术语叫贪婪匹配( <.> )尽可能多的匹配和非贪婪匹配(<.?>）匹配少的

例如:

<div><span>test</span></div>
<.*> :<div><span>test</span></div>
<.*?> :<div>

Python里面如何生成随机数？

答：random模块
随机整数：random.randint(a,b)：返回随机整数x,a<=x<=b
random.randrange(start,stop,[,step])：返回一个范围在(start,stop,step)之间的随机整数，不包括结束值。
随机实数：random.random( ):返回0到1之间的浮点数
random.uniform(a,b):返回指定范围内的浮点数。
python中生成随机整数、随机小数、0–1之间小数方法

随机整数：random.randint(a,b),生成区间内的整数
随机小数：习惯用numpy库，利用**numpy.random.randn(5)**生成5个随机小数
0-1随机小数：random.random(),括号中不传参

import random
random.randint(a,b)
random.randrange(start,stop,[,step])
random.random()
random.uniform(a,b)

有没有一个工具可以帮助查找python的bug和进行静态的代码分析？

答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告**;PyChecker会导入所检查文件中包含的模块，检查导入是否正确，同时检查文件中的函数、类和方法等。
Pylint是另外一个工具可以进行codingstandard检查,Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误，查找不符合代码风格标准**（Pylint 默认使用的代码风格是 PEP 8）和有潜在问题的代码。
https://blog.csdn.net/permike/article/details/51026156

如何在一个function里面设置一个全局的变量？

答：解决方法是在function的开始插入一个global声明：
def f()
global x

单引号，双引号，三引号的区别

答：单引号和双引号是等效的，如果要换行，需要符号(),三引号则可以直接换行，并且可以包含注释

如何用Python来发送邮件？

可以使用smtplib标准库。
先初始化SMTPserver，sender，password，定义mailserver=smtplib.SMTP(self.SMTPServer,25),mailserver.login;
定义sendmail方法sendmail(self,message,title, receiver)，msg;mailserver.sendmail()
定义exit；mailserver.quit()

import smtplib
from email.mime.text import MIMEText
class sendemail():
    def __init__(self,SMTPserver,sender,password):
        self.SMTPserver = SMTPserver
        self.sender = sender
        self.password = password
        self.mailserver = smtplib.SMTP(self.SMTPserver,25)
        self.mailserver.login(self.sender,self.password)
    def sendmail(self,message,title, receiver):
        msg = MIMEText(message)
        msg['subject']=title
        msg['From']=self.sender
        msg['To']=receiver
        self.mailserver.sendmail(self.sender,receiver,msg.as_string())
    def exit(self):
        self.mailserver.quit()
sendemail1=sendemail('','','')
sendemail1.sendmail('','','')
sendemail1.exit()

Python如何实现单例模式？

单例模式（Singleton Pattern）的主要目的是确保某一个类只有一个实例存在。
实现单例模式的几种方式
1.使用模块：因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。
2.使用装饰器：@Singleton
单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
函数装饰器

def singleton(cls):
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]
    return inner
    
@singleton
class Cls(object):
    def __init__(self):
        pass

类装饰器

class Singleton(object):
    def __init__(self, cls):
        self._cls = cls
        self._instance = {}
    def __call__(self):
        if self._cls not in self._instance:
            self._instance[self._cls] = self._cls()
        return self._instance[self._cls]

@Singleton
class Cls2(object):
    def __init__(self):
        pass

cls1 = Cls2()
cls2 = Cls2()
print(id(cls1) == id(cls2))

3.使用类：为了保证线程安全需要在内部加入锁
4.基于__new__方法实现（推荐使用，方便）：实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.new），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化
实现__new__方法
#并在将一个类的实例绑定到类变量_instance上,
#如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
#如果cls._instance不为None,直接返回cls._instance

class Single(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance
    def __init__(self):
        pass

single1 = Single()
single2 = Single()
print(id(single1) == id(single2))

5.基于metaclass方式实现：metaclass = Singleton；将 metaclass 指向 Singleton 类，让 Singleton 中的 type 来创造新的 MyClass3实例。

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass3(object):  
      __metaclass__ = Singleton

cls1 = Cls4()
cls2 = Cls4()
print(id(cls1) == id(cls2))

python程序中文输出问题怎么解决？

在Python3中，对中文进行了全面的支持，但在Python2.x中需要进行相关的设置才能使用中文。否则会出现乱码。
Python默认采取的ASCII编码，字母、标点和其他字符只使用一个字节来表示，但对于中文字符来说，一个字节满足不了需求。
为了能在计算机中表示所有的中文字符，中文编码采用两个字节表示。如果中文编码和ASCII混合使用的话，就会导致解码错误，从而才生乱码。
解决办法:
1.交互式命令中：一般不会出现乱码，无需做处理
2.py脚本文件中：设置系统默认编码

#!/usr/bin/env python
#coding=utf-8

#!/usr/bin/ env python -*- coding:UTF-8 -*-

3.其次需将文件保存为UTF-8的格式！
4. 最后: s.decode(‘utf-8’).encode(‘gbk’)
用encode和decode
decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode(‘gb2312’)，表示将gb2312编码的字符串str1转换成unicode编码。
encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode(‘gb2312’)，表示将unicode编码的字符串str2转换成gb2312编码。

python代码得到列表list的交集与差集

交集

b1=[1,2,3]

b2=[2,3,4]

b3 = [val for val in b1if val in b2]
print b3

res=set(b1).intersection(set(b2))

差集

b1=[1,2,3]
b2=[2,3,4]
b3 = [val for val in b1 if val not in b2]
print b3
res=set(b1).difference(set(b2))#b1有b2没有


并集
res=set(b1).union(set(b2))

写一个简单的python socket编程

python 编写server的步骤：
1第一步是创建socket对象。调用socket构造函数。如：socket = socket.socket(family, type )
family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信。type参数代表套接字类型，可为SOCK_STREAM(流套接字，TCP)和SOCK_DGRAM(数据报套接字，UDP)。
2.第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：
socket.bind( address )由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。
3.第三步是使用socket套接字的listen方法接收连接请求。socket.listen( backlog )
backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。
4.第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。
connection, address =socket.accept()
调用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素address是客户的Internet地址。
5. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv 时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最大数据量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符串，