【知识梳理】Python知识梳理

GitHub - taizilongxu/interview_python: 关于Python的面试题

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

__init__.py  相当于主文件模块

Python关键字：

• 全局变量：global
• 返回值的字符串表达方式：repr
• 一次创建整个数组：range
• 一次创建一个生成器：xrange

xrange(stop)

xrange(start, stop[, step])

• pass、del、exec、eval：pass是空语句，为了保持程序的完整性

基本运算符：

• and、or、not、in、not in
• is / is not 判断两个对象是否一样
• is 用于判断两个对象是否为同一个(类似于equals)
• == 用于判断引用变量的值是否相同
• import 别名： import xx as ... 别名
• 输入：input /  raw_input  (raw_input 不要求输入带引号)

正则表达式：

re模块

re.match(partten,string,flags=0)
re.match(...,...).span() 在起始位匹配
re.match(...,...) 不在起始位匹配
re.sub 替换字符串中的匹配项

if、while、for语句:

if语句	while语句	for语句
if expression:    elif expression:    else:	while expresion:     statements(s)	for item in sequence:     statements(s) for index in range(len(x)):  //range(0,10,2)     print  x[index]

序列：

列表[]   
          list函数：list('Hello')  => ['H','e','l','l','o']
          list[0]第一个元素
          list[1:3] 第2-3个元素

• append
• count
• extend
• index
• insert
• pop
• remove
• reverse
• sort
• 高级排序 CMP(x,y)：如果x<y 则返回-1；x==y返回0；如果x>y返回1

---

元组() 不可修改，只读列表
        tuple（[1,2,3]） => (1,2,3)

元组的意义：映射中当键使用
元组的判断：isinstance

---

字典 dict

• clear
• copy：浅复制
• deepcopy：深复制
• fromkeys：给定的键建立字典   dic.fromkeys(['name','age']) ==> {'age'=None,'name'=None }
• get
• has_key
• items 和 iteritems
• keys 和 iterkeys
• pop
• popitem 弹出随机项
• setdefault 如果不存在则创建
• update
• values 和 itervalues

---

字符串

• join
• lower
• find
• replace
• split
• strip        去除两侧空格字符串
• translate 只处理单个字符串，可以同时替换。比replace效率高；在translate执行前，需调用。。。
• capitalize

• string.digits：0-9字符串
• string.letters：字母
• string.lowercase：小写字母
• string.printable：可打印字符
• string.punctuation：所有标点字符串
• string.uppercase：大写字母字符串

---

不可变对象：strings,tuples,numbers
可修改对象：list、dict

参数：关键字参数、缺省参数、不定长参数

函数定义时，def(*params)表示收集参数
    如：调用A(1,2,3)后，则print params 为 (1,2,3)

关键字参数 **params，可变参数
    def B(**params)
   调用B(x=1,x=2),则 print params 为 {'x':'1','b':'2'}

逆过程：定义好元组或字典，以*params 或 **params形式传入参数

闭包：在一个外函数中定义一个内函数，在内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用
          闭包的应用是装饰器

def foo():
    def bar():
      print "Hello world"
bar()

闭包：
当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点：

1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数的返回值必须是内嵌函数

装饰器：用来添加新功能

def A(Func):
       def B():
         B = A(B) #装饰
B()

类的私有属性：__private_attrs
类的私有方法：__private_method
protected类型变量：_foo

继承：class A  class B   class C(A,B)

Python内置类属性：

__dict__:     类的属性
__doc__:     文档字符串    
__name__:  类名
__module__:类定义所在的模块
__bases__:  类所有父类构成的元素
__del__:      析构方法

访问属性：

getattr(obj,name)   访问对象的属性
hasattr(obj,name)   检查是否存在一个属性
setattr(obj,name,value)  设置一个属性
delattr(obj,name)     删除属性

匿名函数：lambda [arg1,[arg2,...,argn]]:expresion

sum = lambda arg1,arg2: arg1+arg2;
print sum(10,20)

迭代器：实现了__iter__方法的对象（可迭代）+实现了next方法的对象

def next(self):
    return self.x

def __iter__(self):
    return self

生成器：

       python yield的用法：python中yield用法_-牧野-的博客-CSDN博客_python yield
        yield在函数中的功能类似于return，不同的是yield每次返回结果之后函数并没有退出，而是每次遇到yield关键字后返回相应结果，并保留函数当前的运行状态，等待下一次的调用。

      （调用一次返回一个值，并保持返回时函数的状态，调用函数从状态保存处继续）
        包含yield的函数成为一个生成器，生成器同时也是一个迭代器，支持通过next方法获取下一个值。
       yield 的好处是显而易见的，把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。
       yield生成一个值，而return要停止执行

异常：

raise 异常
except Error,e:
finally:

模块：

查看模块中的内容：dir(模块)
模块.__all__
help(模块.方法)
找模块源码  模块.__file__

文件和流

open(文件，'r/w/a/b/+',缓冲)
read、readline、readlines
seek 定位文件中的指针
tell 返回指针的位置
getcmd 显示当前的工作目录
rmdir 删除目录
mkdir 创建目录
chdir 改变当前目录

文件读取模板：

f = open(filename)
char = f.read()
while char: # while True
    char = f.read()  #line = f.readline()
f.close()

使用fileinput实现惰性迭代：

 import fileinput
 for line in fileinput.input('xxx.txt')
     print(line)

标准库：

sys、os、fileinput、reload
集合 set
堆 heap
双端队列 Deque
time、random
shelve 简单的存储方案
re 正则表达式
twisted 事件驱动的python网络框架
测试：pychecker、pylint
程序打包：Distril + Dyzexe

网络编程：urlib & urllib2

---

@staticmethod和@classmethod：静态方法 & 类方法

Python自省：运行时能够获得对象的类型

__new__ 和 __init__的区别：

• __new__ 是静态方法， __init__是一个实例方法
•  __new__方法返回一个创建的实例， __init__什么也不返回
• 只有在 __new__返回一个cls的实例后 __init__才会被调用
• 当创建一个新实例时调用 __new__，初始化一个实例时用 __init__

*args  和  ** kwargs：
*args可以传递任意数量的参数
**kwargs允许使用没有事先定义的参数名
*args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面

>>> def print_everything(*args):
 
        for count, thing in enumerate(args):

             print '{0}. {1}'.format(count, thing)


>>> print_everything('apple', 'banana', 'cabbage')

0. apple

1. banana

2. cabbage


>>> def table_things(**kwargs):

     for name, value in kwargs.items():

         print '{0} = {1}'.format(name, value)


>>> table_things(apple = 'fruit', cabbage = 'vegetable')
c
cabbage = vegetable
a
apple = fruit