2017年6月 – 唐晓锋

# map [1+4, 2+5, 3+6] -> [5, 7, 9]
def f(x, y):
    return x + y
res = map(f, [1, 2, 3], [4, 5, 6])
print(list(res))
# reduce f(f(f(1,6),2),3) -> 1+6+2+3 = 12
from functools import reduce
res = reduce(f, [1, 2, 3], 6)
print(res)
# filter 返回 true | false 过滤
def f(x):
    return x > 0
print(list(filter(f, [1, 0, -1, 2])))
# sorted(data [,key=func] [,reverse=True])
list = ['Zoo', 'about', 'kiss', 'Fuck']
print(sorted(list))    #['Fuck', 'Zoo', 'about', 'kiss']
print(sorted(list, key=str.lower))     #['about', 'Fuck', 'kiss', 'Zoo']
print(sorted(list, key=str.lower, reverse=True))     #['Zoo', 'kiss', 'Fuck', 'about']
# 返回函数
def my_sum(*args):
    def do_sum():
        x = 0
        for v in args:
            x = x + v
        return x
    return do_sum
f = my_sum(1, 2, 3, 4, 5, 6)
print(f())
# 匿名函数 关键字:lambda
print(list(map(lambda x : x * x, [1,2,3])))
# 装饰器 decorator
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# @log相当于 now=log() (*args, **kw)表示传任意参数
@log
def now(date, time):
    print(date, time)
now('2017-06-14', '12:12:12')
print(now.__name__)         # wrapper
# 3层嵌套的decorator、使用包装器
import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)   # wrapper.__name__ = func.__name__ python自带的包装器，完成了类似的赋值功能
        def wrapper(*args, **kw):
            print(text, func.__name__)
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now(date):
    print(date)
now('2017-06-14 13:13:13')
print(now.__name__)         # now
# 偏函数,只是把默认值改了,还是可以显示传入的
import functools
def hello(data, language='ENGLISH'):
    if language == '中文':
        print('你好', data)
    else:
        print('hello', data)
helloChinese = functools.partial(hello, language = '中文')
helloChinese('世界')
hello('world')
helloChinese('world', language = 'ENGLISH')
hello('世界', language = '中文')
# 模块(Module)、包(Package)
# 一个python文件就是一个模块，外层的目录就是包
# 每一个包目录下面都会有一个__init__.py的文件,否则，Python就把这个目录当成普通目录
# __init__.py可以是空文件,也可以有Python代码
# 因为__init__.py本身就是一个模块，而它的模块名就是目录名
# 一个包中可以放另外的包
# 约定属性 abc(PUBLIC) _abc __abc(PRIVATE) __name__(特殊变量)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'BestLove'
import sys
def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')
# 命令行执行时，会调试test()方法
if __name__=='__main__':
    test()
# 第三方库地址 https://pypi.python.org/pypi
# MySQL的驱动：mysql-connector-python
# 科学计算的NumPy库：numpy
# 生成文本的模板工具Jinja2等等
# 安装图片处理工具库 pip install Pillow
from PIL import Image
im = Image.open('1.jpg')
print(im.format, im.size, im.mode)
# JPEG (75, 95) RGB
# 保存缩略图
im.thumbnail((50, 50))
im.save('thumb.jpg', 'JPEG')
# 默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块
import sys
print(sys.path)
# 运行时修改，运行结束失效
sys.path.append('/data/wwwroot/test')
# 设置环境变量PYTHONPATH Python自己本身的搜索路径不受影响

100

101

102

103

104

105

106

107

108

109

110

111

# map [1+4, 2+5, 3+6] -> [5, 7, 9]

def f(x, y):

return x + y

res = map(f, [1, 2, 3], [4, 5, 6])

print(list(res))

# reduce f(f(f(1,6),2),3) -> 1+6+2+3 = 12

from functools import reduce

res = reduce(f, [1, 2, 3], 6)

print(res)

# filter 返回 true | false 过滤

def f(x):

return x > 0

print(list(filter(f, [1, 0, -1, 2])))

# sorted(data [,key=func] [,reverse=True])

list = ['Zoo', 'about', 'kiss', 'Fuck']

print(sorted(list)) #['Fuck', 'Zoo', 'about', 'kiss']

print(sorted(list, key=str.lower)) #['about', 'Fuck', 'kiss', 'Zoo']

print(sorted(list, key=str.lower, reverse=True)) #['Zoo', 'kiss', 'Fuck', 'about']

# 返回函数

def my_sum(*args):

def do_sum():

x = 0

for v in args:

