pythonguid生成

① python的uuid

uuid是128位的全局唯一标识符（univeral unique identifier），通常用32位的一个字符串的形式来表现。有时也称guid(global unique identifier)。python中自带了uuid模块来进行uuid的生成和管理工作。（具体从哪个版本开始有的不清楚。。）

python中的uuid模块基于信息如MAC地址、时间戳、命名空间、随机数、伪随机数来uuid。具体方法有如下几个：

uuid.uuid1()基于MAC地址，时间戳，随机数来生成唯一的uuid，可以保证全球范围内的唯一性。

uuid.uuid2()算法与uuid1相同，不同的是把时间戳的前4位置换为POSIX的UID。不过需要注意的是python中没有基于DCE的算法，所以python的uuid模块中没有uuid2这个方法。

uuid.uuid3(namespace,name)通过计算一个命名空间和名字的md5散列值来给出一个uuid，所以可以保证命名空间中的不同名字具有不同的uuid，但是相同的名字就是相同的uuid了。【感谢评论区大佬指出】namespace并不是一个自己手动指定的字符串或其他量，而是在uuid模块中本身给出的一些值。比如uuid.NAMESPACE_DNS，uuid.NAMESPACE_OID，uuid.NAMESPACE_OID这些值。这些值本身也是UUID对象，根据一定的规则计算得出。

uuid.uuid4()通过伪随机数得到uuid，是有一定概率重复的

uuid.uuid5(namespace,name)和uuid3基本相同，只不过采用的散列算法是sha1

一般而言，在对uuid的需求不是很复杂的时候，uuid1方法就已经够用了，使用方法如下：
"""

import uuid

name = 'test_name'

namespace = uuid.NAMESPACE_URL

print uuid.uuid1()
print uuid.uuid3(namespace,name)
print uuid.uuid4()
print uuid.uuid5(namespace,name)
"""

② python生成器到底有什么优点

1. 迭代器协议

由于生成器自动实现了迭代器协议，而迭代器协议对很多人来说，也是一个较为抽象的概念。所以，为了更好的理解生成器，我们需要简单的回顾一下迭代器协议的概念。
迭代器协议是指：对象需要提供next方法，它要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代

可迭代对象就是：实现了迭代器协议的对象

协议是一种约定，可迭代对象实现迭代器协议，Python的内置工具(如for循环，sum，min，max函数等)使用迭代器协议访问对象。

举个例子：在所有语言中，我们都可以使用for循环来遍历数组，Python的list底层实现是一个数组，所以，我们可以使用for循环来遍历list。如下所示：
>>> for n in [1, 2, 3, 4]:
... print n

但是，对Python稍微熟悉一点的朋友应该知道，Python的for循环不但可以用来遍历list，还可以用来遍历文件对象，如下所示：
>>> with open(‘/etc/passwd’) as f: # 文件对象提供迭代器协议
... for line in f: # for循环使用迭代器协议访问文件
... print line
...

