为了便于查找，在这贴一些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作为前缀
类的私有成员：
python的私有成员通过名字区分，以两个下划线开头的为私有成员。
也可以强制访问私有成员：
instance._classname__attribute
其中，instance为对象名，classname为类名，attribute为属性
动态增加函数：
可以先定义一个函数，然后动态的增加到类的方法里。
构造函数：
python的__int__函数类似于c++的构造函数，子类的构造函数必须先调用父类的构造函数
内置属性：
__dict__ 属性组成字典
__module__ 类名所在模块名
__class__ 类名
输出（注意并没有输出静态变量）：
test.__class__: __main__.Ca
test.__dict__: {'c': 0, 'd': 0}
test.__module__: __main__
多态实现：
isinstance可以判断对象是否属于一个类：
输出（注意，子类是基类的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个比较难的话，
可以自己多写点代码练习下。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
