时间戳

首页 > 技术文章 > 元组集合

元组集合

jiayibingi 2021-10-20 22:49 原文

元组

元组的创建

元组和列表相似，不同之处在于元组的元素不可修改。元组使用小括号()，元组的组建很简单，只要在括号中添加元素，然后用逗号隔开就可以了。

t1=(1,2,3)
t2=('a','b',2)
t3='a',1
print(type(t3))
# <class 'tuple'>

有括号也行，没括号也行，类型混杂也行

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

t=(50)
t1=(50,)
print(type(t))
print(type(t1))
# <class 'int'>
# <class 'tuple'>

元组与字符串类似，下表的索引从0开始，可以进行截取，组合等。

元组的基本操作
一、访问元组
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
# tup1[0]:  Google
# tup2[1:5]:  (2, 3, 4, 5)
二、修改元素

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

t1=(1,12,45)
t2=('abc','sda')
# t1[0]=100
# 错误
t3 = t1 + t2
print (t3)
# (1, 12, 45, 'abc', 'sda')
三、删除元素
tup = ('Google', 'Runoob', 1997, 2000)

print(tup)
del tup
print("删除后的元组 tup : ")
print(tup)
# ('Google', 'Runoob', 1997, 2000)
# 删除后的元组 tup : 
# Traceback (most recent call last):
#   File "D:/PyCharmProject/main.py", line 6, in <module>
#     print(tup)
# NameError: name 'tup' is not defined
四、元素运算符
Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print (x,) 1 2 3 迭代
五、元组的索引、截取

与字符串相似

集合

一、集合的概念

集合：是一组无序排序，且不重复的元素组成的，使用大括号表示。

元素类型可以是：数字类型、字符串、元组，但不能是列表、字典-->不可改变

使用大括号创建的集合属于可变集合，可以添加和删除元素。

pr=set(['asda'])
pr.update('12')
print(pr)
print(type(pr))
# {'2', 'asda', '1'}
# <class 'set'>

二、集合的操作

  1. 增加元素 add,update

  2. 删除元素 remove,discard,clear

    s1=set('axas')
s1.remove(1)
print(s1) # KeyError: 1


s1=set('axas')
s1.discard(1)
print(s1) # {'x', 's', 'a'}

三、集合的运算

运算 说明 运算 说明
x in set1 检测x是否在集合set1中 set1 set2
set1==set2 判断集合是否相等 set1 & set2 交集
set1<=set2 判断set1是否是set2的子集 set1 - set2 差集
set1<set2 判断set1是否是set2的真子集 set1 ^ set2 对称差集（a|b-a&b）
set1>=set2 判断set1是否是set2的超集 set1 = set2
set1>set2 判断set1是否是set2的真超集

union()、intersection()与difference()函数：实现集合的并集、交集与差集。

四、字典推导与集合推导

字典推导式：使用大括号包围，需要两个表达式，一个生成key，一个生成value，两个表达式之间使用冒号分隔，结果返回字典。

s=(x for x in range(10))
print(*s)
print(type(s))
l=list(s)
print(l) # []
x=list(s)
print(x) # [] 只能访问一次
d={x:x+1 for x in range(10)} # 字典推导式
print(d)
print(type(d))
# 0 1 2 3 4 5 6 7 8 9
# <class 'generator'> 构造器对象
# {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}
# <class 'dict'>

函数

函数：实现某种功能的代码块

# 求最大公约数和最小公倍数
def gcd(m, n):
    r = m % n
    while (r != 0):
        m, n = n, r
        r = m % n
    return n


def lmc(m, n):
    return m * n // gcd(m, n)


a, b = map(int, input().split())
print(gcd(a, b), lmc(a, b))

def gcd(m, n):
    r = m % n
    while (r != 0):
        m, n = n, r
        r = m % n
    return n


def f(m, n):
    return gcd(m, n),m * n // gcd(m, n)


a, b = map(int, input().split())
# c,d=f(a, b)
print(type(f(a,b))) # <class 'tuple'>

函数的参数列表：形参和实参

位置参数：函数调用时，调用实参的顺序和定义形参的顺序是一样的

关键字参数：函数调用时，通过对形参赋值，传递参数。

允许函数调用时传递实参的顺序与定义函数的形参顺序不一样。

def printF(name,age):
    return name,age
print(printF("a",20)) # 位置参数
print(printF(age=31,name='wamg')) # 关键字参数
print(printF('am',age=56,name='man',))

默认参数：在函数定义时，参数列表中某个形参有值，称这个参数为默认参数，默认参数必须放在没有默认值的参数后面。

def printF(name,age,school='sdut'):
    return name,age,school # school是默认参数
print(printF('aa',20))
# ('aa', 20, 'sdut')

不定长参数：函数形参不定长度参数的实参作为元组，在形参前面使用*来实现。

不定长参数接受关键参数并将其存放在字典中，这时候许哟啊使用**来实现

def sum1(a=1,b=2,*args):
    print(a,b,args)
    s=a+b
    for n in args:
        s+=n
    return s
print(sum1(1,2,3,4))
# 1 2 (3, 4)
# 10

推荐阅读