python2

编程语言 编程语言 python
Created At :
Views 👀 :
  1. Python2
    1. 特性
    2. 安装
      1. pip
    3. conda
    4. 重要的环境变量
      1. 运行
    5. 语法
      1. 规范
      2. 帮助
      3. 示例
      4. 类型
      5. 操作符
      6. 语法关键词
      7. 流程控制
      8. 函数
      9. 类和对象和方法
    6. 内置函数
    7. 常用备查
      1. 串类型
      2. 字符串
        1. 元组 () tuple
        2. 数组 [] List
        3. Set
        4. Dictionary {}
    8. 內库
      1. threading
      2. Queue
      3. logging
      4. 文件对象 File
      5. Modules
      6. classes 和 类实例 : Objects, values and types
      7. function
      8. sys
      9. random
      10. 时间 time datetime
      11. 文件和目录
      12. 文件读写
      13. 进程
      14. json
      15. mutilprocess
      16. PB protobuf
      17. 网络
      18. Bisect 二分查找
      19. 正则
      20. 配置，命令行
      21. Mysql
    9. 外库
      1. traceback
      2. redis-py
      3. redis-py-cluster
      4. kafka-python
      5. getopt
      6. oss
      7. 流重定向
      8. 调试
      9. 中断信号
      10. 操作符重载
    10. 特殊技巧
      1. 动态
    11. 参考
    12. 其它
    13. tornado Web Service
    14. python虚拟环境

Python2

快速备查

版本

特性

  • 全部都是对象，包括数字
  • 对象是类的实例，但是类本身也是一个对象

安装

1
2
yum install python27
python -V
1
2
3
4
5
6
wget https://www.python.org/ftp/python/2.7.5/Python-2.7.5.tgz
tar -xzvf Python-2.7.5.tgz
cd Python-2.7.5
configure --prefix=$HOME/local/python --enable-unicode=ucs4
make -j 8
make install

pip

安装python第三方库的工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   sudo yum install -y python2-pip
   sudo easy_install pip
   
   wget ..../get-pip/py
   curl -O https://bootstrap.pypa.io/get-pip.py
   sudo /usr/local/bin/python get-pip.py
   
# 这种方法安装pip稍复杂
wget http://peak.telecommunity.com/dist/ez_setup.py 
python ez_setup.py
python ez_setup.py -U setuptools
easy_install -i http://pypi.douban.com/simple/ pip
easy_install pip  # root user

# 安装你想要的组件
pip install thrift
# 使用阿里云镜像
   pip install pinyin -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
   
1
2
3
4
5
6
7
sudo pip install six --upgrade --ignore-installed
sudo pip install numpy --upgrade --ignore-installed
sudo pip install tensorflow==1.1.0rc2 --ignore-installed
sudo pip install tensorflow --ignore-installed
pip install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.12.0-cp27-none-linux_x86_64.whl
pip install --upgrade https://files.pythonhosted.org/packages/df/d7/0526ed0b717dd3473d0f2e2de803222a5c87b2c74a2a4736e474988509e3/tensorflow-1.1.0rc2-cp27-cp27mu-manylinux1_x86_64.whl
./python -c "import tensorflow"

conda

和pip类似，包管理软件，更多的是机器学习的包管理

conda官网：https://conda.io/miniconda.html

包、依赖和环境管理（任何语言）

1
2
wget "https://repo.anaconda.com/miniconda/Miniconda2-latest-MacOSX-x86_64.sh"
sh Miniconda2-latest-MacOSX-x86_64.sh
1
2
3

conda install tensorflow=1.1.0rc2

https://www.jianshu.com/p/edaa744ea47d

重要的环境变量

  • PYTHONPATH：类似PATH. 加载模块时的搜索的路径。
  • PYTHONSTARTUP：类似Unix的.profile。
  • PYTHONHOME：改变标准Python库的位置，/usr

os.environ.get('PYTHONSTARTUP')

运行

1
2
3
python -c ""
python file.py
python # 交互模式，ctrl+d 退出
  • debug方式
  • 文档查看: python -c "print dir(str)" 列出全部str的方法

语法

规范

书写优美的代码

谷歌命名规范

  • 只使用空格缩进
  • 函数名：this_is_a_function
  • 全局变量：_global_various
  • 变量名：this_is_a_various
  • 常量名：CONST_VALUE
  • 异常，以“Error”作为后缀：RuntimeError

帮助

  • dir(obj) # 简单的列出对象obj所包含的方法名称，返回一个字符串列表
  • help(obj.func) # 查询obj.func的具体介绍和用法

这2个是内置函数

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/usr/bin/env python
# coding=utf-8
import time
import redis

"""这个是程序文档
"""
def main():
    # 注释一下
    rR=redis.Redis('nodea',6379,1,'passwd')
    rW=redis.Redis('nodea',6379,1,'passwd')
    ts=['game_down_lastime','game_play_lastime','game_play_uis','game_applist_lastime']
    for t in ts:
        print "Table:", t
        num=0
        modifyN=0
        for k in rR.hscan_iter(t,count=10000):
            #print k[0], k[1]
            modifyN+=rW.hsetnx(t,k[0],k[1])
            num+=1
            if num%10000 == 0:
                print "already:", num, " modify:", modifyN
            if num%5000 == 0:
                time.sleep(0.1)
        print "total:", num, " modify:", modifyN

