Python基础（三）列表、元组、字典、集合_元组与列表、字典与集合、字符串与列表的共同点和区别

一、序列（sequence）

• 序列是Python中最基本的一种数据结构。
• 数据结构指计算机中数据存储的方式。
• 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引。
• 序列的分类：
  • 可变序列（序列中的元素可以改变）
    • 列表（list）
  • 不可变序列（序列中的元素不可以改变）
    • 字符串（str）
    • 元组（tuple）
• 序列的通用操作：
  • 切片
  • +、*
  • in、not in
  • max（）、min（）
  • index（）
  • count（）

二、列表（list）

2.1 简介

        列表可以保存多个有序（数据按添加的顺序存储）的数据，另外Python不用声明变量类型，所以列表可以直接存放不同类型的对象。

使用[]创建列表

my_list = [10, 2.2, "33", True, None]
'
运行
运行

但是如果Java想实现这一点，则要声明List的泛型为Object。

List list = new ArrayList<>();

可以通过索引获取列表中的元素，若索引超出长度，则报 list index out of range 异常。

my_list = [10, 20, 30, 40, 50]
print(my_list[2]) # 30
'
运行
运行

如果索引为负数，则表示倒序。-1表示倒数第一个，-2表示倒数第二个。

my_list = [10, 20, 30, 40, 50]
print(my_list[-1]) # 50
'
运行
运行

使用len（）函数获取列表的长度。

my_list = [10, 20, 30, 40, 50]
print(len(my_list))
'
运行
运行

5

---

2.2 通用操作

切片

        切片指从现有列表中，获取一个子列表。

• 语法：列表[起始位置：结束位置]
  • 不包括结束的位置，左闭右开。
  • 返回一个新列表，不影响原来的列表。
  • 起始跟结束位置的索引可以省略：
    • 若起始省略，表示从第一个开始。
    • 若结束省略，表示截取到最后一个。
    • 如果都省略，相当于复制了一份原来的列表。

  names = ["tom", "jack", "amy", "bob", "ross"]
  subname = names[3:]
  print(subname)   # ['bob', 'ross']
  subname = names[:3]
  print(subname)   # ['tom', 'jack', 'amy']
  subname = names[:]
  print(subname)   # ['tom', 'jack', 'amy', 'bob', 'ross']
  '
  运行
  运行

• 语法：列表[起始位置：结束位置：步长]
  • 步长表示每次获取元素的间隔。
  • 步长可以是负数，但不能是0。
  • 步长若是负数，表示倒序取元素

其他

• + 拼接、* 重复

names = ["tom", "jack", "amy"]
print(names + ["helloworld"])
print(names * 2)
'
运行
运行

['tom', 'jack', 'amy', 'helloworld']
['tom', 'jack', 'amy', 'tom', 'jack', 'amy']

• in、not in 判断元素是否在序列中

print("tom" in names) # True
print("tom" not in names) # False
print("jerry" in names) # False
print("jerry" not in names) # True

• max()、min() 最大最小值

num=[10,20,30,40,50]
print(max(num)) # 50
print(min(num)) # 10
'
运行
运行

• index()  获取指定元素的第一个索引位置，若元素不存在，抛异常。
• count()  统计指定元素出现的次数。

num = [10, 20, 30, 40, 30, 20, 10]
print(num.index(10)) # 0
print(num.count(20)) # 2
'
运行
运行

2.3 修改元素

通过索引修改

names = ["Bob", "Jack", "Jerry", "Tom"]
names[1] = "hello"
print(names)
'
运行
运行

['Bob', 'hello', 'Jerry', 'Tom']
'
运行
运行

通过切片修改

names = ["Bob", "Jack", "Jerry", "Tom"]
names[0:2]=["hello","world"]
print(names)
'
运行
运行

['hello', 'world', 'Jerry', 'Tom']
'
运行
运行

通过切片删除元素

names = ["Bob", "Jack", "Jerry", "Tom"]
del names[0:2]
print(names)
'
运行
运行

['Jerry', 'Tom']
'
运行
运行

 需要注意的是，以上操作仅限于可变序列。

2.4 列表的方法

增加元素

• list.append(value) 在最后的位置添加元素。
• list.insert(value，index) 在指定索引位置插入元素。
• list.extend( list) 将新序列扩展到当前序列尾部。

删除元素

• list.clear() 清空所有元素。
• list.pop(index) 删除指定索引上的元素，并返回该元素。若index不传，默认删除最后一个元素。
• list.remove(value) 删除指定的元素，若存在多个，只会删除第一个。

