-------------------------纯手打总结，转载请注明出处，爱您~

3.2元组

• 元组和列表类似，但属于不可变序列，元组一旦创建，用任何方法都不可以修改其元素。
• 元组的定义方式和列表相同，定界符为圆括号"(" 和 ")"。

3.2.1 元组创建与删除

• 使用"="将一个元组赋值给变量。

>>> a_tuple=('a',)
>>> print(a_tuple)
('a',)
>>> a_tuple=('a','b','mpilgrim','z','example')
>>> print(a_tuple)
('a', 'b', 'mpilgrim', 'z', 'example')
>>> a=3
>>> print(a)
3
>>> a=(3,)
>>> print(a)
(3,)
>>> x=() #空元组
>>> print(x)
()
>>> 

• 使用tuple函数将其他序列转换成元组：

>>> print(tuple('abcdefg'))
('a', 'b', 'c', 'd', 'e', 'f', 'g')

>>> aList=[-1,-4,6,7.5,-3.3,9,-11]
>>> print(aList)
[-1, -4, 6, 7.5, -3.3, 9, -11]
>>> tuple(aList)
(-1, -4, 6, 7.5, -3.3, 9, -11)
>>> print(aList)
[-1, -4, 6, 7.5, -3.3, 9, -11]
#使用tuple函数转换成元组之后，原来的对象类型并没有改变，比如上面的，列表aList在使用tuple()函数转换成元组之后，原列表的并没有改变。
>>> s=tuple()    #空元组
>>> print(s)
()

注意！：使用del删除元组对象，不能删除元组对象

3.2.2 元组与列表的区别

• 元组中的数据一旦定义就不允许更改。
• 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
• 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
• 内建的tuple()函数接受一个列表参数，并返回一个包含同样元素的元组，而list()函数接收一个元组参数并返回一个列表。从效果上看，tuple()冻结列表，而list()融化元组。

>>> aList=[1,2,3]
>>> tuple(aList)
(1, 2, 3)    #将列表转为元组之后，列表的值不能被改变，所以被"冻结"。
>>> pList=(4,5,6)
>>> list(pList)
[4, 5, 6]    #元组的值定义之后就不能被改变，使用list()函数把元组转换为列表，进而能改变相应的值，即元组被"融化"。这样说可能不严谨，但是差不多就是这个意思。

3.2.3 元组的优点

• 元组的速度比列表更快。
• 元组对不需要改变的数据进行"写保护"将使得代码更加安全。
• 一些元组可用作字典键(特别是包含字符串、数值和其他元组这样的不可变数据的元组)。列表永远不能当作字典键使用，因为列表不是不可变的。

3.2.4 生成器推导式

• 生成器推导式与列表推导式非常接近，只是生成器推导式使用圆括号而不是列表推导式所使用的方括号。
• 与列表推导式不同的是，生成器推导式的结果是一个生成器对象，而不是列表，也不是元组。使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法(python 3.X)进行遍历，或者直接将其作为迭代器对象来使用。
• 列表推导式，也称列表解析式。使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历，过滤与再次计算，快速生成满足特定需求的新列表，代码简洁具有很强的可读性。格式为：>>>aList=[x*x for x in range(10)]
• 不管用哪种方法访问其元素，当所有元素访问结束以后,如果需要重新访问其中的元素，必须重新创建该生成器对象。

>>> g=((i+2)**2 for i in range(10))
#其中range10输出的结果是
>>> print(g)
<generator object <genexpr> at 0x00000217C340ED68>
>>> tuple(g)
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> tuple(g)
()
#使用__next__()方法，注意，要两个下划线
>>> g=((i+2)**2 for i in range(10))
>>> g.__next__()
4     
>>> g.__next__()
9    #这里的9是因为当元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象。上面的4已经访问结束了，现在元组中第一个没有被访问的元素是9，所以用__next__()方法访问的是9.
>>> next(g)
16    #内置函数next()

3.3 字典

• 字典是键值对的无序可变集合。
• 定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号"{" 和 "}" 中。
• 字典中的每个元素包含两部分：键和值，向字典添加一个键的同时，必须为该键增添一个值。
• 字典中的键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等。
• 字典中的键不允许重复。

