python别人的学习笔记

为了便于查找，在这贴一些python基础知识，随时更新。
by FW http://blog.csdn.net/adrianfeng/archive/2010/09/13/5881353.aspx 转载请注明

列表：

列表中用for

去掉列表中每个元素头尾的空格
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [str.strip() for str in freshfruit]
['banana', 'loganberry', 'passion fruit']

把列表中，大于3的元素，乘以2
>>> vec = [2, 4, 6]
>>> [2*x for x in vec if x > 3]
[8, 12]

把列表1的每一个元素和列表2的每一个元素相乘
>>> lst1 = [2, 4, 6]
>>> lst2 = [4, 3, -9]
>>> [x*y for x in lst1 for y in lst2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]

获取[0-10)的平方
[x**2 for x in range(10)]

或
map(lambda x : x*x, range(10))

获取[0-10)中奇数的平方
[x**2 for x in filter( lambda x : x%2, range(10) )]

删除列表中的元素

del语句用来删除一个List的一个元素或是几个连续的元素，也就是一个slice：

>>> a = [-1, 1, 66.6, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.6, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.6, 1234.5]

del语句也可以用来删除整个变量：

>>>del a

还可以：

del a[:]

range函数

range(1,5) => [1,2,3,4]
range(5) => [0,1,2,3,4]
range(1,5,2) => [1,3]

获取列表长度：

len(lst)

列表寻址：

t = ['a', 'b', 'c', 'd', 'e', 'f']
t[1:3] => ['b', 'c']
t[:3] => ['a', 'b', 'c']
t[3:] => ['d', 'e', 'f']
t[:] => ['a', 'b', 'c', 'd', 'e', 'f']

函数：

匿名函数：

>>> def f(x):
...     return x*2
...
>>> f(3)
6
>>> g = lambda x: x*2  ①
>>> g(3)
6
>>> (lambda x: x*2)(3) ②
6

①	这是一个 lambda 函数，完成同上面普通函数相同的事情。注意这里的简短的语法：在参数列表周围没有括号，而且忽略了 return 关键字 (隐含存在，因为整个函数只有一行)。而且，该函数没有函数名称，但是可以将它赋值给一个变量进行调用。
②	使用 lambda 函数时甚至不需要将它赋值给一个变量。这可能不是世上最有用的东西，它只是展示了 lambda 函数只是一个内联函数。

总的来说，lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。lambda 函数不能包含命令，包含的表达式不能超过一个。不要试图向 lambda 函数中塞入太多的东西；如果你需要更复杂的东西，应该定义一个普通函数，然后想让它多长就多长。

# lambda.py
def fun1(n):
return lambda m:m**n

def fun2(m, n):
return m+n

# 演示通常的lambda用法
f1 = lambda x,y,z: x*2+y+z
print f1(3,2,1)

# 动态生成一个函数
f2 = fun1(2)
print f2(4)

# lambda用作函数参数的写法
print fun2(3, (lambda x:x+1)(2))

类：

类的实例属性和静态属性：

所有的示例属性必须以self作为前缀view plainclass Demo():
#静态属性
staticattr=0
def __init__(self):
#对象属性
self.objattr=0

类的私有成员：

python的私有成员通过名字区分，以两个下划线开头的为私有成员。也可以强制访问私有成员：instance._classname__attribute其中，instance为对象名，classname为类名，attribute为属性

动态增加函数：

可以先定义一个函数，然后动态的增加到类的方法里。view plaindef f1(self):
print 'f1'
class Demo:
pass
Demo.fun=f1

构造函数：

python的__int__函数类似于c++的构造函数，子类的构造函数必须先调用父类的构造函数

内置属性：

__dict__ 属性组成字典__module__ 类名所在模块名__class__ 类名view plainclass Ca():
data=0
def __init__(self):
self.d=0
self.c=0
print
test=Ca()
print 'test.__class__:',test.__class__
print 'test.__dict__:',test.__dict__
print 'test.__module__:',test.__module__

输出（注意并没有输出静态变量）：test.__class__: __main__.Ca
test.__dict__: {'c': 0, 'd': 0}
test.__module__: __main__

多态实现：

