Python之旅-基础篇（三）

第三章，来介绍python中较为复杂的数据类型，即**“列元典集”**四种。

---

列表list

列表是由一系列按特定顺序排列的元素组成，是可以存储一系列数据的数据结构，python的列表还有一个比其他语言更强大的地方，就是同一个列表无需什么其他操作，就可以存储不同类型的数据。同时，也不需要首先申请它的长度。

表示

我们用中括号来定义一个列表

weiky=['w','e','i','k','y']

而系统输出的时候会用[ ]的样式，表示这是一个列表

#输出： ['w','e','i','k','y']

访问

列表是有序的因此我们可以用某个元素位置索引来找到这个元素。

print(weiky[0])
#输出 'w'

• 当我们输出单个元素的时候，就不会在显示[ ]
• 索引的第一个数字为0，而不是为1
• 我们可以用负数，来以倒序的方式来访问

print(weiky[-1])
#输出 'y'

修改

若你想修改列表中的一个元素值，你只需要利用索引找出元素，重新赋值即可。

Weikys=["JLHS","20","信息安全"]
Weikys[0]="NJUPT"
print(Weikys)
#输出 ['NJUPT','20','信息安全']

添加

append():在列表末尾添加

Weikys.append('male')
print(Weikys)
#输出 ['NJUPT','20','信息安全'，'male']

insert():在列表中插入

Weikys.insert(0,"NJ")
print(Weikys)
#输出 ['NJ','NJUPT','20','信息安全'，'male']

删除

del+变量名

del Weikys[4]
print(Weikys)
#输出['NJ','NJUPT','20','信息安全']

pop

方法pop()可删除列表末尾的元素，源于弹出栈的术语，删除列表末尾的元素相当于弹出栈顶元素

print(Weikys)
Weiky_last=Weikys.pop()
print(Weikys)
print(Weiky_last)
#输出 ['NJ','NJUPT','20','信息安全']
#输出 ['NJ','NJUPT','20']
#输出 '信息安全'

处理

sort(default reverse=False)

cars=['bmw','audi','toyota','subaru']
cars.sort()
print(cars)
#sort不单单是有序输出，会永久性的改变列表顺序
#按照字母顺序排序
#当你改变sort()的参数reverse=True时，则会为倒序

sorted(default reverse=False)

sorted()是sort()的临时性版本，即它不会改变列表顺序

reverse()

cars=['bmw','audi','toyota','subaru']
cars.reverse()
print(cars)
#reverse()是将整个列表调了个头，即与原来的顺序恰好相反；与上面的函数截然不同

len()

该函数可以统计列表的个数，也可以成为统计列表的长度

cars=['bmw','audi','toyota','subaru']
len(cars)

数列表

range(default n=0,m,default p=1)

表示创建以n为起始，m-1为终止的一系列数，如果只填一个参数，则n的值默认为0,p数值指定间隔，默认值为1

list()

将一系列数转换为列表，可以将list(range(n,m))协同使用，即是生成了以n为起始，m-1为终止的列表。

列表解析

#用一句合在一起的话来描述
squares=[value**2 for value in range(1,11)]
print(squares)

切片

在使用列表的索引时，也可以指定一块区域，形似range()的使用方法，当上限的值也取不到。

cars=['bmw','audi','toyota','subaru']
print(cars[0:2])

如果没有前索引，即可以表示列表前或者后的所有元素。

也可以使用负数索引，负数指的是倒着数的顺序排列的，起始索引为-1

复制

cars=['bmw','audi','toyota','subaru']
favorcars=cars[:]

---

元组tuple

定义

元组的特征是**（）**,定义的时候是使用（）

在本质上其实就是关联度比列表的数列，索引的访问方式和列表是相同的。

不可修改

元组中的元素是不可以像列表一样修改的，但是同一个元组名可以重新整体赋值。

---

字典dict

定义

字典是以键值对的方式组织数据的，键和值一一对应，每一个键就是值的索引，字典的特征是**{}**

alien_0={'color':'green',
         'points':5
          'HP':100}
#索引
print(alien_0['color'])

添加与修改

可以直接通过赋值的方式给字典加元素

alien_0['x_position']=0
alien_0['y_position']=25

删除

del

del alien_0['color']

遍历

键值对

key和value是两个字典重要的关键词

for key,value in user_0.items:
    print(f"\nKEY:{key}")
    print(f"VALUE:{value}")

键

keys( )

keys()可以使得我们在不重视值的时候，完成遍历键。本质上keys()返回的是由键组成的列表。

alien_0={'color':'green',
         'points':5
          'HP':100}
for name in alien_0.keys():
    print(name)

values()

values()则是可以直接值的大小，返回的也是一个列表。

alien_0={'color':'green',
         'points':5
          'HP':100}
for number in alien_0.values():
    print(number)

嵌套

需要注意的是，字典是一个巨大的数据类型的熔炉，在字典中可以包含所有种类的数据类型，如字典中的列表，字典中的字典

小技巧

这里总结了我在变成过程中有意思的小算法：

键值转换

在Python中，要将字典的键值互换，可以使用字典推导式（dict comprehension）来创建一个新的字典，如下：

python复制代码# 原始字典
original_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 创建一个新的字典，其键和值与原字典互换
swapped_dict = {value: key for key, value in original_dict.items()}

print(swapped_dict)

上述代码会输出： {'Alice': 'name', 25: 'age', 'New York': 'city'}

请注意，字典的键必须是不可变（immutable）且唯一的。如果原字典的值有重复，或者有可变类型（如列表），则在进行键值互换时会出现问题。

值向上位移

要使字典的值向上位移，可以将字典的值提取到一个列表中，然后将列表中的第一个元素移动到列表的末尾。之后，再将更新后的列表的值重新赋值给字典的键，如下：

python复制代码my_dict = {'a': 1, 'b': 2, 'c': 3}

# 提取字典的值到列表
values = list(my_dict.values())

# 将第一个元素移动到列表末尾
first_value = values.pop(0)
values.append(first_value)

# 将更新后的值重新赋值给字典的键
for key, value in zip(my_dict.keys(), values):
    my_dict[key] = value

print(my_dict)

这段代码会将字典{'a': 1, 'b': 2, 'c': 3}中的值向上位移，输出结果为`{‘a’: 2, ‘b’: 3, ‘c’: 1}

---

集合set

定义

就集合的外貌上来说就想是字典的兄弟，因为它的特征也是**{}**,但是它有一些特征：

1.字典都是键值对的成双成对出现的，但是集合的元素是单一的。

2.集合里面每个元素都是唯一的，并且不像列表，它没有顺序可言。

num={1,2,3,4,5,6}

查找

in

print(2 in num)
#输出： True

增加

add()

num.add(11)

合并

update()

num.update({0,9,8})

删除

remove( )

num.remove(2)

discard()

用法和remove()相同，只是当remove删除集合中不存在的元素时，系统会报错，但是discard()则没有这样的问题。

pop()

弹出集合的一个元素，定义中的第一个，但是要强调集合的无序性

同时可以给一个变量赋值

num1=num.pop()

clear()

清除所有元素

num.clear()

并集

union()

num.union({3,4,5,6,7})

交集

intersection()

用法同上

固定

frozenset()