3.3.1 字典创建与删除

• 使用=将一个字典赋值给一个变量。

>>> a_dict={'sever':'db.diveintopython3.org','database':'mysql'}
>>> print(a_dict)
{'sever': 'db.diveintopython3.org', 'database': 'mysql'}
>>> x={}   #空字典
>>> print(x)
{}

• 使用dict利用已有数据创建字典：

>>> keys=['a','b','c','d']
>>> values=[1,2,3,4]
>>> dictionary=dict(zip(keys,values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> x=dict()    #空字典
>>> print(x)
{}

• 使用dict根据给定的键、值创建字典：

>>> d=dict(name='Dong',age=37)
>>> print(d)
{'name': 'Dong', 'age': 37}

• 以给定内容为键，创建值为空的字典

>>> adict=dict.fromkeys(['name','age','sex'])
>>> adict
{'name': None, 'age': None, 'sex': None}

• 使用del删除整个字典

>>> del(adict)
>>> adict
Traceback (most recent call last):
  File "<pyshell#55>", line 1, in <module>
    adict
NameError: name 'adict' is not defined

3.3.2 字典元素的读取

• 以键作为下标可以读取字典元素,若键不存在则抛出异常

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> aDict['name']
'Dong'
>>> aDict['tel']
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    aDict['tel']
KeyError: 'tel'

只能使用[]列表来读取字典元素，当使用()元组来读取字典元素时就会报错。

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> aDict('name')
Traceback (most recent call last):
  File "<pyshell#63>", line 1, in <module>
    aDict('name')
TypeError: 'dict' object is not callable

• 使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> print(aDict.get('sex'))
male
>>> print(aDict.get('address'))
None
>>> print(aDict.get('address','Not exists'))   #指定的"键"不存在时返回指定的值
Not exists

• 使用字典对象的items方法可以返回字典的键、值对列表。
• 使用字典对象的keys方法可以返回字典的键列表。
• 使用字典对象的values方法可以返回字典的值列表。

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> aDict.values()
dict_values(['Dong', 37, 'male'])
>>> aDict.keys()
dict_keys(['name', 'age', 'sex'])
>>> aDict.items()
dict_items([('name', 'Dong'), ('age', 37), ('sex', 'male')])

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> for item in aDict.items():
    print(item)

    
('name', 'Dong')
('age', 37)
('sex', 'male')
>>> for key in aDict:   #默认遍历字典的"键"
    print(key )

    
name
age
sex

>>> for key,value in aDict.items():
    print(key,value)

    
name Dong
age 37
sex male
>>> print(aDict.keys())
dict_keys(['name', 'age', 'sex'])
>>> print(aDict.values())
dict_values(['Dong', 37, 'male'])
>>> aDict.keys()
dict_keys(['name', 'age', 'sex'])

3.3.3 字典元素的添加与修改

• 当以指定键为下标为字典赋值时，若键存在，则可以修改该键的值；若不存在，则表示添加一个键、值、对。

>>> aDict['age']=38
>>> aDict
{'name': 'Dong', 'age': 38, 'sex': 'male'}
>>> aDict['address']='SDIBT'
>>> aDict
{'name': 'Dong', 'age': 38, 'sex': 'male', 'address': 'SDIBT'}

注：使用字典时并不需要太在意元素的顺序。

• 使用字典对象的update方法将另一个字典的键、值对添加到当前字典对象。

>>> aDict={'name': 'Dong', 'age': 37, 'sex': 'male','score':[98,97]}
>>> aDict.items()
dict_items([('name', 'Dong'), ('age', 37), ('sex', 'male'), ('score', [98, 97])])
>>> aDict.update({'a':'a','b':'b'})
>>> aDict
{'name': 'Dong', 'age': 37, 'sex': 'male', 'score': [98, 97], 'a': 'a', 'b': 'b'}

• 使用del删除字典中指定键的元素

>>> aDict={'name':'Dong','age':37,'sex':'male'}
>>> del aDict['name']
>>> aDict
{'age': 37, 'sex': 'male'}

• 使用字典对象的clear方法来删除字典中所有元素

>>> aDict.clear()
>>> aDict
{}

• 使用字典元素的pop方法删除并返回指定键的元素

>>> aDict.pop('name')
'Dong'
>>> aDict
{'age': 37, 'sex': 'male'}

• 使用字典对象的popitem方法删除并返回字典中的一个元素。
  随机删除字典中的一个键值对，并且返回该键值对，(key,value)形式。之所以随机，是因为我们创建的字典是无序的，它返回给我们的字典是怎样的顺序我们并不清楚，但popitem()会从返回字典的第一个开始删除。

>>> aDict.popitem()
('sex', 'male')
>>> aDict
{'name': 'Dong', 'age': 37}

3.4 集合

• 集合是无序可变集合，使用一对大括号界定，元素不可重复

3.4.1 集合的创建与删除

• 直接将集合赋值给变量

>>> a={3,5}
>>> a.add(7)
>>> a
{3, 5, 7}

• 使用set将其他类型数据转换为集合

>>> a_set=set(range(8,14))
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set={0,1,2,3,0,1,2,3,7,8}
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> c_set=set()   #空集合
>>> c_set
set()

• 使用del删除整个集合qaz123
  del命令可删除整个集合，集合对象的pop()方法随机弹出使用并删除其中一个元素，集合对象的remove()方法直接删除指定元素，如果指定元素不存在则抛出异常；使用discard()方法从集合中删除一个特定元素，如果元素不在集合内则忽略该操作；集合对象的clear()方法清空集合删除所有元素。

>>> a={1,4,2,3}
>>> a.pop()
1
>>> print(a)
{2, 3, 4}
>>> a.pop()
2
>>> print(a)
{3, 4}
>>> a.add(2)
>>> print(a)
{2, 3, 4}
>>> a.remove(3)  #删除指定元素
>>> print(a)
{2, 4}
>>> a.pop(2)    #报错，pop方法不接收参数
Traceback (most recent call last):
  File "<pyshell#176>", line 1, in <module>
    a.pop(2)    #报错，pop方法不接收参数
TypeError: pop() takes no arguments (1 given)

3.4.2 集合操作

• Python集合支持交集、并集、差集等运算。
  (1).并集： a_set | b_set 等同于 a_set.union(b_set)

>>> a_set=set([8,9,10,11,12,13])
>>> b_set=set([0,1,2,3,7,8])
>>> a_set | b_set
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}

(2).交集：a_set&b_set 等同于 a_set.intersection(b_set)

>>> a_set&b_set
{8}

(3).差集： a_set-b_set 等同于 a_set.difference(b_set)

>>> a_set-b_set
{9, 10, 11, 12, 13}

(4). 对称差集(即A、B中不属于A∩B的集合)：a_set^b_set 等同于 a_set.symmetric_difference(b_set)

>>> a_set^b_set
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}

