python对象集合找出符合元素

Python列表、元组、字典、集合介绍

文章目录

• Python列表、元组、字典、集合介绍

• 序列
• 列表（List）

• 列表简介：
• 列表的基本使用
• 列表的切片操作
• 列表的函数与方法和通用操作
• 列表的修改
• 列表的遍历

• 元组（tuple）

• 简介：
• 元组的基本操作

• 字典（dict）

• 字典的基本简介
• 字典的基本操作
• 字典的方法函数和通用 方法
• 字典的遍历

• 集合（set）

• 集合概念
• 集合的基本操作
• 集合的函数方法
• 集合的运算

• 结束语

序列

在了解列表、元组与字典之前我们还需要了解一个概念：序列。

1、概念：序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列中都有唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引

2、序列的分类：

(1)、可变序列（序列中的元素可以改变）：例如 列表（list），字典（doct）；

(2)、不可变序列（序列中的元素不可变）：例如 字符串（str）、元组（tuple）；

列表（List）

列表简介：

列表是Python中的一个对象

列表作用:

列表可以保存多个有序的数据

列表可以储存对象的对象

列表的基本使用

通过“[]”英文的中括号来创建列表

lst = [] print(lst,type(lst)) #输出结果为：[] <class 'list'>

一个列表可以储存元素，可以在创建时直接指定元素，也可以创建后添加。

创建时直接指定：

lst = [1, 2, 'Pyhton'] print(lst, type(lst)) #输出结果为：[1, 2, 'python'] <class 'list'>

列表中元素可以时任意类型

lst = [1, None, True, 'python', '1.2'] print(lst, type(lst)) #输出结果为：[1, None, True, 'python', '1.2'] <class 'list'>

在来介绍下列表的索引：

列表索引有两种形式，一种时由左至右从0开始；一种时由右至左从-1开始，如下图：

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

lst = [1, 2, 3, 4] print(lst[0]) print(lst[1]) print(lst[2]) print(lst[3]) #输出结果为：1 2 3 4 print(lst[-1]) print(lst[-2]) print(lst[-3]) print(lst[-4]) #输出结果为：4 3 2 1

列表的切片操作

概念：从现有列表在获取一个子列表。切片时根据列表索引来操作的。

例：

#创建列表 hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长'] heroA = hero[1:3] print(heroA) #输出结果为：['蜘蛛侠', '绿巨人']

**切片的具体作用：

• 添加元素

• • 向零索引添加元素：

    hero = ['美队', '黑寡妇']
    hero[0:0] = ['灭霸']
    print(hero)
    #输出结果为：['灭霸', '美队', '黑寡妇']

  • 向列表中索引为偶数的添加元素

    hero = ['灭霸', '美队', '黑寡妇']
    hero[::2] = ['黑豹'] * 3
    print(hero)
    #输出结果为：['黑豹', '灭霸', '黑豹', '美队', '黑豹', '黑寡妇']

    上面个的hero[::2]表示从列表开头到结束以没两个添加一个元素

• 删除列表中的元素

  lst = [1, 2, 3, 4, 5]
  list[1:3] = []
  print(lst)
  #输出结果为：[1,4,5] 删除了列表索引1、2处的值

• 逆序列表

  lst = [1, 2, 3, 4, 5]
  print(lst[::-1])

• 特殊的切片

  • list[::]从开始到结束

    lst = [1,2,3]
    ptint(lst[::])
    #输出结果为：[1,2,3]
    print(list)
    #输出结果为：[1,2,3]

  • list[:n]从列表索引0开始到n结束，不包括n

    hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
    print(hero[:3])
    #输出结果为：['钢铁侠', '蜘蛛侠', '绿巨人']

  • list[n:]从n开始到结束

    hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
    print(hero[3:])
    #输出结果为：['黑寡妇', '蚁人', '美国队长']

• 切片的步长

  • list[int start, int end, int step]表时从start开始以没隔step个元素取一个元素到end为止，不包括end

    hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
    print(hero[::2])
    #输出结果为：['钢铁侠', '绿巨人', '蚁人']

  • list[int start, int end, -1]当列表步长为-1时就可以实现列表的逆序

    lst = [1,2,3,4]
    print(lst[::-1])
    #输出结果为：[4,3,2,1]

列表的函数与方法和通用操作

通用操作：

• “+”将两个列表拼接起来：

lst1 = [1,2,3] lst2 = [4,5,6] lst = lst1 + lst2 print(lst) #输出结果为：[1,2,3,4,5,6]

• “*”将列表中指元素重复次数

