python源码中的学习笔记_第6章_元组

最新推荐文章于 2022-07-11 07:39:00 发布
最新推荐文章于 2022-07-11 07:39:00 发布
阅读量490 收藏 1
点赞数
分类专栏： python学习 文章标签： python pycharm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_love_you_me/article/details/120595329
版权

元组基础

#
# 主题：元组基础
#

if __name__ == '__main__':
    # 元组是不可变序列，没有增删改操作
    # 修改不可变序列后，会生成新的对象，储存在新的位置
    # 可变序列：列表、字典
    # 不可变序列：字符串、元组

创建元组

#
# 主题：创建元组
#

if __name__ == '__main__':
    # 使用 ()
    t = ('python', 'world', 98)
    print(t)                    # ('python', 'world', 98)
    print(type(t))              # <class 'tuple'>

    t = 'python', 'world', 100
    print(t)                    # ('python', 'world', 100)
    print(type(t))              # <class 'tuple'>

    # 使用 tuple 函数
    t1 = tuple(('python', 'world', 99))
    print(t1)                   # ('python', 'world', 99)
    print(type(t1))             # <class 'tuple'>

    # 元组中只含有一个元素时，要加上逗号
    t2 = (10, )
    print(t2)                   # (10,)
    print(type(t2))             # <class 'tuple'>

    # 创建空元组
    t = ()
    print(t)                    # ()
    t = tuple()
    print(t)                    # ()

元组设计成不可变序列的原因

#
# 主题：元组设计成不可变序列的原因
#

if __name__ == '__main__':
    # 可以规避因修改数据而导致的错误

    # 在其他语言中，多个程序访问同一个对象时，需要锁的概念
    # 元组在多任务环境下，同时操作对象时不需要加锁。因为元组的元素都是只读的而不能修改的

    # 元组中对象是不可变对象，则不能再引用其他对象
    # 元组中对象是可变对象，则可变对象的引用不允许改变，但数据可变

在这里插入图片描述

#
# 主题：元组设计成不可变序列的原因
#

if __name__ == '__main__':
    # 元组中对象是不可变对象，则不能再引用其他对象

    t = (10, [20, 30], 9)
    print(t)                # (10, [20, 30], 9)
    print(type(t))          # <class 'tuple'>
    for i in range(0,3):
        print(t[i], type(t[i]), id(t[i]))   # t[0] = 10, t[1] = [20, 30], t3 = 9
                                            # type(t[0]) = int, type(t[1]) = list, type(t[2]) = int
                                            # t 中三个对象的地址不相同

    # 元组中对象是可变对象，则可变对象的引用不允许改变，但数据可变
    
    # t[1] = 100            # 报错，因为元组不允许修改元素
    print(id(t[1]))         # 2317358293576
    t[1].append(100)        # 向 t[1] 的末尾添加元素
    print(t)                # (10, [20, 30, 100], 9)
                            # t[1] 是可变序列，允许增删改
    print(id(t[1]))         # 2317358293576
                            # 添加前后，t[1] 的地址未发生改变

遍历元组

#
# 主题：遍历元组
#

if __name__ == '__main__':
    t = ('python', 'world', 99)
    for item in t:
        print(item)

集合基础

在这里插入图片描述

#
# 主题：集合
#

if __name__ == '__main__':
    # 可变序列：列表、字典、集合
    # 集合的存储地址与存储先后顺序无关，故集合中的元素出现顺序和储存的先后顺序无关（说明集合中的元素无序）

创建集合

#
# 主题：创建集合
#

if __name__ == '__main__':
    # 使用 {}
    s = {2, 3, 4, 5, 6, 7, 7}
    print(s)                # {2, 3, 4, 5, 6, 7}
                            # 集合中的元素不能重复

    # 使用 set 函数
    s = set(range(6))
    print(s)                # {0, 1, 2, 3, 4, 5}
    print(type(s))          # <class 'set'>

    s = set([1, 2, 3, 4, 5])# 将数列转换为集合
    print(s)                # {1, 2, 3, 4, 5}
    print(type(s))          # <class 'set'>

    s = set((1, 2, 3, 4))   # 将元组转换为集合
    print(s)                # {1, 2, 3, 4}
    print(type(s))          # <class 'set'>

    s = set('python')       # 将字符串转换为集合
    print(s)                # {'h', 't', 'o', 'p', 'n', 'y'}
                            # 说明集合中的元素无序
    print(type(s))          # <class 'set'>

    s = set({1, 2, 3, 4})   # 将集合转换为集合
    print(s)                # {1, 2, 3, 4}
    print(type(s))          # <class 'set'>

    # 创建空集合
    s = {}
    print(type(s))          # <class 'dict'>
    s = set()
    print(type(s))          # <class 'set'>

判断集合元素

#
# 主题：判断集合元素
#

if __name__ == '__main__':
    s = {1, 2, 3, 4, 5}
    print(10 in s)                  # False
    print(10 not in s)              # True