3.5 序列解包

• 序列解包的本质就是把一个序列或可迭代对象中的元素同时赋值给多个变量。
• 序列解包对于列表和字典同样有效

>>> x,y,z=1,2,3
>>> v_tuple=(False,3.5,'exp')
>>> (x,y,z)=v_tuple
>>> print(v_tuple)
(False, 3.5, 'exp')
>>> print(x,y,z)
False 3.5 exp

>>> a=[1,2,3]
>>> b,c,d=a
>>> print(b,c,d)
1 2 3

>>> s={'a':1,'b':2,'c':3}
>>> b,c,d=s.items()
>>> b
('a', 1)
>>> c
('b', 2)
>>> d
('c', 3)

>>> keys=['a','b','c','d']
>>> values=[1,2,3,4]
>>> for k,v in zip(keys,values):
    print(k,v)

    
a 1
b 2
c 3
d 4

>>> aList=[1,2,3]
>>> bList=[4,5,6]
>>> cList=[7,8,9]
>>> dList=zip(aList,bList,cList)
>>> for index,value in enumerate(dList):
    print(index,':',value)

    
0 : (1, 4, 7)
1 : (2, 5, 8)
2 : (3, 6, 9)

• 练习
  1.编写程序，生成包含20个随机数的列表，然后将列表前10个元素升序排列，后10个元素降序排列，并输出结果。

