Category Archives: Python

十一 06

Python MySQL使用持久连接

Posted on by

python连接mysql中没有长连接的概念，但我们可以利用mysql的ping机制，来实现长连接功能~
思路:
1 python mysql 的cping 函数会校验连接的可用性,如果连接不可用将会产生异常
2 利用这一特性，构造一个连接丢失的循环，不断尝试连接数据库，直到连接恢复
3 使用这样的机制不需要关闭数据库功能,对于驻留进程，有大量数据进行写操作时，很有用途

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#!/usr/bin/env python  
# -*-coding:UTF-8-*-  
import sys,MySQLdb,traceback  
import time  
class mysql:  
    def __init__ (self,  
                  host   = '',  
                  user   = '',  
                  passwd = '',  
                  db     = '',  
                  port   = 3306,  
                  charset= 'utf8'  
                  ):  
        self.host   = host  
        self.user   = user  
        self.passwd = passwd  
        self.db     = db  
        self.port   = port  
        self.charset= charset  
        self.conn   = None  
        self._conn()  
 
    def _conn (self):  
        try:  
            self.conn = MySQLdb.Connection(self.host, self.user, self.passwd, self.db, self.port , self.charset)  
            return True  
        except :  
            return False  
 
    def _reConn (self,num = 28800,stime = 3): #重试连接总次数为1天,这里根据实际情况自己设置,如果服务器宕机1天都没发现就......  
        _number = 0  
        _status = True  
        while _status and _number <= num:  
            try:  
                self.conn.ping()       #cping 校验连接是否异常  
                _status = False  
            except:  
                if self._conn()==True: #重新连接,成功退出  
                    _status = False  
                    break  
                _number +=1  
                time.sleep(stime)      #连接不成功,休眠3秒钟,继续循环，知道成功或重试次数结束  
 
    def select (self, sql = ''):  
        try:  
            self._reConn()  
            self.cursor = self.conn.cursor(MySQLdb.cursors.DictCursor)  
            self.cursor.execute (sql)  
            result = self.cursor.fetchall()  
            self.cursor.close ()  
            return result  
        except MySQLdb.Error,e:  
            #print "Error %d: %s" % (e.args[0], e.args[1])  
            return False  
 
    def select_limit (self, sql ='',offset = 0, length = 20):  
        sql = '%s limit %d , %d ;' % (sql, offset, length)  
        return self.select(sql)  
 
    def query (self, sql = ''):  
        try:  
            self._reConn()  
            self.cursor = self.conn.cursor(MySQLdb.cursors.DictCursor)  
            self.cursor.execute ("set names utf8") #utf8 字符集  
            result = self.cursor.execute (sql)  
            self.conn.commit()  
            self.cursor.close ()  
            return (True,result)  
        except MySQLdb.Error, e:  
            return False  
 
    def close (self):  
        self.conn.close()  
 
if __name__=='__main__':  
    my = mysql('localhost','root','password','database',3306)  
    print my.select_limit('select * from sdb_admin_roles',1,1)  
    #my.close()

 

十一 06

python MySQLdb中cursor操作数据库

Posted on by

python 操作数据库，要安装一个Python和MySQLdb，这样就可以进行数据库操作了。

操作步骤如下：

1、建立数据库连接

import MySQLdb
conn=MySQLdb.connect(host=”localhost”,user=”root”,passwd=”sa”,db=”mytable”)
cursor=conn.cursor()

2、执行数据库操作

n=cursor.execute(sql,param)
我们要使用连接对象获得一个cursor对象,接下来,我们会使用cursor提供的方法来进行工作.
这些方法包括两大类:1.执行命令,2.接收返回值

3、cursor用来执行命令的方法:

callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
executemany(self, query, args):执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
nextset(self):移动到下一个结果集

4、cursor用来接收返回值的方法:

fetchall(self):接收全部的返回结果行.
fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
fetchone(self):返回一条结果行.
scroll(self, value, mode=’relative’):移动指针到某一行.如果mode=’relative’,则表示从当前所在行移动value条,如果mode=’absolute’,则表示从结果集的第一 行移动value条.

