{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 6.4 列表的更新"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"赋值语句是改变对象值的最简单的方法，在列表中，也可以通过索引赋值改变列表中指定序号元素值。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.索引赋值的方法为： "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls[i] = a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"其中i 为列表中的元素序号，要求i为整数且在列表序号范围内（-len(ls) <= i < len(ls)），当i值超出列表序号范围时，抛出错误：IndexError: list assignment index out of range。\n",
"a 为新值，其值可以与列表中原有元素的数据类型相同，也可以是不同的数据类型，甚至可以是一个列表或元组。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88,56,95,46,100,77] # 通过赋值创建列表L\n",
"ls[2] = 66\n",
"print(ls) # 序号为2的元素被替换为66，输出：[88, 56, 66, 46, 100, 77]\n",
"\n",
"ls[3] = 'pass' # 序号为3的元素赋字符串类型新值\n",
"print(ls) # 序号为3的元素被替换，输出：[88, 56, 66, 'pass', 100, 77]\n",
"\n",
"ls[5] = ['True','False'] # 序号为5的元素赋列表类型新值\n",
"print(ls) # 序号为5的元素被替换， [88, 56, 66, 'pass', 100, ['True', 'False']]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"除了按索引赋值以外，还可以用切片赋值的方法更新列表中的数据，切片赋值要求新值也为列表。 \n",
"其操作相当于将原列表中切片中元素删除，同时用新的列表中的元素代替切片的位置。 \n",
"当切片连续时（如ls[i:j]），此时新列表长度不限，可为空列表、与切片等长列表或超出切片长度的列表。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"当切片不连续时（如，ls[i:j:step]），要求新列表与切片元素数量相等，再按顺序一一替换。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88,56,95,46,100,77] # 通过赋值创建列表ls\n",
"print(ls) # 输出原列表中元素[88, 56, 95, 46, 100, 77]\n",
"\n",
"ls[1:3] =[33,44] # 序号为1和2的元素被替换为新列表中的33和44\n",
"print(ls) # 输出：[88, 33, 44, 46, 100, 77]\n",
"\n",
"ls[1:3] = [] # 序号为1和2的元素被替换为新列表中空值\n",
"print(ls) # 输出[88, 46, 100, 77]，列表长度减少2\n",
"\n",
"ls = [88,56,95,46,100,77] # 通过赋值创建列表ls\n",
"ls[1:3] =[33,44,55,66] # 序号为1和2的元素被替换为33、44、55、66\n",
"print(ls) # 输出[88, 33, 44, 55, 66, 46, 100, 77]，列表长度增加2\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77] # 通过赋值创建列表ls\n",
"print(ls[0:6:2]) # 切片返回结果，3个元素，输出[88, 95, 100]\n",
"\n",
"ls[0:6:2] = [10, 20, 30] # 将切片返回的3个元素用新列表中对应位置的元素替代\n",
"print(ls) # 输出[10, 56, 20, 46, 30, 77]\n",
"\n",
"ls = [88, 56, 95, 46, 100, 77] # 通过赋值创建列表ls\n",
"ls[0:6:2] = ['Python', 'C语言', 'VB'] # 新列表元素的数据可为任意类型\n",
"print(ls) # 输出['Python', 56, 'C语言', 46, 'VB', 77]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"如果输出id(ls)查看每次操作前后列表ls的id，可以发现，当列表长度没有增加且新加入的数据类型与原数据类型相同时，更新前后列表的id没有发生变化，也就是说，此时的更新是原地操作。而当更新列表后长度增加的操作，或更新后新加入的数据的类型与原数据类型不同时，更新前后列表的id会发生变化。也就是说，此时的更新是重新创建了新的列表，并将原列表和更新的数据一起放入新列表。 \n",
"可以这样理解列表被创建后，就不能再往列表中增加元素了，如需增加新的元素，需要将整个列表中的元素复制一遍，再添加需要增加的元素。 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.为了解决这个问题，python提供了三种方法向列表中添加元素： \n",
"append() \n",
"extend() \n",
"insert() \n",
"\n",
"这三种方法都是原地操作，不影响列表在内存中的起始地址。 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.1 append()在列表末尾添加一个元素， \n",
"append()方法的使用方式为： "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls.append(x) \n",
"# ls为操作的列表名，x为增加的元素。 \n",
"# 相当于: \n",
"a[len(a):] = [x]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77] # 通过赋值创建列表ls\n",
"ls.append(100) # 在原列表末尾增加新元素数字100\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 100]\n",
"\n",
"ls = [88, 56, 95, 46, 100, 77] # 通过赋值创建列表ls\n",
"ls[len(ls):] = [100] # 在原列表末尾增加新元素数字100\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 100]\n",
"\n",
"ls.append('python') # 在原列表末尾增加新元素字符串'python'\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 100, 'python']\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"如果输出id(ls)可以发现，应用append()方法向列表中增加元素时，可以增加同类型元素，也可以增加不同类型元素，其列表的id不变，说明只是修改了原列表而没有重建列表。 \n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 extend()是将另一个可迭代对象转为列表并追加到当前列表的末尾\n",
"extend()方法的使用方式为： "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls.extend(iterable) \n",
"# 相当于： \n",
"ls[len(ls):] = iterable"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77]\n",
"L = [10, 20, 30]\n",
"ls.extend(L) # 在原列表末尾增加新列表中的元素10,20,30\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]\n",
"\n",
"ls = [88, 56, 95, 46, 100, 77]\n",
"L = [10, 20, 30]\n",
"ls[len(ls):] = L # 在原列表末尾增加新列表中的元素10,20,30\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77]\n",
"ls.extend(range(5)) # 在原列表末尾增加新列表中的元素0, 1, 2, 3, 4\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 0, 1, 2, 3, 4]\n",
"\n",
"ls = [88, 56, 95, 46, 100, 77]\n",
"ls[len(ls):] = range(5) # 在原列表末尾增加新列表中的元素0, 1, 2, 3, 4\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 0, 1, 2, 3, 4]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 与ls.extend(L)功能类似的一个操作是赋值运算+=： "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77]\n",
"L = [10, 20, 30]\n",
"\n",
"ls += L # 不创建新对象，在原列表末尾增加新列表中的元素10,20,30\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"+=运算符会调用__iadd__方法，该方法的参数类型是可迭代对象(iterable)，也就是说，L的类型并不局限于列表，可以是元组、range、字符串、集合和字典等，会先将其它类型的对象转为列表类型，再附加到列表的末尾。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls = [88, 56, 95, 46, 100, 77]\n",
"L1 = {35,65}\n",
"L2 = range(10, 30, 10)\n",
"L3 = (1, 2, 3)\n",
"L4 = \"abc\"\n",
"\n",
"ls += L1 # 不创建新对象，在原列表末尾增加集合中的元素35,65\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 35, 65]\n",
"ls += L2 # 不创建新对象，在原列表末尾增加新列元素10,20\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20]\n",
"ls += L3 # 不创建新对象，在原列表末尾增加新元组中的元素1,2,3\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20, 1, 2, 3]\n",
"ls += L4 # 不创建新对象，在原列表末尾增加新字符串中的元素a,b,c\n",
"print(ls) # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20, 1, 2, 3, 'a', 'b', 'c']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 insert()是向列表中任意位置插入一个一元素，insert()方法的使用方式为： \n",
"ls.insert(i,x) \n",
"ls为操作的列表名，i为插入位置的序号，x为增加的元素。 "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ls.insert(0, x) # 在列表开头插入元素\n",
"\n",
"ls.insert(len(ls), x)\n",
"# 等同于 \n",
"ls.append(x)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[88, 56, 99, 95, 46, 100, 77]\n"
]
}
],
"source": [
"ls = [88,56,95,46,100,77] \n",
"ls.insert(2,99) # 在序号为2的位置插入新值99\n",
"print(ls) # 输出[88, 56, 99, 95, 46, 100, 77]\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
