第三章:Python基础

3-1 人生苦短，我用Python

"Life is short,you need Python"

------Bruce Eckel

Python是什么

1989年

设计哲学

Python为什么流行

代码量小

维护成本低

编程效率高

3-2 Python 安装与配置

python-3-5.-0-x86.exe

python-3-5-0-x86-64.exe

Add pyton 3.5 to PATH

Pip安装Selenium

pip是一个现代的。通用的Python 包管理工具，提供了对Python包的查找、下载、安装、卸载的功能

安装指定版本的Selenium 

pip install selenium==2.48.0

pip uninstall selenium

查看当前包

pip show selenium

...\LIb\site-packages

PyCharm安装

Pycharm是一种IDE,带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、Project管理、

代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能。以用于支持Django框架下的专业

Web开发。

官网下载地址（选择社区版）：

http://www.jetbrains.com/pycharm/download/#section=windows

3-3 第一个Python程序

''' # print语句 # 打印字符串 print ("hello world!") print ("are","you","ok")  #打印整数 print(500) print(500+200)  #打印变量 name="123" print("hello,%s" %name)  width=30 print("width is %d " %width) ''' #input语句 con=input("please input Contten: ")
print("the input Content is %r" %con)

3-4 Python常用数据类型

 整数

x=5

y=5

z=x+y

print(z)

浮点数

f=5.20

l=5.30

a=f+l

print(a)

字符串

str="hello world"

print(str)

转义字符

print("hello \n world")

print("c:\\python35")

#my name is 'Jack' and "you" print("My name is \'Jack\' and \"your\"")

布尔值

t=True f=False print(t and f)

3-5 数组定义与访问

数组是一种有序的集合，可以随时添加和删除其中的元素。

数组定义

student =['jack','bob','harry','Micle']
print(student)

#访问数组元素，用索引来访问数组中的每一位元素值，记得索引是从0开始的
print(student[0])
print(student[1])

#访问数组最后一个元素
#注意，当索引超过范围时，Python会报一个Index Error错误，所以，要确保索引不要越界
print(student[-1])

3-6 数组元素添加修改与删除

添加元素
#末尾追加元素
student.append("john")
print(student)
#在指定位置添加元素
student.insert(0,'tom')
print(student)


修改元素
student[0]='No.1'
print(student)

删除元素

#删除末尾元素
student.pop()
print(student)

#删除指定位置元素
student.pop(1)
print(student)

3-7 Python元组数据

Python 的元组与列表类似，不同之处在于元组的元素一旦定义就不能修改。元组使用小括号，

列表使用广括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

course=('Chinese','Math','Englist','compuuter')
print(course)
print(course[1:3])
print(course[-1])
print(course[1:])
print(course[:2])


#元组的个数
print(len(course))

#定义一个只有1个元素的元组，则需要在元素后面加逗号，用来消除数据歧义
t=(1,)


#返回元组最大值
score=(78,90,88,76,78)
print(max(score))

3-8 python字典

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值（key=> value）对用

冒号（:）分割，每个对之间用逗号（，）分割。整个字典包括在花括号{}中，格式如下所示：

d = {key1:value1,key2:vlaue2 }

键必须是唯一的，但值则不必。值可以聂任何数据类型，但键必须是不可变的。

student = {1:'jack',2:'bob',3:'marry',4:'Micle'}
print(student[3])


#添加元素
#增加新的键值对
student[5]='hello'
print(student)


#修改元素
#修改字典
student[2]='Marry'
print(student)

#删除字典
del student[1]
print(student)

#清空字典全部内容
student.clear()
print(student)

#删除字典
del student

3-9 条件判断

案例1：根据分数来判断学生成绩是否优秀，80分以以上为优秀，评级为A。

score = 80
if score >=80:
    print("score is A")
else:
    print("score is not A")

注意：print语句要注意，不要Tab和空格混合使用，否则会编译报错

案例2：成绩80分以上为评级A,60-79分为B,60分以下为C

score = 80
if score >= 80:
    print("score is A")
elif score>=60:
    print("score is not B")
else:
    print("score is C")

Tips:elif是else if的缩写，完全可以有多个elif

3-10 循环语句

循环语句允许我们执行一个语句或语句组多次，Python提供了for循环不while循环（在Python中没有do..while循环）

