blocks|key|1275062|text|也许uuid.uuid4()可以做这项工作。有关详细信息，请参阅uuid。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1275063|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/uuid.html^0|2|C|W|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Perhaps <code>uuid.uuid4()</code> might do the job. See <a href="http://docs.python.org/library/uuid.html" rel="noreferrer">uuid</a> for more information.

blocks|key|1489934|text|也许是uuid模块？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1489935|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/uuid.html^0|3|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Maybe the <a href="http://docs.python.org/library/uuid.html" rel="nofollow noreferrer">uuid</a> module?

blocks|key|1275134|text|唯一性和随机性是互斥的。也许你想要这个？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275135|import+random
def+uniqueid():
++++seed+=+random.getrandbits(32)
++++while+True:
+++++++yield+seed
+++++++seed+%2B=+1|code-block|syntax|javascript|1275136|用法：|1275137|unique_sequence+=+uniqueid()
id1+=+next(unique_sequence)
id2+=+next(unique_sequence)
id3+=+next(unique_sequence)
ids+=+list(itertools.islice(unique_sequence,+1000))|1275138|没有两个返回的id是相同的(唯一的)，这基于随机化的种子值|1275139|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

unique and random are mutually exclusive. perhaps you want this?

<pre><code>import random
def uniqueid():
 seed = random.getrandbits(32)
 while True:
 yield seed
 seed += 1
</code></pre>

Usage:

<pre><code>unique_sequence = uniqueid()
id1 = next(unique_sequence)
id2 = next(unique_sequence)
id3 = next(unique_sequence)
ids = list(itertools.islice(unique_sequence, 1000))
</code></pre>

no two returned id is the same (Unique) and this is based on a randomized seed value

blocks|key|1275151|text|import+time
import+random
import+socket
import+hashlib

def+guid(+*args+):
++++"""
++++Generates+a+universally+unique+ID.
++++Any+arguments+only+create+more+randomness.
++++"""
++++t+=+long(+time.time()+*+1000+)
++++r+=+long(+random.random()*100000000000000000L+)
++++try:
++++++++a+=+socket.gethostbyname(+socket.gethostname()+)
++++except:
++++++++#+if+we+can't+get+a+network+address,+just+imagine+one
++++++++a+=+random.random()*100000000000000000L
++++data+=+str(t)%2B'+'%2Bstr(r)%2B'+'%2Bstr(a)%2B'+'%2Bstr(args)
++++data+=+hashlib.md5(data).hexdigest()

++++return+data|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1275152|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import time
import random
import socket
import hashlib

def guid( *args ):
 """
 Generates a universally unique ID.
 Any arguments only create more randomness.
 """
 t = long( time.time() * 1000 )
 r = long( random.random()*100000000000000000L )
 try:
 a = socket.gethostbyname( socket.gethostname() )
 except:
 # if we can't get a network address, just imagine one
 a = random.random()*100000000000000000L
 data = str(t)+' '+str(r)+' '+str(a)+' '+str(args)
 data = hashlib.md5(data).hexdigest()

 return data
</code></pre>

