目录

  • 前言
  • 一、列表：[]、list()
  • 1.0、列表的特点和操作总览
  • 1.1、列表创建
  • 1.2、列表查找
  • 1.3、列表添加
  • 1.4、列表删除
  • 1.5、列表修改
  • 1.6、列表排序
  • 二、字典: {}、dict()
  • 2.0、字典的特点和操作总览
  • 2.1、字典创建
  • 2.2、字典查找
  • 2.3、字典添加
  • 2.4、字典删除
  • 2.5、字典修改
  • 2.6、字典遍历
  • 三、元组：()、tuple()
  • 3.0、元组的特点和操作总览
  • 3.1、元组创建
  • 3.2、元组的查找和遍历
  • 3.3、元组添加
  • 四、集合：{}、set()
  • 4.0、集合的特点和操作总览
  • 4.1、集合创建
  • 4.2、集合添加
  • 4.3、集合删除
  • 五、总结区别
  • Reference


前言

打算重新系统的温习一下基础，这一系列主要是温习一下python这门语言。不会涉及的太深的知识点，主要是一些基础性但是又容易忽视的东西，研一学的时候没怎么做笔记，也没好好总结一下，这里重新温习总结一下，方便后面用的时候就不用老是百度了。

这部分总结一下python常见的数据结构类型，主要是列表、字典、集合、元组这四类。

主要介绍下它们的区别和具体的操作。

下一节介绍String字符串。

一、列表：[]、list()

1.0、列表的特点和操作总览

列表的特点

序列类型：列表

  1. 是一个可变序列；
  2. 列表中的元素都是有序的；
  3. 列表中每一个元素都对应一个索引index，可以根据索引定位到对应的元素；
  4. 列表可以存储重复元素；
  5. 列表可以存储任意类型的元素；
  6. 列表没有固定长度，它可以根据元素个数实时动态分配内存空间；

操作总览

操作

描述

[]、list()

创建列表

x=ls.index(idx，start，end)

根据index在start-end范围内查找列表

ls.append(x)

在列表ls末尾添加一个元素x

ls.insert(i，x)

在列表ls的第i个位置添加元素x

ls.extend()

在列表ls的末尾添加若干个元素，1个或多个

ls.pop()

删除指定索引位置上的元素，默认是删除最后一个-1，0表示删除第一个元素

ls.remove(x)

删除列表中出现的第一个x元素

ls.clear()

清空列表

del ls

彻底删除列表

ls[idx] = new_value

修改列表元素

ls.sort()

默认升序，原地((即列表本身被修改 返回None))且稳定的排序(保持两个相等元素的顺序不变)，reverse属性可以降序排序

sorted(ls)

python内置函数，返回一个新列表，默认升序，reverse属性可以降序排序

1.1、列表创建

# 创建列表
# 1、[]创建列表
l1 = ['Hello', 'World', 'Python']
print(l1)

# 2、内置函数list创建列表
l2 = list(l1)
print(l2)

# 3、列表生成式
l3 = [i for i in range(1, 11)]
print(l3)

1.2、列表查找

因为列表中的每个元素都有一个索引index与之一一对应，所以根据元素找到对于的索引值。

如果列表有相同的元素，那么只返回相同元素的第一个元素的索引。

语法：列表.index('要获取索引的元素值'，起始位置，结束位置)

l1 = ['hello', 'world', 'python', 'hello', 'world', 'python']
print(l1.index('world'))          # 1
print(l1.index('world', 2, 5))  # 4

1.3、列表添加

方法

描述

ls.append(x)

在列表ls末尾添加一个元素x

ls.insert(i，x)

在列表ls的第i个位置添加元素x

ls.extend()

在列表ls的末尾添加若干个元素，1个或多个

ls1 = [10, 20, 30]
ls2 = ['hello', 'world']

ls1.append(100)
print(ls1)  # [10, 20, 30, 100]

ls1.extend(ls2)
print(ls1)  # [10, 20, 30, 100]

ls1.insert(4, 'python')
print(ls1)  # [10, 20, 30, 100, 'python', 'hello', 'world']

1.4、列表删除

方法

描述

ls.pop()

删除指定索引位置上的元素，默认是删除最后一个-1，0表示删除第一个元素

ls.remove(x)

删除列表中出现的第一个x元素

ls.clear()

清空列表

del ls

彻底删除列表

ls = [1, 2, 3, 2, 4, 5, 6, 7, 8, 9]
ls.remove(2)
print(ls)  # [1, 3, 2, 4, 5, 6, 7, 8, 9]

ls.pop(7) 
print(ls)  # [1, 3, 2, 4, 5, 6, 7, 9]
ls.pop()
print(ls)  # [1, 3, 2, 4, 5, 6, 7]
ls.pop(0)
print(ls)  # [3, 2, 4, 5, 6, 7]

