python休眠1秒 python睡眠1秒

我想写一个python让其纸上面在随机时间20秒到100秒之间打印一遍hello,world？

深入解析Python中的线程同步方法

import time

python休眠1秒 python睡眠1秒

python休眠1秒 python睡眠1秒

import random

sleeptime=random.randint(20,100) #在这里产生20到100之间的随机整数

time.sleep(sleeptime) ##根据上步产生的时间进行休眠

print("helock.release() #: release lock, no matter whatllo,world") #输出hello，world

python鼠标单击不干扰暂停

一个是一个简单的同步对象，表示为一个内部标识(internal flag)，线程等待这个标识被其它线程设定，或者自己设定、清除这个标识。

是的，不干扰，一次运行程序时，会产生一个keepWorking.txt 文件，可以修改这个文件中的变量。如果检测到已经存在这个文件，则读取文件中的配置。

... 从共享对象中获取部分数据

等待delay 秒后，让鼠标水平跳动pix 个像素，再等待delay 秒后，再跳回去。

到达maxDelay 秒时，程序退出，不再模拟作鼠标。

click =1 表示鼠标移动后，是否模拟左击作。设置为0可能起不到防止休眠的作用。

深入解析Python中的线程同步方法

start = time.time()

同步访问共享资源

while(True): #循环条件，可以自行修改，这里设置一直运行下去

在使用线程的时候，一个很重要的问题是要避免多个线程对同一变量或其它资源的访问冲突。一旦你稍不留神，重叠访问、在多个线程中修改（共享资源）等这些作会导致各种各样的问题；更的是，这些问题一般只会在比较极端（比如高并发、生产、甚至在性能更好的硬件设备上）的情况下才会出现。

比如有这样一个情况：需要对一处理的次数

counter = 0

def process_():

global counter

... do soming with ...

counter += 1

如果你在多个线程中同时调用这个函数，你会发现counter的值不是那么准确。在大多数情况下它是对的，但有时它会比实际的少几个。

出现这种情况的原因是，计数增加作实际上分三步执行:

解释器获取counter的当前值计算新值将计算的新值回写counter变量

考虑一下这种情况：在当前线程获取到counter值后，另一个线程抢占到了CPU，然后同样也获取到了counter值，并进一步将counter值重新计算并完成回写；之后时间片重新轮到当前线程（这里仅作标识区分，并非实际当前），此时当前线程获取到counter值还是原来的，完成后续两步作后counter的值实际只加上1。

另一种常见情况是访问不完整或不一致状态。这类情况主要发生在一个线程正在初始化或更新数据时，另一个进程却尝试读取正在更改的数据。

原子作

实现对共享变量或其它资源的同步访问最简单的方法是依靠解释器的原子作。原子作是在一步完成执行的作，在这一步中其它线程无法获得该共享资源。

通常情况下，这种同步方法只对那些只由单个核心数据类型组成的共享资源有效，譬如，字符串变量、数字、列表或者字典等。下面是几个线程安全的作：

读或者替换一个实例属性读或者替换一个全局变量从列表中获取一项元素原位修改一个列表（例如：使用append增加一个列表项）从字典中获取一项元素原位修改一个字典（例如：增加一个字典项、调用clear方法）

注意，上面提到过，对一个变量或者属性进行读作，然后修改它，最终将其回写不是线程安全的。因为另外一个线程会在这个线程读完却没有修改或回写完成之前更改这个共享变量/属性。

锁锁是Python的threading模块提供的最基本的同步机制。在任一时刻，一个锁对象可能被一个线程获取，或者不被任何线程获取。如果一个线程尝试去获取一个已经被另一个线程获取到的锁对象，那么这个想要获取锁对象的线程只能暂时终止执行直到锁对象被另一个线程释放掉。

锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：

lock = Lock()

lock.acquire() #: will block if lock is already held

... access shared resource

lock.release()

注意，即使在访问共享资源的过程中出错了也应该释放锁，可以用try-finally来达到这一目的：

lock.acquire()

try:

... access shared resource

finally:

