1 列表（元组）基本使用

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

3 列表（元组）in和not in

• in是判断某个成员（元素）是否在该数据结构中
• not in就是判断某个成员（元素）是否不在该数据结构中

4 列表的添加append函数

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

用法
list append（new_item）
参数：
new item：添加进列表的新的元素（成员）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6SAxydqn-1611749945052)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210127195518841.png)]

注意事项：

• 被添加的元素只会被添加到末尾

• append函数是在原有列表的基础上添加，不需要额外添加新的变量

5 列表的添加-insert函数

功能：

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

用法

list.insert（index，new_item）

参数

index：新的元素放在哪个位置（数字）
new_item：添加的新元素（成员）

6 列表insert和append的区别

• append只能添加到列表的结尾，而insert可以选择任何一个位置

• 如果insert传入的位置列表中不存在，则将新元素添加到列表结尾

• 字符串，元组，列表元素的位置是从0开始计算的

7 列表（元组）的 count函数

功能：

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

用法：

inttype = list.count(item）

参数:

item：你想查询个数的元素

注意事项：

• 如果查询的成员（元素）不存在，则返回0

• 列表只会检查完整元素是否存在需要计算的内容

# coding:utf-8

animals = ['小猫', '小狗', '龙猫', '小猫', '鹦鹉', '小狗', '小兔子', '小猫']

cat = animals.count('小猫')
dog = animals.count('小狗')
l_cat = animals.count('龙猫')
rabbit = animals.count('小兔子')

print('我家的院子里有很多小动物')
print('其中小猫有 %s 只' % cat)
print('小狗有 {} 只'.format(dog))
print(f'龙猫有 {l_cat} 只')
print('小兔子有 %d 只' % rabbit)
print('我们没有小松鼠， 所以松鼠有  %s 只' % animals.count('松鼠'))

animals_dict = [
    {'name': 'dog'},
    {'name': 'dog'},
    {'name': 'cat'}
]

dog_dict_count = animals_dict.count({'name': 'dog'})
print('小狗在动物的字典中有%s只' % dog_dict_count)

animals_tuple = ('小猫', '小狗', '龙猫', '小猫',
           '鹦鹉', '小狗', '小兔子', '小猫')

cat = animals_tuple.count('小猫')
dog = animals_tuple.count('小狗')
l_cat = animals_tuple.count('龙猫')
rabbit = animals_tuple.count('小兔子')

print('其中小猫有 %s 只\n小狗有 %s 只\n龙猫有 %s 只\n小兔子有%s只'
      % (cat, dog, l_cat, rabbit))

8 列表的 remove函数

删除列表中的某个元素

用法

list.remove（item）

参数

item：准备删除的列表元素

remove的注意事项

• 如果删除的成员（元素）不存在，会直接报错

• 如果被删除的元素有多个，只会删除第一个

• remove函数不会返回一个新的列表，而是在原先的列表中对元素进行删除

9 Python的内置函数del

# coding:utf-8

shops = ['可乐', '洗发水', '可乐', '牛奶', '牛奶', '牙膏', '牙膏']

print('我们的超市有这些内容:%s' % shops)
print('我们的可乐有%s件产品' % shops.count('可乐'))
print('我们的牛奶有%s件产品' % shops.count('牛奶'))
print('我们的牙膏有%s件产品' % shops.count('牙膏'))
print('我们的洗发水有%s件产品' % shops.count('洗发水'))
print('我们要购买一件洗发水')
shops.remove('洗发水')
print('现在我们的洗发水还剩下%s件, 当前已经没有洗发水了' % shops.count('洗发水'))
shops.remove('可乐')
print('当前可乐还有%s' % shops.count('可乐'))
shops.remove('可乐')
print('可乐还有%s件' % shops.count('可乐'))

del shops

print(shops)

10 列表的 reverse函数

功能：

对当前列表顺序进行反转

用法

list.reverse

参数

无参数传递

11 列表的sort函数

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

用法：

list.sort（key =None，reverse=False）

参数：

key-参数比较

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

注意事项：

列表中的元素类型必须相同，否则无法排序（报错）

12 列表的cear函数

将当前列表中的数据清空

用法：

list.clear0->该函数无参数，无返回值

# coding:utf-8

mixs = ['python', 1, (1,), {'name': 'dewei'}]
print(mixs, len(mixs))
mixs.clear()
print(mixs, len(mixs))

mixs = []

13 列表的copy函数

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

用法：

list.copy()->该函数无参数，返回一个一模一样的列表

copy与二次赋值的区别:

a = [1,2,3]
b = a

• 二次赋值的变量与原始变量享有相同内存空间
• copy函数创建的新列表与原始列表不是一个内存空间，不同享数据变更
• copy属于浅拷贝

浅拷贝：

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

深拷贝：

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

# coding:utf-8

old_list = ['python', 'django', 'flask']

new_list = old_list
new_list.append('tornado')

print(new_list)
print(old_list)
print(id(new_list), id(old_list))

old_list.remove('tornado')
print(new_list, old_list)

del new_list
print(old_list)


old_list_copy = ['python', 'django', 'flask']
new_list_copy = old_list_copy.copy()

print(old_list_copy, new_list_copy)
new_list_copy.append('tornado_copy')
print(old_list_copy, new_list_copy)
print(id(old_list_copy), id(new_list_copy))

13 列表的 extend函数

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

用法：

list.extend（iterable）->

参数：

iterable代表列表或元组，该函数无返回值

# coding:utf-8

manhua = []
history = []
code = []

new_manhua = ('a', 'b', 'c')
new_history = ('中国历史', '日本历史', '韩国历史')
new_code = ('python', 'django', 'flask')

manhua.extend(new_manhua)
history.extend(new_history)
code.extend(new_code)

print(manhua, history, code)

history.extend(manhua)
del manhua
print(history)

14 列表的索引与切片

什么是索引：

• 字符串，列表和元组
• 从最左边记录的位置就是索引
• 索引用数字表示，起始从0开始

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

什么是切片：

• 索引用来对单个元素进行访问，切片则对一定范围内的元素进行访问
• 切片通过冒号在中括号内把相隔的两个索引查找出来[0：10]
• 切片规则为：左含，右不含

# coding:utf-8

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(len(numbers) - 1)
print(numbers[9])
print(id(numbers))
print('获取列表完整数据：', numbers[:])
print('另一种获取完整列表的方法：', numbers[0:])
print('第三种获取列表的方法：', numbers[0:-1])
print('列表的反序:', numbers[::-1])
print('列表的反项获取', numbers[-3:-1])
print('步长获取切片:', numbers[0: 8: 2])
print('切片生成空列表', numbers[0: 0])
new_numbers = numbers[: 4]
print(new_numbers)

numbers[3] = 'code'
print(numbers)
numbers[2: 5] = ['a', 'b', 'c']
print(numbers)

item = numbers.pop(4)
print(item, numbers, len(numbers))

del numbers[4]
print(numbers)

tuple_test = (1, 2 ,3)
del tuple_test

15 列表的pop函数

通过索引删除并获取列表的元素

用法：

list.pop（index）

参数

• index：删除列表的第几个索引

• 函数会删除该索引的元素并返回

• 如果传入的 index索引不存在则报错

16 列表通过de删除索引

del list[index]

直接删除无返回值

如果lindex（索引）不存在则报错

17 索引切片在元组中的特殊性

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

18 索引与切片之字符串

• 索引规则与列表相同
• 切片和索引的获取与列表相同
• 无法通过索引修改与删除
• 字符串不可修改

name= 'dewei'
name[0]->d
name[: 2]->de

19 字符串的find与 index函数

功能：

获取元素的索引位置

用法:

• string index（item）->item：查询个数的元素返回索引位置

• string.find（item）->item：查询个数的元素，返回索引位置

# coding:utf-8

name = 'dewei'
new_name = name[::-1]
print(new_name)

print(new_name)
result = new_name.index('wei')
print(result)