>>> num=list(range(20))  #包含20个整数的列表
>>> import random
>>> random.shuffle(num)  #把列表num中的元素随机乱序
>>> print(num)
[12, 4, 17, 14, 7, 5, 0, 16, 13, 10, 8, 11, 18, 1, 3, 6, 15, 9, 2, 19]
>>> left=num[0:10]
>>> left  #输出
[12, 4, 17, 14, 7, 5, 0, 16, 13, 10]
>>> left.sort()   #升序排列
>>> left           #输出排序结果
[0, 4, 5, 7, 10, 12, 13, 14, 16, 17]
>>> right=num[10::]    #利用切片操作取出列表中的后10个元素
>>> right     #输出
[8, 11, 18, 1, 3, 6, 15, 9, 2, 19]
>>>right.sort(reverse=True)
>>> print(right)  #降序排列并输出结果
[19, 18,15,11, 9, 8,6, 3,2, 1  ]

2.编写程序，生成包含1000个0~100之间的随机数，并统计每个元素的出现次数。

>>> import random
>>> i=0
>>> aList=[]
>>> while i<1000:
    a=random.randint(0,100)
    aList.append(a)
    i=i+1

    
>>> print(aList)
[39, 88, 60, 57, 53, 38, 51, 21, 80, 91, 0, 39, 3, 76, 45, 44, 50, 67, 22, 69, 15, 4, 74, 61, 95, 73, 94, 35, 23, 79, 39, 74, 94, 94, 31, 81, 1, 60, 50, 2, 79, 44, 28, 100, 71, 51, 82, 66, 47, 80, 17, 24, 26, 45, 19, 7, 64, 41, 16, 4, 29, 94, 5, 87, 10, 53, 10, 9, 96, 28, 50, 53, 89, 15, 96, 12, 66, 8, 81, 53, 42, 85, 42, 87, 72, 99, 95, 5, 10, 94, 18, 94, 45, 23, 75, 92, 68, 16, 30, 98, 30, 30, 30, 67, 0, 67, 69, 81, 37, 9, 99, 39, 65, 94, 59, 83, 43, 37, 1, 34, 63, 19, 15, 82, 83, 28, 73, 54, 74, 48, 93, 76, 100, 81, 22, 44, 99, 71, 43, 64, 60, 13, 47, 5, 96, 42, 92, 94, 79, 6, 85, 98, 77, 24, 99, 49, 66, 9, 17, 77, 53, 12, 60, 1, 82, 32, 5, 87, 55, 2, 76, 50, 47, 41, 97, 67, 11, 15, 70, 95, 9, 1, 26, 39, 64, 30, 33, 75, 31, 71, 58, 4, 89, 42, 20, 16, 88, 7, 24, 73, 71, 24, 20, 88, 3, 11, 0, 44, 85, 46, 31, 12, 37, 58, 10, 33, 42, 48, 17, 100, 34, 24, 52, 44, 36, 86, 20, 16, 90, 67, 96, 4, 77, 100, 25, 84, 84, 92, 60, 20, 36, 80, 93, 98, 7, 7, 42, 7, 67, 19, 87, 34, 3, 77, 73, 88, 77, 34, 93, 40, 69, 26, 90, 18, 68, 15, 5, 66, 46, 14, 12, 24, 81, 85, 66, 57, 62, 80, 39, 27, 83, 52, 90, 80, 65, 87, 85, 54, 57, 75, 55, 96, 34, 30, 12, 63, 66, 6, 0, 65, 20, 2, 33, 84, 70, 88, 54, 58, 93, 54, 94, 70, 71, 67, 67, 87, 48, 19, 36, 13, 87, 67, 36, 55, 33, 86, 42, 61, 96, 62, 91, 6, 4, 39, 87, 57, 77, 12, 45, 15, 100, 50, 4, 55, 48, 16, 68, 31, 10, 56, 60, 56, 13, 67, 57, 49, 49, 65, 49, 95, 42, 83, 71, 36, 68, 26, 43, 93, 30, 40, 3, 12, 53, 54, 32, 75, 15, 84, 27, 99, 7, 87, 56, 27, 27, 39, 96, 73, 73, 63, 67, 43, 38, 20, 25, 84, 63, 18, 65, 61, 84, 13, 90, 2, 64, 84, 2, 5, 88, 23, 70, 85, 86, 47, 40, 33, 14, 56, 6, 90, 97, 10, 44, 67, 13, 91, 25, 6, 84, 64, 50, 10, 38, 73, 5, 26, 58, 5, 71, 82, 55, 89, 7, 80, 75, 10, 55, 16, 74, 0, 48, 4, 66, 11, 49, 79, 93, 90, 9, 44, 86, 94, 72, 52, 15, 86, 45, 5, 50, 86, 82, 34, 43, 94, 16, 5, 22, 58, 11, 56, 31, 57, 83, 53, 67, 16, 96, 86, 74, 77, 99, 43, 48, 54, 25, 15, 52, 84, 45, 50, 75, 13, 54, 43, 36, 98, 95, 63, 47, 98, 47, 40, 39, 16, 5, 83, 44, 14, 47, 98, 29, 58, 49, 54, 75, 20, 21, 75, 80, 73, 23, 0, 85, 55, 94, 96, 56, 16, 89, 27, 99, 33, 43, 33, 94, 51, 41, 10, 83, 74, 22, 50, 10, 21, 81, 43, 95, 16, 87, 50, 70, 71, 64, 88, 83, 39, 41, 79, 84, 91, 96, 24, 7, 12, 27, 97, 86, 69, 23, 38, 22, 53, 55, 99, 43, 93, 23, 69, 95, 17, 4, 54, 5, 33, 81, 36, 39, 44, 21, 45, 19, 95, 48, 74, 49, 70, 83, 51, 45, 28, 33, 53, 45, 19, 1, 54, 14, 1, 34, 83, 10, 59, 86, 69, 27, 61, 41, 78, 65, 60, 10, 43, 46, 58, 89, 26, 99, 82, 1, 98, 52, 69, 8, 33, 41, 66, 22, 95, 22, 31, 33, 68, 66, 41, 58, 23, 91, 77, 11, 9, 1, 9, 6, 34, 64, 75, 65, 88, 70, 45, 13, 40, 18, 46, 11, 58, 80, 80, 14, 44, 66, 1, 94, 35, 9, 92, 92, 44, 2, 15, 51, 10, 58, 54, 17, 41, 19, 81, 74, 71, 0, 44, 65, 75, 30, 10, 45, 34, 38, 49, 6, 42, 25, 83, 100, 12, 45, 98, 66, 5, 100, 2, 65, 16, 95, 98, 76, 65, 37, 20, 37, 34, 35, 22, 55, 71, 51, 71, 84, 52, 19, 89, 54, 89, 26, 35, 38, 80, 0, 85, 18, 11, 76, 92, 72, 36, 43, 31, 39, 4, 91, 63, 97, 35, 50, 91, 33, 16, 36, 73, 86, 52, 46, 36, 85, 98, 21, 67, 10, 45, 30, 10, 90, 12, 21, 68, 42, 98, 23, 18, 86, 9, 67, 98, 4, 5, 46, 41, 88, 32, 29, 64, 39, 11, 100, 88, 62, 87, 87, 8, 40, 30, 95, 54, 61, 71, 24, 1, 6, 12, 94, 29, 3, 27, 21, 49, 36, 48, 16, 31, 36, 73, 60, 21, 14, 24, 70, 19, 51, 73, 19, 55, 97, 79, 89, 88, 52, 65, 98, 69, 4, 16, 83, 30, 31, 0, 88, 1, 20, 60, 87, 52, 79, 23, 100, 55, 10, 42, 37, 41, 24, 78, 22, 95, 13, 38, 72, 2, 22, 19, 62, 41, 71, 76, 2, 50, 76, 42, 86, 80, 99, 24, 52, 29, 84, 71, 26, 79, 27, 21, 87, 56, 30, 1, 63, 88, 55, 63, 25, 40, 53, 4, 3, 60, 37, 73, 74, 64, 6, 16, 66, 29, 79, 80, 38, 83, 71, 66, 55, 9, 94, 69, 58, 47, 24, 33, 27, 64, 63, 63, 18, 60, 28, 3, 13, 85, 72, 60, 24, 44, 51, 56, 43, 41, 65, 3, 17, 25, 49, 6, 83, 66, 82, 36, 6, 87, 64, 27, 10, 3, 38, 14, 60, 0, 82, 53, 1, 49, 1, 100, 56, 13, 22, 99, 67, 50, 59, 61, 21, 7, 84, 7, 18, 57, 23, 95, 49, 85, 93, 77]
>>> a_set={}
>>> for i in aList:
    a_set[i]=aList.count(i)

    
