python 学习记录（5）-变量、模块名的命名规则及random模块使用

学习：Python开发技术祥解 源文件\02\2.2\2.2.1

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 变量、模块名的命名规则
# Filename: ruleModule.py

_rule = "rule information"             #定义全局变量，变量命名最好以下划线开头

#面向对象中的命名规则
class Student:                      # 类名大写
    __name = ""                     # 私有实例变量前必须有两个下划线
    def __init__(self, name):
        self.__name = name          # self相当于Java中的this
    def getName(self):              # 方法名首字母小写，其后每个单词的首字母大写
        return self.__name

if __name__ == "__main__":
    student = Student("borphi")     # 对象名小写
    print student.getName()
# 函数中的命名规则
import random

def compareNum(num1, num2):      # 函数名首字母小写，其后每个单词的首字母大写
    if(num1 > num2):
        return 1
    elif(num1 == num2):
        return 0
    else:
        return -1
num1 = random.randrange(1, 9, 2)     #关于range模块的使用见下方
num2 = random.randrange(1, 9, 2)
print "num1 =", num1
print "num2 =", num2
print compareNum(num1, num2)

运行结果：

borphi
num1 = 1
num2 = 3
-1

# 不规范的变量命名
sum = 0
i = 2000
j = 1200
sum = i + 12 * j
# 规范的变量命名    ———看其名，知其意
sumPay = 0
bonusOfYear = 2000
monthPay = 1200
sumPay = bonusOfYear + 12 * monthPay

一次赋多值

>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v     >>> x
'a'
>>> y
'b'
>>> z
'e'

v 是一个三元素的 tuple，并且 (x, y, z) 是一个三变量的 tuple。将一个 tuple 赋值给另一个 tuple，会按顺序将 v 的每个值赋值给每个变量。

连续值赋值

>>> range(7)                                                                    [0, 1, 2, 3, 4, 5, 6]
>>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7) >>> MONDAY                                                                      0
>>> TUESDAY
1
>>> SUNDAY
6

	内置的 range 函数返回一个元素为整数的 list。这个函数的简化调用形式是接收一个上限值，然后返回一个初始值从 0 开始的 list，它依次递增，直到但不包含上限值。(如果您愿意，您可以传入其它的参数来指定一个非 0 的初始值和非 1 的步长。也可以使用 print range.__doc__ 来了解更多的细节。)
	MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY 和 SUNDAY 是我们定义的变量。(这个例子来自 calendar 模块。它是一个很有趣的打印日历的小模块，像 UNIX 的 cal 命令。这个 calendar 模块定义了一星期中每天的整数常量表示。)
	现在每个变量都拥有了自己的值：MONDAY 的值为 0，TUESDAY 的值为 1，等等。

1.2 Python中的random模块用于生成随机数。

下面介绍一下random模块中最常用的几个函数。

random.random

random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import random
print random.random()

0.587631903386     #每次运行结果都不一样

0.272705884379

random.uniform

　　random.uniform的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机浮点数，两个参数其中一个是上限，一个是下限。生成的浮点数在[a,b]区间内

print random.uniform(31, 20)
print random.uniform(20, 31)

30.6312092563
21.0429564652

random.randint

　　random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

print random.randint(20, 31)  #a <=b，否则会报错

22

random.randrange

　　random.randrange的函数原型为：random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2)) 等效。

print random.randrange(0, 100, 5)
print random.choice(range(0, 100, 5))

15
90

random.choice

　　random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章，也可以参考：http://www.17xie.com/read-37422.html 。下面是使用choice的一些例子：

print random.choice("学习Python")
print random.choice(["JGood","is","a","handsome","boy"])
print random.choice(("Tuple","List","Dict"))

o
JGood
Dict                                         #随机取值

random.shuffle

　　random.shuffle的函数原型为：random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:

list1 = ["JGood","is","a","handsome","boy"]
random.shuffle(list1)

['a', 'handsome', 'is', 'boy', 'JGood']

random.sample