list = ['黑豹'] * 3 print(list) #输出结果为：['黑豹','黑豹','黑豹']

• “in” 和 “not in” 判断元素是否在列表中，返回boolean类型

lst = [1,2,3] print(1 in lst) #输出结果为：True print(1 not in lst) #输出结果为：False

函数：

• len() 获取列表中元素的个数或列表长度

lst = [1,2,3] print(len(lst)) #输出结果为：3

• max() 获取列表元素的ascll码最大值

lst = [1,2,3] print(max(lst)) #输出结果为：3

• min() 获取列表元素的ascll最小值

lst = [1,2,3] print(min(lst)) #输出结果为：1

方法：

• list.index(x[, i[, j]])获取元素在列表中的位置，从i开始查询到j结束

hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长'] print(hero.index('绿巨人',2,6)) #输出结果为：2

• list.count(x) 统计指定元素在列表在出现的次数

hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长'] print(hero.count('美国队长')) #输出结果为：2

• list.append(x) 向列表最后添加元素

hero = ['钢铁侠', '蜘蛛侠', '绿巨人'] hero.append('黑寡妇') print(hero) #输出结果为：['钢铁侠', '蜘蛛侠', '绿巨人'， '黑寡妇']

• list.insert(int index, char x) 向列表只当的索引位置index插入元素x

hero = ['钢铁侠', '蜘蛛侠', '绿巨人'] hero.insert(2,'黑寡妇') print(hero) #输出结果为：['钢铁侠', '蜘蛛侠', '黑寡妇', '绿巨人']

• list.extend() 用新的序列来扩展当前序列

lst1 = [1,2,3] lst2 = [4,5,6] lst1.extend(lst2) print(lst1) #输出结果为：[1,2,3,4,5,6]

• list.clear() 清空列表中的所有元素

lst = [1,2,3] lst.clear() print(lst) #输出结果为：[]

• list.pop(int index) 根据索引删除元素并返回指定元素，无索引时默认删除最后一个

lst = [1,2,3] result = lst.pop(2) print(result,lst) #输出结果为：3 [1,2]

• list.remove(char c)移除指定的元素，如果列表中有多个c则只会删除第一个

lst = [1,2,3] lst.remove(2) print(lst) #输出结果为：[1,2]

• list.reverse() 逆序列表的所有元素

lst = [1,2,3] lst.reverse print(lst) #输出结果为：[3,2,1]

• list.sort(reverse) 对列表元素进行ascll排序，reverse=True反序，reverse=False正序

lst = ['a','v','s'] lst.sort(reverse = True) print(lst) #输出结果为：['v', 's', 'a'] lst.sort() print(lst) #输出结果为：['a', 's', 'v']

列表的修改

• 通过索引修改

hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长'] hero[0] = '雷神' print(hero) #输出结果为：['雷神', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']

• 通过del 删除元素

hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长'] del hero[2] print(hero) #输出结果为：hero = ['钢铁侠', '蜘蛛侠', '美国队长'， '黑寡妇', '蚁人', '美国队长']

• 通过切片修改列表

hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长'] hero[0:2] = ['雷神', '奥丁', '月老'] print(hero) #输出结果为：['雷神', '奥丁', '月老'， '钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']

列表的遍历

在这就用一个例题来看：

温度转换问题，输入华氏温度转换为摄氏温度，输入摄氏温度转换为华氏温度；

Input Description：12.34C

Output Description: 54.21F

temperature = input("请输入温度:") if temperature[-1] in ['F', 'f']: c = (eval（temperature[0:-1]) - 32) / 1.8 print("转换后的温度是{:.2f}C".format(c)) elif temperature[-1] in ['c', 'C']: f = eval（temperature[0:-1]) * 1.8 + 32 print("转换后的温度是{:.2f}F".format(f)) else: print("输入的数据错误")

元组（tuple）

简介：

元组操作方式基本和列表是一致的，不过元组时不可变序列。所以在操作时像索引赋值，切片修改元素等这些，其他的通用方法都可以。

那么，我们应该在什么时候用列表，什么时候用元组呢？

一般，当我们希望数据不改变就可以用元组，其他情况都用列表。

元组的基本操作

创建元组：

• 用()创建元组

#创建一个空元组 my_tuple = () print(my_tuple, type(my_tuple)) #输出结果为：() <class 'tuple'>

• 创建时指定元素

my_tuple = (1,2,3,4) print(my_tuple, type(my_tuple)) #输出结果为：(1,2,3,4) <class 'tuple'>

• 不使用()创建元组，至少有一个“ , ”