添加集合元素

#
# 主题：添加集合元素
#

if __name__ == '__main__':
    s = {1, 2, 3, 4, 5}

    # add 方法添加一个集合元素
    s.add(6)
    print(s)                # {1, 2, 3, 4, 5, 6}

    # update 方法添加多个集合元素
    s.update({10, 20, 30})
    s.update([40, 50])
    s.update((60, 70))
    print(s)                # {1, 2, 3, 4, 5, 6, 70, 40, 10, 50, 20, 60, 30}

集合的删除操作

#
# 主题：集合的删除操作
#

if __name__ == '__main__':
    s = {1, 2, 3, 4, 5, 6, 7, 8}

    s.remove(8)                 # 若要删除的元素不在原集合中，则报错 KeyError
    print(s)                    # {1, 2, 3, 4, 5, 6, 7}

    s.discard(6)                # 若要删除的元素不在原集合中，则不报错
    print(s)                    # {1, 2, 3, 4, 5, 7}

    s.pop()                     # 删除任意元素
                                # 小括号内不能指定要删除的元素
    print(s)                    # {2, 3, 4, 5, 7}

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

集合间的关系

#
# 主题：集合间的关系
#

if __name__ == '__main__':
    # 判断两个集合是否相等
    s1 = {10, 20, 30, 40}
    s2 = {40, 30, 20, 10}
    print(s1 == s2)             # True
    print(s1 != s2)             # False
                                # 元素相同，则集合相等

    # 判断一个集合是否是另一个集合的子集
    s1 = {10, 20, 30, 40, 50, 60}
    s2 = {40, 30, 20, 10}
    s3 = {1, 2, 10}
    print(s2.issubset(s1))      # True  s2 是 s1 的子集
    print(s3.issubset(s1))      # False s3 不是 s1 的子集

    #  判断一个集合是否是另一个集合的超集
    s1 = {10, 20, 30, 40, 50, 60}
    s2 = {40, 30, 20, 10}
    s3 = {1, 2, 10}
    print(s1.issuperset(s2))    # True
    print(s1.issuperset(s3))    # False

    # 判断两个集合是否没有交集
    s1 = {10, 20, 30, 40, 50, 60}
    s2 = {40, 30, 20, 10}
    s3 = {1, 2, 10}
    print(s1.isdisjoint(s3))    # False s1 与 s3 有交集
    print(s2.isdisjoint(s3))    # False s2 与 s3 有交集

集合的数学操作

#
# 主题：集合的数学操作
#

if __name__ == '__main__':
    s1 = {10, 20, 30, 40}
    s2 = {20, 30, 40, 50, 60}

    # 交集
    print(s1.intersection(s2))          # {40, 20, 30}
    print(s1 & s2)                      # {40, 20, 30}

    # 并集
    print(s1.union(s2))                 # {40, 10, 50, 20, 60, 30}
    print(s1 | s2)                      # {40, 10, 50, 20, 60, 30}

    # 差集
    print(s1.difference(s2))            # {10}
    print(s1 - s2)                      # {10}

    # 对称差集
    print(s1.symmetric_difference(s2))  # {50, 10, 60}
    print(s1 ^ s2)                      # {50, 10, 60}

总结

在这里插入图片描述