blocks|key|1275163|text|你可以在这里找到一个实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275164|def+__uniqueid__():
++++"""
++++++generate+unique+id+with+length+17+to+21.
++++++ensure+uniqueness+even+with+daylight+savings+events+(clocks+adjusted+one-hour+backward).

++++++if+you+generate+1+million+ids+per+second+during+100+years,+you+will+generate+
++++++2*25+(approx+sec+per+year)+*+10**6+(1+million+id+per+sec)+*+100+(years)+=+5+*+10**9+unique+ids.

++++++with+17+digits+(radix+16)+id,+you+can+represent+16**17+=+295147905179352825856+ids+(around+2.9+*+10**20).
++++++In+fact,+as+we+need+far+less+than+that,+we+agree+that+the+format+used+to+represent+id+(seed+%2B+timestamp+reversed)
++++++do+not+cover+all+numbers+that+could+be+represented+with+35+digits+(radix+16).

++++++if+you+generate+1+million+id+per+second+with+this+algorithm,+it+will+increase+the+seed+by+less+than+2**12+per+hour
++++++so+if+a+DST+occurs+and+backward+one+hour,+we+need+to+ensure+to+generate+unique+id+for+twice+times+for+the+same+period.
++++++the+seed+must+be+at+least+1+to+2**13+range.+if+we+want+to+ensure+uniqueness+for+two+hours+(100%25+contingency),+we+need+
++++++a+seed+for+1+to+2**14+range.+that's+what+we+have+with+this+algorithm.+You+have+to+increment+seed_range_bits+if+you
++++++move+your+machine+by+airplane+to+another+time+zone+or+if+you+have+a+glucky+wallet+and+use+a+computer+that+can+generate
++++++more+than+1+million+ids+per+second.

++++++one+word+about+predictability+:+This+algorithm+is+absolutely+NOT+designed+to+generate+unpredictable+unique+id.
++++++you+can+add+a+sha-1+or+sha-256+digest+step+at+the+end+of+this+algorithm+but+you+will+loose+uniqueness+and+enter+to+collision+probability+world.
++++++hash+algorithms+ensure+that+for+same+id+generated+here,+you+will+have+the+same+hash+but+for+two+differents+id+(a+pair+of+ids),+it+is
++++++possible+to+have+the+same+hash+with+a+very+little+probability.+You+would+certainly+take+an+option+on+a+bijective+function+that+maps
++++++35+digits+(or+more)+number+to+35+digits+(or+more)+number+based+on+cipher+block+and+secret+key.+read+paper+on+breaking+PRNG+algorithms+
++++++in+order+to+be+convinced+that+problems+could+occur+as+soon+as+you+use+random+library+:)

++++++1+million+id+per+second+?...+on+a+Intel(R)+Core(TM)2+CPU+6400+@+2.13GHz,+you+get+:

++++++>>>+timeit.timeit(uniqueid,number=40000)
++++++1.0114529132843018

++++++an+average+of+40000+id/second
++++"""
++++mynow=datetime.now
++++sft=datetime.strftime
++++#+store+old+datetime+each+time+in+order+to+check+if+we+generate+during+same+microsecond+(glucky+wallet+!)
++++#+or+if+daylight+savings+event+occurs+(when+clocks+are+adjusted+backward)+[rarely+detected+at+this+level]
++++old_time=mynow()+#+fake+init+-+on+very+speed+machine+it+could+increase+your+seed+to+seed+%2B+1...+but+we+have+our+contingency+:)
++++#+manage+seed
++++seed_range_bits=14+#+max+range+for+seed
++++seed_max_value=2**seed_range_bits+-+1+#+seed+could+not+exceed+2**nbbits+-+1
++++#+get+random+seed
++++seed=random.getrandbits(seed_range_bits)
++++current_seed=str(seed)
++++#+producing+new+ids
++++while+True:
++++++++#+get+current+time+
++++++++current_time=mynow()
++++++++if+current_time+<=+old_time:
++++++++++++#+previous+id+generated+in+the+same+microsecond+or+Daylight+saving+time+event+occurs+(when+clocks+are+adjusted+backward)
++++++++++++seed+=+max(1,(seed+%2B+1)+%25+seed_max_value)
++++++++++++current_seed=str(seed)
++++++++#+generate+new+id+(concatenate+seed+and+timestamp+as+numbers)
++++++++#newid=hex(int(''.join([sft(current_time,'%25f%25S%25M%25H%25d%25m%25Y'),current_seed])))[2:-1]
++++++++newid=int(''.join([sft(current_time,'%25f%25S%25M%25H%25d%25m%25Y'),current_seed]))
++++++++#+save+current+time
++++++++old_time=current_time
++++++++#+return+a+new+id
++++++++yield+newid

"""+you+get+a+new+id+for+each+call+of+uniqueid()+"""
uniqueid=__uniqueid__().next

import+unittest
class+UniqueIdTest(unittest.TestCase):
++++def+testGen(self):
++++++++for+_+in+range(3):
++++++++++++m=[uniqueid()+for+_+in+range(10)]
++++++++++++self.assertEqual(len(m),len(set(m)),"duplicates+found+!")|code-block|syntax|javascript|1275165|希望它能帮上忙！|1275166|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

here you can find an implementation :