5、下面的代码是一个完整的例子.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#使用sql语句,这里要接收的参数都用%s占位符.要注意的是,无论你要插入的数据是什么类型,占位符永远都要用%s
sql="insert into cdinfo values(%s,%s,%s,%s,%s)"
#param应该为tuple或者list
param=(title,singer,imgurl,url,alpha)
#执行,如果成功,n的值为1
n=cursor.execute(sql,param)
#再来执行一个查询的操作
cursor.execute("select * from cdinfo")
#我们使用了fetchall这个方法.这样,cds里保存的将会是查询返回的全部结果.每条结果都是一个tuple类型的数据,这些tuple组成了一个tuple
cds=cursor.fetchall()
#因为是tuple,所以可以这样使用结果集
print cds[0][3]
#或者直接显示出来,看看结果集的真实样子
print cds
#如果需要批量的插入数据,就这样做
sql="insert into cdinfo values(0,%s,%s,%s,%s,%s)"
#每个值的集合为一个tuple,整个参数集组成一个tuple,或者list
param=((title,singer,imgurl,url,alpha),(title2,singer2,imgurl2,url2,alpha2))
#使用executemany方法来批量的插入数据.这真是一个很酷的方法!
n=cursor.executemany(sql,param)

需要注意的是(或者说是我感到奇怪的是),在执行完插入或删除或修改操作后,需要调用一下conn.commit()方法进行提交.这样,数据才会真正保 存在数据库中.如果不用commit,那数据就不会保留在数据库中,但是,数据 确实在数据库呆过.因为自动编号进行了累积,而且返回的受影响的行数并不为0.

6、关闭数据库连接

需要分别的关闭指针对象和连接对象.他们有名字相同的方法
cursor.close()
conn.close()

Django操作数据库
django是一个出色的用于python的web框架。django连接有操作数据库的api，使用起来十分简洁。我们在settings.py中配置好所要连接的数据库，然后在modules、view、urls中分别写好业务逻辑

十一 06

命令行运行Python脚本时传入参数的三种方式

Posted on by

如果在运行python脚本时需要传入一些参数，例如gpus与batch_size，可以使用如下三种方式。

0
1
2
python script.py 0,1,2 10
python script.py -gpus=0,1,2 --batch-size=10
python script.py -gpus=0,1,2 --batch_size=10

这三种格式对应不同的参数解析方式，分别为sys.argv, argparse, tf.app.run, 前两者是python自带的功能，后者是tensorflow提供的便捷方式。

sys.argv

sys模块是很常用的模块， 它封装了与python解释器相关的数据，例如sys.modules里面有已经加载了的所有模块信息，sys.path里面是PYTHONPATH的内容，而sys.argv则封装了传入的参数数据。
使用sys.argv接收上面第一个命令中包含的参数方式如下：

0
1
2
3
4
5
import sys
gpus = sys.argv[1]
#gpus = [int(gpus.split(','))]
batch_size = sys.argv[2]
print gpus
print batch_size

需要模块：sys
参数个数：len(sys.argv)
脚本名：    sys.argv[0]
参数1：     sys.argv[1]
参数2：     sys.argv[2]

test.py

0
1
2
3
4
5
import sys
print "脚本名：", sys.argv[0]
for i in range(1, len(sys.argv)):
    print "参数", i, sys.argv[i]
 
>>>python test.py hello world

脚本名：test.py
参数 1 hello
参数 2 world

python中使用命令行选项：
例如我们需要一个convert.py脚本。它的作用是处理一个文件,并将处理后的结果输出到另一个文件中。
要求该脚本满足以下条件：
1.通过-i -o选项来区别参数是输入文件还是输出文件.
>>> python convert.py -i inputfile -o outputfile
2.当不知道convert.py需要哪些参数时，用-h打印出帮助信息
>>> python convert.py -h

getopt函数原形:
getopt.getopt(args, options[, long_options])

convert.py

0
1
2
3
4
5
6
7
8
9
10
11
12
import sys, getopt
 
opts, args = getopt.getopt(sys.argv[1:], "hi:o:")
input_file=""
output_file=""
for op, value in opts:
    if op == "-i":
        input_file = value
    elif op == "-o":
        output_file = value
    elif op == "-h":
        usage()
        sys.exit()

代码解释：
a) sys.argv[1:]为要处理的参数列表，sys.argv[0]为脚本名，所以用sys.argv[1:]过滤掉脚本名。
b) ”hi:o:”: 当一个选项只是表示开关状态时，即后面不带附加参数时，在分析串中写入选项字符。当选项后面是带一个附加参数时，在分析串中写入选项字符同时后面加一个”:”号。所以”hi:o:”就表示”h”是一个开关选项；”i:”和”o:”则表示后面应该带一个参数。
c) 调用getopt函数。函数返回两个列表：opts和args。opts为分析出的格式信息。args为不属于格式信息的剩余的命令行参数。opts是一个两元组的列表。每个元素为：(选项串,附加参数)。如果没有附加参数则为空串”。

