python基础知识

原创

Lee_1985 2019-02-20 18:12:41 博主文章分类：Python ©著作权

©著作权归作者所有：来自51CTO博客作者Lee_1985的原创作品，请联系作者获取转载授权，否则将追究法律责任

随着云计算，大数据，人工智能等行业的兴起，Python语言也变得越来越流行。在分布式系统开发，大数据处理，人工智能，自动化部署，自动化运维等多个领域，都萌生了许多优秀的Python框架。小编认为，Python被广泛接受有两方面原因：一是，Python语言的简洁性，代码可读性非常强，开发效率奇高，另一方面是，Python语言功能的全面性，即可以帮你完成业务逻辑处理，又能可以完成自动化安装部署。

总则：python一切皆对象！！！

Python中子类怎样调用父类方法(有2种方式，推荐使用第2种）

class A(object):  #继承object就是新式类，直接class A就是古典类
def __init__(self):
print 'This is A __init__'
def funA(self, s):
print s
class B(A):
def __init__(self):
super(B,self).__init__() #方法2，只有新式类可以使用
def funB1(self):
A.funA(self, 'A.funA(s)') #方法1，古典类，新式类都可以使用
b = B()
b.funB1()

python中private、protected、public

private：双下划线开头
protected：python无此概念，约定：以单下划线变量作为protected
public：默认都是public

面向对象中的几个概念

python无虚函数概念
python可以多继承，无接口概念
在Python可理解为对应于一个文件，导入就可以复用里面的类、函数等

命名空间与变量作用域

常用的有：
build—in name space（内建命名空间）
global name space（全局命名空间）
local name space（局部命名空间）
在不同的namespace中的name是没有关系的。

package

package是模块的集合，每一个Package的根目录下面都应当有一个__init__.py文件。当解释器发现目录下有这个文件时，
他就会认为这是一个Package，而不是一个普通的目录。
import a :导入模块a
from a import B：导入模块a中的B，并将B加到局部环境空间。这种情形容易污染被导入的命名空间。

import的加载顺序

1) 当前工作目录
2) PYTHONPATH中的目录
3) Python安装目录 (/usr/local/lib/python)
事实上，模块搜索是在保存在sys.path这个全局变量中的目录列表中进行搜索。
导入时候执行：
a)在sys.modules中查找该模块是否已经存在，如果已经存在，则将其导入到命名空间当中，加载结束。
b)如果sys.modules中找不到对应模块的名称，则为需要导入的模块创建一个字典对象，并将该对象信息插入到sys.modules中。
c)加载前确认是否需要对模块进行编译，如果需要则先进行编译
d)执行动态加载，在当前模块的命名空间中执行编译后的字节码，并将其中的所有对象放入模块对应的字典中。
也由此可见，如果命名空间有冲突（模块名有冲突），新导入的会覆盖系统原先导入的。

python与C/C++相互调用

1)python调用C
python的强大之一在于可以用C/C++编写扩展模块.
如果我们有一些C模块,想在python调用 里面的函数,那么首先需要将其用python的API写成一个win32 DLL,然后编译后就可以在 python中调用.
如果python提供的是python25_d.lib,因此编译时采用release环境. 还可以用python的模块ctypes直接在动态链接库中传递参数到C的函数中,比如 
from ctypes import *
MessageBox = windll.user32.MessageBoxA
MessageBox(0, 'Hello, world！', 'The first ctype program', 0)
 
2)C调用python
#include <Python.h>
int main(int argc, char *argv[])
{
      Py_Initialize();
      PyRun_SimpleString("from time import time,ctime\n" "print 'Today is',ctime(time())\n");
      Py_Finalize();
      return 0;
}

python的空值

python对象的三个特征：身份（id），类型（type），值（value），只有值可以改变，其他都只读
id()用来标识对象的唯一身份的，type()是对象的类型
Python的特殊类型：python的空值对象只有一个值None 类型为：NoneType

python关键字is与==的区别

is判断是否为同一个对象，==判断值是否相等。
is是判断a对象是否就是b对象，是通过id判断的， a is b相当于id(a) == id(b)
==是判断a对象的值是否等于b对象的值

lambda表达式

