Python基础语法—— 列表+元组+字典

Posted 2022-09-12 郭怀远

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python基础语法—— 列表+元组+字典相关的知识，希望对你有一定的参考价值。

文章目录

一、列表和元组
二、字典

一、列表和元组

列表和元组一组变量的集合，它们可以批量粗存储数据。
元组和列表是非常相似的，只是列表中存放的元素是可以修改的，而元组是不可变的（也就是不能修改），所以创建元组的时候就要设定好，不能修改调整

1. 创建列表

创建列表主要有两种方式

list1 = []
list2 = list()
print(type(list1))
print(type(list2))
# 执行结果
<class 'list'>
<class 'list'>

设置初始值
```
my_list = [10, 3.14, 'hello']
print(my_list)
# 运行结果
[10, 3.14, 'hello']
```
Python列表中是可以存放不同类型的元素的，这和C/Java差别比较大

2. 下标访问

我们可以通过下标访问操作符[]来获取列表中的任意元素

从前往后访问下标是从0开始的
Python的索引是可以取负数的（从后往前是从-1开始，也就是倒数第一个元素）
如果下标越界就会抛出异常

my_list = [1, 2, 3, 4, 5]
print(my_list[0])
print(my_list[3])
print(my_list[-1])
print(my_list[-5])

计算列表长度，通过len函数

my_list = [1, 2, 3, 4, 5]
print(len(my_list))
# my_list[-1]就相当于 my_list[len(my_list)-1]

3. 切片操作

通过下标能后一次获取一个元素
通过切片则是一次获取一组连续的元素，相当于一个子列表

语法格式

列表名[起始下标:结束下标:步长]

区间是左闭右开的
[起始下标:结束下标)
步长默认是1，也就是每次夸多少个元素

代码示例

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[0:4:1])
print(lists[0:5:2])
print(lists[-1:-4:-1])
# 运行结果
[1, 2, 'hello', 3.14]
[1, 'hello', 'world']
['world', 3.14, 'hello']

在切片过程中可以省略前后边界

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[1:]) # 省略后边界，表示获取到列表末尾
print(lists[:-1]) # 省略前边界，表示从开头开始获取
print(lists[:]) # 省略两个边界表示获取整个列表

#运行结果
[2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14]
[1, 2, 'hello', 3.14, 'world']

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[::-1])
print(lists[::1])
print(lists[::-2])
# 运行结果 
['world', 3.14, 'hello', 2, 1]
[1, 2, 'hello', 3.14, 'world']
['world', 'hello', 1]

如果切片中填的数字越界了，不会有负面效果，只会尽可能的把满足条件的元素获取到

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[:500])
print(lists[100:])
运行结果
[1, 2, 'hello', 3.14, 'world']
[]

4. 变量列表元素

通过for循环遍历整个列表

lists = [1, 2, 'hello', 3.14, 'world']
for tmp in lists:
    print(tmp, end=' ')
print()
for i in range(len(lists)-1, -1, -1):
    print(lists[i], end=' ')

# 运行结果
1 2 hello 3.14 world 
world 3.14 hello 2 1

5. 新增元素

使用append方法，向列表末尾插入一个元素


lists = [1, 2, 'hello', 3.14, 'world']
lists.append(1000)
lists.append('test')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world', 1000, 'test']

使用insert方法，向任意位置插入一个元素

lists = [1, 2, 'hello', 3.14, 'world']
print(lists)
lists.insert(2, 'hahaha')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world']
[1, 2, 'hahaha', 'hello', 3.14, 'world']

6. 查看元素

使用in操作符，判断元素是否在列表中存在，相反not in则是判断元素是否不在列表中

lists = [1, 2, 'hello', 3.14, 'world']
print('hello' in lists)
print(2 in lists)
print(44 in lists)
print(44 not in lists)

# 运行结果
True
True
False
True

使用index方法。查找元素在列表中的下标，放回一个整数，如果元素不存在就会抛出异常

lists = [1, 2, 'hello', 3.14, 'world']
print(lists.index(2))
print(lists.index('haha')) # 不存在会抛异常

7. 删除元素

使用pop方法删除最末尾的元素，也可以使用下标来删除元素

lists = [1, 2, 'hello', 3.14, 'world']
print(lists.pop())
print(lists)
lists.pop(2)
print(lists)

# 运行结果
world
[1, 2, 'hello', 3.14]
[1, 2, 3.14]

使用 remove，按照值来删除元素

lists = [1, 2, 'hello', 3.14, 'world']
lists.remove(2)
lists.remove('hello')
print(lists)
# 运行结果
[1, 3.14, 'world']

8. 合并列表

