python编程 列表、元组、字典、集合的基础使用

已于 2023-10-25 21:04:03 修改
阅读量434 收藏 5
点赞数
分类专栏： python编程 文章标签： python
于 2022-09-21 17:35:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56051805/article/details/126975502
版权

目录

一：列表list [索引]

二：列表list [切片] 

三：列表list [脚本操作符] 

四：元组tuple 写法

五：元组tuple 基本操作 

六：字典dict 基本操作

七：集合set 基本操作

一：列表list [索引]

1 获取 内容、数据结构类型、数据结构长度

name_list = ["张三", "李四", "王五"]
print(name_list, type(name_list), len(name_list))

输出结果如下： 内容、数据类型为list列表、长度为3

['张三', '李四', '王五'] <class 'list'> 3   

2 访问元素

2.1 下标访问法   name_list[0]

name_list = ["张三", "李四", "王五"]
# 访问元素方法一：下标访问法
print(name_list[0])

输出结果：

张三

2.2 遍历访问元素 [元素访问法]

name_list = ["张三", "李四", "王五"]
# 遍历list列表 访问元素[元素访问法]
for item in name_list:
    print(item)

输出结果：

张三
李四
王五

2.3 遍历 获取元素索引及其对应内容[下标访问法]

name_list = ["张三", "李四", "王五"]
# 下标访问法
for i in range(len(name_list)):
    print("index = ", i, "item = ", name_list[i])

输出结果：

index =  0 item =  张三
index =  1 item =  李四
index =  2 item =  王五

3.1 添加元素[尾部添加元素] append

name_list = ["张三", "李四", "王五"]

# 添加元素 append列表尾部添加元素
name_list.append("赵六")
print(name_list)

输出结果：

['张三', '李四', '王五', '赵六']

3.2 添加元素[指定位置插入元素]

name_list = ["张三", "李四", "王五"]

# 指定位置插入元素 列表索引0处插入一个元素
name_list.insert(0, "涵")
print(name_list)

输出结果：

['涵', '张三', '李四', '王五']

4.1 删除元素 下标删除法

name_list = ["张三", "李四", "王五"]

# 删除元素 下标删除法  删除列表索引为2的元素
name_list.pop(2)
print(name_list)

输出结果：

['张三', '李四']

4.2 删除元素 内容指定删除法

name_list = ["张三", "李四", "王五"]

# 删除元素 内容指定   删除列表内容为李四的元素
name_list.remove("李四")
print(name_list)

输出结果：

['张三', '王五']

4.3 删除元素 del索引删除法

name_list = ["张三", "李四", "王五"]

# 删除元素 del   del删除列表索引为1的元素
del name_list[1]
print(name_list)

输出结果：

['张三', '王五']

5 列表索引修改元素内容

name_list = ["张三", "李四", "王五"]

# 修改 list[index] = val
name_list[0] = "涵"  # 将列表索引为0处的元素内容进行修改
print(name_list)

输出结果：

['涵', '李四', '王五']

6 列表查询元素是否在其中

name_list = ["张三", "李四", "王五"]

# 查询元素  成员运算符in的使用
print("张三" in name_list)  # 张三是否在列表中

输出结果：

True

7 清空整个列表元素 clear

name_list = ["张三", "李四", "王五"]

# 清空列表全部元素 clear
name_list.clear()
print(name_list)

输出结果：

[]

8 列表内容对应索引的查看 

name_list = ["张三", "李四", "王五"]

# 列表元素对应索引的查看
print(name_list.index("王五"))  # 王五在列表中的索引

输出结果：

2

9.1 元素拷贝   copy开辟新内容空间

name_list = ["张三", "李四", "王五"]

# 元素拷贝
name_list2 = name_list.copy()
# copy：name_list2开辟新的内存空间
print(name_list2 is name_list)
# 修改name_list2索引0处的内容
name_list2[0] = 'han'
# 查看name_list2和name_list，证实copy开辟新内存空间
print(name_list2, name_list)

输出结果：

False
['han', '李四', '王五'] ['张三', '李四', '王五']

9.2 元素拷贝    赋值拷贝，不开新的内存空间 

name_list = ["张三", "李四", "王五"]

# 元素拷贝 赋值拷贝 没有开辟新内存空间
name_list3 = name_list
print(name_list3 is name_list)
# 将name_list3索引0处内容修改
name_list3[0] = 'han'
# 证实了赋值拷贝不开新的内存空间
print(name_list3, name_list)

输出结果：

True
['han', '李四', '王五'] ['han', '李四', '王五']

通过以上内容，已经对 索引有了大致的理解，下面学习切片

二：列表list [切片] 

