python基础知识

时间 2020-01-04

标签 python 基础知识栏目 Python 繁體版

原文原文链接

随着云计算，大数据，人工智能等行业的兴起，Python语言也变得愈来愈流行。在分布式系统开发，大数据处理，人工智能，自动化部署，自动化运维等多个领域，都萌生了许多优秀的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) #溢出，异常

以上为小编开发过程当中总结的一些小经验，一些甚至仍是刚刚学习Python的时候做为难点记录下来的，经过整理，但愿对你们有些帮助，同时，也欢迎你们帮忙勘误。python3.x