开发者学堂课程【Python 开发基础入门：Python 编程必备-Python 列表实现】学习笔记，与课程紧密联系，让用户快速学习知识。
课程地址：https://developer.aliyun.com/learning/course/556/detail/7655
Python 编程必备-Python 列表实现
目录：
一、范例讲解
二、转置矩阵
三、Enumerate用法
一、范例讲解
这道题它是在问的是第m行，第n个元素。那想第二行第一个元素，第二行，第二个元素也是以第三行就不同了，第一个元素它是末尾的元素，其实是最简单的方式，是可以找规律计算，但是应该往后放，因为这个里面它有很多不是能想到的规律。
必须得想办法计算，按照前面的做法，也是能做出来的，不管是先给它加上去组织用前一行的数据，还是把它再变两个列表交替来算的话，也是知道前一行数据，之后相互覆盖，总之还是知道前一行数据。这其实都是同一种算法，只不过同一种简化出来，它的空间使用率和它的时间复杂度但是不一样的，尤其在空间使用数量还是越来越简化的，而且它采用了一组。
甚至还找到了中心对称的这种左右对称，之后发现可以把左边算出来，或者把右边先算出来，之后那一半就可以算出来了。通过这些方式来对它进行优化，优化从而减少计算量。
说减少计算量，进一步提升它在算大数据规模的时候，它的计算量。提高计算速度。
之后根据杨辉三角的第二定理，刚才说的第一种算法就是杨辉三角的第一种定义。也是它第一个性质，可以发现它有这个规律，就是两边是一，之后中间是经过上面两个元素的相加来的，还发现了，之后重复索引字段，像这种方式，它都是按照某种规律来形成的，规律形成这样，找到规律.
但是如果这样规定的话，它必须从前一直迭代到想要的行，之后发现它的性质，说它是一个多项式展开的系数。
而这个多项式展开系数，它发现它是组合数的规律，它说第n行的第m个数也就是说，就转化成了从什么里面一个组合数的第n行第m个数变成n-1。
就看着匹配索引从0开始，就这个一个概念，关键组合数公式。
1.求杨辉三角的第m行第k个元素
2.第m行有m项,m是正整数，因此k一定不会大于m
3.第n行的m个数可表示为C(n-1 , m-1)，即为从n-1个不同元素中取m-1个元素的组合数
当不考虑组合数的时候
m= 5,
k = 4
triangle = []这里先给个大框子
for i in range(m):
#所有行都需要1开头
row = [1]
triangle.append(row)
if i == 0 :
continue
for j in range(1,i):这里都是特例
row.append(triangle[i-1][j-1]+triangle[i-1][j])row.append(1)
print(triangle)print("---------")
print(triangle[m-1][k-1])
print("---------")
这种方式算出第m行第k项
范例
算法二
求杨辉三角的第m行第k个元素
组合数公式∶有m个不同元素，任意取n(n≤m)个元素，记作c(m,n)，组合数公式为
C(m, n) = m!/(n!(m - n)!)
从六个里面取三个，相当于五个里面取三个，变成了五的阶乘除以三的阶乘，这地方再乘以二的阶乘。
算阶乘的问题，但是如果现在是算阶乘的问题，算阶乘那个例子过。但是这里面有个取巧的地方，就在五的阶乘，两端，找到一些方法，从现在规模小的时候，发现532阶乘之间是有简单关系，但是现在通过这样思考发现好像数字上，得算从某个开始到后面的成绩，之后从2之后的约掉了一个东西之后，从这个起点，向后一直到5的这块相当于不能说阶乘，也就是前面也得乘，后面还得乘，里面还得除一遍，也从里面剔除掉，发现规律，研究5之后，的三和二就可以不考虑了。
235的规律，如果要不做任何变形的话，5得阶乘算出来了，23的阶乘也出来了，至少要算到5的阶乘，通过公示第六行取四个的C53,如果想拿到一个普遍性的东西，是就看一下它阶乘之间的关系。
发现阶乘之间的关系现在是要算上那个所谓的最大数。就可以把所有的算完最后变成除法。
一次把想要的数据算完，通过组合数公式变形来算。k等于1或者等于m的时候，是头尾的时候，直接把底下迭代都不用进，直接报给它就行，看杨辉三角，它第二个元素就这样的，第三个元素就不放出来。而它有一定间隔，它有规律，第四行其实都是有规律的看一下，就是特例，如果需要的话。
半段的解决，之后看下面一个怎么做，下面要做的方式很简单，一直迭代，说它是从一开始这样累积，当i等于二的时，就把它给放进来。I=2的时候，谁在第一项是第二项是没关系，就是按照原始的公式用，就做三项来做，谁在前，谁在后，没关系。
这个地方，这是一句话。所以一定会保证它在这个列表中最后一项，但是绝对不能把这两个条件是写在一起一个等于就少了一项，所以一定得分开写，这三项绝对不能和在一起得各写各的。
尤其是前两项绝对要各写各的，因为有可能等于四。这个地方并不考虑顺序就可以算，当然可以用它的性质。
#m行k列的值，c(m-1,k-1)组合数
m = 9
k = 5
# c(n,r) = c(m-1,k-1) = (m-1)!/((k-1)!(m-r) !)
# m最大
n = m - 1 这里是8
r = k - 1
d = n - r
targets = []# r ,n-r, n
factorial = 1
#可以加入k为1或者m的判断，返回1 头尾的时候直接返回1
for i in range(1,n+1):
factorial *= i 开始累积
if i == r:
targets.append(factorial) 当i=r放入第一项上
if i == d: 等于d时放第二项，但是它有顺序，因为是相乘所以顺序没有关系但是不能把两个条件写在一起，要各写各的。
targets.append(factorial)
if i == n:
targets.append(factorial) 一定要一起写，不能分开写
#print(targets)
print(targets[2]//(targets[e]*targets[1]))
ir、in、i==d这三个条件不要写在一起，因为它有可能两两相等。
算法说明:一趟到n的阶乘算出所有阶乘值。
二、转置矩阵
1）看见矩阵，应该想到它是二维的
matrix ='1 2 3in4 5 6ln7 8 9'
print (matrix + 'ln ' )
length_column = len (matrix.split ( 'in ' ))
matrix= matrix.split ()
length_row = len (matrix) //length_column
print (matrix)
for i in range (length_row) :
for j in range ( length_column ) :
print (matrix[j* 3 + i],end = ' ")
print ( 'lr ')
如果扭转怎么解决，转置矩阵的意思是扭转，但是这里是print，由于找到其中的规律，
2）
List1 =[ [1,2,3],[4,5,6]]#,[ 7,8,9]]
for i in range (len (list1)):
for p in range ( len (list1[0] )):
print ( list1[i][p],end - '")print ()
print ( ' -"*10)
for i in range (len (list1[0])) :
for p in range (len (list1)) :
print (list1 [p][i], end = ' ')
print ()
空间结构上没有任何变化。
3）
m=[ [1,2,3],[4,5,6],[7,8,9]]
for i in range (len (m) ) :
for j in range (i) :
m[i][j],m[j][i]= m[j][i], m[i][j]
print (m)
[ [1,4，7]，[2，5，8 ],[3，6，9]]
如果说构造二维结构，坐标写出来，对角线不动，40，37换下，要统计一下归纳一下，所以说，现在发现这跟那个乘法表一样，只要整一半儿就行了，都是连边界都不用动。
找跟它对应的，所以说找对应，如果说把它构造成二维结构的话，把坐标是打印出来，如果这是行的话，同行来代表它是第几个的话，这是第一行，这是第二行，第一个元素，第二个元素，40应该表示成0，这样的坐标系能够变出来，要构建出来以后，下面就是一走到边界之后，边界下半部分找到一个元素，就把坐标相当于扭转一下就找到了对方交换，调换一下就行了。
这里已经考虑把对角线的条件写出来了
4）lst1 = [ [1,2,3],
[4,5,6]，
[ 7,8,9]]
x等于的情况
for x in range ( len ( lst1) ) : （通用写法）
for y in range ( len (lst1 [x])):
if y > x:
lst1[x][y] ,lst1[y][x] = lst1[y][x],lst1 [x][y]
print (lst1[xj)|i
这样的写法可以适用与非方阵，如果这个长度3可以取012，它的循环一个都不少，等于与对角线都不用做，
凡y>X的时候，或者说yX，总之要么是对角线上方，要么就是对角线下方。
大于y>X，就是在对角线的上方或者下方，之后找到了以后做交换。
最后打印一下就可以了，当然它最后是整体打印。
也可以含在range函数里，暗示了y的取值范围一定大于x。
5）
line = [ [1,2,3],[4,5,6],[7,8,9]]
for k in line:
for t in k:
print (t,end = "")
print ()
print ( " ~~~ ~ ~ ~ ~~~" )
n= 0
for i in line:
m=0
for j in i:
print ( "{J ".format (line [m] [n]), end - "")
m+=1
print ()
n +=1
解决一些索引找到的规律在交换，建议不用打印的版本
6）square=[ [1,2,3],[4,5,6],[7,8,9]]
print ( ' { }n{ } in{ ) '.format (square[0], square[1],square[2]))
print ( '---———三———-==')
for i in range (3) :
for j in range (3) :
If j > i:
tmp=square[i][j]
square[i][j]=square[j][i]
square[j][i]=tmp
print(' { }in{}in{ } '.format (square[0],square[1] , square [2]))
7）
import copy
matrix1 = [ [1,2,3],[4,5,6],[7,8,9]]把它们都替换为空，把空格们都弄掉
print ( 'Befer : ')
print (str (matrix1)
.replace ( ' ],','n ')
.replace ( ' ]", "')
.replace ( 'l，‘’）
.replace ( 'l，‘’）
.replace ( ' ')
)
matrix2 = copy.deepcopy (matrix1)
for m in range (3) :
for n in range (3) :
matrix2[m][n] = matrix1[n] [m]
print ( " { }After : '.format ( 'ln ' ))
print (str (matrix2)
.replace ( 'l,','ln ')
.replace ( '
.replace (
'.replace ( '
.replace ( '
）
这里用函数索引会更高级一点，用 replace 也可以有更好的解决方案，这里用了深拷贝。
二、Enumerate 用法
enumerate 对一个列表把它 enumerate 完了之后，列表因为是有序的，因为本来就想用列表的索引，但是有的时候发现还求个 lens 之后再做，那 enumerate 能给配对出来的东西。
Enumeraterange5 一看到这玩意儿，这东西立即不会给返回想看到的东西，也就是说，它实际上是生成一个了对象，要用的时候，再给一个，当list这东西要用的时候，要立即给生成一个列表，它就从 range 里面拿出一个数据配个对，之后range函数也不会立即给到它会返回到range对象，此时 range 给了它一个0，enumerate默认就会给配对一个所谓的索引给那个0。
就给配上来之后，就是两零零配合好就凑成了一对一对二元组。所以它其实是内部是一个现在需要相当于去迭代，再去迭代 range 的这么一个过程，之后一个给一个凑数字，直到一直把这些数字全部给凑好。但是 enumerate start 还有一个等于0的一个问题，比如说它来个一百。走一半。
如果不该，它就默认就跟索引一样从0开始，默认还是start等于0，就可以改成想要的东西，比如说 start等于一，为了计算方便，enumerate range 5就变成了二元组，如果想用前面那个0，那就在加一个0，此时就可以了。
其它方案：
因为明细知道是个二元组，就可以解构，如果不解构就是一个整体，结果就是把它拆开。
经常在用索引，或者对它的值经常用enumerate因为会配对一个数据，就会变成一个可迭代对象，这个时候没有必要用list。
[1] : enumerate(range (5))
[2]: list(enumerate(range(5)))
: [(0，0)，(1，1)，(2，2)，(3,3)，(4，4)]
[3]: list(enumerate(range(5) , 100))
: [(100，0)，(101，1)，(102，2)，(103，3)，(104，4)]
[4]: for i in list(enumerate(range(5))):
print(i)
(0，0)
(1，1)
n[5]: for i in list(enumerate (range（5），100））：
print(i[0])
100
101
102
103
104
n[6]：for i, val in list(enumerate (range（5），100））
print(i[0])
100
101
102
103
104
n[7]：for i, val in list(enumerate (range（5），100））
print(i，val)
100 0
101 1
102 2
103 3
104 4
所以当想使用索引时用enumerate，没必要再用list
enumerate(iterable[， start]) -> iterator for index，value of iterable
返回一个可迭代对象，将原有可迭代对象的元素和从start开始的数字配对。
解决方案:
matrix = [[1,2,3]，[4,5,6]，[7,8,9]]
print(matrix)
count = e
for i,row in enumerate(matrix):
for j, col in enumerate(rowl):
if i < j :
temp = matrix[i][j]
matrix[i][j] = matrix[j][i]
matrix[j][i] = temp
count += 1
print(matrix)
print(count)
转置矩阵这个东西，究竟应该是开启一个新内存里面转制出来，还是说在原基础上转置，这里模式是一样，按照这个题的经典解法，一般来讲都是在半矩阵上，之后进行转弯，那么它这意思就说原来不动，相当影响圆角矩阵，拷贝出来之后，随弄了它在第二个矩阵上。
抽答：
写法1：
#给定一个3*3方阵，求其转置矩阵
m= [ [1,2,3],[4,5,6]，[7,8,9]]
for i in range (len (m) ) :
for j in range(i) :
m[i][j], m[j][i]= m[j][i], m[i][j]
print (m)
需要考虑对角线
通用写法
写法2:
lst1 =[ [1,2,3],
[ 4,5,6]，
[ 7,8,9]]
for x in range ( len (lst1) ) :
for y in range ( len (lst1[x])):
if y > x:
lst1[x] [y] , lst1[y][x]= lst1[y][x],lst1[x][y]
print (lst1)
#方法2
matrix = [[1,2,3,10],[4,5,6,11],[7,8,9,12],[1,2,3,4]]
length = len(matrix)
count = e
for i in range(length):
for j in range(i): # j
到i为止，它的问题是一个左闭右开的问题，注意count是不是最小的。
arr[i][j],arr[j][i]= arr[j][i],arr[i][j]
count += 1
print(matrix)
print(count)
其它两种思路：
算法1：
过程就是，扫描matrix第一行，在tm的第一列从上至下附加，之后再第二列附加
举例，扫描第一行1,2,3，加入到tm的第一列，之后扫描第二行4,5,6，追加到tm的第二列
当不用enumerate的时候，它的过程就扫描第一行，有个目标，接下来创建一个新的矩阵，之后在第二趟附加，举例，扫描第一行，你拿到123，把它依次加到的目标矩阵的第一行，第二行，第三行。
你的第一个，当不知道该怎么加进去，们说这个地方实际上先走一次先做一次循环，但是肯定想一次循环能不能搞定全部搞定，但是可能先可以先考虑说这边是不是有几列，几行，指望每一行中开辟的过程中，是不是可以把一个列表进去，所以这才能构成一个二维结构，满二元结构。
在tm里面扫描完123，看看这个矩阵里面现在有几行，这个矩阵联系的一行都没有要一个空列表进去，之后在这个空列表里面，再怎么追加一个一进来，之后当扫描的这个元素时候，就得为这个大矩阵里在增加一行，之后在这个玩意儿里面的第一项把二技加进去。
当第二行456来的时候，就没有必要再追加半个列表，关键就是这款有个小技巧。
提问：这种追加能不能在一趟循环全部搞定，连追加一个列表，在列表里面追加第一个元素，第二个元素这套逻辑。
说们现在有个矩阵，这是的目标矩阵，
#定义一个矩阵，不考虑稀疏矩阵
#12 3 14
# 4 5 6 ==>> 2 5
# 3 6
import datetime
matrix = [[1,2,3]，[4,5,6]]这里把数字标上去
#matrix = [[1,4],[2,5],[3,6]]
tm = []当一行都没有，这个行数是0，如果小于i+1,i与竖行相关，内层循环与列相关，当前123有三列，分别对应元素012，i第一次进来读到1，i当前是1，长度小于1，追加一个空列表变成打的列表里有了第一行空列表，判断做完，对外层tm来讲，外层中括号的长度，当小于2在追加一个空列表，把2追加带进来走到3在小于再追加列表把3加进来，此时大循环回头取了456。
count = 0
for row in matrix:这个东西发现不需要enumerate，独立一行依次读它的元素，
for i, col in enumerate(row):
if len(tm) < i + 1:# matrix有i列就要为tm创建i行
tm.append([])
tm[i].append(col) ，
count += 1
或者现在外面创建结构，在追加。
该怎么去创建目标，循环把目标的结构创建好了以后，发现里面是个空的，发现实际上相当于这个元素所对应的这个空没有。
能不能把目标去创建出来，同时把那些空都填好，这样直接一转就全回来了，就绝对不会落空的，就相当于直接创建出这样的结构，反正都是放六个元素的，直接把目标结构给它创建出来，这个得用到下面要讲的列表解析式，但是不用也可以写出来。
如果说能把目标的这个结构，能直接创建出来。原来是3×2的可以直接写成2×3的结构出来，把这个填过来，也是一次位置填写，关键就是这个的位置是得填到这里去，如果用这种方式的话，它是把所谓的坐标被移掉，因为所有的空都已经填好了，说这里有个空，原来是3×2的，能不能创造一个2×3一个空间结构出来，就是把所有的空都已经好了。
算法2：
能否一次性开辟目标矩阵的内存空间?
如果一次性开辟好目标矩阵内存空间，那么原矩阵的元素直接移动到转置矩阵的对称坐标就行了
#12 3 14
# 4 5 6 ==>> 2 5
# 3 6
#在原有矩阵上改动，牵扯到增加元素和减少元素，麻烦，所以，定义一个新的矩阵输出
matrix = [[1,2,3]，[4,5,6]]
#matrix = [[1,4],[2,5],[3,6]]
这里所谓的拷贝就是数值
列表解析式：tm = [[0 for col in range(len(matrix))] for row in range(len(matrix[0]))]count = 0
这里是个for循环，第一次循环在里面数一下元素有一个，在考虑对目标行来讲要构建几行，发现构建三行，这里每一行又要创建列表，在考虑有几列，2列这里面每一个列表里面计数器里面添两个0，两层for循环嵌套。
for i,row in enumerate(tm):
for j,col in enumerate(row):
tm[i][j]= matrix[j][i]#将matrix的所有元素搬到tm中
count += 1（扭转拷贝的问题）
print(matrix)
print(tm)
print(count)
能不能一次性开好，如果能一次性开，那么原矩阵把xy需要交换到里面来就完了，并且绝对不会落空。
就是它的xy坐标处于交换过来了，说目标是到这个地方，就叫列表解析，相当于套了两层造型还套了两层for循环，先看第一层循环，看它的元素有几个，之后下面就应该建立目标行，对目标就要考虑一下应该建几行，也就是说这个元素里面有几列，之后这个目标是要构建三行。
前面这不会是每一行那里面每一个这个列表里面要创建多少个，就是计数器里面添两个0，这就是计数器就这么来用，，所以这是两层for循环嵌套。
for row in range (len (matrix[ 0] )):
tm. append( [])目标叫tm
for col in range (len (matrix) ) :
tm[ xxxx].append(0)
这东西就可以转化成上面的嵌套，不这么创建容易出问题，引用类型。
两种方法：
print ( ' lnMethod 1')
start = datetime.datetime. now ( )
for c in range (100000):
tm =[]#目标矩阵for row in matrix:
for i, item in enumerate (row) :
if len (tm) < i +1:
tm.append( [ ])
tm[i].append(item)
delta = (datetime.datetime.now ( ) -start).total_seconds ()
print (delta)
print(matrix)
print (tm)
2
print ( ' lnMethod 2 ')
start = datetime.datetime.now ( )
for c in range ( 100000) :
tm =[0]* len (matrix[0])
for i in range ( len (tm) ) :
tm[i] = [0]* len (matrix)
#print (tm)
for i,row in enumerate(tm) :
for j, col in enumerate (row) :
tm[ i][j]= matrix[j][i]
delta = (datetime.datetime.now ( ) -start).total_seconds ()
print (delta)
print (matrix)
print (tm)
这两个方法随便转都可以，第二种是开辟好，第二种没用列表解析式，这两种方式代码是一致的，但是第一种会快一点，第二种故意不写出列表解析式，其实快慢在于规模问题，矩阵大小快慢是规模问题。
第一种在小矩阵的情况下速度不占优，当矩阵大的时候，第二种会更优的，两周都是开辟新的内存空间，
这里不能用嵌套，应用类型。
测试发现，其实只要增加到4*4开始，方法二优势就开始了。矩阵规模越大，先开辟空间比后append效率高。
三、例题讲解
数字统计
一组十个数字，不用循环，就没法迭代，之后说这就是个变量，凡是两个以上的基本上都有用列表或者容器，一般都是这个样子的，它说十个数字。那既然是用循环技能，几层循环，一层循环的。
如何知道重复的没重复，还哪些重复，哪些不重复，得想办法给它标记，像用count，index，列表等等，或者字符串，根据它的位置在哪儿，虽然说效率低，但是好歹找到了。
它是一个大on问题的这种函数解决这样一种问题，读到11就可以知道还有11没有，但是如果要知道还有11的话，是不是得先到头，才知道还要不要再对它进行什么操作，之后去找一个11，下次再找到11，就告诉不要再处理了。
找到第一个11找到第二个11是给打个标题告诉已经找过了，其它的都不是11。一遍就过去了。
第二遍，从七开始向后找，碰到11的时候，直接就过去了跟它没关系，得标一下有关系。
这个七和11已经反复标记了，之后走到五，走到五这个是没打过标记，看的六和四，第五是不是可以标记，是不重复的，之后这个六，没人管过这6就越走越少。
所以你发现这个东西当你重复的越多它效率越高。而一个都没重复，这是没办法的。
但是你投入的越多就笑脸越高，而且发现看似是两层循环，但是实际上每次是在不断的剔除那些已经被判断过的数字。
但是你拿一个11后你找到个11，你要是拿到一个五，你跟任何人都不相等的话，那们其实你不能说这个五，只能用现在这种方式就是依次向后迭代。最后发现这好像刚才说那个东西，最终这种思想是可以解决的，但是这种思想是不是一层循环。之后中间是不是要加一些判断，判断的一些哪些是重复过的数据。就是这一种算法这种算法是一个最简单的。
随机产生10个数字要求:
每个数字取值范围[1,20]
充计重复的数字有几个?分别是什么?充计不重复的数字有几个?分别是什么?
举例∶11,7,5 ,11,6,7,4，其中2个数字7和11重复了，3个数字4、5、6没有重复过
思路︰
对于一个排序的序列，相等的数字会挨在一起。但是如果先排序，还是要花时间，能否不排序解决?
例如11,7,5,11,6,7,4，先拿出11，依次从第二个数字开始比较，发现11就把对应索引标记，这样一趟比较就知道11是否重复，哪些地方重复。第二趟使用7和其后数字依次比较，发现7就标记，当遇到以前比较过的11的位置的时候，其索引已经被标记为1，直接跳过。
回答1：
import random
lst=[]
rep_lst=[]
uniq_lst=[]
for i in range (10) :
temp=random.randint (1,20)
if temp in lst and temp not in rej
rep_lst.append (temp)
lst.append(temp)这是每个数都加进来，相当与告诉你这个数已经存在做，在列表里。
for j in lst:
if jnot in rep_lst:
uniq_lst.append (j )
print (lst)
print (len (rep_lst),' : ',rep_lst)
print (len (uniq_lst) ," : ', uniq_lst)
先构造出一个大列表，在解决里面到底有没有重复的问题。
回答2：
import random
lst =[0]*21
stri = ""
strimin = ""
strimax = ""
for i in range (10) :
——num - random.randint ( 1,20)
——“ lst [num] += 1
maxnum = max(lst)
for j in range (1,21):
——if lst[j]>0:
——— stri += "{}, ".format (j)s
——f lst[j]-= 1:
———strimin += "[],".format(j)wif lst[j]==maxnum :
strimax +="{3,".format (j)
print("数字最多出现过{0}次".format ( maxnum) ,
print("数字出现有:[ }其中()出现过[}次，其中{]只出现过1次".format(stri,strimax, maxnum,strimin))
这个就是按照数值范围，整的一个索引。用的count的方式在本题来讲没有任何问题。
算法
import random
nums = []
for _ in range(10):
nums.append( random.randrange(21))
#nums = [1,22,33,56,56,22,4,56,9,56,2,1]
print("origin numbers = {".format(nums))
print()
length = len(nums)
samenums = []#记录相同的数字（重复的扔进这个列表里面）
diffnums = []#记录不同的数字
states = []* length # 记录不同的索引异同状态
如果说每个数列重复几次也是可以的
for i in range(length):
flag = False #假定没有重复
if states[i] == 1:
continue
for j in range(i+1, length):
if states[j] == 1:
continue
if nums[i] == nums[j]:
flag = True
states[j] = 1
if flag: #有重复
samenums.append(nums[i])
states[i] = 1
else:
diffnums. append(nums[i])
print("Same numbers = {1}，Counter = {0}".format(len(samenums)
samenums))
print("Different numbers = {1},Counter = {0}".format(len(diffnums)，diffnums))print(list(zip(states,nums)))
这是用列表的解决方式
这些都是可以发现重复的打标记，所以这些东西都是用来打标记的，但是打标记的同时，实际上是可以在标题上标一个数。
也就是说它重复几次也可以的，当然单独的用一些列表来记录也是没有问题的。
先整十个数给凑进来，假设看数据凑很多，可以把这个数重新打印一下，反映一下来看。
重复的扔了列表里面去就行，不重复了就不相同。就知道到底是重复的机制，重复的数字有几个，不重复的数字有几个是都可以出来，因为如果没有问每一个数字，重复几次，其实也可以搞定了。
首先外层循环，假定现在用11刚进来要进行比较的时候，认为是没有投入的。
但是要判断一下这个数，两个是一是第一个数，但是找到了后面那个11，所以这块儿有一个判断，这真是个索引，那个标记也被打印成一了，这是的同步数，就没必要再办了。