快速列表获取元素前三个的内容

在没有使用切片情况下，只能遍历获取

name_list = ["张三", "李四", "王五", "赵六"]

# 定义 列表
list1 = []
# 遍历获取前三个元素
for i in range(3):
    list1.append(name_list[i])
print(list1)

输出结果：

['张三', '李四', '王五']

1 使用切片，可直接获取列表中的前三个元素内容

name_list = ["张三", "李四", "王五", "赵六"]

# 切片 可以快速得到列表的前三个元素
list1 = name_list[0:3]  # [0,3)
print(list1)

输出结果：

['张三', '李四', '王五']

2 切片获取列表中的全部/单数/双数的元素

示例如下

name_list = ["张三", "李四", "王五", "赵六", "涵"]

# 切片 获取列表全部元素
list1 = name_list[0:len(name_list)]
print(list1)
# 切片 获取列表中的单数元素
list1 = name_list[0:len(name_list):2]  # [0,3)
print(list1)
# 切片 获取列表中的双数元素
list1 = name_list[1:len(name_list):2]  # [0,3)
print(list1)

输出结果：

['张三', '李四', '王五', '赵六', '涵']
['张三', '王五', '涵']
['李四', '赵六']

3 start stop step   

   开始：结束：步幅   

   以及三者的默认值

name_list = ["张三", "李四", "王五", "赵六", "涵"]

# 切片 获取列表全部元素
# [start:stop:step]  开始:结束:步幅
# start开始 默认是0
# stop结束 默认是len(List)
# step步幅 默认是1
list1 = name_list[::]
print(list1)

# 切片 修改默认值 可以获取列表单数元素
list1 = name_list[::2]
print(list1)
# 切片 修改默认值 可以获取列表双数元素
list1 = name_list[1::2]
print(list1)

输出结果：

['张三', '李四', '王五', '赵六', '涵']
['张三', '王五', '涵']
['李四', '赵六']

注意：step有 正负之分，表示输出顺序

如下示例，可以倒序输出列表的全部元素

name_list = ["张三", "李四", "王五", "赵六", "涵"]

# [start:stop:step]  开始:结束:步幅
# start 默认是0
# stop 默认是len(List)
# step 默认是1 可以正负 表示顺序 正从0开始 负从-1开始
list1 = name_list[::-1]  # 倒序输出全部元素
print(list1)

输出结果：

['涵', '赵六', '王五', '李四', '张三']

三：列表list [脚本操作符] 

加 +操作符

示例如下

# 列表定义 名字
name_list = ["张三", "李四", "王五", "赵六", "涵"]
# 列表定义 密码
pwd_list = ["xxx", "yyyyy"]
# + 操作符的使用
res = name_list + pwd_list
# 输出结果
print(res)

输出结果：

['张三', '李四', '王五', '赵六', '涵', 'xxx', 'yyyyy']

乘 *操作符  (类似于 复制)

示例如下

# 列表定义 名字
name_list = ["张三", "李四", "王五", "赵六", "涵"]
# *操作符的使用
hi_list = ['hi'] * 4
# 输出结果
print(hi_list)

输出结果：

['hi', 'hi', 'hi', 'hi']

四：元组tuple 写法

列表是可变有序序列，元组是不可变的序列 、

列表 [ ]  元组( )

int 和 元组

示例 元组写法一 

# int 数据类型
t1 = 10
print(t1, type(t1))

# 元组 不可变序列，这边不使用()直接,也是元组
t2 = 10,
print(t2, type(t2))

输出结果：

10 <class 'int'>
(10,) <class 'tuple'> 

示例 元组写法二 

# int 数据类型
t1 = 10
print(t1, type(t1))

# 元组 不可变序列，这边使用() 一眼看出是元组
t2 = (10,)
print(t2, type(t2))

输出结果：

10 <class 'int'>
(10,) <class 'tuple'> 

RGB 常用 元组表示 

# tuple 元组 不可变序列
rgb = (255, 255, 255)
# 输出结果为 元组数据类型
print(rgb, type(rgb))

输出结果：

(255, 255, 255) <class 'tuple'>

五：元组tuple 基本操作 

1 访问元素 下标访问法

# 元组 定义
rgb = (255, 100, 0)

# 访问元素 下标访问法
print(rgb[0])

输出结果：

255

2 修改元素  编辑器给出报错 [元组是不可变序列]

# 元组 定义
rgb = (255, 100, 0)

# 修改元素
rgb[0] = 0

说明了元组是不可变的序列

3 删除元素 编辑器给出报错 [元组是不可变序列]

# 元组 定义
rgb = (255, 100, 0)

