Note_python_note

python__note
import Image
def test():
im = Image.open(‘D:\111.png’)
(w,h)= im.size
im.thumbnail((w//2,h//2))
im.save(‘D:\thumbnail.jpg’,’jpeg’)
if name == ‘main‘:
test()

round(1.15,2) ===> 1.2
ord(‘a’) ===> 97 #### 字母和数字相互转换
chr(65) ===> ‘A’
divmod(15,6) ===>(2,3)

‘-‘*40 ===> ‘———————————————-’
‘an’ in ‘Django’ ===>True
‘xyz’ not in ‘Django’ ===> True
字符串拼接用 join “;”.join[‘list1’,’list2’]
列表扩充 list1.extend(list2)

u’ABC’.encode(‘utf-8’) ####把unicode转为utf-8
‘abc’.decode(‘utf-8’) ####把utf-8转为unicode

保存python文件时，保存为utf-8格式

！/usr/bin/env python

--coding:utf-8 --

List列表 =[‘jack’,’mike’]
list.append(‘marry’)
list[0] list[1] ####根据下标访问制定元素
list.insert(1,’Jack’) ####插入
list.pop() ####弹出最后一个元素
list.pop(1) ####弹出制定元素
list[1]=’Sarah’ ####赋值
list 列表 =[‘jack’,’mike’,’marry’]
s = [‘python’,’java’,list,’scheme’] ####list元素也可以是另一个list
这样如果要取mike的值， s[2][1]

在序列中循环时，索引位置和对应值可以使用enumerate()函数同时得到
for i,v in enumerate([‘tic’,’tac’,’tom’]):
print i,v
同时循环两个或更多序列，可以使用zip()整体打包
questions = [‘name’,’quesst’,’favorite’]
answers = [‘lance’,’the’,’only’]
for q,a in zip(questions,answers):
print ‘what is your {0}?it is {1}’.format(q,a)
pass 语句

def fib(n):
result = []
a,b = 0,1
while a < n:
result.append(b)
a,b = b,a+b
return result #### 返回一个包含数列的链表
f100 = fib(100)

tuple 元组的值不能变，更安全
tuple 当只有一个元素的时候定义： t=(1,)
当 tuple 中包含list时候，list的值是可以变化的
eg: t=(‘a’,’b’,[‘A’,’B’])
t[2][0]=’x’ t[2][1]=’y’

循环 for 语句
names = [‘mike’,’marry’,’java’]
for name in names:
print name
for x in [1,2,3,4,5]:
sum = sum+x
range(5) ===> 0,1,2,3,4
1到100的和：
for x in range(101):
sum = sum+x

birth = raw_input(‘birth:’)

dict 和 set
d ={‘mick’:98,’Bob’:93,’marry’:88}
d[‘mick’]
d[‘mick’] = 90
d.pop(‘Bob’)

重复元素在 set 中自动被过滤
s = set([1,1,2,2,3,3])
s ===> set([1,2,3])
s.add(4)
s.remove(4)
a = set(‘abc’) b = set(‘deab’)
a - b
a | b
a ^ b
a & b

list 内容可变 比如： a = [‘c’,’b’,’a’]
a.sort() a===> [‘a’,’b’,’c’] #### 值改变
tuple　内容不可变　比如：a = ‘abc’
b = a.replace(‘a’,’A’) b===>’Abc’ a===>’abc’ ####值不变

import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny ####返回多个值，实质是返回一个tuple
x,y = move(100,100,60,math.pi/6)
print x,y

def add_end(L=None):
if L is None:
L = []
L.append(‘END’)
return L #### 默认参数必须指向不变对象

def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum #### 把函数参数变为可变参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数
*args是可变参数，args接收的是一个tuple
**kw是关键字参数，kw接收的是一个dict

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。
由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出
解决递归调用栈溢出的方法是通过尾递归优化

切片特性：
L=[‘mick’,’java’,’marry’,’hello’]
L[:3] L[-3:]
L = range(100)
L[:10:2] ####到10为止，步长为2
eg: ‘ABCDEFG’[::2]

Python的for循环抽象程度要高于Java的for循环
因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上

如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断
from collections import Iterable
isinstance(‘abc’, Iterable) ####str是否可迭代
True
isinstance([1,2,3], Iterable) #### list是否可迭代
True
isinstance(123, Iterable) #### 整数是否可迭代
False

Python内置的enumerate函数可以把一个list变成索引-元素对
这样就可以在for循环中同时迭代索引和元素本身
for i, value in enumerate([‘A’, ‘B’, ‘C’]):
print i, value

列表生成式 ：
[x*x for x in range(1,11) if x % 2]
[m + n for m in ‘ABC’ for n in ‘XYZ’]
squares = map(lambda x:x**2,range(10))
[(x,y) for x in [1,2,3] for y in [2,3,1] if x != y]

列出当前目录下的所有文件和目录名
import os #### 导入os模块，模块的概念后面讲到
[d for d in os.listdir(‘.’)] #### os.listdir可以列出文件和目录

for循环其实可以同时使用两个甚至多个变量，比如dict的iteritems()可以同时迭代key和value
d = {‘x’:’A’,’y’:’B’,’z’:’C’}
for k,v in d.iteritems(): #### 或者[k+’=’+v for k,v in d.iteritems()]
print k,’=’,v
L = [‘Hello’,’World’,’IBM’,’Apple’]
[s.lower() for s in L]
isinstance(x, str) ####判断是否字符串

生成器：
g = (x * x for x in range(10))

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言
变量可以指向函数
如 f = abs
def add(x,y,f):
return f(x)+f(y)

Python 内建了 map() 和 reduce() 函数 函数式编程工具 filter(),map(),reduce()
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
educe把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，
reduce把结果继续和序列的下一个元素做累积计算，其效果就是： reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

str 类型转化成 int 类型：
def fn(x, y):
return x * 10 + y
def char2num(s):
return {‘0’: 0, ‘1’: 1, ‘2’: 2, ‘3’: 3, ‘4’: 4, ‘5’: 5, ‘6’: 6, ‘7’: 7, ‘8’: 8, ‘9’: 9}[s]
reduce(fn, map(char2num, ‘13579’))
13579
def str2int(s):
return reduce(lambda x,y: x*10+y, map(char2num, s)) ####编写str–>int 函数

和map()类似，filter()也接收一个函数和一个序列。和 map()不同的时，filter()把传入的函数依次作用于每个元素
eg:
def is_odd(n):
return n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]) ==>1,5,9,15

