零碎python学习笔记（三） - 20121207

虽然已经将《简明python教程》阅读一遍，但很多问题仍存疑。慢慢持续调查之。

1.排序：list，dict

list 排序：

使用listvar.sort()或者listvar2=sorted(listvar1)

listvar.sort 改变列表listvar的元素排序

sorted(listvar1)不改变列表listvar1的元素排序，而以排序生成一个新表listvar2。

默认为从小到大排序。

需从大到小排序：listvar.sort(reverse=True)或者listvar2=sorted(listvar1, reverse=True)

自定音排序函数：

def sortfunc(var)

return somecalculation(var)// 根据列表中的元素返回一个值，所有元素将根据分别产生的这个值进行排序

然后

listvar.sort(key=sortfunc)或者listvar2=sorted(listvar1, key=sortfunc)

嗯嗯。这点与C++/Java的排序操作略有不同。不过似乎也很简单明了。

dict排序：

dict本身无序，所以只是按序输出。

那么便可按key排序，按value排序或者随便定义怎么排序，然后生成一个有序表或直接按序输出key/value对

Python官网PEP265文档指出最快按值排序方法：

from operator import itemgetter
sorted(d.iteritems(), key=itemgetter(1))

它的意思是从dict变量d生成一个iterator item list，然后以list每个item的第二个值（index从0开始，第二个item的index为1）为标准排序。

因为只是一个iterator item list，所以直接在dict原有内存上遍历（大概吧）

2.拷贝构造函数？默认拷贝构造函数？

3.类中静态变量/方法？

4.函数中根据输入变量不同类型进行不同处理？（函数重载能否参数数量一样但类型不同）

5.打印在同一行中？（打印时不自动在行尾输出换行符）

可。

>>> print 0;print 1
0
1
>>> print 0,;print 1
0 1
>>>

（注意第二次打印时print 0后面的逗号）

 

6.类继承函数重写？二义性？虚拟继承？

多重继承

类多继承

class DerivedClassName(Base1,Base2,Base3):
    pass

对于该类函数的解析规则是深度优先,先是Base1,然后是Base1的基类,诸如此类.

class A:
    def hi(self):
        print "A"

class B:
    def hi(self):
        print "B"
        
class C(A,B):
    pass

C().hi()

输出:

A

7.pickle输出文件类型？

8.操作复杂的二进制数据如图像和声音？

9.能否将函数A作为参数传入函数B？在函数B中能否调用函数A？

可。

10.list是否可包含不同类型元素？

可。

 11.产生新表/元组/字典的for item in ... 语法？

哇哈哈哈其实就是for loop，后面可以直接跟if来限定范围

比如

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

b = [item + 5 for item in a] // b = [6, 7, 8, 9, 10]

d = {a[i]:b[i] for i in range(5)}

d2 = {item : b[item - 1] for item in a if item < 4 and item >= 1}

进阶：

unique_words=set(word for line in page for word in line.split())#page为打开的文件

12. 列表的算术操作

+ 和 *

+：相连

*：将表重复N次

13.所有的元素都是reference，所以：

比如

x = [3]

y = [x, x]  //这时y = [[3], [3]]

现在

x[0]=4

y就会变成[[4], [4]]

需要小心。

13.eval和repr用法：其实这两个应该基本上互逆。

>>> x=raw_input("Please enter an sentence:")
Please enter an sentence:[1, 2, 44]
>>> x
'[1, 2, 44]'
>>> y = list(x)
>>> y
['[', '1', ',', ' ', '2', ',', ' ', '4', '4', ']']
>>> y = eval(x)
>>> y
[1, 2, 44]
>>> repr(y)
'[1, 2, 44]'

14.filter(function , sequence) 返回序列,为原序列中能使function返回true的值

15.set（集合）：无序不重复的元素集

>>>basket = ['apple','orange','apple','pear','apple','banana']

>>>fruit=set(basket)

>>>fruit
set(['orange', 'pear', 'apple', 'banana'])

 

16.@ 装饰器

@A def B:pass 等价于 def B:pass B=A(B) 即将函数B作为参数传给参数A

from time import time
#测试运行时间
def cost_time(func):
    def result(*args,**dic):
        beign=time()
        func(*args,**dic)
        print "cost time : ",time()-beign
    return result

@cost_time
def show(n):
    for x in range(n):print x