if __name__ == '__main__':
    main()
1
2
3
4
import sys

for line in sys.stdin:
    print line

类型

没有显式类型声明语法

  • None：空值，类似java语言中的null
  • boolean: True or False
  • int：由c的long实现
  • float：由c的double实现，1.0
  • long：123L
  • str："abc"
  • unicode：u"abc"
  • list：列表，[]
  • set：无重复集合，()
  • tuple：组，()
  • dict：字典，{}

操作符

每个对象，包括数字，操作符实际是通过魔法转换转为对对象方法的调用。

  • 布尔操作：not and or
  • 三元操作符："ok" if True else "not ok"

语法关键词

  • assert：assert x < 0, 'x must be negative'
  • pass：空操作，用于占位
  • print
    • print var_i, 打印时不换行
    • print >> sys.stderr, var_i 打印到错误流
  • return
  • yield 用于定义一个生成器函数
  • raise：抛出异常
  • import
    • import module [ as name ]
    • from moudule import moudle [ as name ]
    • from moudule import *
  • global：生命变量是全局变量
  • del：显式删除一个变量，或者集合中的元素

流程控制

  • if
  • while
  • for
  • break
  • continue
  • try except finally
1
2
3
4
5
6
7
8
9
10
11
12
13
if *:
elif *:
else:

while *:
    break
    
for * in *:
    continue
    
try:
except Exception, e:
finally:

全部异常的基类是： BaseException，Error是一种Exception。

函数

1
2
def compress(data):
    return '!'+snappy.compress(data)

类和对象和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class C1(C2, C3):
    spam = 42
    def __init__(self, name):
        self.name = name
        
    def __del__(self):
        print("goodbey ", self.name)
        
    @classmethod
    def get_no_of_instance(cls_obj):
        return cls_obj.spam
        
    @staticmethod
    def checkind():
        return (IND == 'ON')
        
I1 = C1('bob')
  • 类的特殊方法，注意他们声明时的传入参数
    • @classmethod 类方法
    • @staticmethod 静态方法

内置函数

  • abs(numberic)

  • all(iterable)

    如果迭代元素全部是True，返回True;迭代器为空，也返回True

  • any(iterable)：任一元素为True，返回True

  • basestring()：

    等同于isinstance(obj, (str, unicode))

  • bin(int)：将一个整数转化成一个二进制字符串

  • bool（[x]）：将一个值转化成布尔值

  • bytearray([source[, encoding[, errors]]])：返回一个新的字节数组

  • chr(i)

    返回包含Ascii值i对应的char的字符串

  • classmethod(function)：将function包装成类方法。

    类方法接受类作为隐式的第一个参数。
    python的类结构和对象结构都是可以组装的。

  • cmp(x, y)：比较两个对象x和y，根据结果返回一个整数。如果x < y，返回负数；如果x == y，返回0；如果x > y，返回正数

  • eval(expression[, globals[, locals]])

    globals和locals为了传递环境值变量

  • execfile(filename[, globals[, locals]])

  • filter(function , sequence)

    返回序列，元素是原序列中能使function返回true的值。  
等同于：[item for item in iterable if function(item)]

  • format(value[, format_spec])

  • frozenset([iterable]) 

    返回一个冻结的set

  • getattr(object, name[, default])

  • globals()

    返回当前全局符号表的字典

  • hasattr(object, name)

  • hash(object) 内置的哈希函数

  • hex(x) 

    把数字转为16进制字符串

  • id(obj) 

    返回对象的身份标识

  • isinstance(object, classinfo)

    判断实体类型

  • issubclass(class, classinfo)

  • len(s)

  • locals()

  • map(function,sequence,[sequence…])

       返回序列,为对原序列每个元素分别调用function获得的值
   map(lambda x,y,z:x+y+z,range(1,3),range(3,5),range(5,7))

  • max(iterable[, args…][, key])

    • max(iterable) 最大值
    • max(var1,var2,…)
    • max(var1,var2,…,func) func是单参数的排序函数？

  • min(iterable[, args…][, key])

  • object()

    返回一个对象。

  • oct(x)

  • open(filename[, mode[, bufsize]])

    打开文件 open(fiel, "w")
    • r 读
    • w 写，文件存在会清空内容
    • a 追加
    • b 二进制方式处理
    • r+ 支持更新
    • w+
    • a+

  • ord(c)

  • pow(x, y[, z])

    pow(x, y) % z)

  • range([start], stop[, step])

    参数的含义为起点(默认为0),终点(不含终点),步长(默认为1)

  • raw_input([prompt])

    从标准流读入用户键入数据到变量。

  • reduce(function,sequence,[init])

    返回一个单值，计算为对每个序列值重复调用function