for循环

案例1：将Student 数组值全部打印出来。

student=('Jack','Bob','Marry','Micle')
for stu in student:
    print (stu)

案例2：计算1+2+3+...10的值

Python 提供了一个range()函数，可以生成一个整数序列，比如range(10)生成的序列是从0开始小于10的整数

sum = 0
for i in range(11):
    sum += i
print(sum)

While 循环

while 循环，只要条件满足，就不断循环，条件不满足时退出循环

n=10
while n>0:
    n=n-1
    print(n)
print('over')

3-11 Python 猜数字小游戏

游戏规则 生成一个指定范围的随机数（如：1-100），然后玩家输入数值猜答案，屏幕

会根据玩家输入的数字给出大小提示，一直到玩家猜出准确答案则游戏胜利结束

import random
#生成随机数
answer = random.randint(1,100)
#家输入数值
n=int(input("Please input num()1-100:"))
#判断输入数字大小
while n!=answer:
    if n>answer:
        n=int(input("Num is more Please Continue input num:"))
    elif n<answer:
        n=int(input("Num is less Please Continue input num:"))
#输出答案正确，程序退出
print("You win the game!")

3-12 Python函数定义与调用

函数概念

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高 应用的模块性，和代码的重复

利用率。如print(),range()函数，也可以自己创建函数，这被叫做用户自定义函数。

函数定义

案例：定义一个函数Max_num(),用来比较两个数字的大小，然后将数值大的数字返回

函数代码块以def 关键字开头，后接函数标识符名称和圆括号（）。

圆括号之间可以用于定义参数。

函数内容以冒号起始，并且缩进

return[表达式]选择性地返回一个值给调用方。不带表达式的return相当月于返回None

def Max_num (a,b):
    if a>b:
        return a
    elif a<b:
        return b
    else:
        return a

result = Max_num(15,100)
print((result))

3-13 Python 面向对象（1）

场景案例：

在python班级要求两名新同学Jack和Harry分别介绍自己的名字和来自哪座城市，然后分别

别说一名班级口号：“Hello,python!”.最给控制台打印效果如下：

仅结合页面所学的知识来实现

name='Jack'
city='Beijing'
print("My name is %s and come from %s" %(name,city))
print("hello,python")

name='Harry'
city='Shanghai'
print("My name is %s and come from %s" %(name,city))
print("hello,python")

？思考几个问题

1、如果老师要求全班60个同学依次以上面形式自我介绍，该怎么办？

2、每个同学介绍自己姓名和来自城市之后，现顺便介绍自己的年龄？

3、每个同学自我介绍的代码块有何相同特征？

3-14 Python面向对象（2）

 

类与对象

现实世界中，随处可见的一种事物就是对象，对象中事物存在的实体，如人类，汽车、动物、水果这些都是一个抽象的类别。

我们所见到的实物都是这些类的具体存在，因此类是对象的抽象集合，对象是类的具体表现。现实世界是万物皆对象。

人

属性：地域、肤色、国家，......

功能：走路、思考、饮食、繁衍，......

具体对象：中国人、非洲人

学生

属性：姓名、学号、城市、年龄......

功能：听、说、读、写......

具体对象:Jack同学，Harry同学

面向对象关键要素

类（Class）:

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法

数据成员

类的不同属性数据

对象

对象是类的实例

方法

类为定义的函数，实现相关的功能

面向对象编程

简称OOP(Object Oriented Programming),是一种程序设计思想。OOP把对象作为程序

基本单元，一个对象包含了数据和操作数据的函数（方法）。

面向对象的设计思想是从自然界中来的，因为在自然界中，类(Class)和实例

（Instance）的概念是很自然的。Class是一种抽象概念。比如我们定义的Student类，是

指学生这个概念，而实例（Instance）则是一个个体的Student对象

Python是一门面向 对象的语言，在Pythonk 创建一个类和对象是很容易的。

三大特性

封装

继承

多态

3-15 Python类与对象

定义类

class Student(objcet):

类体

Class是类的定义产关键词，class后面紧接着是类名，即Student,类名通过是大写开关的ujyn，紧接着是

（object）,表示该类是从哪个类继承下来的。通常如果没有明确的继承类，