在Python 2.5及以后的版本中，你可以使用with语句。在使用锁的时候，with语句会在进入语句块之前自动的获取到该锁对象，然后在语句块执行完成后自动释放掉锁：

from __future__ import with_statement #: 2.5 only

with lock:

... access shared resource

acquire方法带一个可选的等待标识，它可用于设定当有其它线程占有锁时是否阻塞。如果你将其值设为False，那么acquire方法将不再阻塞，只是如果该锁被占有时它会返回False:

if not lock.acquire(False):

... 锁资源失败

else:

try:

... access shared resource

finally:

lock.release()

你可以使用locked方法来检查一个锁对象是否已被获取，注意不能用该方法来判断调用acquire方法时是否会阻塞，因为在locked方法调用完成到下一条语句（比如acquire）执行之间该锁有可能被其它线程占有。

if not lock.locked():

#: 其它线程可能在下一条语句执行之前占有了该锁

lock.acquire() #: 可能会阻塞

简单锁的缺点

标准的锁对象并不关心当前是哪个线程占有了该锁；如果该锁已经被占有了，那么任何其它尝试获取该锁的线程都会被阻塞，即使是占有锁的这个线程。考虑一下下面这个例子：

lock = threading.Lock()

lock.acquire()

try:

finally:

lock.release()

return data

def get_second_part():

lock.acquire()

try:

... 从共享对象中获取第二部分数据

finally:

lock.release()

return data

示例中，我们有一个共享资源，有两个分别取这个共享资源部分和第二部分的函数。两个访问函数都使用了锁来确保在获取数据时没有其它线程修改对应的共享数据。

现在，如果我们想添加第三个函数来获取两个部分的数据，我们将会陷入泥潭。一个简单的方法是依次调用这两个函数，然后返回结合的结果：

first = get_first_part()

seconde = get_second_part()

return first, second

这里的问题是，如有某个线程在两个函数调用之间修改了共享资源，那么我们最终会得到不一致的数据。最明显的解决方法是在这个函数中也使用lock:

lock.acquire()

try:

first = get_first_part()

seconde = get_second_part()

finally:

lock.release()

return first, second

然而，这是不可行的。里面的两个访问函数将会阻塞，因为外层语句已经占有了该锁。为了解决这个问题，你可以通过使用标记在访问函数中让外层语句释放锁，但这样容易失去控制并导致出错。幸运的是，threading模块包含了一个更加实用的锁实现：re-entrant锁。

Re-Entrant Locks (RLock)

RLock类是简单锁的另一个版本，它的特点在于，同一个锁对象只有在被其它的线程占有时尝试获取才会发生阻塞；而简单锁在同一个线程中同时只能被占有一次。如果当前线程已经占有了某个RLock锁对象，那么当前线程仍能再次获取到该RLock锁对象。

lock = threading.Lock()

lock.acquire()

lock.acquire() #: 这里将会阻塞

lock = threading.RLock()

lock.acquire()

lock.acquire() #: 这里不会发生阻塞

RLock的主要作用是解决嵌套访问共享资源的问题，就像前面描述的示例。要想解决前面示例中的问题，我们只需要将Lock换为RLock对象，这样嵌套调用也会OK.

lock = threading.RLock()

... see above

def get_second_part():

... see above

... see above

这样既可以单独访问两部分数据也可以一次访问两部分数据而不会被锁阻塞或者获得不一致的数据。

注意RLock会递归层级，因此记得在acquire后进行release作。

信号量是一个更高级的锁机制。信号量内部有一个计数器而不像锁对象内部有锁标识，而且只有当占用信号量的线程数超过信号量时线程才阻塞。这允许了多个线程可以同时访问相同的代码区。

semaphore = threading.BoundedSemaphore()

semaphore.acquire() #: counter减小

... 访问共享资源

semaphore.release() #: counter增大

当信号量被获取的时候，计数器减小；当信号量被释放的时候，计数器增大。当获取信号量的时候，如果计数器值为0，则该进程将阻塞。当某一信号量被释放，counter值增加为1时，被阻塞的线程（如果有的话）中会有一个得以继续运行。