reduce(lambda x,y:x+y,range(3),99)的计算为
99+0=99 => 99+1=100 => 100+2=102

  • reversed(seq) 反向循环

  • round(x[, n]) 舍入x到小数点后n个数字

  • setattr(object, name, value)

  • sorted(iterable[, cmp[, key[, reverse]]])

    cmp：指定对比函数
key：指定单参数函数，用于对key预处理
reverse：是否倒序

返回一个有序的新序列
sorted(m_p[k], lambda x, y: x[1]-y[1])

  • str(obj) 返回打印友好的字符串

  • sum(iterable[, start])

  • vars(obj)

    返回对象或模型的属性 attribute

  • xrange() range的加速版

    1
    2
    3
    xrange(stop)
    xrange(start, stop[, step])
    [start, stop) step=1

  • zip([iterable, …])

    用于多个sequence的循环
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]

常用备查

串类型

串类型包括:str，unicode，list，set，tuple

  • x in s， x not in s
  • s + t
  • s * n # s重复拷贝多次（n），浅拷贝
  • s[i] # 基于0，如果是负数，从后倒数
  • s[i:j] # 切片，从i到j，包含
  • s[i:j:k] # 切片，k是step
    • “abc”[::-1] # 翻转字符串
  • len(s), min(s), max(s)
  • s.index(i) # i在s中出现的位置
  • s.count(i) # i在s中出现的次数

字符串

常用方式

1
2
3
4
5
6
7
8
9
','.join(["a","b"])	# 字符关联
"%s%s" % tuple(["a","b"]) # 字符关联
find()					index
split(s[, sep[, maxsplit]]) 返回数组
startswith('w'):boolean
endswith('w'):boolean
'a' in 'cdab'
replace
str.strip([chars]) 移除字符串头尾指定的字符（默认为空格）。
  • 字节数组转字符串： b"abcde".decode("utf-8")

https://docs.python.org/2/library/stdtypes.html

元组 () tuple

声明后不可变，和list不一样

1
2
3
4
5
(q, b)
(a,) # 单元素
() # 空元组

(1,2)[0]

数组 [] List

  • li = [“a”, “b”, “mpilgrim”, “z”, “example”]
  • li.append(‘new’)
  • li.insert(2, ‘new’)
  • li.index(‘new’)
  • li.remove(‘z’)
  • li.pop() # 弹出1个，列表中元素少1个，如列表为空，报异常
  • li += [‘aaa’,’bbb’]
  • li = [1,2] * 3

列表推导

1
2
[v for v in vs if v > 2] # 可以带守护条件
[v for vs in vvs for v in vs] # 可以迭代多次

Set

s = set([1,2])

  • add(x)
  • clear()
  • pop()
  • remove(x) # 移除，如不存在，抛出异常
  • discard(x) # 丢弃，不会抛出报错
  • update(other, …)
  • 支持特别的符号操作
    • set([1]) < set([1,2]) # True
    • <=
    • | set |= other 并集
    • set & other 交集
    • set - other 差集
    • ^ 全集 - 交集

Dictionary {}

{“a”:1}

  • [‘key’]：作为右值，key必须存储，否则报异常

  • [‘key’]=value：作为左值，key不存在为新增

  • key in d

  • {“a”:1}.items()：返回[(‘a’, 1)]

  • keys()

  • values()

  • get(k[,x]) 

    获取，默认值为None

  • clear()

  • pop(k[,default])

    弹出，移除，如果没有默认值并且key不存在，异常

  • del d[key]

  • - & | - ^

       viewitems() viewkeys() viewvalues() 这些的视图才可以使用这些，完全一致的才算&

字典列表推导

dict([(v, v*10) for v in L])

map addAll

1
2
for k,v in dict.iteritems(): 
    print "dict[%s]=" % k,v

內库

threading

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#coding:utf-8
import threading
import time

def action(arg):
    time.sleep(1)
    print  'sub thread start!the thread name is:%s    ' % threading.currentThread().getName()
    print 'the arg is:%s   ' %arg
    time.sleep(1)

thread_list = []    #线程存放列表
for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.setDaemon(True)
    thread_list.append(t)

for t in thread_list:
    t.start()

for t in thread_list:
    t.join()

join用法

Queue

  • Queue.Queue(maxsize=0)

  • Queue.LifoQueue(maxsize=0)

  • Queue.PriorityQueue(maxsize=0)

  • Queue.qsize()

  • Queue.empty() 判断是否为空

  • Queue.full()

  • Queue.put(item[, block[, timeout]]) 

    放置数据，阻塞，最长时间，如设置不阻塞，或者阻塞超时，
队列满的话会报错Queue.Full异常。
timeout是大于0的浮点数，单位秒，小数部分表示毫秒。

  • Queue.get([block[, timeout]]) 

       获取数据，阻塞，最长时间，如设置不阻塞，或者阻塞超时，
   队列空的话会报错Queue.Empty异常

  • Queue.task_done() 

       标记来自于队列的任务已经完成，用于消费者线程。当使用wait函数时才有意义。

