python列表在内存 python列表最多存储多少数据

数据类型划分

分为可变数据类型和不可变数据类型

不可变数据类型（又叫可hash）：

元祖，布尔值，int数字，字符str（对str的任何操作都是形成了一个新的str）

可变数据类型（不可hash）：

list列表，字典，set集合

列表

　　列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

　　列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

增：

　　增加对列表操作，没有返回值，直接无法打印

insert

#插入到指定位置中

li = [1,'a','b',2,3,'a']
li.insert(0,55) #按照索引去增加，在指定位置增加
print(li)

append

#一次只能添加一个元素
#添加到列表的最后
li.append('aaa') #增加到最后
li.append([1,2,3]) #增加到最后
print(li)

extend

li = ['authur' , 'yxd']
li.extend(['q,a,w']) #迭代的去增，列表以每个最小单位添加，
print(li)
li.extend('qwe')
print(li)
#['authur', 'qwe', 'q,a,w']
#['authur', 'qwe', 'q,a,w', 'q', 'w', 'e']

不能迭代int，可以将数字放在列表中添加
li = ['authur','qwe']
li.extend(123) #这样会报错，'int' object is not iterable

可以在列表中迭代
li = ['authur','qwe']
li.extend([123,'asd'])
print(li)
['authur', 'qwe', 123, 'asd']

删：

pop

#按照索引去删除，默认不写是删除最后一个。有返回值，返回值为删除的那个元素，也是列表操作中唯一有返回值的。
li = ['arthur',21]
print(li.pop(1))
21

del

#按照位置去删除，也可切片删除没有返回值。如果没有切片，将整个列表删除
li = ['arthur','qwe',21]
del li[0:2]
print(li)
[21]

li = ['arthur','qwe',21]
del li #直接删除列表
print(li) #print会报错，因为直接从内存删除了列表

remove

#按照元素去删除,
li = ['arthur','qwe',21]
li.remove('arthur')
print(li)
['qwe', 21]

clear

#清空列表
li.clear() #此时列表为空列表

改

将指定的一个值或是切片的范围值替换为指定的元素

指定位置更改

li = [1,'a','b',2,3,'a']
li[1] = 'Arthur'
print(li)
[1, 'Arthur', 'b', 2, 3, 'a']
#会将指定的位置元素替换为输入的元素，可以是列表等等

切片范围更改

切片是将所选范围替换掉，更改任意多个新的元素，以最小单位去迭代，字符串是以每个字符，列表是以每一位。和extend效果一样，也不可以直接迭代int，可以借助列表

li = [1,'a','b',2,3,'a']
li[0:2] = 'yxd'
print(li)
['y', 'x', 'd', 'b', 2, 3, 'a']
#将选择的切片范围去掉，以迭代的方式将指定的内容写入列表中

切片添加列表

li = [1,'a','b',2,3,'a']
li[0:2] = ['qwe',123,'Arthur',['qwe',123,'Arthur']]
print(li)
['qwe', 123, 'Arthur', ['qwe', 123, 'Arthur'], 'b', 2, 3, 'a']
#可以发现，列表是以最小单位迭代的，所以替换字符串的时候可以使用列表来实现，而列表中的列表依旧是列表，没有被拆分。

查：

切片去查，或者循环去查。

可以遍历列表查

li = ['authur','yxd','21']
for i in li:
    print(i)
#查看前两个元素
print(li[0:2])

列表的嵌套：

现在要显示zxc的x,思想就是，先找到列表中的列表，再找具体的字符串

li = ['arthur' , 'zxc' , '我去', ['qwe','asd',92],23 ]
print(li[1][1])
x

找到arthur，首字母大写，再放回去

li[0]=li[0].capitalize()
print(li)

找到我去，改成我不去

li[2] = '我不去'
li[li.index('我去')]= li[li.index('我去')].replace('去','不去')
print(li)

找到qwe，全部变成大写，再放回原处

li[3][0] = li[3][0].upper()
print(li)

元组：

元组被称为只读列表，即数据可以被循环查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

元组的直接元素不能更改，元组元素的元素可以修改，例如元组中的列表的元素可以改，但是列表本身不能改

li = ('authur' , 'yxd' , '我去' , ['qwe','asd',92],23 )
print(li[2])
print(li[1:3])
#遍历元组
for i in li:
    print(i)
#修改元素中的列表
li[3][1] = li[3][1].upper()
print(li)
('authur', 'yxd', '我去', ['qwe', 'ASD', 92], 23)
#追加元素到元祖中的列表
li[3].append('Authur')
print(li)

字典

唯一的映射数据类型，由键值对组成，一个键对应一个值，一个key对应一个value，

字典的key必须是不可变数据类型，value是任意

 

dict优点： 对内存的数据使用二分查找法，效率高，字典的key都会转换数字，以二分法查找，效率高

                 存储大量的关系型数据

      特点：字典是无序的，只针对3.5及以前的版本

字典举例

dic = {
    'name':['arthur','qwe'],
    'py9':[{'num':71,'avg_age':18,},
           {'num': 71, 'avg_age': 18, },
           {'num': 71, 'avg_age': 18, },
           ],
    True:1,
    (1,2,3):'wuyiyi',
    2:'ewq',
}
print(dic)