semaphore = threading.BoundedSemaphore(max_connections)

如果你不传任何初始化参数，计数器的值会被初始化为1.

Python的threading模块提供了两种信号量实现。Semaphore类提供了一个无限大小的信号量，你可以调用release任意次来增大计数器的值。为了避免错误出现，使用BoundedSemaphore类，这样当你调用release的次数大于acquire次数时程序会出错提醒。

线程同步

Events

nt = threading.Event()

#: 一个客户端线程等待flag被设定

nt.wait()

nt.set()

nt.clear()

一旦标识被设定，wait方法就不做任何处理（不会阻塞），当标识被清除时，wait将被阻塞直至其被重新设定。任意数量的线程可能会等待同一个。

Conditions

条件是对象的高级版本。条件表现为程序中的某种状态改变，线程可以等待给定条件或者条件发生的信号。

下面是一个简单的生产者/消费者实例。首先你需要创建一个条件对象：

#: 表示一个资源的附属项

condition = threading.Condition()

生产者线程在通知消费者线程有新生成资源之前需要获得条件：

#: 生产者线程

... 生产资源项

condition.acquire()

... 将资源项添加到资源中

condition.notify() #: 发出有可用资源的信号

condition.release()

消费者必须获取条件（以及相关联的锁），然后尝试从资源中获取资源项：

#: 消费者线程

condition.acquire()

while True:

...从资源中获取资源项

if :

break

condition.wait() #: 休眠，直至有新的资源

condition.release()

... 处理资源

wait方法释放了锁，然后将当前线程阻塞，直到有其它线程调用了同一条件对象的notify或者notifyAll方法，然后又重新拿到锁。如果同时有多个线程在等待，那么notify方法只会唤醒其中的一个线程，而notifyAll则会唤醒全部线程。

为了避免在wait方法处阻塞，你可以传入一个超时参数，一个以秒为单位的浮点数。如果设置了超时参数，wait将会在指定时间返回，即使notify没被调用。一旦使用了超时，你必须检查资源来确定发生了什么。

注意，条件对象关联着一个锁，你必须在访问条件之前获取这个锁；同样的，你必须在完成对条件的访问时释放这个锁。在生产代码中，你应该使用try-finally或者with.

可以通过将锁对象作为条件构造函数的参数来让条件关联一个已经存在的锁，这可以实现多个条件公用一个资源：

lock = threading.RLock()

condition_1 = threading.Condition(lock)

condition_2 = threading.Condition(lock)

互斥锁同步

我们先来看一个例子：

#!/usr/bin/env python

# -- coding: utf-8 --

import time, threading

# 定这是你的银行存款:

balance = 0

muxlock = threading.Lock()

def change_it(n):

global balance

balance = balance + n

balance = balance - n

def run_thread(n):

# 循环次数一旦多起来，的数字就变成非0

for i in range(100000):

change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))

t2 = threading.Thread(target=run_thread, args=(8,))

t3 = threading.Thread(target=run_thread, args=(9,))

t2.start()

t3.start()

t1.join()

t2.join()

t3.join()

print balance

结果 :

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

61

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

24

上面的例子引出了多线程编程的最常见问题：数据共享。当多个线程都修改某一个共享数据的时候，需要进行同步控制。

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。互斥锁为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

#创建锁mutex = threading.Lock()

#锁定mutex.acquire([timeout])

#释放mutex.release()

其中，锁定方法acquire可以有一个超时时间的可选参数timeout。如果设定了timeout，则在超时后通过返回值可以判断是否得到了锁，从而可以进行一些其他的处理。

使用互斥锁实现上面的例子的代码如下：

balance = 0

muxlock = threading.Lock()

def change_it(n):

# 获取锁，确保只有一个线程作这个数

muxlock.acquire()

global balance

balance = balance + n

balance = balance - n

# 释放锁，给其他被阻塞的线程继续作

muxlock.release()

def run_thread(n):

for i in range(10000):

change_it(n)

