python基础知识

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"

以上实例,两个整型对象12的分配给变量ab,字符串对象"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)                                             将一个整数转换为一个八进制字符串

 

 

 

 

 

 

 

Pythoneval 函数妙用

 

作者博文地址: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赋值运算符

以下假设变量a10,变量b20

运算符

描述

实例

=

简单的赋值运算符

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 Falsex 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])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"20081211 周二180714秒)的24个字符的字符串。

3

time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时,比time.time()更有用。

4

time.ctime([secs])
作用相当于asctime(localtime(secs)),未给参数相当于asctime()

5

time.gmtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。注:t.tm_isdst始终为0

6

time.localtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回当地时间下的时间元组tt.tm_isdst可取01,取决于当地当时是不是夏令时)。

7

time.mktime(tupletime)
接受时间元组并返回时间辍(1970纪元后经过的浮点秒数)。

8

time.sleep(secs)
推迟调用线程的运行,secs指秒数。

9

time.strftime(fmt[,tupletime])
接收以时间元组,并返回以可读字符串表示的当地时间,格式由fmt决定。

10

time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根据fmt的格式把一个时间字符串解析为时间元组。

11

time.time( )
返回当前时间的时间戳(1970纪元后经过的浮点秒数)。

12

time.tzset()
根据环境变量TZ重新初始化时间相关设置。

 

 

 

 

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.py
import sys
print 'The command line argumentsare:'
for i in sys.argv:
    print i
print '\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
2

for line in open("test.txt").readlines():
    print line

这样虽然可以工作,但不是最好的方法。因为他实际上是把文件一次加载到内存中,然后逐行打印。当文件很大时,这个方法的内存开销就很大了。

利用file的迭代器,我们可以这样写:

1
2

for line in open("test.txt"):   #use file iterators
    print line

这是最简单也是运行速度最快的写法,他并没显式的读取文件,而是利用迭代器每次读取下一行。

 

 

 

 

 

 

 

 

 

 

 

 

 

类相当于模板

定义格式:

class 类名(object):

   "类的说明文档"

    属性

    初始方法__init__

    其他方法

事例

  1. 属性没有公有和私有的说法。
  2. 没有构造方法,初始方法只是在实例化时会执行的方法。
  3. 定义方法时必须带上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__:####只返回key
for 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 查看操作系统所有的依赖库

 

 

发布了22 篇原创文章 · 获赞 1 · 访问量 2165
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览