python入门

1，输出 print 或 print() ，数字直接即可输出，字符串用" "或' '  。输入 input()

2，if/while语句（注意缩进，tab与空格键混用会出错）

if/while 条件:

    可执行的语句

3，引入模块的方法： from 模块名 import 方法名(写在最前面）

　  引入随机数： from random import randint

例1：猜数字游戏

num = 10                                   ----->   num=randint(min,max)
print 'Guess what I think?'
flag = False

while flag == False:
　　answer = input()

　　if answer < num:
　　　　print 'too small'
　　if answer > num:
　　　　print 'too big'
　　if answer == num:
　　　　print 'Bingo!'
　　　　flag=True

4，变量的名称：第一个字符必须是字母或者下划线；剩下的部分可以是字母，下划线，数字（0-9）；大小写敏感 （例：_my_name ; name_23 )

5，bool的使用 （False or True） 可用 not  （not 1即false）

6，for循环语句： for...in...   for i in range(a,b)   即输出 a <= i < b  ，

7，字符串： 输出内容有双引号则用单引号表示 即 'You are a "good" boy!'  反之亦然 。 还可以用转译字符 \ （不受引号限制）， \" 表示双引号 ， \’ 表示单引号 （\ 还可用于在代码      中换行，\n 表示字符串中的换行）。 在三个引号中， 你可以方便的使用单引号和双引号，并且可以直接换行。

例2：

print 'I\'m a \"good\" teacher.'

s2="this is the\
same line."                       -----> this is thesame line.
print s2

s3='''
"What's your name?"I asked.
"I'm Gina."
'''
print s3

 8，字符串格式化：若想将多个字符串连起来输出，相加即可（print str1+str2）；还可以把字符变量与一个字符串相加（print str1 + 'and' + str2）；  

   　字符串与数字不能相加输出， 方法一：用str()把数字转化成字符串，print 'My age is ' + str(num)；方法二：用%对字符串进行格式化，print 'My age is %d' % num （%d会          被%后面的值替换）；

      可以用%s来替换一段字符串 name='Gino'   print '%s is my boyfriend.'%name  或者  print '%s is my boyfriend.' %'Gino' ；

      若既要输出字符又要输出数字  print "%s's score is %d"%(name, score)

 

9 , 循环的嵌套：print   起到换行的作用；在print语句后面加上逗号，可让输出在同一行。

例3：

for i in range(0,5):
　　for j in range(0,i+1):
　　　　print '*',
　　print