加锁后的结果，就能确保数据正确：

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

Python作业，求大神帮助~

def get_first_part():

class Time:

# 先存后取，结果应该为0:

def __init__(self,hour,minute,second):

self.SetTime(hour,minute,second)

def SetTime(self,hour,minute,second):

self.hour,self.minute,self.second=hour,minute,second

def AddOneSec(self):

if self.second==60:

self.second=0

if self.minute==60:

self.hour+=1

if self.hour==24:

self.hour=0

def PrintTime(self):

print("{0:02d}:{1:02d}:{2:02d}".format(

self.hour,self.minute,self.second))

python基础教程 10-11例子如何执行

def get_both_parts():

10. 模块相关

Python的标准安装包包括一组模块，称为标准库（standard library）。

10.1 模块

10.1.1 模块是程序

# hello.pyprint "Hello, world!"# 保存放在C:python# 告诉解释器在哪里寻找模块>>> import sys>>> sys.path.append('c:/python')# 这样，解释器除了从默认的目录中寻找之外，还需要从目录c:python中寻找模块>>> import hello

Hello, world!1234567801112

导入模块多次和导入一次的效果是一样的。如果坚持重新载入模块，可以使用内建的reload函数。

10.1.2 模块用于定义

在模块中定义函数

# hello2.pydef hello():

print "Hello, world# 使用import hello2

hello2.hello()1234567

在模块中增加测试代码

为 “告知” 模块本身是作为程序运行还是导入到其他程序，需要使用__name__变量：

# hello4.pydef hello():

hello()if __name__ == '__main__': test()123456789

10.1.3 让模块可用

将模块放置在正确位置

# 下面命令列出的路径都可以放置，但site-packages目录是选择>>> import sys, pprint>>> pprint.pprint(sys.path)123

告诉编译器去哪里找

除了编辑sys.path外，更通用的方法是设置环境变量PYTHONPATH

10.1.4 包

当模块存储在文件中时（扩展名.py），包就是模块所在的目录。为了让Python将其作为包对待，它必须包含一个命名为__init__py的文件（模块）。如果将它作为普通模块导入的话，文件的内容就是包的内容。

vim constants/__init__.py

PI=3.14# 别的地方引用import constantsprint constants.PI1234567

10.2 探究模块

10.2.1 模块中有什么

使用dir

查看模块包含的内容，它会将对象（以及模块的所有函数、类、变量等）的所有特性列出。

# 导入模块

import copy# 列表推导式是个包含dir(copy)中所有不以下划线开头的名字的列表。

[n for n in dir(copy)] if not n.startwith('_')]12345

__all__变量

这个变量包含一个列表，该列表与上一节的列表类似。

copy.__all__1

它定义了模块的共有接口，在编写模块的时候，像设置__all__这样的技术是相当有用的。

__all__ = ["Error", "copy", "deepcopy"]1

10.2.2 用获取帮助

使用函数，获得帮助文本。

(copy.copy)1

10.2.3 文档

参考

10.2.4 使用源代码

方案一：检查sys.path，然后自己找。

方案二：检查模块的__file__属性

10.3 标准库

10.3.1 sys

sys这个模块能够访问与Python解释器联系紧密的变量和函数。部分重要函数和变量如下：

函数/变量

描述

argv 命令行参数，包括传递到Python解释器的参数，脚本名称

exit([arg]) 退出当前的程序，可选参数为给定的返回值或错误信息

modules 映射模块名字到载入模块的字典

path 查找模块所在目录的目录名列表

platform 类似sunos5或win32的平台标识符

stdin 标准输入流——一个类文件（file-like）对象

st1.start()tdout 标准输出流

stderr 标准错误流

10.3.2 os

os模块提供了访问多个作系统服务的功能。下表列出一些最有用的函数和变量。另外，os和它的子模块os.path还包含一些用于检查、构造、删除目录和文件的函数，以及一些处理路径的函数（例如，os.path.split和os.path.join让你在大部分情况下都可以忽略os.pathsep）。

函数/变量

描述

