可直接放入pycharm中查看并运行看结果
列表是一种数据结构,是一个序列,用于顺序的存储数据
#使用list函数定义空列表
l = list()
#使用中括号定义空列表
l = []
#使用中括号定义带初始值的列表
l = [1,2,3]
#使用list函数把可迭代对象转换为列表
l = list(range(1,19))
#通常在定义列表的时候使用[],在转化可迭代对象为列表时用list函数
'''查询(访问列表)'''
#定义一个1-10的列表
l = list(range(1,10))
#通过下标访问,下标从0开始
print(l[0])
#当下标超出范围时,会抛出IndexError
try:
l[100]
except BaseException as e:
print(e)
# 负数索引从右边开始,并且索引从-1开始
print(l[-1], l[-4])
'''list.index'''
#help(list.index)
#index(self, value, start=0, stop=9223372036854775807, /)
# Return first index of value.
#
# Raises ValueError if the value is not present.
#在l[0]-l[7]中寻找中值为2的索引
print(l.index(2,0,7))
#list.index函数解读
def index(lst,value,start=0,stop=-1):
#定义一个起始位置,这个起始位置就是我们list里的start参数
i = start
#通过for循环来迭代list对象,同时这里用到一个分片的概念
for x in lst:
#value是我们要查找的值,当value存在,就返回当前的i
if x == value[start,stop]:
return i
i += 1
#当循环结束还未找到值时,抛出异常报错
raise ValueError()
'''list.count'''
#help(list.count)
# count(self, value, /)
# Return number of occurrences of value.
#统计查询的字符在列表中出现的次数
l = [2,2,3,4,1,6]
print("统计字符2的出现:" + str(l.count(2)))
#list.count的函数解读
def count(lst,value):
#添加一个计数变量c,用来统计
c = 0
for x in lst:
if x == value:
c += 1
return c
# 通过索引访问元素
# index方法根据值返回第一个索引
# count方法返回元素在列表里的个数
#index和count的时间复杂度是O(n)
#线性复杂度:效率与数据规模线性相关
'''增加'''
#help(list.append)
# append(self, object, /)
# Append object to the end of the list.
#append原地修改list,返回值是None,直接加在最后一位
print("append返回值为None:" + str(l.append(5)))
print(l)
'''list.insert'''
#help(list.insert)
# insert(self, index, object, /)
# Insert object before index.
l.insert(3,9)
print("在索引为3的值前插入数字9:" + str(l))
#当越界时:自动往最左或最右插入该值,并不会报错
#append和insert的效率:
# append的时间复杂度是O(1),常数时间,效率和数据的规模无关
# insert的时间复杂度是O(n),线性时间,效率和数据规模线性相关
# 尽量使用append
'''list.extend'''
#help(list.extend)
# Extend list by appending elements from the iterable.
# extend将任意可迭代对象追加到数据的末尾,原地修改,返回None
# append操作单个元素
# extend操作可迭代对象
print("="*4 + "append和extend的区别" + "="*4)
l.append([1,12,3])
print(l)
l.extend([1,2,3])
print(l)
'''list + list'''
print("="*4 + "list + list" + "="*4)
l = [0,1,2,3,4]
print(l + ['a','v','d'])
print(l)
#这种方法有返回值,但不修改list本身,返回一个新的list
#这种操作叫list的连接操作
#时间复杂度:定性的描述一个算法的效率
#时间复杂度是分析的,不是计算的
'''删除'''
print("="*4 + "list.remove" + "="*4)
#help(list.remove)
# remove(self, value, /)
# Remove first occurrence of value.
# 删除第一个匹配的元素
# Raises ValueError if the value is not present.
l = [1,1,1,2,3,4,3]
l.remove(1)
print(l)
#原地修改,返回None,根据值删除元素
print("="*4 + "list.pop" + "="*4)
#help(list.pop)
# pop(self, index=-1, /)
# Remove and return item at index (default last).
# 不传入参数则默认返回并删除最后一个值
# 传入index参数,返回并删除index所在位置的值
# Raises IndexError if list is empty or index is out of range.
print(l.pop(1))#返回值为所删除的值
print(l)
# pop不传递index参数,时间复杂度为O(1)
# pop传递index参数,时间复杂度为O(n)
# pop根据索引删除元素,并且返回删除的元素
# remove根据值删除元素,返回None
'''list.clear'''
print("="*4 + "list.clear" + "="*4)
# help(list.clear)
# clear(self, /)
# Remove all items from list.
print(l)
l.clear()
print(l)#列表对象还在,值被情空
'''others'''
print("="*4 + "others" + "="*4)
l = [1,1,1,2,3,4,3]
print(len(l))
#原地修改,返回值为None
print(l.reverse(),l)
print(l.sort(),l)
#列表拷贝
print("="*4 + "浅copy" + "="*4)
l2 = l
print(l,l2)
l2[1] = 22
print(l,l2)
#l2做修改,l也被修改
#赋值操作是引用传递,也叫浅复制
#浅复制会产生引用关联,导致不希望被修改的值也被修改
#影子拷贝
print("="*4 + "影子copy" + "="*4)
# help(list.copy)
# copy(self, /)
# Return a shallow copy of the list.
l2 = l.copy()
print(l,l2)
l2[1] = 2333
print(l,l2)
#还原浅拷贝,内嵌list,还是一个浅复制
def copy(lst):
temp = []
for i in lst:
temp.append(i)
return temp
l = [1,[1,2,3],4]
l2 = l.copy()
l2[1][1] = 'a'
print(l,l2)
#这里发现1的值依然也发生了变化
#赋值操作,对可变对象是引用传递,对不可变对象是值传递
#若使用深拷贝,则值不变
from copy import deepcopy
print("="*4 + "深copy" + "="*4)
l = [1,[1,2,3],4]
l2 = deepcopy(l)
l2[1][1] = 'b'
print(l,l2)
以上知识为对「人人都是Pythonista」的学习。
我正在「人人都是Pythonista」和朋友们讨论有趣的话题,你⼀起来吧?
https://t.zsxq.com/aMrjYrz