def not_empty(s):
return s and s.strip()
filter(not_empty, [‘A’, ”, ‘B’, None, ‘C’, ’ ‘])

[‘A’, ‘B’, ‘C’]

seq = range(8)
def add(x,y):
return x+y
map(add,seq,seq)
reduce(add,ra nge(1,11))

sorted([12,32,39,45])
sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序
eg： sorted([12,34,24,54],reversed_sort)
def reversed_sort(x,y):
if x >y :
return -1
if x < y:
return 1
return 0

sorted([‘bob’,’about’,’zo’,’bac’],cmp_ignore_cast)

字典：
cleese = {} 或者 palin = dict() 都可以创建字典，第二个属于工厂模式

默认字典排序
def cmp_ignore_case(s1,s2):
u1 = s1.upper()
u2 = s2.upper()
if u1 < u2:
return -1
if u1 > u2:
return 1
return 0;

在函数调用前后自动打印日志，但又不希望修改now()函数的定义，

这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

字典： tel = {‘jack’:3089,’merry’:2309}
tel[‘jack’]
del tel[‘jack’]
tel.keys()
‘jack’ in tel

偏函数就是把某些参数固定
import functools
int2 = functools.partial(int,base = 2)

面向对象编程——Object Oriented Programming，简称OOP
“测试驱动开发”（TDD：Test-Driven Development）

我5分钟后到，如果没到，请再读一遍此短信…

os.path.abspath(‘.’)
‘D:\green\python’ ####得到当前目录

对文件重命名:

os.rename(‘test.txt’, ‘test.py’)
#### 删掉文件:
os.remove(‘test.py’)

os.path.splitext()可以直接让你得到文件扩展名

os.path.splitext(‘/path/to/file.txt’)
(‘/path/to/file’, ‘.txt’)

把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名

os.path.split(‘/Users/michael/testdir/file.txt’)
(‘/Users/michael/testdir’, ‘file.txt’)

在某个目录下创建一个新目录，

首先把新目录的完整路径表示出来:

os.path.join(‘/Users/michael’, ‘testdir’)
‘/Users/michael/testdir’

然后创建一个目录:

os.mkdir(‘/Users/michael/testdir’)

<