environ 对环境变量进行映射

(command) 在子shell中执行作系统命令

sep 路径中的分隔符

pathsep 分隔路径的分隔符

linesep 行分隔符

urandom(n) 返回n个字节的加密强随机数据

10.3.3 fileinput

fileinput模块能够轻松地遍历文本文件的所有行。

函数/变量

描述

input([files[, inplace[, backup]]]) 便于遍历多个输入流中的行

filename() 返回当前文件的名称

lineno() 返回当前（累计）的行数

filelineno() 返回当前文件的行数

isfirstline() 检查当前行是否是文件的行

isstdin() 检查一行是否来自sys.stdin

nextfile() 关闭当前文件，移动到下一个文件

close() 关闭序列

# numberlines.pyimport fileinputfor line in fileinput.input(inplcae=True) line = line.rstrip() num = fileinput.lineno()

print '%-40s # %2i' % (line, num)12345678

10.3.4 、堆和双端队列

Set类位于sets模块中。非重复、无序的序列。

堆堆（heap）是优先队列的一种。使用优先队列能够以任意顺序增加对象，并且能在任何时间找到最小的元素，也就是说它比用于列表的min方法要得多。下面是heapq模块中重要的函数：

函数

描述

heappush(heap, x) 将x入堆

heappop(heap) 将堆中最小的元素弹出

heapify(heap) 将heap属性强制应用到任意一个列表，将其转换为合法的堆

heapreplace(heap, x) 将堆中最小的元素弹出，同时将x入堆

nlargest(n, iter) 返回iter中第n大的元素

nallest(n, iter) 返回iter中第n小的元素

元素虽然不是严格排序的，但是也有规则：i位置处的元素总比2i以及2i+1位置处的元素小。这是底层堆算法的基础，而这个特性称为堆属性（heap property）。

双端队列（以及其他类型）

双端队列（Double-ended queue）在需要按照元素增加的顺序来移除元素时非常有用。它能够有效地在开头增加和弹出元素，这是在列表中无法实现的，除此之外，使用双端队列的好处还有：能够有效地旋转（rotate）元素。deque类型包含在collections模块。

10.3.5 time

time模块所包含的函数能够实现以下功能：获得当前时间、作时间和日期、从字符串读取时间以及格式化时间为字符串。日期可以用实数或者包含有9个整数的元组。元组意义如下：

索引

字段

值0 年 比如2000等

1 月 范围1~12

2 日 范围1~31

3 时 范围0~23

4 分 范围0~59

5 秒 范围0~61（应付闰秒和双闰秒）

6 周 当周一为0时，范围0~6

7 儒历日 范围1~366

8 夏令日 0、1、-1

time的重要函数：

函数

描述

asctime([tuple]) 将时间元组转换为字符串

localtime([secs]) 将秒数转换为日期元组，以本地时间为准

mktime(tuple) 将时间元组转换为本地时间

sleep(secs) 休眠secs秒

strptime(string[, format]) 将字符串解析为时间元组

time() 当前时间（新纪元开始后的秒数，以UTC为准）

10.3.6 random

random模块包括返回随机数的函数，可以用于模拟或者用于任何产出随机输出的程序。

如果需要真的随机数，应该使用os模块的urandom函数。random模块内的SystemRandom类也是基于同样功能。

函数

描述

random() 返回0 <= n < 1之间的随机实数n，其中0 < n <=1

getrandbits(n) 以长整型形式返回n个随机位

uniform(a, b) 返回随机实数n，其中 a <= n < b

randrange([start], stop, [step]) 返回range(start, stop, step)中的随机数

cho(seq) 从序列seq中返回随机元素

shuffle(seq[, random]) 原地指定序列seq

sample(seq, n) 从序列seq中选择n个随机且的元素

示例一：

from random import from time import

date1 = (2008, 1, 1, 0, 0, 0, -1, -1, -1)

time1 = mktime(date1)

date2 = (2009, 1, 1, 0, 0, 0, -1, -1, -1)

time2 = mktime(date2)

