4、Python列表的操作

置顶 Python python
发布时间 :
  1. Python列表的操作
    1. 1、len在列表元组中的使用
    2. 2、列表（元组）之间的累加与乘法
    3. 3、in和not in在列表（元组）中的用法
    4. 4、列表的添加-append函数
    5. 5、列表的添加-insert函数
    6. 6、列表（元组）的count函数
    7. 7、列表的remove函数
    8. 8、列表的reverse函数
    9. 9、列表的sort函数
    10. 10、列表的clear函数
    11. 11、列表的copy函数
    12. 12、列表的extend函数
    13. 13、列表的索引与切片
    14. 14、索引与切片之字符串

Python列表的操作

1、len在列表元组中的使用

In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: length = len(names)
In [3]: print(length)
Out[1]: 3

　len函数可以计算出除了数字类型以外，其他所有的数据类型的长度

2、列表（元组）之间的累加与乘法

In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: new_names = names + names
In [3]: print(new_names)
Out[1]: ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu', 'xiaowang', 'xiaoming']

In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: new_names = names * 2
In [3]: print(new_names)
Out[1]: ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu', 'xiaowang', 'xiaoming']

3、in和not in在列表（元组）中的用法

  1. in是判断某个成员（元素）是否在该数据结构中
  2. not in就是判断某个成员（元素）是否不再该数据结构中
In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: bool('xiaoliu' in names)
Out[1]: True
In [3]: bool('xiaohong' in names)
Out[2]: False

4、列表的添加-append函数

  • append的功能

    将一个元素添加到当前列表中

  • append的用法

    • 用法：list.append(new_item)
    • 参数：new_item：添加进列表的新的元素（成员）
    In [1]: names = ['xiaoliu']
In [2]: names.append('xiaowang')
In [3]: print(names)
Out[1]: ['xiaoliu', 'xiaowang']

  • append的注意事项

    1. 被添加的元素只会被添加到末尾
    2. append函数是在原有列表的基础上添加，不需要额外添加新的变量

5、列表的添加-insert函数

  • insert的功能

    将一个元素添加到当前列表的指定位置中

  • insert的用法

    • 用法：list.insert(index, new_item)

    • 参数

      index：新的元素放在哪个位置（数字）

      new_item：添加的新元素（成员）

    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: names.insert(1, 'xiaohong')
In [3]: print(names)
Out[1]: ['xiaoliu','xiaohong', 'xiaowang', 'xiaoming']

  • insert与append的区别

    1. append只能添加到列表的末尾，而insert可以选择任何一个位置
    2. 如果insert传入的位置列表中不存在，则将新元素添加到列表结尾
    3. 字符串，元组，列表的位置是从0开始计算的

6、列表（元组）的count函数

  • count的功能

    返回当前列表中某个成员的个数

  • count的用法

    • 用法：inttype = list.count(item)
    • 参数：你想查询个数的元素
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu']
In [2]: count = names.count('xiaoliu')
In [3]: print(count)
Out[1]: 2

  • count的注意事项

    1. 如果查询的成员（元素）不存在，则返回0
    2. 列表只会检查完整元素是否存在需要计算的内容
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu']
In [2]: count = names.count('xiao')
In [3]: print(count)
Out[1]: 0

7、列表的remove函数

  • remove的功能

    删除列表中的某个元素

  • remove的用法

    • 用法：list.remove(item)
    • 参数：item：准备删除的列表元素
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu']
In [2]: names.remove('xiaowang')
In [3]: print(names)
Out[1]: ['xiaoliu', 'xiaoming', 'xiaoliu']

  • remove的注意事项

    1. 如果删除的成员（元素）不存在，会直接报错
    2. 如果被删除的元素有多个，只会删除第一个
    3. remove函数不会反悔一个新的列表，而是在原先的列表中对元素进行删除

  • Python内置函数del

    • del把变量完全删除
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaoliu']
In [2]: del names
In [3]: print(names)
Out[1]: NameError: name 'names' is not defined

8、列表的reverse函数

  • reverse的功能

    对当前列表顺序进行翻转

  • reverse的用法

    • 用法：list.reverse()
    • 参数：无参数传递
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: names.reverse()
In [3]: print(names)
Out[1]: ['xiaoming', 'xiaowang', 'xiaoliu']

9、列表的sort函数

  • sort的功能

    对当前列表按照一定规律排序

  • sort的用法

    • 用法：list.sort(key=None, reverse=False)

    • 参数：

      key - 参数比较(必须是一个函数)

      reverse - 排序规则，reverse = True降序，reverse = False升序（默认）

      key设计函数学习，后续再写，当前默认不传递

    In [1]: books = ['python', 'django', 'web']
In [2]: books.sort()
In [3]: print(books)
Out[1]: ['django', 'python', 'web']

  • sort的注意事项

    • 列表中的元素类型必须相同，否则无法排序（报错）
    In [1]: mixs = ['python', 1, 1.5, 'django']
In [2]: mixs.sort()
Out[1]: TypeError: '<' not supported between instances of 'int' and 'str'

10、列表的clear函数

  • clear的功能

    讲当前列表中的数据清空

  • clear的用法

    list.clear() –>该函数无参数，无返回值

    In [1]: books = ['python', 'django', 'web']
In [2]: books.clear()
In [3]: print(books)
Out[1]: []

11、列表的copy函数

  • copy的功能

    将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同

  • copy的用法

    • 用法：list.copy() –>该函数无参数，返回一个一模一样的列表
    In [1]: old_list = ['a', 'b', 'c']
