python list内存占用

一、基础

1. 列表的数据项不需要具有相同的类型 -->里面数据项地址不一定会相邻

list01=[1,2,3,'hello']
 print(id(list01))  # 1833720636040
 print(id(list01[0]))  # 140704119612048
 print(id(list01[1]))  # 140704119612080
 print(id(list01[2]))  # 140704119612112
 print(id(list01[3]))  # 1833721071576

1. List（列表） 是 Python 中使用最频繁的数据类型。
2. 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
3. 列表形式：list01 = [1, 2, ‘hello’, 4]
4. 列表不是链表，因为list是保存到其内容对应的地址，链表是直接连接
5. 列表为可变对象

list01=[1,3,5,7,9]
 list01[0]=10
 print(list01)

1. 列表切片
   列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表
   从左到右索引默认 0 开始，从右到左索引默认 -1开始
   加号 + 是列表连接运算符，星号 * 是重复操作。

list=[1,3,5,7,9,11]
 list    # 输出完整列表
 list[0] 	# 输出列表的第一个元素
 list[-1]    # 输出列表的最后一个元素
 list[1:3]   # 输出第二个至第三个元素 
 list[2:]    # 输出从第三个开始至列表末尾的所有元素
 list[::2]   # 步长为2
 list[::-1]  # 反转数组
 list[-1:-3:-1]  # 从后往前截取
 list * 2    # 输出列表两次
 list + tinylist # 打印组合的列表
 
 for item in range(len(arr)):   
    print(arr(item))        
 
 for item in arr:   
    print(item)

二、list 操作

fruits = ['orange', 'apple', 'pear', 'banana']

1. count()：统计

print (fruits.count('apple'))

1. index()：找到为位置，找不到为异常，判断是否存在

fruits=['orange','apple','pear','banana']
     if 'apple' in fruits:  # 用in解决异常
         index=fruits.index('apple')
         print(index)
 
     #demo--模糊搜索
     fuits = ['orange', 'apple', 'pear', 'banana','apples','big apple']
     condition='app'
     res=[]
     for f in fruits:
         if condition in f:
             res.append(f)
     print(res)

1. reverse()：反转

fruits=['orange','apple','pear','banana']
     fruits.reverse()
     print(fruits)  # ['banana', 'pear', 'apple', 'orange']

1. 排序sort()

list01=[1,20,3,4]
     list01.sort()  # 默认从小到大
     print(list01)  # [1, 3, 4, 20]
     list01.sort(reverse=True)#从大到小
     print(list01)  # [20, 4, 3, 1]
     print(list01.sort()) #sort.()返回值为None

1. 增加 增加元素：append() ，增加集合：extend() +连接
   增加元素append()：地址不变
   增加集合extend([])：地址不变，相当于list0+list1的结果
   增加集合+[]连接：地址改变

f0 = ['apple','orange','banana','pear']
     print('原列表：','地址为：',id(f0),f0)  # 原列表： 地址为： 2818495219208 ['apple', 'orange', 'banana', 'pear']
     
     f0.append('append')
     print('append增加元素后：','地址为：',id(f0),f0)  # append增加元素后： 地址为： 2818495219208 ['apple', 'orange', 'banana', 'pear', 'append']
     
     f0.extend(['extend'])
     print('extend增加集合后：','地址为：',id(f0),f0)  # extend增加集合后： 地址为： 2818495219208 ['apple', 'orange', 'banana', 'pear', 'append', 'extend']
     
     f1 = f0 + ['+连接']
     print('+连接后：','地址为：',id(f1),f1)  # +连接后： 地址为： 2818495525064 ['apple', 'orange', 'banana', 'pear', 'append', 'extend', '+连接']

1. 合并两个列表

new_fruits=fruits+['kiwi','water']

1. 插入元素 insert()

fruits = ['apple','pear']
     fruits.insert(1,'pick')
     print(fruits)  # ['apple', 'pick', 'pear']

1. 删除元素 pop(index) ，remove(list[index]) ，del， [:]=[]
   pop(i)：i为空时，默认删除最后一个，为i时，删除下标为i的
   pop()比remove()效率高
   remove(a)：在列表中找不到a时，则停止执行