　　random.sample的函数原型为：random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
slice = random.sample(list, 5)  #从list中随机获取5个元素，作为一个片断返回  
print slice  
print list #原有序列并没有改变。 
[5, 1, 10, 8, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

This module implements pseudo-random number generators for variousdistributions.

For integers, uniform selection from a range. For sequences, uniform selectionof a random element, a function to generate a random permutation of a listin-place, and a function for random sampling without replacement.

On the real line, there are functions to compute uniform, normal (Gaussian),lognormal, negative exponential, gamma, and beta distributions. For generatingdistributions of angles, the von Mises distribution is available.

Almost all module functions depend on the basic function random(), whichgenerates a random float uniformly in the semi-open range [0.0, 1.0). Pythonuses the Mersenne Twister as the core generator. It produces 53-bit precisionfloats and has a period of 2**19937-1. The underlying implementation in C isboth fast and threadsafe. The Mersenne Twister is one of the most extensivelytested random number generators in existence. However, being completelydeterministic, it is not suitable for all purposes, and is completely unsuitablefor cryptographic purposes.

The functions supplied by this module are actually bound methods of a hiddeninstance of therandom.Random class. You can instantiate your owninstances ofRandom to get generators that don’t share state. This isespecially useful for multi-threaded programs, creating a different instance ofRandom for each thread, and using thejumpahead() method to makeit likely that the generated sequences seen by each thread don’t overlap.

Class Random can also be subclassed if you want to use a differentbasic generator of your own devising: in that case, override therandom(),seed(),getstate(),setstate() andjumpahead() methods.Optionally, a new generator can supply agetrandbits() method — thisallowsrandrange() to produce selections over an arbitrarily large range.

New in version 2.4: the getrandbits() method.

As an example of subclassing, the random module provides theWichmannHill class that implements an alternative generator in purePython. The class provides a backward compatible way to reproduce results fromearlier versions of Python, which used the Wichmann-Hill algorithm as the coregenerator. Note that this Wichmann-Hill generator can no longer be recommended:its period is too short by contemporary standards, and the sequence generated isknown to fail some stringent randomness tests. See the references below for arecent variant that repairs these flaws.

Changed in version 2.3: MersenneTwister replaced Wichmann-Hill as the default generator.

The random module also provides theSystemRandom class whichuses the system functionos.urandom() to generate random numbersfrom sources provided by the operating system.

Bookkeeping functions:

random. seed ( [ x ] )

Initialize the basic random number generator. Optional argument x can be anyhashable object. Ifx is omitted orNone, current system time is used;current system time is also used to initialize the generator when the module isfirst imported. If randomness sources are provided by the operating system,they are used instead of the system time (see the os.urandom() functionfor details on availability).

Changed in version 2.4: formerly, operating system resources were not used.

random. getstate ( )

Return an object capturing the current internal state of the generator. Thisobject can be passed tosetstate() to restore the state.

New in version 2.1.

Changed in version 2.6: State values produced in Python 2.6 cannot be loaded into earlier versions.

random. setstate ( state )

state should have been obtained from a previous call to getstate(), andsetstate() restores the internal state of the generator to what it was atthe time setstate() was called.

New in version 2.1.

random. jumpahead ( n )

Change the internal state to one different from and likely far away from thecurrent state.n is a non-negative integer which is used to scramble thecurrent state vector. This is most useful in multi-threaded programs, inconjunction with multiple instances of theRandom class:setstate() or seed() can be used to force all instances into thesame internal state, and thenjumpahead() can be used to force theinstances’ states far apart.

New in version 2.1.

Changed in version 2.3: Instead of jumping to a specific state, n steps ahead, jumpahead(n)jumps to another state likely to be separated by many steps.

random. getrandbits ( k )

Returns a python long int withk random bits. This method is suppliedwith the MersenneTwister generator and some other generators may also provide itas an optional part of the API. When available,getrandbits() enablesrandrange() to handle arbitrarily large ranges.

New in version 2.4.

Functions for integers:

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

Return a randomly selected element from range(start,stop,step). This isequivalent tochoice(range(start,stop, step)), but doesn’t actually build arange object.

New in version 1.5.2.

random. randint ( a, b )

Return a random integer N such that a<=N <=b.

Functions for sequences:

random. choice ( seq )

Return a random element from the non-empty sequence seq. If seq is empty,raisesIndexError.

random. shuffle ( x [, random ] )

Shuffle the sequence x in place. The optional argument random is a0-argument function returning a random float in [0.0, 1.0); by default, this isthe functionrandom().

Note that for even rather small len(x), the total number of permutations ofx is larger than the period of most random number generators; this impliesthat most permutations of a long sequence can never be generated.

random. sample ( population, k )

Return a k length list of unique elements chosen from the population sequence.Used for random sampling without replacement.

New in version 2.3.

Returns a new list containing elements from the population while leaving theoriginal population unchanged. The resulting list is in selection order so thatall sub-slices will also be valid random samples. This allows raffle winners(the sample) to be partitioned into grand prize and second place winners (thesubslices).

Members of the population need not be hashable or unique. If the populationcontains repeats, then each occurrence is a possible selection in the sample.

To choose a sample from a range of integers, use an xrange() object as anargument. This is especially fast and space efficient for sampling from a largepopulation:sample(xrange(10000000),60).

The following functions generate specific real-valued distributions. Functionparameters are named after the corresponding variables in the distribution’sequation, as used in common mathematical practice; most of these equations canbe found in any statistics text.

random. random ( )

Return the next random floating point number in the range [0.0, 1.0).

random. uniform ( a, b )

Return a random floating point number N such that a <= N<=b fora<=b and b<= N<=a for b< a.

The end-point value b may or may not be included in the rangedepending on floating-point rounding in the equationa+(b-a) *random().

random. triangular ( low, high, mode )

Return a random floating point number N such that low <= N<=high andwith the specifiedmode between those bounds. Thelow and high boundsdefault to zero and one. Themode argument defaults to the midpointbetween the bounds, giving a symmetric distribution.

New in version 2.6.

random. betavariate ( alpha, beta )

Beta distribution. Conditions on the parameters are alpha > 0 andbeta>0. Returned values range between 0 and 1.

random. expovariate ( lambd )

Exponential distribution. lambd is 1.0 divided by the desiredmean. It should be nonzero. (The parameter would be called“lambda”, but that is a reserved word in Python.) Returned valuesrange from 0 to positive infinity iflambd is positive, and fromnegative infinity to 0 if lambd is negative.

random. gammavariate ( alpha, beta )

Gamma distribution. (Not the gamma function!) Conditions on theparameters arealpha>0 and beta> 0.

The probability distribution function is:

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

random. gauss ( mu, sigma )

Gaussian distribution. mu is the mean, and sigma is the standarddeviation. This is slightly faster than thenormalvariate() functiondefined below.

random. lognormvariate ( mu, sigma )

Log normal distribution. If you take the natural logarithm of thisdistribution, you’ll get a normal distribution with meanmu and standarddeviationsigma. mu can have any value, andsigma must be greater thanzero.

random. normalvariate ( mu, sigma )

Normal distribution. mu is the mean, and sigma is the standard deviation.

random. vonmisesvariate ( mu, kappa )

mu is the mean angle, expressed in radians between 0 and 2*pi, andkappais the concentration parameter, which must be greater than or equal to zero. Ifkappa is equal to zero, this distribution reduces to a uniform random angleover the range 0 to 2*pi.

random. paretovariate ( alpha )

Pareto distribution. alpha is the shape parameter.

random. weibullvariate ( alpha, beta )

Weibull distribution. alpha is the scale parameter and beta is the shapeparameter.

Alternative Generators:

class random. WichmannHill ( [ seed ] )

Class that implements the Wichmann-Hill algorithm as the core generator. Has allof the same methods asRandom plus thewhseed() method describedbelow. Because this class is implemented in pure Python, it is not threadsafeand may require locks between calls. The period of the generator is6,953,607,871,644 which is small enough to require care that two independentrandom sequences do not overlap.

random. whseed ( [ x ] )

This is obsolete, supplied for bit-level compatibility with versions of Pythonprior to 2.1. Seeseed() for details.whseed() does not guaranteethat distinct integer arguments yield distinct internal states, and can yield nomore than about 2**24 distinct internal states in all.

class random. SystemRandom ( [ seed ] )

Class that uses the os.urandom() function for generating random numbersfrom sources provided by the operating system. Not available on all systems.Does not rely on software state and sequences are not reproducible. Accordingly,the seed() andjumpahead() methods have no effect and are ignored.Thegetstate() andsetstate() methods raiseNotImplementedError if called.

New in version 2.4.

Examples of basic usage:

>>>

>>> random.random()        # Random float x, 0.0 <= x < 1.0
0.37444887175646646
>>> random.uniform(1, 10)  # Random float x, 1.0 <= x < 10.0
1.1800146073117523
>>> random.randint(1, 10)  # Integer from 1 to 10, endpoints included
7
>>> random.randrange(0, 101, 2)  # Even integer from 0 to 100
26
>>> random.choice('abcdefghij')  # Choose a random element
'c'

>>> items = [1, 2, 3, 4, 5, 6, 7]
>>> random.shuffle(items)
>>> items
[7, 3, 2, 5, 6, 4, 1]

>>> random.sample([1, 2, 3, 4, 5],  3)  # Choose 3 elements
[4, 1, 5]

http://docs.python.org/library/random.html