In [2]: new_list = old_list.copy()
In [3]: print(new_list)
Out[1]: ['a', 'b', 'c']

  • copy与2次赋值的区别

    1. 二次复制的变量与原始变量享有相同内存空间

    2. copy函数创建的新列表与原始列表不是一个内存空间，不同享数据变更

      In [1]: a = [1, 2, 3]
In [2]: b = a.copy()
In [3]: b.append(4)
In [4]: print(b)
In [5]: print(a)
Out[1]: b
        [1, 2, 3, 4]
        a
        [1, 2, 3]

    • copy属于浅拷贝

      • 浅拷贝：通俗的说，我们有一个列表a，列表里的元素还是列表，当我们拷贝出新列表b后，无论是a还是b的内部的列表中的数据发生了变化后，互相之间都会受到影响

        In [1]: a = [[1, 2, 3], [5, 6, 7]]
In [2]: b = a.copy()
In [3]: b[0].append(10)
In [4]: print(b)
In [5]: print(a)
Out[1]: b
        [[1, 2, 3, 10], [5, 6, 7]]
        a
        [[1, 2, 3, 10], [5, 6, 7]]

      • 深拷贝：不仅对第一层数据进行了copy，对深层的数据也进行了copy，原始变量和新变量完完全全不共享数据

        In [1]: a = [[1, 2, 3], [5, 6, 7]]
In [2]: b = a.deepcopy()
In [3]: b[0].append(10)
In [4]: print(b)
In [5]: print(a)
Out[1]: b
        [[1, 2, 3, 10], [5, 6, 7]]
        a
        [[1, 2, 3], [5, 6, 7]]

      • 深浅拷贝之间的内存变化

        因为列表里面存储的是可变类型元素，所以会产生子对象（开辟一块新的内存空间）去存储，如下图中lst1[5] 中实际上存储的是子对象的内存地址信息，浅拷贝只会拷贝父对象，而不会拷贝子对象，当子对象发生改变的时候，浅拷贝到的对象中的子对象数据也会一并发生改变，而深拷贝不仅会拷贝父对象，也会拷贝子对象

12、列表的extend函数

  • extend功能

    将其他列表或元组中的元素导入到当前列表中

  • extend用法

    • 用法：list.extend(iterable)
    • 参数：iterable代表列表或元组，该函数无返回值
    In [1]: names = ['xiaoliu', 'xiaowang', 'xiaoming']
In [2]: new_names = ('xiaogang', 'xiaohong')
In [3]: names.extend(new_names)
In [4]: print(names)
Out[1]: ['xiaoliu', 'xiaowang', 'xiaoming', 'xiaogang', 'xiaohong']

13、列表的索引与切片

  • 什么是索引

    1. 字符串，列表和元组，从最左边记录的位置就是索引

    2. 索引用数字表示，起始从0开始

    3. 字符串，列表（元组）的最大索引是他们的长度-1

      In [1]: I = ['name']
In [2]: I[0]
Out[1]: 'name'

  • 什么是切片

    1. 索引用来对单个元素进行访问，切片则对一定范围内的元素进行访问

    2. 切片通过冒号在中括号内把相隔的两个索引查找出来[0:10]

      numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[3:8])
>> [4, 5, 6, 7, 8]

    3. 切片规则为：左含右不含

  • 列表的索引，获取与修改

    1. list[index] = new_item

    2. 数据的修改只能在存在的索引范围内

    3. 列表无法通过添加新的索引的方式赋值

      test = ['a', 'b', 'c']
test[2] = 's' ----> OK
test[3] = 'o' ----> NO

    4. list.index[item]

      names = ['david', 'tom']
names.index['david']
>> 0
names.index['kevin']
>> ValueError: 'kevin' is not in list

  • 通过pop删除索引

    • pop的功能：通过索引删除并获取列表的元素

    • pop的用法：list.pop(index)，参数index：删除列表的第几个索引

      1、函数会删除改索引的元素并返回

      2、如果传入的index索引不存在则会报错

      names = ['david', 'tom']
pop_item = names.pop[0]
print('pop item: ', pop_item, 'names:', names)
>> pop item: david names:['tom']

  • 通过del删除索引

    1. del list[index]
    2. 直接删除，无返回值
    3. 如果index（索引）不存在，则会报错
    names = ['david', 'tom']
del names[1]
print(names)
>> ['david']

  • 索引在元组中的特殊性

    1. 可以和列表一样获取索引与切片索引
    2. 元祖函数index和列表用法完全一致
    3. 无法通过索引修改与删除元素

14、索引与切片之字符串

  • 字符串的索引，获取

    1. 索引规则与列表相同
    2. 切片规则和索引的获取与列表相同
    name = 'david'
name[0] --> d
name[:2] --> da

    无法通过索引修改与删除，因为字符串不可修改

  • 字符串的find与index函数

    • 功能：获取元素的索引位置

    • 用法：

      string.index(item) –>item：查询个数的元素，返回索引位置

      string.find(item) –>item：查询个数的元素，返回索引位置

      info = 'my name is david'
info.index('david')
>> 11
info.find('david')
>> 11

    • index与find的区别

      1. find如果获取不到，返回-1
      2. index如果获取不到，直接报错
      info = 'my name is david'
info.find('hello')
>> -1
info.index('hello')
>> ValueError: substring not found
转载请注明来源

粤ICP备2024346163号 ©2020-2025 David Deng

Built with Hexo and 3-hexo theme