匿名函数，可以提高代码简洁度，但也降低了代码的可读性
f=lambda x,y,z:x+y+z
f(1,2,3) 
lambda表达式求x,y,z的和，输出6

eval和exec

简单来说，eval（str, [[globals [,locals]])函数将字符串str当成有效的python表达式来执行，并返回计算结果。
print eval（“1+2+3”)  ===> 6
参数：globals必须是个字典，locals可以使任何一个对象
globals返回的是当前全局变量的引用，而且可以改变变量的值，即：globals返回值是可读写的
locals返回值是只读的。
与exec()的区别：
exec也可以执行python代码，但是eval却可以计算结果并返回值。exec是语句，eval是函数。
注意：无论是eval还是exec都请慎用！！！

with语句

with 表达式 [as 目标对象]:
可支持嵌套，主要用于文件操作，多线程锁
with通过上下文管理器实现，用它来实现一个运行时环境，需要支持协议：__enter__(), __exit__()。
__enter__()进入上下文，返回一个对象，with将这个对象返回给目标对象。
__exit__()退出上下文，可处理异常，清理现场
with语句执行过程是这样的：
a)计算表达式的值，返回一个目标对象
b)加载__exit__()以备后用
c)调用__enter__()方法
d)给目标对象赋值（如果有）
e)执行with中的代码
f)如果e)正常退出调用__exit__()
g)如过e)发生异常，调用__exit__(),如果__exit__()处理异常，返回true，则异常处理结束，如果__exit__()返回false，则将异常抛给上层。

else语句

a)在for，while中，如果循环条件不满足，要跳出的时候，会执行一次else，但是如果是break跳出，就不会执行else
b)在try except else finally中，如果没有发生任何异常，则执行一次else

几个小经验

finally会屏蔽异常，别用finally，为最好。
连接字符串尽量用join不要用“+”，在字符串量大的时候，效率较低。
格式化字符串尽量用format，不要用%，核心原因是：%最终也被转换成了format函数完成字符串格式化
Python函数传递的的是对象，或者说是对象的引用，不是传值

python变长参数的函数（*args，**kwargs）

a)*args使用列表作为接收参数
b)\*\*kwargs使用字典作为接收参数
但是要注意默认参数和变长参数混合使用的时候，会优先满足普通参数，然后是默认参数，然后是变长参数。
要慎用变长参数，原因是：使用过于灵活，使代码混乱，稍有不慎就会出现错误。

静态方法和类方法

python中得静态方法和类方法都依赖于装饰器来实现。二者定义如下：
class C(object):
  @staticmethod 
  def f(arg1,arg2…):
class C(object):
 @classmethod
  def f(cls,arg1,arg2…):
二者都可用过类名.方法名，或对象名.方法名来访问。
a)类方法第一个参数为本身，静态方法无此概念，主要用于工厂方法，具体实现就交给子类实现。
b)静态方法只能访问静态成员及静态成员方法
c)静态方法无self

浅拷贝与深拷贝

copy遇到类对象不进入类对象进行递归拷贝，二deepcopy会进入类对象进行递归拷贝

构造方法

__init__()不是构造方法，该方法仅仅做了初始化工作，真正的构造方法是 __new__()，__new__()返回对象时会自动调用__init__()。

property

property是用来实现属性可管理的built-in数据类型，其实质是一种特殊的描述符，可以看做是实现了__get__(),__set__()方法的类。
使用形式：
a)第一种形式：
class Some_Class(object):
    def __init__(self):
          self._somevalue=0
    def get_value(self):
          return self._somevalue
   
    def set_value(self, value):
          self._somevalue = value
    def del_attr(self):
         del self._somevalue
    x=property(get_value,set_value,del_attr,”I am x property”)
obj = Some_Class()
obj.x = 10
print obj.x
del obj.x
obj.x
b)第二种形式：
class Some_Class(object):
    _x = None
    def __init__(self):
        self._x = 0
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self, val):
        self._x = val
    @x.deleter
    def x(self):
        del self._x
属性的优势：
a)代码更简洁，可读性强，易于维护
b)更好的管理属性的访问权限

python中的对象协议