isinstance可以判断对象是否属于一个类：view plainclass Cbase:
def __init__(self):
self.d=0
class Child1(Cbase):
def __init__(self):
Cbase.__init__(self)
self.d=0
class Child2(Cbase):
def __init__(self):
Cbase.__init__(self)
self.d=0
print
test1=Child1()
test2=Child2()
print 'test1 is an obj of Child1?:',isinstance(test1,Child1)
print 'test1 is an obj of Child2?:',isinstance(test1,Child2)
print 'test1 is an obj of Cbase?:',isinstance(test1,Cbase)
print 'test2 is an obj of Child1?:',isinstance(test2,Child1)
print 'test2 is an obj of Child2?:',isinstance(test2,Child2)
print 'test2 is an obj of Cbase?:',isinstance(test2,Cbase)

输出（注意，子类是基类的instance）：test1 is an obj of Child1?: True
test1 is an obj of Child2?: False
test1 is an obj of Cbase?: True
test2 is an obj of Child1?: False
test2 is an obj of Child2?: True
test2 is an obj of Cbase?: True 另外，子类的函数会覆盖基类的函数。

运算符重载：

只要重载下面的函数即可 __gt__(self,other)__lt__(self,other)__ge__(self,other)__le__(self,other)__eq__(self,other) 重载del__delitem__(self,key)重载方括号：__getitem__(self,key) 这里还有一张表：二元运算符 特殊方法
+ __add__,__radd__
- __sub__,__rsub__
* __mul__,__rmul__
/ __div__,__rdiv__,__truediv__,__rtruediv__
// __floordiv__,__rfloordiv__
% __mod__,__rmod__
** __pow__,__rpow__
<< __lshift__,__rlshift__
>> __rshift__,__rrshift__
& __and__,__rand__
^ __xor__,__rxor__
| __or__,__ror__
+= __iaddr__
-= __isub__
*= __imul__
/= __idiv__,__itruediv__
//= __ifloordiv__
%= __imod__
**= __ipow__
<<= __ilshift__
>>= __irshift__
&= __iand__
^= __ixor__
|= __ior__
== __eq__
!=,<> __ne__
> __get__
< __lt__
>= __ge__
<= __le__

sting

string.partition

str.partition(sep)Split the string at the first occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings.

string.startswith

if line.startswith("#"):

string.strip

Python中的strip用于去除字符串的首位字符，同理，lstrip用于去除左边的字符，rstrip用于去除右边的字符。这三个函数都可传入一个参数，指定要去除的首尾字符。
注意的是，传入的是一个字符数组，编译器去除两端所有相应的字符，直到没有匹配的字符，比如：
复制代码 代码如下:
theString = 'saaaay yes no yaaaass'
print theString.strip('say')
theString依次被去除首尾在['s'，'a'，'y']数组内的字符，直到字符在不数组内。所以，输出的结果为：
yes no
比较简单吧，lstrip和rstrip原理是一样的。注意：当没有传入参数时，是默认去除首尾空格的。
复制代码 代码如下:
theString = 'saaaay yes no yaaaass'
print theString.strip('say')
print theString.strip('say ') #say后面有空格
print theString.lstrip('say')
print theString.rstrip('say')
运行结果：
yes no
es no
yes no yaaaass
saaaay yes no

查找：

if contest.find('○')!=-1 or contest.find('Re:')!=-1:
print contest
else:
continue

替换：

字符串函数法：
title=str.replace('○','Re:')
正则法：
f=re.compile('/[a-z]+/?')
articleurl=f.sub('/bbspst?',post.url,1)

字符串与编码：

字符串前加r:

在python中，"/"是一个转义号，/后面加上一个特别的字符就有不同的含义。
在window下，一些路径的分隔符是/,在python 的字符串中，在开头加上r,说明字符串里的/不作转义，只是一个普通的路径分隔符。

如：print r'/n'
输出：/n

Python字符串的encode与decode