fruits0 = ['apple','pear','orange']
     fruits0.pop(2)  # ['apple', 'pear']
     print(fruits0)
     
     fruits = ['apple','pear','orange']
     fruits.remove('apple')
     print(fruits)  # ['pear', 'orange']
     fruits.remove(fruits[1])
     print(fruits)  # ['pear']
     
     fruits1 = ['apple','pear','orange','banana','watermelon']
     del fruits1[1]  #del回收内存
     print(fruits1) # ['apple', 'orange', 'banana', 'watermelon']
     
     fruits1[1:3]=[]
     print(fruits1) # ['apple', 'watermelon']

1. 清空元素

fruits = ['apple','pear','orange','banana','watermelon']
     fruits=[]
     fruits[:]=[]
     fruits.clear()  # 第三个更好
     del fruits[:]    #不同于del fruits

1. 最大最小值

list01=[1,2,3,4]
    print(max(list01)) # 4
    print(min(list01)) # 1
    print(sum(list01)) # 10

三、多维列表

1. 多维列表的访问和遍历

print('多维列表：')
 list01=[[1,2],[3,4],[5,6]]
 list02=[10,20,[100,200]]
 print(list02[2][1]) # 200
 for i in list01:
     for j in i:  # 这样循环list02会停止
         print(j)

1. demo–找最长的单词

def LogestWord(sen):
     words=''.join(([',',c][ int(c.isalpha())]for c in sen )).split(',') # 1为c，0为,
     maxLen=max(len(i) for i in words )
     return [i for i in words if len(i)==maxLen][0]
 print(LogestWord('fun! times 7643579'))  # times

四、list去重

1. 方法一：新建新列表list
2. 方法二：（删除前面所有与后面元素相同的元素）

list01=[1,2,2,2,3,4,2,5,4,2]
 le=len(list01)
 i=0
 while i<le-1:
     j=i+1
     while j<le:
         if list01[i]==list01[j]:
             list01.remove(list01[i])
             le-=1
             i-=1
             break
         j+=1
     i+=1
 
 print(list01)

1. 方法三：（删除后面所有与当前元素相同的元素）

list01=[1,2,2,2,3,4,2,5,4,2]
 le=len(list01)
 i=0
 while i<le-1:
     j=i+1
     while j<le:
         if list01[i]==list01[j]:
             list01.pop(j)
             le-=1
             j-=1
         j+=1
     i+=1
 
 print(list01)

五、list拷贝

列表可以拷贝，即拷贝完后两地址不同（string不可拷贝）
参考资料：

import copy
    list01 = [1, 3, 5, 7, 9]
    list02 = list01  # 不是拷贝，传引用/地址，id(list01) == id(list02)
    list03 = list01[:]  # 浅拷贝，id(list03) != id(list01)
    list04 = list01.copy()  # 浅拷贝，id(list04) != id(list01)
    list05 = copy.copy(list01)  # 浅拷贝，id(list05) != id(list01)
    list06 = copy.deepcopy(list01)  # 深拷贝，id(list06) != id(list01)

深、浅拷贝对列表的影响：

import copy
        list01=[10,20,[100,200]]
        list02=list01.copy() #浅拷贝 list[:] copy.copy(list) list.copy()
        list02=copy.deepcopy(list01) #深拷贝 copy.deepcopy()
        
        print(id(list01[0]),id(list02[0]))  # 深、浅拷贝两个地址相同
        print(id(list01[2]),id(list02[2]))  # 浅拷贝两个地址相同，深拷贝两个地址不同
        
        list01[2][0]=1000
        print(list01)
        print(list02)  # 浅拷贝变为1000，深拷贝不变
        print(id(list01[2]),id(list02[2]))  # 浅拷贝两个地址相同，深拷贝两个地址不同
        
        list01[0]=50
        print(list01)
        print(list02)  # 浅拷贝、深拷贝均不变
        print(id(list01[0]),id(list02[0]))  # 浅、深拷贝两个地址均不同

深、浅拷贝只针对于列表中的列表
当改变一个列表中的一个数字时，
深、浅拷贝均不影响另一个列表的数字