random是python的第三方库吗_Python 标准库：random

Python 中的 random 模块用于生成各种分布的随机数。random 模块可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等。

在 Python 中，实现我们比较熟悉的均匀分布、正态(高斯)分布都非常方便，此外，还有对数正态、负指数、伽马和 β 分布的函数。

几乎所有模块函数都依赖于基本函数random()，在 [0.0,1.0) 中均匀地生成随机浮点。Python 使用 Mersenne Twister 作为核心生成器。它产生 53 位精确度浮点数，周期为2 ** 19937-1。底层使用 C 实现既快又线程安全。Mersenne Twister 是现存最广泛测试的随机数生成器之一。然而，它不适合于所有目的，比如不适合于加密用途。

警告：该模块的伪随机生成器不应该用于安全目的。

1. random.random

函数是这个模块中最常用的方法了，它会生成一个随机的浮点数，范围是在 0.0~1.0 之间。

2. random.uniform

它可以设定浮点数的范围，一个是上限，一个是下限。random.uniform 的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个较大的数是上限，较小的数是下限。

>>> import random

>>> print(random.uniform(10, 20))

12.2990031101

>>> print(random.uniform(20,10))

13.597102709

3. random.sample

可以从指定的序列中，随机地选择元素得到指定长度的列表，不修改原先的序列。random.sample 的函数原型为：random.sample(sequence, k)，其中的两个参数一个为序列，另一个为新序列的长度。

import random

orig_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

slice_list = random.sample(orig_list, 5)

print(orig_list)

print(slice_list)

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[4, 3, 2, 8, 6]

4. random.choice

random.choice 从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数 sequence 表示一个有序类型， 它在 python 中不是一种特定的类型，而是泛指一系列的类型。列表、元组、字符串都属于 sequence。下面是使用 choice 的一些例子：

>>> print(random.choice("学习Python"))

学

>>> print(random.choice(["oatmeal","is","a","cute","man"]))

is

>>> print(random.choice(("Tuple","List","Dict")))

Tuple

>>>

然后我们再来个实际点的例子，比如你要帮领导写个发言稿， 你先收集好领导平时经常用的词或者语句， 用 random.choice 从这些语句中随机的选择拼接，这样就不用费脑筋就可以完成一篇文章了， 当然写出来后还得通顺通顺。

import random

import textwrap

OPENING_WORDS = ['Our', 'clear', 'strategic', 'direction', 'is', 'to', 'invoke',]

PHRASE_TABLE = (

("accountable", "transition", "leadership"),

("driving", "strategy", "implementation"),

("drilling down into", "active", "core business objectives"),

("next billion", "execution", "with our friends in "),

("creating", "next-generation", "franchise platform"),

("'s", "volume and", "value leadership"),

("significant", "end-user", "experience"),

("transition", "from ", "to 's platform"),

("integrating", "shared", "services"),

("empowered to", "improve and expand", "our portfolio of experience"),

("deliver", "new", "innovation"),

("ramping up", "diverse", "collaboration"),

("next generation", "mobile", "ecosystem"),

("focus on", "growth and", "consumer delight"),

("management", "planning", "interlocks"),

("necessary", "operative", "capabilities"),

("knowledge", "optimization", "initiatives"),

("modular", "integration", "environment"),

("software", "creation", "processes"),

("agile", "working", "practices"),

)

INSERTS = ('for', 'with', 'and', 'as well as', 'by',

'whilst not forgetting',

'. Of course',

'. To be absolutely clear',

'. We need',

'and unrelenting',

'with unstoppable',

)

def get_phrase():

"""Return a phrase by choosing words at random from each column of the PHRASE_TABLE."""

return [random.choice(PHRASE_TABLE)[i] for i in range(3)]

def get_insert():

"""Return a randomly chosen set of words to insert between phrases."""

return random.choice(INSERTS)

def write_speech(n):

"""Write a speech with the opening words followed by n random phrases

interspersed with random inserts."""

phrases = OPENING_WORDS

for i in range(n):

