Python学习笔记--list

可直接放入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