Python语言特性
Python的函数参数传递
看两个例子:
1 | a = 1 |
1 | a = [] |
所有的变量都可以理解是内存中一个对象的“引用”,或者,也可以看似c中void*的感觉。
通过id
来看引用a
的内存地址可以比较理解:
1 | a = 1 |
注:具体的值在不同电脑上运行时可能不同。
可以看到,在执行完a = 2
之后,a
引用中保存的值,即内存地址发生变化,由原来1
对象的所在的地址变成了2
这个实体对象的内存地址。
而第2个例子a
引用保存的内存值就不会发生变化:
1 | a = [] |
这里记住的是类型是属于对象的,而不是变量。而对象有两种,“可更改”(mutable)与“不可更改”(immutable)对象。在python中,strings, tuples, 和numbers是不可更改的对象,而 list, dict, set 等则是可以修改的对象。(这就是这个问题的重点)
当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了。所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改。
如果还不明白的话,这里有更好的解释: http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference
my conclusion
Python中一切事物皆对象,变量是对对象在内存中的存储和地址的抽象。
“=”(赋值号)是将右侧对象的内存地址赋值给左侧的变量。
1 | a = "abc" # 将“abc”的地址保存到“a”中 |
这样我们就能通过操作“a”而改变内存中的“abc”。
所以执行下面语句
1 | a = "123" |
第一句Python解释器创建字符串“123”和变量“a”,并把“a”指向“123”。
执行第二句,因为“a”已经存在,并不会创建新的对象,但会创建变量“b”, 并把“b”指向“a”指向的字符串“123“。
因为Python对象分为可变对象(list,dict,set等)和不可变对象(number,string,tuple等)。
当进行修改操作时,可变类型传递的是内存中的地址,也就是说,直接修改内存中的值,并没有开辟新的内存。
不可变类型被改变时,并没有改变原内存地址中的值,而是开辟一块新的内存,将原地址中的值复制过去,对这块新开辟的内存中的值进行操作。
没有指针,但是所有对象均为指针
python中的函数,如果是传递的tuple,那么是值传递;如果传递的参数类型是list,那么是引用传递。
Python中的元类(metaclass)
https://lotabout.me/2018/Understanding-Python-MetaClass/
对象的类型叫作类(class),类的类型就称作元类 meta-class
。是不是很像“爸爸的爸爸叫爷爷”?换句话说,“普通类(class)”可以用来生成实例(instance),同样的,元类 (meta-class)也可以生成实例,生成的实例就是“普通类”了。
可以使用type()动态的创建类以外,要控制类的行为,还可以使用metaclass。
这个非常的不常用,但是像ORM这种复杂的结构还是会需要的,详情请看:http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
@staticmethod和@classmethod
Python其实有3个方法,即静态方法(staticmethod), 类方法(classmethod)和实例方法,如下:
1 | def foo(x): |
这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定,对于一般的函数来说我们可以这么调用foo(x)
,这个函数就是最常用的,它的工作跟任何东西(类,实例)无关.对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x)
,为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)
(其实是foo(a, x)
).类方法一样,只不过它传递的是类而不是实例,A.class_foo(x)
.注意这里的self和cls可以替换别的参数,但是python的约定是这俩,还是不要改的好.
对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)
或者A.static_foo(x)
来调用.
\ | 实例方法 | 类方法 | 静态方法 |
---|---|---|---|
a = A() | a.foo(x) | a.class_foo(x) | a.static_foo(x) |
A | 不可用 | A.class_foo(x) | A.static_foo(x) |
更多关于这个问题:
- http://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python
- https://realpython.com/blog/python/instance-class-and-static-methods-demystified/
my conclusion
1、self表示一个具体的实例本身。如果用了staticmethod,那么就可以无视这个self,将这个方法当成一个普通的函数使用。
2、cls表示这个类本身。
python类里会出现这三个单词,self和cls都可以用别的单词代替,类的方法有三种。有利于组织代码,有利于命名空间的整洁。
一、类实例方法:是通过def定义的 普通的一般的,需要至少传递一个参数,一般用self,这样的方法必须通过一个类的实例去访问,类似于c++中通过对象去访问;
二、类方法:是在def前面加上@classmethod,形参为cls,表示类对象,类对象和实例对象都可调用。cls表示这个类本身。(可以使用类名和对象调用)
三、静态方法:是在def前面加上@staticmethod,这种类方法是静态的类方法,他的一个特点是参数可以为空,形参为self, 指代对象本身; 可以无视这个self,将这个方法当成一个普通的函数使用。(可以使用类名和对象调用)
1 | class A(object): |
类变量和实例变量
类变量:
是可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。例如下例中,num_of_instance 就是类变量,用于跟踪存在着多少个Test 的实例。
实例变量:
实例化之后,每个实例单独拥有的变量。
1 | class Test(object): |
补充的例子
1 | class Person: |
这里p1.name="bbb"
是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题,p1.name
一开始是指向的类变量name="aaa"
,但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量, self.name不再引用Person的类变量name了.
可以看看下面的例子:
1 | class Person: |
参考:http://stackoverflow.com/questions/6470428/catch-multiple-exceptions-in-one-line-except-block
Python自省
这个也是python彪悍的特性.
自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型。简单一句就是运行时能够获得对象的类型。比如type(),dir(),getattr(),hasattr(),isinstance()。
1 | a = [1,2,3] |
字典推导式
可能你见过列表推导时,却没有见过字典推导式,在2.7中才加入的:
1 | d = {key: value for (key, value) in iterable} |
Python中单下划线和双下划线
1 | class MyClass(): |
__foo__
:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突,就是例如__init__()
,__del__()
,__call__()
这些特殊方法
_foo
:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.不能用from module import * 导入,其他方面和公有一样访问;
__foo
:这个有真正的意义:解析器用_classname__foo
来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx这样的方式可以访问.
或者: http://www.zhihu.com/question/19754941
字符串格式化:%和.format
.format在许多方面看起来更便利.对于%
最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:
1 | "hi there %s" % name |
但是,如果name恰好是(1,2,3),它将会抛出一个TypeError异常.为了保证它总是正确的,你必须这样做:
1 | "hi there %s" % (name,) # 提供一个单元素的数组而不是一个参数 |
但是有点丑。.format就没有这些问题。你给的第二个问题也是这样,.format好看多了。
你为什么不用它?
- 不知道它(在读这个之前)
- 为了和Python2.5兼容(譬如logging库建议使用
%
(issue #4))
1 | sub1 = "python string!" |
http://stackoverflow.com/questions/5082452/python-string-formatting-vs-format
*args
and **kwargs
用*args
和**kwargs
只是为了方便并没有强制使用它们.
当你不确定你的函数里将要传递多少参数时你可以用`*args`.例如,它可以传递任意数量的参数:
1 | def print_everything(*args): |
相似的,kwargs
允许你使用没有事先定义的参数名:
1 | def table_things(**kwargs): |
你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给*args
和**kwargs
.命名参数在列表的最前端.例如:
1 | def table_things(titlestring, **kwargs) |
*args
和**kwargs
可以同时在函数的定义中,但是*args
必须在kwargs
前面.
当调用函数时你也可以用*
和**
语法.例如:
1 | def print_three_things(a, b, c): |
就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*.
http://stackoverflow.com/questions/3394835/args-and-kwargs
鸭子类型
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
我们并不关心对象是什么类型,到底是不是鸭子,只关心行为。
比如在python中,有很多file-like的东西,比如StringIO,GzipFile,socket。它们有很多相同的方法,我们把它们当作文件使用。
又比如list.extend()方法中,我们并不关心它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等.
鸭子类型在动态语言中经常使用,非常灵活,使得python不像java那样专门去弄一大堆的设计模式。
Python中重载
引自知乎:http://www.zhihu.com/question/20053359
函数重载主要是为了解决两个问题。
- 可变参数类型。
- 可变参数个数。
另外,一个基本的设计原则是,仅仅当两个函数除了参数类型和参数个数不同以外,其功能是完全相同的,此时才使用函数重载,如果两个函数的功能其实不同,那么不应当使用重载,而应当使用一个名字不同的函数。
好吧,那么对于情况 1 ,函数功能相同,但是参数类型不同,python 如何处理?答案是根本不需要处理,因为 python 可以接受任何类型的参数,如果函数的功能相同,那么不同的参数类型在 python 中很可能是相同的代码,没有必要做成两个不同函数。
那么对于情况 2 ,函数功能相同,但参数个数不同,python 如何处理?大家知道,答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同,那么那些缺少的参数终归是需要用的。
好了,鉴于情况 1 跟 情况 2 都有了解决方案,python 自然就不需要函数重载了。
新式类和旧式类
这个面试官问了,我说了老半天,不知道他问的真正意图是什么.
这篇文章很好的介绍了新式类的特性: http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html
新式类很早在2.2就出现了,所以旧式类完全是兼容的问题,Python3里的类全部都是新式类.这里有一个MRO问题可以了解下(新式类继承是根据C3算法,旧式类是深度优先),
一个旧式类的深度优先的例子
1 | class A(): |
按照经典类的查找顺序从左到右深度优先
的规则,在访问d.foo1()
的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1(),从而导致C重写的foo1()被绕过
新式类中特殊的只读属性__mro__
,类型是一个元组,保存着解析顺序信息。
super
- 使用方法
想在子类中调用父类的某个已经被覆盖的方法。
1 | class A: |
- 使用场景
(1) super()
函数的一个常见用法是在 __init__()
方法中确保父类被正确的初始化了,保证相同的基类只初始化一次。
1 | class A: |
(2) 解决多重继承中,子类重复调用父类方法的问题
super()使您避免显式引用基类。但是主要优势来自多重继承(直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。)
对于你定义的每一个类,Python会计算出一个所谓的方法解析顺序(MRO)列表。如果对于下一个类存在两个合法的选择,选择第一个父类。
只要每个重定义的方法统一使用 super()
并只调用它一次, 那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次。
https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html
http://stackoverflow.com/questions/576169/understanding-python-super-with-init-methods
__new__
和__init__
的区别
这个__new__
确实很少见到,先做了解吧.
当创建一个新实例时调用
__new__
,初始化一个实例时用__init__
.__new__
是一个静态方法,而__init__
是一个实例方法.__new__
方法会返回一个创建的实例,而__init__
什么都不返回.只有在
__new__
返回一个cls的实例时后面的__init__
才能被调用.
ps: __metaclass__
是创建类时起作用.所以我们可以分别使用__metaclass__
,__new__
和__init__
来分别在类创建,实例创建和实例初始化的时候做一些小手脚.
Python中的作用域
Python 中,一个变量的作用域总是由在代码中被赋值的地方所决定的。
当 Python 遇到一个变量的话他会按照这样的顺序进行搜索:
函数作用域的LEGB顺序
本地作用域(Local)→ 函数内部与内嵌函数之间(Enclosing locals)→全局/模块作用域(Global)→内建作用域(Built-in)
GIL线程全局锁
线程全局锁(Global Interpreter Lock), 即Python为了保证线程安全而采取的独立线程运行的限制, 说白了就是一个核只能在同一时间运行一个线程.对于io密集型任务,python的多线程起到作用,但对于cpu密集型任务,python的多线程几乎占不到任何优势,还有可能因为争夺资源而变慢。
解决办法就是多进程的协程(协程也只是单CPU,但是能减小切换代价提升性能).
lambda函数
lambda函数是匿名函数,使用lambda函数能创建小型匿名函数,这种函数得名于省略了用def声明函数的标准步骤
1.lambda函数比较轻便,即用即仍,很适合需要完成一项功能,但是此功能只在此一处使用,连名字都很随意的情况下
2.匿名函数,一般用来给filter,map这样的函数式编程服务
3.作为回调函数,传递给某些应用,比如消息处理
其实就是一个匿名函数,为什么叫lambda?因为和后面的函数式编程有关.
1 | add = lambda x, y: x + y |
推荐: 知乎
Python函数式编程(filter…)
这个需要适当的了解一下吧,毕竟函数式编程在Python中也做了引用.
推荐: 酷壳
python中函数式编程支持:
filter 函数的功能相当于过滤器。调用一个布尔函数bool_func
来迭代遍历每个seq中的元素;返回一个使bool_seq
返回值为true的元素的序列。
1 | >>>a = [1,2,3,4,5,6,7] |
map函数是对一个序列的每个项依次执行函数,下面是对一个序列每个项都乘以2:
1 | map(lambda x:x*2,[1,2,3]) a = |
reduce函数是对一个序列的每个项迭代调用函数,下面是求3的阶乘:
1 | lambda x,y:x*y,range(1,4)) reduce( |
Python里的拷贝
引用和copy(),deepcopy()的区别
1 | import copy |
Python中的赋值:
赋值的本质就是将一个对象的内存空间地址赋值给一个变量,让变量指向该内存空间地址。
Python浅拷贝:
只拷贝父对象(不可变对象)的地址,子对象(可变对象)的地址还是原来的。
浅拷贝是拷贝了源对象的引用,并创建了一个新的内存空间地址。但是引用的对象的子对象的地址仍然是源对象的,所以当源对象的子对象发生改变时,拷贝对象内的子对象同时也跟着改变。
Python深拷贝:
拷贝父对象和子对象。
深拷贝就是彻底的拷贝,完全的拷贝了父对象及子对象,同时指向一个新的内存空间地址。源对象与拷贝对象之间的修改互不影响。
Python垃圾回收机制
Python GC主要使用引用计数(reference counting)来跟踪和回收垃圾。在引用计数的基础上,通过“标记-清除”(mark and sweep)解决容器对象可能产生的循环引用问题,通过“分代回收”(generation collection)以空间换时间的方法提高垃圾回收效率。
1 引用计数
PyObject是每个对象必有的内容,其中ob_refcnt
就是做为引用计数。当一个对象有新的引用时,它的ob_refcnt
就会增加,当引用它的对象被删除,它的ob_refcnt
就会减少.引用计数为0时,该对象生命就结束了。
优点:
- 简单
- 实时性
缺点:
- 维护引用计数消耗资源
- 循环引用
2 标记-清除机制
基本思路是先按需分配,等到没有空闲内存的时候从寄存器和程序栈上的引用出发,遍历以对象为节点、以引用为边构成的图,把所有可以访问到的对象打上标记,然后清扫一遍内存空间,把所有没标记的对象释放。
3 分代回收
分代回收的整体思想是:将系统中的所有内存块根据其存活时间划分为不同的集合,每个集合就成为一个“代”,垃圾收集频率随着“代”的存活时间的增大而减小,存活时间通常利用经过几次垃圾回收来度量。
Python默认定义了三代对象集合,索引数越大,对象存活时间越长。
举例:
当某些内存块M经过了3次垃圾收集的清洗之后还存活时,我们就将内存块M划到一个集合A中去,而新分配的内存都划分到集合B中去。当垃圾收集开始工作时,大多数情况都只对集合B进行垃圾回收,而对集合A进行垃圾回收要隔相当长一段时间后才进行,这就使得垃圾收集机制需要处理的内存少了,效率自然就提高了。在这个过程中,集合B中的某些内存块由于存活时间长而会被转移到集合A中,当然,集合A中实际上也存在一些垃圾,这些垃圾的回收会因为这种分代的机制而被延迟。
Python的List
推荐: http://www.jianshu.com/p/J4U6rR
Python的is和==
is是对比地址(id())
==是对比值(eql())
read,readline和readlines
- read 读取整个文件
- readline 读取下一行,使用生成器方法;从文件读取整行,包括 “\n” 字符。如果指定了一个非负数的参数,则返回指定大小的字节数,包括 “\n” 字符。
- readlines 读取整个文件到一个迭代器以供我们遍历
1 | for line in fo.readlines(): #依次读取每行 |
Python2和3的区别
推荐:Python 2.7.x 与 Python 3.x 的主要差异
python2中可以使用
__future__
模块,来导入python3的特性print函数
- Python2 的默认编码是 asscii,这也是导致 Python2 中经常遇到编码问题的原因之一。Python 3 默认采用了 UTF-8 作为默认编码。
- 整除
1 | # Python2 |
- 在 Python 3 中已经解决了把用户的输入存储为一个 str 对象的问题(input())。为了避免在 Python 2 中的读取非字符串类型的危险行为,我们不得不使用 raw_input() 代替。
range and xrange
都在循环时使用,xrange内存性能更好。
for i in range(0, 20):
for i in xrange(0, 20):
range创建一个列表,因此,如果执行range(1,10000000),它将在内存中创建一个包含9999999个元素的列表。
xrange是一个延迟计算的序列对象,类似于生成器。
python新式类和经典类的区别
a. 在python里凡是继承了object的类,都是新式类
b. Python3里只有新式类
c. Python2里面继承object的是新式类,没有写父类的是经典类
d. 经典类目前在Python里基本没有应用
e. 保持class与type的统一对新式类的实例执行a.class与type(a)的结果是一致的,对于旧式类来说就不一样了。
f.对于多重继承的属性搜索顺序不一样新式类是采用广度优先搜索,旧式类采用深度优先搜索。
python中内置的数据结构有几种
a. 整型 int、 长整型 long、浮点型 float、 复数 complex
b. 字符串 str、 列表 list、 元祖 tuple
c. 字典 dict 、 集合 set
d. Python3 中没有 long,只有无限精度的 int
编写函数的4个原则
函数设计要尽量短小
函数声明要做到合理、简单、易于使用
函数参数设计应该考虑向下兼容
一个函数只做一件事情,尽量保证函数语句粒度的一致性
hasattr() getattr() setattr() 函数使用详解?
hasattr(object,name)函数:
判断一个对象里面是否有name属性或者name方法,返回bool值,有name属性(方法)返回True,否则返回False。
1 | class function_demo(object): |
getattr(object, name[,default])函数:
获取对象object的属性或者方法,如果存在则打印出来,如果不存在,打印默认值,默认值可选。注意:如果返回的是对象的方法,则打印结果是:方法的内存地址,如果需要运行这个方法,可以在后面添加括号().
1 | functiondemo = function_demo() |
setattr(object, name, values)函数:
给对象的属性赋值,若属性不存在,先创建再赋值
1 | class function_demo(object): |
综合使用
1 | class function_demo(object): |
对缺省参数
缺省参数指在调用函数的时候没有传入参数的情况下,调用默认的参数,在调用函数的同时赋值时,所传入的参数会替代默认参数。
*args是不定长参数,它可以表示输入参数是不确定的,可以是任意多个。
**kwargs
是关键字参数,赋值的时候是以键值对的方式,参数可以是任意多对在定义函数的时候不确定会有多少参数会传入时,就可以使用两个参数
为什么函数名字可以当做参数用
Python中一切皆对象,函数名是函数在内存中的空间,也是一个对象
Python中pass语句的作用是什么
在编写代码时只写框架思路,具体实现还未编写就可以用pass进行占位,是程序不报错,不会进行任何操作。
Python高级
元类
遍历一个object的所有属性,并print每一个属性名?
1 | class Car: |
写一个类,并让它尽可能多的支持操作符?
1 | class Array: |
介绍Cython,Pypy Cpython Numba各有什么缺点
- Pypy最重要的一点就是Pypy集成了JIT。同时针对CPython的缺点进行了各方面的改良,性能得到很大的提升(官方宣称为6.3倍)。缺点是对很多C语言库支持性不好。
- Cython:Cython是让Python脚本支持C语言扩展的编译器,Cython能够将Python+C混合编码的.pyx脚本转换为C代码,主要用于优化Python脚本性能或Python调用C函数库。
- Numba:Numba是一个库,可以在运行时将Python代码编译为本地机器指令,而不会强制大幅度的改变普通的Python代码。
Pypy是非常理想的Python解释器,最大的瑕疵就是对部分库的兼容问题。Cython是一种Python + C的便利性组合,转为C编译的扩展执行效率非常高,但使用相对麻烦,移植CPython项目代价较高。Numba更适合针对性优化,效率高,并且不会大幅度的改变普通的Python代码。
请描述抽象类和接口类的区别和联系
从设计层面来说,抽象是对类的抽象,是一种模板设计,接口是行为的抽象,是一种行为的规范。
1.抽象类: 规定了一系列的方法,并规定了必须由继承类实现的方法。由于有抽象方法的存在,所以抽象类不能实例化。
2.接口类:与抽象类很相似,表现在接口中定义的方法,必须由引用类实现。
区别和关联:
1.接口是抽象类的变体,接口中所有的方法都是抽象的,而抽象类中可以有非抽象方法,而抽象类可以实现部分方法
2.抽象类可以继承,接口不行
3.接口中基本数据类型为static而抽象类不是
具体使用的场景
- 如果你拥有一些方法并且想让它们中的一些有默认实现,那么使用抽象类吧。
- 如果你想实现多重继承,那么你必须使用接口。由于Java不支持多继承,子类不能够继承多个类,但可以实现多个接口。因此你就可以使用接口来解决它。
- 如果基本功能在不断改变,那么就需要使用抽象类。如果不断改变基本功能并且使用接口,那么就需要改变所有实现了该接口的类。
- 多用组合,少用继承。
Python中如何动态获取和设置对象的属性?
1 | if hasattr(Parent, 'x'): |
内存管理与垃圾回收机制
哪些操作会导致Python内存溢出,怎么处理?
内存溢出原因:
- 内存中加载的数据量过于庞大,如一次从数据库中取出过多数据。
- 代码中存在死循环,或循环过多重复的对象实体。
- 使用的第三方软件中的BUG。
内存溢出的解决方案:
- 修改JVM启动参数,直接增加内存。
- 检查错误日志,查看“OutOfMemory”错误前是否有其他异常错误。
- 对代码进行走查和分析,找出可能发生内存溢出的位置。
内存泄露是什么?如何避免?
内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存。内存泄漏并非指内存在物理上的消失,而是应用程序分配某段内存后,由于设计错误,导致在释放该段内存之前就失去了对该段内存的控制,从而造成了内存的浪费。
避免手段:
有
__del__()
函数的对象间的循环引用是导致内存泄露的主凶。不使用一个对象时使用: del object 来删除一个对象的引用计数就可以有效防止内存泄露问题。通过Python扩展模块gc 来查看不能回收的对象的详细信息。
可以通过 sys.getrefcount(obj) 来获取对象的引用计数,并根据返回值是否为0来判断是否内存泄露。
关于Python内存管理,下列说法错误的是 B
A,变量不必事先声明 B,变量无须先创建和赋值而直接使用
C,变量无须指定类型 D,可以使用del释放资源
面向对象
Python的魔法方法
魔法方法就是可以给你的类增加魔力的特殊方法,如果你的对象实现(重载)了这些方法中的某一个,那么这个方法就会在特殊的情况下被Python所调用,你可以定义自己想要的行为,而这一切都是自动发生的,它们经常是两个下划线包围来命名的(比如__init___
,__len__
),Python的魔法方法是非常强大的所以了解其使用方法也变得尤为重要!
__init__
构造器,当一个实例被创建的时候初始化的方法,但是它并不是实例化调用的第一个方法。
__new__
才是实例化对象调用的第一个方法,它只取下cls参数,并把其他参数传给__init___
.
___new__
很少使用,但是也有它适合的场景,尤其是当类继承自一个像元祖或者字符串这样不经常改变的类型的时候。
__call__
让一个类的实例像函数一样被调用
__getitem__
定义获取容器中指定元素的行为,相当于self[key]
__getattr__
定义当用户试图访问一个不存在属性的时候的行为。
__setattr__
定义当一个属性被设置的时候的行为
__getattribute___
定义当一个属性被访问的时候的行为
面向对象中怎么实现只读属性?
将对象私有化,通过共有方法提供一个读取数据的接口
1 | class person: |
最好的方法
Python内置的@property
装饰器就是负责把一个方法变成属性调用的
1 | class MyCls(object): |
谈谈你对面向对象的理解?
面向对象是相当于面向过程而言的,面向过程语言是一种基于功能分析的,以算法为中心的程序设计方法,而面向对象是一种基于结构分析的,以数据为中心的程序设计思想。在面向对象语言中有一个很重要的东西,叫做类。面向对象有三大特性:封装、继承、多态。
设计模式
对设计模式的理解,简述你了解的设计模式?
设计模式是指面向对象的设计模式,是有经验的程序员对代码开放的经验总结。解决特定问题的一系列套路。目的是用来提高代码可复用性、可维护性、可读性、稳健型及安全性。
所以设计模式不是什么理论,也不是什么语法规定,没有对错只有适不适合或者好与不好。
不能为了使用设计模式而去做架构,而是有了特定架构需求,这种架构层次在进行基本展开后发现它符合某一类设计模式的结构,再将两者相结合。
设计模式按使用场景可以分为三大类
- 创建型模式:对象实例化的模式,用于对象的创建对业务或应用逻辑是强依赖
- 结构型模式:把类或对象结合在一起形成一个更大的结构。一般是解决不同的类之间有不同关系的情况
- 行为型模式:类和对象如何交互,及划分责任和算法
常见的是工厂模式和单例模式
https://www.zhihu.com/question/23757906
单例模式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。
__new__()
在__init__()
之前被调用,用于生成实例对象。利用这个方法和类的属性的特点可以实现设计模式的单例模式。单例模式是指创建唯一对象,单例模式设计的类只能实例
这个绝对常考啊.绝对要记住1~2个方法,当时面试官是让手写的.
1 import方法
作为python的模块是天然的单例模式
1 | # mysingleton.py |
2 使用__new__
方法
1 | class Student(object): |
3 装饰器版本
1 | def Singleton(cls): |
单例模式的应用场景有那些?
单例模式应用的场景一般发生在以下条件下:
控制资源的情况下,方便资源之间的互相通信。
如数据库连接池(因为数据库连接的创建和销毁很耗时)、线程池、日志对象、打印机等场景下。
装饰器和面向切面编程AOP
对装饰器的理解,并写出一个计时器记录方法执行性能的装饰器?
装饰器(给原有对象添加新的功能)是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有鉴权、插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。装饰器的返回值也是一个函数的对象
中文: http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/3/README.html
详细参考:https://manjusaka.itscoder.com/2018/02/23/something-about-decorator/
1 | import time |
闭包
闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构,它同样提高了代码的可重复使用性。
当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点:
- 必须有一个内嵌函数
- 内嵌函数必须引用外部函数中的变量
- 外部函数的返回值必须是内嵌函数
感觉闭包还是有难度的,几句话是说不明白的,还是查查相关资料.
重点是函数运行后并不会被撤销,就像单例模式-装饰器版本中的instance字典一样(装饰器),当函数运行完后,instance并不被销毁,而是继续留在内存空间里.这个功能类似类里的类变量,只不过迁移到了函数上.
闭包就像个空心球一样,你知道外面和里面,但你不知道中间是什么样.
迭代器,生成器的区别?
迭代器(iterator)是遵循迭代协议的对象。用户可以使用 iter() 以从任何序列得到迭代器(如 list, tuple, dictionary, set 等)。另一个方法则是创建一个另一种形式的迭代器 —— generator 。要获取下一个元素,则使用函数
__next()__
(Python 3)。当没有元素时,则引发 StopIteration 此例外。生成器(Generator),只是在需要返回数据的时候使用yield语句(yield就是保存当前程序执行状态)。每次next()被调用时,生成器会返回它脱离的位置(它记忆语句最后一次执行的位置和所有的数据值)
区别: 生成器也是一种迭代器,但只使用一次迭代。这是因为它们并没有把所有的值存在内存中,而是在运行时生成值。
这里有个关于生成器的创建问题面试官有考:
问: 将列表生成式中[]改成() 之后数据结构是否改变?
答案:是,从列表变为生成器
1 | for x in range(10)] L = [x*x |
通过列表生成式,可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含百万元素的列表,不仅是占用很大的内存空间,如:我们只需要访问前面的几个元素,后面大部分元素所占的空间都是浪费的。因此,没有必要创建完整的列表(节省大量内存空间)。在Python中,我们可以采用生成器:边循环,边计算的机制—>generator
官方介绍:https://docs.python.org/3/tutorial/classes.html#iterators
请用一行代码 实现将1-N 的整数列表以3为单位分组
1 | N =100 |
Python中yield的用法?
yield就是保存当前程序执行状态。你用for循环的时候,每次取一个元素的时候就会计算一次。用yield的函数叫generator,和iterator一样,它的好处是不用一次计算所有元素,而是用一次算一次,可以节省很多空间,generator每次计算需要上一次计算结果,所以用yield,否则一return,上次计算结果就没了
*NIX
unix进程间通信方式(IPC)
- 管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。
- 命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
- 信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送信号给进程本身;linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数)。
- 信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。
- 共享内存:使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。
- 内存映射(mapped memory):内存映射允许任何多个进程间通信,每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。
- 套接口(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:Linux和System V的变种都支持套接字。
- 消息(Message)队列:消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺。
文件操作
1 | import os |
有一个jsonline格式的文件file.txt大小约为10K
1 | def get_lines(): |
现在要处理一个大小为10G的文件,但是内存只有4G,如果在只修改get_lines 函数而其他代码保持不变的情况下,应该如何实现?需要考虑的问题都有那些?
1 | def get_lines(): |
个人认为:还是设置下每次返回的行数较好,否则读取次数太多。
1 | def get_lines(): |
Pandaaaa906提供的方法
1 | from mmap import mmap |
要考虑的问题有:内存只有4G无法一次性读入10G文件,需要分批读入分批读入数据要记录每次读入数据的位置。分批每次读取数据的大小,太小会在读取操作花费过多时间。
https://stackoverflow.com/questions/30294146/python-fastest-way-to-process-large-file
设计实现遍历目录与子目录,抓取.pyc文件
第一种方法:
1 | import os |
第二种方法:
1 | import os |
第三种方法
1 | from glob import iglob |
补充缺失的代码
1 | def print_directory_contents(sPath): |
模块与包
输入日期, 判断这一天是这一年的第几天?
1 | import datetime |
1 | import datetime |
打乱一个排好序的list对象alist?
1 | import random |
架构
Python后端架构演进
这篇文章几乎涵盖了python会用的架构,在面试可以手画架构图,根据自己的项目谈下技术选型和优劣,遇到的坑等。绝对加分
正则表达式
请写出一段代码用正则匹配出ip?
a = “abbbccc”,用正则匹配为abccc,不管有多少b,就出现一次?
思路:不管有多少个b替换成一个
re.sub(r'b+', 'b', a)
Python字符串查找和替换?
a、str.find():正序字符串查找函数
函数原型:
str.find(substr [,pos_start [,pos_end ] ] )
返回str中第一次出现的substr的第一个字母的标号,如果str中没有substr则返回-1,也就是说从左边算起的第一次出现的substr的首字母标号。
参数说明:
str:代表原字符串
substr:代表要查找的字符串
pos_start:代表查找的开始位置,默认是从下标0开始查找
pos_end:代表查找的结束位置
例子:
'aabbcc.find('bb')' # 2
b、str.index():正序字符串查找函数
index()函数类似于find()函数,在Python中也是在字符串中查找子串第一次出现的位置,跟find()不同的是,未找到则抛出异常。
函数原型:
str.index(substr [, pos_start, [ pos_end ] ] )
参数说明:
str:代表原字符串
substr:代表要查找的字符串
pos_start:代表查找的开始位置,默认是从下标0开始查找
pos_end:代表查找的结束位置
例子:
'acdd l1 23'.index(' ') # 4
c、str.rfind():倒序字符串查找函数
函数原型:
str.rfind( substr [, pos_start [,pos_ end ] ])
返回str中最后出现的substr的第一个字母的标号,如果str中没有substr则返回-1,也就是说从右边算起的第一次出现的substr的首字母标号。
参数说明:
str:代表原字符串
substr:代表要查找的字符串
pos_start:代表查找的开始位置,默认是从下标0开始查找
pos_end:代表查找的结束位置
例子:
'adsfddf'.rfind('d') # 5
d、str.rindex():倒序字符串查找函数
rindex()函数类似于rfind()函数,在Python中也是在字符串中倒序查找子串最后一次出现的位置,跟rfind()不同的是,未找到则抛出异常。
函数原型:
str.rindex(substr [, pos_start, [ pos_end ] ] )
参数说明:
str:代表原字符串
substr:代表要查找的字符串
pos_start:代表查找的开始位置,默认是从下标0开始查找
pos_end:代表查找的结束位置
例子:
'adsfddf'.rindex('d') # 5
e、使用re模块进行查找和替换:
函数 | 说明 |
---|---|
re.match(pat, s) | 只从字符串s的头开始匹配,比如(‘123’, ‘12345’)匹配上了,而(‘123’,’01234’)就是没有匹配上,没有匹配上返回None,匹配上返回matchobject |
re.search(pat, s) | 从字符串s的任意位置都进行匹配,比如(‘123’,’01234’)就是匹配上了,只要s只能存在符合pat的连续字符串就算匹配上了,没有匹配上返回None,匹配上返回matchobject |
re.sub(pat,newpat,s) | re.sub(pat,newpat,s) 对字符串中s的包含的所有符合pat的连续字符串进行替换,如果newpat为str,那么就是替换为newpat,如果newpat是函数,那么就按照函数返回值替换。sub函数两个有默认值的参数分别是count表示最多只处理前几个匹配的字符串,默认为0表示全部处理;最后一个是flags,默认为0 |
f、使用replace()进行替换:
基本用法:对象.replace(rgExp,replaceText,max)
其中,rgExp和replaceText是必须要有的,max是可选的参数,可以不加。
rgExp是指正则表达式模式或可用标志的正则表达式对象,也可以是 String 对象或文字;
replaceText是一个String 对象或字符串文字;
max是一个数字。
对于一个对象,在对象的每个rgExp都替换成replaceText,从左到右最多max次。
s1='hello world'
s1.replace('world','liming')
用Python匹配HTML tag的时候,<.> 和 <.?> 有什么区别
第一个代表贪心匹配,第二个代表非贪心;
?在一般正则表达式里的语法是指的"零次或一次匹配左边的字符或表达式"相当于{0,1}
而当?后缀于*,+,?,{n},{n,},{n,m}之后,则代表非贪心匹配模式,也就是说,尽可能少的匹配左边的字符或表达式,这里是尽可能少的匹配.(任意字符)
所以:第一种写法是,尽可能多的匹配,就是匹配到的字符串尽量长,第二中写法是尽可能少的匹配,就是匹配到的字符串尽量短。
比如<tag>tag>tag>end,第一个会匹配<tag>tag>tag>,第二个会匹配<tag>。
正则表达式贪婪与非贪婪模式的区别?
贪婪模式:
定义:正则表达式去匹配时,会尽量多的匹配符合条件的内容
标识符:+,?,*,{n},{n,},{n,m}
匹配时,如果遇到上述标识符,代表是贪婪匹配,会尽可能多的去匹配内容
非贪婪模式:
定义:正则表达式去匹配时,会尽量少的匹配符合条件的内容 也就是说,一旦发现匹配符合要求,立马就匹配成功,而不会继续匹配下去(除非有g,开启下一组匹配)
标识符:+?,??,*?,{n}?,{n,}?,{n,m}?
可以看到,非贪婪模式的标识符很有规律,就是贪婪模式的标识符后面加上一个?
参考文章:https://dailc.github.io/2017/07/06/regularExpressionGreedyAndLazy.html
写出开头匹配字母和下划线,末尾是数字的正则表达式?
s1='_aai0efe00'
res=re.findall('^[a-zA-Z_]?[a-zA-Z0-9_]{1,}\d$',s1)
print(res)
正则表达式操作
请匹配出变量A 中的json字符串。
怎么过滤评论中的表情?
思路:主要是匹配表情包的范围,将表情包的范围用空替换掉
1 | import re |
简述Python里面search和match的区别
match()函数只检测字符串开头位置是否匹配,匹配成功才会返回结果,否则返回None;
search()函数会在整个字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。