>>> print(a_set)
{39: 13, 88: 13, 60: 13, 57: 7, 53: 11, 38: 9, 51: 8, 21: 10, 80: 12, 91: 7, 0: 10, 3: 9, 76: 7, 45: 13, 44: 13, 50: 13, 67: 16, 22: 11, 69: 9, 15: 10, 4: 12, 74: 9, 61: 6, 95: 13, 73: 12, 94: 16, 35: 5, 23: 10, 79: 9, 31: 9, 81: 8, 1: 14, 2: 9, 28: 5, 100: 10, 71: 15, 82: 8, 66: 14, 47: 8, 17: 6, 24: 13, 26: 8, 19: 11, 7: 10, 64: 11, 41: 12, 16: 16, 29: 6, 5: 14, 87: 15, 10: 18, 9: 10, 96: 10, 89: 8, 12: 11, 8: 3, 42: 12, 85: 11, 72: 5, 99: 11, 18: 8, 75: 10, 92: 6, 68: 6, 30: 12, 98: 13, 37: 7, 65: 12, 59: 3, 83: 14, 43: 13, 34: 10, 63: 10, 54: 13, 48: 8, 93: 8, 13: 10, 6: 11, 77: 9, 49: 12, 32: 3, 55: 13, 97: 5, 11: 8, 70: 8, 33: 13, 58: 11, 20: 9, 46: 6, 52: 10, 36: 13, 86: 12, 90: 7, 25: 7, 84: 13, 40: 7, 14: 7, 62: 4, 27: 11, 56: 9, 78: 2}
>>> for i in a_set.keys():
    print("在1000个随机数中，数字"+str(i)+"出现的次数为"+str(a_set[i])+"次")

    