首先要搞清楚，字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串转换成unicode编码。
encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串转换成gb2312编码。
在某些IDE中，字符串的输出总是出现乱码，甚至错误，其实是由于IDE的结果输出控制台自身不能显示字符串的编码，而不是程序本身的问题。
如在UliPad中运行如下代码：
s=u"中文"
print s
会提示：UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)。这是因为UliPad在英文WindowsXP上的控制台信息输出窗口是按照ascii编码输出的（英文系统的默认编码是ascii），而上面代码中的字符串是Unicode编码的，所以输出时产生了错误。
将最后一句改为：print s.encode('gb2312')
则能正确输出“中文”两个字。
若最后一句改为：print s.encode('utf8')
则输出：/xe4/xb8/xad/xe6/x96/x87，这是控制台信息输出窗口按照ascii编码输出utf8编码的字符串的结果。

Updated at: 2008.11.05
另外，代码中字符串的默认编码与代码文件本身的编码一致，如：
s='中文'
如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。 这种情况下，要进行编码转换，都需要先用decode方法将其转换成unicode编码，再使用encode方法将其转换成其他编码。通常，在没有指定特定的编码方式时，都是使用的系统默认编码创建的代码文件，在这篇文章中可以看到如何获得系统的默认编码。
如果字符串是这样定义：
s=u'中文'
则该字符串的编码就被指定为unicode了，即python的内部编码，而与代码文件本身的编码无关。因此，对于这种情况做编码转换，只需要直接使用encode方法将其转换成指定编码即可。
如果一个字符串已经是unicode了，再进行解码则将出错，因此通常要对其编码方式是否为unicode进行判断：
isinstance(s, unicode) #用来判断是否为unicode

字符串前加u:

字符串前加u，把字符串转换成unicode
#-- coding: GBK --
a=u'哈哈'
b='哈哈'
print repr(a)
print repr(b)
print r'/n'

输出：
u'/u54c8/u54c8'
'/xb9/xfe/xb9/xfe'
/n

其中，54c8为‘哈’的unicode码
b9fe为gbk码

格式化字符串：

eg：
userdir='/vd'+"%05d"%random.randint(0,100000)
%05d表示前面用0填充,总共5位

转换大小写：

s.lower()
s.upper()

文件读写：

f=open('hello.txt')
while True
line=f.readline()
if line:
print line
else:
break
f.close()

一些内建函数：

map函数func作用于给定序列的每个元素，并用一个列表来提供返回值。
map函数python实现代码：
def map(func,seq):
mapped_seq = []
for eachItem in seq:
mapped_seq.append(func(eachItem))
return mapped_seq

filter函数的功能相当于过滤器。调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。
filter函数python代码实现：
def filter(bool_func,seq):
filtered_seq = []
for eachItem in seq:
if bool_func(eachItem):
filtered_seq.append(eachItem)
return filtered_seq

reduce函数，func为二元函数，将func作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列的元素），连续的将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值。
reduct函数python代码实现：

def reduce(bin_func,seq,initial=None):
lseq = list(seq)
if initial is None:
res = lseq.pop(0)
else:
res = initial
for eachItem in lseq:
res = bin_func(res,eachItem)
return res

下面是测试的代码

#coding:utf-8

def map_func(lis):
return lis + 1

def filter_func(li):
if li % 2 == 0:
return True
else:
return False

def reduce_func(li, lis):
return li + lis

li = [1,2,3,4,5]

map_l = map(map_func, li) #将li中所有的数都+1
filter_l = filter(filter_func, li) #得到li中能被2整除的
reduce_l = reduce(reduce_func, li) #1+2+3+4+5

print map_l
print filter_l
print reduce_l

运行结果如下：
C:/>python test1.py
[2, 3, 4, 5, 6]
[2, 4]
15

apply(func [, args [, kwargs ]]) 函数用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典。

apply()的返回值就是func()的返回值，apply()的元祖参数是有序的，元素的顺序必须和func()形式参数的顺序一致

下面给几个例子来详细的说下:
1假设是执行没有带参数的方法

def say():
print 'say in'

apply(say)

输出的结果是'say in'

2函数只带元组的参数。

def say(a, b):
print a, b

apply(say,("hello", "老王python"))

3函数带关键字参数。

def say(a=1,b=2):
print a,b

def haha(**kw):
# say(kw)
apply(say,(),kw)

print haha(a='a',b='b')

输出的结果是:a,b

对于有些朋友来说第3个函数带关键字的操作稍微比较难理解一点，其他的应该还比较简单，如果你觉的第3个比较难的话，
可以自己多写点代码练习下。