>>> show(10)
0
1
2
3
4
5
6
7
8
9
cost time :  0.0469999313354

17.map(function,sequence,[sequence...])

返回序列,为对原序列每个元素分别调用function获得的值.

可以传入多个序列,但function也要有相应多的参数

18.zip用于多个sequence的循环

questions=['name','quest','favorite color']
answers=['lancelot','the holy grail','blue']

for q,a in zip(questions,answers):
    print 'What is your %s ? It is %s.'%(q,a)

输出:

What is your name ? It is lancelot.
What is your quest ? It is the holy grail.
What is your favorite color ? It is blue.

19.reversed反向循环

for i in reversed(range(1,4)):
    print i

20.enumerate 返回索引位置和对应的值

for i,v in enumerate(['tic','tac','toe'])
    print i,v

输出:

0 tic
1 tac
2 toe

21.操作符重载

通过定义类的一些约定的以""开头并结尾的函数,可以到达重载一些特定操作的目的,下面是是一些常用的重载

 __str__ / __unicode__

当print一个对象实例时,实际是print该实例str()函数的返回值.

class A:
    def __str__(self):
        return "A"
    def __unicode__(self):
        return "uA"

print A()
print unicode(A())

输出

A
uA

unicode和str类似,不过返回Unicode字符串.

 比较操作

x<y x.lt(y)

x<=y x.le(y)

x==y x.eq(y)

x!=y 或 x<>y x.ne(y)

x>y x.gt(y)

x>=y x.ge(y)

cmp( self, other) 用来简化比较函数的定义 self < other返回负数,相等时返回0,self>other时返回正数

class A:
    def __init__(self,i):
        self.i=i
    def __cmp__(self,other):
        return self.i-other.i

print A(1)>A(2)

输出

False

 __iter__

for ... in 循环即就是通过这个函数遍历当前容器的对象实例 可配合yield方便的编写这个函数(参见基本语法yield)

class A:
   def __init__(self,n):
       self.n=n
   def __iter__(self):
       n=self.n
       while n:
           m=n%2
           n/=2
           yield m

for i in A(5):
    print i,

输出

1 0 1 

另有一种繁琐的实现: 返回一个可以通过next()函数遍历的对象,当结束时抛出StopIteration异常

22.类相关函数

 type

返回对象的类型

>>> type("")
<type 'str'>
>>> type("")==str
True

>>> type([])
<type 'list'>
>>> type([])==list
True

>>> type({})
<type 'dict'>

>>> type(())
<type 'tuple'>

>>> class A:pass

>>> type(A)
<type 'classobj'>

>>> type(A())
<type 'instance'>

>>> import types #在types模块中有许多类型的定义

>>> type(A)==types.ClassType
True

 getattr / hasattr /delattr

getattr:通过类实例和一个字符串动态的调用类函数/属性

class A:
    def name(self):
        return "ZSP"
    def hello(self):
        return "nice to meet me ."

def say(obj,attr):
    print getattr(obj,attr)()

a=A()
say(a,"name")
say(a,"hello")

输出

ZSP
nice to meet me .

hasattr 用来判断实例有无该函数/属性

delattr 用来删除实例的函数/属性

 property

通过值的方式调用实例无参函数

class A(object):
    def __init__(self): self._x = None
    def getx(self): return self._x
    def setx(self, value): self._x = value
    def delx(self): self._x=None
    x = property(getx, setx, delx, "I'm the 'x' property.")
a=A()
print a.x

a.x="ZSP"
print a.x

del a.x
print a.x

输出

None
ZSP
None

可以方便的定义一个只读属性

class A(object):
    @property
    def x(self): return "Property"

调用

>>>a=A()

>>>print a.x
Property

>>>a.x="ZSP" #只读属性,不能更改
Traceback (most recent call last):
  File "D:\Profile\Untitled 2.py", line 9, in <module>
    a.x="ZSP"
AttributeError: can't set attribute

 isinstance( object, classinfo)

判断一个对象是否是一个类的实例

>>>class A:pass

>>>class B:pass

>>>a=A()

>>>isinstance(a,A)
True

>>>isinstance(a,B)
False

23.redirecting sys.stdin: 
import sys 
old_stdin = sys.stdin # save it, in case we need to restore it 
sys.stdin = open('myfile') 

you can also restore stdin using sys.__stdin__ instead of saving the old 
one, but in the case you or someone else is redirecting the stdin twice...