ls.clear()
print(ls)   # []

del ls
# print(ls)   # 报错

1.5、列表修改

列表是可变的，列表修改不需要什么方法，直接修改对应索引上的值即可。

ls = [1, 2, 3, 4]
ls[2] = 100
print(ls)  # [1, 2, 100, 4]

1.6、列表排序

方法

描述

ls.sort()

默认升序，原地((即列表本身被修改 返回None))且稳定的排序(保持两个相等元素的顺序不变)，reverse属性可以降序排序

sorted(ls)

python内置函数，返回一个新列表，默认升序，reverse属性可以降序排序

ls = [1, 3, 4, 2]
ls.sort()
print(ls)   # [1, 2, 3, 4]
ls.sort(reverse=True)
print(ls)   # [4, 3, 2, 1]

ls1 = [1, 3, 4, 2]
ls2 = sorted(ls1)
print(ls2)  # [1, 2, 3, 4]
ls3 = sorted(ls1, reverse=True)
print(ls3)  # [4, 3, 2, 1]

二、字典: {}、dict()

映射类型：字典

2.0、字典的特点和操作总览

字典的特点

  1. 也是一个可变的序列，以键值对的方式存储数据；
  2. 键值一一对应，键key不可以重复，值value可以重复；
  3. 字典中的元素都是无序的；
  4. 字典会浪费很大的内存，是一种用空间换时间的数据结构，但是查询速度很快；

操作总览

操作

描述

{}、dict ()

创建字典

zip()

可创建字典，将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

d[key]、d.get(key，default)

根据键key获取字典d的值val，返回对应的值，不存在就返回默认值

d.keys()

返回字典d所有键的信息

d.values()

返回字典d所有值的信息

d.items()

返回字典d所有键值对，这个函数可以配合用来遍历字典

d[‘key’]=val

添加/修改新的键值对

del d[key]

删除字典d的某个键值对

val = d.pop(key, default)

删除字典d的某个键值对，并返回这个键对应的值，如果不存在的话返回默认值

key, val = d.popitem()

删除并返回出 最后一个元素的键和值

d.clear()

清空整个字典

len(d)

字典d的元素个数

max(d)

字典d的键的最大值

min(d)

字典d的键的最小值

2.1、字典创建

# 1、使用花括号{}创建
scores = {'章三': 29, '李四': 10, '王五': 40}
print(scores)   # {'章三': 29, '李四': 10, '王五': 40}
print(type(scores))  # <class 'dict'>

# 2、内置函数dict(键1=值1, 键2=值2)
people = dict(name='章三', age=20)
print(people)  # {'name': '章三', 'age': 20}

# 3、zip() 将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
keys = ['fruits', 'books', 'others']
vals = [96, 78, 85]
d1 = {key: val for key, val in zip(keys, vals)}
print(d1)  # {'fruits': 96, 'books': 78, 'others': 85}

d2 = dict(zip(keys, vals)) 
print(d2)  # {'fruits': 96, 'books': 78, 'others': 85}

2.2、字典查找

# 1、使用[]直接查找
scores = {'章三': 29, '李四': 10, '王五': 40}
print(scores['李四'])       # 10

# 2、使用get()方法查找   字典1.get(键1，值1)  在字典1中查找键1的值，如果不存在就返回值1
print(scores.get('李四'))   # 10
print(scores.get('章三'))   # 29
print(scores.get('麻子'))   # None
print(scores.get('麻子', 100))   # 100

# 3、获取所有的键和值
print(scores.keys())          # dict_keys(['章三', '李四', '王五'])
print(list(scores.keys()))    # ['章三', '李四', '王五']
print(scores.values())        # dict_values([29, 10, 40])
print(list(scores.values()))  # [29, 10, 40]
print(scores.items())  # dict_items([('章三', 29), ('李四', 10), ('王五', 40)])

2.3、字典添加

scores = {'章三': 29, '李四': 10, '王五': 40}
scores['陈六'] = 20
print(scores)  # {'章三': 29, '李四': 10, '王五': 40, '陈六': 20}

2.4、字典删除

# 1、删除某个键值对
scores = {'章三': 29, '李四': 10, '王五': 40, '老六': 99}
del scores['李四']
print(scores)  # {'章三': 29, '王五': 40, '老六': 99}

# 2、d.pop(key,default=val) pop掉键key和对应的值 并返回对应的值  如果不存在返回默认值
val = scores.pop('章三', 100)
print(val)  # 29
print(scores)   # {'王五': 40, '老六': 99}

# d.popitem() pop出最后一个元素的键和值
key, val = scores.popitem()
print(key, val)  # 老六 99
print(scores)    # {'王五': 40}