my_tuple = 1, print(my_tuple, type(my_tuple)) #输出结果为：(1) <class 'tuple'>

元组的解包：

• 概念：将元组中各元素的值赋值给其他变量。

my_tuple = (1,2,3,4) a, b, c, d = my_tuple print(a) #输出结果为：1 print(b) #输出结果为：2 print(c) #输出结果为：3 print(d) #输出结果为：4

• 解包方式

• 只需要前两个值 a, b, *c = my_tuple

my_tuple = (1,2,3,4) a, b, *c = my_tuple print(a) #输出结果为：1 print(b) #输出结果为：2 print(*c) #输出结果为：3 4 print(c) #输出结果为：[3, 4]

• 只需要后两个值*a, b, c = my_tuple

my_tuple = (1,2,3,4) *a, b, c = my_tuple print(*a) #输出结果为：1 2 print(a) #输出结果为;[1, 2] print(b) #输出结果为：3 print(c) #输出结果为：4

• 只去中间两个值

• a, *b, c = my_tuple

my_tuple = (1,2,3,4) a, *b, c = my_tuple print(a) #输出结果为：1 print(*b) #输出结果为：2 3 print(b) #输出结果为：[2, 3] print(c) #输出结果为：4

• *a, b, c, *d = my_tuple

my_tuple = (1,2,3,4) *a, b, c, *d = my_tuple print(a) #输出结果为：1 print(b) #输出结果为：2 print(c) #输出结果为：3 print(d) #输出结果为：4

字典（dict）

字典的基本简介

• 字典属于一种新的数据结构称为映射（Mapping）
• 字典与列表很相似，都是用来储存对象的容器
• 列表储存性能好，但查询数据性能差，字典正好与之相反
• 字典中每一个元素都有唯一一个名字，可以通过名字找到指定的元素
• 唯一一个的名字可以称为key，通过key可以快速查找到与值唯一对应的值称为value
• 字典也称为键值对（key——value）结构
• 每个字典可以有多个键值对，每一对键值对称为项
• 创建一个有数据的字典语法：{key:value}
• 字典的值可以是任意对象，字典的键可以是任意的不可变对象

字典的基本操作

• 使用{}创建字典

#创建空字典 d = {} #创建带有数据的字典 d = {'name':'葫芦娃', 'age':12, 'gender':'男'}

• 使用函数dict()创建字典

d = dict('name':'葫芦娃', 'age':12, 'gender':'男') print(d, type(d)) #输出结果为：{'name':'葫芦娃', 'age':12, 'gender':'男'} <class 'dict'>

• 如果字典里的key重复了，那么后面的覆盖前面的

d = {'name':'葫芦娃', 'age':12, 'gender':'男, 'name':'钢铁侠'} print(d) #输出结果为：{'name':'钢铁侠', 'age':12, 'gender':'男}

• 取值，字典根据key来取值

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} print(d['name']) #输出结果为：葫芦娃

字典的方法函数和通用 方法

• 通用方法

• in 和 not in 判断字典中是否有这一元素

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} print('name' in d) #输出结果为：True

• 函数

• len() 获取字典键值对个数

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} print(len(d)) #输出结果为：3

• min() 获取字典key的ascll码最小值

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} print(min(d)) #输出结果为：age

• max() 获取字典key的ascll码最大值

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} print(max(d)) #输出结果为：name

• del 删除key——value

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} del d['name'] print(d) #输出结果为：d = {'age':12, 'gender':'男'}

• 方法

• dict.setdefault(key,value)字典添加键值对，如果key存在则返回value，不对字典操作。

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} d.setdefault('name':'钢铁侠') print(d) #输出结果为：d = {'name':'葫芦娃', 'age':12, 'gender':'男'} d.setdefault('address':'中国') print(d) #输出结果为：d = {'name':'葫芦娃', 'age':12, 'gender':'男', 'address':'中国'}

• dict.update(dict2) 将其他字典元素添加到当前字典中，如果有重复的key则后面的覆盖前面的

d1 = {'a':1, 'b':2} d2 = {'c':3, 'd':4} d1.update(d2) print(d1) #输出结果为：{'a':1, 'b':2, 'c':3. 'd':4} d3 = {'b':3, 'd':4} d1.update(d3) print(d1) #输出结果为：{'a':1, 'b':3, 'd':4}

• dict.popitem() 随机删除，一般是最后一个，返回一个元组，元组中第一个是key，第二个是value

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} s = d.popitem() pritn(s, d) #输出结果为：('gender', '男') {'name': '葫芦娃', 'age': 12}