random_time = uniform(time1, time2)print asctime(localtime(random_time))123456780

提供一个存储方案。shelve的open函数返回一个Shelf对象，可以用它来存储内容。只需要把它当做普通的字典来作即可，在完成工作之后，调用close方法。

import shelve

s = shelve.open('test.dat')

s['x'] = ['a', 'b', 'c']# 下面代码，d的添加会失败# s['x'].append('d')# s['x']# 正确应该使用如下方法：temp = s['x']

temp.append('d')

s['x'] = temp1234567801112

10.3.8 re

re模块包含对正则表达式的支持。

正则表达式

.号只能匹配一个字符（除换行符外的任何单个字符）。

为转义字符

字符集：使用[]括起来，例如[a-zA-Z0-9]，使用^反转字符集

选择符（|）和子模式()：例如'p(ython|erl)'

可选项（在子模式后面加上问号）和重复子模式：例如r'(://)?(www.)?python，问号表示出现一次或根本不出现。 (pattern)：允许模式重复0次或多次

(pattern)+：允许模式重复1次或多次

(pattern){m,n}：允许模式重复m~n次

字符串的开始（^）和结尾（$）

所有的重复运算符都可以通过在其后面加上一个问号变成非贪婪版本，例如：r'(.+?)'

re模块的内容

re模块中一些重要的函数

函数

描述

compile(pattern[, flags]) 根据包含正则表达式的字符串创建模式对象

search(pattern, string[, flags]) 在字符串中寻找模式

match(pattern, string[, flags]) 在字符串的开始处匹配模式

sub(pat, repl, string[, count=0]) 将字符串中所有pat的匹配项用repl替换

escape(string) 将字符串中所有特殊正则表达式字符转义

匹配对象和组

对于re模块中那些能够对字符串进行模式匹配的函数而言，当能找到匹配项时，返回MatchObject对象。包含了哪个模式匹配了子字符串的哪部分的信息。——这些“部分”叫做组。

组就是放置在圆括号内的子模式。组的序号取决于它左侧的括号数。组0就是整个模式。

re匹配对象的一些方法：

描述

group([group1, …]) 获取给定子模式（组）的匹配项

start([group]) 返回给定组的匹配项的开始位置

end([group]) 返回给定组的匹配项的结束位置（和分片一样，不包括组的结束位置）

span([group]) 返回一个组的开始和结束位置

作为替换的组号和函数

示例：设要把'soming'用soming替换掉：

emphasis_pattern = r'([^]+)'# 或者用VERBOSE标志加注释，它允许在模式中添加空白。emphasis_pattern = repile(r'''

# 开始的强调标签

( # 组开始

[^]+ # 除了星号的所有字符

) # 组结束

# 结束的强调标签

