python3.5日常记录

1.pickle

有时会遇到cPickle这个方法，在python3中没有发现这个模型。找了一个叫pickle的方法。
功能：python对象进行序列化操作。

import pickle

# 数据列表
my_data = [145, 6, 9, '中国']
# wb 写入 二进制
saveFile = open('mybin.pkl', 'wb')
# 将列表写入文件
pickle.dump(my_data, saveFile)
saveFile.close()

# 读取
# 以二进制的方式读取
pickleFile = open('mybin.pkl', 'rb')
data = pickle.load(pickleFile)
#关闭文件
pickleFile.close()
print(data)

2.命令行参数解释

# coding=utf-8

from optparse import OptionParser

import sys

usage = "usage: %prog [options] arg1 arg2"
MODEL_OP = OptionParser(usage=usage)
MODEL_OP.add_option("-t", "--type",
                    # action="store_true",
                    dest='type',
                    default='keyword',
                    help="types[keyword,multy_class,dict,tfidf,word2vec]")
MODEL_OP.add_option("-o", "--output",
                    dest="model",
                    default="test.model",
                    help="output model file name")
MODEL_OP.add_option("-l", "--is_load_data",
                    action="store_true",
                    dest="is_load_data",
                    default=False,
                    help="whether will be loaded data or not")

print(MODEL_OP.parse_args(sys.argv[1:]))

3.lambda-map-filter-reduce-sorted

# lambda
a = [(lambda x: x * x)(x) for x in range(1, 10)]
print(a)

# filter:找偶数
a = filter(lambda x: x % 2 == 0, range(2, 25))
print(list(a))

# map(function,sequence) 平方数
a = map(lambda x: x * x, range(1, 5))
print(list(a))

# reduce(function,sequence):累加求和
from past.builtins import reduce
a = reduce(lambda x, y: x + y, range(1, 11))
print(a)

# sorted(itrearble, cmp=None, key=None, reverse=False)
print(sorted([1, 4, 5, 2, 3, 6]))
print(sorted({1: 'q', 3: 'c', 2: 'g'}.items()))
# dic按value来排序：key的功能，制定排序的关键字，通常都是一个lambda函数
print(sorted({1: 'q', 3: 'c', 2: 'g'}.items(), key=lambda x: x[1]))
# 稍复杂一些
s = ['Chr1-10.txt', 'Chr1-1.txt', 'Chr1-2.txt', 'Chr1-14.txt', 'Chr1-3.txt', 'Chr1-20.txt', 'Chr1-5.txt']
print(sorted(s, key=lambda d: int(d.split('-')[-1].split('.')[0])))
# 另外：对于list列表，有自己的排序

4.namedtuple

namedtuple是继承自tuple的子类。namedtuple创建一个和tuple类似的对象，而且对象拥有可访问的属性。

from collections import namedtuple

Friend=namedtuple("Friend",['name','age','email'])

f1=Friend('xiaowang',33,'xiaowang@163.com')
print(f1)
print(f1.age)
print(f1.email)
f2=Friend(name='xiaozhang',email='xiaozhang@sina.com',age=30)
print(f2)

name,age,email=f2
print(name,age,email)

5. dict

 # 1. 去重操作 
 if temps[0] in category_dict:
     category_dict[temps[0]] += 1
 else:
     category_dict[temps[0]] = 1
 # 2. 排序操作
 rs_category_dict = sorted(category_dict.items(), key=lambda x: x[1], reverse=True)

6.call函数

# __call__
# 在Python中，函数其实是一个对象：
f = abs
print(f.__name__)
print(f(-123))
# 由于 f 可以被调用，所以，f 被称为可调用对象。
# 所有的函数都是可调用对象。
# 一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。
# 我们把 Person 类变成一个可调用对象：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print('My name is %s...' % self.name)
        print('My friend is %s...' % friend)

# 现在可以对Person实例直接调用：
p = Person('Bob', 'male')
print(p('Tim'))
#  单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

7.python的时间转化

图片来自：http://blog.sina.com.cn/s/blog_b09d460201018o0v.html

8.多个字符分割（split）字符串

import re
re.split('[_#|]','this_is#a|test')

持续更新….