• dict.pop(key[, default]) 根据key删除字典中的key——value，返回key的value,如果字典中没有要删除的key——value，则返回默认语句default

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} k = d.pop('name','没有这个值') print(k,d) #输出结果为：葫芦娃 {'age':12, 'gender':'男'} k = d.pop('str', '没有这个值') print(k, d) #输出结果为：没有这个值 {'name':'葫芦娃', 'age':12, 'gender':'男'}

• dict.keys() 返回字典所有key

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} keys = d.keys() pritn(keys) #输出结构为：dict_keys(['name', 'age', 'gender'])

• dict.values()返回字典所有value

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} values = d.values() print(values) #输出结果为：dict_values(['葫芦娃', 7, '男'])

• dict.item() 返回字典所有key——value的双值子序列

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} items = d.items() print(items) #输出结果为：dict_items([('name', '葫芦娃'), ('age', 7), ('gender', '男')])

字典的遍历

• 根据dict.keys()函数遍历

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} for i in d.keys(): print(d.get(i)) #输出结果为： 葫芦娃 7 男

• 根据dict.values()函数遍历

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} for i in d.values(): print(i) #输出结果为： 葫芦娃 7 男

• 根据dict.items()函数遍历

d = {'name':'葫芦娃', 'age':12, 'gender':'男'} for k, v in d.items(): print('{} = {}'.format(k, v)) #输出结果为： name = 葫芦娃 age = 7 gender = 男

集合（set）

集合概念

• 集合只能储存不可变对象
• 集合中储存的对象是无序的
• 集合中没有重复的对象

集合的基本操作

• 创建集合

• 通过“ {} ”创建集合, 通过该方法不可以创建空集合

s1 = {1,2,3,4} print(s1,type(s1)) #输出结果为：{1,2,3,4} <calss 'set'> s2 = {} print(s2, type(s2)) #输出结果为：{} <class 'dict'>

• 通过set()函数创建集合

s1 = set() print(s1, type(s1)) #输出结果为：set() <class 'set'> #将列表转化为集合 s2 = set([1,2,3,4]) print(s2, type(s2)) #输出结果为：{1,2,3,4} <class 'set'> #将字典转化为集合是只保留key d = {'name':'葫芦娃', 'age':12, 'gender':'男'} s3 = set(d) print(s3, type(s3)) #输出结果为：{'gender', 'name', 'age'} <class 'set'>

• 集合通用操作

• in 和not in 判断是否包含元素

s1 = {1,2,3,4} pritn(1 in s1) #输出结果为：True print(0 not in s1) #输出结果为：True

集合的函数方法

• len(set) 获取集合中的元素个数

s1 = {1,2,3,4} print(len(s1)) #输出结果为：4

• set.add()向集合中添加元素

s = {1,2,3,4} s.add(5) print(s) #输出结果为：{1, 2, 3, 4, 5}

• set.update()将另一个集合添加到当前集合

s1 = {1,2,3,4} s2 = set('python') s1.update(s2) print(s1) #输出结果为：{1, 2, 3, 4, 'h', 'p', 'n', 'o', 'y', 't'}

• set.pop()随机删除集合中的元素，并返回删除值

s1 = {1,2,3,4} result = s1.pop() print(result, s1) #输出结果为：1 {2,3,4}

• set.remove()删除集合中指定的值

s1 = {1,2,3,4} s1.remove(1) print(s1) #输出结果为：{2,3,4}

• set.clear() 清空集合中的所有元素

s1 = {1,2,3,4} s1.clear() print(s1) #输出结果为：set()

集合的运算

• 交集运算 “ & ”

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s1 & s2 print(result) #输出结果为：{3, 4, 5}

• 并集运算 “ | ”

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s1 | s2 print(result) #输出结果为：{1, 2, 3, 4, 5, 6, 7}

• 差集运算 “ - ”

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} result1 = s1 - s2 result2 = s2 - s1 print(result1,result2) #输出结果为：{1, 2} {6, 7}

• 异或运算 “ ^ ”

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s1 ^ s2 print(result) #输出结果为：{1, 2, 6, 7}

• <= 检查一个集合是否是另一个集合的子集

s1 = {1,2,3} s2 = {1,2,3,4} result = s1 <= s2 print(result) #输出结果为：True

• < 检查一个集合是否是；另一个集合的真子集

#s2 必须有s1中所有的元素，并且有s1没有的元素 s1 = {1,2,3} s2 = {1,2,3,4} result = s1 < s2 print(result) #输出结果为：True

• >= 检查一个集合是否是另一个集合的超集
• >检查一个集合是否是另一个集合的真超集