<pre><code>def __uniqueid__():
 """
 generate unique id with length 17 to 21.
 ensure uniqueness even with daylight savings events (clocks adjusted one-hour backward).

 if you generate 1 million ids per second during 100 years, you will generate 
 2*25 (approx sec per year) * 10**6 (1 million id per sec) * 100 (years) = 5 * 10**9 unique ids.

 with 17 digits (radix 16) id, you can represent 16**17 = 295147905179352825856 ids (around 2.9 * 10**20).
 In fact, as we need far less than that, we agree that the format used to represent id (seed + timestamp reversed)
 do not cover all numbers that could be represented with 35 digits (radix 16).

 if you generate 1 million id per second with this algorithm, it will increase the seed by less than 2**12 per hour
 so if a DST occurs and backward one hour, we need to ensure to generate unique id for twice times for the same period.
 the seed must be at least 1 to 2**13 range. if we want to ensure uniqueness for two hours (100% contingency), we need 
 a seed for 1 to 2**14 range. that's what we have with this algorithm. You have to increment seed_range_bits if you
 move your machine by airplane to another time zone or if you have a glucky wallet and use a computer that can generate
 more than 1 million ids per second.

 one word about predictability : This algorithm is absolutely NOT designed to generate unpredictable unique id.
 you can add a sha-1 or sha-256 digest step at the end of this algorithm but you will loose uniqueness and enter to collision probability world.
 hash algorithms ensure that for same id generated here, you will have the same hash but for two differents id (a pair of ids), it is
 possible to have the same hash with a very little probability. You would certainly take an option on a bijective function that maps
 35 digits (or more) number to 35 digits (or more) number based on cipher block and secret key. read paper on breaking PRNG algorithms 
 in order to be convinced that problems could occur as soon as you use random library :)

 1 million id per second ?... on a Intel(R) Core(TM)2 CPU 6400 @ 2.13GHz, you get :

 &gt;&gt;&gt; timeit.timeit(uniqueid,number=40000)
 1.0114529132843018

 an average of 40000 id/second
 """
 mynow=datetime.now
 sft=datetime.strftime
 # store old datetime each time in order to check if we generate during same microsecond (glucky wallet !)
 # or if daylight savings event occurs (when clocks are adjusted backward) [rarely detected at this level]
 old_time=mynow() # fake init - on very speed machine it could increase your seed to seed + 1... but we have our contingency :)
 # manage seed
 seed_range_bits=14 # max range for seed
 seed_max_value=2**seed_range_bits - 1 # seed could not exceed 2**nbbits - 1
 # get random seed
 seed=random.getrandbits(seed_range_bits)
 current_seed=str(seed)
 # producing new ids
 while True:
 # get current time 
 current_time=mynow()
 if current_time &lt;= old_time:
 # previous id generated in the same microsecond or Daylight saving time event occurs (when clocks are adjusted backward)
 seed = max(1,(seed + 1) % seed_max_value)
 current_seed=str(seed)
 # generate new id (concatenate seed and timestamp as numbers)
 #newid=hex(int(''.join([sft(current_time,'%f%S%M%H%d%m%Y'),current_seed])))[2:-1]
 newid=int(''.join([sft(current_time,'%f%S%M%H%d%m%Y'),current_seed]))
 # save current time
 old_time=current_time
 # return a new id
 yield newid

""" you get a new id for each call of uniqueid() """
uniqueid=__uniqueid__().next

import unittest
class UniqueIdTest(unittest.TestCase):
 def testGen(self):
 for _ in range(3):
 m=[uniqueid() for _ in range(10)]
 self.assertEqual(len(m),len(set(m)),"duplicates found !")
</code></pre>

hope it helps !

blocks|key|1275197|text|也许这对你有用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275198|str(uuid.uuid4().fields[-1])[:5]|code-block|syntax|javascript|1275199|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Maybe this work for u

<pre><code>str(uuid.uuid4().fields[-1])[:5]
</code></pre>

I need to generate a unique ID based on a random value.

How can I generate a unique ID in Python?

我需要根据随机值生成一个唯一的ID。

问如何在Python中生成唯一ID？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中生成唯一ID？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中生成唯一ID？
EN