Python 编程必备-Python 列表实现|学习笔记

开发者学堂课程【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，所以这块儿有一个判断，这真是个索引，那个标记也被打印成一了，这是的同步数，就没必要再办了。