x = x + v

return x

return do_sum

f = my_sum(1, 2, 3, 4, 5, 6)

print(f())

# 匿名函数关键字:lambda

print(list(map(lambda x : x * x, [1,2,3])))

# 装饰器 decorator

def log(func):

def wrapper(*args, **kw):

print('call %s():' % func.__name__)

return func(*args, **kw)

return wrapper

# @log相当于 now=log() (*args, **kw)表示传任意参数

@log

def now(date, time):

print(date, time)

now('2017-06-14', '12:12:12')

print(now.__name__) # wrapper

# 3层嵌套的decorator、使用包装器

import functools

def log(text):

def decorator(func):

@functools.wraps(func) # wrapper.__name__ = func.__name__ python自带的包装器，完成了类似的赋值功能

def wrapper(*args, **kw):

print(text, func.__name__)

return func(*args, **kw)

return wrapper

return decorator

@log('execute')

def now(date):

print(date)

now('2017-06-14 13:13:13')

print(now.__name__) # now

# 偏函数,只是把默认值改了,还是可以显示传入的

import functools

def hello(data, language='ENGLISH'):

if language == '中文':

print('你好', data)

else:

print('hello', data)

helloChinese = functools.partial(hello, language = '中文')

helloChinese('世界')

hello('world')

helloChinese('world', language = 'ENGLISH')

hello('世界', language = '中文')

# 模块(Module)、包(Package)

# 一个python文件就是一个模块，外层的目录就是包

# 每一个包目录下面都会有一个__init__.py的文件,否则，Python就把这个目录当成普通目录

# __init__.py可以是空文件,也可以有Python代码

# 因为__init__.py本身就是一个模块，而它的模块名就是目录名

# 一个包中可以放另外的包

# 约定属性 abc(PUBLIC) _abc __abc(PRIVATE) __name__(特殊变量)

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

' a test module '

__author__ = 'BestLove'

import sys

def test():

args = sys.argv

if len(args)==1:

print('Hello, world!')

elif len(args)==2:

print('Hello, %s!' % args[1])

else:

print('Too many arguments!')

# 命令行执行时，会调试test()方法

if __name__=='__main__':

test()

# 第三方库地址 https://pypi.python.org/pypi

# MySQL的驱动：mysql-connector-python

# 科学计算的NumPy库：numpy

# 生成文本的模板工具Jinja2等等

# 安装图片处理工具库 pip install Pillow

from PIL import Image

im = Image.open('1.jpg')

print(im.format, im.size, im.mode)

# JPEG (75, 95) RGB

# 保存缩略图

im.thumbnail((50, 50))

im.save('thumb.jpg', 'JPEG')

# 默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块

import sys

print(sys.path)

# 运行时修改，运行结束失效

sys.path.append('/data/wwwroot/test')

# 设置环境变量PYTHONPATH Python自己本身的搜索路径不受影响

# sublime插件：SublimeCodeIntel、[Anaconda]、SublimePythonIDE
# list 列表:有序的集合
list = ['test1', 'test2', 'test3', 123, True, ['child1', 'child2']]
print(list)
# 输出倒数第一个
print(list[-1])
print(list[len(list)-1])
# 末尾添加
list.append('test4')
print(list[len(list)-1])
# 指定索引处插入
list.insert(0, 'test0')
print(list)
# 末尾移除
list.pop()
# 指定索引处移除
list.pop(1)
# 赋值(替换)
list[0] = 't0'

# tuple 元组:不能修改的有序集合
t = (1, 2, 3)
# 当tuple中只有一个元素时，可能和括号中的一个数字产生歧义，加个,
t = (1,)
# tuple中的list是可以变的，因为tuple指向的list并没有改变
t = (1, 2, [3, 4])
t[2][0] = 1
t[2][1] = 2

# 判断 (":"和缩进)
a = 2
if a > 100:
    print("大")
elif a > 0:
    print("中")
else:
    print("小")

# 循环 (":"和缩进)  break continue
# for in
list = ['a', 'b', 'c', 'd']
for v in list:
    print(v)

# while
sum = 0
num = 100
while num > 0:
    sum += num
    num -= 1
print(sum)

# dict 字典 全称dictionary
dict = {'张三': 100, '李四': 99, '王八': 60}
print(dict['张三'])
# key不存在会报错
dict['王五'] = 99
# 用in判断
if ('王五' in dict):
    dict['王五'] = 99
# 用dict的get方法，第2个参数非必填[获取不到给默认值]，但是dict中并没有添加王五
five = dict.get('王五', 99)
print(five)
# 删除某个值
dict.pop('王八')

