基础知识汇总
2015-02-06 15:42
316 查看
body
{
font-family: "Microsoft YaHei UI","Microsoft YaHei",SimSun,"Segoe UI",Tahoma,Helvetica,Sans-Serif,"Microsoft YaHei", Georgia,Helvetica,Arial,sans-serif,宋体, PMingLiU,serif;
font-size: 10.5pt;
line-height: 1.5;
}
html, body
{
}
h1 {
font-size:1.5em;
font-weight:bold;
}
h2 {
font-size:1.4em;
font-weight:bold;
}
h3 {
font-size:1.3em;
font-weight:bold;
}
h4 {
font-size:1.2em;
font-weight:bold;
}
h5 {
font-size:1.1em;
font-weight:bold;
}
h6 {
font-size:1.0em;
font-weight:bold;
}
img {
border:0;
max-width: 100%;
}
blockquote {
margin-top:0px;
margin-bottom:0px;
}
table {
border-collapse:collapse;
border:1px solid #bbbbbb;
}
td {
border-collapse:collapse;
border:1px solid #bbbbbb;
}
基础知识汇总
1.self 首先明确的是self只有在类的方法中才会有，独立的函数或方法是不必带有self的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以,但是约定成俗，不要搞另类，大家会不明白的。
python中的self就相当于C++中的this指针也就是指向对象本身的指针self.name = name 就是当前对象的成员变量name赋值为name。在这里面self.name是什么类型呢？和变量有什么不同？python的特性就是声明一个变量的时候不需要手动的指定类型，赋值的时候类型就自动的决定了，并且后期也可以改变。这里name是从外部传入的，所以这里的self.name的类型就是由外部传递的name类型决定的。
那就是说self就是实例。name就是它的一个属性了。
2.superPython 的内置函数 super 来调用父类 Parent 里的版本
3.类参数不用写在类名后，在init里加。
4.函数参数可以设置默认值，但只能放在最后，如：def say(message, times = 1): print message * times
say('Hello')say('World', 5)
5.列表、元组中一个元素 my[0],字典是my['index']
6.b=a 如果a列表中数据改变，那么b列表中数据也改变
7.函数接收参数，如果函数中参数写为*args，所有多余的函数参数都会作为一个元组存储在args中;**args，多余的参数则会被认为是一个字典的键/值对。
8.enumerate 显示索引和值>>> for a, b in enumerate(['a','b','c']):... print a , b...0 a1 b2 c
9.id 显示内存地址,判断对象是否变化
10.正则？ 单独出现表未左边字符出现0或1次，左边为重复元字符表示越短越好如：（+？） 贪婪模式
11.a,b=b,a+b可以拆成a = b, b = a + b也就是说等号左边的第一个位置的等于等号右边的第一个位置等号左边第二个位置的等于等号右边第二个位置的。（a, b） = (b, a + b)如何写成a=b b=a+b 这样a的值就变了，（a, b） = (b, a + b) 相当于a用原来的值
12.yield函数只有返回一个值，每次都一样，而且使用yield生成器，可以用for 循环来取，每次都不一样，也就是说yield b 返回的值是一个循环def fab(max): n, a, b = 0, 0, 1 while n < max: yield b # print b a, b = b, a + b n = n + 1
i=fab(5)for a in i: print a
13.元组中包含的列表是可以改变的>>> a=(['a','b'], 'c', 'd')>>> a[0][0] = '1'>>> a(['1', 'b'], 'c', 'd')
14.列表浅拷贝和深拷贝>>> l = [ [1,2],3]>>> s = l[：] --同s=l>>> s[0][0]=5>>> s[[5, 2], 3]>>> l[[5, 2], 3]
--深>>> a=[1,2,3]>>> b=a[::]>>> b[0]=5>>> b[5, 2, 3]>>> a[1, 2, 3]
15.字典的格式打印>>> dict{'arch': 'sunos5', 'name': 'venus', 'port': 80}>>> print 'host %(name)s is running on port %(port)d' %dicthost venus is running on port 80
16.os.system('ipconfig') 执行系统命令
17. small = x if x < y else y同于if x < y : small = xelse: small = y
18.zip()的使用>>> l1 = ('a','b','c','d')>>> l2 = (1,2,3,4)>>> b = zip(l1,l2)>>> b[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> a=[[1, 2, 3],[4, 5, 6]]>>> print zip(a)[([1, 2, 3],), ([4, 5, 6],)]参数解包>>> print zip(*a)[(1, 4), (2, 5), (3, 6)]
19. for...else语句中,break会跳过else
20. 文件的迭代访问>>>myfile = open('1.txt')>>>for eachline in myfile:.... print eachline
for eachline in myfile 等同 for eachline in myfile.readlines()
21. 迭代统计文件字数>>> f = open('b.txt')>>> len([word for line in f for word in line.split( )])62
22. 批量修改列表内字符>>> all = [x.strip() for x in f.readlines()]
23.python 列表list中内置函数sort,sortedsorted(a) #将a从小到大排序,不影响a本身结构sorted(a,reverse = True) #将a从大到小排序,不影响a本身结构a.sort() #将a从小到大排序,影响a本身结构a.sort(reverse = True) #将a从大到小排序,影响a本身结构
#调用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
--------------------------------sorted--------------------------------------->>> help(sorted)Help on built-in function sorted in module __builtin__:
sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list---------------------------------sort---------------------------------------->>> help(list.sort)Help on method_descriptor:
sort(...) L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1-----------------------------------------------------------------------------
iterable：是可迭代类型;cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;reverse：排序规则. reverse = True 或者 reverse = False，有默认值。返回值：是一个经过排序的可迭代类型，与iterable一样。 注；一般来说，cmp和key可以使用lambda表达式。
sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。
24.函数中return的作用是函数立即返回,循环不再继续运行.def fc(lst): for i in lst: if i >0: continue else: return il = [1, -1, 2, -3, -4, 6, 7]
print fc(l)-1
25.关键字变量参数（字典类型）在非关键字变量参数之后def newfoo(arg1, arg2, *arv, **argv): print 'arg1 is :', arg1 print 'arg2 is :', arg2 for each in arv: print 'tuple :', each
newfoo(arg1='1', arg2=3, 4, 5)报错：SyntaxError: non-keyword arg after keyword arg————因为字典类型应该在最后 newfoo(4, 5, arg1='1', arg2=3)报错：TypeError: newfoo() got multiple values for keyword argument 'arg1'————因为arg1被赋了2个值4和1
26.lamda函数def add(x, y): return x+yprint add(5, 9)等同于a = lambda x, y: x + yprint a(5, 9)
27.map函数对集合使用函数，多个集合同时按顺序取1个出来处理，保存为列表map(lambda x: x**2, range(6))等同于[x**2 for x in range(6)]
28.map 列表a = map(lambda x, y: x + y, [1, 3, 5], [2, 4, 6])print a等同于a = [x + y for x, y in zip([1, 3, 5] , [2, 4, 6])]print a执行结果： [3, 7, 11]
b = [x + y for x in [1, 3, 5] for y in [2, 4, 6]]print b等同于b = []for x in [1, 3, 5]: for y in [2, 4, 6]: b.append(x + y)print b执行结果：[3, 5, 7, 5, 7, 9, 7, 9, 11]
30.reduce对集合中前2个进行函数调用，返回值再和后面数调用函数，输入2个参数，返回1个数a = reduce(lambda x, y: x + y, (0, 1, 2, 3, 4))print a结果：10
31.闭包引用外部变量的内部函数是闭包closure>>> def counter(start_at = 0):... count = [start_at]... def incr():... count[0] += 1... return count[0]... return incr...>>> count = counter(5)>>> print count()6>>> print count()7
32.递归函数求n*(n-1)*...*1def f(n): if n == 0 or n == 1: return 1 else: return (n * f(n-1))print f(50)
33.子类中如果写了构造器__init__,那就需要显式的写出父类的构造器
34.dir(c), c.__class__, c.__dict__
35.>>> class myClass(object):... def __init__(self):... self.foo = 100...>>> myInst = myClass()>>> hasattr(myInst, 'foo')True>>> getattr(myInst, 'foo')100>>> getattr(myInst, 'bar', 'oops!') --oops为默认值，如果bar不存在就返回默认值'oops!'>>> setattr(myInst, 'bar', 'my attr')>>> getattr(myInst, 'bar')'my attr'>>> delattr(myInst, 'foo')>>> dir(myInst)['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar']>>> hasattr(myInst, 'foo')False>>> myInst.__dict__{'bar': 'my attr'}
36.__str__函数定义了 print classA 的输出值__repr__定义了执行类实例的返回值可以用__repr__ = __str__
37.exec执行py文件内容f = open('1.py')exec f等同于execfile('1.py')
38.eval(a)转换字符串为对象>>> b = eval('dir()')>>> b['__builtins__', '__doc__', '__name__', '__package__', 'a', 'b']
39.字符串>>> c = '%d %s %d = %d' % (5, 'add', 3, 8)>>> c'5 add 3 = 8'
40.字符串显示>>> print '%03d' % 8008
41.正则表达式 ?1.单独使用表示0或1次.2.紧跟在表示重复的元字符后,表示搜索引擎匹配的字符串越短越好
42.chcp 65001 设置CMD的编码为UTF-8
43.在python27/scripts下执行easy_install Tornado
44.url解码
>>> import urllib>>> eu='http%3A%2F%2Fwww.baidu.com%2Fcache%2Fuser%2Fhtml%2Fv3Jump.html'>>> du=urllib.unquote(eu)>>> du'http://www.baidu.com/cache/user/html/v3Jump.html'
45.python3 print函数 可以用end参数来定义结束符print('\t', end='', file=sys.stdout) end=''不做换行, file=sys.stdout输出到显示屏
46.split函数(n, m) = i.split(':', 1) 后面max参数为1 表示分割字符的时候把字符串以第1个符号进行分割。
47.用WITH打开议文件不用考虑文件关闭with open('man_data.txt', 'w') as man_data: print(man, file=man_data)
相当于man_data = open('man_data,txt', 'w')
48.pickle的使用import pickledata = open('a.txt', 'wb')pickle.dump([1,2,3], data)data.close()indata = open('a.txt', 'rb')alist=pickle.load(indata)print(alist)
49.利用集合来去重>>> a=[1, 2, 3, 4, 2, 1]>>> b=list(set(a))>>> b[1, 2, 3, 4]
50.class Athlete: def __init__(self, value=0): self.thing = value def how_big(self): return(len(self.thing))
d = Athlete("Holy Grail") --> Athlete.__init__(d, "Holy Grail")d.how_big() --> Athlete.how_big(d)
51.列表推导包含append函数>>> a = []>>> b = [1, 2, 3]>>> for i in b: x = i*20 a.append(x)>>> a[20, 40, 60]
等同于
>>> b = [1, 2, 3]>>> c = [i*20 for i in b]>>> c[20, 40, 60]
52.如何检测一个变量是否存在
问题 链接
我想检测一个变量是否存在，我现在是这么做的
try: myVarexcept NameError: # Doint smth
存在其他不是使用exception的方式么？
回答
检测本地变量
if 'myVar' in locals(): # myVar exists.
检测全局变量
if 'myVar' in globals(): # myVar exists.
检测一个对象是否包含某个属性
if hasattr(obj, 'attr_name'): # obj.attr_name exists.
53.如何扁平一个二维数组
问题 链接
l = [[1,2,3],[4,5,6], [7], [8,9]]变为[1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9]
列表解析
[item for sublist in l for item in sublist]
等同
for sublist in l: for item in sublist: x.append(item)
54.函数默认参数只解析一次
默认值在函数 定义 作用域被解析，如下所示
i = 5
def f(arg=i): print arg
i = 6f()
将打印出 5.重要警告 默认值只解析一次。 这造成字典、列表或大部分类实例等可变对象的行为会与期待的不太一样。例如，下例的函数在每次调用时都造成参数的累加
def f(a, L=[]): L.append(a) return L
print f(1)print f(2)print f(3)
这将会打印
[1][1, 2][1, 2, 3]
如果你不想在随后的调用中共享默认值，可以像这样写函数
def f(a, L=None): if L is None: L = [] L.append(a) return L
55.参数列表的分拆当你要传递的参数已经是一个列表，但要调用的函数却接受分开一个个的参数值,你可以在调用函数时加一个 * 操作符来自动把参数列表拆开
>>> range(3, 6) # normal call with separate arguments[3, 4, 5]>>> args = [3, 6]>>> range(*args) # call with arguments unpacked from a list[3, 4, 5]
以同样的方式，可以使用 ** 操作符分拆关键字参数为字典
>>> def parrot(voltage, state='a stiff', action='voom'):... print "-- This parrot wouldn't", action,... print "if you put", voltage, "volts through it.",... print "E's", state, "!"...>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}>>> parrot(**d)-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
56.一种无名函数的速写法def make_incrementor(n): return lambda x: x+nf=make_incrementor(n)#f等价于#def f(x):# return x+n
57.列表推导式可以嵌套。
考虑以下的 3x4 矩阵， 一个列表中包含三个长度为4的列表
>>> matrix = [... [1, 2, 3, 4],... [5, 6, 7, 8],... [9, 10, 11, 12],... ]现在，如果你想交换行和列，可以用列表推导式
>>> [[row[i] for row in matrix] for i in range(4)][[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]像前面看到的，嵌套的列表推导式是对 for 后面的内容进行求值，所以上例就等价于
>>> transposed = []>>> for i in range(4):... transposed.append([row[i] for row in matrix])...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]反过来说，如下也是一样的
>>> transposed = []>>> for i in range(4):... # the following 3 lines implement the nested listcomp... transposed_row = []... for row in matrix:... transposed_row.append(row[i])... transposed.append(transposed_row)...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]在实际中，你应该更喜欢使用内置函数组成复杂流程语句。 对此种情况 zip() 函数将会做的更好
>>> zip(*matrix)[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
等同于>>>zip(matrix[0], matrix[1], matrix[2])
58. 不包含abc的字符串re.compile(r'^((?!abc)\w)+$')
59.遇到特殊字符写入文件报错可以使用#coding:gb18030import sys
reload(sys)
sys.setdefaultencoding("gb18030")
60.集合求差>>> a={1,2,3,4,5,6,7}
>>> b={2,4,6}>>> a.difference(b)
set([1, 3, 5, 7])
③ 对两个集合的 Union［并集］操作也是对称的。④ 对两个集合的 Intersection［交集］操作也是对称的。⑤ 对两个集合的 Difference［求差］操作不是对称的。
61. pip用豆瓣数据源更新pip install XXXX -i http://pypi.douban.com/simple
62.替换列表中符合条件的字符(如果字符串第一个字符为数字的改成a开头)ax = [i if i[0].isdigit() == False else 'a'+i for i in l]
63.在列表前插入值>>> a = [1, 2, 3]
>>> a.insert(0,99)
>>> a
[99, 1, 2, 3]
64.冒泡算法a = [1, 4, 51, 92, 11]
for x in range(len(a)):
for y in range(len(a)-1):
if a[y] > a[y+1]:
a[y+1], a[y] = a[y], a[y+1]
print a
65.查看元素在列表中的位置list1.index('a')
67.ascii解码成汉字>>> print 'c4e3bac3'.decode('hex')
你好
>>> print 'c4e3'.decode('hex')
你
来自为知笔记(Wiz)
{
font-family: "Microsoft YaHei UI","Microsoft YaHei",SimSun,"Segoe UI",Tahoma,Helvetica,Sans-Serif,"Microsoft YaHei", Georgia,Helvetica,Arial,sans-serif,宋体, PMingLiU,serif;
font-size: 10.5pt;
line-height: 1.5;
}
html, body
{
}
h1 {
font-size:1.5em;
font-weight:bold;
}
h2 {
font-size:1.4em;
font-weight:bold;
}
h3 {
font-size:1.3em;
font-weight:bold;
}
h4 {
font-size:1.2em;
font-weight:bold;
}
h5 {
font-size:1.1em;
font-weight:bold;
}
h6 {
font-size:1.0em;
font-weight:bold;
}
img {
border:0;
max-width: 100%;
}
blockquote {
margin-top:0px;
margin-bottom:0px;
}
table {
border-collapse:collapse;
border:1px solid #bbbbbb;
}
td {
border-collapse:collapse;
border:1px solid #bbbbbb;
}
基础知识汇总
1.self 首先明确的是self只有在类的方法中才会有，独立的函数或方法是不必带有self的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以,但是约定成俗，不要搞另类，大家会不明白的。
python中的self就相当于C++中的this指针也就是指向对象本身的指针self.name = name 就是当前对象的成员变量name赋值为name。在这里面self.name是什么类型呢？和变量有什么不同？python的特性就是声明一个变量的时候不需要手动的指定类型，赋值的时候类型就自动的决定了，并且后期也可以改变。这里name是从外部传入的，所以这里的self.name的类型就是由外部传递的name类型决定的。
那就是说self就是实例。name就是它的一个属性了。
2.superPython 的内置函数 super 来调用父类 Parent 里的版本
3.类参数不用写在类名后，在init里加。
4.函数参数可以设置默认值，但只能放在最后，如：def say(message, times = 1): print message * times
say('Hello')say('World', 5)
5.列表、元组中一个元素 my[0],字典是my['index']
6.b=a 如果a列表中数据改变，那么b列表中数据也改变
7.函数接收参数，如果函数中参数写为*args，所有多余的函数参数都会作为一个元组存储在args中;**args，多余的参数则会被认为是一个字典的键/值对。
8.enumerate 显示索引和值>>> for a, b in enumerate(['a','b','c']):... print a , b...0 a1 b2 c
9.id 显示内存地址,判断对象是否变化
10.正则？ 单独出现表未左边字符出现0或1次，左边为重复元字符表示越短越好如：（+？） 贪婪模式
11.a,b=b,a+b可以拆成a = b, b = a + b也就是说等号左边的第一个位置的等于等号右边的第一个位置等号左边第二个位置的等于等号右边第二个位置的。（a, b） = (b, a + b)如何写成a=b b=a+b 这样a的值就变了，（a, b） = (b, a + b) 相当于a用原来的值
12.yield函数只有返回一个值，每次都一样，而且使用yield生成器，可以用for 循环来取，每次都不一样，也就是说yield b 返回的值是一个循环def fab(max): n, a, b = 0, 0, 1 while n < max: yield b # print b a, b = b, a + b n = n + 1
i=fab(5)for a in i: print a
13.元组中包含的列表是可以改变的>>> a=(['a','b'], 'c', 'd')>>> a[0][0] = '1'>>> a(['1', 'b'], 'c', 'd')
14.列表浅拷贝和深拷贝>>> l = [ [1,2],3]>>> s = l[：] --同s=l>>> s[0][0]=5>>> s[[5, 2], 3]>>> l[[5, 2], 3]
--深>>> a=[1,2,3]>>> b=a[::]>>> b[0]=5>>> b[5, 2, 3]>>> a[1, 2, 3]
15.字典的格式打印>>> dict{'arch': 'sunos5', 'name': 'venus', 'port': 80}>>> print 'host %(name)s is running on port %(port)d' %dicthost venus is running on port 80
16.os.system('ipconfig') 执行系统命令
17. small = x if x < y else y同于if x < y : small = xelse: small = y
18.zip()的使用>>> l1 = ('a','b','c','d')>>> l2 = (1,2,3,4)>>> b = zip(l1,l2)>>> b[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> a=[[1, 2, 3],[4, 5, 6]]>>> print zip(a)[([1, 2, 3],), ([4, 5, 6],)]参数解包>>> print zip(*a)[(1, 4), (2, 5), (3, 6)]
19. for...else语句中,break会跳过else
20. 文件的迭代访问>>>myfile = open('1.txt')>>>for eachline in myfile:.... print eachline
for eachline in myfile 等同 for eachline in myfile.readlines()
21. 迭代统计文件字数>>> f = open('b.txt')>>> len([word for line in f for word in line.split( )])62
22. 批量修改列表内字符>>> all = [x.strip() for x in f.readlines()]
23.python 列表list中内置函数sort,sortedsorted(a) #将a从小到大排序,不影响a本身结构sorted(a,reverse = True) #将a从大到小排序,不影响a本身结构a.sort() #将a从小到大排序,影响a本身结构a.sort(reverse = True) #将a从大到小排序,影响a本身结构
#调用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
--------------------------------sorted--------------------------------------->>> help(sorted)Help on built-in function sorted in module __builtin__:
sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list---------------------------------sort---------------------------------------->>> help(list.sort)Help on method_descriptor:
sort(...) L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1-----------------------------------------------------------------------------
iterable：是可迭代类型;cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;reverse：排序规则. reverse = True 或者 reverse = False，有默认值。返回值：是一个经过排序的可迭代类型，与iterable一样。 注；一般来说，cmp和key可以使用lambda表达式。
sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。
24.函数中return的作用是函数立即返回,循环不再继续运行.def fc(lst): for i in lst: if i >0: continue else: return il = [1, -1, 2, -3, -4, 6, 7]
print fc(l)-1
25.关键字变量参数（字典类型）在非关键字变量参数之后def newfoo(arg1, arg2, *arv, **argv): print 'arg1 is :', arg1 print 'arg2 is :', arg2 for each in arv: print 'tuple :', each
newfoo(arg1='1', arg2=3, 4, 5)报错：SyntaxError: non-keyword arg after keyword arg————因为字典类型应该在最后 newfoo(4, 5, arg1='1', arg2=3)报错：TypeError: newfoo() got multiple values for keyword argument 'arg1'————因为arg1被赋了2个值4和1
26.lamda函数def add(x, y): return x+yprint add(5, 9)等同于a = lambda x, y: x + yprint a(5, 9)
27.map函数对集合使用函数，多个集合同时按顺序取1个出来处理，保存为列表map(lambda x: x**2, range(6))等同于[x**2 for x in range(6)]
28.map 列表a = map(lambda x, y: x + y, [1, 3, 5], [2, 4, 6])print a等同于a = [x + y for x, y in zip([1, 3, 5] , [2, 4, 6])]print a执行结果： [3, 7, 11]
b = [x + y for x in [1, 3, 5] for y in [2, 4, 6]]print b等同于b = []for x in [1, 3, 5]: for y in [2, 4, 6]: b.append(x + y)print b执行结果：[3, 5, 7, 5, 7, 9, 7, 9, 11]
30.reduce对集合中前2个进行函数调用，返回值再和后面数调用函数，输入2个参数，返回1个数a = reduce(lambda x, y: x + y, (0, 1, 2, 3, 4))print a结果：10
31.闭包引用外部变量的内部函数是闭包closure>>> def counter(start_at = 0):... count = [start_at]... def incr():... count[0] += 1... return count[0]... return incr...>>> count = counter(5)>>> print count()6>>> print count()7
32.递归函数求n*(n-1)*...*1def f(n): if n == 0 or n == 1: return 1 else: return (n * f(n-1))print f(50)
33.子类中如果写了构造器__init__,那就需要显式的写出父类的构造器
34.dir(c), c.__class__, c.__dict__
35.>>> class myClass(object):... def __init__(self):... self.foo = 100...>>> myInst = myClass()>>> hasattr(myInst, 'foo')True>>> getattr(myInst, 'foo')100>>> getattr(myInst, 'bar', 'oops!') --oops为默认值，如果bar不存在就返回默认值'oops!'>>> setattr(myInst, 'bar', 'my attr')>>> getattr(myInst, 'bar')'my attr'>>> delattr(myInst, 'foo')>>> dir(myInst)['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar']>>> hasattr(myInst, 'foo')False>>> myInst.__dict__{'bar': 'my attr'}
36.__str__函数定义了 print classA 的输出值__repr__定义了执行类实例的返回值可以用__repr__ = __str__
37.exec执行py文件内容f = open('1.py')exec f等同于execfile('1.py')
38.eval(a)转换字符串为对象>>> b = eval('dir()')>>> b['__builtins__', '__doc__', '__name__', '__package__', 'a', 'b']
39.字符串>>> c = '%d %s %d = %d' % (5, 'add', 3, 8)>>> c'5 add 3 = 8'
40.字符串显示>>> print '%03d' % 8008
41.正则表达式 ?1.单独使用表示0或1次.2.紧跟在表示重复的元字符后,表示搜索引擎匹配的字符串越短越好
42.chcp 65001 设置CMD的编码为UTF-8
43.在python27/scripts下执行easy_install Tornado
44.url解码
>>> import urllib>>> eu='http%3A%2F%2Fwww.baidu.com%2Fcache%2Fuser%2Fhtml%2Fv3Jump.html'>>> du=urllib.unquote(eu)>>> du'http://www.baidu.com/cache/user/html/v3Jump.html'
45.python3 print函数 可以用end参数来定义结束符print('\t', end='', file=sys.stdout) end=''不做换行, file=sys.stdout输出到显示屏
46.split函数(n, m) = i.split(':', 1) 后面max参数为1 表示分割字符的时候把字符串以第1个符号进行分割。
47.用WITH打开议文件不用考虑文件关闭with open('man_data.txt', 'w') as man_data: print(man, file=man_data)
相当于man_data = open('man_data,txt', 'w')
48.pickle的使用import pickledata = open('a.txt', 'wb')pickle.dump([1,2,3], data)data.close()indata = open('a.txt', 'rb')alist=pickle.load(indata)print(alist)
49.利用集合来去重>>> a=[1, 2, 3, 4, 2, 1]>>> b=list(set(a))>>> b[1, 2, 3, 4]
50.class Athlete: def __init__(self, value=0): self.thing = value def how_big(self): return(len(self.thing))
d = Athlete("Holy Grail") --> Athlete.__init__(d, "Holy Grail")d.how_big() --> Athlete.how_big(d)
51.列表推导包含append函数>>> a = []>>> b = [1, 2, 3]>>> for i in b: x = i*20 a.append(x)>>> a[20, 40, 60]
等同于
>>> b = [1, 2, 3]>>> c = [i*20 for i in b]>>> c[20, 40, 60]
52.如何检测一个变量是否存在
问题 链接
我想检测一个变量是否存在，我现在是这么做的
try: myVarexcept NameError: # Doint smth
存在其他不是使用exception的方式么？
回答
检测本地变量
if 'myVar' in locals(): # myVar exists.
检测全局变量
if 'myVar' in globals(): # myVar exists.
检测一个对象是否包含某个属性
if hasattr(obj, 'attr_name'): # obj.attr_name exists.
53.如何扁平一个二维数组
问题 链接
l = [[1,2,3],[4,5,6], [7], [8,9]]变为[1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9]
列表解析
[item for sublist in l for item in sublist]
等同
for sublist in l: for item in sublist: x.append(item)
54.函数默认参数只解析一次
默认值在函数 定义 作用域被解析，如下所示
i = 5
def f(arg=i): print arg
i = 6f()
将打印出 5.重要警告 默认值只解析一次。 这造成字典、列表或大部分类实例等可变对象的行为会与期待的不太一样。例如，下例的函数在每次调用时都造成参数的累加
def f(a, L=[]): L.append(a) return L
print f(1)print f(2)print f(3)
这将会打印
[1][1, 2][1, 2, 3]
如果你不想在随后的调用中共享默认值，可以像这样写函数
def f(a, L=None): if L is None: L = [] L.append(a) return L
55.参数列表的分拆当你要传递的参数已经是一个列表，但要调用的函数却接受分开一个个的参数值,你可以在调用函数时加一个 * 操作符来自动把参数列表拆开
>>> range(3, 6) # normal call with separate arguments[3, 4, 5]>>> args = [3, 6]>>> range(*args) # call with arguments unpacked from a list[3, 4, 5]
以同样的方式，可以使用 ** 操作符分拆关键字参数为字典
>>> def parrot(voltage, state='a stiff', action='voom'):... print "-- This parrot wouldn't", action,... print "if you put", voltage, "volts through it.",... print "E's", state, "!"...>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}>>> parrot(**d)-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
56.一种无名函数的速写法def make_incrementor(n): return lambda x: x+nf=make_incrementor(n)#f等价于#def f(x):# return x+n
57.列表推导式可以嵌套。
考虑以下的 3x4 矩阵， 一个列表中包含三个长度为4的列表
>>> matrix = [... [1, 2, 3, 4],... [5, 6, 7, 8],... [9, 10, 11, 12],... ]现在，如果你想交换行和列，可以用列表推导式
>>> [[row[i] for row in matrix] for i in range(4)][[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]像前面看到的，嵌套的列表推导式是对 for 后面的内容进行求值，所以上例就等价于
>>> transposed = []>>> for i in range(4):... transposed.append([row[i] for row in matrix])...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]反过来说，如下也是一样的
>>> transposed = []>>> for i in range(4):... # the following 3 lines implement the nested listcomp... transposed_row = []... for row in matrix:... transposed_row.append(row[i])... transposed.append(transposed_row)...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]在实际中，你应该更喜欢使用内置函数组成复杂流程语句。 对此种情况 zip() 函数将会做的更好
>>> zip(*matrix)[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
等同于>>>zip(matrix[0], matrix[1], matrix[2])
58. 不包含abc的字符串re.compile(r'^((?!abc)\w)+$')
59.遇到特殊字符写入文件报错可以使用#coding:gb18030import sys
reload(sys)
sys.setdefaultencoding("gb18030")
60.集合求差>>> a={1,2,3,4,5,6,7}
>>> b={2,4,6}>>> a.difference(b)
set([1, 3, 5, 7])
③ 对两个集合的 Union［并集］操作也是对称的。④ 对两个集合的 Intersection［交集］操作也是对称的。⑤ 对两个集合的 Difference［求差］操作不是对称的。
61. pip用豆瓣数据源更新pip install XXXX -i http://pypi.douban.com/simple
62.替换列表中符合条件的字符(如果字符串第一个字符为数字的改成a开头)ax = [i if i[0].isdigit() == False else 'a'+i for i in l]
63.在列表前插入值>>> a = [1, 2, 3]
>>> a.insert(0,99)
>>> a
[99, 1, 2, 3]
64.冒泡算法a = [1, 4, 51, 92, 11]
for x in range(len(a)):
for y in range(len(a)-1):
if a[y] > a[y+1]:
a[y+1], a[y] = a[y], a[y+1]
print a
65.查看元素在列表中的位置list1.index('a')
67.ascii解码成汉字>>> print 'c4e3bac3'.decode('hex')
你好
>>> print 'c4e3'.decode('hex')
你
来自为知笔记(Wiz)
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 