''', re.VERBOSE)

re.sub(emphasis_pattern, r'1', 'Hello, world!')# 结果'Hello, world!'123456780111213141516

找出Email的发信人

# 示例一# 匹配内容：From: Foo Fie # find_sender.pyimport fileinput, re

pat = repile('From: (.) <.?>$')for line in fileinput.input():

m = pat.match(line) if m: print m.group(1)# 执行$ python find_sender.py message.eml# 示例二# 列出所有Email地址import fileinput, re

pat = repile(r'[a-z-.]+@[a-z-.]+', re.IGNORECASE)

addresses = set()for line in fileinput.input(): for address in pat.findall(line):

addresses.add(address)for address in sorted(addresses): print address123456780111213141516171819202122

模板系统示例

模板是一种通过放入具体值从而得到某种已完成文本的文件。

示例：把所有'[somings]'（字段）的匹配项替换为通用Python表达式计算出来的soming结果

'The sum of 7 and 9 is [7 + 9].'

应该翻译成'The sum of 7 and 9 is 16.'

同时，可以在字段内进行赋值

'[name="Mr. Gumby"]Hello, [name]'

应该翻译成'Hello, Mr. Gumby'12345678

代码如下

# templates.py#!/usr/bin/python# -- coding: utf-8 --import fileinput, re# 匹配中括号里的字段field_pat = repile(r'[(.+?)]')# 我们将变量收集到这里scope = {}# 用于re.sub中def replacement(match):

code = match.group(1) try: # 如果字段可以求值，返回它：

return str(eval(code, scope)) except SyntaxError: # 否则执行相同作用域内的赋值语句......

exec code in scope # ......返回空字符串

return ''# 将所有文本以一个字符串的形式获取lines = []for line in fileinput.input():

lines.append(line)

text = ''.join(lines)# 将field模式的所有匹配项都替换掉print field_pat.sub(replacement, text)1234567801112131415161718192021222324252627282930313233

10.3.9 其他标准模块

functools：能够通过部分参数来使用某个函数（部分求值），稍后再为剩下的参数提供数值。

difflib：可以计算两个序列的相似程度。还能从一些序列中（可供选择的序列列表）找出和提供的原始序列“最像”的那个。可以用于创建简单的搜索程序。

hashlib：可以通过字符串计算小“签名”。

csv：处理CSV文件

timeit、profile和trace：timeit（以及它的命令行脚本）是衡量代码片段运行时间的工具。它有很多神秘的功能，应该用它代替time模块进行性能测试。profile模块（和伴随模块pstats）可用于代码片段效率的全面分析。trace模块（和程序）可以提供总的分析（覆盖率），在写测试代码时很有用。

datetime：支持特殊的日期和时间对象，比time的接口更直观。

itertools：有很多工具用来创建和联合迭代器（或者其他可迭代对象），还包括实现以下功能的函数：将可迭代的对象链接起来、创建返回无限连续整数的迭代器（和range类似，但没有上限），从而通过重复访问可迭代对象进行循环等等。

logging：输出日志文件。

getopt和optparse：在UNIX中，命令行程序经常使用不同的选项或开关运行。getopt为解决这个问题的。optparse则更新、更强大。

cmd：可以编写命令行解释器。可以自定义命令。

10.4 新函数

函数

描述

dir(obj) 返回按字母顺序排序的属性名称列表

([obj])

reload(module)

11. 文件

11.1 打开文件

open函数用来打开文件，语法如下：

open(name[, mode[, buffering]])1

11.1.1 文件模式

默认只读打开。

值描述

‘r’ 读模式

‘w’ 写模式

‘a’ 追加模式

‘b’ 二进制模式（可添加到其他模式中使用）

‘+’ 读/写模式（可添加到其他模式中使用）

11.1.2 缓存

open函数的第三个参数（可选）控制文件的缓冲。有缓冲时，只有使用flush或close时才会更新硬盘上的数据。

值描述

0或False 无缓冲

1或True 有缓冲

大于1的数字 缓冲区大小（字节）

-1或负数 默认的缓冲区大小

11.2 基本文件方法

11.2.1 读和写

>>> f = open('somefile.txt', 'w')>>> f.write('Hello, ')>>> f.write('World!')>>> f.close()>>> f = open('somefile.txt', 'r')>>> f.read(4) # 读取的字符数（字节）'Hell'>>> f.read()'o, World!'123456780

11.2.2 管式输出# somescript.pyimport systext = sys.stdin.read()words = text.split()

wordcount = len(words)

Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件作、函数、装饰器、迭代器、内置方法、常用模块等。

Python基础语法、文件作、函数、数据类型、字符编码、装饰器、迭代器、内置方法、常用模块等。

python教程：链接: 提取码: ad4p

使用Python进行邮箱业务的模拟，但是一直找不到对应元素，请求帮忙

max_connections = 10

同样的代码可以执行，你执行有问题出在了页面刚加载出来webdriver 就去find 元素，这个时候DOM元素还没有完全加载出来。所以要在打开后的代码中加一个sleep，停2s在执行。

time.sleep锁可以用在线程间的同步上。threading模块包含了一些用于线程间同步的类。(2) # 休眠2秒

python time.sleep 随机数

Semaphores

你可以查看一下帮助。比如这样子

split(pattern, string[, maxsplit=0]) 根据模式的匹配项来分隔字符串

Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (In)] on win32

Type "", "copyright", "credits" or "lnse" for more rmation.

>>> (time.sleep)

Help on built-in function sleep in module time:

sleep(...)

sleep(seconds)

Delay execution for a given number of seconds. The argument may be

a floating point number for subsecond precision.

Traceback (most recent call last):

File "", line 1, in

TypeError: sleep() takes exactly 1 argument (2 given)从帮助里可以看到。sleep(这里里允许时间秒）秒可以是浮点数。但是不允许多个参数。

如果想随机可以使用random

比如

import random,time

time.sleep(random.randint(5,30))

Python求数列前n项的平方和

众所周知，最简单的 daemon 运行的方式就是在命令后加 &，再配合将输出重定向到一个 log 文件，这样就可以实现即以 daemon 跑，也能随时查看 output 和error 相关的信息。比如

import time #用于结尾的等待

over=0 #新建一个列表来存储数据

into=0

into=int(input('输入n是多少：'))#不嫌麻烦的话可以加一个try except防止出错

for i in range(1,into+1):

over=ii+over

print('结果是',over)

time.sleep(1)#等待1秒，不需要可以删除

防止 python deamon 进程掉

#: 服务端线程设置或者清除flag

最近需要在一台 remote 的 gpu 机器上跑 training 的脚本，terminal 不可能一直开着，所以肯定都是要以 daemon 方式来跑。

print "Hello, world!"def test():

不过最近几天，我发现每次到公司查看昨晚上的任务情况，都发现进程在我下班后不久就掉，output.log 中也没有任何的错误信息。实在是相当诡异。

google 了一番，没什么有建设性的意见，一开始以为是不是 & 方式的 daemon 天生有缺陷，还研究半天怎么用 python fork 出 daemon process。但越试越感觉，可能这个不是主要原因，在玩了几次 python-daemon 之后，还是决定回到源头尝试解决。

其中有一个回答提到了可能因为脚本占用内存过大导致被系统 kill 掉(OOM)，这个时候脚本本身是不会输出错误的。于是就去 /var/log/.log 里边儿翻 OOM，结果 OOM 没翻到到翻到了一个 "Received SIGRTMIN+24 from PID 27041 (kill)." , 继续 google 了一下发现。这是系统进程 d 发出的信号，（d 可以理解为调度 daemon process 的进程）。

为什么 d 没事儿会来干我的脚本呢？ 因为 d 默认会在一个 user detach 的时候，干掉这个 user 启动的所有 process，不管你是不是 daemon。所以当我的本地电脑休眠超过一定时间时，远程的机器自动 logout user, 然后触发 d 干掉了我的脚本，即便我的脚本有 & 加持。

知道问题的原因那就简单了，简单 google 一下就能知道, 我们只需要修改 /etc/d/logind.conf 中，将 KillUserProcesses=no 反 comment 即可。代表让 d 不要干掉 user process。

Python如何实现页面滚动？

findall(pattern, string) 列出字符串中模式的所有匹配项

使用selenium可以模拟人使用浏览器，我们在使用浏览器的时候滑动鼠标，然后等待网页加载新的内容。同样的，我们可以使用selenium模拟浏览器继续向下滑动作。首先使用execute_script()方法模拟鼠标向下滑页面，括号中填入滑动距离的js，例如window.scrollBy(0,1000)就表示向下滑动1000个距离。由于加载内容需要时间，我们可以使用Python中time模块的sleep方法使程序休眠一段时间，等待内容加载完成。

信号量通常被用来限制对容量有限的资源的访问，比如一个网络连接或者数据库。在这类场景中，只需要将计数器初始化为值，信号量的实现将为你完成剩下的事情。

树莓派（linux）怎么每1秒执行一次python脚本呢 越简单越好 谢谢

10.3.7 shelve

可以利用Linux的定时任务

输入crontab

-e，对定时任务进行编辑

格式是：“任务重复的时间

执行的命令”

任务重self.minute=0复的时间有专门的格式

每秒重复一次就需要添加一行

/1

python

xxx.py