# 删除元素
del rgb[0]

元组是不可变的序列 

4 查询元组中的元素是否存在

# 元组 定义
rgb = (255, 100, 0)

# 查询元素 in成员运算符的使用
print(100 in rgb)  # 元素100是否在元组中

输出结果：

True

5.1 迭代 输出元组的全部元素

# 元组 定义
rgb = (255, 100, 0)

# 迭代 输出元组全部元素
for item in rgb:
    print(item)

输出结果：

255
100
0

5.2 元组全部元素求和 直接使用sum

# 元组 定义
rgb = (255, 100, 0)

# 迭代 输出元组全部元素
# for item in rgb:
#     print(item)
# 输出结果：全部元素求和
print(sum(rgb))

输出结果：

355

6 元组 脚本操作符

+操作符使用示例(运行元组相加 ，新生成tuple)

# 元组 定义
rgb = (255, 100, 0)
black = 0, 0, 0
# +操作符的使用
print(rgb + black)

输出结果：

(255, 100, 0, 0, 0, 0)

7 元组的实际应用

如 开启并使用摄像头

[在if下添加break，可以查看摄像头获取的形式]

import cv2


# 查看摄像头形式
def test1():
    cap = cv2.VideoCapture(0)
    while 1:
        t1 = cap.read()             # 元组读取数据
        print(t1, type(t1))
        if t1[0]:
            cv2.imshow("img", t1[1])  # 显示窗口
            key = cv2.waitKey(20)    # 延时处理
            if key == 27:            # ESC退出
                break
        break                        # if后加break 仅查看摄像形式
    cv2.destroyAllWindows()  # 关闭所有窗口


test1()

输出结果： 

(True, array([[[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       ...,

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        ...,
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]], dtype=uint8)) <class 'tuple'>

六：字典dict 基本操作

字典 key value，键必须是唯一的，但值不一定

字典是无序可变的序列

列表[ ]  元组( ) 字典  { }

字典的定义

1.1 访问字典全部的元素 

# 字典 定义  key value键值对
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}
# 访问字典全部数据
print(stu, type(stu))

输出结果：

{'name': 'lily', 'age': 20, 'sex': 'female', 'account': 'OMO2203', 'pwd': '123456'} <class 'dict'>

1.2 访问字典中的某个元素数据，通过键获取值 

# 字典 定义  key value键值对
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}
# 访问数据 通过键，获取值
print(stu['name'])

输出结果：

lily

1.3 字典遍历 通过键，获取值 

# 字典 定义  key value键值对
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}
for key in stu.keys():
    print(key, type(key), stu[key])

输出结果：key键的数据类型是字符串

name <class 'str'> lily
age <class 'str'> 20
sex <class 'str'> female
account <class 'str'> OMO2203
pwd <class 'str'> 123456

1.4 字典遍历 通过值，获取值 

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}
for val in stu.values():
    print(val, type(val))

输出结果： 值的数据类型有str，有int

lily <class 'str'>
20 <class 'int'>
female <class 'str'>
OMO2203 <class 'str'>
123456 <class 'str'>

1.5 遍历字典每一个键&值  (key value以tuple元组形式输出)

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}
# 遍历 字段每一个键&值
for item in stu.items():
    print(item)

输出结果：(key value以tuple元组形式输出)

('name', 'lily')
('age', 20)
('sex', 'female')
('account', 'OMO2203')
('pwd', '123456')

2 字典添加key键   (通过键添加)

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}

# 添加key
stu['address'] = "福州"
print(stu)

输出结果：

{'name': 'lily', 'age': 20, 'sex': 'female', 'account': 'OMO2203', 'pwd': '123456', 'address': '福州'}

3.1 字典访问key键(不确定是否有该键)(使用[]访问)

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}

# 字典访问的key键不存在 会报错
print(stu['han'])

输出结果 报错：

Traceback (most recent call last):
  File "D:/python_pro_omo220315/class_demo/class1/demo_tuple.py", line 11, in <module>
    print(stu['han'])
KeyError: 'han'

3.2 字典访问key键(不确定是否有该键)

python脚本 程序若出错，会在出错的那一行终止程序，不运行后面的代码

使用get访问

键不存在，python脚本不会报错，但也不会添加

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}

# 字典访问的key不存在 -- 不确定 -- 返回值
print(stu.get('han',0))
# 不报错 但也不会添加
print(stu)

输出结果：

0
{'name': 'lily', 'age': 20, 'sex': 'female', 'account': 'OMO2203', 'pwd': '123456'}

4.1 字典pop删除元素 通过键删除

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}

# 删除 通过键删除
stu.pop('name')
print(stu)