phrases.extend(get_phrase())

if i != n-1:

phrases.append(get_insert())

text = ' '.join(phrases) + '.'

print(textwrap.fill(text))

if __name__ == '__main__':

write_speech(8)

开始这篇文章可以有个固定的开头，把这些词存在 OPENING_WORDS 列表里。常用的语句放在 PHRASE_TABLE 元组里， 把它写成三列的形式， 每次从这三列里各选一个词组成一个新的语句。 然后还得从 INSERTS 里面选一个连接词。

在从 PHRASE_TABLE 选择词汇的时候使用了 [random.choice(PHRASE_TABLE)[i] for i in range(3)] 语句， 注意random.choice在这一句被执行了三次，每一次随机的选择表里面的某一行的元组，然后把元组中对应列的词汇找出来。

输出：

Our clear strategic direction is to invoke next generation planning

collaboration and unrelenting next billion shared experience for

accountable mobile innovation for driving shared with our friends in

with unstoppable focus on mobile initiatives . Of course

significant execution capabilities and unrelenting ramping up

integration innovation and unrelenting focus on execution ecosystem.

5. random.randrange

random.randrange(stop)

random.randrange(start, stop[, step])

从 range(start, stop, step) 返回一个 start 到 end 范围内的随机整数(start，end，step 都是整数，不包含 end)，可以指定 step。

下面我们利用 randrange 实现一个 21 点扑克牌游戏。

import random

def ask_user(prompt, response1, response2):

"""

Ask user for a response in two responses.

prompt (str) - The prompt to print to the user

response1 (str) - One possible response that the user can give

response2 (str) - Another possible response that the user can give

"""

while True:

# ask user for response

user_response = input(prompt)

#if response is response1 or response2 then return

if user_response == response1 or user_response == response2:

return user_response

def print_card(name, num):

"""

print "______ draws a _____" with the first blank replaced by the user's

name and the second blank replaced by the value given to the function.

name (str) - the user name to print out

num (int) - the number to print out

"""

# if the value is a 1, 11, 12, 13, print Ace, Jack, Queen, King

if num == 1:

num = "Ace"

elif num == 11:

num = "Jack"

elif num == 12:

num = "Queen"

elif num == 13:

num = "King"

else:

num = str(num)

# print the string

print(name, "draws a", num)

def get_ace_value():

"""

Ask the user if they want to use a 1 or 11 as their Ace value.

"""

# get the value use "ask_user" function

value = ask_user("Should the Ace be 1 or 11?", "1", "11")

# retrun the value

return int(value)

def deal_card(name):

"""

Pick a random number between 1 and 13, and print out what the user drew.

name (str) - the user name to print out

"""

# get a random number in range 1 to 13

num = random.randrange(1, 13+1)

# use "print_card" function to print out what the user drew

print_card(name, num)

if num > 10:

# if the card is a Jack, Queen, or King, the point-value is 10

return 10

elif num == 1:

# If the card is an Ace, ask the user if the value should be 1 or 11

return get_ace_value()

else:

return num

def adjust_for_bust(num):

"""

If the given number is greater than 21, print "Bust!" and return -1.

Otherwise return the number that was passed in.

num (int) - the given number

"""

# determine the value of num

if num > 21:

print("Bust!")

return -1

else:

return num

def hit_or_stay(num):

"""

Prompt the user hit or stay and return user's chose.

num (int) - the value of a player's card hand

"""

if num <= 21:

chose = ask_user("Hit or stay?", "hit", "stay")

# if num less than 21 and user chose hit return True

if chose == "hit":

return True

# otherwise return False

return False

def play_turn(name):

"""

Play whole the trun for a user.

name (str) - the player's name

"""

# print out that it's the current players turn

print("==========[ Current player:", name, "]==========")

# set total score zero

total_score = 0

# deal the player a card for loop

while True:

# get total score

total_score += deal_card(name)

# if not busted print out the player's total score

print("Total:", total_score)

# if player chose stay return the result, otherwise continue the loop

if not hit_or_stay(total_score):