logging

import logging
logger = logging.getLogger("simple_example")
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.exception(''), 会中处理Exception
    try:
        some_code()
    except:
        logging.exception('')

文件对象 File

  • open

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    f = open("hello.txt")
    try:
        for line in f:
            print line
    finally:
        f.close()

    # 打开文件
    fo = open("test.txt", "w")
    print "文件名为: ", fo.name
    str = "菜鸟教程"
    fo.write( str )
    fo.close()

    with open("hello.txt") as f:
        for line in f:
            print line

Modules

  • m.name
  • __dict__：包含了m的符号表，可以修改，C.x 等同于 C.dict[“x”]

classes 和 类实例 : Objects, values and types

  • id() # 对象的identity，创建时产生，不会改变
  • type() # 类型，类似id
  • name
  • module ： ()
  • dict ： {}
  • bases ： ()
  • doc

从2.1版本开始，有新旧2种类

  • 旧类：x.class ！= type(x)
  • 新类：x.class == type(x)

function

Callable类型的对象

  • doc
  • name
  • module

函数修饰符

函数修饰符返回值为 callable

@f1(arg)
@f2
def func(): pass

等同于

def func(): pass
func = f1(arg)(f2(func))

1
2
3
4
def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

sys

version
version_info
sys.argv[0]

sys.argv[0]表示代码本身文件路径，所以参数从1开始

random

  • random
    • random() 随机浮点数
    • uniform(a,b) 生成一个指定范围内的随机浮点数
    • randint(a,b) 随机整数 [a,b]
    • seed([x]) 随机数种子

时间 time datetime

py中可能涉及的time有四种类型
    1. time string
    2. datetime tuple(datetime obj)
    3. time tuple(time obj)
    4. timestamp

print ((datetime.datetime.now()-datetime.timedelta(minutes=2)).strftime(“%Y-%m-%d %H:%M”))

  • time

    • gmtime([secs]) 国际时间, 元组

    • localtime([secs]) 本地时间，元组

    • mktime(tupletime) 指定时间，秒数，浮点型

    • sleep(secs)

    • strftime(fmt[,tupletime]) 默认是localtime()的tupletime

    • strptime(str,fmt=’%a %b %d %H:%M%S %Y’) 返回struct_time

    • time() 当前时刻，秒数，浮点数 UTC

      Index Attribute Values 
0 tm_year (for example, 1993) 
1 tm_mon range [1, 12] 
2 tm_mday range [1, 31] 
3 tm_hour range [0, 23] 
4 tm_min range [0, 59] 
5 tm_sec range [0, 61]; see (1) in strftime() description 
6 tm_wday range [0, 6], Monday is 0 
7 tm_yday range [1, 366] 
8 tm_isdst 0, 1 or -1; see below

    time.strftime("%Y-%m-%d %H:%M:%S")

time.time()
time.gmtime()
得到的时间都是以格林威治时间为基准的，要显示为我们当地时间，需要调整+8个时区

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python
# coding=utf-8
from __future__ import print_function

import json
import math
import os
import sys
import time

print(time.gmtime(time.time()))
ts = time.time()+8*3600
ts = ts
print(ts)
#ts = time.mktime(time.strptime("2019-05-24 08:00:00", "%Y-%m-%d %H:%M:%S"))
#print(ts)

yestoday = time.gmtime(ts - 86400)
before_yestoday = time.gmtime(ts - 2*86400)

print( time.strftime("%Y%m%d %H%M%S", yestoday))
print( time.strftime("%Y%m%d %H%M%S", before_yestoday))

文件和目录

  • os

    • remove 只能删除存在的文件
    • rename(src,dst) 重命名
    • renames(old, new)
    • listdir(path) 返回实体名列表，非递归
    • mkdir
    • makedirs 创建目录，并且自动创建中间目录，但如果叶节点目录存在，会报错
    • readlink
    • symlink
    • walk 返回的是一个三元tupple(dirpath, dirnames, filenames)
    • sep 路径分隔符
    • chdir(‘D:\Program Files’)
    • getcwd()
    • getpid()
    • popen(command[, mode[, bufsize]])
    • getenv(varname[, value])
    • open()

  • os.path

    • isabs(path)

    • isfile(path)

    • isdir(path)

    • islink(path) 是否是链接；但如果系统不支持链接，返回False

    • ismount(path)

    • abspath(path) 返回绝对路径 os.path.abspath(‘.’)

    • dirname(path) 返回

    • exists(path)

    • lexists(path) 和exists函数一样

    • getsize(path)

    • getctime(path) 

      返回浮点数的系统时间，在类Unix系统上是文件最近更改的时间，在Windows上是文件或目录的创建时间

    • getmtime(path) 文件或目录最后更改的时间

    • getatime(path) 文件或目录最后存取的时间

    • samefile(path1,path2) 

      如果2个路径指向同样的文件或目录，返回True(Windows上不可用)

    • split(path) 

         分割路径，如果path是目录，返回[parentName, dirName]；如果path是文件，返回[dirName, fileName]

    • splitext(path) 

         分割路径，如果path是目录，返回[parentName, '']；如果path是文件，返回[dirName+fileName, 文件后缀]

    • basename