# set 无序、不重复的不变值集合 可以理解为一个没有value的dict或者说dict的key的集合
# 要创建一个set，需要提供一个list作为输入集合
s = set([1, 2, 3, 2, 3])
# 输出{1,2,3}
print(s)
s.add(4)
s.remove(3)
sb = set([2, 3, 4, 5, 6])
# 交集
rs = s & sb
print(rs)
# 并集
rs = s | sb
print(rs)
# 函数
abs(-100)
# 函数可以赋值
a = abs
a(-100)
# 定义函数
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
# 定义空函数 pass是一个占位符，防止代码，还可以用在其它语句中
def nop():
    pass
# 返回多个值
def more_res(x):
    return x+1, x-1
rs1,rs2 = more_res(22)
print(rs1)
print(rs2)
# 默认参数 默认值需要是不变参数，否则多次调用后的返回值会不符合预期
def student_info(name, score, age=6, city='上海'):
    print(name, score, age, city)
student_info("王八", 90)
student_info("王八", 90, city="北京")
# 关键字参数
def person(name, age, **kw):
    print(name, age, kw)
person('张三', '13', city='上海', sex='男')
wangba = {'city': '山东', 'sex': '女'}
person('王八', '22', **wangba)
# 可变参数
def person(name, *age):
    print(name, age)
person('张三', 1, '2', '三')
# 命名关键字参数
def person(name, age, *, city, sex):
    print(name, age, city, sex)
person('张三', '13', city='广州', sex='男')
# 切片
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]              #索引0 - 索引3 而不是 索引0后面取长度3
L[:3]               #索引0 - 索引3
L[1:3]              #索引1 - 索引3
L[-2:]              #最后2个
L[:10:2]            #前10个，每2个取1个
L[::5]              #所有数，每5个取1个
L[:]                #原样复制一个
'ABCDEFG'[:3]       #字符串也可以使用切片操作
# dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样
dect = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4","k5":"v5"}
for k in dect:
    print(k)
for v in dect.values():
    print(v)
for k,v in dect.items():
    print(k,v)
# 可以多个迭代
for x,y,z in [(1,1,1),(2,2,2)]:
    print(x,y,z)
#列表生成式
list_a = [x * x for x in range(1,9)]        # [1, 4, 9, 16, 25, 36, 49, 64]
print(list_a)
list_b = [x * x for x in range(1,9) if x % 2 == 0]          # [4, 16, 36, 64]
print(list_b)
#两层循环
test_c = [m + n for m in 'ABC' for n in 'XYZ']
print(test_c)
# 生成器 generator 把列表生成式的"[]"变成"()"
# 生成器的好处，节省空间，保存的是一个对象或者说是一种算法，每次迭代推算出后续的元素
g = (x * x for x in range(1,9))
print(next(g))
for i in g:
    print(i)
# yield关键字
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield 2
    print('step 3')
    yield 3
    return 'ok'
g = odd()
for i in g:
    print(i)
# Iterable可迭代对象 list、tuple、dict、set、str、generator
from collections import Iterable
print(isinstance('abc', Iterable))
# 可以被next()方法调用的称为迭代器 Iterator
from collections import Iterator
print(isinstance( (x for x in range(1,9)), Iterable ))
print(isinstance( (x for x in range(1,9)), Iterator))
# 把list、dict、str等Iterable变成Iterator可以使用iter()函数
iter([])
# Iterator对象表示的是一个数据流,可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误
# 可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据
# Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算
# 所以Iterator甚至可以表示一个无限大的数据流，例如全体自然数，但list确做不到，因为内存不够

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

# sublime插件：SublimeCodeIntel、[Anaconda]、SublimePythonIDE

# list 列表:有序的集合

list = ['test1', 'test2', 'test3', 123, True, ['child1', 'child2']]

print(list)

# 输出倒数第一个

print(list[-1])

print(list[len(list)-1])

# 末尾添加

list.append('test4')

print(list[len(list)-1])

# 指定索引处插入

list.insert(0, 'test0')

print(list)

# 末尾移除

list.pop()

# 指定索引处移除

list.pop(1)

# 赋值(替换)

list[0] = 't0'

# tuple 元组:不能修改的有序集合

t = (1, 2, 3)

# 当tuple中只有一个元素时，可能和括号中的一个数字产生歧义，加个,

t = (1,)

# tuple中的list是可以变的，因为tuple指向的list并没有改变

t = (1, 2, [3, 4])

t[2][0] = 1

t[2][1] = 2

