os.system("mkdir Test.txt"),
python setup.py install
dir()
以列表形式返回
查询对象所有的方法
range()的用法
使用python的人都知道range()函数很方便，今天再用到他的时候发现了很多以前看到过但是忘记的细节。这里记录一下range(),复习下list的slide，最后分析一个好玩儿的冒泡程序。
这里记录一下：
|
|
>>> range(10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> range(1, 11)[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> range(0, 30, 5)[0, 5, 10, 15, 20, 25]>>> range(0, 10, 3)[0, 3, 6, 9]>>> range(0, -10, -1)[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]>>> range(0)[]>>> range(1, 0)[]
range错误返回一个空list
list的slide()方法
再看看list的操作:
|
|
那么两个[::]会是什么那？
|
来源： http://www.cnblogs.com/buro79xxd/archive/2011/05/23/2054493.html |
list的sort()方法
元组不可以
x = [4, 6, 2, 1, 7, 9] x.sort() print x # [1, 2, 4, 6, 7, 9]
x =[4, 6, 2, 1, 7, 9] y = sorted(x) print y #[1, 2, 4, 6, 7, 9] print x #[4, 6, 2, 1, 7, 9]
如果需要一个排序好的副本，同时保持原有列表不变，怎么实现呢
x =[4, 6, 2, 1, 7, 9] y = x[ : ] y.sort() print y #[1, 2, 4, 6, 7, 9] print x #[4, 6, 2, 1, 7, 9]
y = x[:] 通过分片操作将列表x的元素全部拷贝给y，如果简单的把x赋值给y：y = x，y和x还是指向同一个列表，并没有产生新的副本。
二、自定义比较函数
可以定义自己的比较函数，然后通过参数传递给sort方法：
def comp(x, y): if x < y: return 1 elif x > y: return -1 else: return 0 nums = [3, 2, 8 ,0 , 1] nums.sort(comp) print nums # 降序排序[8, 3, 2, 1, 0] nums.sort(cmp) # 调用内建函数cmp ，升序排序 print nums # 降序排序[0, 1, 2, 3, 8]
来源： http://www.jb51.net/article/52730.htm
相当于是冒泡排序
2、reverse实现降序排序，需要提供一个布尔值：
y = [3, 2, 8 ,0 , 1] y.sort(reverse = True) print y #[8, 3, 2, 1, 0]
list的reverse()函数
方法没有返回值，但是会对列表的元素进行反向排序。
aList = [123, ‘xyz‘, ‘zara‘, ‘abc‘, ‘xyz‘]; aList.reverse();print "List : ", aList;
python交换两个值
可以多个变量同时交换
复制代码代码如下:
a=50
b=10
c=20
c,b,a = a,b,c
跟c的指针差不多，改变了指针的指向
删除一个list里面的重复元素
1 >>> l = [1,1,2,3,4,5,4] 2 >>> list(set(l)) 3 [1, 2, 3, 4, 5]
copy一个对象
标准库中的copy模块提供了两个方法来实现拷贝.一个方法是copy,它返回和参数包含内容一样的对象.
使用deepcopy方法,对象中的属性也被复制
1.import copy
new_list = copy.copy(existing_list)
有些时候,你希望对象中的属性也被复制,可以使用deepcopy方法:
2.import copy
new_list_of_dicts = copy.deepcopy(existing_list_of_dicts)
3.对于dict,你可能见过下面的复制方法:
>>> for somekey in d:
... d1[somekey] = d[somekey]
4.如果需要一个排序好的副本，同时保持原有列表不变，怎么实现呢
x =[4, 6, 2, 1, 7, 9] y = x[ : ] y.sort() print y #[1, 2, 4, 6, 7, 9] print x #[4, 6, 2, 1, 7, 9]
y = x[:] 通过分片操作将列表x的元素全部拷贝给y，如果简单的把x赋值给y：y = x，y和x还是指向同一个列表，并没有产生新的副本。
re.sub 函数进行以正则表达式为基础的替换工作
[python] view plain copy
- >>> import re
- >>> re.search(‘[abc]‘, ‘Mark‘)
- <_sre.SRE_Match object at 0x001C1FA8>
- >>> re.sub(‘[abc]‘, ‘o‘, ‘Mark‘)
- ‘Mork‘
- >>> re.sub(‘[abc]‘, ‘o‘, ‘rock‘)
- ‘rook‘
- >>> re.sub(‘[abc]‘, ‘o‘, ‘caps‘)
- ‘oops‘
用Python匹配HTML tag
术语叫贪婪匹配( <.*> ) 非贪婪匹配( <.*?> )例如: <div><span>test</span></div><.*> : <div><span>test</span></div><.*?> : <div>
术语叫贪婪匹配( <.*> ) 非贪婪匹配( <.*?> )例如: <div><span>test</span></div><.*> : <div><span>test</span></div><.*?> : <div>
重复匹配一个正则表达式时候， 例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值
例如：
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>
<.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
来源： http://www.educity.cn/develop/1123833.html
re.search r,match方法介绍
match ：只从字符串的开始与正则表达式匹配，匹配成功返回matchobject，否则返回none；
search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回none，否则返回matchobject；（re.search相当于perl中的默认行为）
re.search(w1, s1)
re.match(w2, s1)
random模块
Python中的random模块
Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个函数。
random.random
random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0
random.uniform
random.uniform的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
- printrandom.uniform(10,20)
- printrandom.uniform(20,10)
- #----结果（不同机器上的结果不一样）
- #18.7356606526
- #12.5798298022
print random.uniform(10, 20) print random.uniform(20, 10) #---- 结果（不同机器上的结果不一样） #18.7356606526 #12.5798298022
random.randint
random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b
- printrandom.randint(12,20)#生成的随机数n:12<=n<=20
- printrandom.randint(20,20)#结果永远是20
- #printrandom.randint(20,10)#该语句是错误的。下限必须小于上限。
print random.randint(12, 20) #生成的随机数n: 12 <= n <= 20 print random.randint(20, 20) #结果永远是20 #print random.randint(20, 10) #该语句是错误的。下限必须小于上限。
random.randrange
random.randrange的函数原型为：random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。
random.choice
random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。下面是使用choice的一些例子：
- printrandom.choice("学习Python")
- printrandom.choice(["JGood","is","a","handsome","boy"]) 需要指定为list或者tuple,也就是外面要加括号
- printrandom.choice(("Tuple","List","Dict"))
print random.choice("学习Python") print random.choice(["JGood", "is", "a", "handsome", "boy"]) print random.choice(("Tuple", "List", "Dict"))
python中如何将两个list合并成一个list
1.直接相加
2。extend()
3.分隔符，至改变前面的数值，代表第二个list的起始位置
python 怎么删除文件
使用os包的remove方法可以删除文件
import osfilename = ‘f:/123.txt‘if os.path.exist(filename): os.remove(filename)
Python如何copy一个文件？
|
|
从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为
list的extend()与append()方法
2. append() 方法向列表的尾部添加一个新的元素。只接受一个参数。
3. extend()方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
>>> mylist.append(‘haha‘)
>>> mylist.extend([‘lulu‘])
if 的牛逼用法
4, 条件表达式(即"三元操作符")
三元运算符语法为：X if C else Y，只需要一行完成条件判断和赋值操作：
>>> x, y = 4, 3 >>> smaller = x if x < y else y >>> smaller
3
1 b1=[1,2,3] 2 b2=[2,3,4] 3 b3 = [val for val in b1 if val in b2] 4 print b3
后面的else没有写，所以如果 val不再b2中存在就返回一个空值
python捕获异常
在Python中，异常也是对象
所有异常都是基类Exception的成员
4. 采用sys模块回溯最后的异常
import sys
try:
block
except:
info=sys.exc_info()
print info[0],":",info[1]
或者以如下的形式:
import sys
tp,val,td = sys.exc_info()
sys.exc_info()的返回值是一个tuple
（2）用raise语句手工引发一个异常:
1 raise [exception[,data]] 23 try: 4 raise MyError #自己抛出一个异常 5 except MyError: 6 print ‘a error‘78 raise ValueError,’invalid argumen
4, 条件表达式(即"三元操作符")
三元运算符语法为：X if C else Y，只需要一行完成条件判断和赋值操作：
>>> x, y = 4, 3 >>> smaller = x if x < y else y >>> smaller
3
1、if语句
2、else语句
3、elif (即else-if )语句
5、while语句
6、for语句
它会自动地调用迭代器的next()方法，捕获StopIteration异常并结束循环（所有这一切都是在内部发生的）
使用项和索引迭代
>>> nameList = [‘Donn‘, ‘Shirley‘, ‘Ben‘, ‘Janice‘,‘David‘, ‘Yen‘, ‘Wendy‘] >>> for i, eachLee in enumerate(nameList): ... print "%d %s Lee" % (i+1, eachLee) ... 1 Donn Lee 2 Shirley Lee 3 Ben Lee 4 Janice Lee 5 David Lee 6 Yen Lee 7 Wendy Lee
通过序列索引迭代
>>> nameList = [‘Cathy‘, "Terry", ‘Joe‘, ‘Heather‘,‘Lucy‘] >>> for nameIndex in range(len(nameList)): ... print "Liu,", nameList[nameIndex] ... Liu, Cathy Liu, Terry Liu, Joe Liu, Heather Liu, Lucy
通过序列项迭代
>>> nameList = [‘Walter‘, "Nicole", ‘Steven‘, ‘Henry‘] >>> for eachName in nameList: ... print eachName, "Lim" ... Walter Lim Nicole Lim Steven Lim Henry Lim
lambda
Python用于支持将函数赋值给变量的一个操作符 默认是返回的,所以不用再加return关键字,不然会报错
result = lambda x: x * x result(2) # return 4 map()/filter()/reduce()
需要两个参数,第一个是一个处理函数,第二个是一个序列(list,tuple,dict)
map()
将序列中的元素通过处理函数处理后返回一个新的列表
filter()
将序列中的元素通过函数过滤后返回一个新的列表
reduce()
将序列中的元素通过一个二元函数处理返回一个结果
将上面三个函数和lambda结合使用
li = [1, 2, 3, 4, 5] # 序列中的每个元素加1 map(lambda x: x+1, li) # [2,3,4,5,6] # 返回序列中的偶数 filter(lambda x: x % 2 == 0, li) # [2, 4] # 返回所有元素相乘的结果 reduce(lambda x, y: x * y, li) # 1*2*3*4*5 = 120
sorted() 结合lambda对列表进行排序
sorted 用于列表的排序,比列表自带的更加智能 有两个列表,每个列表中都有一个字典([{},{}])要求将两个这样的列表合并后按照时间排序, 两个列表中的时间为了能够通过json输出已经由时间格式转变为字符串格式.字段名为 sort_time 现在将他们按照倒序排列
sorted 的用法
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list terable：是可迭代类型; cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项; key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项; reverse：排序规则. reverse = True 或者 reverse = False，有默认值。 * 返回值：是一个经过排序的可迭代类型，与iterable一样。
sorted()结合lambda对可迭代类型用sort_time排序
sorted(data, key=lambda d: d[‘sort_time‘], reverse=True)
赋值语句就像 A = B = 0，Python支持链式赋值。 （Python不是C）
- lambda是一个用来构造回调的工具
|
1 |
square_root = lambda x: math.sqrt(x) |
下面是lambda的其他的一些有趣的例子：
Python
|
1 2 3 |
sum = lambda x, y: x + y # def sum(x,y): return x + y out = lambda *x: sys.stdout.write(" ".join(map(str,x))) lambda event, name=button8.getLabel(): self.onButton(event, name) |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
def __init__(self, parent): """Constructor""" frame = tk.Frame(parent) frame.pack() btn22 = tk.Button(frame, text="22", command=self.buttonCmd22) btn22.pack(side=tk.LEFT) btn44 = tk.Button(frame, text="44", command=self.buttonCmd44) btn44.pack(side=tk.LEFT) def buttonCmd22(self): self.printNum(22) def buttonCmd44(self): self.printNum(44) |
这样写更容易（且更清楚）
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 |
def __init__(self, parent): """Constructor""" frame = tk.Frame(parent) frame.pack() btn22 = tk.Button(frame, text="22", command=lambda: self.printNum(22)) btn22.pack(side=tk.LEFT) btn44 = tk.Button(frame, text="44", command=lambda: self.printNum(44)) btn44.pack(side=tk.LEFT) |
|
1 2 |
lambda: a if some_condition() else b lambda x: ‘big’ if x > 100 else ‘small’ |
lambda只执行一条语句
必须要有返回值
lambda 参数:执行语句（有返回值）迭代器
7、break和continue语句
8、pass语句
9、迭代器和iter()函数
迭代器是一个概念，只要python中一个对象符合迭代器类型，就可以迭代
迭代器有一个next()方法的对象，而不是通过索引来计数
>>> myTuple = (123, ‘xyz‘, 45.67) >>> i = iter(myTuple) >>> i.next() 123 >>> i.next() ‘xyz‘ >>> i.next() 45.670000000000002 >>> i.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
reversed()内建函数将返回一个反序访问的迭代器
10、列表解析
Python支持的函数式编程特性
列表解析的语法：[expr for iter_var in iterable]， 它迭代iterable对象的所有条目。其中的expr应用于序列的每个成员，最后的结果值是该表达式产生的列表，迭代变量并不需要是表达式的一部分。
还提供了一个扩展版本的语法：[expr for iter_var in iterable if cond_expr]，它在迭代时会过滤/捕获满足条件表达式cond_expr的序列成员。
>>> [x ** 2 for x in range(6)] [0, 1, 4, 9, 16, 25]
>>> seq = [11, 10, 9, 9, 10, 10, 9, 8, 23, 9, 7, 18, 12, 11, 12] >>> filter(lambda x: x % 2, seq) [11, 9, 9, 9, 23, 9, 7, 11] >>> [x for x in seq if x % 2] [11, 9, 9, 9, 23, 9, 7, 11]
矩阵样例：迭代一个有三行五列的矩阵，[(x+1,y+1) for x in range(3) for y in range(5)]。
磁盘文件样例：若有一个数据文件text.txt，需要计算出所有非空白字符的数目，可以把每行分割( split )为单词,，然后计算单词个数：>>> f = open(‘hhga.txt‘, ‘r‘);len([word for line in f for word in line.split()])。快速地计算文件大小：>>>import os;os.stat(‘text.txt‘).st_size。把每个单词的长度加起来：>>>f.seek(0);sum([len(word) for line in f for word in line.split()])。
生成器表达式
生成器表达式是列表解析的一个扩展，只用一行代码就可以创建包含特定内容的列表
[expr for iter_var in iterable if cond_expr]
生成器表达式语法：
(expr for iter_var in iterable if cond_expr)
\ 为python可以接着下一行写的符号
配置templates需要在settings.py里面的
TEMPLATES = [
‘DIRS‘:[os.path.join(BASE_DIR, ‘templates‘)],
]
and-or 技巧
bool ? a : b 表达式熟悉，这个表达式当 bool 为真时计算为 a，其它值则为 b。
>>> a = "first">>> b = "second">>> 1 and a or b‘first‘>>> 0 and a or b
‘second‘
‘first‘>>> 0 and a or b 
‘second‘与C表达式 bool ? a : b类似，但是bool and a or b，当 a 为假时，不会象C表达式 bool ? a : b 一样工作
应该将 and-or 技巧封装成一个函数：
def choose(bool, a, b):return (bool and [a] or [b])[0]
>>> a = "">>> b = "second">>> (1 and [a] or [b])[0]
>>> a = "">>> b = "second">>> 1 and a or b‘second‘
因为 a 是一个空串，空串在一个布尔环境中被Python看成假值，这个表达式将“失败”，且返回 b 的值。如果你不将它想象成象 bool ? a : b 一样的语法，而把它看成纯粹的布尔逻辑，这样的话就会得到正确的理解。 1 是真，a 是假，所以 1 and a 是假。假 or b 是 b。
来源： http://www.kuqin.com/diveinto_python_document/apihelper_andor.html
__getattr__为内置方法，当使用点号获取实例属性时，如果属性不存在就自动调用__getattr__方法__setattr__当设置类实例属性时自动调用，如j.name=5 就会调用__setattr__方法 self.[name]=5因为这个类是从dict继承来的，是dict的超类