排序

• list.reverse() 反转列表。
• list.sort() 对元素进行排序，默认是升序。如果需要降序，需要传递一个reverse=True作为参数。

names = ["Bob", "Jack", "Amy", "Tom"]
names.sort(reverse=True)
print(names)
 
 
['Tom', 'Jack', 'Bob', 'Amy']
'
运行
运行

2.5 列表的遍历

        使用for循环遍历。（相当于Java中的fori循环）

for 变量 in 序列：

        代码块

names = ["Bob", "Jack", "Jerry", "Tom", "Rose"]
for s in names:
    print(s)
 
---------------------------------------
Bob
Jack
Jerry
Tom
Rose

2.6 range函数

        range()用来生成一个自然数的序列。

• 该函数需要3个参数：
  • 1.起始位置。可省略，默认为0。
  • 2.结束位置。
  • 3.步长。可以省略，默认为1。
• 通过range()可以创建一个执行指定次数的for循环。（相当于Java中的for循环）

for i in range(5):
    print("helloworld")
'
运行
运行

二、元组（tuple）

• 元组是一个不可变的序列。
• 它的操作方式与列表基本一致。
• 一般来说，不希望数据被改变时，就使用元组。

使用（）创建元组

my_tuple=(1,2,3,4)

• 当元组不是空元组时，括号可以被省略，但至少要有一个"，"

• my_tuple=10,20,30,40

my_tuple=10,

元组的解包（解构）

        解包就是将元组当中每一个元素都赋值给一个变量。

my_tuple = (10, 20, 30, 40)
a, b, c, d = my_tuple
print(a)
print(b)
print(c)
print(d)
'
运行
运行

• 利用元组解包，可以轻松交换两个变量的值。
• =右边的b,a相当于(b,a) ，也就等价于a,b=(b,a)。

a = 100
b = 200
a, b = b, a
print("a=", a)
print("b=", b)
'
运行
运行

• 在对元组进行解包时，变量的数量必须和元组的数量一致。
• 也可以在变量前添加一个*，这样变量将会获取元素中所有剩余的元素。
• 但是不能出现2个及以上的带*变量（multiple starred expressions in assignment）

my_tuple = (10, 20, 30, 40)
*a, b, c = my_tuple
print("a=", a) # [10,20]
print("b=", b) # 30
print("c=", c) # 40
'
运行
运行

my_tuple = (10, 20, 30, 40)
a, *b, c = my_tuple
print("a=", a) # 10
print("b=", b) # [20,30]
print("c=", c) # 40
'
运行
运行

my_tuple = (10, 20, 30, 40)
a, b, *c = my_tuple
print("a=", a) # 10
print("b=", b) # 20
print("c=", c) # [30,40]
'
运行
运行

==和is

• ==、!= 比较的是对象的值是否相等。
• is、is not 比较的是对象的id（地址值）是否相等，也就是判断两个对象是否是同一个对象。

 

三、字典（dict）

3.1 概述

• 字典属于一种新的数据结构，称为映射（mapping）。
• 字典作用和列表类似，都是用来存储对象的容器。
• 字典是可变对象。

使用{}创建字典

{key:value,key:value,....}

• 列表存储数据的性能很好，但是查询数据的性能很差。
• 字典中存储的为键值对（key-value）
  • 键可以是任意的不可变对象（int、str、bool、tuple.....）。
  • 值可以是任意对象。
  • 键是唯一，不可重复。若重复，后面的值替换前面的。
• 可以根据键来获取值。若键不存在，会报错（KeyError）

my_dict = {
    "name": "Tom",
    "age": 18,
    "sex": "man"}
# 根据键获取值
print(my_dict["name"])
print(my_dict["age"])
print(my_dict["sex"])
'
运行
运行

3.2 字典的使用

使用dict()函数创建字典

• 参数为键值对：key=value
  • 创建的字典，key都是字符串

#key=value
my_dict = dict(name="Tom", age=18, sex="man")
'
运行
运行

• 也可以将一个包含双值子序列的序列转换为字典
  • 双值序列：序列中只有 2个值。[1,2]、(“a“,3)，'ab'
  • 子序列：序列中的元素也是序列。
  • [(1,2),(3,4)]

# 双值子序列创建字典
my_dict = dict([("name", "Tom"), ("age", 18), ("sex", "man")])
'
运行
运行

长度

• len()函数

是否包含

• in、not in：检查字典中是否包含/不包含指定的键

获取值