文件读写

1
2
3
4
f = open("d:\test.txt", "w")		open和os.open是不一样的

with open("test.txt", "a") as myfile:
    myfile.write("appended text")
  • file f
    • .read([size])：读取整个文件到字符串
    • .readline()：读取一行，注意，行内容包含了换行符
    • .readlines()
    • .write(string)
    • .seek(0)
    • .seek(offset, from_what)
    • .close()
1
2
3
4
5
with open('data.txt', 'r') as f:
    for line in f:
        line=line.strip()
        print line,

进程

http://www.oschina.net/question/234345_52660
os.system(cmd)
os.open(cmd)
    os.O_RDONLY
    os.O_WRONLY
    os.O_RDWR
    os.O_APPEND
    
subprocess
    .call
    p = subprocess.Popen('ls',stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

  • Popen

    • poll() 

         用于检查子进程是否已经结束。设置并返回returncode属性。

    • wait() 等待子进程结束。设置并返回returncode属性。

    • communicate(input=None) 

         与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。
   可选参数input指定发送到子进程的参数。
   Communicate()返回一个元组：(stdoutdata, stderrdata)。
   注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。
   同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。

    • send_signal(signal) 向子进程发送信号。

    • terminate() 停止(stop)子进程

    • kill() 杀死子进程。和terminate相比，发送的信号量不同

    • stdin 如果在创建Popen对象是，参数stdout被设置为PIPE，否则返回None。

    • stdout

    • stderr

    • pid 获取子进程的进程ID。

    • returncode 获取进程的返回值。如果进程还没有结束，返回None。

json

1
2
3
4
5
6
7
8
import json
json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
json.loads('"\\"foo\\bar"')

echo '{"json":"obj"}' | python -m json.tool
{
    "json": "obj"
}

mutilprocess

进程和父进程以某种方式保持联系，其中子进程的STDIN和STDOUT被重定向。
和reload(sys)会有冲突。

import multiprocessing

def worker(num):
    """thread worker function"""
    print 'Worker:', num
    return

if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()

PB protobuf

ParseFromString
SerializeToString

网络

urlparse.urlparse(http://abc.com/path/file.php?a=b&d=c#flag)
    scheme 	 0 URL scheme specifier empty string 
    netloc 	 1 Network location part empty string 
    path 	 2 Hierarchical path empty string 
    params 	 3 Parameters for last path element empty string 
    query	 4 Query component empty string 
    fragment 5 Fragment identifier empty string 
    username   User name None 
    password   Password None 
    hostname   Host name (lower case) None 
    port 

httplib.HTTPConnection(host[, port[, strict[, timeout[, source_address]]]])
    成功连接后，返回	
    httplib.HTTPResponse
        HTTPResponse.getheader(name[, default])
        HTTPResponse.read([amt])
        HTTPResponse.status
    httplib.HTTPMessage		hold the headers from an HTTP response
    httplib.HTTPException	此包的基础异常
    httplib.responses		字典，封装了HTTP 1.1 status codes对应的标准名称
    
    >>> import httplib
    >>> conn = httplib.HTTPConnection("www.python.org:80", timeout=10) #单位秒
    >>> conn.request("GET", "/index.html")
    >>> r1 = conn.getresponse()
    >>> print r1.status, r1.reason
    200 OK
    >>> data1 = r1.read()
    >>> conn.request("GET", "/parrot.spam")
    >>> r2 = conn.getresponse()
    >>> print r2.status, r2.reason
    404 Not Found
    >>> data2 = r2.read()
    >>> conn.close()
    
    >>> import httplib, urllib
    >>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
    >>> headers = {"Content-type": "application/x-www-form-urlencoded",
    ...            "Accept": "text/plain"}
    >>> conn = httplib.HTTPConnection("musi-cal.mojam.com:80")
    >>> conn.request("POST", "/cgi-bin/query", params, headers)
    >>> response = conn.getresponse()
    >>> print response.status, response.reason
    200 OK
    >>> data = response.read()
    >>> conn.close()

Bisect 二分查找

bisect.bisect_left(a,x, lo=0, hi=len(a))	查找在有序列表a中插入x的index。lo和hi用于指定列表的区间，默认是使用整个列表。如果x已经存在，在其左边插入。返回值为index。
bisect.bisect_right							和bisect_left类似，但如果x已经存在，在其右边插入。
bisect.bisect								同bisect_right
bisect.insort_left(a,x, lo=0, hi=len(a))	在有序列表a中插入x。和a.insert(bisect.bisect_left(a,x, lo, hi), x) 的效果相同。
bisect.insort_right(a,x, lo=0, hi=len(a))	和insort_left类似，但如果x已经存在，在其右边插入。
bisect.insort(a, x,lo=0, hi=len(a))			同insort_right

正则

import re

re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

p = re.compile('ab*')
p = re.compile('ab*', re.IGNORECASE)

常规字符："\\\\section"
raw字符：r"\\section"

re.match(pattern, string, flags=0)		决定 RE 是否在字符串刚开始的位置匹配
re.search(pattern, string, flags=0)	扫描字符串，找到这个 RE 匹配的位置
re.sub(pattern, repl, string, max=0)   替换字符串中的匹配项,返回新的字符串

MatchObject = p.match( 'tempo')
p.findall(str)	找到 RE 匹配的所有子串，并把它们作为一个列表返回
p.finditer(str)	找到 RE 匹配的所有子串，并把它们作为一个迭代器返回
m = p.match( 'tempo')
p.findall(str)	找到 RE 匹配的所有子串，并把它们作为一个列表返回
p.finditer(str)	找到 RE 匹配的所有子串，并把它们作为一个迭代器返回


MatchObject可以访问：
group()	返回被 RE 匹配的字符串
start()	返回匹配开始的位置
end()	返回匹配结束的位置
span()	返回一个元组包含匹配 (开始,结束) 的位置

m.group()
m.start()
m.end()

re 模块也提供了顶级函数调用如 match()、search()、sub() 等等，所以也可以：
print re.match(r'From\s+', 'Fromage amk')
num = re.sub(r'#.*$', "", phone)

配置，命令行

parser = OptionParser( "usage: %prog [config]", version = "%prog 0.1" )
parser.add_option( "-p", "--package", dest="max_package_size", type="int", default=256, help="max package size(M)" )
parser.add_option( "-s", "--speed", dest="speed_limit", type="int", default=10, help="speed limit(M/S)" )
parser.add_option( "-r", "--time", dest="max_run_time", type="int", default=9, help="max run time(Minutes)" )
parser.add_option( "-c", "--conf", dest="conf_dir", type="int", default="%s/conf" % base_dir, help="config file dir" )
(config, args) = parser.parse_args()
load_config( config )

Mysql

mysql
PyMySQL

1
2
3
4
5
6
7
8
import pymysql
conn = pymysql.connect(host='127.0.0.1', user='root', passwd="xxx", db='mysql')
cur = conn.cursor()
cur.execute("SELECT Host,User FROM user")
for r in cur:
    print(r)
cur.close()
conn.close()
pymysql.Connect()参数说明
host(str):      MySQL服务器地址
port(int):      MySQL服务器端口号
user(str):      用户名
passwd(str):    密码
db(str):        数据库名称
charset(str):   连接编码

connection对象支持的方法
cursor()        使用该连接创建并返回游标
commit()        提交当前事务
rollback()      回滚当前事务
close()         关闭连接

cursor对象支持的方法
execute(op)     执行一个数据库的查询命令
fetchone()      取得结果集的下一行
fetchmany(size) 获取结果集的下几行
fetchall()      获取结果集中的所有行
rowcount()      返回数据条数或影响行数
close()         关闭游标对象

外库

traceback

import traceback
traceback.print_exc()
 
def fifths(a):
    return 5/a
 
def myfunction(value):
    b = fifths(value) * 100
 
try:
    print myfunction(0)
except Exception, ex:
    logfile = open('mylog.log','a')
    traceback.print_exc(file=logfile)
    logfile.close()
    print "Oops ! Something went wrong. Please look in the log file."

Exception ex:
    Exception.

redis-py

redis python 简单操作

1
pip install redis
1
2
3
4
5
6
7
8
9
import redis
client = redis.StrictRedis(host='127.0.0.1', port=6379)
key = "hello"
client.set(key, "python-redis")
value = client.get(key)
print "key:" + key + ", value:" + value
client.hset('blog:info','url', u'http://www.the5fire.com')
cache.hmset('blog:info', {'title': 'the5fire blog', 'url': 'http://www.the5fire.com'})
r.expire('foo', 60)  # 单位秒

redis-py-cluster

1
pip install redis-py-cluster
1
2
3
4
5
6
7
8
9
10
>>> from rediscluster import StrictRedisCluster
>>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]
>>> # Note: decode_responses must be set to True when used with python3
>>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)
>>> rc.set("foo", "bar")
True
>>> print(rc.get("foo"))