# 3、清除整个字典
scores.clear()
print(scores)  # {}

2.5、字典修改

scores = {'章三': 29, '李四': 10, '王五': 40}
scores['李四'] = 20
print(scores)  # {'章三': 29, '李四': 20, '王五': 40}

2.6、字典遍历

for item in scores:
    print(item, scores[item])

for key, value in scores.items():
    print(key, value)

三、元组：()、tuple()

3.0、元组的特点和操作总览

元组的特点

  1. 元组是一个不可变序列，元组有增加操作，但是没有删、改的操作；
  2. 相较于列表，元组的读取速度更快，占用内存空间更小，并且可以作为字典的key去使用；
  3. （4）和（4，）是不一样的，前者是int类型，后者才是元组类型；

元组操作总览

操作

描述

()、tuple()

创建元组

t[idx]

查找元组

3.1、元组创建

# 1、()创建 注意只包含一个元素的时候需要在最后加一个逗号
t1 = ('python', 'java')
print(t1)        # ('python', 'java')
print(type(t1))  # <class 'tuple'>

t2 = ('python')
print(t2)        # python
print(type(t2))  # <class 'str'>
t3 = ('python', )
print(t3)        # ('python',)
print(type(t3))  # <class 'tuple'>

# 2、内置函数tuple()创建
t4 = tuple(('python', 'java'))
print(t4)        # ('python', 'java')
print(type(t4))  # <class 'tuple'>

3.2、元组的查找和遍历

t = ('hello', 'world', 'python')
print(t[1])  # world

for item in t: 
    print(item, end=' ')  # hello world python

3.3、元组添加

t1 = (1, 2, 3, 4)
t1 += (5, )
print(t1)  # (1, 2, 3, 4, 5)

四、集合：{}、set()

4.0、集合的特点和操作总览

集合的特点

  1. 集合中的元素都是无序的，且元素都是不可重复的，所以{1，2，3} 和{3，2，1}是同一个集合；
  2. 集合是没用value的字典；
  3. 和列表、字典一样都是可变序列，但是集合是没法修改的，因为集合是无序的，无法根据index对集合进行修改，只能删除掉再重新添加；

操作总览

操作

描述

{}、set()

创建集合

s.add(x)

集合s添加一个元素x

s2.uptate(s1)

集合s2添加多个元素s1

s.remove(x)

集合s删除元素x，不存在就报错

s.discard(x)

集合s删除元素x，不存在也不会报错

s.pop()

集合s删除任意一个元素，因为集合是无序的

s.clear()

清空集合s

len(s)

集合s中的元素个数

4.1、集合创建

# 1、{}创建集合
s1 = {1, 2, 3, 4, 5, 6}
print(s1)  # {1, 2, 3, 4, 5, 6}

# 2、内置函数set()创建集合
s2 = set([1, 2, 3, 4, 5, 6])
print(s2)  # {1, 2, 3, 4, 5, 6}

s3 = set('python')
print(s3)  # {'h', 'n', 'o', 'y', 'p', 't'}

4.2、集合添加

# 1、s.add(x) 添加一个元素x 
s1 = {1, 2, 3, 4, 5, 6}
print(s1)  # {1, 2, 3, 4, 5, 6}
s1.add(7)
print(s1)  # {1, 2, 3, 4, 5, 6, 7}

# 2、s2.update(s1)  添加多个元素
s1.update((7, 8, 9))
print(s1)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

4.3、集合删除

# 1、s.remove(x) 一次删除一个元素x  不存在即报错 
s1 = {1, 2, 3, 4, 5, 6}
s1.remove(3)
print(s1)  # {1, 2, 4, 5, 6}
# s1.remove(7)  报错

# 2、s.discard(x) 一次删除一个元素x  不存在不会报错  不怎么用
s1.discard(4)
print(s1)  # {1, 2, 5, 6}
s1.discard(7)  # 不报错
print(s1)  # {1, 2, 5, 6}

# 3、s.pop()  一次删除任一个元素
s1.pop()
print(s1)

# 4、s.clear() 清空集合
s1.clear()
print(s1)  # set()

五、总结区别

项目

列表

集合

字典

元组(只读)

创建

[]、list()

{}、set()

{}、dict()

()、tuple

存储方式

值

键（不能重复）

键值对（键不可以重复）

值

是否有序

有序

无序

无序

有序

查找元素

value = ls[index]

无

value = d[key]

value = t[index]

添加元素

append、insert、extend

add、update

d[key] = value

t1 += t2

删除元素

pop、remove

remove、discard

del d[key]、d.pop(key,default=val) 、d.popitem()

无

修改元素

ls[index]=new_value

无

d[key]=new_value

无