查询对象所有的方法使用python的人都知道range()函数很方便，今天再用到他的时候发现了很多以前看到过但是忘记的细节。这里记录一下range(),复习下list的slide，最后分析一个好玩儿的冒泡程序。
这里记录一下：
>>> range(1,5) #代表从1到5(不包含5)[1, 2, 3, 4]>>> range(1,5,2) #代表从1到5，间隔2(不包含5)[1, 3]>>> range(5) #代表从0到5(不包含5)[0, 1, 2, 3, 4] |
再看看list的操作:
array = [1, 2, 5, 3, 6, 8, 4]#其实这里的顺序标识是[1, 2, 5, 3, 6, 8, 4](0，1，2，3，4，5，6)(-7,-6,-5,-4,-3,-2,-1)>>> array[0:] #列出0以后的[1, 2, 5, 3, 6, 8, 4]>>> array[1:] #列出1以后的[2, 5, 3, 6, 8, 4]>>> array[:-1] #列出-1之前的[1, 2, 5, 3, 6, 8]>>> array[3:-3] #列出3到-3之间的[3] |
那么两个[::]会是什么那？
>>> array[::2][1, 5, 6, 4]>>> array[2::][5, 3, 6, 8, 4]>>> array[::3][1, 3, 4]>>> array[::4][1, 6] 如果想让他们颠倒形成reverse函数的效果>>> array[::-1][4, 8, 6, 3, 5, 2, 1]>>> array[::-2][4, 6, 5, 1] |
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]
如果需要一个排序好的副本，同时保持原有列表不变，怎么实现呢
二、自定义比较函数
可以定义自己的比较函数，然后通过参数传递给sort方法：
2、reverse实现降序排序，需要提供一个布尔值：
aList = [123, 'xyz', 'zara', 'abc', 'xyz']; aList.reverse();print "List : ", aList;
1 >>> l = [1,1,2,3,4,5,4] 2 >>> list(set(l)) 3 [1, 2, 3, 4, 5]
使用deepcopy方法,对象中的属性也被复制
new_list = copy.copy(existing_list)
有些时候,你希望对象中的属性也被复制,可以使用deepcopy
2.import copy
new_list_of_dicts = copy.deepcopy(existing_list_of_dicts)
>>> for somekey in d:
... d1[somekey] = d[somekey]
4.如果需要一个排序好的副本，同时保持原有列表不变，怎么实现呢
re.sub 函数进行以正则表达式为基础的替换工作
- >>> 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'
术语叫贪婪匹配( <.*> ) 非贪婪匹配( <.*?> )
例如: <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>
<.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回none，否则返回matchobject；（re.search相当于perl中的默认行为）
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
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)#该语句是错误的。下限必须小于上限。
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"))
使用os包的remove方法可以删除文件
import os
filename = 'f:/123.txt'
if os.path.exist(filename):
os.remove(filename)
copyfile(src, dst) |
从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为
2. append()
3. extend()方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
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
（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 = ['Walter', "Nicole", 'Steven', 'Henry'] >>> for eachName in nameList: ... print eachName, "Lim" ... Walter Lim Nicole Lim Steven Lim Henry Lim
lambda
Python用于支持将函数赋值给变量的一个操作符 默认是返回的,所以不用再加return关键字,不然会报错
需要两个参数,第一个是一个处理函数,第二个是一个序列(list,tuple,dict)
map()
将序列中的元素通过处理函数处理后返回一个新的列表
filter()
将序列中的元素通过函数过滤后返回一个新的列表
reduce()
将序列中的元素通过一个二元函数处理返回一个结果
将上面三个函数和lambda结合使用
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排序
- lambda是一个用来构造回调的工具
1 | square_root = lambda x: math.sqrt(x) |
下面是lambda的其他的一些有趣的例子：
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) |
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) |
这样写更容易（且更清楚）
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
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()])。
生成器表达式是列表解析的一个扩展，只用一行代码就可以创建包含特定内容的列表
生成器表达式语法：
为python可以接着下一行写的符号
配置templates需要在settings.py里面的
TEMPLATES = [
'DIRS':[os.path.join(BASE_DIR, 'templates')],
]
and-or 技巧
应该将 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。
__getattr__为内置方法，当使用点号获取实例属性时，如果属性不存在就自动调用__getattr__方法
__setattr__当设置类实例属性时自动调用，如j.name=5 就会调用__setattr__方法 self.[name]=5
因为这个类是从dict继承来的，是dict的超类