Python变量类型
#!/usr/bin/python
# -*-coding: UTF-8 -*-
counter =100 # 赋值整型变量
miles =1000.0 # 浮点型
name ="John" # 字符串
printcounter
printmiles
printname
结果：
100
1000.0
John
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2,"john"
以上实例，两个整型对象1和2的分配给变量a和b，字符串对象"john"分配给变量c。
标准数据类型
在内存中存储的数据可以有多种类型。
例如，person.s年龄作为一个数值存储和他或她的地址是字母数字字符存储。
Python有一些标准类型用于定义操作上，他们和为他们每个人的存储方法可能。
Python有五个标准的数据类型：
Numbers（数字）
String（字符串）
List（列表） [] 中括号
Tuple（元组） () 小括号
Dictionary（字典） {} 大括号
Numbers（数字）
当你指定一个值时，Number对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象。例如：
del var
del var_a, var_b
Python支持四种不同的数值类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
实例
Python字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :
s="a1a2···an"(n>=0)
它是编程语言中表示文本的数据类型。
python的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
如果你的实要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
比如:
s = 'ilovepython'
s[1:5]的结果是love。
当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。
上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
#!/usr/bin/python
# -*-coding: UTF-8 -*-
str ='Hello World!'
print str# 输出完整字符串
printstr[0] # 输出字符串中的第一个字符
printstr[2:5] # 输出字符串中第三个至第五个之间的字符串
printstr[2:] # 输出从第三个字符开始的字符串
print str* 2 # 输出字符串两次
print str+ "TEST" # 输出连接的字符串
以上实例输出结果：
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Python列表
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识。是python最通用的复合数据类型。看这段代码就明白。
列表中的值得分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：
#!/usr/bin/python
# -*-coding: UTF-8 -*-
list = ['abcd', 786 , 2.23, 'john', 70.2 ]
tinylist= [123, 'john']
printlist # 输出完整列表
printlist[0] # 输出列表的第一个元素
printlist[1:3] # 输出第二个至第三个的元素
printlist[2:] # 输出从第三个开始至列表末尾的所有元素
printtinylist * 2 # 输出列表两次
printlist + tinylist # 打印组合的列表
以上实例输出结果：
['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123,'john']
Python元组
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元素不能二次赋值，相当于只读列表。
#!/usr/bin/python
# -*-coding: UTF-8 -*-
tuple = ('abcd', 786 , 2.23, 'john', 70.2 )
tinytuple= (123, 'john')
printtuple # 输出完整元组
printtuple[0] # 输出元组的第一个元素
printtuple[1:3] # 输出第二个至第三个的元素
printtuple[2:] # 输出从第三个开始至列表末尾的所有元素
printtinytuple * 2 # 输出元组两次
printtuple + tinytuple # 打印组合的元组
以上实例输出结果：
('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123,'john')
以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：
#!/usr/bin/python
# -*-coding: UTF-8 -*-
tuple = ('abcd', 786 , 2.23, 'john', 70.2 )
list = ['abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # 元组中是非法应用
list[2] =1000 # 列表中是合法应用
Python元字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
#!/usr/bin/python
# -*-coding: UTF-8 -*-
dict = {}
dict['one']= "This is one" ##列表
dict[2] ="This is two"
tinydict= {'name': 'john','code':6734, 'dept': 'sales'}
printdict['one'] # 输出键为'one' 的值
printdict[2] # 输出键为 2 的值
printtinydict # 输出完整的字典
printtinydict.keys() # 输出所有键
printtinydict.values() # 输出所有值
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
函数 描述
int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real[,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列(key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
作者博文地址：https://www.cnblogs.com/liu-shuai/
eval
功能：将字符串str当成有效的表达式来求值并返回计算结果。
语法： eval(source[,globals[, locals]]) -> value
参数：
source：一个Python表达式或函数compile()返回的代码对象
globals：可选。必须是dictionary
locals：可选。任意map对象
实例展示：
1 可以把list,tuple,dict和string相互转化。
2 #################################################
3 字符串转换成列表
4 >>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
5 >>>type(a)
6 <type 'str'>
7 >>> b = eval(a)
8 >>> print b
9 [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
10 >>> type(b)
11 <type 'list'>
12 #################################################
13 字符串转换成字典
14 >>> a ="{1: 'a', 2: 'b'}"
15 >>> type(a)
16 <type 'str'>
17 >>> b = eval(a)
18 >>> print b
19 {1: 'a', 2: 'b'}
20 >>> type(b)
21 <type 'dict'>
22 #################################################
23 字符串转换成元组
24 >>> a ="([1,2], [3,4], [5,6], [7,8],(9,0))"
25 >>> type(a)
26 <type 'str'>
27 >>> b = eval(a)
28 >>> print b
29 ([1, 2], [3, 4],[5, 6], [7, 8], (9, 0))
30 >>> type(b)
31 <type 'tuple'>
Python 运算符
算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
#!/usr/bin/python
# -*-coding: UTF-8 -*-
a = 21
b = 10
c = 0
if ( a ==b ):
print "1 - a 等于 b"
else:
print "1 - a 不等于 b"
if ( a !=b ):
print "2 - a 不等于 b"
else:
print "2 - a 等于 b"
if ( a<> b ):
print "3 - a 不等于 b"
else:
print "3 - a 等于 b"
if ( a< b ):
print "4 - a 小于 b"
else:
print "4 - a 大于等于 b"
if ( a> b ):
print "5 - a 大于 b"
else:
print "5 - a 小于等于 b"
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a<= b ):
print "6 - a 小于等于 b"
else:
print "6 - a 大于 b"
if ( b>= a ):
print "7 - b 大于等于 b"
else:
print "7 - b 小于 b"
以上实例输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 不等于 b
4 - a 大于等于 b
5 - a 大于 b
6 - a 小于等于 b
7 - b 大于等于 b
Python赋值运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
Python位运算符
| 运算符 | 描述 | 实例 |
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13。
以下实例演示了Python所有位运算符的操作：
#!/usr/bin/python
# -*-coding: UTF-8 -*-
a =60 # 60 = 0011 1100 32+16+8+4+0+0
b =13 # 13 = 0000 1101
c = 0
c = a& b; # 12 = 0000 1100
print"1 - c 的值为：", c
c = a |b; # 61 = 0011 1101
print"2 - c 的值为：", c
c = a ^b; # 49 = 0011 0001
print"3 - c 的值为：", c
c =~a; # -61 = 1100 0011
print"4 - c 的值为：", c
c = a<< 2; # 240 = 1111 0000
print"5 - c 的值为：", c
c = a>> 2; # 15 = 0000 1111
print"6 - c 的值为：", c
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15
Python逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
#!/usr/bin/python
# -*-coding: UTF-8 -*-
a = 10
b = 20
if ( aand b ):
print "1 - 变量 a 和 b 都为 true"
else:
print "1 - 变量 a 和 b 有一个不为true"
if ( a orb ):
print "2 - 变量 a 和 b 都为 true，或其中一个变量为true"
else:
print "2 - 变量 a 和 b 都不为true"
# 修改变量 a 的值
a = 0
if ( aand b ):
print "3 - 变量 a 和 b 都为 true"
else:
print "3 - 变量 a 和 b 有一个不为true"
if ( a orb ):
print "4 - 变量 a 和 b 都为 true，或其中一个变量为true"
else:
print "4 - 变量 a 和 b 都不为true"
if not( aand b ):
print "5 - 变量 a 和 b 都为 false，或其中一个变量为false"
else:
print "5 - 变量 a 和 b 都为 true"
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为true
5 - 变量 a 和 b 都为 false，或其中一个变量为false
Python身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
#!/usr/bin/python
# -*-coding: UTF-8 -*-
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a +b) * c / d #( 30 * 15 ) / 5
print"(a + b) * c / d 运算结果为：", e
e = ((a +b) * c) / d # (30 * 15 ) / 5
print"((a + b) * c) / d 运算结果为：", e
e = (a +b) * (c / d); # (30) * (15/5)
print"(a + b) * (c / d) 运算结果为：", e
e = a +(b * c) / d; # 20 + (150/5)
print"a + (b * c) / d 运算结果为：", e
Python While循环语句
#!/usr/bin/python
count = 0
while(count < 9):
print 'The count is:', count
count = count + 1
print"Good bye!"
Python for 循环语句
#!/usr/bin/python
# -*-coding: UTF-8 -*-
forletter in 'Python': # 第一个实例
print '当前字母 :', letter
fruits =['banana', 'apple', 'mango']
for fruitin fruits: # 第二个实例
print '当前字母 :', fruit
print"Good bye!"
Break
Continue
Python pass 语句
Python pass是空语句，是为了保持程序结构的完整性。
passass 不做任何事情，一般用做占位语句。
Python 日期和时间
Time（）
#!/usr/bin/python
importtime; # This is required to include timemodule.
ticks =time.time()
print"Number of ticks since 12:00am, January 1, 1970:", ticks
#!/usr/bin/python
importtime;
localtime= time.localtime(time.time())
print"Local current time :", localtime
#!/usr/bin/python
importtime;
localtime= time.asctime( time.localtime(time.time()) )
print"Local current time :", localtime
Time模块
Time模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：
| 序号 | 函数及描述 |
| 1 | time.altzone |
| 2 | time.asctime([tupletime]) |
| 3 | time.clock( ) |
| 4 | time.ctime([secs]) |
| 5 | time.gmtime([secs]) |
| 6 | time.localtime([secs]) |
| 7 | time.mktime(tupletime) |
| 8 | time.sleep(secs) |
| 9 | time.strftime(fmt[,tupletime]) |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') |
| 11 | time.time( ) |
| 12 | time.tzset() |
Python函数
字符串延伸
对print函数字符串的的打印连接，对含有int类型的字符与字符串类型不能使用加号（+）。
print会自动在行末加上回车,如果不需回车，只需在print语句的结尾添加一个逗号”,“，就可以改变它的行为。print i,
或直接使用下面的函数进行输出：
sys.stdout.write("输出的字串")
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,]*var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
Python 文件I/O
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
raw_input str = raw_input("请输入：");
input
str = input("请输入：");
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是: [10, 20, 30, 40]
input([prompt])函数和raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
打开和关闭文件
现在，您已经可以向标准输入和输进行读写。现在，来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
open 函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
file object =open(file_name [, access_mode][, buffering])
各个参数的细节如下：
file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
模块
使用sys模块
#!/usr/bin/python# Filename:using_sys.pyimport sysprint 'The command line argumentsare:'for i in sys.argv: print iprint '\n\nThe PYTHONPATH is', sys.path, '\n'
python using_sys.py weare arguments
结果：
The command linearguments are:
using_sys.py
we
are
arguments
我们利用import语句 输入 sys模块。基本上，这句语句告诉Python，我们想要使用这个模块。sys模块包含了与Python解释器和它的环境有关的函数。
当Python执行import sys语句的时候，它在sys.path变量中所列目录中寻找sys.py模块。如果找到了这个文件，这个模块的主块中的语句将被运行，然后这个模块将能够被你 使用 。注意，初始化过程仅在我们 第一次 输入模块的时候进行。另外，“sys”是“system”的缩写。
脚本的名称总是sys.argv列表的第一个参数。所以，在这里，'using_sys.py'是sys.argv[0]、'we'是sys.argv[1]、'are'是sys.argv[2]以及'arguments'是sys.argv[3]。注意，Python从0开始计数，而非从1开始。
字节编译的.pyc文件
http://www.php100.com/manual/Python/ch08s02.html
输入一个模块相对来说是一个比较费时的事情，所以Python做了一些技巧，以便使输入模块更加快一些。一种方法是创建 字节编译的文件 ，这些文件以.pyc作为扩展名。字节编译的文件与Python变换程序的中间状态有关（是否还记得Python如何工作的介绍？）。当你在下次从别的程序输入这个模块的时候，.pyc文件是十分有用的——它会快得多，因为一部分输入模块所需的处理已经完成了。另外，这些字节编译的文件也是与平台无关的。所以，现在你知道了那些.pyc文件事实上是什么了。
常用函数
f=open("1.txt",'rb');
print f.readlines();输出所有打印出都在一行（以\r\n换行）
printf.read(); 正常打印，与文件里的格式一样
f.readline();只读一行
正则表达式：match是从字符串的头匹配 re.search不是从字符串的头匹配
searchObj= re.search( r'Last 300 seconds input: \d+',ff, re.M|re.I)
searchObj.group()
import re
f=open("1.txt",'r');
printf.readlines();
ff=f.readlines();
reobj=re.compile(r'Last300 seconds input: \d+')
reobj.findall(ff)//匹配所有的
import re
n1=[]
f=open("1.txt",'r');
for i inf:
#print len(i)
if 'Last 300 seconds input:' in i or 'Last300 seconds output:' in i:
#print i
printre.split(":|packets/sec|bytes",i)[1:3] //利用正则分域，
#for m inre.split(":|packets/sec|bytes",i)[1:3]:
#print m
#n1.append(int(m))
#print n1
#print n.append(m)
#for m in i.split(":")[1:]:
# print m
#printre.split("packets/sec|bytes",m)[0:2]
#print m.split("bytes")
#for j in i.split(":"):
# print j
Split：把特殊字符换成逗号，变成列表，再从列表中取特定值，与awk相当
Strip用法：默认去除字符串头尾的空格
" xyz ".strip() # returns "xyz"
" xyz ".lstrip() # returns "xyz "
" xyz ".rstrip() # returns " xyz"
" x y z ".replace(' ', '') # returns"xyz"
s ='Hello!This?Is!What?I!Want'
for i in('!', '?'):
s = s.replace(i,' ')
import re
使用正则替换
>>>s
'Hello!This?Is!What?I!Want'
>>>re.sub(re.compile(r'\?|\!'),'',s) ###替换？或！，使用‘|’为‘或’，正则里问号要转义，问号代表一个字符
'HelloThisIsWhatIWant'
>>>re.sub(re.compile(r'\?|!'),'',s)
'HelloThisIsWhatIWant'
>>>re.sub(r'\?|!','',s)
'HelloThisIsWhatIWant'
>>>
>>>my_str ='Jason' # 定义字符串 my_str
>>>my_str.startswith('Jas') # 若my_str以'Jas'开头，返回True, 否则返回False
>>>my_str.endswith('son') # 若 my_str以'son'结尾，返回True, 否则返回False
备注：.startswith(),.endswith() 均可以 tuple 为参数，满足其中之一即返回True
String.startswith(('a','b'))# 当String 以 a或 b开头均返回True
对文件中每行加入特殊字符，先按行读原文见，再写入新的文件添加特定字符。
importshutil
import os
root_dir="/root/python/data/"
#a=open('/root/python/data/ltec1_s1mme_201611260000_511_npssig152_9600.DAT','rb')
#printa.readline()
for parent,dirnames,filenames inos.walk(root_dir):
# print parent,dirnames,filenames
for i in filenames:
m=parent+i
#print m
f=open(m,'rb')
#r=f.readline()
new_file="/root/python/data1/"+i
print new_file
wri=open(new_file,'w+')
for j in f:
# print j
wri.write(j.rstrip("\r\n")+'|\n') ##需要先去掉换行符，再在行尾加入特定字符
#wri.write('|')
#wri.write('\n')
f.close()
wri.close()
shutil.move(m,"/root/python/finish_data/")
#printparent+filenames
按行打印全部：
f=open("1.txt",'r');
for i inf:
print i
此方法是边读边打印，非常实用，像f.readlines()是读完整个文件再打印
http://www.cnblogs.com/tqsummer/archive/2010/12/27/1917927.html
使用迭代器一个显而易见的好处就是：每次只从对象中读取一条数据，不会造成内存的过大开销。
比如要逐行读取一个文件的内容，利用readlines()方法，我们可以这么写：
| 1 | for line in open("test.txt").readlines(): |
这样虽然可以工作，但不是最好的方法。因为他实际上是把文件一次加载到内存中，然后逐行打印。当文件很大时，这个方法的内存开销就很大了。
利用file的迭代器，我们可以这样写：
| 1 | for line in open("test.txt"): #use file iterators |
这是最简单也是运行速度最快的写法，他并没显式的读取文件，而是利用迭代器每次读取下一行。
类
类相当于模板
定义格式：
class 类名(object):
"类的说明文档"
属性
初始方法__init__
其他方法
事例
- 属性没有公有和私有的说法。
- 没有构造方法，初始方法只是在实例化时会执行的方法。
- 定义方法时必须带上self参数，类似java里的this。
classUser(object):
"This is user class."
name = "tom"
age = 0
def __init__(self, age=22):
self.age = age
def showAge(self):
print self.age
def showClassName(self):
print self.__class__.__name__
def showClassDoc(self):
print self.__class__.__doc__
结果:
>>>summer=User()
>>>summer.showClassName
<boundmethod User.showClassName of <__main__.User object at0x0000000002DAFBA8>>
>>>summer.age
22
>>>summer.name
'tom'
>>>summer.showClassDoc
<boundmethod User.showClassDoc of <__main__.User object at 0x0000000002DAFBA8>>
>>>summer.__class__.__name__
'User'
>>>summer.__class__.__doc__;
'This is user class.'
__init__()方法：是基本类（没有继承的类）的入口，必须有
classPerson(): ######属于经典类
m='xxxxxx' ##静态字段，静态字段属于类，动态字段数据对象
def __init__(self,name,gene,weight):
self.name=name
self.__Gene=gene ###私有的属性
if name != 'root':
self.Gender='xxx'
self.Weight=weight
self.Age=None
def talk(self):
print 'xxxxxxxxx'
def fight(self,value):
if self.Weight > value:
print 'da'
else:
print 'go'
p1=Person('n1','a',190)
p1.Age=18
p2=Person('n2','s',50)
p2.fight(p1.Weight)
print p2.__dict__
for i inp2.__dict__.items():
print i
printdir(p2)
print p2.__dict__ ###打印所有的属性，返回字典对字典操作：for i in p2.__dict__：####只返回keyfor i in p2.__dict__.items():#####返回(’key’：’value’)print dir(p2) ####返回属性和方法，返回list新式类与经典类
经典类的特性全部可读可写
新式类：读、写分开，私有方法
新式类可以动态添加属性
##静态字段，静态字段属于类，动态字段数据对象 可以用于统计创建了多少实例，
建议使用 类. 静态字段 来取值 Person.m
静态方法（不带self的方法）只能由类访问
断言
assert(1==1)
类似if语句和try catch。。。
满足什么条件，再执行
多继承
经典类
新式类
先深度优先，后广度优先
python_mysql
#coding:utf-8
删改查
import MySQLdb
conn=MySQLdb.connect(host='127.0.0.1',user='root')
cur=conn.sursor()
reCount=cur.execute('select* from admin')
data=cur.fetchall()
cur.close()
conn.close()
printreCount ###返回影响的行数
printdata ##返回元组
增
importMySQLdb
conn=MySQLdb.connect(host='127.0.0.1',user='root')
cur=conn.sursor()
sql='insertinto admin(id,name) values (%s,%s)'
params=('xxx','xxx')
reCount=cur.execute(sql,params)
conn.commit()
#conn.rollback()
cur.close()
conn.close()
批量添加数据
importMySQLdb
li=[(‘aaa’,’ssss’),(‘www’,’rrrrr’)]
conn=MySQLdb.connect(host='127.0.0.1',user='root')
cur=conn.sursor()
reCount=cur.executemany('insert intoadmin(id,name) values (%s,%s)',li)
conn.commit()
cur.close()
conn.close()
更改cursor，可以返回列名
cur=conn.cursor(cursorclass=MySQLdb.cursors.DictCursor)
数据返回字典：
cur.fetchone() 返回第一条数据
绝对定位
cur.scroll(-a.mode=’absolute’)
相对定位
cur.scroll(-a.mode=’relative’)
参数
*列表
**字典
json模块（不同语言之间数据交换）
两种方法：loads，dumps
Json先将列表变成字符串格式，再将字符串变成列表
l =['iplaypython',[1,2,3], {'name':'xiaoming'}]
encoded_json = json.dumps(l)
>>> printencoded_json
["iplaypython",[1, 2, 3], {"name": "xiaoming"}]
>>> printtype(encoded_json)
<type 'str'>
>>>decode_json=json.loads(encoded_json)
>>> printtype(decode_json)
<type 'list'>
>>>import json
>>>a=[1,'45','ty',6,7,8]
>>>json.dumps(a) ####dumps加s直接打印出来，在socket中使用，不加s是写到文件中，socket只能传字符串
'[1,"45", "ty", 6, 7, 8]'
>>>
将json写入文件
>>>a=[1,'45','ty',6,7,8]
>>>json.dumps(a)
'[1,"45", "ty", 6, 7, 8]'
>>>f=open('txt.json','wb')
>>>json.dump(a,f)
>>>f.close()
>>>f=open('txt.json','rb')
>>>json.load(f)
[1,u'45', u'ty', 6, 7, 8]
>>>
re.sub
reg=re.compile('//<!\[CDATA\[[^>]*//\]\]>',re.I)s=reg.sub(‘’,html)
return s
replace 替换单字符
get_url.sort()##列表排序
import sys
import os
sys.exit() python解释器直接退出，主线程中间
os.exit() 直接退出python，以后代码不会退出
import time
'''
f=open('1.txt','w')
for i in xrange(10):
f.write("di %d line\n"%i)
time.sleep(1)
f.flush()
f.close()'''
withopen('1.txt','w') as f:
for i in xrange(10):
f.write("di%d line\n"%i)
time.sleep(1)
f.flush()
zip函数( 配对)
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>ab=zip(a,b)
>>> ab
[(1, 4), (2, 5), (3,6)]
编码
Unicode 指 “字符串”
Bytes 指“字节字符串”
u表示unicode
>>> print u'你好'
你好
>>> print b'你好'
你好
>>> b'你好' gbk编码
'\xc4\xe3\xba\xc3'
>>> '你好'
'\xc4\xe3\xba\xc3'
>>> print '你好'
你好
>>> u'你好' 以unicode码输出
u'\u4f60\u597d'
>>>
unicode编码（包含世界上所有字符（英中日韩。。。）），每个字符由2个字节（4个字符，32位）表示，（很浪费空间）
u'\u4f60\u597d' （0-ffff/65536）16进制 叫代码点
所以需要不同的规则，将代码点映射到不同的数字.
只需要将 英文中文做映射（比如gbk）
utf-8每个汉字占3个字节，gbk汉字占两个字节
>>> b'你好'
'\xc4\xe3\xba\xc3'
>>>'\xc4\xe3\xba\xc3'.decode('gbk')
u'\u4f60\u597d'
>>>u'\xc4\xe3\xba\xc3'.encode('utf-8')
'\xc3\x84\xc3\xa3\xc2\xba\xc3\x83'
window上，默认显示gbk码
.encode 编码
.decode 解码
由于unicode是代码点，我们要再做一次“编码”，编码到我们想要的数字上，所以unicode字符串拥有encode方法
unicode字符串备encode编码以后 会变成bytes字符串
>>> a=1
>>> a.bit_length
<built-in methodbit_length of int object at 0x00000000021E7AF8>
>>> a.bit_length() ###占多少位（bit比特）
1
>>>
查看python 内置对象
__builtins__.
dir(__builtins__)
类是一个对象
特例（实例）也是一个对象
python对象分两种：
类对象
实例对象
参数：必要参数，位置参数，默认参数，关键字参数，不定长参数
作用域（流程是封闭的）：
基本格式化（位置格式化）
>>>ns.format('son')
'son sys hey~'
>>> ns.format(12)
'12 sys hey~'
>>> ns.format('12')
'12 sys hey~'
>>>'{}....{}----{}pppppp{}'
'{}....{}----{}pppppp{}'
>>> '{}....{}----{}pppppp{}'.format(1,2,3,4)
'1....2----3pppppp4'
>>>
格式化花括号{}里写索引
>>>'{1}{0}'.format(1,2)
'21'
>>>
填充和对齐
默认使用空格填充
新版
默认是左对齐
>>>'{:10}'.format('left')
'left '
>>>
旧版
默认是右对齐
>>> '%10s'%'right'
' right'
>>> '%-10s'%'right'
'right '
>>> '{:<10}'.format('left')
'left '
>>> '{:>10}'.format('left')
' left'
居中
>>>'{:^10}'.format('left')
' left '
更改填充字符
>>>'{:_<10}'.format('left')
'left______'
截断
如果指定的长度比实际的长度要短
>>> '{:.10}'.format('qwertyuioasdfghjklzxcvbnm,')
'qwertyuioa'
先填充长度在截断
>>>'{:17.3}'.format('qwerty')
'qwe '
字符串方法
split（分割）按照某种字符分割字符串，默认是空格
>>>'qw:ewr:etg:'.split(:)
SyntaxError: invalid syntax
>>> 'qw:ewr:etg:'.split(':')
['qw', 'ewr', 'etg', '']
.join()
将列表里的元素以某种方式连接起来
>>>a=[‘a’,’b’,’g’]
>>> ':'.join(a)
'a:b:g'
===================================================
必须导入string模块
>>> import string
>>> string.join(["aaaa","bbb"])
'aaaa bbb'
>>>
>>> "".join(["People's","Republic","of","China"])
People's Republic of China
.title()将首字母变成大写
'tt yy'.capitalize() 将第一个字母大写
'qaz'.replace('q','w')替换字母，将q换成w
re.sub(pattern, repl, string, count=0, flags=0)正则表达式替换
.splitlines()替换行尾符，而不是空白符
rstrip将所有结尾的空白符去掉
>>> 'qw\r\nrf'.splitlines()
['qw', 'rf']
>>>
>>> '''hello
wor
df
'''.splitlines()
['hello', 'wor', 'df']
元组的理解
元组是由逗号决定的，而不是圆括号
>>> a=('one','two',)
>>> a[0]
'one'
>>> b=('just-one')
>>> b[0]
'j'
>>> c=('just-one',)
>>> c[0]
'just-one'
>>>
字典的补充
字典是可变的、无序的，是python里唯一的映射类型
字典的键值是无序的，正是无序让字典查找元素非常高效
get方法是提取键值，若没有可以指定返回的值，使用b[‘pub’]，若没有会返回错误
>>>b={'title':'Python','year':20170310}
>>> b.get('pub','nooooo')
'nooooo'
>>> b.get('pub')
>>> b.get('pub',)
>>>
采用for来迭代字典
>>> for key in b:
print key,'---->',b[key]
year ----> 20170310
title ----> Python
添加元素
>>>b.setdefault('pub','west add')
'west add'
>>> b
{'year': 20170310, 'pub':'west add', 'title': 'Python'}
>>>
*args和**kwargs
单个星号表示有元组（或是列表）出现，两个星号表示有字典出现
def check_web_server(host,port,path):
pass
用check_web_server(‘127.0.0.1’,’8000’,’/admin/’)即可调用
将信息放入三元组里
host_info=(‘127.0.0.1’,’8000’,’/admin/’)
调用：check_web_server(host_info[0], host_info[1],host_info[2])
等价于
check_web_server(*host_info)
字典：
host_info={‘host’:’127.0.0.1’,’port’:8000,’path’:’/admin/’}
等价于
check_web_server(**host_info)
迭代器(Iterator)
[i*i for i in xrange(10)] 输出list
迭代器:是一次只产生一个数据项，直到没有为止。与for类似 与list和tuple的区别，占用更少的内存。next()方法是打印出下一个数据项，不能反回，一旦输出完毕，数据就消失。而序列类型则保存所有数据项，
>>> a=[i*i for i inxrange(10**2)]
>>> iter(a)
<listiterator object at 0x0000000002173B38>
>>> b=iter(a)
>>> b
<listiterator object at0x000000000304A9B0>
>>> for i inb:print i
此处b为迭代器，当读完一次，数据就消失了，处理大数据时非常快，（当要处理百G数据时，使用list需要全部读到内存中，而迭代器不用。当迭代器使用next()方法时，读到没有数据时，会抛出一个异常）
0
1
4
9
16
生成迭代器：
>>> (i*i for i inxrange(10**9))
<generator object<genexpr> at 0x0000000002C6B3A8>
>>> e=(i*i for i inxrange(10**9)) （生成迭代器）打印出结果很快，如果使用list很慢
>>> e
<generator object<genexpr> at 0x0000000002C2DB40>
>>> e.next()
0
>>> e.next()
1
>>>
lambda函数（匿名函数）
函数没有具体名称，
>>> a=lambda i:i**2
>>> a(3)
9
>>>
>>> a=lambdai,x:i**2/(x-1)
>>> a(2,3)
2
>>>
>>> a=[1,2,3,4,5,6,7,8,9]
>>> map(lambda i:i*i,a) ##使用map函数
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>
map（函数，list）##将list里每个值作用于函数，返回list
>>> map(lambdai:i*i,(i for i in range(10)))
[0, 1, 4, 9, 16, 25, 36, 49,64, 81]
>>>
正则
>>> import re
>>>p=re.compile(r'\d')
>>>p.split('hg23hg45hg32')
['hg', '', 'hg', '', 'hg','', '']
>>> p.match('hg34')
>>>p.match('23skdhf345')
<_sre.SRE_Match object at0x00000000331DC030>
>>> printp.match('23skdhf345')
<_sre.SRE_Match object at0x00000000331DC098>
>>>a=p.match('23skdhf345')
>>> a
<_sre.SRE_Match object at0x00000000331DC098>
>>> a.group()
'2'
>>>p.search('weyr234jhg35')
<_sre.SRE_Match object at0x00000000331DC030>
>>> p.search('weyr234jhg35').group()
'2'
re.match匹配首个字符
search遍历整个字符串，匹配首个符合正则的
re.sub(‘[acb]’,’o’,’Mark’)
Mork
序列化
所有的文件读写，只能以字符串的形式进行，若将列表直接写入文件，会报错
d=[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
f=open(‘text’,’w’)
f.write(d) ###报错！！！！！！
f.write(‘%s’,%d) ##正确
c.close()
f=open(‘text’,’r’)
l=f.readlines()
此时l为 [‘[0, 1, 4, 9,16, 25, 36, 49, 64, 81]’]，不是列表了
此时，就不能将数据写到硬盘了，这就需要pickle序列化
import pickle
info={'n':[1,2,3,4],'m':['w','r','s']}
f=file('txti.pkl','wb')
pickle.dump(info,f)
f.flush()
f.close()
生成的文件为不规则字符串文件
读取序列化文件
>>> import pickle
>>>f=open('txti.pkl','rb')
>>>f.readlines()
['(dp0\n',"S'm'\n", 'p1\n', '(lp2\n', "S'w'\n", 'p3\n',"aS'r'\n", 'p4\n', "aS's'\n", 'p5\n', "asS'n'\n",'p6\n', '(lp7\n', 'I1\n', 'aI2\n', 'aI3\n', 'aI4\n', 'as.']
>>>pickle.load(f)###此处报错是因为已经readlines()了一次
Traceback(most recent call last):
File "<stdin>", line 1, in<module>
File"/usr/lib64/python2.6/pickle.py", line 1370, in load
return Unpickler(file).load()
File"/usr/lib64/python2.6/pickle.py", line 858, in load
dispatch[key](self)
File"/usr/lib64/python2.6/pickle.py", line 880, in load_eof
raise EOFError
EOFError
>>>f=open('txti.pkl','rb')
>>>a=pickle.load(f)
>>>a
{'m': ['w', 'r', 's'], 'n': [1,2, 3, 4]}
>>>
import os,sys
os.system(‘df’) ###返回系统执行结果
a= os.system(‘df’) ###a的值为0，表示返回正常
a=os.popen(‘df’) ###将系统执行结果赋值给a
>>> import os
>>> os.system('df')
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 206424760 143517444 52421556 74% /
。。。。
/dev/loop0 3351190 3351190 0 100% /mnt/iso
0
>>> a=os.system('df')
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 206424760 143518020 52420980 74% /
。。。。。
/dev/loop0 3351190 3351190 0 100% /mnt/iso
>>> a
0
>>>
>>> os.popen('df')
<open file 'df', mode 'r'at 0x7f34cbe738a0>
>>> a=os.popen('df')
>>> a
<open file 'df', mode 'r'at 0x7f34cbe73930>
>>> a.read()
'Filesystem 1K-blocks Used Available Use% Mountedon\n/dev/sda1 206424760 143518020 52420980 74% /\ntmpfs 。。。。。。。/data05\n/dev/loop0 3351190 3351190 0 100% /mnt/iso\n'
>>>
标准格式打印
>>> for i inos.popen('df -h'):
... print i,
...
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 197G 137G 50G 74% /
tmpfs 12G 112K 12G 1% /dev/shm
/dev/sdb1 985G 7.4G 927G 1% /cache
/dev/sdb2 850G 182G 625G 23% /data01
/dev/sdd1 1.8T 528M 1.7T 1% /data03
/dev/sde1 1.8T 213G 1.5T 13% /data04
/dev/sdf1 1.8T 56G 1.7T 4% /data05
/dev/loop0 3.2G 3.2G 0 100% /mnt/iso
>>> import commands
>>> c=commands.getoutput('df -h')
c=commands.getstatusoutput('df-h')###得到两个元素的tuple，
i,j=commands.getstatusoutput('df -h')
自带数据库（shelve）
import shutil
import sys, shelve
shelve模块与pickle模块区别
shelve：存储数据是先制定key然后再添加values，也可以存储类。key只能是字符串
import shelve
f=shelve.open(“test”)
f[‘qq’]=[1,2,3,4,5]
f[‘111’]={‘naem’:’hhhh’}
f.close()
方法：
has_key(self, key)
keys(self)
sync(self)
import collections
计数器collections.Counter()
有序字典collections.OrderedDict()
默认字典collections.defaultdict()
可命名元祖：collections.namedtuple()
MytupleClass=collections.namedtuple(‘MytupleClass’,[‘x’,’y’,’z’])##现场创建一个类
obj=MytupleClass(11,22,33) ###适用于创建坐标
print(obj.x)
print(obj.y)
print(obj.z)
-----------------------------------------------------------------------------------------------------------------
>>> import collections
>>> m=collections.namedtuple('m',['x','y','z'])
>>> obj=m(11,22,33)
>>> print(obj.x )
11
>>>
队列
双向、单项（先进先出）队列
d=collections.deque()
装饰器
为函数嵌套一层外套（适用于身份的验证）
与类的继承不同，
多线程
importthreading
t=threading.Thread(target=f ,args=(1，))
t.start()
#coding:utf-8
import os
importthreading
deffoo(arg,v):
print arg
print '子线程id：',os.getpid()
print '父线程id：',os.getpid()
print'before'
t1=threading.Thread(target=foo,args=(1,11,))t1.setDaemon(True)t1.start()print '-->',t1.getName()print t1.isDaemon()默认情况，当主进程执行完后，子线程还没有执行完，主线程会等待，一起结束。也就是t1.isDaemon()为false。t1=threading.Thread(target=foo,args=(1,11,))t1.setDaemon(True) ##添加在start之前，当为True，主进程执行完，程序退出，不等子线程t1.start()print '-->',t1.getName()print t1.isDaemon()
start
getName
setName
IsDaemon
setDaemon 是否守护线程
join(timeout)
run（）
可变参数加星号‘*’
join方法 等待子线程执行完后，程序停在这里，主程序也不往下执行
t1=threading.Thread(target=foo,args=(1,11,))
t1.setDaemon(True)
t1.start()
print'-->',t1.getName()
printt1.isDaemon()
t1.join(timeout=5) ##join是等待子线程执行完后，程序停在这里，主程序也不往下执行，此时timeout最多等待5S
print'main'
print'main end'
run()方法调用参数方法
定义类，重新写run方法，
importtime
fromthreading import Thread
classMyThread(Thread): ####继承Thread
def run(self):
time.sleep(3)
print 'i am processing'
defbar():
print 'bar'
t1=MyThread(target=bar) ####此时bar函数不执行，只是执行run方法
t1.start()
print'over'
importtime
fromthreading import Thread
classMyThread(Thread): ####继承Thread
def run(self):
time.sleep(3)
print 'i am processing' ###这是自己定义的类，新加的功能
Thread.run(self) ###调用了父类的run
defbar():
print 'bar'
t1=MyThread(target=bar)####此时可以打印出bar
t1.start()
print'over'
生产者消费者模型
使用类重写了多线程，生产者消费者分别一个类，利用Queue。
#coding:utf-8
importtime
fromthreading import Thread
fromQueue import Queue
classProcuder(Thread):
def __init__(self,name,queue):
#super(Procuder,self).__init__(self,group=None, target=None, name=None,args=(), kwargs=None, verbose=None)
super(Procuder,self).__init__()
self.__Name=name
self.__Queue=queue
def run(self):
while 1:
if self.__Queue.full():
time.sleep(1)
else:
time.sleep(1)
self.__Queue.put('baozi')
print '%s生产了一个包子'%self.__Name
#Thread.run(self)
classCoustmer(Thread):
def __init__(self, group=None, target=None,name=None,args=(), kwargs=None, verbose=None):
super(Coustmer,self).__init__()
self.__Name=args[0]
self.__Queue=args[1]
def run(self):
while 1:
if self.__Queue.empty():
time.sleep(1)
else:
self.__Queue.get()
time.sleep(1)
print '%s消费了一个包子'%self.__Name
#Thread.run(self)
que =Queue(maxsize=100)
A1=Procuder('a1',que,)
A1.start()
A2=Procuder('a2',que,)
A2.start()
A3=Procuder('a3',que,)
A3.start()
for i inrange(20):
name='B%d'%i
tmp=Coustmer(args=(name,que))
tmp.start()
'''que.put('1')
que.put('2')
printque.qsize()
printque.get()'''
锁
#coding:utf-8
importthreading
importtime
num=0
defrun(n):
time.sleep(1)
global num
lock.acquire()##获取锁，独占cpu
lock.acquire()
num+=1
lock.release()
lock.release()
time.sleep(0.001)
print'%s\n'%num
lock=threading.RLock()###递归锁，可以所多次
lock=threading.Lock()
samp=threading.BoundedSemaphore(4) ##信号量，当为1时和lock一样，相当于同时有4个人在执行，（适用于mysql最大连接数），拿加数字（num++）来说，也就是4个人同时获得num=50，cpu分别给4个人加1，同时得到51，返回时还是51
for i inrange(10):
t=threading.Thread(target=run,args=(i,))
t.start()
多进程
由于python限制（线程锁，同时只有一个进程来被cpu运行），线程不能被同时调用，所以使用多进程来解决。
多进程可以同时被多个cpu来执行，每个进程有一个线程。多个线程可以共享同一个进程的资源。
多线程间内存共享，进程之间内存独立
串行的执行
>>>map(lambda x:x*x,a)
[0, 1, 4,9, 16, 25, 36, 49, 64, 81]
>>>
基本的多进程
importtime
importmultiprocessing
deffoo(x):
time.sleep(0.1)
print x*x
return x*x
if__name__=='__main__':
a=range(10)
p=multiprocessing.Pool(10)
p.map(foo,a)
多线程间内存共享，进程之间内存独立
进程间通信
只能运行于linux
import multiprocessing
def run(p_list,n):
p_list.append(i)
print p_list
l=[]
for i in range(10):
p=multiprocessing.Process(target=run,args=[l,i,])
p.start()
import Queue as Q2 ###单独的Queue
from multiprocessing import Process,Queue ###多进程的封装Queue
def f(q,n):
q.put([n,'hello'])
printq.get()
if __name__=='__main__':
q=Queue()
for i inrange(5):
p=Process(target=f,args=(q,i))
p.start()
while True:
printq.get()
利用multiprocessing自带的Value,Array同步，只能是数字和列表
from multiprocessing import Process,Value,Array
def f(n,a,raw):
n.value=3.14159
for i in range(5):
a[i]=-a[i]
raw.append(9999)
print raw
if __name__=='__main__':
num=Value('d',0.0) ##d代表是数字，可以在进程间共享
arr=Array('i',range(10)) ###i代表是int，
raw_list=range(10)
print num.value
print arr[:]
p=Process(target=f,args=(num,arr,raw_list))
p.start()
p.join()
print num.value
print arr[:]
print raw_list
=============================结果===================================
0.0
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9999]
3.14159
[0, -1, -2, -3, -4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Manager可以支持字典列表，比array慢，进程共享
from multiprocessing import Process,Manager
def f(d,l):
d[1]='1'
d['2']=2
d[0.25]=None
l.reverse()
if __name__=='__main__':
manager=Manager()
d=manager.dict()
l=manager.list(range(10))
p=Process(target=f,args=(d,l))
p.start()
p.join()
print d
print l
进程池
只能执行与linux
from multiprocessing import Pool
importtime
def f(x):
print x*x
time.sleep(1)
return x*x
pool=Pool(processes=4)
res_list=[]
for i inrange(10):
res=pool.apply_async(f,[i,]) ##表示异步，自动启动，没有start方法----- pool.apply()方法为同步，表示串行输出，也就是没有get（）方法，它自己自动输出
res.get() ##表示取结果，此时为串行执行，当放到for外面，不知道取谁的值
#res_list.append(res) ##将结果放到列表
res_list.append(res)
for i in res_list:
print i.get(timeout=1) ###表示超时，自动退出
####相当于：printpool.map(f,range(10))
生产者消费者模型
用于线程之间的同步（相当于queue）解决松耦合，防止程序的阻塞。
python3.6安装
解压
yum installreadline-devel解决下方向键、退格键出现乱码问题（先安装再编译）
./configure --prefix=/usr/local/python3.6 --enable-shared
make&&make install
cp /usr/local/python3.6/lib/libpython3.6m.so.1.0 /lib64/
ln -s /usr/local/python3.6/bin/python3.6 /usr/bin/python3
编译安装python3.7.3
./configure --prefix=/usr/local/python3.7.3 --enable-optimizations --enable-shared --with-ssl
make && make install
解决依赖库的问题
在/etc/ld.so.conf.d/python3.7.3.conf添加如下(也可以追加到文件/etc/ld.so.conf):
/usr/local/python3.7.3/lib/
执行 ldconfig 生效, ldconfig -v 查看操作系统所有的依赖库
198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