10 , 类型转换：字符串，整数，浮点数，bool类型是python里几种最基本的数据类型，在python里定义一个变量时不需要给它限定类型，变量会根据赋给他的值自动决定他的类型，       改变值即改变了它的类型。但当对特定的变量进行操作时，若与数据类型不匹配则会报错，例：print 'Hello'+1 (字符串与整数不能相加）     print 'hello%d' % '123'（%d需要的是         整数，'123'是字符串） 这种情况下，python提供了一些方法对数值进行类型转换：

　　int(x)  #把x转化成整数                      float(x) #把x转化成浮点数                              str(x)  #把x转化为字符串                       bool(x) #把x转换成bool值  

　　改正：print 'hello'+str(1)    

　　　　    print 'hello%d'%int('123')

　　但并不是所有的值都能做类型转换，比如 int('abc') 同样会报错，python无法将它转换成一个整数。

11，bool类型的转化：在python中以下数值会被认为是False：为0的数字（包括0.0），无空格的空字符串（''， ""），表示空值的None，空集合（包括()，[]，{}）,其它值都认为　　        是True。 　　bool(0) ； bool('') ；bool(None) ； bool() ；

12，函数： 自定义函数用 def + 函数名(参数1,参数2):

def sayhello(str,num):                          #定义函数sayhello

　　print 'Hello '+str                             #函数体

       print num

sayhello('World',2)                                  #调用函数   

sayhello('World',2)                                  #可重复调用

函数的默认参数：当只有少数情况才会去改参数的时候，我们可以给这个函数一个默认参数。

def hello(name='world'):
　　print 'hello '+name
hello()                                           ==>hello world

hello('python')                             ==>hello python

注意，当函数有多个参数时，如果想给部分参数提供默认参数，那么这些默认参数只能在参数的末尾。def func(a,b=5)是正确的，def func(a=5,b)会报错。

 

函数的参数传递：def func(arg1,arg2)  

（1）func1(3,7)：我们把函数定义时的参数名（arg1,arg2）称为形参，调用时提供的参数（3,7）称为实参。这种是根据调用时提供参数的位置进行匹配，少参数或多参数都将引起错误。在调用时也可以根据形参的名称来指定实参。如 func(arg2=3,arg1=7)，但同样必须提供所有参数。

（2）func2(a=1,b=2,c=3)：这种方式可以理解为，在一般的函数定义的基础上，增加了参数的默认值。这样定义的函数可以在你没有提供足够数量参数的时候，会用默认值作为参数的值。提供的参数会按照顺序先匹配前面位置的参数，后面未匹配到的参数则使用默认值。也可指定其中的部分参数。没有指定参数名的参数必须在所有指定参数名的参数前面，且参数不能重复。

def func(arg1=1,arg2=2,arg3=3):
　　print arg1,arg2,arg3

func(3,6,9)                                 ==>3 6 9
func(5)                                       ==>5 2 3
func(11,arg3=8)                        ==>11 2 8

（3）CalcSum(*args) 元组参数：在变量前面加个星号前缀*，调用时的参数会储存在一个tuple（元组）对象中，赋值给形参。在定义时无需指明参数个数，即可处理。需要注意的是，tuple是有序的。

def CalcSum(*args):
　　sum=0
　　for i in args:
　　　　sum+=i
　　print sum

CalcSum(1,2,3)                      ==>6
CalcSum()                              ==>0

（4）func(**kargs) 字典参数：是最灵活的参数传递方式，把参数以键值对字典的形式传入。因为字典是无序的，所以在输出的时候，并不一定按照提供参数的顺序输出。同样在调用时，参数的顺序无所谓，只要对应合适的参数名即可。即不受参数数量，位置的限制。

def printAll(**kargs):
　　for k in kargs:
　　　　print k,':',kargs[k]

printAll(a=1,b=2,c=3)
printAll(x=10,y=20)

可以混合使用：

def f(x,y=5,*a,**b):

　　print x,y,a,b

f(1,2,3,4,5,a=1,b=2)               ==>1 2 (3, 4, 5) {'a': 1, 'b': 2} 

参数的传递规则：

①按顺序把无指定参数的实参赋值给形参；

②把指定参数名称（arg=v）的实参赋值给对应的形参；

③将多余的无指定参数的实参打包成一个tuple传递给元组参数（*args）；

④将多余的指定参数名的实参打包成一个dict传递给字典参数（**args）。

13，if ， elif，else的用法：elif 即else if

14，list：中文为列表，是用来处理一组有序项目的数据结构。range(1,10) 即为一个list：print range(1,10) 得到的是[1，2，3，4，5，6，7，8，9]  ；也可以自己定义一个列表。

　　格式为中括号包围，逗号隔开，元素可为不同类型的混合。

　　I=range(1,10)

　　for i in l :                                     #for循环做的事情就是遍历一个列表中的每一项，每次循环都把当前项赋值给变量（i），直到列表结束

　　　　print i,

　　访问：除了用for...in访问list中的元素，还能用 l[0] 访问list中的第一个元素 ，以此类推；

　　修改：直接赋值 l[0]=123

　　添加：调用 l.append(1024) 即可在list末尾加上1024

　　删除：del l[0] 

例4：点球小游戏（罚球）

from random import choice                        #choice的作用是从list中随机挑选一个元素
print 'Choose one side to shoot'
print 'Left Center Right'
you=input()
print 'You kicked '+you
direction=[ 'Left' , 'Center' , 'Right' ] 
com=choice(direction)
print 'Computer saved '+com
if you!=com:
　　print 'Goal'
else:
　　print 'Oops...'

 

list的两类操作：索引（index）和切片（slice）

用 [ ] 加序号的方法是指定位置的索引，list还可以处理负数的索引，如 list[-1] 表示list中的最后一个元素，list[-3] 表示倒数第三个元素 。

切片操作符是在[ ]内提供一对可选数字，用：分隔。冒号前的数字表示切片的开始位置，后面的数字表示切片到哪里结束。同样，计数从0开始。开始位置包括在切片中，结束位置不包括；如果不指定第一个数，切片就从第一个数开始；不指定第二个数，就一直到最后一个元素结束。同索引一样，切片中的数字也可以用负数。

l=['everyday'，0.11，True，'apple']  

print l[1:3]                          ==>  [0.11, True]

print l                                  ==>  ['everyday'，0.11，True，'apple']

 

列表解析：通过一个已有列表生成一个新的列表。

a=[0,1,3,5,8,13,22]
b_1=[]

for i in a:                                                 #常规方法取出偶数
　　if i%2==0:
　　　　b_1.append(i)

b_3=[i for i in a]                                     #会把a中的每一个元素都取出来，构成一个新的列表
b_2=[i/2 for i in a if i%2==0]                 #如果需要对其中的元素进行筛选，就在后面加上判断条件if。还可以对取出的元素i进行操作。

print b_1                                                ==>[0, 8, 22]
print b_3                                                ==>[0, 1, 3, 5, 8, 13, 22]
print b_2                                                ==>[0, 4, 11]

15，字符串的分割：sentence.split()

　　split() 会把字符串按照其中的空白字符（空格，换行符\n，制表符\t）进行分割 ，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个list 。

　　split 还可以制定分割的符号。split('.') 分隔符为 . （每个'.'都会被作为分割符，即使他的后面没有其他字符，也会有一个空串被分割出来）

　　sen="OK.I am a teacher."

　　print sen.split('.')               ==>['OK', 'I am a teacher', '']

　　print sen.split()                  ==>['OK.I', 'am', 'a', 'teacher.']

 16，字符串的连接：首先需要有一个字符串（可为空串）作为list中所有元素的连接符，然后再调用这个连接符的join方法，join的参数是被连接的list 。

s=';'
list=['apple','pear','orange']
print s.join(list)                 ==>apple;pear;orange

17，字符串与list相似的操作：

　　（1）遍历：通过 for...in 可以遍历字符串中的每一个字符。

　　（2）索引访问：通过 [] 加索引的方式，访问字符串中某个字符。不同的是，字符串不能通过索引访问去更改字符。

　　（3）切片：通过两个参数，截取一段子串。

　　（4）连接字符：join方法也可以对字符串使用，作用就是用连接符把字符串中每个字符重新连接成一个新字符串。

 

s=','
string='hello'
print s.join(string)           ==>h,e,l,l,o

18，读文件：打开一个文件的命令 file('文件名')  这里的文件名可以用文件的完整路径，也可以是相对路径。将要打开文件与代码放在同一文件夹下，只用写它的文件名（data.txt）        就够了。

f=file('data.txt')             #用变量f保存这个文件
data=f.read()                #通过read()函数把文件内所有内容读进一个字符串中（readline()读取一行内容；readlines()把内容按行读取至一个list中）
print data
f.close()                        #释放资源

19，写文件：python默认的是只读不写，若想写入，在打开文件时需要指定打开模式为写入，即'w'，原来文件的内容会被新写入的内容覆盖掉，如果文件不存在，会自动创建文件；

　　不加参数时，file为你默认为'r'，即只读模式，此时文件必须存在，否则会引发异常；还有一种模式 'a' 即appending，也是一种写入模式，但写入内容不会覆盖之前内容，而是添        加到文件中。

out=file('data.txt','w')
string='I will be in a file.\nSo cool!'
out.write(string)
out.close()

 

例：从一个文件夹读取内容，保存至另一个文件夹

f=file('data.txt')
data=f.read()
g=file('copy.txt','w')
g.write(data)
f.close()
g.close()

 

pickle模块：

import pickle
test_data=['Save me!',123.456,True]

f=file('test_data.txt','w')
pickle.dump(test_data,f)               #存储过程
f.close()

f=file('test_data.txt')
text_data=pickle.load(f)                #读取过程  
f.close()
print text_data

20，break，continue： 同在c语言里使用方法一样。前者彻底跳出循环，后者略过本次循环剩下的内容，进行下一次循环。

21，异常处理：try...except   把可能引发异常的语句放在try-块中，把处理异常的语句放在except-块中。当程序在try内部打开文件引发异常时，会跳过try中剩下的代码，直接跳转到           except中的语句处理异常。

try:
　　f=file('non-exist.txt')
　　print 'File opened!'
　　f.close()
except:
　　print 'File not exists!'
print 'Done!'

 

22，字典：这种数据结构有点像我们平时的通讯录，有一个名字和这个名字对应的信息。在字典中，名字叫做“键“，对应的内容叫做“值”。字典就是一个键/值对的集合。

　　基本格式是（key是键，value是值）：d={ key1:value1,key2:value2 }

键/值对用冒号分割，每个对之间用逗号分割，整个字典包括在花括号中。（注意：键必须是唯一的；键只能是简单的对象，比如字符串，整数，浮点数，bool值，list就不能做为键，但可以作为值）  简单的字典例子：score={'小红':98，'小帆':95，'小洋':90}   

访问：python字典中的键/值对没有顺序，无法用索引来访问字典中的某一项，而是需要用键来访问。print score['小红'] （如果键是字符串，通过键访问时要记得加引号）

遍历：通过 for...in 遍历。

for name in score:                         #遍历的变量中储存的是字典中的键
　　print score[name]                  #print出来的是值  

修改：要改变某一项的值，直接赋值即可。score['小洋']=100

增加：给一个新键赋值：score['小雨']=110

删除：del score['小雨']（这个键必须已经存在于字典中）

新建字典只需要 d={} 即可

字典类的get方法是按照给定key寻找对应项，如果不存在这样的key，就返回空值None。 score=scores.get(name)

23，模块：python自带了功能丰富的标准库，还有数量庞大的各种第三方库。使用这些功能的基本方法就是使用模块。之前用到过的模块：import random

import语句告诉python我们要用random模块中的内容。然后便可以使用random中的方法，比如 random.randint(1,5)         random.choice([1,3,5])  

注意函数前面要加上 random.  这样python才知道你是要调用random中的方法。想知道random中有哪些函数和变量，可以用 dir(random)  

如果只是用到random中的某一个函数或变量，也可以通过 from... import... 指明。例如 from math import pi ，为了便于理解和避免冲突，还可以给引入的方法换个名字：

from math import pi as math_pi

print math_pi

 24，urllib2 模块：用来发送网络请求。

json ：用来解析获得的数据。json是一种文本格式，有点像xml的意思，本质上是一个字符串。这个字符串用来表示一组数据。它数据的组织形式又很像python中的字典，是按照{"名称":"值","名称":"值"}的形式来的。有了这种约定好的形式之后，把数据转换成字符串传递就比较方便了.

　　自定义模块 from city import city ，前一个city是模块名，也就是py文件的名称，后一个city是模块中的自变量的名称。

25 ，面向对象：按照功能需求顺序所设计的程序，被称为“面向过程”的编程（以上所写小程序）。还有一种程序设计的方法，是把数据和对数据的操作用一种叫“对象”的东西包裹起来，这种被称为“面向对象”的编程。

面向对象编程最主要的两个概念是类（class）和对象（object）。类是一种抽象的类型，而对象是这种类型的实例。一个类可以有属于他自己的函数，这种函数被称为类的“方法”。一个类/对象可以有属于他的变量，这种变量被称作“域”。域根据所属不同，又分别被称作“类变量”和“实例变量”。

s='how are you'   #s被赋值后就是一个字符串类型的对象                  l=s.split()   #split是字符串的方法，这个方法返回一个list类型的对象                                                            通过dir()方法可以查看一个类/变量的所有属性。

创建一个类：关键字class加上类名

class Myclass:

pass                   #pass语句代表一个空的代码块 

创建一个类的实例：类名加圆括号()（即被称作对象的东西）

mc=Myclass()          #变量mc就是Myclass类的对象

print mc          

 ==>  <__main__.Myclass instance at 0x0000000002F18E88>  

#mc是_main_模块中Myclass类的一个实例（instance），后面的一串是十六进制的数字是这个对象的内存地址

给这个类加上一些域：

class Myclass:

name='Sam'                                    #name为Myclass类的类变量

　　def sayHi(self):                               #类方法sayHi ，第一个参数必须为self
　　print 'Hello %s'%self.name

　　mc=Myclass() 
　　print mc.name                                       #调用类变量的方法是“对象.变量名”
　　mc.name='Gino'                                    #可以改变类变量的值
　　mc.sayHi()                                             #调用类方法“对象.方法名()” ，不需要额外提供self这个参数的值，self在类方法中的值就是你调用的

                                                                        这个对象本身

有了面向对象，可以把相关的数据和方法封装在一起，并且可以把不同类中的相同功能整合起来。

 例：假使有两辆汽车，时速60km/h和150km/h，AB两地的距离100km，BC两地的距离为200km，算出这两辆车分别从A到B的距离以及B到C所花费的时间。

　　class Car:

　　　　speed=0

　　　　def drive(self,distance):
　　　　　　time=distance/self.speed
　　　　　　print time

　　car1=Car()
　　car1.speed=60.0
　　car1.drive(100.0)
　　car1.drive(200.0)

　　car2=Car()
　　car2.speed=150.0
　　car2.drive(100.0)
　　car2.drive(200.0)

假使我们又有一辆自行车，自行车和汽车有着相同的属性：速度（speed）。还有一个相同的方法（drive），来输出行驶/骑行一段距离所花费的时间。但这次给汽车新增一个属 性：每公里油耗（fuel）。在汽车行驶一段距离的方法中，还要输出所需油耗。

面向过程的方法，你可能要写两个函数，然后传参数进去。有了面向对象，我们可以把相关的数据和方法封装在一起，并且可以把不同类的相同功能整合起来。这就需要用到面 向对象中另外一个重要概念——继承。

　　class Vehicle:                                                                          #创建一个叫Vehicle的类，表示某种车，它包含了两类车共有的东西：速度

　　　　def __init__(self,speed):　　                                            和方法，然后让Car类和Bike类都继承作为它的子类（导出类）。

　　　　　　self.speed=speed                                                       Vehicle类被称为基本类或超类。

　　　　def drive(self,distance):
　　　　　　print 'need %f hour(s)'%(distance/self.speed)

　　class Bike(Vehicle):                                                      #类名后面的括号里表示这个类继承于哪个类，Vehicle里的属性和方法，Bike都会有。
　　　　pass

　　class Car(Vehicle):                                                        #在每个子类中，可以分别添加各自独有的属性。
　　　　def __init__(self,speed,fuel):                                #若在子类里重新定义超类里的函数，则会覆盖掉它继承自Vehicle的同名函数。
　　　　　　Vehicle.__init__(self,speed)                              但我们依然可以通过"Vehicle.函数名"的方法来调用它的超类方法。因为是通过
　　　　　　self.fuel=fuel                                                      类名调用方法，而不是像之前一样通过对象调用，所以这里必须提供self 的参数值。

　　　　def drive(self,distance):
　　　　　　Vehicle.drive(self,distance)
　　　　　　　print 'need %f fuels'%(distance*self.fuel)

　　b=Bike(15.0)                                                                   #__init__函数会在类被创建的时候自动调用，用来初始化类。它的参数要在创建类
　　c=Car(80.0,0.012)                                                             的时候提供。于是我们通过提供一个数值来初始化speed的值。
　　b.drive(100.0) 
　　c.drive(100.0)

26，and-or 技巧：这个bool and a or b 语句很像c语言中 bool?a:b 很像，当bool条件为真时，结果是a；当bool条件为假时，结果是b。

a='heaven'
b='hell'
print True and a or b                 ==>heaven
print False and a or b               ==>hell

和c语言中？：表达式不同，当a本身是个假值（如0，""）时，输出则不尽人意。所以and-or的真正技巧在于确保a的值不为假。最常用的方法是使a变成 [a] 、b变成 [b] ，然后使用返回值列表的第一个元素。由于[a] 是一个非空列表，所以它绝不会为假。即使a是0或''或其他假值，列表[a] 也为真，因为它是有一个元素的。

a=''
b='Hell'
c=(True and [a] or [b])[0]
print c

27，元组（tuple）：是一种序列，和list相似，有同样的索引、切片、遍历等操作，只是元组中的元素在创建之后就不能被修改。

如 postion=(1,2)   colors=('red','white','black')    在print 语句中使用是元组最常见的用处：print '%s are %d years old.'%('Gino',20)

元组作为函数返回值的例子：

def get_pos(n):
　　return (n/2,n*2)

得到这个函数的返回值有两种形式，一种是根据返回值元组中元素的个数提供变量：

x,y=get_pos(2)
print x
print y

另一种是用一个变量记录返回的元组：

pos=get_pos(2)
print pos[1]

28，数学运算：模块名math。 math包里有两个常量：math.pi （π=3.141592...）   math.e（自然常数e=2.718281...）

数值运算：math.ceil(x) ：对x向上取整，比如x=1.2，返回2.0。  math.floor(x) ：对x向下取整。  math,pow(x,y)：指数运算，得到x的y次方。  math.sqrt(x)：平方根。

math.fabs(x)：绝对值。  

三角函数：math.sin(x) 、math.cos(x) 、math.tan(x)、math.asin(x)、math.acos(x)、math.atan(x)   注意这里的x是以弧度为单位，所以计算角度的话，需要先换算。

弧度换角度： math.degrees(x) ；角度转弧度：math.radians(x)  ……

29，真值表：NOT：not False <=> True ；not True <=> False （not的结果与原值相反）

OR：True or False <=>True； True or True <=> True ；False or False <=> False（只要有一个值为True ，or 的结果就是 True）

AND：只要有一个值为False，and的结果就是False

NOT OR： not (True or False ) <=> False 

NOT AND：not ( True and False ) <=> True

!=：1 != 0 <=> True

==：1==0 <=> False

30，正则表达式：（1）是记录文本规则的代码。python中的正则表达式库，所做的事情是利用正则表达式来搜索文本。

最简单的正则表达式，它没有特殊的符号，只有基本的字母或数字，它满足的匹配规则就是完全匹配。

例：有个正则表达式是 'na'，那么它就可以匹配出文本中所有含有 na 的字符。因为是完全匹配，所以每个结果都是 na ，这两个 na 分别来自 name 和 Gina （区分大小写）

import re
text='Hi,my name is Gina.My boyfriend is Gino.'
m=re.findall(r'na',text)
if m:
　　print m                             ==> ['na', 'na']
else:
　　print 'no match'     

如果只想找到 'Hi' 这个单词，而不是把包含它的单词也算在内，那就可以使用  "\bHi\b" 这个正则表达式。"\b" 在正则表达式中表示单词的开头或结尾，空格，标点，换行都算是单词的分割。而 "\b" 自身又不会匹配任何字符，它代表的只是一个位置。所以单词前后的空格标点之类不会出现在结果里。在前面的例子中 ，"\bna" 可以匹配出来自 "name" 的 "na" ，"na\b" 可以匹配出来自 "Gina" 的 "na" 。

在正则表达式中，[] 这个符号表示满足括号中任一字符，比如 [My]，它就不是匹配 My 了，而是匹配 M 或 y。如果改成 "[M,m]y" 就可以既匹配 "my" ， 又匹配"My"

 

（2）代码解释：

1，r'na'：r 是raw的意思，它表示对字符串不进行转义，

import re 

print r"\tna"         ==>\tna
print "\tna"          ==>　　na

 可以看到，不加 r 的话，\t 就没有了，因为Python的字符串碰到 \ 就会转移后面的字符。如果想在字符串里打 \ ，则必须打 \\ 。

2，re.findall() ：re 是Python里的正则表达式模块，findall 是其中的一个方法，用来按照提供的正则表达式，去匹配文本中的所有符合条件的字符串。返回结果是一个包含所有匹配的list 。

3，符号 "." ：. 在正则表达式中表达除换行符之外的任意字符。与之相似的是符号 "\S" ，它表示除空白字符之外的任意字符。

import re  
text='Hi,my name is Gina.My boyfriend is Gino.'
m=re.findall(r'i.',text)
print m                                           ==> ['i,', 'is', 'in', 'ie', 'is', 'in']

4，符号 "*" ： 在很多搜索中，会用？ 表示任意字符，* 表示任意数量连续字符，这种被称为通配符。 但在正则表达式中，任意字符是用 . 来表示，* 则表示数量，它表示前面的字符可以重复任意多次（包括0次），只要满足条件，都会被表达式匹配上。* 在匹配时，会匹配尽可能上的结果，称为贪婪匹配；如果你想让他匹配到最短的就停止，需要用 ".*?" ，如 "m.*?s" ，被称为懒惰匹配。

import re
text='Hi,my name is Gina.My boyfriend is Gino.'
m=re.findall(r'm.*s',text)
print m                                         ==> ['my name is Gina.My boyfriend is']

例：site sea sue sweet see case sse ssee loses 从该文本中匹配出所有以s开头，e为结尾的单词。

匹配规则  \bs\S*e\b

（3）用正则表达式匹配文件中的手机号：要匹配数字我们可以用 [0123456789] ，由于他们是连续的字符，有一种简化的写法：[0-9] ，类似的还有 [a-zA-Z] 的用法。

还有另一种表示数字的方法：\d ，要表示任意长度的数字，就可以用 [0-9]* 或者 \d* ，但是* 表示的长度包括0 ，也就是说没有数字的空字符也会被匹配出来。此时就要用到类似作用的符号 + ，表示的则是1个或更长。所以要匹配出所有的字符串,应该用 [0-9]+ 或者 \d+ 。如果限制长度，就用 {} 代替 + 里面写上限制的长度。比如十一位数字： \d{11}；若要把第一位限制为1，则在最前面加上1，后面去掉一位 1\d{10}

（4）关于正则表达式的详细内容参见 https://deerchao.net/tutorials/regex/regex.htm

 31，随机数random模块：import random

random.randint(a,b)可以生成一个a到b之间的随机整数，包括a和b，且必须b>=a。

random.random(a,b)生成一个 [0.0,1.0)  的随机浮点数。

random.uniform(a,b)生成a，b之间的随机浮点数，a和b无需是整数，也无需考虑大小。

random.choice(seq)从序列中随机选取一个元素。seq需要是一个序列，比如list，元组，字符串。

random.randrange(start,stop,step)生成一个从start到stop（不包括stop），间隔为step的一个随机数，三个数都要为整数，且满足start<stop。start和step都可以不提供参数，默认是从0开始，1为间隔。但如果需要指定step，则必须指定start。效果等同于random.choice(range(start,stop,step))

random.sample(population,k)从population序列中随机获取k个元素，生成一个新序列。sample不改变原来的序列。

random.shuffle(x)把序列x中的元素顺序打乱。

import random
print random.randint(1,10)
print random.random()
print random.uniform(3,1.5)
print random.choice('Gino')
print random.randrange(1,9,2)

a=[1,2,3,4,5,6,7,8]
print random.sample(a,3)
random.shuffle(a)
print a

 32，计时：Python中有一个time模块，它提供了一些与时间相关的方法。利用time，可以简单地计算出程序的运行时间，对于一些较大耗时间较多的程序，可以通过该方法了解程序中哪里是焦虑的瓶颈，从而有针对性的进行优化。

在计算机领域有一个特殊的时间，叫做epoch，它表示的时间是1970-01-01 00:00:00 UTC 。time模块的一个方法 time.time()返回的就是返回的就是从epoch到当前的秒数（不考虑闰秒），这个值被称为unix时间戳。于是我们利用这个方法得到程序的运行时间。在程序中的不同位置调用time.time()就可以得到程序运行到这个位置的时间，了解不同位置的时间消耗。

time中另一个很有用的方法是time.sleep(secs)，它可以让程序暂停secs秒。在抓取网页的时候，适当让程序sleep一下，可以减少短时间内的请求，提高请求的成功率。

import time
starttime=time.time()
print 'start:%f'%starttime

print 1
time.sleep(3)
print 2

endtime=time.time()
print 'endtime:%f'%endtime
print 'total time:%f'%(endtime-starttime)

33，lambda表达式： lambda 参数列表:表达式 

可以被看做一种匿名函数。它可以让你快速定义一个极度简单的的单行函数。定义lambda表达式时，参数列表周围没有括号，返回值前没有return关键字，也没有函数名称。虽然它的写法比def更简洁，但主体只能是一个表达式，不可以是代码块，甚至不能是命令（print不能用在lambda表达式中）。 lambda表达式创建了一个函数对象，可以把这个对象赋值给一个变量进行调用。

以下两个代码块所实现的功能一样：

def sum(a,b,c):
　　return a+b+c
print sum(1,2,3)

sum=lambda a,b,c:a+b+c
print sum(1,2,3) 

把lambda表达式用在def中：

def fn(x):
　　return lambda y:x+y

a=fn(2)
print a(3)

34，变量的作用域：在函数定义内的变量名前加上global关键字，其作用域就变成了全局的作用域。

global x告诉我们：这个x是一个全局变量，函数中的x和外部的x就成了同一个变量。当x在函数内被重新赋值时，外部的x也会随之改变。

def func():
　　global x
　　print 'x in the beginning of func(x)',x             ==>10
　　x=2
　　print 'x in the end of func(x)',x                        ==>2

x=10
func()
print 'x after calling func(x)',x                                ==>2

 

 35，map函数：map是Python自带的内置函数（无需用from引用），它的作用是把一个函数应用在一个（或多个）序列上，把列表中的每一项作为函数输入进行计算，再把计算的结果以列表的形式返回。map的参数可以是list，也可以是tuple。

（1）实现list1内的元素翻倍：

list1=[1,2,3,4,5,6]
def double_func(x):
　　return x*2

list2=map(double_func,list1)
print list2                                              ==>[2, 4, 6, 8, 10, 12]

也可以写成：

list1=(1,2,3,4,5,6)
list2=map(lambda x:x*2,list1)
print list2  

（2）实现list1和list2内的元素相加：

list1=[1,2,3,4,5,6]
list2=[1,3,5,7,9,11]
list3=map(lambda x,y:x+y,list1,list2)
print list3                                              ==>[2, 5, 8, 11, 14, 17]

当map中函数为None时，结果将直接返回参数组成的列表。如果有多组数列，将会返回每组数列中对应元素构成的元组的列表。

list4=map(None,list1)
print list4                                              ==>[1, 2, 3, 4, 5, 6]

list5=map(None,list1,list2)
print list5                                              ==>[(1, 1), (2, 3), (3, 5), (4, 7), (5, 9), (6, 11)]

36，reduce函数：reduce(function,iterable[,initializer])

map可以看做是把一个序列按照某种规则，映射到另一个序列。reduce是把一个序列根据某种规则，归纳为一个输出。第一个参数是作用在序列上的方法，第二个参数是被作用的序列，第三个可选参数，是初始值。function需要是一个接受2个参数，并有返回值的函数。它会从序列iterable里从左至右依次取出元素，进行计算。每次计算的结果，会作为下一次计算的第一个参数。若提供initializer，它会作为第一次计算的第一个参数。否则，就先计算序列中的前两个值。在Python3中reduce需要用from functoos import reduce引入。

list=xrange(1,101)
def add(x,y):
　　return x+y
print reduce(add,list)                          ==>5050

31，多线程：thread.start_new_thread(function,args[,kwargs])

function是开发者定义的线程函数，args是传递给线程函数的参数，必须是tuple类型，kwargs是可选参数。调用之后，会创建一个新的线程，来执行function函数，而代码原本的主线程将继续往下执行，不再等待function的返回。对于耗时长但又相互独立的任务，使用多线程可以大大提高效率。

 

import urllib,time,thread

def get(i):
id=1764796+i
url='https://api.douban.com/v2/movie/subject/%d'%id
d=urllib.urlopen(url).read()
data.append(d)
print i,time.time()-time_start
print 'data:',len(data)

time_start=time.time()
data=[]
for i in range(30):
print 'request movie:',i
thread.start_new_thread(get,(i,))

raw_input('press ENTER to exit...\n')