在1000个随机数中，数字39出现的次数为13次
在1000个随机数中，数字88出现的次数为13次
在1000个随机数中，数字60出现的次数为13次
在1000个随机数中，数字57出现的次数为7次
在1000个随机数中，数字53出现的次数为11次
在1000个随机数中，数字38出现的次数为9次
在1000个随机数中，数字51出现的次数为8次
在1000个随机数中，数字21出现的次数为10次
在1000个随机数中，数字80出现的次数为12次
在1000个随机数中，数字91出现的次数为7次
在1000个随机数中，数字0出现的次数为10次
在1000个随机数中，数字3出现的次数为9次
在1000个随机数中，数字76出现的次数为7次
在1000个随机数中，数字45出现的次数为13次
在1000个随机数中，数字44出现的次数为13次
在1000个随机数中，数字50出现的次数为13次
在1000个随机数中，数字67出现的次数为16次
在1000个随机数中，数字22出现的次数为11次
在1000个随机数中，数字69出现的次数为9次
在1000个随机数中，数字15出现的次数为10次
在1000个随机数中，数字4出现的次数为12次
在1000个随机数中，数字74出现的次数为9次
在1000个随机数中，数字61出现的次数为6次
在1000个随机数中，数字95出现的次数为13次
在1000个随机数中，数字73出现的次数为12次
在1000个随机数中，数字94出现的次数为16次
在1000个随机数中，数字35出现的次数为5次
在1000个随机数中，数字23出现的次数为10次
在1000个随机数中，数字79出现的次数为9次
在1000个随机数中，数字31出现的次数为9次
在1000个随机数中，数字81出现的次数为8次
在1000个随机数中，数字1出现的次数为14次
在1000个随机数中，数字2出现的次数为9次
在1000个随机数中，数字28出现的次数为5次
在1000个随机数中，数字100出现的次数为10次
在1000个随机数中，数字71出现的次数为15次
在1000个随机数中，数字82出现的次数为8次
在1000个随机数中，数字66出现的次数为14次
在1000个随机数中，数字47出现的次数为8次
在1000个随机数中，数字17出现的次数为6次
在1000个随机数中，数字24出现的次数为13次
在1000个随机数中，数字26出现的次数为8次
在1000个随机数中，数字19出现的次数为11次
在1000个随机数中，数字7出现的次数为10次
在1000个随机数中，数字64出现的次数为11次
在1000个随机数中，数字41出现的次数为12次
在1000个随机数中，数字16出现的次数为16次
在1000个随机数中，数字29出现的次数为6次
在1000个随机数中，数字5出现的次数为14次
在1000个随机数中，数字87出现的次数为15次
在1000个随机数中，数字10出现的次数为18次
在1000个随机数中，数字9出现的次数为10次
在1000个随机数中，数字96出现的次数为10次
在1000个随机数中，数字89出现的次数为8次
在1000个随机数中，数字12出现的次数为11次
在1000个随机数中，数字8出现的次数为3次
在1000个随机数中，数字42出现的次数为12次
在1000个随机数中，数字85出现的次数为11次
在1000个随机数中，数字72出现的次数为5次
在1000个随机数中，数字99出现的次数为11次
在1000个随机数中，数字18出现的次数为8次
在1000个随机数中，数字75出现的次数为10次
在1000个随机数中，数字92出现的次数为6次
在1000个随机数中，数字68出现的次数为6次
在1000个随机数中，数字30出现的次数为12次
在1000个随机数中，数字98出现的次数为13次
在1000个随机数中，数字37出现的次数为7次
在1000个随机数中，数字65出现的次数为12次
在1000个随机数中，数字59出现的次数为3次
在1000个随机数中，数字83出现的次数为14次
在1000个随机数中，数字43出现的次数为13次
在1000个随机数中，数字34出现的次数为10次
在1000个随机数中，数字63出现的次数为10次
在1000个随机数中，数字54出现的次数为13次
在1000个随机数中，数字48出现的次数为8次
在1000个随机数中，数字93出现的次数为8次
在1000个随机数中，数字13出现的次数为10次
在1000个随机数中，数字6出现的次数为11次
在1000个随机数中，数字77出现的次数为9次
在1000个随机数中，数字49出现的次数为12次
在1000个随机数中，数字32出现的次数为3次
在1000个随机数中，数字55出现的次数为13次
在1000个随机数中，数字97出现的次数为5次
在1000个随机数中，数字11出现的次数为8次
在1000个随机数中，数字70出现的次数为8次
在1000个随机数中，数字33出现的次数为13次
在1000个随机数中，数字58出现的次数为11次
在1000个随机数中，数字20出现的次数为9次
在1000个随机数中，数字46出现的次数为6次
在1000个随机数中，数字52出现的次数为10次
在1000个随机数中，数字36出现的次数为13次
在1000个随机数中，数字86出现的次数为12次
在1000个随机数中，数字90出现的次数为7次
在1000个随机数中，数字25出现的次数为7次
在1000个随机数中，数字84出现的次数为13次
在1000个随机数中，数字40出现的次数为7次
在1000个随机数中，数字14出现的次数为7次
在1000个随机数中，数字62出现的次数为4次
在1000个随机数中，数字27出现的次数为11次
在1000个随机数中，数字56出现的次数为9次
在1000个随机数中，数字78出现的次数为2次
>>> 

-------------------------纯手打总结，转载请注明出处，爱您~