• dict[ key ]：获取key对应的值。若key不存在，报异常。
• dict.get( key , default) ：获取key对应的值。若key不存在，返回default。

更新

• dict[ key ] =value ：如果key存在则覆盖，不存在则添加。
• dict.update( [other]) ：将其他字典的key-value添加到当前字典，若有重复的key，则替换。

删除 

• dict.popiteam()：删除最后一个键值对并以元组的形式返回。
• dict.pop(key, default) ：删除key对应的键值对，返回值。若key不存在，返回default。
• dict.clear() ：清空所有元素。

复制

• dict.copy()：对字典进行浅复制
  • 复制以后的对象与原对象独立
  • 注意：浅复制会简单地复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制。

dict = {"data": {'name': 'Tom', 'age': 18, 'sex': 'man'}, "AAA": 123}
dict2 = dict.copy()
dict2["data"]["name"] = "Jack"
print(dict)
print(dict2)
'
运行
运行

打印结果：

{'data': {'name': 'Jack', 'age': 18, 'sex': 'man'}, 'AAA': 123}
{'data': {'name': 'Jack', 'age': 18, 'sex': 'man'}, 'AAA': 123}
'
运行
运行

 

---

3.3 字典的遍历

• dict.keys() ：返回一个序列，保存字典所有的键。
  • 通过keys来遍历字典：

my_dict = dict(name="Tom", age=18, sex="man")
# 通过所有的key遍历字典
for key in my_dict.keys():
    print(key, "=", my_dict[key])
'
运行
运行

• dict.values() ：返回一个序列，保存字典所有的值。
• dict.items() ：返回一个序列，包含双值子序列，分别对应key和value，子序列的格式为元组。

for k, v in my_dict.items():
    print(k, "=", v)

四、集合（set）

4.1 概述

• 集合和列表非常相似
• 不同点：
  • 1.集合只能存储不可变对象
  • 2.集合存储的对象是无序（不是按照元素的插入顺序保存）
  • 3.集合不能出现重复的元素

4.2 集合的创建

使用{}来创建集合

s = {10, 3, 5, 1, 2, 1, 8}
'
运行
运行

使用set()来创建集合

• 可以通过set()来将序列和字典转换为集合。
• 当转换的是字典时，只会包含字典的键。

s = set([1, 2, 3, 4, 5, 1, 1, 3])
print(s) # {1, 2, 3, 4, 5}
s = set("hello")
print(s) # {'o', 'e', 'h', 'l'}
s = set({"name": "Tom", "age": 18, "sex": "man"}) 
print(s) # {'sex', 'name', 'age'}
'
运行
运行

4.3 集合的方法

判断是否存在

• in、not in

长度

• set.len()

增加

• set.add( element ) ：添加元素至集合。
• set.update( )：将集合/序列/字典中的元素添加到当前集合。

s = {10, 3, 5, 1, 2, 1, 8}
s2 = set("abc")
s.update(s2)
s.update([99, 100])
s.update({"name": "Tom"})
print(s)
 
#{1, 2, 3, 'a', 5, 'b', 'c', 8, 99, 10, 100, 'name'}
'
运行
运行

删除

• set.pop() ：随机删除一个集合元素。
• set.remove( element )：删除集合中指定的元素。
• set.clear() ：清空

复制

• set.copy()：浅复制。

4.4集合的运算

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
'
运行
运行

& 交集运算

result = s1 & s2
print(result) # {3, 4, 5}

| 并集运算

result = s1 | s2
print(result) # {1, 2, 3, 4, 5, 6, 7}

- 差集运算

result = s1 - s2
print(result) #{1, 2}

^ 异或集

        获取只在一个集合中出现的元素。

result = s1 ^ s2
print(result) # {1, 2, 6, 7}

<= 检查是否是子集

result = {3, 4, 5} <= {3, 4, 5, 6}
print(result) # True
 
result = {3, 4, 5} <= {3, 4}
print(result) # False
'
运行
运行

< 检查是否真子集

result = {1,2,3} < {1,2,3}
print(result) # False
result = {1,2,3} < {1,2,3,4,5}
print(result) # True
'
运行
运行

>= 检查是否是超集

result = {3, 4, 5} >= {3, 4, 5, 6}
print(result) # False
result = {3, 4, 5} >= {3, 4}
print(result) # True
'
运行
运行

> 检查是否真超集

result = {1, 2, 3} > {1, 2, 3}
print(result) # False
result = {1, 2, 3, 4, 5} > {1, 2, 3}
print(result) # True
'
运行
运行