python基本操作
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160922590-77037234.jpg)
使用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]
如果需要一个排序好的副本,同时保持原有列表不变,怎么实现呢
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160923824-791186759.png)
二、自定义比较函数
可以定义自己的比较函数,然后通过参数传递给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"))
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160925434-521952539.png)
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160925902-912307158.png)
使用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
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160926449-1314685851.png)
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。
![](https://images2015.cnblogs.com/blog/801928/201608/801928-20160808160930324-1577394342.png)
__getattr__为内置方法,当使用点号获取实例属性时,如果属性不存在就自动调用__getattr__方法
__setattr__当设置类实例属性时自动调用,如j.name=5 就会调用__setattr__方法 self.[name]=5
因为这个类是从dict继承来的,是dict的超类