python学习

每天学一点Python ing

python学习

平时记录

  • *args是可变参数,args接收的是一个tuple;
  • **kw是关键字参数,kw接收的是一个dict

迭代

  • dict迭代

    1
    2
    3
    4
    5
    6
    7
    8
    // 默认为key
    d = {'a': 1, 'b': 2, 'c': 3}
    for key in d:
    print(key)

    // 迭代value的话
    for value in d.values()
    print(value)
  • str迭代

    1
    2
    3
    str = 'hello'
    for ch in str:
    print(ch)
  • list迭代

    1
    2
    3
    //enumerate 可以获得index值
    for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
  • tuple迭代

    1
    2
    for x, y in [(1, 1), (2, 4), (3, 9)]:
    print(x, y)
  • set迭代

  • 生成器迭代

生成器

  • 生成器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // List生成式
    L = [x * x for x in range(10)]

    L //[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    // 改为生成器
    g = (x * x for x in range(10))

    next(g)
    // 0

    next(g)
    // 1
  • 生成器可以被迭代

    1
    2
    for n in g:
    print(n)
  • 使用yield

迭代器

  • 可作用于for的称为可迭代对象 Iterable
  • 可使用next()的称为迭代器 Iterator
  • 把list、dict、str等Iterable变成Iterator可以使用iter()函数

装饰器

  • 简单的装饰器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    import functools

    def log(func):
    def wrapper(*args, **kw):
    print 'call', func.__name__
    return func(*args, **kw)
    return wrapper

    def logPlus(text):
    def decorator(func):
    @functools.wraps(func) // 此处保证函数信息一致
    def wrapper(*args, **kw):
    print text, func.__name__
    return func(*args, **kw)
    return wrapper
    return decorator

    @log
    def now():
    print '2017-11-15'
    now()

    // call now
    // 2017-11-15
  • 带参数的装饰器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    def logPlus(text):
    def decorator(func):
    def wrapper(*args, **kw):
    print text, func.__name__
    return func(*args, **kw)
    return wrapper
    return decorator

    @logPlus('time')
    def now():
    print '2017-11-15'
    now()
    // time now
    // 2017-11-15

偏函数

用于固定部分参数

1
2
3
4
5
import functools
int2 = functools.partial(int, base=2)
int2('1000000')

//64

  • 基本

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    // object是值该类继承于object类
    class Student(object):
    // 这样可以直接定义类的属性
    grade = 6
    // 这样可以规定属性的个数,使用元祖定义,仅对当前的类起作用
    __slot__ = ('name', 'score')
    // 这相当于js的construct,self为必传参数
    def __init__(self, name, score):
    // 以两个_开头的是私有变量
    self.__name = name
    self.__score = score

    def print_score(self):
    print('%s: %s' % (self.__name, self.__score))
  • @property

1
2
3
4
5
6
7
8
9
10
11
12
13
class Student(object):
// 这样方法相当于属性值返回
@property
def score(self):
return self._score
// 修改score时自动通过该方法判断
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
  • 多重继承
1
2
3
4
5
6
7
8
9
10
class Runnable(object):
def run(self):
print('Running...')

class Flyable(object):
def fly(self):
print('Flying...')
// 在类名的括号中填入需要继承的多个类名
class Dog(Mammal, Runnable):
pass
  • 元类

这个看起来很厉害是class的上级,具体用到再看看

调试

  • 断言 assert 如果断言处不符,则会报错 启动Python解释器时可以用-O参数来关闭assert
  • logging
  • pdb单步调试

文件读写

  • 文件读操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    with open('/path/to/file', 'r') as f:
    print(f.read())

    // 反复调用read(size)可以每次读取固定大小值

    // readlines() 可以按行读取文件,得到list
    for line in f.readlines():
    print(line.strip()) # 把末尾的'\n'删掉


    // 读取二进制文件 后面使用参数 'rb'
    f = open('/Users/michael/test.jpg', 'rb')
    f.read()

    // 第三个参数可以确定读取的编码
    f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
    f.read()

    // 如果不能按编码读取, 第四个参数可以加入errors='ignore',就可以忽略读取时的报错
    f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')
  • 文件写操作

    1
    2
    with open('/Users/michael/test.txt', 'w') as f:
    f.write('Hello, world!')
  • 序列化

    • pickle.dumps()方法把任意对象序列化成一个bytes,然后,就可以把这个bytes写入文件。
    • pickle.dump()直接把对象序列化后写入一个file-like Object
    • 用pickle.loads()方法反序列化出对象,也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()

// 从保存这序列化对象的文件中读取对象
f = open('dump.txt', 'rb')
d = pickle.load(f)
f.close()

// JSON的序列化和反序列化、
import json
d = dict(name='Bob', age=20, score=88)
json.dumps(d)

json_str = '{"age": 20, "score": 88, "name": "Bob"}'
json.loads(json_str)

常用模块

  • datetime
1
2
3
from datetime import datetime
print datetime.now()
// datetime.datetime(2017, 11, 17, 16, 12, 24, 665000)
  • collections

    • namedtuple
      1
      2
      3
      4
      5
      from collection import namedtuple
      Point = nametuple('Point', ['x', 'y'])
      p = Ponit(1, 2)
      p.x // 1
      p.y // 2
  • hashlib摘要算法

    • md5
    • sha1