当取压缩数据时，需要指定禁止以字符串方式解析结果
r=Redis(startup_nodes=nodes, decode_responses=False, password=redis_password)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/usr/bin/env python
#coding:utf8
__author__ = "LUODI"
 
from rediscluster import StrictRedisCluster
import sys
 
 
'''连接redis集群节点'''
def RedisCluster():
    Redis_nodes = [ {'host': '192.168.2.76', 'port': 6380},
                {'host': '192.168.2.76', 'port': 6381},
                {'host': '192.168.2.76', 'port': 6382},
                {'host': '192.168.2.105', 'port': 7380},
                {'host': '192.168.2.105', 'port': 7381},
                {'host': '192.168.2.105', 'port': 7382},
              ]
    try:
        redisconn = StrictRedisCluster(startup_nodes=Redis_nodes)
    except Exception,e:
        print "Connect Redis node error:",e
        sys.exit(1)
     
    redisconn.set("name",'luodi') #设置值
    print(redisconn.get("name"))  #获取值
 
 
RedisCluster()

kafka-python

Python中的Kafka：使用kafka-python库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from kafka import KafkaConsumer
from kafka import TopicPartition

TOPIC = "test_topic"
PARTITION = 0

consumer = KafkaConsumer(
    group_id=TOPIC,
    auto_offset_reset="earliest",
    bootstrap_servers="localhost:9092",
    request_timeout_ms=100000,
    session_timeout_ms=99000,
    max_poll_records=100,
)
topic_partition = TopicPartition(TOPIC, PARTITION)
# format: topic, partition
consumer.assign([topic_partition])
consumer.seek(topic_partition, 1660000)
# format: TopicPartition, offset. 1660000 is the offset been set.
for message in consumer:
    # do something