CodeQingqing
关注
专栏目录
python数据结构之元组
yuyue0916的博客
08-12 1771
和列表一样，元组也是一种序列，不同的是，元组不可以被修改（字符串也是如此）。因此，元组属于不可变序列。 创建元组的方法同样很简单： 1、利用tuple函数： >>> t1=tuple('python') >>> t1 ('p', 'y', 't', 'h', 'o', 'n') 2、直接赋值，元素间用逗号隔开： >>> t2=1,2,3 >>> t2 (1, 2, 3) >
Python 数据结构之元组
大田的博客
06-03 2684
大家好啊，我是大田。 1、元组的定义下面 5 种形式都为定义元组的方式t = tuple('python') t1 = ('p', 'y', 't', 'h', 'o', 'n') t2 = ('my', 'name', 'is', 'datian') t3 = 'my', 'age', 'is', 20 t4 = ('solo' ,)# 输出元组中索引为 2 的元素，即第三位 print(t1[2]) # 从大元组中取出两个小元组，相当于java中的数组print(t1[:2]) 元组特点：不
python 元组
fly
11-29 693
''' 元组的创建 第一方式 ''' a = (1,2,3) print(a,type(a)) t2 = 1,2,3 print(t2,type(t2)) # 如果元祖中只有一个元素 ,不能省略 t4 = ('哈哈哈',) print(t4,type(t4)) '''第二种 内置函数 tuple()''' t1 = tuple(('p','y','t')) print(t1,type(t1)) (1, 2, 3) <class 'tuple'> (1, 2, 3) <class.
Python学习笔记：元组
大田的博客
06-28 724
元组
Python——元组
时光·漫步的博客
08-05 734
在 Python 中，元组由内置的 tuple 类型定义。 Python 的元组与列表类似，不同之处在于元组的元素不能修改。 一. 创建元组 元组使用小括号，列表使用方括号。 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。 如果你使用逗号分隔了一些值，就会自动创建元组。 创建包含一个值的元组，必须在括号中的元素家一个逗号。 &gt;&gt;&gt; 1,2,3 (1, ...
Python课堂笔记_python_源码
10-02
在Python课堂笔记中，你可能会遇到以下几个关键知识点： 1. **基础语法**：包括变量声明、数据类型（如整型、浮点型、字符串、布尔型、列表、元组、字典和集合）、输入/输出操作（print和input函数）、流程控制（if...
python核心笔记_python核心笔记_源码.zip
10-18
这份"Python核心笔记"的源码提供了深入学习Python基础知识的机会。在深入探讨这些知识点之前，我们先了解一下Python的基本概念。 1. **变量与数据类型**：Python中的数据类型包括整型（int）、浮点型（float）、...
python从入门到精通笔记_python教程_python_
09-29
6. **列表、元组、字典与集合**：这些是Python的数据结构，用于存储和操作数据。你将学习它们的创建、访问和修改方法，以及它们各自的特性。 7. **字符串操作**：Python对字符串的支持非常强大，包括格式化输出、...
python基础知识点_python学习_源码
10-02
"课程笔记"中的内容可能包含了这些基础知识点的详细解释和实例，是深入学习Python的好资源。记得实践是检验理论的最好方式，多动手编写代码，结合实际问题应用所学知识，这样才能更好地掌握Python编程。
简明Python教程学习笔记_6_面向对象编程
墨鱼菜鸡
07-11 311
面向对象编程：https://www.liaoxuefeng.com/wiki/897692888725344/923030496738368面向对象高级编程：https://www.liaoxuefeng.com/wiki/897692888725344/923030538012640 1、类、对象 类和对象是面向对象编程的两个主要方面。...
Python入门：列表和元组
weixin_42075898的博客
08-24 514
1.1 序列概览 Python包含6中内建序列，分别为列表、元组、字符串、Unicode字符串、buffer对象、xrange对象 1.2 通用序列操作 1.2.1 索引 序列中的所有元素都是有编号的，从0开始递增。这些元素可以通过编号分别访问 >>> greeting = 'Hello' >>> greeting[0] 'H' 使用负数索引时，Py...
Python数据结构：元组（tuple）
shield911的博客
04-10 1053
元组的定义、创建及基本操作函数。
Python3元组
weixin_43265596的博客
08-02 490
一、元组 1. 通用的元组操作 1.1 元组的创建 1.2 元组的索引 ​ ​1.3 元组的切片 1.4 元组的连接和复制 2. 元组的函数 2.1 len（） 2.2 max（）/min（） 2.3 tuple（） 2.4 sorted() 3. 元组的方法 3.1 count()方法 3.2 index()方法 一、元组 元组是一种静态的或者说不可变的数据结构，里...
python之元组的基础使用方法
weixin_42893756的博客
04-16 312
“”" 元组的基本方法使用 “”" 与列表区别：元素不可被 增加 修改 删除 元组可通过索引下标和切片操作来获取内部元素，返回元组类型 支持for循环，也可看为可迭代对象 元组有序 可通过转换数据类型来修改元组数据 元组，字符串，列表之间可相互转换 s = 'iusepython' l = [1,2,3,'hello','world'] t = (123,123,'life','short')...
Python基础学习 -- 列表与元组
weixin_30875157的博客
08-03 195
返回到Python知识体系 本节学习目的: 掌握数据结构中的列表和元组 应用场景: 编程 = 算法 + 数据结构 数据结构: 通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些元素可以是数字或者字符,或者其他数据结构. 容器: 序列,映射,集合是三种比较常见的数据结构 序列: 每个元素都...
Python（9）——元组
weixin_46146755的博客
04-27 364
元组特性 常用方法
元组的知识点
weixin_30813225的博客
09-18 143
什么是元组: 元组就是一个不可变的列表 ======================================基本使用====================================== 1、用途: 用于存放多个值,当存放的多个值只有读的需求没有改的需求时用元组最合适 2、定义方式:在()内用逗号分隔开多个任意类型的值 t=(1,3.1,'aaa',(1,2,3),['a',...
python元组
ljm_99的博客
07-18 254
t=('o','q') print(t) 一个元组可以存储多个数据，元组内的数据是不能修改的。 对应上一章的列表 列表可以一次性存储多个数据，但是列表中的数据允许更改。
Python时间戳与struct_time元组详解及转换方法
本文将深入探讨Python中的time模块，特别是时间戳的使用和转换，以及struct_time元组在时间表示中的角色。 **时间戳在Python中的应用** Python的time模块提供了一个基础函数time.time()，用于获取当前时间的Unix...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值