getopt函数的第三个参数[, long_options]为可选的长选项参数，上面例子中的都为短选项(如-i -o)
长选项格式举例:
--version
--file=error.txt
让一个脚本同时支持短选项和长选项
getopt.getopt(sys.argv[1:], "hi:o:", ["version", "file="]) Continue reading →

十一 06

python的日志模块logging

Posted on by

1.简单的将日志打印到屏幕

0
1
2
3
4
import logging
 
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')

 

屏幕上打印:
WARNING:root:This is warning message
默认情况下，logging将日志打印到屏幕，日志级别为WARNING；
日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，当然也可以自己定义日志级别。
2.通过logging.basicConfig函数对日志的输出格式及方式做相关配置

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import logging
 
logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')
 
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
./myapp.log文件中内容为:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

 

logging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，’w'或’a’
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
%(levelno)s: 打印日志级别的数值
%(levelname)s: 打印日志级别名称
%(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s: 打印当前执行程序名
%(funcName)s: 打印日志的当前函数
%(lineno)d: 打印日志的当前行号
%(asctime)s: 打印日志的时间
%(thread)d: 打印线程ID
%(threadName)s: 打印线程名称
%(process)d: 打印进程ID
%(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
level: 设置日志级别，默认为logging.WARNING
stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略
3.将日志同时输出到文件和屏幕

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import logging
 
logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')
 
#################################################################################################
#定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
#################################################################################################
 
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
屏幕上打印:
root        : INFO     This is info message
root        : WARNING  This is warning message
./myapp.log文件中内容为:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

 

4.logging之日志回滚

0
1
2
3
4
5
6
7
8
9
10
import logging
from logging.handlers import RotatingFileHandler
 
#################################################################################################
#定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M
Rthandler = RotatingFileHandler('myapp.log', maxBytes=10*1024*1024,backupCount=5)
Rthandler.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
Rthandler.setFormatter(formatter)
logging.getLogger('').addHandler(Rthandler)
################################################################################################

 

从上例和本例可以看出，logging有一个日志处理的主对象，其它处理方式都是通过addHandler添加进去的。
logging的几种handle方式如下：

0
1
2
3
4
5
6
7
8
9
10
11
12
logging.StreamHandler: 日志输出到流，可以是sys.stderr、sys.stdout或者文件
logging.FileHandler: 日志输出到文件
日志回滚方式，实际使用时用RotatingFileHandler和TimedRotatingFileHandler
logging.handlers.BaseRotatingHandler
logging.handlers.RotatingFileHandler
logging.handlers.TimedRotatingFileHandler
logging.handlers.SocketHandler: 远程输出日志到TCP/IP sockets
logging.handlers.DatagramHandler:  远程输出日志到UDP sockets
logging.handlers.SMTPHandler:  远程输出日志到邮件地址
logging.handlers.SysLogHandler: 日志输出到syslog
logging.handlers.NTEventLogHandler: 远程输出日志到Windows NT/2000/XP的事件日志
logging.handlers.MemoryHandler: 日志输出到内存中的制定buffer
logging.handlers.HTTPHandler: 通过"GET"或"POST"远程输出到HTTP服务器

 

由于StreamHandler和FileHandler是常用的日志处理方式，所以直接包含在logging模块中，而其他方式则包含在logging.handlers模块中，
上述其它处理方式的使用请参见python2.5手册！
5.通过logging.config模块配置日志

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#logger.conf
###############################################
[loggers]
keys=root,example01,example02
[logger_root]
level=DEBUG
handlers=hand01,hand02
[logger_example01]
handlers=hand01,hand02
qualname=example01
propagate=0
[logger_example02]
handlers=hand01,hand03
qualname=example02
propagate=0
###############################################
[handlers]
keys=hand01,hand02,hand03
[handler_hand01]
class=StreamHandler
level=INFO
formatter=form02
args=(sys.stderr,)
[handler_hand02]
class=FileHandler
level=DEBUG
formatter=form01
args=('myapp.log', 'a')
[handler_hand03]
class=handlers.RotatingFileHandler
level=INFO
formatter=form02
args=('myapp.log', 'a', 10*1024*1024, 5)
###############################################
[formatters]
keys=form01,form02
[formatter_form01]
format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s
datefmt=%a, %d %b %Y %H:%M:%S
[formatter_form02]
format=%(name)-12s: %(levelname)-8s %(message)s
datefmt=

上例3：

0
1
2
3
4
5
6
7
8
import logging
import logging.config
 
logging.config.fileConfig("logger.conf")
logger = logging.getLogger("example01")
 
logger.debug('This is debug message')
logger.info('This is info message')
logger.warning('This is warning message')

上例4：

0
1
2
3
4
5
6
7
8
import logging
import logging.config
 
logging.config.fileConfig("logger.conf")
logger = logging.getLogger("example02")
 
logger.debug('This is debug message')
logger.info('This is info message')
logger.warning('This is warning message')

 

十一 05

MySQLdb ImportError: libmysqlclient.so.18解决方法

Posted on by

ImportError: libmysqlclient.so.18: cannot open shared object file: No such file or directory

初装系统，运行制作完成的python项目，出现上面提示信息，说明缺少文件libmysqlclient.so.18，解决方案：

1、全局搜索libmysqlclient.so.18

# find / -name libmysqlclient.so.18

结果为：/www/wdlinux/mysql-5.5.58/lib/libmysqlclient.so.18

2、做软连接

32位系统
# ln -s /www/wdlinux/mysql-5.5.58/lib/libmysqlclient.so.18 /usr/lib/libmysqlclient.so.18

64位系统
# ln -s /www/wdlinux/mysql-5.5.58/lib/libmysqlclient.so.18 /usr/lib64/libmysqlclient.so.18

3、测试是否成功

# python
# import MySQLdb
#
如果这里不报错，则说明问题解决。

十一 05

初装CentOS6.x系统常用安装模块

Posted on by

CentOS安装zip、unzip

# yum install -y zip unzip

安装setuptools，下载页面https://pypi.org/project/setuptools/#files

# get https://pypi.python.org/packages/45/29/8814bf414e7cd1031e1a3c8a4169218376e284ea2553cc0822a6ea1c2d78/setuptools-36.6.0.zip#md5=74663b15117d9a2cc5295d76011e6fd1
# unzip setuptools-36.6.0.zip
# cd setuptools-36.6.0
# python setup.py install

安装pip，下载页面https://pypi.org/project/pip/#files

# wget https://pypi.python.org/packages/11/b6/abcb525026a4be042b486df43905d6893fb04f05aac21c32c638e939e447/pip-9.0.1.tar.gz#md5=35f01da33009719497f01a4ba69d63c9
# tar -zxvf pip-9.0.1.tar.gz
# cd pip-9.0.1.tar
# python setup.py install

十一 05

CentOS6.x安装python2.7.14

Posted on by

python安装,python多版本并存

1、 CentOS系统python默认版本是2.6.x，现在我们要在这种环境下安装2.7.14

　　python所有版本

　　下载：# wget https://www.python.org/ftp/python/2.7.14/Python-2.7.14.tar.xz

　　用xz解压工具：# xz -d Python-2.7.14.tar.xz

               　　　　   #tar -xf Python-2.7.14.tar

　　　　　　　　   进入安装文件目录进行安装

　　　　　　　　　#cd Python-2.7.14

　　　　　　　　　# ./configure

　　　　　　　　　# make

　　　　　　　　　# make install

2.1、 检查python版本，如果依然是2.6，则将系统指向的python从2.6修改到2.7版本

#/usr/local/bin/python2.7 -V
备份一份python
# mv /usr/bin/python  /usr/bin/python.bak
创建文件链接
# ln -s /usr/local/bin/python2.7 /usr/bin/python

2.2、分支：或者不使用2.1的方法和后续方法，直接在/usr/bin文件夹下创建python27文件链接，之后在使用python时的命令就使用python27就可以了，如果是想python2x与python3x并存的话创建文件链接就使用python3。方法如下：

创建python2.7版本的文件链接
# ln -s /usr/local/bin/python2.7 /usr/bin/python27

3、特别的，yum是基于python2.6才能正常工作，需单独将yum指向python2.6版本

命令：用vi打开yum文本
#vi /usr/bin/yum
将文件里的头一行，也就是指定python环境的那行代码!/usr/bin/python，修改成：!/usr/bin/python2.6

命令：# a：在光标后插入文本

Esc退出文本编辑，输入：#：wq 保存修改并退出vi编辑。

4、检查python版本：#python –v 可以看到版本是2.7了

5、其它，关于ln命令

ln -s 源文件 目标文件

举例：

在目录/usr/bin下创建一个名为python的/usr/local/bin/python2.7（这个文件）的链接，
# ln -s /usr/local/bin/python2.7 /etc/bin/python
建立两者之间的链接,
即访问/etc/bin/python时，实际是在访问/usr/local/bin/python2.7

十一 04

Python读写文件

Posted on by

Python读写文件
1.open
使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

0
1
2
3
4
file_object = open('thefile.txt')
try:
    all_the_text = file_object.read( )
finally:
    file_object.close( )

 

注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。

2.读文件
读文本文件
input = open('data', 'r')
#第二个参数默认为r
input = open('data')

 

读二进制文件
input = open('data', 'rb')

读取所有内容

0
1
2
3
4
file_object = open('thefile.txt')
try:
    all_the_text = file_object.read( )
finally:
    file_object.close( )

 

读固定字节

0
1
2
3
4
5
6
7
8
file_object = open('abinfile', 'rb')
try:
    while True:
        chunk = file_object.read(100)
        if not chunk:
            break
        do_something_with(chunk)
finally:
    file_object.close( )

 

读每行
list_of_all_the_lines = file_object.readlines( )

如果文件是文本文件，还可以直接遍历文件对象获取每行：

0
1
for line in file_object:
    process line

 

3.写文件
写文本文件
output = open('data', 'w')

写二进制文件
output = open('data', 'wb')

追加写文件
output = open('data', 'w+')

写数据
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )

写入多行
file_object.writelines(list_of_text_strings)

注意，调用writelines写入多行在性能上会比使用write一次性写入要高。

在处理日志文件的时候，常常会遇到这样的情况：日志文件巨大，不可能一次性把整个文件读入到内存中进行处理，例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件，我们可能希望每次只处理其中 200MB 的内容。
在 Python 中，内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例：

0
1
2
3
4
5
file = open('test.log', 'r')
sizehint = 209715200 # 200M
position = 0lines = file.readlines(sizehint)
while not file.tell() - position < 0:
    position = file.tell()
    lines = file.readlines(sizehint)

Continue reading →

十 16

Python程序中如何设置HTTP代理

Posted on by

urllib2/urllib 代理设置

urllib2是Python标准库，功能很强大，只是使用起来稍微麻烦一点。在Python 3中，urllib2不再保留，迁移到了urllib模块中。

urllib2中通过ProxyHandler来设置使用代理服务器。

0
1
2
3
4
import urllib2
proxy_handler = urllib2.ProxyHandler({'http': '121.193.143.249:80'})
opener = urllib2.build_opener(proxy_handler)
r = opener.open('http://httpbin.org/ip')
print(r.read())

也可以用install_opener将配置好的opener安装到全局环境中，这样所有的urllib2.urlopen都会自动使用代理。

0
1
2
3
import urllib2
urllib2.install_opener(opener)
r = urllib2.urlopen('http://httpbin.org/ip')
print(r.read())

在Python 3中，使用urllib。

0
1
2
3
4
import urllib
proxy_handler = urllib.request.ProxyHandler({'http': 'http://121.193.143.249:80/'})
opener = urllib.request.build_opener(proxy_handler)
r = opener.open('http://httpbin.org/ip')
print(r.read())

Continue reading →

十 16

Python生成随机数的方法

Posted on by

在Python生成随机数与random模块中最常用的几个函数的关系实例

random.random()
用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成随机数

0
1
2
3
4
5
6
# n: a <= n <= b。如果 a <b， 则 b <= n <= a
 
print random.uniform(10, 20)
print random.uniform(20, 10)
# ----
# 18.7356606526
# 12.5798298022

 

用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，Python生成随机数

0
1
2
print random.randint(12, 20) #生成的随机数n: 12 <= n <= 20
print random.randint(20, 20) #结果永远是20
#print random.randint(20, 10) #该语句是错误的。

 

下限必须小于上限。
random.randrange
从指定范围内，按指定基数递增的集合中 ，这篇文章就是对python生成随机数的应用程序的部分介绍。

随机整数：
>>> import random
>>> random.randint(0,99)
21
随机选取0到100间的偶数：
>>> import random
>>> random.randrange(0, 101, 2)
42
随机浮点数：
>>> import random
>>> random.random()
0.85415370477785668
>>> random.uniform(1, 10)
5.4221167969800881
随机字符：
>>> import random
>>> random.choice(‘abcdefg&#%^*f’)
‘d’
多个字符中选取特定数量的字符：
>>> import random
random.sample(‘abcdefghij’,3)
['a', 'd', 'b']
多个字符中选取特定数量的字符组成新字符串：
>>> import random
>>> import string
>>> string.join(random.sample(['a','b','c','d','e','f','g','h','i','j'], 3)).r
eplace(” “,”")
‘fih’
随机选取字符串：
>>> import random
>>> random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
‘lemon’
洗牌：
>>> import random
>>> items = [1, 2, 3, 4, 5, 6]
>>> random.shuffle(items)
>>> items
[3, 2, 5, 6, 4, 1]