return adjust_for_bust(total_score)

def determine_winner(name1, name2, score1, score2):

"""

Determine_the game's winner.

name1 (str) - the first player's name

name2 (str) - the second player's name

score1 (str) - the first player's score

score2 (str) - the second player's score

"""

if score1 == score2:

print(name1, "and", name2, "tie!")

elif score1 > score2:

print(name1, "wins!")

elif score1 < score2:

print(name2, "wins!")

def main():

"""

The main program of BlackJack game

"""

while True:

# Ask each player for their name

name1 = input("Player 1 name:")

name2 = input("Player 2 name:")

# Greet them

print("Welcome to BlackJack", name1, "and", name2)

print()

# Let the first player play a turn

score1 = play_turn(name1)

print()

# Let the second player play a turn

score2 = play_turn(name2)

print()

# Determine who won

determine_winner(name1, name2, score1, score2)

# Play again if they say yes and end the loop if they say no

if ask_user("Would you like to play again?", "yes", "no") == "no":

break

if __name__ == "__main__":

main()

输出：

Player 1 name:oatmeal

Player 2 name:alice

Welcome to BlackJack oatmeal and alice

==========[ Current player: oatmeal ]==========

oatmeal draws a 9

Total: 9

Hit or stay?hit

oatmeal draws a 3

Total: 12

Hit or stay?hit

oatmeal draws a 2

Total: 14

Hit or stay?stay

==========[ Current player: alice ]==========

alice draws a 9

Total: 9

Hit or stay?hit

alice draws a Jack

Total: 19

Hit or stay?stay

alice wins!

Would you like to play again?yes

Player 1 name:oatmeal

Player 2 name:alice

Welcome to BlackJack oatmeal and alice

==========[ Current player: oatmeal ]==========

oatmeal draws a Ace

Should the Ace be 1 or 11?11

Total: 11

Hit or stay?hit

oatmeal draws a Jack

Total: 21

Hit or stay?stay

==========[ Current player: alice ]==========

alice draws a 9

Total: 9

Hit or stay?hit

alice draws a 2

Total: 11

Hit or stay?hit

alice draws a 6

Total: 17

Hit or stay?hit

alice draws a Ace

Should the Ace be 1 or 11?1

Total: 18

Hit or stay?hit

alice draws a 2

Total: 20

Hit or stay?stay

oatmeal wins!

6. random.randint

而 randint 是怎么用的呢，它可以从参数指定的范围里随机选择一个整数返回来。

import random

import time

def open_connection():

if random.randint(0, 3) != 0:

raise ValueError

return True

def connect(nretry=100):

for _ in range(nretry):

try:

if open_connection():

print("Connected!")

return

except ValueError:

print("failed to connect, note this!")

time.sleep(2)

continue

if "__main__" in __name__:

connect()

在这个程序里， 我们模拟了网络连接的情况。如果在连接的时候没有得到正常值，那就等一会儿，然后再连接。

输出：

failed to connect, note this!

failed to connect, note this!

Connected!

7. random.shuffle()

可以将一个列表里的元素打乱顺序重新排列。

import random

def remove_indices(mylist, idxs):

result = []

for i, l in enumerate(mylist):

if i not in idxs:

result.append(l)

return result

if "__main__" in __name__:

name_list = ["xiaopai", "oatmeal", "shuo", "gang"]

print(name_list)

random.shuffle(name_list)

idx_list = []

for i in range(2):

Num = input("please enter a number:")

idx_list.append(int(Num))

print(name_list)

win_names = remove_indices(name_list, idx_list)

print(win_names)

这个在抽签的时候尤其好用， 备选的人名组成一个列表，然后用 shuffle 把它打乱， 由人再输入些下标数值，让对应下标的人名从列表里被删掉，看看剩下的人是谁。

输出：

['xiaopai', 'oatmeal', 'shuo', 'gang']

please enter a number:1

please enter a number:2

['shuo', 'xiaopai', 'gang', 'oatmeal']

['shuo', 'oatmeal']