为什么在Python中，文件还可以使用for循环进行遍历呢？这是因为，在Python中，文件对象实现了迭代器协议，for循环并不知道它遍历的是一个文件对象，它只管使用迭代器协议访问对象即可。正是由于Python的文件对象实现了迭代器协议，我们才得以使用如此方便的方式访问文件，如下所示：
>>> f = open('/etc/passwd')
>>> dir(f)
['__class__', '__enter__', '__exit__', '__iter__', '__new__', 'writelines', '...'

2. 生成器

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

Python有两种不同的方式提供生成器：
生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

2.1 生成器函数

我们来看一个例子，使用生成器返回自然数的平方（注意返回的是多个值）：
def gensquares(N):
for i in range(N):
yield i ** 2

for item in gensquares(5):
print item,

使用普通函数：
def gensquares(N):
res = []
for i in range(N):
res.append(i*i)
return res

for item in gensquares(5):
print item,

可以看到，使用生成器函数代码量更少。

2.2 生成器表达式

使用列表推导，将会一次产生所有结果：
>>> squares = [x**2 for x in range(5)]
>>> squares
[0, 1, 4, 9, 16]

将列表推导的中括号，替换成圆括号，就是一个生成器表达式：
>>> squares = (x**2 for x in range(5))
>>> squares
<generator object at 0x00B2EC88>
>>> next(squares)
0
>>> next(squares)
1
>>> next(squares)
4
>>> list(squares)
[9, 16]

Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
>>> sum(x ** 2 for x in xrange(4))

而不用多此一举的先构造一个列表：
>>> sum([x ** 2 for x in xrange(4)])

2.3 再看生成器

前面已经对生成器有了感性的认识，我们以生成器函数为例，再来深入探讨一下Python的生成器：
语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行
3. 示例

我们再来看两个生成器的例子，以便大家更好的理解生成器的作用。

首先，生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

大家可以在自己电脑上试试下面两个表达式，并且观察内存占用情况。对于前一个表达式，我在自己的电脑上进行测试，还没有看到最终结果电脑就已经卡死，对于后一个表达式，几乎没有什么内存占用。
sum([i for i in xrange(10000000000)])
sum(i for i in xrange(10000000000))

除了延迟计算，生成器还能有效提高代码可读性。例如，现在有一个需求，求一段文字中，每个单词出现的位置。

不使用生成器的情况：
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result

使用生成器的情况：
def index_words(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index

这里，至少有两个充分的理由说明 ，使用生成器比不使用生成器代码更加清晰：
使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成器的时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回index。
这个例子充分说明了，合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成器要好，能够理解使用生成器真的可以让代码变得清晰易懂。

4. 使用生成器的注意事项

相信通过这篇文章，大家已经能够理解生成器的作用和好处。但是，还没有结束，使用生成器，也有一点注意事项。

我们直接来看例子，假设文件中保存了每个省份的人口总数，现在，需要求每个省份的人口占全国总人口的比例。显然，我们需要先求出全国的总人口，然后在遍历每个省份的人口，用每个省的人口数除以总人口数，就得到了每个省份的人口占全国人口的比例。

如下所示：
def get_province_population(filename):
with open(filename) as f:
for line in f:
yield int(line)

gen = get_province_population('data.txt')
all_population = sum(gen)
#print all_population
for population in gen:
print population / all_population

执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。

③ python生成金字塔

人生苦短，我用python！
本文将介绍三种使用python实现生成金字塔的方法，文末归纳了知识点。

本方法使用print打印出每一个字符，通过for循环计算每一次需要输出的空格和星号。
print语句中，end=''表示不换行。

本方法利用了一个有趣的规律：

在程序中表达为 m += pow(10,i) ，即 m = m + pow(10,i) ，例如：

通过运行我们发现输出数字的时候，由于每行数字是一次性输出，而非每个数字输出一次，相比方法一效率有了提升。
pow(10,i) 表示 10 i 。

本方法在方法二的基础上再次改进空格的输出方式，print(b*a)语句中，a表示输出的次数。

当我把层数n设置为100的时候，发生了壮观的一幕，感兴趣的朋友欢迎自己试试。

文中同时使用了 range 数列，range[10] 表示：0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 。

以下是 print() 方法的语法:

参数

pow() 方法返回 x y （x的y次方） 的值。语法为：

参考文献：
[1] Python for 循环语句
[2] Python print() 函数
[3] Python pow() 函数
[4] Number Pyramid

④ python如何自动生成单个随机字母(a-z)。

1:mport random
#导入random模块 用于生产随机数功能

2:a = random.randint(97, 122)
#利用random.randint()函数生成一个随机整数a，使得97<=a<=122
#对应从“a”到“z”的ASCII码

3:c = chr(a)
#将a表示的ASCII码转换为对应的字母，这里的c就是你要的随机字母

4:print c
#将字母输出，完成

⑤ Python3 生成一个随即列表

Python 生成一个随即列表

      -1.最原始的方法--循环

import random #随机数的库

l = [] # 先定义一个空列表

for i in range(1,100):

        x = random.randint(1,100) # 选取数字的范围是1--100 ，且为int

        l.append(x)

print(l)

-2.

l = [random.randint(0,100000) for i in range(1000)]  #

print(l)

3.

l = [random.randrange(1000) for i in range(1000)]

print(l)

4.

#生成不可重复的随机数。

l = random.sample([i for i in range(10000)],100)

print(l)

⑥ python 如何生成 2 1 4 3 6 5 8 7。。。的指定长度的序列

首先，找规律：

(2 1) (4 3) (6 5) (8 7) ..

发现是每个偶数i与i-1互换位置，或者说：奇数加1，偶数减1。如此一来可以用列表表达式生成（假设长度为n）：

[i-1 if i % 2 == 0 else i+1 for i in range(1, n+1)]

⑦ python如何编译生成二进制文件

1、可以
2、当你编辑运行py文件后，就会生成对应文件名的pyc文件。
3、pyc是一种二进制文件，是由py文件经过编译后，生成的文件，是一种byte code，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由python的虚拟机来执行的，这个是类似于JAVA或者.NET的虚拟机的概念。pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不同的。
总之，是可以的

⑧ 关于Python中的随机数生成步骤和随机数质量

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

printrandom.uniform(10,20)
printrandom.uniform(20,10)
#----
#18.7356606526
#12.5798298022
random.randint

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

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

random.randrange方法从指定范围内，按指定基数递增的集合中 ，下面对python生成随机数的应用程序的部分介绍：

1.随机整数：

>>>importrandom
>>>random.randint(0,99)
21

2.随机选取0到100间的偶数：

>>>importrandom
>>>random.randrange(0,101,2)
42

3.随机浮点数：

>>>importrandom
>>>random.random()
0.85415370477785668
>>>random.uniform(1,10)
5.4221167969800881

4.随机字符：

>>>importrandom
>>>random.choice('abcdefg&#%^*f')
'd'

5.多个字符中选取特定数量的字符：

>>>importrandom
random.sample('abcdefghij',3)
['a','d','b']

6.多个字符中选取特定数量的字符组成新字符串：

>>>importrandom
>>>importstring
>>>string.join(random.sample(['a','b','c','d','e','f','g','h','i','j'],3)).r
eplace("","")
'fih'

⑨ python---随机生成密码

importrandom,string
n=int(input('请输入生成随机密码的个数n='))#n=10
m=int(input("请输入生成随机密码的长度m="))#m=8
chars=string.ascii_letters+string.digits#生成['a',...,'z','A',...,'Z','0',...'9']
new_chars=''.join(chars)
ll=new_chars.split()
num=0
whilenum<n:
random.shuffle(ll)
list1=ll[:m]
num+=1
print(''.join(list1))
else:
print('生成了%s个长度是%s的随机密码'%(n,m))

在python 3.5上运行，结果完全满足题的要求，也用了我一个多小时时间。

⑩ 如何更好地理解Python迭代器和生成器

Python这门语言中，生成器毫无疑问是最有用的特性之一。与此同时，也是使用的最不广泛的Python特
性之一。究其原因，主要是因为，在其他主流语言里面没有生成器的概念。正是由于生成器是一
个“新”的东西，所以，它一方面没有引起广大工程师的重视，另一方面，也增加了工程师的学习成本，
最终导致大家错过了Python中如此有用的一个特性。
我的这篇文章，希望通过简单易懂的方式，深入浅出地介绍Python的生成器，以改变“如此有用的特性却
使用极不广泛”的现象。本文的组织如下：在第1章，我们简单地介绍了Python中的迭代器协议；在本文
第2章，将会详细介绍生成器的概念和语法；在第3章，将会给出一个有用的例子，说明使用生成器的好
处；在本文最后，简单的讨论了使用生成器的注意事项。
1. 迭代器协议
由于生成器自动实现了迭代器协议，而迭代器协议对很多人来说，也是一个较为抽象的概念。所以，为了
更好的理解生成器，我们需要简单的回顾一下迭代器协议的概念。
1. 迭代器协议是指：对象需要提供next方法，它要么返回迭代中的下一项，要么就引起一个
StopIteration异常，以终止迭代
2. 可迭代对象就是：实现了迭代器协议的对象
3. 协议是一种约定，可迭代对象实现迭代器协议，Python的内置工具(如for循环，sum，min，max函
数等)使用迭代器协议访问对象。
举个例子：在所有语言中，我们都可以使用for循环来遍历数组，Python的list底层实现是一个数组，所
以，我们可以使用for循环来遍历list。如下所示：
>>> for n in [1, 2, 3, 4]:
... print n
但是，对Python稍微熟悉一点的朋友应该知道，Python的for循环不但可以用来遍历list，还可以用来遍历
文件对象，如下所示：
>>> with open(‘/etc/passwd’) as f: # 文件对象提供迭代器协议
... for line in f: # for循环使用迭代器协议访问文件
... print line
...
为什么在Python中，文件还可以使用for循环进行遍历呢？这是因为，在Python中，文件对象实现了迭代
器协议，for循环并不知道它遍历的是一个文件对象，它只管使用迭代器协议访问对象即可。正是由于
Python的文件对象实现了迭代器协议，我们才得以使用如此方便的方式访问文件，如下所示：
>>> f = open('/etc/passwd')
>>> dir(f)
['__class__', '__enter__', '__exit__', '__iter__', '__new__', 'writelines', '...'
2. 生成器
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产
生结果。这也是生成器的主要好处。
Python有两种不同的方式提供生成器：
2017/11/6 如何更好地理解Python迭代器和生成器？ - 知乎
https://www.hu.com/question/20829330 2/5
1. 生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一
个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2. 生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个
结果列表
2.1 生成器函数
我们来看一个例子，使用生成器返回自然数的平方（注意返回的是多个值）：
def gensquares(N):
for i in range(N):
yield i ** 2
for item in gensquares(5):
print item,
使用普通函数：
def gensquares(N):
res = []
for i in range(N):
res.append(i*i)
return res
for item in gensquares(5):
print item,
可以看到，使用生成器函数代码量更少。
2.2 生成器表达式
使用列表推导，将会一次产生所有结果：
>>> squares = [x**2 for x in range(5)]
>>> squares
[0, 1, 4, 9, 16]
将列表推导的中括号，替换成圆括号，就是一个生成器表达式：
>>> squares = (x**2 for x in range(5))
>>> squares>>> next(squares)
0
>>> next(squares)
1
>>> next(squares)
4
>>> list(squares)
[9, 16]
Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象
的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协
2017/11/6 如何更好地理解Python迭代器和生成器？ - 知乎
https://www.hu.com/question/20829330 3/5
议，所以，我们可以直接这样计算一系列值的和：
>>> sum(x ** 2 for x in xrange(4))
而不用多此一举的先构造一个列表：
>>> sum([x ** 2 for x in xrange(4)])
2.3 再看生成器
前面已经对生成器有了感性的认识，我们以生成器函数为例，再来深入探讨一下Python的生成器：
1. 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在
于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
2. 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for
循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，
在没有值可以返回的时候，生成器自动产生StopIteration异常
3. 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，
以便之后从它离开的地方继续执行
3. 示例
我们再来看两个生成器的例子，以便大家更好的理解生成器的作用。
首先，生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大
数据量处理，将会非常有用。
大家可以在自己电脑上试试下面两个表达式，并且观察内存占用情况。对于前一个表达式，我在自己的电
脑上进行测试，还没有看到最终结果电脑就已经卡死，对于后一个表达式，几乎没有什么内存占用。
sum([i for i in xrange(10000000000)])
sum(i for i in xrange(10000000000))
除了延迟计算，生成器还能有效提高代码可读性。例如，现在有一个需求，求一段文字中，每个单词出现
的位置。
不使用生成器的情况：
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result
使用生成器的情况：
2017/11/6 如何更好地理解Python迭代器和生成器？ - 知乎
https://www.hu.com/question/20829330 4/5
def index_words(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index
这里，至少有两个充分的理由说明 ，使用生成器比不使用生成器代码更加清晰：
1. 使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前
提下，代码行数越少越好
2. 不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。
也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成
器的时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回
index。
这个例子充分说明了，合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，
理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成
器要好，能够理解使用生成器真的可以让代码变得清晰易懂。
4. 使用生成器的注意事项
相信通过这篇文章，大家已经能够理解生成器的作用和好处。但是，还没有结束，使用生成器，也有一点
注意事项。
我们直接来看例子，假设文件中保存了每个省份的人口总数，现在，需要求每个省份的人口占全国总人口
的比例。显然，我们需要先求出全国的总人口，然后在遍历每个省份的人口，用每个省的人口数除以总人
口数，就得到了每个省份的人口占全国人口的比例。
如下所示：
def get_province_population(filename):
with open(filename) as f:
for line in f:
yield int(line)
gen = get_province_population('data.txt')
all_population = sum(gen)
#print all_population
for population in gen:
print population / all_population
执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，
就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不
会有任何输出。
因此，生成器的唯一注意事项就是：生成器只能遍历一次。
5. 总结
2017/11/6 如何更好地理解Python迭代器和生成器？ - 知乎
https://www.hu.com/question/20829330 5/5
本文深入浅出地介绍了Python中，一个容易被大家忽略的重要特性，即Python的生成器。为了讲解生成
器，本文先介绍了迭代器协议，然后介绍了生成器函数和生成器表达式，并通过示例演示了生成器的优点
和注意事项。在实际工作中，充分利用Python生成器，不但能够减少内存使用，还能够提高代码可读性。
掌握生成器也是Python高手的标配。希望本文能够帮助大家理解Python的生成器