就使用object类，括号内一般为为空默认就是继承object类。这是所有类最终都会继承的类，也就是基类。

属性初始化

由于类可以起到模板的作用，因此，可以在创建实例对象的时候，把一些我们认为必须绑定的属性强制

填写进去。通过定义一个特殊的_init_方法，如：在创建Student实例的时候，就把name,city等属性绑上

去

class Student():
    def __init__(self,name,city):
        self.name=name
        self.city=city
        print("My name is %s and come from %s" %(name,city))
        

__init__方法的第一个参数永远是self,表示创建实例本身，因此，在__init__方法内部，

就可以把各种属性绑定到self，因为sef就指向创建的实例本身，有了__init__方法，在创建

实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数。但self不需要

传，Python解释器自己会把实例变量传进去。

定义方法

类型方法坠子第一个参数是self外，其他和变通函数一样，要调用一个方法，只需要在实例变量上直接调用。

class Student():
    def __init__(self,name,city):
        self.name=name
        self.city=city
        print("My name is %s and come from %s" %(name,city))
    def talk(self):
        print("hello python")

生成实例对象

class Student():
    def __init__(self,name,city):
        self.name=name
        self.city=city
        print("My name is %s and come from %s" %(name,city))
    def talk(self):
        print("hello python")


stu1=Student('Jack','Beijing')
stu1.talk()
stu2=Student('Micle','Shanghai')
stu2.talk()

3-16 Python模块引用

模块

为何要使用模块

随着项目功能和需求增多，代码量也会增大，把全部代码放在一个文件会显得冗余，因此需要使用模块进行分区管理。

python模块是什么？

Python模块（Module）是一个Python 文件，以.py结尾，包含了Python对旬定义和Python语句。

使用模块有什么好处？

最大的好处是大大提高了代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用，如：随机数模块，时间模块。

 import语句

 导入时间模块显示当前系统时间

#模块 显示当前时间
import time
print(time.ctime()) #调用获取当前时间方法

导入随数模块显示随机整数

from ...import...

Python 的from语句让你从模块中导入一个指定的部分到当前命名空间中。

from time import sleep
sleep(5)
print("Sleep over!")

3-17 跨目录模块引用

from student import Student
stu1=Student('Jack','Beijing')
stu1.talk()
stu2=Student('Micle','Shanghai')
stu2.talk()

跨目录调用模块

案例：调用School目录下的Student模块,把student移到school下

from school.student import Student
stu1=Student('Jack','Beijing')
stu1.talk()
stu2=Student('Micle','Shanghai')
stu2.talk()

import搜索路径

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

当前目录

如果不在当前目录，Python则搜索PYTHONPATH下的每个目录

如果都找不到，Python会察看安装默认路径

3-18 Python异常（1）

什么是异常？

异常是一个事件，该 事件会在执行过程发生，影响了程序的正常执行。一般情况下

在Python无法正常处理时就会发生一个异常。异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

常见异常类型

异常名称 描述

FileNotFoundError 找不到指定文件的异常

NameError 未声明/初始化对象(没有属性)

BaseException 所有异常的基类

异常处理语句

try...;except...

try...except...finally

raise

1.try......except

try:
    print(stu)
except BaseException as msg:
    print(msg)

try:
        fileName=input("please input fileName:")
        open("%s.txt" %fileName)
except FileNotFoundError:
        print("%s.txt file not found" %fileName)

NameError

try:
    print(stu)
except NameError:
    print("stu not define")

BaseException

try:
    print(stu)
except BaseException:
    print("stu not define")

3-19 Python异常(2)

try..;except...as

try:
    print(stu)
except BaseException as msg:
    print(msg)

try...except ...else  使用

try:
    stu= "jack"
    print(stu)
except BaseException as msg:
    print(msg)
else:
    print("stu is defined")

try...excepy...finally输出

try:
    stu= "jack"
    print(stu)
except BaseException as msg:
    print(msg)
finally:
    print("The end !")

raise 抛出异常

前面try语句是执行过程中捕获代码块的异常，而else是通过事先定义一个条件，一旦符合异常条件就抛出异常。

def division(x,y):
    if y==0:
        raise ZeroDivisionError("Zero is not allow!")
    return x/y
try:
    division(8,0)
except BaseException as msg:
    print(msg)

