#!/usr/bin/python
#coding=UTF-8
counter = 100 # 赋值整型变量 miles = 1000.0 # 浮点型 name = "John" # 字符串
a, b, c = 1, 2, "john"
if 判断条件: 执行语句…… else: 执行语句……
if 判断条件1: 执行语句1…… elif 判断条件2: 执行语句2…… else: 执行语句3……
while 判断条件: 执行语句……
for iterating_var in sequence: statements(s)
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
... print key
>>> for ch in 'ABC':
... print ch
...
A
B
C
del var1
var2 = "Python Runoob" print "var1[0]: ", var1[0] //H print "var2[1:5]: ", var2[1:5] //ytho
Python 列表(List)
list1 = ['physics', 'chemistry', 1997, 2000];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:2] //['chemistry', 1997]
del list1[2];
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。
Python 表达式 | 结果 | 描述 |
---|---|---|
len([1, 2, 3]) | 3 | 长度 |
[1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
3 in [1, 2, 3] | True | 元素是否存在于列表中 |
for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
Python列表函数&方法
Python包含以下函数:
序号 | 函数 |
---|---|
1 | cmp(list1, list2) 比较两个列表的元素 |
2 | len(list) 列表元素个数 |
3 | max(list) 返回列表元素最大值 |
4 | min(list) 返回列表元素最小值 |
5 | list(seq) 将元组转换为列表 |
Python包含以下方法:
序号 | 方法 |
---|---|
1 | list.append(obj) 在列表末尾添加新的对象 |
2 | list.count(obj) 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) 将对象插入列表 |
6 | list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
8 | list.reverse() 反向列表中元素 |
9 | list.sort([func]) 对原列表进行排序 |
Python的元组与列表类似,不同之处在于元组的元素不能修改。
tup1 = ('physics', 'chemistry', 1997, 2000);
tup1 = (50,); //元组中只包含一个元素时,需要在元素后面添加逗号
print "tup2[1:5]: ", tup2[1:5]
del tup1;
元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
Python 表达式 | 结果 | 描述 |
---|---|---|
len((1, 2, 3)) | 3 | 计算元素个数 |
(1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 |
3 in (1, 2, 3) | True | 元素是否存在 |
for x in (1, 2, 3): print x, | 1 2 3 | 迭代 |
元组索引,截取
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:
元组:
L = ('spam', 'Spam', 'SPAM!')
Python 表达式 | 结果 | 描述 |
---|---|---|
L[2] | 'SPAM!' | 读取第三个元素 |
L[-2] | 'Spam' | 反向读取;读取倒数第二个元素 |
L[1:] | ('Spam', 'SPAM!') | 截取元素 |
元组内置函数
Python元组包含了以下内置函数
序号 | 方法及描述 |
---|---|
1 | cmp(tuple1, tuple2) 比较两个元组元素。 |
2 | len(tuple) 计算元组元素个数。 |
3 | max(tuple) 返回元组中元素最大值。 |
4 | min(tuple) 返回元组中元素最小值。 |
5 | tuple(seq) 将列表转换为元组。 |
Python 字典(Dictionary)
d = {key1 : value1, key2 : value2 }
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
print "dict['Alice']: ", dict['Alice’];
dict['Alice'] = 8 # update existing entry
del dict['Alice']; # 删除键是'Name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
字典内置函数&方法
Python字典包含了以下内置函数:
序号 | 函数及描述 |
---|---|
1 | cmp(dict1, dict2) 比较两个字典元素。 |
2 | len(dict) 计算字典元素个数,即键的总数。 |
3 | str(dict) 输出字典可打印的字符串表示。 |
4 | type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法:
序号 | 函数及描述 |
---|---|
1 | radiansdict.clear() 删除字典内所有元素 |
2 | radiansdict.copy() 返回一个字典的浅复制 |
3 | radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 |
4 | radiansdict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值 |
5 | radiansdict.has_key(key) 如果键在字典dict里返回true,否则返回false |
6 | radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组 |
7 | radiansdict.keys() 以列表返回一个字典所有的键 |
8 | radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
9 | radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 |
10 | radiansdict.values() 以列表返回字典中的所有值 |
import time; # 引入time模块
ticks = time.time() print "当前时间戳为:", ticks
localtime = time.localtime(time.time()) print "本地时间为 :", localtime
# 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
def functionname( parameters ): "函数_文档字符串" function_suite return [expression]
在Python中,一个.py文件就称之为一个模块(Module)。
import sys
导入sys
模块后,我们就有了变量sys
指向该模块,利用sys
这个变量,就可以访问sys
模块的所有功能。
sys
模块有一个argv
变量,用list存储了命令行的所有参数。argv
至少有一个元素,因为第一个参数永远是该.py文件的名称,例如
$ python hello.py Michael
Hello, Michael!
安装第三方模块
easy_install
和
pip
。目前官方推荐使用
pip
。
pip install PIL
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))
注意到__init__
方法的第一个参数永远是self
,表示创建的实例本身,因此,在__init__
方法内部,就可以把各种属性绑定到self
,因为self
就指向创建的实例本身。
bart = Student('Bart Simpson', 59)
bart.print_score()
继承与多态
class Animal(object):
def run(self):
print('Animal is running...')
当我们需要编写Dog
类时,就可以直接从Animal
类继承:
class Dog(Animal):
pass
使用type()
首先,我们来判断对象类型,使用type()
函数:
>>> type(123)==type(456)
True
map()
函数接收两个参数,一个是函数,一个是序列,map
将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回。>>> def f(x):
... return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]
reduce把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
如果要把序列[1, 3, 5, 7, 9]
变换成整数13579,reduce就可以派上用场:
>>> def fn(x, y):
... return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本,默认的标准输入是键盘。如下:
- raw_input
- input #可以接收一个Python表达式作为输入
try:
f = open('/path/to/file', 'r’) #打开一个文件对象
print f.read()
finally:
if f:
f.close()
但是每次都这么写实在太繁琐,所以,Python引入了with
语句来自动帮我们调用close()
方法:
with open('/path/to/file', 'r') as f:
print f.read()
try ... finally
是一样的,但是代码更佳简洁,并且不必调用
f.close()
方法。
调用read()
会一次性读取文件的全部内容,如果文件有10G,内存就爆了,所以,要保险起见,可以反复调用read(size)
方法,每次最多读取size个字节的内容。另外,调用readline()
可以每次读取一行内容,调用readlines()
一次读取所有内容并按行返回list
。因此,要根据需要决定怎么调用。
如果文件很小,read()
一次性读取最方便;如果不能确定文件大小,反复调用read(size)
比较保险;如果是配置文件,调用readlines()
最方便:
for line in f.readlines():
print(line.strip()) # 把末尾的'\n'删掉
f.write('Hello, world!')
操作文件和目录
Python的os模块提供了帮你执行文件处理操作(删除,重命名,创建目录删除目录等)的方法。
操作文件和目录的函数一部分放在os
模块中,一部分放在os.path
模块中,这一点要注意一下。查看、创建和删除目录可以这么调用:
# 查看当前目录的绝对路径:
>>> os.path.abspath('.')
'/Users/michael'
# 在某个目录下创建一个新目录,
# 首先把新目录的完整路径表示出来:
>>> os.path.join('/Users/michael', 'testdir')
'/Users/michael/testdir'
# 然后创建一个目录:
>>> os.mkdir('/Users/michael/testdir')
# 删掉一个目录:
>>> os.rmdir('/Users/michael/testdir')
注:
把两个路径合成一个时,不要直接拼字符串,而要通过
os.path.join()
函数,这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下,
os.path.join()
返回这样的字符串:
同样的道理,要拆分路径时,也不要直接去拆字符串,而要通过
os.path.split()
函数,这样可以把一个路径拆分为两部分,后一部分总是最后级别的目录或文件名:
>>> os.path.split('/Users/michael/testdir/file.txt')
('/Users/michael/testdir', 'file.txt')
os.path.splitext()
可以直接让你得到文件扩展名,很多时候非常方便:
>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')
#!/usr/bin/python #coding=utf-8 import os for root, dirs, files in os.walk(".", topdown=False): for name in files: print(os.path.join(root, name)) for name in dirs: print(os.path.join(root, name))
多进程
Unix/Linux操作系统提供了一个fork()
系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()
调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。getppid()
就可以拿到父进程的ID,
import os
print 'Process (%s) start...' % os.getpid()
pid = os.fork()
if pid==0:
print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())
else:
print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)
fork
调用。multiprocessing
模块就是跨平台版本的多进程模块。
multiprocessing
模块提供了一个Process
类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结束:
from multiprocessing import Process
import os
# 子进程要执行的代码
def run_proc(name):
print 'Run child process %s (%s)...' % (name, os.getpid())
if __name__=='__main__':
print 'Parent process %s.' % os.getpid()
p = Process(target=run_proc, args=('test',))
print 'Process will start.'
p.start()
p.join()
print 'Process end.'
创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process
实例,用start()
方法启动,这样创建进程比fork()
还要简单。join()
方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。
多线程
thread
和
threading
,
thread
是低级模块,
threading
是高级模块,对
thread
进行了封装。绝大多数情况下,我们只需要使用
threading
这个高级模块。
import time, threading
# 新线程执行的代码:
def loop():
print 'thread %s is running...' % threading.current_thread().name
n = 0
while n < 5:
n = n + 1
print 'thread %s >>> %s' % (threading.current_thread().name, n)
time.sleep(1)
print 'thread %s ended.' % threading.current_thread().name
print 'thread %s is running...' % threading.current_thread().name
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print 'thread %s ended.' % threading.current_thread().name
创建一个锁就是通过
threading.Lock()
来实现:
balance = 0
lock = threading.Lock()
def run_thread(n):
for i in range(100000):
# 先要获取锁:
lock.acquire()
try:
# 放心地改吧:
change_it(n)
finally:
# 改完了一定要释放锁:
lock.release()
当多个线程同时执行lock.acquire()
时,只有一个线程能成功地获取锁,然后继续执行代码,其他线程就继续等待直到获得锁为止。
获得锁的线程用完后一定要释放锁,否则那些苦苦等待锁的线程将永远等待下去,成为死线程。所以我们用try...finally
来确保锁一定会被释放。
正则表达式
\d
可以匹配一个数字
\w
可以匹配一个字母或数字,
.
可以匹配任意字符。
*
表示任意个字符(包括0个)
+
表示至少一个字符
?
表示0个或1个字符
{n}
表示n个字符,用
{n,m}
表示n-m个字符:
\s
可以匹配一个空格
[]
表示范围
A|B
可以匹配A或B,所以
(P|p)ython
可以匹配
'Python'
或者
’python'
。
^
表示行的开头,^\d
表示必须以数字开头。
$
表示行的结束,\d$
表示必须以数字结束。
r
前缀,就不用考虑转义的问题了:
s = r'ABC\-001' # Python的字符串
# 对应的正则表达式字符串不变:
match()
方法判断是否匹配,如果匹配成功,返回一个
Match
对象,否则返回
None
if re.match(r'正则表达式', test):
print 'ok'
else:
print ‘failed'
切分字符串
请看正常的切分代码:
>>> 'a b c'.split(' ')
['a', 'b', '', '', 'c']
无法识别连续的空格,用正则表达式试试
>>> re.split(r'\s+', 'a b c')
['a', 'b', ‘c']
分组
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object at 0x1026fb3e8>
>>> m.group(0)
'010-12345'
>>> m.group(1)
'010'
>>> m.group(2)
‘12345'
group(0)
永远是原始字符串,group(1)
、group(2)
……表示第1、2、……个子串。