getopt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import getopt
import sys
 
 
def usage():
    print ' -h help \n' \
          ' -i ip address\n' \
          ' -p port number\n' \
          ''
 
if __name__ == '__main__':
    try:
        options, args = getopt.getopt(sys.argv[1:], "hp:i:", ['help', "ip=", "port="])
        for name, value in options:
            if name in ('-h', '--help'):
                usage()
            elif name in ('-i', '--ip'):
                print value
            elif name in ('-p', '--port'):
                print value
    except getopt.GetoptError:
        usage()

oss

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding: utf-8 -*-

import oss2
from itertools import islice

auth = oss2.Auth('您的AccessKeyId', '您的AccessKeySecret')
bucket = oss2.Bucket(auth, 'oss-cn-shenzhen.aliyuncs.com', 'vidmate-backup-sz')

total_size = 0
for i, object_info in enumerate(oss2.ObjectIterator(bucket)):
    total_size = total_size + object_info.size
    if i >= 100:
        break
      
# 这是object_info里面有的东西
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'etag', 'is_prefix', 'key', 'last_modified', 'size', 'storage_class', 'type']

流重定向

标准输入、输出和错误流：sys.stdin, sys.stdout, sys.stderr。

流的重定向包括重定向到文件，程序，和Python对象。

stdin, stdout, stderr在Python中都是具有文件属性的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import sys

buffer = ''

class Logger:
	def write(self, s):
		global buffer
		buffer += s

mylogger = Logger()
stdout_ = sys.stdout # backup reference to the old stdout.
sys.stdout = mylogger

print 'ok'
print '1'
print {'a': 1, 'b': 2}, 'hello', [1,2,3]

sys.stdout = stdout_
print buffer

另一个示例：

from StringIO import StringIO
import sys
buff =StringIO()
temp = sys.stdout                               #保存标准I/O流
sys.stdout = buff                                 #将标准I/O流重定向到buff对象
print 42, 'hello', 0.001
sys.stdout =temp                                 #恢复标准I/O流
print buff.getvalue()

调试

代码中
import pdb
pdb.set_trace()

进入调试界面后
命令	解释
break 或 b 设置断点	设置断点
continue 或 c	继续执行程序
list 或 l	查看当前行的代码段
step 或 s	进入函数
return 或 r	执行代码直到从当前函数返回
exit 或 q	中止并退出
next 或 n	执行下一行
pp	打印变量的值
help	帮助

import atexit

atexit.register(func[, *args[, **kargs]])
atexit.register(savecounter)
atexit.register(goodbye, 'Donny', 'nice')
atexit.register(goodbye, adjective='nice', name='Donny')

中断信号

signal(SIGALRM,when_alarm);  	//当接收到SIGALRM信号时，调用when_alarm函数  
signal(SIGINT,when_sigint);  	//当接收到SIGINT信号时，调用when_sigint函数  
signal(SIGCHLD,when_sigchld);	//当接收到SIGCHLD信号时，调用when_sigchld函数  
signal(SIGUSR1,when_sigusr1);	//当接收到SIGUSR1信号时，调用when_sigusr1函数  
signal(SIGIO,when_sigio);		//当接收到SIGIO信号时，调用when_sigio函数

操作符重载

