1、// 对结果舍掉尾数
1/2==>>>0
3/2.0==>>>1.5
3//2.0===>>>1.0
3.8/2===>>>1.9
3.8//2===>>>1.0
2、生成随机数
import random
random.randint(0,1000)生成一个[0, 1000]之间的整数
random.random()生成一个随机的0和1之间的浮点数
3、|按位或，&按位与，^按位异或，~按位求反
4、None 没有什么有用的属性，它的布尔值总是 False。
5、3 < 4 < 7 # same as "( 3 < 4 ) and ( 4 < 7 )"===>>> True
6、删除列表中重复的元素
方法一：
b1 = [1, 2, 3, 1, 3]
b1 = [b1[i] for i in range(len(b1)) if b1[i] not in b1[:i]]
方法二（最快）：
{}.fromkeys([b1]).keys()
方法三：
list(set(b1))
7、求列表交集
b6 = [1, 2, 3]
b2 = [2, 3, 4]
b4 = [val for val in b1 if val in b2]
b4 是 [2, 3]
8、单例模式
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
9、当a,b 的值是一样的时候，返回同一个对象
将new出来的新对象保存在一个列表中
class C(object):
lstObj=[]
def __init__(self,a,b):
print "__init__"
self.a=a
self.b=b
def __new__(cls, *args, **kwargs):
print "__new__"
for obj in cls.lstObj:
if obj.a == args[0] and obj.b == args[1]:
return obj
obj = object.__new__(cls, *args, **kwargs)
cls.lstObj.append(obj)
return obj
10、类A的属性a的值将会被转换为整数
class A(object):
def __init__(self, a):
self.a = 1
def __setattr__(self, attr, value):
if 'a' == attr:
object.__setattr__(self, attr, int(value))
else:
object.__setattr__(self, attr, value)
11、apply用法
def f(*args, **kwargs):
print args
print kwargs
apply(f, (1,203,3), {}) 返回值是'hello'
12、字典
dict(zip([1,2],[2,3]))===>{1: 2, 2: 3}
dict(zip([1,1],[2,3]))===>{1: 3}
13、字符串方法
"s".ljust(3,'0')===>'s00'
"s".rjust(3,'0')===>'00s'
"s".zfill(3)===>'00s'
14、lambda函数
lambda函数匿名函数
key=lambda x:x+1
key(2)===>3
15、re方法
re.match(pattern, string)只在字符串的起始处查找，类似startswith(prefix[, start[, end]])的找法
re.search(pattern, string)在整个字符串里面查找
re.sub(pattern, repl, string, count=0, flags=0)
re.subn(pattern, repl, string, count=0, flags=0)
Perform the same operation as sub(), but return a tuple (new_string, number_of_subs_made).
16、装饰器
#装饰器带参数
def deco(arg):
def _deco(func):
def __deco(*args, **kwargs):
print("before %s called [%s]." % (func.__name__, arg))
func(*args, **kwargs)
print("after %s called [%s]." % (func.__name__, arg))
return __deco
return _deco
@deco("mymodule")
def myfunc(*args, **kwargs):
print(" myfunc() called.")
@deco("module2")
def myfunc2(*args, **kwargs):
print(" myfunc2() called.")
myfunc(1)
myfunc2(1)
装饰器,装饰器实际就是函数
你可以考虑在装饰器中置入通用功能的代码来降低程序复杂度。例如，可以用装饰器来：
1 引入日志
2 增加计时逻辑来检测性能
2 给函数加入事务的能力
#被装饰的函数有参数
def f(func):
def wrapper(*args, **kwargs):
print "func called",args, kwargs
func(*args, **kwargs)
return wrapper
@f
def ff(*args, **kwargs):
print "ff"
ff(1,2)
@timeit
def f(*args, **kwargs):
print "in f"
17、用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别？
当重复匹配一个正则表达式时候， 例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值
例如：
import re
s = '<html><head><title>Title</title>'
print(re.match(‘<.*>’, s).group())
会返回一个匹配<html><head><title>Title</title>而不是<html>
而
import re
s = '<html><head><title>Title</title>'
print(re.match(‘<.*?>’, s).group())
则会返回<html>
<.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
18、介绍一下Python下range()函数的用法?
如果需要迭代一个数字序列的话，可以使用range()函数，range()函数可以生成等差级数。
如例：
for i in range(5)
print(i)
这段代码将输出0, 1, 2, 3, 4五个数字
range(10)会产生10个值， 也可以让range()从另外一个数字开始，或者定义一个不同的增量，甚至是负数增量。
range(5, 10)从5到9的五个数字range(0, 10, 3) 增量为三， 包括0,3,6,9四个数字range(-10, -100, -30) 增量为-30， 包括-10, -40, -70可以一起使用range()和len()来迭代一个索引序列例如：a = ['Nina', 'Jim', 'Rainman', 'Hello']for i in range(len(a)): print(i, a[i])
19、发送邮件
import smtplib
s = smtplib.SMTP_SSL()
s.connect("smpt.126.com")
s.login("user", "password")
s.sendmail("1@126.com",["1@qq.com", "222@126.com"],"From: 1@126.com\r\nTo: 1@qq.com, 222@126.com\r\nSubject: testmsg\r\n\r\nNicetomeetyou!\r\n")
s.quit()
20、打乱一个排好序的 list 对象 alist
import random
alist.sort(key=lambda True: random.randint(0,1))
21、默写尽可能多的 str 对象的方法
split,startswith,endswith,replace,upper,lower,splitlines,strip,ljust,rjust,zfill,join,rstrip,isdigit,encode,decode,lstrip,find
22、说说 dict 的 items() 方法与 iteritems() 方法的不同
items()返回一个列表，列表元素是(key, value)。iteritems()返回一个迭代器iterator，可以iterator.next()访问元素(key, value)
>>> for i in d.iteritems():
print i
(1, 2)
>>> for i in d.items():
print i
(1, 2)
>>>
如果 iterator.next()是空，会抛出异常。
>>> it.next()
Traceback (most recent call last):
File "<pyshell#136>", line 1, in <module>
it.next()
StopIteration
23、写一段程序逐行读入一个文本文件，并在屏幕上打印出来
f = open("filepath")
try:
for strLine in f:
if not strLine:
break
print strLine
finally:
f.close()
24、有二维的 list 对象（即它的每一个元素都是一个 list 对象）alist，假定其中的所有元素都具有相同的长度（把 alist 想象成一个表格），写一段程序根据元素的第二个元素排序（即对表格的第二列字段排序）
alist.sort(key=lambda x:x[1])
>>> alst=[(1,2),(2,3),(3,1)]
>>> alst.sort(key=lambda x:x[1])
>>> alst
[(3, 1), (1, 2), (2, 3)]
25、有一个排好序地 list 对象 alist，查找其中是否有某元素 a（尽可能地使用标准库函数）。
方法一、if a in alist
方法二、alist.count(a)
26、现在有一个 list 对象 alist，里面的所有元素都是字符串，编写一个函数对它实现一个大小写无关的排序
可以把字符串都转换成小写或大写再比较
>>> lsta=['One','one','TWO','twp','two']
>>> lsta.sort(key=lambda x:x.lower())
>>> lsta
['One', 'one', 'TWO', 'two', 'twp']
>>> lsta.sort(key=lambda x:x.upper())
>>> lsta
['One', 'one', 'TWO', 'two', 'twp']
27、字典中查找值相同的键
查找值是value的键，得到一个键列表
>>> lstSameValue=[]
>>> for k, v in d.items():
if v == value:
lstSameValue.append(k)
28、听过 the zen of python 吗？尽可能地默写它，中英文皆可，大意也可。如果没有听过，谈谈你对 pythonic 的看法，或者你认为什么样的 python 代码才是好代码
python风格的代码，比如pythoncookbook里面的代码
如:
lsta = []
for item in lsta:
do_something(item)
逐行处理文本
f = open(filepath)
for line in f:
do_something(line)
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea
-- let's do more of those!
-- by Tim Peters
29、数据结构的优缺点（转）
数据结构的特性
(1) 数组
优点：插入块，如果知道下标，可以非常快的存储。
缺点：查找慢，删除慢，大小固定
(2) 有序数组
优点：比无序数组查找快
缺点：删除和插入慢，大小固定
(3) 栈
优点：提供后进先出方式的存取，
缺点：效率低
(4) 队列
优点：提供先进先出的方式存取
缺点：效率低
(5) 链表
优点：插入，删除快
缺点：查找慢
(6) 二叉树
优点：查找，插入，删除都快
缺点：删除的算法复杂
(7) 红黑树
优点：查找，插入，删除都快
缺点：算法复杂
(8) 哈希表：
优点：如果关键字已知则存取极快，插入块
缺点：删除慢，如果不知道关键字则存取很慢，对存储空间使用不充分。
(9) 堆
优点：插入，删除快，对最大数据项的存取很快
缺点：对其他存储项很慢
数据结构：数据在计算机内存空间中或磁盘空间中的组织形式。
算法：完成特定任务的过程、
30、实现一个 stack
31、filter函数
filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。
【filter()函数有两个参数】
第一个，自定函数名，必须的
第二个，需要过滤的列，也是必须的
>>> seq=(12,50,8,17,65,14,9,6,14,5)
>>> def f(num):
if num > 5 and num < 10:
return True
return False
>>> filter(f, seq)
(8, 9, 6)
>>> def f2(num):
if num > 5 and num < 10:
return num
>>> filter(f2, seq)
(8, 9, 6)
>>> def f(num):
if num > 5 and num < 10:
return True
>>> filter(f, seq)
(8, 9, 6)
1/2==>>>0
3/2.0==>>>1.5
3//2.0===>>>1.0
3.8/2===>>>1.9
3.8//2===>>>1.0
2、生成随机数
import random
random.randint(0,1000)生成一个[0, 1000]之间的整数
random.random()生成一个随机的0和1之间的浮点数
3、|按位或，&按位与，^按位异或，~按位求反
4、None 没有什么有用的属性，它的布尔值总是 False。
5、3 < 4 < 7 # same as "( 3 < 4 ) and ( 4 < 7 )"===>>> True
6、删除列表中重复的元素
方法一：
b1 = [1, 2, 3, 1, 3]
b1 = [b1[i] for i in range(len(b1)) if b1[i] not in b1[:i]]
方法二（最快）：
{}.fromkeys([b1]).keys()
方法三：
list(set(b1))
7、求列表交集
b6 = [1, 2, 3]
b2 = [2, 3, 4]
b4 = [val for val in b1 if val in b2]
b4 是 [2, 3]
8、单例模式
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
9、当a,b 的值是一样的时候，返回同一个对象
将new出来的新对象保存在一个列表中
class C(object):
lstObj=[]
def __init__(self,a,b):
print "__init__"
self.a=a
self.b=b
def __new__(cls, *args, **kwargs):
print "__new__"
for obj in cls.lstObj:
if obj.a == args[0] and obj.b == args[1]:
return obj
obj = object.__new__(cls, *args, **kwargs)
cls.lstObj.append(obj)
return obj
10、类A的属性a的值将会被转换为整数
class A(object):
def __init__(self, a):
self.a = 1
def __setattr__(self, attr, value):
if 'a' == attr:
object.__setattr__(self, attr, int(value))
else:
object.__setattr__(self, attr, value)
11、apply用法
def f(*args, **kwargs):
print args
print kwargs
return 'hello'
apply(f, (1,203,3), {}) 返回值是'hello'
12、字典
dict(zip([1,2],[2,3]))===>{1: 2, 2: 3}
dict(zip([1,1],[2,3]))===>{1: 3}
13、字符串方法
"s".ljust(3,'0')===>'s00'
"s".rjust(3,'0')===>'00s'
"s".zfill(3)===>'00s'
14、lambda函数
lambda函数匿名函数
key=lambda x:x+1
key(2)===>3
15、re方法
re.match(pattern, string)只在字符串的起始处查找，类似startswith(prefix[, start[, end]])的找法
re.search(pattern, string)在整个字符串里面查找
re.sub(pattern, repl, string, count=0, flags=0)
re.subn(pattern, repl, string, count=0, flags=0)
Perform the same operation as sub(), but return a tuple (new_string, number_of_subs_made).
16、装饰器
#装饰器带参数
def deco(arg):
def _deco(func):
def __deco(*args, **kwargs):
print("before %s called [%s]." % (func.__name__, arg))
func(*args, **kwargs)
print("after %s called [%s]." % (func.__name__, arg))
return __deco
return _deco
@deco("mymodule")
def myfunc(*args, **kwargs):
print(" myfunc() called.")
@deco("module2")
def myfunc2(*args, **kwargs):
print(" myfunc2() called.")
myfunc(1)
myfunc2(1)
装饰器,装饰器实际就是函数
你可以考虑在装饰器中置入通用功能的代码来降低程序复杂度。例如，可以用装饰器来：
1 引入日志
2 增加计时逻辑来检测性能
2 给函数加入事务的能力
#被装饰的函数有参数
def f(func):
def wrapper(*args, **kwargs):
print "func called",args, kwargs
func(*args, **kwargs)
return wrapper
@f
def ff(*args, **kwargs):
print "ff"
ff(1,2)
@timeit
def f(*args, **kwargs):
print "in f"
17、用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别？
当重复匹配一个正则表达式时候， 例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值
例如：
import re
s = '<html><head><title>Title</title>'
print(re.match(‘<.*>’, s).group())
会返回一个匹配<html><head><title>Title</title>而不是<html>
而
import re
s = '<html><head><title>Title</title>'
print(re.match(‘<.*?>’, s).group())
则会返回<html>
<.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
18、介绍一下Python下range()函数的用法?
如果需要迭代一个数字序列的话，可以使用range()函数，range()函数可以生成等差级数。
如例：
for i in range(5)
print(i)
这段代码将输出0, 1, 2, 3, 4五个数字
range(10)会产生10个值， 也可以让range()从另外一个数字开始，或者定义一个不同的增量，甚至是负数增量。
range(5, 10)从5到9的五个数字range(0, 10, 3) 增量为三， 包括0,3,6,9四个数字range(-10, -100, -30) 增量为-30， 包括-10, -40, -70可以一起使用range()和len()来迭代一个索引序列例如：a = ['Nina', 'Jim', 'Rainman', 'Hello']for i in range(len(a)): print(i, a[i])
19、发送邮件
import smtplib
s = smtplib.SMTP_SSL()
s.connect("smpt.126.com")
s.login("user", "password")
s.sendmail("1@126.com",["1@qq.com", "222@126.com"],"From: 1@126.com\r\nTo: 1@qq.com, 222@126.com\r\nSubject: testmsg\r\n\r\nNicetomeetyou!\r\n")
s.quit()
20、打乱一个排好序的 list 对象 alist
import random
alist.sort(key=lambda True: random.randint(0,1))
21、默写尽可能多的 str 对象的方法
split,startswith,endswith,replace,upper,lower,splitlines,strip,ljust,rjust,zfill,join,rstrip,isdigit,encode,decode,lstrip,find
22、说说 dict 的 items() 方法与 iteritems() 方法的不同
items()返回一个列表，列表元素是(key, value)。iteritems()返回一个迭代器iterator，可以iterator.next()访问元素(key, value)
>>> for i in d.iteritems():
print i
(1, 2)
>>> for i in d.items():
print i
(1, 2)
>>>
如果 iterator.next()是空，会抛出异常。
>>> it.next()
Traceback (most recent call last):
File "<pyshell#136>", line 1, in <module>
it.next()
StopIteration
23、写一段程序逐行读入一个文本文件，并在屏幕上打印出来
f = open("filepath")
try:
for strLine in f:
if not strLine:
break
print strLine
finally:
f.close()
24、有二维的 list 对象（即它的每一个元素都是一个 list 对象）alist，假定其中的所有元素都具有相同的长度（把 alist 想象成一个表格），写一段程序根据元素的第二个元素排序（即对表格的第二列字段排序）
alist.sort(key=lambda x:x[1])
>>> alst=[(1,2),(2,3),(3,1)]
>>> alst.sort(key=lambda x:x[1])
>>> alst
[(3, 1), (1, 2), (2, 3)]
25、有一个排好序地 list 对象 alist，查找其中是否有某元素 a（尽可能地使用标准库函数）。
方法一、if a in alist
方法二、alist.count(a)
26、现在有一个 list 对象 alist，里面的所有元素都是字符串，编写一个函数对它实现一个大小写无关的排序
可以把字符串都转换成小写或大写再比较
>>> lsta=['One','one','TWO','twp','two']
>>> lsta.sort(key=lambda x:x.lower())
>>> lsta
['One', 'one', 'TWO', 'two', 'twp']
>>> lsta.sort(key=lambda x:x.upper())
>>> lsta
['One', 'one', 'TWO', 'two', 'twp']
27、字典中查找值相同的键
查找值是value的键，得到一个键列表
>>> lstSameValue=[]
>>> for k, v in d.items():
if v == value:
lstSameValue.append(k)
28、听过 the zen of python 吗？尽可能地默写它，中英文皆可，大意也可。如果没有听过，谈谈你对 pythonic 的看法，或者你认为什么样的 python 代码才是好代码
python风格的代码，比如pythoncookbook里面的代码
如:
lsta = []
for item in lsta:
do_something(item)
逐行处理文本
f = open(filepath)
for line in f:
do_something(line)
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea
-- let's do more of those!
-- by Tim Peters
29、数据结构的优缺点（转）
数据结构的特性
(1) 数组
优点：插入块，如果知道下标，可以非常快的存储。
缺点：查找慢，删除慢，大小固定
(2) 有序数组
优点：比无序数组查找快
缺点：删除和插入慢，大小固定
(3) 栈
优点：提供后进先出方式的存取，
缺点：效率低
(4) 队列
优点：提供先进先出的方式存取
缺点：效率低
(5) 链表
优点：插入，删除快
缺点：查找慢
(6) 二叉树
优点：查找，插入，删除都快
缺点：删除的算法复杂
(7) 红黑树
优点：查找，插入，删除都快
缺点：算法复杂
(8) 哈希表：
优点：如果关键字已知则存取极快，插入块
缺点：删除慢，如果不知道关键字则存取很慢，对存储空间使用不充分。
(9) 堆
优点：插入，删除快，对最大数据项的存取很快
缺点：对其他存储项很慢
数据结构：数据在计算机内存空间中或磁盘空间中的组织形式。
算法：完成特定任务的过程、
30、实现一个 stack
31、filter函数
filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。
【filter()函数有两个参数】
第一个，自定函数名，必须的
第二个，需要过滤的列，也是必须的
>>> seq=(12,50,8,17,65,14,9,6,14,5)
>>> def f(num):
if num > 5 and num < 10:
return True
return False
>>> filter(f, seq)
(8, 9, 6)
>>> def f2(num):
if num > 5 and num < 10:
return num
>>> filter(f2, seq)
(8, 9, 6)
>>> def f(num):
if num > 5 and num < 10:
return True
>>> filter(f, seq)
(8, 9, 6)
扫一扫
1987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