注意:raise 只能用于Python标准异常类

BaseException  所有异常的基类

SystemExit 解释器请求退出

3-20 文件处理

打开文件

使用Python内置的方法open()可以打开文件

File object = open(file_name [,access_mode][,buffering])

file_name: file_name变量是一个包含了你要访问的文件名称的字符串值。

access_mode:access_mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个

参数是非强制的，默认文件访问模式为只读的(r)。

buffering:如果buffering的值设为0,就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

f1=open("aa.txt",'r')
f2=open('D:\\python\\selenium自动化测试\\ch3\\aa.txt','r')

常用文件打开模式

模式 描述

r 以只读方式打开文件

rb 以二进制格式打开一个文件用于只读

w 打开一个文件只用于写入

a 打开一个文件用追加。新的内容会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

文件读取

line=f1.read()
line1=f1.readline()
line2=f1.readlines()

read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。

readline()每次只读取一行

readlines()一次性读取文件所有行 自动将文件内容分析成一个行的列表， 该列表可以由Python 的for...in...结构进行处理

关闭文件

f.close()

3-21 读取txt文件

案例:读取stu_info.txt文件内容，并将所有文件中学生名称显示出来。

f=open("stu_Info.txt",'r')
lines=f.readlines()
print(lines)

for line in lines:
    print(line.split(',')[0])

程序运行输出结果

['Jack,22,Beijing\n', 'Micle,33,Shanai\n', 'John,23,Shenzhen\n']
Jack
Micle
John

split()方法语法

str.split(str="",num=string..count(str))

参数

str --分隔符，默认为所有的空字符，包括空格、换行（\n）、制表符(\t)等。

num --分割次数

3-22 读写csv文件

csv即为逗号分隔值（Comma-Separated Calues, VSV），有时也称为字符分隔值，其文件以纯文本形式存储表格数据（数字和文本）。

csv文件读取

案例：读取stu_info.csv 文件里所有学生信息。.

import csv
csv_file=csv.reader(open('stu_info.csv','r'))

for stu in csv_file:
    print(stu)

csv_file=csv.reader(open('stu_info.csv','r'))
for stu in csv_file:
    print(stu[0])

csv_file=csv.reader(open('stu_info.csv','r'))
for stu in csv_file:
    print(stu[1])

csv_file=csv.reader(open('stu_info.csv','r'))
for stu in csv_file:
    print(stu[2])

csv文件写入

对stu_info.csv文件追加写入两个学生信息Marry和Rom

stu=['Marry',28,'Changsha']
stu1=['Rom',23,'Chendu']
#打开文件
out=open('stu_info.csv','a',newline='')
#设定写入模式
csv_write=csv.writer(out,dialect='excel')
#写入具体内容
csv_write.writerow(stu)
csv_write.writerow(stu1)
print("Write file over")

if csvfile is a file object,it should be opened with newline=

3-23 xml文件概述

什么是xml文件？

xml即可扩展标记语言，它可以用来标记数据，定义数据类型，是一种允许用户对自己的

标记语言进行定义的源语言。

从结构上，很像HTML超文本标记语言。但它被设计的目的是不同的，具体如下：

XML被设计用来传输和存储数据

HTML被设计用来显示数据

xml特征

它是有标签对组成：<aa></aa>

标签可以有属性：<<aa d='123'></aa>

标签对可以嵌入数据：<aa>abc</aa>

标签可以嵌入子标签（具有层级关系）

XML文件结构

XML文档形成了一种树结构，它从“根部”开始，然后扩展到“ 枝叶”

第一行是XML声明，它定义了XML的版本（1..0）和所使用的编码

<node>是根元素，也称为根节点

<to><form><heading><body>是子元素（子节点）

XML文档必须包含根元素，该元素是所有其他元素的父元素

DOM文档对象模型

文档对象模型（Document Object MOdel,简称DOM）,DOM就是针对HTML和XML提供的一个 API.什么意思？

就是说为了能以编程折方法操作这处HTML的内容（比如添加某些元素、修改元素的内容、删除某些元素）。

我们把这个HTML或xml看做一个对象树（DOM树）。它本身和里面的所有东西比如<div></div> 这些标签都看

做一个对象。每个对象都叫做一个节点（node).

DOM有什么用