# 判断 (":"和缩进)

a = 2

if a > 100:

print("大")

elif a > 0:

print("中")

else:

print("小")

# 循环 (":"和缩进) break continue

# for in

list = ['a', 'b', 'c', 'd']

for v in list:

print(v)

# while

sum = 0

num = 100

while num > 0:

sum += num

num -= 1

print(sum)

# dict 字典全称dictionary

dict = {'张三': 100, '李四': 99, '王八': 60}

print(dict['张三'])

# key不存在会报错

dict['王五'] = 99

# 用in判断

if ('王五' in dict):

dict['王五'] = 99

# 用dict的get方法，第2个参数非必填[获取不到给默认值]，但是dict中并没有添加王五

five = dict.get('王五', 99)

print(five)

# 删除某个值

dict.pop('王八')

# set 无序、不重复的不变值集合可以理解为一个没有value的dict或者说dict的key的集合

# 要创建一个set，需要提供一个list作为输入集合

s = set([1, 2, 3, 2, 3])

# 输出{1,2,3}

print(s)

s.add(4)

s.remove(3)

sb = set([2, 3, 4, 5, 6])

# 交集

rs = s & sb

print(rs)

# 并集

rs = s | sb

print(rs)

# 函数

abs(-100)

# 函数可以赋值

a = abs

a(-100)

# 定义函数

def my_abs(x):

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x >= 0:

return x

else:

return -x

# 定义空函数 pass是一个占位符，防止代码，还可以用在其它语句中

def nop():

pass

# 返回多个值

def more_res(x):

return x+1, x-1

rs1,rs2 = more_res(22)

print(rs1)

print(rs2)

# 默认参数默认值需要是不变参数，否则多次调用后的返回值会不符合预期

def student_info(name, score, age=6, city='上海'):

print(name, score, age, city)

student_info("王八", 90)

student_info("王八", 90, city="北京")

# 关键字参数

def person(name, age, **kw):

print(name, age, kw)

person('张三', '13', city='上海', sex='男')

wangba = {'city': '山东', 'sex': '女'}

person('王八', '22', **wangba)

# 可变参数

def person(name, *age):

print(name, age)

person('张三', 1, '2', '三')

# 命名关键字参数

def person(name, age, *, city, sex):

print(name, age, city, sex)

person('张三', '13', city='广州', sex='男')

# 切片

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

L[0:3] #索引0 - 索引3 而不是索引0后面取长度3

L[:3] #索引0 - 索引3

L[1:3] #索引1 - 索引3

L[-2:] #最后2个

L[:10:2] #前10个，每2个取1个

L[::5] #所有数，每5个取1个

L[:] #原样复制一个

'ABCDEFG'[:3] #字符串也可以使用切片操作

# dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样

dect = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4","k5":"v5"}

for k in dect:

print(k)

for v in dect.values():

print(v)

for k,v in dect.items():

print(k,v)

# 可以多个迭代

for x,y,z in [(1,1,1),(2,2,2)]:

print(x,y,z)

#列表生成式

list_a = [x * x for x in range(1,9)] # [1, 4, 9, 16, 25, 36, 49, 64]

print(list_a)

list_b = [x * x for x in range(1,9) if x % 2 == 0] # [4, 16, 36, 64]

print(list_b)

#两层循环

test_c = [m + n for m in 'ABC' for n in 'XYZ']

print(test_c)

# 生成器 generator 把列表生成式的"[]"变成"()"

# 生成器的好处，节省空间，保存的是一个对象或者说是一种算法，每次迭代推算出后续的元素

g = (x * x for x in range(1,9))

print(next(g))

for i in g:

print(i)

# yield关键字

def odd():

print('step 1')

yield 1

print('step 2')

yield 2

print('step 3')

yield 3

return 'ok'

g = odd()

for i in g:

print(i)

# Iterable可迭代对象 list、tuple、dict、set、str、generator

from collections import Iterable

print(isinstance('abc', Iterable))

# 可以被next()方法调用的称为迭代器 Iterator

from collections import Iterator

print(isinstance( (x for x in range(1,9)), Iterable ))

print(isinstance( (x for x in range(1,9)), Iterator))

# 把list、dict、str等Iterable变成Iterator可以使用iter()函数

iter([])

# Iterator对象表示的是一个数据流,可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误

# 可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据

# Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算

# 所以Iterator甚至可以表示一个无限大的数据流，例如全体自然数，但list确做不到，因为内存不够

唐晓锋–BLOG

This is just a personal note.

月份：2017年6月

函数与模块

python简介到高级特性