重载是通过特殊命名的类方法来实现的
__new__ 						在创建实例的时候被调用, 通常用在设置不变数据类型的子类
__init__ 						在创建实例的时候被调用
__cmp__(self, other)			在比较的时候调用
__pos__(self)					一元加
__neg__(self)					一元减
__invert__(self)				取反
__index__(self)					对象被作为索引使用的时候	x[self]
__nonzero__(self)				对象的布尔值	bool(self)
__getattr__(self, name)			访问一个不存在的属性时	self.name # name 不存在
__getattribute__(self, name)	访问任何属性时	self.name
__setattr__(self, name, val)	对一个属性赋值时	self.name = val
__delattr__(self, name)			删除一个属性时	del self.name
__getitem__(self, key)			使用索引访问元素时	self[key]
__setitem__(self, key, val)		self[key] = val	对某个索引值赋值时
__delitem__(self, key)	del 	self[key]	删除某个索引值时
__iter__(self)	for x in self	迭代时
__contains__(self, value)		value in self, value not in self	使用 in 操作测试关系时
__concat__(self, value)			self + other	连接两个对象时
__call__(self [,...])			self(args)	“调用”对象时
__enter__(self)					with self as x:	with 语句环境管理
__exit__(self, exc, val, trace)	with self as x:	with 语句环境管理
__getstate__(self)				pickle.dump(pkl_file, self)		序列化
__setstate__(self)				data = pickle.load(pkl_file)	序列化
C.__str__(self) 				可打印的字符输出；内建str()及print 语句
C.__repr__(self) 				运行时的字符串输出；内建repr()  ‘‘  和 操作符
C.__unicode__(self)				b Unicode 字符串输出；内建unicode()
C.__len__(self)					长度（可用于类）；内建len()
C.__cmp__(self, obj)			对象比较；内建cmp()
C.__lt__(self, obj)				小于/小于或等于；对应<及<=操作符
C.__le__(self,obj)
C.__gt__(self, obj)				大于/大于或等于；对应>及>=操作符
C.__ge__(self,obj)
C.__eq__(self, obj)				等于/不等于；对应==,!=及<>操作符
C.__ne__(self,obj)
C.__getattr__(self, attr)		获取属性；内建getattr()；仅当属性没有找到时调用
C.__setattr__(self, attr, val)	设置属性
C.__delattr__(self, attr)		删除属性
C.__getattribute__(self, attr)	获取属性；内建getattr()；总是被调用
C.__get__(self, attr)			（描述符）获取属性
C.__set__(self, attr, val)		（描述符）设置属性
C.__delete__(self, attr)		（描述符）删除属性
C.__*add__(self, obj)			加；+操作符
C.__*sub__(self, obj)			减；-操作符
C.__*mul__(self, obj)			乘；*操作符
C.__*div__(self, obj)			除；/操作符
C.__*truediv__(self, obj)		True 除；/操作符
C.__*floordiv__(self, obj)		Floor 除；//操作符
C.__*mod__(self, obj)			取模/取余；%操作符
C.__*divmod__(self, obj)		除和取模；内建divmod()
C.__*pow__(self, obj[, mod])	乘幂；内建pow();**操作符
C.__*lshift__(self, obj)		左移位；<<操作符
C.__*rshift__(self, obj)		右移；>>操作符
C.__*and__(self, obj)			按位与；&操作符
C.__*or__(self, obj)			按位或；|操作符
C.__*xor__(self, obj)			按位与或；^操作符
C.__neg__(self) 				一元负
C.__pos__(self) 				一元正
C.__abs__(self) 				绝对值；内建abs()
C.__invert__(self) 				按位求反；~操作符
C.__complex__(self, com) 		转为complex(复数);内建complex()
C.__int__(self) 				转为int;内建int()
C.__long__(self) 				转为long；内建long()
C.__float__(self) 				转为float；内建float()
C.__oct__(self) 				八进制表示；内建oct()
C.__hex__(self) 				十六进制表示；内建hex()
C.__coerce__(self, num) 		压缩成同样的数值类型；内建coerce()
C.__index__(self)g 				在有必要时,压缩可选的数值类型为整型（比如：用于切片索引等等
C.__len__(self) 				序列中项的数目
C.__getitem__(self, ind) 		得到单个序列元素
C.__setitem__(self, ind,val) 	设置单个序列元素
C.__delitem__(self, ind) 		删除单个序列元素
C.__getslice__(self, ind1,ind2) 得到序列片断
C.__setslice__(self, i1, i2,val) 设置序列片断
C.__delslice__(self, ind1,ind2) 删除序列片断
C.__contains__(self, val) 		f 测试序列成员；内建in 关键字
C.__*add__(self,obj) 			串连；+操作符
C.__*mul__(self,obj) 			重复；*操作符
C.__iter__(self)  				创建迭代类；内建iter()
C.__len__(self) 				mapping 中的项的数目
C.__hash__(self) 				散列(hash)函数值
C.__getitem__(self,key) 		得到给定键(key)的值
C.__setitem__(self,key,val) 	设置给定键(key)的值
C.__delitem__(self,key) 		删除给定键(key)的值
C.__missing__(self,key) 		给定键如果不存在字典中，则提供一个默认值

特殊技巧

  • 虽然可以，但别在一行中写多个语句
  • import sys; print sys.version 获取版本

动态

  • locals()[‘part’+str(i)]=i str()是将变量变成字符串
    exec()
    eval()

参考

其它

tornado Web Service

http://blog.thisisfeifan.com/2012/06/deploy-tornado-application.html

python虚拟环境

http://stackoverflow.com/questions/4750806/how-to-install-pip-on-windows/15915700#15915700

http://liuzhijun.iteye.com/blog/1872241

windows:

linux:

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 jaytp@qq.com

💰

©2016-2020 Yelog

Built with Hexo and 3-hexo theme

×

Help us with donation