python基本操作

os.system("mkdir Test.txt"),

python setup.py install

dir()

以列表形式返回

查询对象所有的方法

range()的用法

使用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]

>>> 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的操作:

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]

来源： 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方法介绍

re.sub 函数进行以正则表达式为基础的替换工作

[python] view plaincopy
 print?
>>> 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>

重复匹配一个正则表达式时候，例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值

例如：

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 os
filename = 'f:/123.txt'
if os.path.exist(filename):
  os.remove(filename)

Python如何copy一个文件？

copyfile(src, dst)

从源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

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

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)

来源： http://python.jobbole.com/80954/

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'

与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的超类

来自为知笔记(Wiz)