输出结果：

{'age': 20, 'sex': 'female', 'account': 'OMO2203', 'pwd': '123456'}

4.2 字典del删除 通过键删除

# 字典 定义
stu = {
    'name': 'lily',
    'age': 20,
    'sex': 'female',
    'account': "OMO2203",
    'pwd': "123456"
}

# 删除 通过键删除
del stu['sex']
print(stu)

输出结果：

{'name': 'lily', 'age': 20, 'account': 'OMO2203', 'pwd': '123456'}

七：集合set 基本操作

集合是无序可变的序列 ，元素不可重复，集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据

列表[ ] 、元组( )、字典{ }、集合也和字典一样使用大括号界定(不同点：没有键值对)

1 集合的定义

# 集合set 定义 元素唯一
set1 = {1, 2, 3, 4, 5}
print(set1, type(set1), len(set1))

 输出结果：

{1, 2, 3, 4, 5} <class 'set'> 5

2 集合元素的添加 add

# 集合定义 元素唯一
set1 = {1, 2, 3, 4, 5}

# 集合元素的添加 add
set1.add(10)
print(set1)

输出结果：

{1, 2, 3, 4, 5, 10}

3 集合元素的删除 remove

# 集合定义 元素唯一
set1 = {1, 2, 3, 4, 5}

# 集合元素的删除 remove
set1.remove(5)
print(set1)

输出结果：

{1, 2, 3, 4}

4 集合 元素唯一性

# 集合定义 元素唯一
set1 = {1, 2, 3, 4, 5}

# 元素添加 连续添加一样的元素
set1.add(1)
set1.add(1)
set1.add(1)
set1.add(1)
set1.add(1)
# 结果 元素唯一性
print(set1)

输出结果：无论添加多少次1，集合都是一个1，元素唯一性

{1, 2, 3, 4, 5}

5 强制类型转换

# 集合定义 元素唯一
set1 = {1, 2, 3, 4, 5}

a = range(10)  # 区间
print(a, type(a))  # 区间数据类型range
# 强制转换：区间数据类型 转换为 list数据类型
num_list = list(a)
print(num_list,type(num_list))

输出结果： range数据类型可以强制转换为list数据类型

range(0, 10) <class 'range'>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

# 集合定义 元素唯一
set1 = {1, 2, 3, 4, 5}

a = range(10)  # 区间
print(a, type(a))  # 区间数据类型range
# 强制转换：区间数据类型 转换为 tuple数据类型
num_tuple = tuple(a)
print(num_tuple, type(num_tuple))

输出结果： range数据类型可以强制转换为tuple数据类型

range(0, 10) <class 'range'>
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) <class 'tuple'> 

