PYTHON 学习笔记3 元组、集合、字典

前言

在上一节的学习中。学习了基本的流程控制语句，if-elif-else for while 等，本节将拓展上一节学习过的一些List 列表当中操作的一些基本方法，以及元祖、序列等。

列表扩展

我们知道，List 是Python最基本的数据结构。序列中每个元素都分配一个索引。每个序列都可以使用基本的操作。包括

1. 索引
2. 切片
3. 加减乘除

在之前的学习当中。已经使用过基本的方法有：append() 在列表后追加一个元素。这里我们将再介绍多个方法，以便于更好的操作列表

insert(i,x)

在指定的位置加入一个元素。例如 list.insert(0,1) 将1 这个元素插入到列表 list 的首位。

arr = [1,2,2,3,4,5]

arr.insert(0,6)

print(arr)
---------------
[6, 1, 2, 2, 3, 4, 5]

append(x)

append() 方法其实是向末尾添加一个元素，相当于

arr[len(arr):] = [x]

remove(x)

移除列表里面首次出现的x,若没有则抛出异常

arr.remove(2)
print('remove',arr)
-------------------
remove [6, 1, 2, 3, 4, 5]

pop([i])

出栈操作，可选参数i ,移除指定索引位置的元素，并返回移除掉的元素，若无参数，则直接移除最后一个元素，并返回

print('pop',arr.pop())
print(arr)
----------------------
[6, 1, 2, 3, 4]

clear()

清空当前列表所有元素

arr.clear();
print(arr)
------------
[]

count(x)

计算元素 x 在数列中出现的次数。

print(arr)
print(arr.count(2))
--------------------
[6, 1, 2, 3, 4]
1

reverse()

用于翻转列表

print(arr)
arr.reverse()
print(arr)
--------------
[6, 1, 2, 3, 4]
[4, 3, 2, 1, 6]

列表的栈使用

我们知道。栈最大的特点是：元素后进先出，最后一个插入，最先取出。这里就只需要涉及到元素的入栈、出栈、

• 入栈 append(x)
• 出栈 pop()

列表的推导式

假设我们需要一个10 以内的，所有数的平方组成的一个列表。我们可以这样：

pont = []

for i in range(10):
    pont.append(i**2)
print(pont)
---------------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

然后，还有一种更加简洁的方式：比如:

ponts = [i**2 for i in range(10)]
print(ponts)
------------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

以上写法更加简洁。

列表推导式的结构是由一对方括号所包含的以下内容：一个表达式，后面跟一个 for 子句。

del 语句

有一种方式可以从列表按照给定的索引而不是值来移除一个元素: 那就是 del 语句
del 语句不同于 pop(x) del 不会返回任何值，直接作为删除,也可以配合切片

print(ponts)
del ponts[0]
print(ponts)
---------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

配合切片使用

print(ponts)
del ponts[3:]
print(ponts)
--------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4]

元组

元组和列表有很大的相同之处，定义的时候使用括号，或者不加括号也可以。

元组最大的特点在于：定义后元素不可改变,元素不可单独赋值
可变的元组，其实就可以叫列表List

元组是 immutable （不可变的），其序列通常包含不同种类的元素

arrays = (1,2,2,3,3,4,5)

print(type(arrays))
----------------------
<class 'tuple'>

base = ('hello',123,'world')
print(base)
------------
('hello', 123, 'world')

特殊元组

比如我们要定义一个空元组。或者定义一个只包含一个元素的元组。那我们就可以这样。

zero = ()

one = 'hello',

print('type',type(zero),len(zero))
print('type',type(one),len(one))
-------------------------------
type <class 'tuple'> 0
type <class 'tuple'> 1

集合

集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。集合对象也支持像 联合，交集，差集，对称差分等数学运算。

创建一个集合

创建一个集合使用 set() 函数，或者{} 花括号来创建一个集合
注意：空集合只能通过set()创建

basket = {'red','yellow','blue','red','green'}
print(basket)
-----------
{'red', 'yellow', 'blue', 'green'}

这里因为包含两个red ,第二个重复元素被覆盖。

print('red' in basket)
----------------
True

in 关键字 用于表示指定元素是否存在于集合内？

basketa = set('abcdefg')
print(basketa)
basketb = set('abcd')
print(basketb)
----------------
{'a', 'c', 'd', 'g', 'e', 'f', 'b'}
{'d', 'a', 'b', 'c'}

集合算数运算

print(basketa - basketb)
----------------
{'e', 'f', 'g'}

与或的运算，与运算取出两个集合都有的元素。而或运算则取出两个的并集，消除重复元素后的并集

print(basketa | basketb)
print(basketa & basketb)
------------------------
{'d', 'b', 'e', 'g', 'c', 'a', 'f'}
{'d', 'b', 'c', 'a'}

字典

理解字典的最好方式，就是将它看做是一个 键: 值 对的集合，键必须是唯一的（在一个字典中）。一对花括号可以创建一个空字典：{} 。另一种初始化字典的方式是在一对花括号里放置一些以逗号分隔的键值对，而这也是字典输出的方式。

字典主要的操作是使用关键字存储和解析值。也可以用del来删除一个键值对。

tel = {'id':12,'name':'test','age':18}
print(tel)
print(tel['id'])

del tel['age']
print(tel)
-----------------------
{'id': 12, 'name': 'test', 'age': 18}
12
{'id': 12, 'name': 'test'}

所有的键

通过 list() 函数来检索所有的字典包含的键信息

print(tel)
print(list(tel))
----------------
{'id': 12, 'name': 'test', 'age': 18}
['id', 'name', 'age']

推导式创建

{x: x**2 for x in (2, 4, 6)}
----------
{2: 4, 4: 16, 6: 36}

字典的循环

当在字典中循环时，用 items() 方法可将关键字和对应的值同时取出

for k,v in tel.items():
    print('key',k,'value',v)
----------
key id value 12
key name value test
key age value 18

小结

通过本节，已经将最基本的6中类型学习完毕了。包括有

• 字符串
• 数字
• 列表List
• 元组
• 字典

学习这些基本类型，其实就是为了更好的学习这门语言，基本类型也是一个基础。
下一节将学习一些基本的模块、模块的导入以及使用