a)用于比较的的协议__cmp__()，返回负值，0，正值，还有__eq__(),__ne__(),__lt__(),__gt__(),__add__()等等
b)容器类协议，__len__(),__getitem__(),__setitem__(),__delitem__(),__iter__()
c)哈希，__hash__()
d)属性，__getattr__(),__setattr__(),__delattr__()
运算符重载：__add__(),__sub__()等等
迭代器：__iter__()
生成器：顾名思义，就是按一定的算法生成一个序列，比如：自然队列，菲波那切数列

迭代器

实现：__iter__()返回一个迭代器，next()函数返回当前元素。
迭代器可以提高内存访问速度，提高程序效率，在程序设计中，非常推荐使用。
itertools是一个库，提供了很多高效的访问方法，最重要的就是izip，imap等。
实际上自定义迭代器主要是实现迭代器协议__iter__()以及next()2个方法。

代码示例：

l = [1,2,3]
it = iter(l)
while True:
try:
print it.next()
except StopIteration:
break;
代码示例：
class Fabs(object):
    def __init__(self,max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1
    def __iter__(self):
        return self
    def next(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise StopIteration()
print Fabs(5)
for key in Fabs(5):
    print key

生成器

生成器是这样一个函数，它记住上一次返回时在函数中的位置，对生成器的第2次（或第n次）调用跳转至函数中间，而上次调用中函数的局部变量中的值都保持不变。
通过yield表达式实现。一般一个函数返回一个值，生成器函数可以返回多个值。
代码示例：
def fib(n):
a,b=1,1
while a <= n:
print '-'*8
yield a
a, b = b, a+b
print '+'*8
print type(fib(1))
print type(fib(5))
print fib(5)
print '==============='
elems = fib(5)
print elems.next()
print elems.next()
print elems.next()
print elems.next()
print elems.next()
print elems.next()

python虚拟机浅析

a)python虚拟机使用过引用计数方式进行内存管理和垃圾回收的。
b)python虚拟机会自动运行垃圾回收线程，也可以由程序员运行gc.collect()进行垃圾回收，建议类中自己定义析构函数__del__()。
c)python虚拟机有一个GIL，即全局解释器锁，在多线程情况下，甚至可能会导致性能低下，甚至低于单线程，尤其再IO密集型的多线程程序中更为如此。
在python3.x版本中有些优化，但也无法去除。为了消除或降低GIL对程序的影响，可以使用多进程multiprocessing或者C语言写扩展的方式。

闭包与装饰器

闭包是一个很神奇的东西，嵌套定义在非全局作用域里面的函数能够记住它在被定义的时候它所处的封闭命名空间，他的主要功能是:将一些复杂操作封装起来。
一般用于改变一个函数的功能，如本例：调用plus返回一个新的函数，再对返回新的函数调用。装饰器依赖于闭包实现，可以认为是一种更简洁的闭包
代码示例：
#!/usr/bin/python
#encoding=utf-8
def f1(para):
    def in_fn(x):
        return x*para
    return in_fn
f1 = f1(2)
print f1(2)
程序输出：4
代码示例：
#! /usr/bin/env python
# coding=utf-8
# http://***
#定义一个函数
#!/usr/bin/python
#encoding=utf-8
def new_fn(f):
    result = f(2)
    def in_fn(x):
        return x*result
    return in_fn
@new_fn
def f1(x):
    return x*2
print f1(2)
程序输出：8

链表推导式

list1 = [x*2 for x in range(5)]
print list1
list2 =[(i, j) for i in range(3) for j in range(i)]
print list2

and / or

python的 bool and a or b 类似于c语言中bool？a:b
c = a or b 解读： 如果a为非0值，c值为a，如果a为零值，c值为b，其实就是or的用法

if ...else ... 的多种写法

a=1，b=2, c=3
方式1：
if a > b:
    c = a
else:
    c = b
方式2：
c = a if a > b else b
方式3：
c =  [b,a][a>b]
三个语法意义相同。

for写在一行

list1=[12,3,4,6,7,13,21] 
newList =[x for x in list1 if x > 10]   #生成一个新的list
print newList #输出：[12, 13, 21]
list1=[12,3,4,6,7,13,21] 
newList =(x for x in list1 if x > 10)  #生成一个生成器
next(newList) #输出：12
next(newList) #输出：13next(newList) #输出：21
next(newList) #溢出，异常