就是为了操作HTML或xml中的元素，比如说我们要通过JS把这个网页的标题改了，直接这样就可以了“

document.title ='hello';

3-24 手工打造一个xml文件

创建xml文件

创建一个xml文件class.xml 用来存储班级学生（姓名，年龄，城市），老师（姓名，年龄，城市）、教务账号（学生和老师的账号，密码）等信息。

<?xml version="1.0" encoding="utf-8" ?>
<class>
    <student>
        <name>Jack</name>
        <age28></age28>
        <city>Beidjing</city>
    </student>
     <student>
        <name>Bob</name>
        <age>25</age>
        <city>Shanghai</city>
    </student>
     <student>
        <name>Harry</name>
        <age>23</age>
        <city>Shenzhen</city>
    </student>
    <teacher>
        <name>Marry</name>
        <age>23</age>
        <city>Changsha</city>
    </teacher>
    <account>
        <login username="teacher" password="12345690"/>
        <login username="student" password="888888"/>
    </account>
</class>

3-25 读取xml元素节点

xml节点

xml文件节点一般包括3类：

1、元素节点

2、文本节点

3、属性节点

每个节点都拥有包含着关于节点某些信息的属性。这些属性是：

• nodeName(节点名称)
• nodeValue(节点值)
• nodeType(节点类型)

读取元素节点

from xml.dom import minidom

#打开xml文件
dom=minidom.parse('class.xml')

#加载dom对象元素
root = dom.documentElement

#打印节点信息
print(root.nodeName)
print(root.nodeValue)
print(root.nodeType)

输出结果

C:\python35\python.exe D:/python/selenium自动化测试/ch3/get_node_info.py
class
None
1

• nodeName：节点名称
• nodeValue：返回文本节点的值
• nodeType：属性返回以数字值返回指定节点的节点类型

如果节点是元素节点，则nodeType属性将返回1.

如果节点是属性节点，则nodeType属性将返回2

3-26 读取xml文本节点

案例：分别打印出class.xml里的学生和老师的详细信息（姓名，年龄、城市）

from xml.dom import minidom

#打开xml文件
dom=minidom.parse('class.xml')

#加载dom对象元素
root = dom.documentElement

#根据标签名称获取标签对象
names=root.getElementsByTagName('name')
ages=root.getElementsByTagName('age')
cities=root.getElementsByTagName('city')

#分别打印显示xml文档标签对里面的内容
for i in range(4):
    print(names[i].firstChild.data)
    print(ages[i].firstChild.data)
    print(cities[i].firstChild.data)

输出结果

C:\python35\python.exe D:/python/selenium自动化测试/ch3/get_node__value.py
Jack
25
Beidjing
Bob
25
Shanghai
Harry
23
Shenzhen
Marry
23
Changsha

3-27 读取xml属性节点

案例：分别读取打印老师和学生的账号密码

from xml.dom import minidom

#打开xml文件
dom=minidom.parse('class.xml')

#加载dom对象元素
root = dom.documentElement

logins=root.getElementsByTagName('login')

for i in range(2):
    username=logins[i].getAttribute('username')
    print(username)
    password=logins[i].getAttribute('password')
    print(password)

输出结果

C:\python35\python.exe D:/python/selenium自动化测试/ch3/get_node_attriibute.py
teacher
12345690
student
888888

3-28 读取xml子节点

读取子节点<student>相关属性

from xml.dom import minidom

#打开xml文件
dom=minidom.parse('class.xml')

#加载dom对象元素
root = dom.documentElement

tags= root.getElementsByTagName('student')

print(tags[0].nodeName)
print(tags[0].tagName)
print(tags[0].nodeType)
print(tags[0].nodeValue)

输出结果

C:\python35\python.exe D:/python/selenium自动化测试/ch3/get_child_node_info.py
student
student
1
None

3-29 线程与进程概述

进程（Process）

是计算机中的程序关于革数据集合上的一次运行活动，是系统进行资源分配和调试的基本单位，是操作系统

结构的基础

线程(Thrread)

有时被称为轻量级进程（Lightweight Process,LWP）,是程序执行流的最小单元。线程是进程中的一个实体。

是被系统独立调度和分派的基本单位， 一个进程可以包含多个线程，但是线程不能包含多个进程。线程