使用+能够把两个列表拼接起来，返回一个新列表不会影响到就列表

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
print(my_list + lists)
print(lists + my_list)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world', 10, 3.14, 'hello']

使用 extend方法，相当于把一个列表拼接到另一列表后面
注意：a.extend(b)，是把b中的内容拼接到a的末尾，不会修改b但是会修改a

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.extend(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world']

使用append方法则是把整个列表当成一个元素拼接到后面

my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.append(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', [1, 2, 'hello', 3.14, 'world']]
[1, 2, 'hello', 3.14, 'world']

9. 关于元组

元组的功能和列表相比基本是相同的，只不过元组是不可变的

元组的创建，元组使用 ()来表示

my_tuple = tuple()
a_tuple = ()
print(type(my_tuple))
print(type(a_tuple))
# 运行结果
<class 'tuple'>
<class 'tuple'>

元组的访问

my_tuple = ('a', 10, 3.14)
print(my_tuple[2])
# 运行结果
3.14

元组不能修改，但切片、遍历、in、inde、+ 等操作也是一样支持的，像增删改这些操作就不支持了

my_tuple = ('a', 10, 3.14)
a_tuple = ('hello', 66)
print(my_tuple[:5])
print(my_tuple.index(10))
print(my_tuple + a_tuple)
print('hello' in a_tuple)

# 运行结果
('a', 10, 3.14)
1
('a', 10, 3.14, 'hello', 66)
True

另外，元组在Python中很多时候是默认的集合类型，列如，当一个函数要返回多个返回值的时候

def test():
    return 10, 'hello'


ret = test()
print(type(ret))

# 运行结果
<class 'tuple'>

10. 小结

既然有了列表，为啥还需要元组？

你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多
字典是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.
如果元素不需要改变, 则优先考虑元组.
如果元素需要改变, 则优先考虑列表

二、字典

1. 字典是啥？

在Python中字典是一种存储键值对的结构，一个 key 对应一个 value。且这个键(key)一定是唯一的
底层使用的哈希表，它的增删改查都是常数级的。

2. 创建字典

创建空的字典，使用表示字典

amap = 
my_map = dict()
print(type(amap))
print(type(my_map))
# 运行结果
<class 'dict'>
<class 'dict'>

也可以在创建的同时指定初始值
键值对之间使用逗号,分割，键和值使用冒号:分割

# 最后一个键值对的逗号可写可不写
student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18

print(student)
# 运行结果
'name': 'zhangsan', 'sex': 'boy', 'age': 18

3. 查找key

使用in可以判定key是否在字典中存在，返回布尔值

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18

print('name' in student)
print('phone' in student)
# 运行结果
True
False

使用[]通过类似于取下标的方式，获取到元素的值，只不过此处的下标是键(key)，这个键可以是整数也可以是字符串或者是其它类型

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

print(student['name'])
print(student[666])
# 运行结果
zhangsan
id

注意如果key在字典中不存在就会抛出异常

4. 新增&修改元素

使用 [] 可以根据key来新增/修改value

如果key不存在，对取下标操作赋值，即为新增键值对

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'


student[666] = 9494
print(student)
# 运行结果
'name': 'zhangsan', 'sex': 'boy', 'age': 18, 666: 9494

如果key已经存在，对取下标操作赋值，就是进行修改操作

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

student['name'] = 'lisi'
print(student)
# 运行结果
'name': 'lisi', 'sex': 'boy', 'age': 18, 666: 'id'

5. 删除元素

使用pop方法根据key删除对应的键值对

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

student.pop(666)
print(student)
# 运行结果
'name': 'zhangsan', 'sex': 'boy', 'age': 18

6. 遍历字典元素

直接使用for循环能够获取到字典中所有key，进一步的就可以去除每个值了

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

for key in student:
    print(key, student[key])

# 运行结果
name zhangsan
sex boy
age 18
666 id

7. 取出所有key和value

使用keys方法可以获取到字典中所有的key

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

print(student.keys())
# 运行结果
dict_keys(['name', 'sex', 'age', 666])

此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于
dict_keys 同样适用

使用values方法可以获取到所有字典中的所有value

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

print(student.values())
# 运行结果
dict_values(['zhangsan', 'boy', 18, 'id'])

此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似

使用items方法可以获取到字典中所有的键值对

student = 
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'

print(student.items())
# 运行结果
dict_items([以上是关于Python基础语法—— 列表+元组+字典的主要内容，如果未能解决你的问题，请参考以下文章 
 python基础--字符串列表元组字典
 python2基础-列表，元组，字典
 python基础语法 第4节课 （字典 元组 集合）
 python基础篇06-元组/字典
 为什么Python在列表和元组的末尾允许使用逗号？
 第四章  python基础之list 元组 字典 及拷贝