增：

 第一种方法：直接赋值

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
dic1['high'] = 185  #如果元组中没有键，则添加
dic1['age'] = 16    #如果元组中有这个键，则值覆盖
#{'age': 16, 'name': 'Arthur', 'sex': 'male', 'high': 185}

第二种方法：setdefault()

格式：setdefault(self, key, value)
特点：在添加的时候，如果字典中已经有键，则不做任何改变，如果字典中没有键值对，则添加。默认添加时，只写键不写值，值为none

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
dic1.setdefault('top','python')
dic1.setdefault('age',81)
print(dic1)
{'age': 18, 'name': 'Arthur', 'sex': 'male', 'top': 'python'}

删：

第一种方法：

格式：pop('key')

特点：删除时以key删除，有返回值，返回key对应的value

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
print(dic1.pop('age'))
18
#用法
print(dic1.pop('python','没有此键'))   #如果没有这个键，删除时可设置返回值，来判断字典中是否存在这个键，如果有键，删除时返回对应的值
没有此键

第二种方法：

格式：popitem()

特点：删除时随机删除，一般删除字典中的最后一对键值对，返回值为删除的这对键值对

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
print(dic1.popitem())
('sex', 'male')         #以元祖的方式返回键值对

第三种方法：

格式：del 字典[‘key’]

特点：删除没有返回值，如果所删的key没在字典中则报错，如果没有指定删除的key，则删除整个字典

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
del dic1['age']
print(dic1)
{'name': 'Arthur', 'sex': 'male'}
del dic1   #删除整个字典

第四种方法：

格式：字典.clear()

特点：清空字典中的内容，和del不同的是，del是在内存中删除，clear保留字典，只不过内容为空

改：

第一种方法：

直接赋值，和增的时候相同

dic1 = {'age': 18, 'name': 'Arthur', 'sex': 'male',}
dic1['high'] = 185  #如果元组中没有键，则添加
dic1['age'] = 16    #如果元组中有这个键，则值覆盖
#{'age': 16, 'name': 'Arthur', 'sex': 'male', 'high': 185}

第二种方法：

格式：字典.update(字典2)

特点：设置两个字典，对其中一个字典进行更新，会将两个字典的键值比对，如果被更新的字典有这个key，则覆盖，没有就添加

dic = {"name":"arthur","age":18,"sex":"male"}
dic2 = {"name":"python","weight":75}
dic2.update(dic)            #以dic的内容更新dic2
print(dic2)
{'name': 'arthur', 'weight': 75, 'age': 18, 'sex': 'male'}

查：

第一种方法：

直接打印，有则打印，没有报错

dic = {"name":"arthur","age":18,"sex":"male"}
print(dic['name'])
arthur

第二种方法：

get()

有key时不管后边如何设置，都会返回key对应的value，没有时，返回后边设置的值，没有设置返回none

#有这个键值时
dic = {"name":"arthur","age":18,"sex":"male"}
print(dic.get('name','没有这个键值'))
arthur
#没有这个键值时
print(dic.get('python','没有这个键值'))
没有这个键值

第三种方法：

格式：字典.keys()        以列表的形式打印字典的key

　　　字典.values()     以列表的形式打印字典的values

　　　字典.items()　　以列表的方式打印，以元组存放字典的键值对

dic1 = {'age': 18, 'name': 'jin', 'sex': 'male',}
print(dic1.keys(),type(dic1.keys()))   
print(dic1.values())
print(dic1.items())
运行结果
dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>      #特殊类型，字典key，可以当做列表处理
dict_values([18, 'jin', 'male'])                             
dict_items([('age', 18), ('name', 'jin'), ('sex', 'male')])  #最小单位是元组

循环打印字典的内容：

打印字典的键：

for i in dic1: 
    print(i)
for i in dic1.keys():
    print(i)

运行结果

age

name

sex

age

name

sex

打印字典的值：

for i in dic1.values():
    print(i)

打印字典的键值对：

for k,v in dic1.items():   #使用k和v分别取值
    print(k,v)

字典的嵌套

dic = {
    'name':['Arthur','python','boa'],
    'py9':{
        'time':'2018',
        'learn_time':10,
        'addr':'CBD',
           },
    'age':21
}

# 添加一个键值为age: 56
dic['age'] = 56 
print(dic)
#{'name': ['Arthur', 'python', 'boa'], 'py9': {'time': '2018', 'learn_time': 10, 'addr': 'CBD'}, 'age': 56}

#显示name的值，以列表的形式
print(dic['name'])        
#['Arthur', 'python', 'boa']

#在name对应的值，也就是列表中，添加ritian
dic['name'].append('ritian')  
print(dic['name'])
#['Arthur', 'python', 'boa', 'ritian']

#将python转换为大写的形式 
dic['name'][1] = dic['name'][1].upper() 
print(dic['name'])
#['Arthur', 'PYTHON', 'boa']

#在py9中添加zabbix: 44 这个键值对 
dic['py9']['zabbix'] = 44 
print(dic)
{'name': ['Arthur', 'python', 'boa'], 'py9': {'time': '2018', 'learn_time': 10, 'addr': 'CBD', 'zabbix': 44}, 'age': 21}