自己不拥有系统资源，在单个程序中间同时运行多个线程完成不同的工作，称为多个线程。

线程与进程的区别

线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程

有自己的执行堆栈和程序计数器为其执行上下文。

Tips:

LoadRunner和Jmeter性能测试工具也利用了多线程和多进程来构造多个并发用户来执行性能测试

线程与进程图文解释

http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

3-30 单线程实践应用

单线程

单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。

案例：一个学生先用2秒说话，按着用3秒写字，最后结束

from time import ctime,sleep

#说
def talk():
    print("Start talk: %r" %ctime())
    sleep(2)

#写

def write():
    print("Start write %r" %ctime())
    sleep(3)

if __name__=='__main__':
    talk()
    write()
    print("All end ! %r" %ctime())

if __name__=='__main__': 表示如果当前模块是被直接运行的，则该语句之后代码块被运行，如果

模块是被导入的，则代码块不被运行。

3-31 多线程实践应用

多线程（MultiThreading）是指从软件或者硬件上实现多个线程并发执行的技术。

案例：让学生同时进行说和写操作

from time import ctime,sleep
import threading

#定义和写的方法
def talk(content,loop):
    for i in range(loop):
        print("Start talk:Hello:%s %s" %(content,ctime()))
        sleep(3)
def write(content,loop):
    for i in range(loop):
        print("Start write:Hello:%s %s" %(content,ctime()))
        sleep(5)

#定义和加载说和写的线程
threads=[]
t1=threading.Thread(target=talk,args=('hello world!',2))
threads.append(t1)

t2=threading.Thread(target=write,args=('Life is short,you need Python!!',2))
threads.append(t2)


#执行多线程
if __name__=='__main__':
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print("All Thread end! %s" %ctime())

输出结果

C:\python35\python.exe D:/python/selenium自动化测试/ch3/multi_threading.py
Start talk:Hello:hello world! Thu Dec 14 15:31:23 2017
Start write:Hello:Life is short,you need Python!! Thu Dec 14 15:31:23 2017
Start talk:Hello:hello world! Thu Dec 14 15:31:26 2017
Start write:Hello:Life is short,you need Python!! Thu Dec 14 15:31:28 2017
All Thread end! Thu Dec 14 15:31:33 2017

3-22 多进程实践应用

与多线程相比，多进程就是import multiprocessing 然后替换相应的方法

multiprocessing.Process()

from time import ctime,sleep
import multiprocessing

#定义和写的方法
def talk(content,loop):
    for i in range(loop):
        print("Start talk:Hello:%s %s" %(content,ctime()))
        sleep(3)
def write(content,loop):
    for i in range(loop):
        print("Start write:Hello:%s %s" %(content,ctime()))
        sleep(5)

#定义和加载说和写的进程
process=[]

p1=multiprocessing.Process(target=talk,args=('hello world!',2))
process.append(p1)

p2=multiprocessing.Process(target=write,args=('Life is short,you need Python!',2))
process.append(p2)


#执行多进程
if __name__=='__main__':
    for t in process:
        t.start()
    for t in process:
        t.join()
    print("All process is run OK! %s" %ctime())

相关延伸

进程间通信IPC(Interprocess communication)

线程锁，进程锁

生命周期

进程调度

3-33 Python爬虫实战-爬取Web页图片

从网页页面上批量下载jpg格式图片，并按照数字递增命名保存到指定的文件夹。

Web地址：http://p.weather.com.cn/2017/06/2720826.shtml#p=1

import urllib
import urllib.request
import urllib.response
import re

def load_page(url):
    request=urllib.request.Request(url)
    response=urllib.request.urlopen(request)
    data=response.read()
    return data

def get_image(html):
    regs=r'http://[\S]*jpg'
    patter=re.compile(regs)
    get_image=re.findall(patter,repr(html))

    num=1
    for img in get_image:
        image=load_page(img)
        with open('D:\\Photo\\%s.jpg' %num,'wb') as fb:
            fb.write(image)
            print("正在下载第%s张图片" %num)
            num=num+1
    print("下载完成")

url='http://p.weather.com.cn/2017/06/2720826.shtml#p=1'
html=load_page(url)
get_image(html)

正则表达式相关知识

http://deerchao.net/tutorials/regex/regex.htm