在内存中，一个python list中的每个元素都是内存地址，由这些地址指向真正的值。也就是list中存放的每个元素实质上都是指针

怎么理解呢，看下面的代码

>>> a = [1, 2, 3, 4, 5, 6]
>>> id(a)
1509136363080
>>> id(a[0])
1653173728
>>> b = 1
>>> id(b)
1653173728 # 和id(a[0])相等

>>> a.append([9,8])
>>> a.append([9,8])
>>> a.append([99,88])
>>> a.append(7)
>>> for ele in a:
...     print(id(ele))
...
1653173728 # 1的内存地址
1653173760 # 2的内存地址
1653173792 # 3的内存地址
1653173824 # 4的内存地址
1653173856 # 5的内存地址
1653173888 # 6的内存地址
1509136362824 # 第一个[9,8]的内存地址
1509136363272 # 第二个[9,8]的内存地址
1509136391368 # [99,88]的内存地址
1653173920 # 7的内存地址，和6的地址是连续的

我们可以看到，数组a 的内存地址是1509136363080，但首个元素a[0]的地址却是1653173728，两个地址差天远，说明我们要的a[0]这个元素的值真正存放在十万八千里以外的内存空间，而不存放在a开辟的内存里。即a = [1, 2, 3, 4, 5, 6] 在内存中的存放形式是a = [ 1这个值的地址, 2这个值的地址, 3这个值的地址, ..., 6这个值的地址 ]，所以，a[0]、a[1]这些都是内存中的地址，python通过寻址这些地址把对应的数值拿给我们
我们又把1赋值给变量b，python中的赋值其实只是给了一个存该值的地址，发现b的地址和a[0]的地址一样，也印证了数组存地址不存值，值自有自己的存储空间

另外，把a所有元素的id打印出来，发现整数之间的差为32，说明给整数分配的内存是连续的，但是给[9,8]、[99,88]这些可变数据类型分配的内存是不连续的。并且可以发现，不可变数据类型总在内存低位，而可变类型在高位

循环删除达不到目的

a = [1, 2, 3, 4, 5, 6]
for i in a:
    a.remove(i)
print(a)
>>>[2, 4, 6]

代码意图删掉a的所有元素，但是并没有，2，4，6剩了下来

因为list是python中的可变数据类型。这类数据的特点是在值发生改变时，其在内存中的首地址并不会改变。由于首地址不变，当发生元素删除时，就会发生元素补位的情况，这就是循环删除达不到目的的根本原因

拿上面的代码为例，首次进入循环，循环指针指向a[0]，a[0]指向1，当我们删除a[0]也就是删除1时，由于list首地址不变，后面的所有元素需要向前补位，这时顶层来看是2补原来1的位置，对应内存中的变化是a首地址a[0]存放指向2的指针；然后继续，进入下一次循环，这时循环指针由a[0]指向a[1]，而a[1]指向3，那么把3给删了，这时后面的4就会来补3的位置；如此反复，补位的元素会被循环跳过，那么偶数就被保留了下来，奇数则被删去。可以将过程打印出来具体看一下：

nums = [1,2,3]
for num in nums:
            now_index = nums.index(num)
            print('当前,循环指针指向下标%s处' % str(now_index))
            print('当前元素是%s, id是%s' % (str(num), str(id(num))))
            print('现在移除当前元素')
            nums.remove(num)
            print('移除后的数组为：')
            print(nums)
            print('被移除元素是%s, 移除后其id是%s' % (str(num), str(id(num))))
            print('')

当前,循环指针指向下标0处
当前元素是1, id是13467992
现在移除当前元素
移除后的数组为：
[2, 3]
被移除元素是1, 移除后其id是13467992

当前,循环指针指向下标1处
当前元素是3, id是13467944
现在移除当前元素
移除后的数组为：
[2]
被移除元素是3, 移除后其id是13467944

可以看到，本来想循环3次，结果只进行了2次，因为第一次循环时删掉1，2向前补位，成功躲过循环。下一次的循环指针指向下标1，a[1]对应的值就是3，删掉，结束循环，剩下[2]

如何避免

• 1.循环时，使用可变数据类型的copy作为循环条件

a = [1, 2, 3, 4, 5, 6]
# 利用a[:] 将a copy了一份
for i in a[:]:
    a.remove(i)
print(a)
>>>[]

• 2.从后往前删。其实，只要被删除的元素后面还有元素，那么就会发生补位现象，就会影响后面未操作元素的位置；但 从后往前删不会 ，删除只会影响后面的元素的位置，前面未操作元素的位置不会受到一丝影响

nums = [1, 2, 3]
for num in nums[::-1]:
            now_index = nums.index(num)
            print('当前,元素指针指向下标%s处' % str(now_index))
            print('当前元素是%s, id是%s' % (str(num), str(id(num))))
            # next_index = now_index - 1
            print('现在移除当前元素')
            nums.remove(num)
            print('移除后的数组为：')
            print(nums)
            print('被移除元素是%s, 移除后其id是%s' % (str(num), str(id(num))))
            print('')

当前,循环指针指向下标2处
当前元素是3, id是26116392
现在移除当前元素
移除后的数组为：
[1, 2]
被移除元素是3, 移除后其id是26116392

当前,循环指针指向下标1处
当前元素是2, id是26116416
现在移除当前元素
移除后的数组为：
[1]
被移除元素是2, 移除后其id是26116416

当前,循环指针指向下标0处
当前元素是1, id是26116440
现在移除当前元素
移除后的数组为：
[]
被移除元素是1, 移除后其id是26116440

一切都是对的，都是那么美妙

例如下面这道题from leetcode：

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

思路：可以考虑从后往前删除重复元素。如果当前循环指针指向的当前元素与前一个元素相同，那么删除当前元素（这样并不影响向前循环的正确性）；否则继续向前循环。循环至数组首个元素时终止

class Solution(object):
    def removeDuplicates(self, nums):
        # 倒着移动下标，可直接在原数组nums上删除元素，不需要借助一个nums的copy
        for num_index in range(len(nums)-1, 0, -1):
            if nums[num_index] == nums[num_index-1]:
                nums.pop(num_index)
        return len(nums)