chenruhan_QAQ_
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python_04_数据结构（列表，元祖，字典）
lin_made的博客
07-19 789
我们引入一个新的概念：数据结构 数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字或字符，甚至可以是其他数据结构&amp;amp;amp;amp;amp;amp;gt;，在python中，最基本的数据结构是序列，序列中的每个元素匾被分配一个序号–即元素的位置，也称为索引，第一&amp;amp;amp;amp;amp;amp;gt;个索引是0，第二个则是1，以此类推 1.列表 列表是什么 列表由一系列特定顺序排列的元素组成，你可以创建包含字母表中所有字
python列表字典
xinhao233的博客
12-30 516
列表的引入：数组只能存储同一种数据类型 元组和列表区别:元组不可变数据类型，不可修改，而列表可变数据类型，可修改 列表的定义:l=[1,2,[3,6,9]] 索引：l[1] ,l[-1], l[-1][2] 切片：l[:1], l[::-1] 重复： l*2 连接：l+l2 成员操作符： in 增： (1)末尾追加:l.append(5)， (2)迭代增加：l.extend(‘
Python列表,元组,集合,字典详解一篇搞懂
最新发布
暗武逢天的博客
05-25 1832
需要顺序访问和修改数据时考虑列表；需要去除重复元素或执行集合运算时选择集合；需要键值对映射时使用字典；而当数据集合不应被修改时，元组是理想选择。每种数据结构都有其独特的性能特点和适用场景，合理选择能够提高程序的效率和可读性。
python的列表和字典
x19979797的博客
01-08 274
列表list(打了激素的数组)          tuple元组：不可变数据类型 数组：只能存储同一种数据类型的数据 列表：li （可变数据类型，可修改元素）     改：利用索引  li[0] = XX , 最后一个元素 li[-1] = XX         li[-1][2] = XX (嵌套：最后一个元素为列表，更改列表中元素)     逆序显示：li[::-1]     l
python列表和字典
eric3012的博客
08-27 291
计算机利用数据的三种方式： 1.直接使用数据 print()模式 2.计算和加工数据 str(), int(), float(),四则运算 3.用数据做判断 if…else… 列表 增加 append 删除 del函数 语法： del 列表名[元素的下标] 实际例子： 什么是列表 案例： list = [‘lilei’,’hanmeimei’,’1.8’,’5’] 从列表提取单个元素 案例： transformers = ['秦天柱’,'大黄蜂’,’救护车’] transformers[1]
python列表与字典_Python的列表List与字典
weixin_36348080的博客
02-03 695
Python的List<列表类似于C/C++中的数组，不同的是数组保存的同一种类型，而列表可以保存不同类型。列表的增删改查：name = ['ha', 'hi', 'he']name.append('hh')将'hh'加入到列表的末尾。name.insert(下标位置，添加内容)names.extend(name)将name元组中的内容追加到names元组中。extend是追加，append...
01-Python—列表、元祖、字典、集合总结
qq_63049065的博客
12-11 870
1，列表 列表是python数据处理中最灵活的一种 列表由[],（和索引的符合相同）或者list来创建 可以自行修改，删除，可以重复， 注意：extend表示把拆分到最后，而append是中规中矩的来 列表——改 li[索引][切片]= ‘被修改的内容’ 列表可进行for 循环！！ 2 ，元祖 元祖是祖宗，固定，无法修改，函数只有索引 元祖由tuple=（）创建 3 ，字典 字典是一种映射关系，通过键值对来实现，用{}来表示（集合也是用{}来表示），d={}生成空字...
(Python)Python—常用的几种列表、字典
weixin_45905741的博客
04-27 3205
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。list的检索原理是：假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。len() 函数可以获得list元素的个数；append() 可以往list中追加元素到末尾；pop(i) 可以删除指定位置的元素；insert() 可以把元素插入到指定的位置；
python--字典和列表
FunnyPrince_的博客
10-29 1903
study
Python之字典、元组、集合
weixin_51209513的博客
09-06 157
Python学习记录6
python代码学习——列表、字典及元组、ipython
叶子的博客
01-28 1528
列表，元祖和字典
python列表和字典使用（详细）
Fran_klin__的博客
06-06 2055
python字典和列表的使用方法
python中列表和字典的常用知识点
明而决之
07-10 3062
python中列表和字典的常用知识点，含列表和字典的增删改查操作方法。
Python知识点深度解析：列表（List）、元组（Tuple）、字典（Dictionary）与集合（Set）
qq_54037316的博客
06-02 466
在Python编程语言中，数据结构是我们存储、操作和组织数据的基本工具。无论我们在做什么类型的项目，我们都需要处理数据，而Python提供了几种非常有用的内置数据结构，可以帮助我们在项目中进行有效的数据管理。本文将深入探讨Python中的四种主要数据结构：列表（List）、元组（Tuple）、字典（Dictionary）与集合（Set）。
python中列表、元组、集合、字典的用法总结
qq_44815135的博客
01-30 3241
本文介绍了python种列表、元组、集合、字典的语法以及常用方法
python 第十二周 元组、列表、字典、序列
colin3516的博客
05-18 1376
4.2 列表列表与元组相似，也是由一组元素组成，列表可以实现添加、删除和查找操作，元素的值可以被修改。 4.2.1 列表的创建List_name = [元素1，元素2，…] ,列表用“[ ]”包含元素。 添加元素调用：函数append(object)，每次添加的新元素将排在列表的尾部。 删除元素调用：函数remove(value),不在列表中的元素，将抛出ValueError异常。
【python学习】列表、元组、字典、集合（详解）
2401_84009215的博客
04-09 903
不前！**
python 关于元组的一些写法
foxirensheng的博客
09-05 299
python元组运用
python元组的方法_Python元组及其方法
weixin_39622399的博客
12-06 80
"""tuple；其实质是一个有序集合。特点：1、与列表相似2、一旦初始化则不能改变3、使用小括号()"""# 创建一个空元组;tuple1 = ()print(tuple1)# 元组中的元素可以为不同类型：tuple2 = (1, 2, 3, "Hellow", 'W')print(tuple2)# 定义一个只有一个元素的元组： 一个元素的后面必须有一个逗号,要不就成为整型。tuple3 = (...
python列表元组字典集合
09-06
在Python编程语言中，有四种常用的集合数据类型，它们分别是列表(List)、元组(Tuple)、字典(Dictionary)和集合(Set)。列表是一种有序和可更改的集合，允许重复的成员。元组是一种有序且不可更改的集合，也允许重复的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chenruhan_QAQ_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值