python学习笔记

发表于 | |

关于语法

大部分语法都差不多，所以不用过多关注于语法。不过也有一些在其它语言中没有的新的特性，比如关键词参数等。

1.基本数据结构

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
'''
tuple元组(),元素指向不可变，类似于js里的const
'''
a = (1, 2)
# 一个元素加逗号消除歧义
a = ('a',)
'''
list列表[]
'''
a = [1, 2, 3, 4]
a[::2]  # 设置步长[1, 3]
a[0:1]  # 切片操作[1]
a[::-1] # 倒序
a,b = divmod(15, 7)   # 求余，解构 a = 2, b = 1
# 遍历
for idx, item in enumerate(['a', 'b', 'c']):
  print (idx, item)
'''
集合set{}
'''
# 去重
set('abcdabc')
=> {'a', 'b', 'c', 'd'}
# Set集合的运算
a = {'a', 'b', 'c'}
b = {'a', 'b', 'd'}
a - b
=> {'c'}
a | b
=> {'b', 'c', 'd', 'a'}
a ^ b
=> {'c', 'd'}
a & b
=> {'b', 'a'}
# Set的方法
a = {'a', 'b', 'c', 'd'}
a.pop()
a.add()
'''
dict字典{'a': 1}其它语言中的map,键引号不可缺
''''
data = {'a': 'b', 'c': 'd'}
data = dict((('a', 'b'),('c', 'd')))
# 生成一个元素dict((('a', 'b'),))
# 访问data['a']， data.get('a')
# 删除 del data['a']
'a' in a
dict.setdefault(key, default) // 若不存在，则创建一个默认值，存在则不管
zip([1, 2], [3, 4])
=> [(1, 3), (2, 4)]

迭代器和生成器

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 迭代器
range(10)
[x for x in range(10)]
'''
----迭代器Iterators
__iter__()返回迭代器对象本身，这用在for in语句中
__next__()返回迭代器的下一个值，如果没有下一个值可以返回，那么应该抛出StopIteration异常
'''
eg:
class Counter(object):
	def __init__(self, low, high):
		self.current = low
		self.hight = high
	
	def __iter__(self):
		return self
	
	def __next__(self):
		if self.current > self.high:
			raise StopIteration
		else:
			self.current += 1
			return self.current - 1
'''
生成器,函数中包含yield,不是普通函数
利用惰性计算，可以无限生成而不会内存溢出
'''
xrange(10)
(x for x in range(10))
def my_generator():
	print("Inside my generator")
	yield 'a'
	yield 'b'
	m = yield 'c'
g = my_generator();
g.next()
=> 'a'
def g():
  x = yield 'a'
  print x
m = g()
m.send(None) # m.next()
m.send('hi')

函数

1.lambda表达式(支持有限，不能支持多行表达式)

1
f = lambda x, y: x+y

2.高阶函数(注意参数顺序)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
map(lambda x: x+1, [1, 2, 3])
reduce, filter, sorted类似
# 分部应用
import functools
int2 = functools.partial(int, base = 2)
# 装饰器(可以实现AOP操作)
import functools
def log(text):
  def decorator(func):
    @functools.wraps(func):
    def wrapper(*args, **kw):
      print '%s %s():' % (text, func.__name__)
      return func(*args, **kw)
    return wrapper
  return decorator

面向对象特性

略

协程(事件驱动非阻塞异步)

对比nodejs里的promise, generator, async/await

1 yield
2 python3.5以后引入的async/await
3 其它第三方协程库gevent

进程和线程

1.进程和线程特点
进程:子进程复制主进程内存空间，子进程崩溃不会影响其它进程，更稳定,相应代价大。
线程:子线程共享同一片内存区域，因此会有竞争;一个线程崩溃会影响整个进程。

2.进程池简单示例

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 -*-
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
    print 'Run task %s (%s)...' % (name, os.getpid())
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print 'Task %s runs %0.2f seconds' % (name, (end - start))
if __name__ == '__main__':
    print 'Parent process %s.' % os.getpid()
    p = Pool(10)          # 默认根据CPU核心数量
    '''
    for i in range(5):
        p.apply_async(long_time_task, args = (i,))
    '''
    p.map(long_time_task, range(5))
    print 'Waiting for all subprocess done...'
    p.close()
    p.join()
    print 'Finished'

3.线程池简单示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding: utf-8 -*-
import time
import threading
import threadpool
def handle(v):
    print threading.current_thread().name, v
    time.sleep(2)
tasks = range(22)
start_t = time.time()
pool = threadpool.ThreadPool(10)
requests = pool.makeRequests(handle, tasks)
[pool.putRequest(i) for i in requests]
pool.wait()
print 'Finished  %ds', % (time.time() - start_t)

其它应用

文件IO、图形界面GUI、网络编程、Web开发等。

参考资料

1.廖雪峰简明Python教程

2.Python线程指南