Python下的元组，set集合，字典（解释器为python3.6）

最新推荐文章于 2022-08-04 14:11:09 发布
最新推荐文章于 2022-08-04 14:11:09 发布
阅读量360 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42303254/article/details/86529312
版权

一.Python下的元组（tuple）——不可变类型

1.Python的内置的一种数据类型是列表：tuple。

Python的元祖和列表相似，不同之处在于：元组是不可变类型，元组的元素一旦声明，就不能再修改，即元组在声明之后长度就是固定的。元素可以是任意类型的数据。

2.元组（tuple）同字符串一样也有len函数。

3.元组（tuple）同字符串一样也有下标索引。（正着从0开始，倒着从-1开始）。超出索引时，回报错。

4.元组（tuple）同字符串一样也有切片。

5.元组（tuple）同字符串一样也有计算（加法和乘法）。——只局限于同类型（同是元组）

6.元组（tuple）同字符串一样也有成员运算符。

7.元组（tuple）同字符串一样也支持for循环。

8.元组（tuple）的定义方法：

names=(100,'200',True,2.3,(100,200,'300'))           #列表中的元素可以是任意类型，当然也包括列表，元组，set集合，字典。

值的注意的是，元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定

t2=('hello',)
t3=('hello')
print(type(t2))      #输出<class 'tuple'>
print(type(t3))      #输出<class 'str'>

如何定义一个空元组呢？

t=()                                                 #定义一个空元组

print(t)                  #输出()
print(type(t))        #输出<class 'tuple'>

或

t=tuple()                                        #定义一个空元组                                          
print(t)             #输出()
print(type(t))   #输出<class 'tuple'>

值的注意的是：当元组中嵌套列表，元组，set集合，字典，字符串——>有下标索引时，列表的索引和切片的写法：即[]是可以多个出现的，只要有索引这个属性就行。

service=(('http',80),('ssh',22),'hello',('ftp',21))
print(service[1][1])        #输出22
print(service[-1][1])       #输出21
print(service[:][1])         #输出('ssh', 22),同service[1]
print(service[:-1][0])      #输出('http', 80)                                       

9.因为元组（tuple）是不可变类型，所以没有增删改这三个操作，但是有查这个操作

元组里面包含可变数据类型，可以间接增，删，修元组的内容。

t=([1,2,3],4)
t[0].append(4)
print(t)      #输出([1, 2, 3, 4], 4)
t[0].remove(1)
print(t)       #输出([2, 3, 4], 4)
t[0][0]=5
print(t)       #输出([5, 3, 4], 4)

元组的查方法：

（1）not  in：不在，返回True；在，返回False——>成员操作符

service=('http','ssh','ftp','http')
print('http' not in service)       #输出False

（2）in：在，返回True；不在，返回False——>成员操作符

service=('http','ssh','ftp','http')
print('http' in service)            #输出True

（3）count：统计某个元素出现的次数

service=('http','ssh','ftp','http')
print(service.count('http'))        #输出2

（4）index：返回某个元素的下标位，默认返回第一个，并且从左往右数

service=('http','ssh','ftp','http')
print(service.index('http'))       #输出0
print(service.index('ssh'))       #输出1

10.元组（tuple）中的排序函数——>sorted函数。因为元组是不可变类型，所以没有sort()方法。——>用法同列表

sorted函数：默认升序排列，要使用sorted函数，必须保证列表中的元素是同类型的。

值的注意的是：元组排序之后，默认变为列表

1.练习一

（1）排序方法一：利用sorted函数

service=('alice','bob','harry','Bob')
print(sorted(service))       #输出['Bob', 'alice', 'bob', 'harry']。字母按照ASCII码进行排序。
print(service)                    #输出['alice', 'bob', 'harry', 'Bob']

（2）方法二：将元组转换为列表

service=('alice','bob','harry','Bob')
serviceli=list(service)
serviceli .sort()
print(serviceli)                 #输出['Bob', 'alice', 'bob', 'harry']。字母按照ASCII码进行排序。

或

service=('alice','bob','harry','Bob')
serviceli=list(service)
print(sorted(serviceli)) #输出['Bob', 'alice', 'bob', 'harry']。字母按照ASCII码进行排序。

2.练习二：

score = (100,89,45,78,65)
scores = sorted(score)
minscore,*middlescore,maxscore = scores           #其中*表示多个
print(minscore)             #输出45
print(middlescore)        #输出[65, 78, 89]
print(maxscore)            #输出100
print('最终成绩为: %.2f' %(sum(middlescore) / len(middlescore)))              #输出最终成绩为: 77.33

11.元组（tuple）的应用场景

（1）变量交换数值
 a = 1
 b = 2
 b,a = a,b
 #1.先把(a,b)封装成一个元组(1,2)
 #2.b,a=a,b ---> b,a=(1,2)
 #b = (1,2)[0] a = (1,2)[1]
 print(a)                   #输出2
 print(b)                   #输出1

（2）打印变量的值

name = 'westos'
age = 11
t = (name,age)
print('name:%s , age:%d'  %(name,age))              #输出name:westos , age:11
print('name:%s , age:%d'  %t)            #输出name:westos , age:11

（3）元组的赋值，有多少个元素，就用多少个变量接收

t = ('westos',11,100)
name,age,score = t
print(name,age,score)             #输出westos 11 100

二.Python下的set集合（set）——可变类型

1.Python的内置的一种数据类型是set集合：set

set是一种无序的集合，没有先后顺序（集合包括列表——list；元组——tuple；set集合——set；字典——dict）。可以随时添加和删除其中的元素。但，元素不可以重复，没有下标。元素可以是任意类型的数据。

2.set集合（set）同字符串一样也有len函数。

3.set集合（set）没有下标索引。（这是因为set集合是无序的）。

4.set集合（set）没有有切片（set集合没有下标索引，当然也就没有切片了）。

5.set集合（set）没有计算（加法和乘法）。

6.set集合（set）同字符串一样也有成员运算符。

7.set集合（set）同字符串一样也支持for循环。

s = {1,2,3}
for  i  in  s:
    print(i,end='|')            #输出1|2|3|

8.set集合（set）的定义方法：

集合里面的元素是不可重复的。
s = {1,2,3,1,2,3,4,5}
print(s)                   #输出{1, 2, 3, 4, 5}
print(type(s))         #输出<class 'set'>


如何定义一个空集合
s2 = {}                       #这是定义了一个空字典
print(type(s2))           #输出<class 'dict'>

s3 = set([])                #或者s3=set()，定义一个空集合。
print(s3)                     #输出set()
print(type(s3))           #输出<class 'set'>

 

因为集合中的元素是不能重复的，所以可以利用集合来去重。

li = [1,2,3,1,2,3]
print(list(set(li)))          #输出[1, 2, 3]，先将列表转换为set集合，再将set集合转换为列表。

9.set集合（set）的相关操作（增删查，没有改（因为没有下标索引））

<1>增（add,update）

#集合:无序的数据类型
#添加顺序和在集合中存储的顺序是不一定相同的

（1）add：增加一个元素

s = {6,7,8,9}

s.add(1)
print(s)               #输出{1, 6, 7, 8, 9}

（2）update：增加多个元素

s = {6,7,8,9}

s.update({5,3,2})           注意：添加的数据必须放到一个集合当中去（列表、元组、set集合）
print(s)               #输出{1, 2, 3, 5, 6, 7, 8, 9}

<2>删（pop,remove,del）

（1）pop：因为set集合是无序的，所以pop取set集合中的随便一个元素进行删除

s = {6,7,8,9}

s.pop()
print(s)           #输出{9, 6, 7}

s = {6,7,8,9}
a=s.pop()
print(s)           #输出{9, 6, 7}
print(a)           #输出8

（2）del：删除set集合——>不仅仅适用于set集合，也适用于字符串，列表，元组和字典。

s = {6,7,8,9}
del  s
print(s)           #输出会报错

（3）remove：类似于del，但其中要接的是删除的一个元素

s = {6,7,8,9}

s.remove(6)
print(s)          #输出{8, 9, 7}

<3>查（not  in,in）

（1）not  in：不在，返回True；在，返回False——>成员操作符

s = {6,7,8,9}

print(6 not in s)       #输出False

（2）in：在，返回True；不在，返回False——>成员操作符

s = {6,7,8,9}

print(6 in s)             #输出True

10.set集合中的并集，交集，差集，对等差分（并集-交集），超集，子集，两个集合是不是不相交

<1>并集

s1 = {1,2,3}
s2 = {2,3,4}

print('并集:',s1.union(s2))     #输出并集: {1, 2, 3, 4}，或者print('并集:',s2.union(s1)) 
print('并集:',s1|s2)                 #输出并集: {1, 2, 3, 4}，或者print('并集:',s2|s1) 

<2>交集

s1 = {1,2,3}
s2 = {2,3,4}

print('交集:',s1.intersection(s2))      #输出交集: {2, 3}，或者print('交集:',s2.intersection(s1)) 
print('交集:',s1&s2)                           #输出交集: {2, 3}，或者print('交集:',s2&s1) 

<3>差集

s1 = {1,2,3}
s2 = {2,3,4}

print('差集:',s1.difference(s2))       #s1-(s1&s2)，输出差集: {1}
print('差集:',s2.difference(s1))       #s2-(s1&s2)，输出差集: {4}

<4>对等差分（并集-交集）

s1 = {1,2,3}
s2 = {2,3,4}

print('对等差分:',s1.symmetric_difference(s2))      #输出对等差分: {1, 4}，或者print('对等差分:',s2.symmetric_difference(s1))    
print('对等差分:',s1^s2)                                            #输出对等差分: {1, 4}，或者print('对等差分:',s2^s1)  

<5>超集

s3 = {1,2}
s4 = {1,2,3}
#s3是否为s4的超集
#超集:如果s3中的每一个元素都在集合s4中,且s4中可能包含s3中没有的元素,
#那么s4就是s3的一个超集
print(s3.issuperset(s4))         #输出False
print(s4.issuperset(s3))         #输出True

<6>子集

s3 = {1,2}
s4 = {1,2,3}

#s3是否为s4的子集
print(s3.issubset(s4))           #输出True

print(s4.issubset(s3))           #输出False

<7>两个集合是不是不相交

#两个集和是不是不相交
print(s3.isdisjoint(s4))         #输出False，或者print(s4.isdisjoint(s3))  

11.set集合（set）中的排序函数——>sorted函数。因为set集合没有下标索引和切片，所以没有sort()方法。——>用法同列表

sorted函数：默认升序排列，要使用sorted函数，必须保证列表中的元素是同类型的。

值的注意的是：元组排序之后，默认变为列表

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性。他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，对于其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不同的学生的学号，然后再把这些数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“去重”与排序工作

import random
s=set()
for i in range(int(input('N:'))):
    s.add(random.randint(1,1000))
print(s)

四.Python下的字典（dict）——可变类型

1.Python的内置的一种数据类型是字典：dict

字典使用键—值（key—value）来存放多个值。

key和value是一个整体，key和value组成一个元素。

字典中所有元素的键都是不可重复的，但值可以重复。

键和值可以是任意类型的数据。

字典是一种无序的集合，没有先后顺序（集合包括列表——list；元组——tuple；set集合——set；字典——dict）。可以随时添加和删除其中的元素。key值不可以重复，但value值可以重复，没有下标。

因为字典是一个无序的数据类型，所以使用print输出字典时，通常输出顺序和定义顺序不一致。

2.字典（dict）同set集合一样也有len函数。

3.字典（dict）同set集合一样，没有下标索引。（这是因为字典是无序的）。但是字典不同于set集合的是：字典可以利用键值来得到value值。

students={
    '03113009':{
        'name':'tom',
        'age':18,
        'score':80
    },
    '03113010':{
        'name':'laoli',
        'age':19,
        'score':30
    }
}
print(students)
#输出  {'03113009': {'name': 'tom', 'age': 18, 'score': 80}, '03113010': {'name': 'laoli', 'age': 19, 'score': 30}}
print(students['03113010']['name'])         #输出laoli

4.字典（dict）同set集合一样，没有有切片（字典没有下标索引，当然也就没有切片了）。

5.字典（dict）同set集合一样，没有计算（加法和乘法）。

6.字典（dict）同set集合一样，也有成员运算符。——>看的是字典的key值。

7.字典（dict）同set集合一样，也支持for循环。

1.遍历键

方法一：

d={'1':'a','2':'b'}
for key in d:
    print(key)
#输出 1
#         2

方法二：

d={'1':'a','2':'b'}
for key in d.keys():
    print(key)
#输出 1
#         2

2.遍历value值

方法一：

d={'1':'a','2':'b'}
for key in d:
    print(d[key])
#输出 a
#         b

方法二：

d={'1':'a','2':'b'}
for value in d.values():
    print(value)
#输出 a
#         b

3.遍历字典

方法一：

d={'1':'a','2':'b'}
for key in d:
    print(key,d[key])
#输出 1 a
#         2 b

方法二：

d={'1':'a','2':'b'}
for key,value in d.items():
    print(key,value)
#输出 1 a
#         2 b

8.字典（dict）的定义方法：

利用zip函数来定义字典

user=['user1','user2']
passwd=['123','456']
print(zip(user,passwd))                  #输出一个对象。<zip object at 0x7f869c59a308>
#想要输出一个字典，就必须利用强制类型转换。
print(dict(zip(user,passwd)))        #输出一个字典。{'user1': '123', 'user2': '456'}

print(set(zip(user,passwd)))         #输出{('user1', '123'), ('user2', '456')}
print(tuple(zip(user,passwd)))      #输出(('user1', '123'), ('user2', '456'))
print(list(zip(user,passwd)))          #输出[('user1', '123'), ('user2', '456')]

利用键—值对来定义字典

students={
    '03113009':{
        'name':'tom',
        'age':18,
        'score':80
    },
    '03113010':{
        'name':'laoli',
        'age':19,
        'score':30
    }
}
print(students)
#输出  {'03113009': {'name': 'tom', 'age': 18, 'score': 80}, '03113010': {'name': 'laoli', 'age': 19, 'score': 30}}

 

利用工厂函数来定义字典

d1=dict(a=1,b=2)                #值的注意的是，默认等号前面的是字符串，等号后面的是数字，等号后面的数据类型是可以改变的（比如加引号，变为字符串的数据类型）；但是等号前面的数据类型是不可以改变的。

print(d1)               #输出{'a': 1, 'b': 2}
print(type(d1))     #输出<class 'dict'>

 

所有的value值一样时，如何快速定义字典？

d={}.fromkeys({1,2},'redhat')           #或d={}.fromkeys([1,2],'redhat')  或d={}.fromkeys((1,2),'redhat')  
print(d)
#输出  {1: 'redhat', 2: 'redhat'}

如何定义一个空字典呢？

d={}                          #定义一个空字典
print(type(d))           #输出<class 'dict'>

或

d=dict()                  #定义一个空字典
print(d)                   #输出{}
print(type(d))         #输出<class 'dict'>

9.字典（dict）的相关操作（增删改查）

<1>增：利用字典的key来增加一个元素；利用update来增加多个元素；利用setfault增加一个元素。

如果key值不存在，则添加对应的key-value值

（1）添加一个元素：利用字典的key

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service['mysql']=3306
print(service)
#输出  {'http': 80, 'ssh': 22, 'ftp': 21, 'mysql': 3306}

（2）添加多个元素：利用update函数

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service_backup={'https':443,'oracal':888}
service.update(service_backup)
print(service)
#输出  {'http': 80, 'ssh': 22, 'ftp': 21, 'https': 443, 'oracal': 888}

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service.update(https=443,oracal=888)
#输出  {'http': 80, 'ssh': 22, 'ftp': 21, 'https': 443, 'oracal': 888}

setdefault添加一个元素

如果key值存在，不做修改；如果key值不存在，则添加对应的key-value值。

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service.setdefault('http',9090)               #http这个键存在，不做任何修改  
print(service)
#输出  {'http': 80, 'ssh': 22, 'ftp': 21}
service.setdefault('oracal',888)           #oracal这个键不存在，增加oracal这个键
print(service)
#输出  {'http': 80, 'ssh': 22, 'ftp': 21, 'oracal': 888}

<2>删（del,pop,popitemclear）

（1）del：可以删除字典某个key对应的value值；也可以删除整个字典

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
del service['http']
print(service)
#输出{'ssh': 22, 'ftp': 21}
del service
print(service)
#输出：报错NameError: name 'service' is not defined

（2）pop：pop删除指定key的key-value
                     #如果key存在,删除,并且返回删除key对应的value
                      #如果key不存在,报错

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
a=service.pop('http')
print(a)
#输出 80
print(service)
#输出 {'ssh': 22, 'ftp': 21}
b=service.pop('https')
print(b)
print(service)
#输出：报错KeyError: 'https'

（3）popitem：删除最后一个key-value值

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
a=service.popitem()
print(a)
print(service)
#输出  ('ftp', 21)
#      {'http': 80, 'ssh': 22}

（4）clear：清空字典内容，但是字典还在（空字典）

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service.clear()
print(service)
#输出{}

<3>改：利用字典的key来修改一个元素；利用update来修改多个元素。

如果key值存在，则更新相应的value值

（1）修改一个元素

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service['http']=8080
print(service)
#输出  {'http': 8080, 'ssh': 22, 'ftp': 21}

（2）修改多个元素

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service_backup={'http':443,'oracal':888}
service.update(service_backup)
print(service)
#输出  {'http': 443, 'ssh': 22, 'ftp': 21, 'oracal': 888}

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
service.update(http=443,oracal=888)
print(service)
#输出  {'http': 443, 'ssh': 22, 'ftp': 21, 'oracal': 888}

<4>查（in,not  in），查看字典的key值，value值，查看字典的key值对应的value值及同时查看字典的key和value值

（1）not  in：不在，返回True；在，返回False——>成员操作符

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
print('http' not in service)
#输出False

（2）in：在，返回True；不在，返回False——>成员操作符

service={
    'http':80,
    'ssh':22,
    'ftp':21
}

print('http' in service)
#输出True

（3）查看字典的key值

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
print(service.keys())
#输出dict_keys(['http', 'ssh', 'ftp'])

（4）查看字典的value值

service={
    'http':80,
    'ssh':22,
    'ftp':21
}

print(service.values())
#输出dict_values([80, 22, 21])

（5）查看字典key对应的value值

方法一：

key不存在，报错

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
print(service['http'])
#输出80
print(service['https'])
#输出报错KeyError: 'https'

方法二：get方法

key存在，返回key对应的value值；

key不存在，默认返回None，有default，默认返回default。

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
print(service.get('http'))             #输出80
print(service.get('https'))           #输出None
print(service.get('https',1))        #输出1

（6）同时查看字典的key和value值

service={
    'http':80,
    'ssh':22,
    'ftp':21
}
for key,value in service.items():
    print(key,'----->',value)
#输出  http -----> 80
#          ssh - ----> 22
#          ftp -----> 21

五.Python下的字典练习

1.练习一：

数字重复统计:
    1)随机生成1000个整数;
    2)数字范围[20,100];
    3)升序输出所有不同的数字及其每个数字重复的次数

import random

#定义一个空字典
d={}

#定义一个空列表
l=[]

for i in range(1000):
    l.append(random.randint(20,100))
print(l)

#对生成的1000个数进行排序，并加到字典中
l1=sorted(l)
print(l1)
for j in l1:
    if j in d:
        d[j]+=1
    else:
        d[j]=1
print(d)

2.练习二：

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
    # 1. 用户输入一句英文句子；
    # 2. 打印出每个单词及其重复的次数;
 "hello java hello python"
# hello 2
# java 1
# python 1

str=input('请输入一个英文句子：')

#定义一个字典
d={}

#分割字符串，得到一个列表
l=str.split()
for i in l:
    if i in d:
        d[i]+=1
    else:
        d[i]=1
print(d)

3.练习三：

 1. 随机生成100个卡号；
#     卡号以6102009开头， 后面3位依次是 （001， 002， 003，...， 100），
# 2. 生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";

# 3. 输出卡号和密码信息， 格式如下:
卡号                  密码
6102009001              000000

import random
#定义一个空set集合
s=set()
#定义一个空字典
d={}
while True:
    num=random.randint(1,100)
    st=str(num)
    if len(st)==3:
        s.add('6101009'+st)
    elif len(st)==2:
        s.add('6101009'+'0'+st)
    elif len(st)==1:
        s.add('6101009'+'00'+st)
    if len(s)==100:
        break
print(sorted(s))
d={}.fromkeys(sorted(s),'redhat')
print('卡号\t\t\t密码')
for key,value in d.items():
    print('%s\t%s' %(key,value))

或：

import random
se=set([])
while True:
    if len(se) != 100:
        se.add('6102009'+str('%03d'%(random.randint(1,100))))
    else:
        break
print(len(se))
d={}.fromkeys(sorted(se),'redhat')
print('卡号\t密码')
for k,v in d.items():
    print(k,'\t',v)
柒️星
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
廖雪峰python3.6教程笔记3-Python基础之使用list, tuple, dict和set
zyc_love_study的博客
03-30 525
一listPython内置的一种数据类型是列表：list，是一种有序的集合。特性：1: 用len()函数可以获得list元素的个数2: 用索引来访问list中每一个位置的元素，记得索引是从0开始的：3: 如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素。4: list是一个可变的有序表，所以，可以往list中追加元素，指定位置插入元素，删除元素，替换元素。appe...
python第三节课：元组 字典 Set 函数
关于一个IT新人的博客
05-25 499
1.元组tuple=("s",124,0)    (1)有一个元素时在元素后面加括号 （2)元组元素不可以修改 （3)del 删除会有异常    (4)列表和元组可以互转2.字典(键值对)键唯一(可以是数字，字符，元组)dict={"Name":"Runoob",Age:7} del dict["Name"]#删除键 dict.clear() #清空 del dict #删除字...
Python语法--元组、字典、Set
dfBeautifulLive的博客
08-04 358
tuple=()代表元组类型tuple=();# 运行结果： 代表是元组对象要注意的是元组里只有一个元素时需要加上逗号，否则就不是元组类型，就是普通的括号里展示的类型，如：tuple=(50)，打印类型以后则是int类型，修改为tuple2=(50,)则是元组类型tuple=(50);...
Python基础：元组和set集合常用方法函数
AmoDic的博客
04-22 1456
元组: 和列表差不多 列表:有序且可重复 元组创建之后是一个不可修改的对象 创建一个元组,并初始化 tu = (4,5,6) 创建一个空元组 tu = () 注意:如果元组里只有一个元素,需要在元素后面添加一个逗号 tu1 = (2,) 元组的切片: tu[3] 取出下标为3的元素 tu[-3] 取出倒数第三个元素 tu[::-1] 倒叙输出元组 tu[6:1:-2] 从下标6到下标2倒叙跳1个输出 元组的常用函数: len() max() min() 注意:元组的增删改都是
Python 元祖(Tuple) 集合(set) 常用方法 总结
不会修电脑的程序猿
09-05 799
************************* 元组 ************************* 元组如果只有一个值，需要加逗号，如：(a,)。元组只有查的方法 列表 = list(元组) 元组转列表 元组 = tuple(列表) 列表转元组(元组内的数据不能修改) 元组/列表 = tuple/list(只要是能for循环的都可以) 将括号中的内容一个一个添加进元组或列...
Python3.6 中文文档_Python3.6中文文档_
09-30
1. **变量与数据类型**：Python3.6支持多种数据类型，包括整型（int）、浮点型（float）、字符串（str）、布尔型（bool）、列表（list）、元组（tuple）、集合（set）和字典（dict）。其中，Python3.6引入了对大整数...
Python3.6中文手册(官方文档)
11-07
2. 列表（list）、元组（tuple）、集合（set）和字典（dict）等复合数据结构。 3. 控制流语句：条件判断（if...else）、循环（for、while）和异常处理（try...except）。 4. 函数定义与调用，包括默认参数、可变参数...
Python 编程练习题 100 例（源码），实例在 Python 3.6 环境下测试通过。.zip
最新发布
01-03
同时，Python的列表（list）、元组（tuple）、集合（set）和字典（dict）是强大的数据结构，它们各自有独特的特点和用途。 3. **函数**：Python中的函数是可重用的代码块，可以接受参数并返回结果。`def`关键字用于...
Python 3.6 官方文档 (html)
01-16
- **变量与数据类型**：包括整型（int）、浮点型（float）、字符串（str）、布尔型（bool）、列表（list）、元组（tuple）、集合（set）和字典（dict）等。 - **控制结构**：if语句、for循环、while循环、try/...
学习笔记(08):Python零基础轻松从入门到实战-字典-2
12-21
在Python 3.6及更高版本中，字典是有序的，因此`popitem()`会按插入顺序删除。如果没有更多键值对，它会抛出`KeyError`异常。 ```python last_item = original_dict.popitem() # 如果字典非空，返回一个元组，表示...
Python 之元组（tuple）、集合（set）
tz_zs的博客
08-21 2046
____tz_zs 元组（tuple） 元组（tuple）是特殊的序列类型，使用逗号和圆括号来表示，如(‘red’, ‘blue’, ‘green’), (2, 4, 6)。 元组一旦被创建就不能修改，使得代码更安全，访问方式和列表相同，一般用于表达固定数据项、函数多返回值等情况。 特点: 元组中的元素可以是不同类型的 元组中各元素存在先后关系，可通过索引访问元组中元素 集合（set） Pytho...
九、python基础：元组（Tuple）和集合（Set）
热门推荐
weixin_42834609的博客
07-31 1万+
一：元组 1、元组与列表类似，但是元组只能查看，不能修改（增、删、改） 2、元组里面的每个元素使用逗号分隔开，最后使用小括号括起来组成元组，需要注意的是：当元组内只有一个元素时，逗号也不能省略 3、元素与字符串类似，下标索引从0开始，可以进行截取、组合等操作   4、元组运算符   5、元组的整体修改与删除 元组中的元素不允许进行修改，但是我们可以对元组整体进行连接组合 ...
python（七）——元组、字典、Set、
苦作舟的空城机
05-11 555
目录 元组 元组的创建 元组元素的访问 获取最后一个元素可以使用下标为-1 元组可以连接 列表转元组 dict字典 key的特性 字典元素的访问： 字典名[key] 字典添加 字典删除pop() 遍历字典 例子：输入一个时间，输出下一秒的时间 Set 元组 元组的创建 元组使用小括号，列表使用方括号。 元组一旦初始化就不能再修改，而列表可以 元组...
列表、元组、Set、字典，在Python中的使用
weixin_37536020的博客
07-07 748
包括：列表、元组、字典、设置集Set
python元组，字典，列表，set集合
qq_38262155的博客
05-25 353
pytho3元组Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。 如下实例： tup1=(50,) 假如元组只有一个元素，需要在后面加一个逗号元组是不可修改的List1=[‘TaobBao’,’Baidu’,’Runoob’]Tuple1=tuple(List1)   #列表转成元组 Pyt...
python之元组字典及set类型
s489397771的博客
08-14 403
python之元组tuple：元组 本质：是一种有序集合特点：1.和列表非常相似 2.一点初始化，就不能修改 3.使用小括号1.创建tuple 格式：元组名 = (元组元素1，元组元素2，……元组元素n)tuple1 = () #创建空元组 tuple2 = (1,2,3,"goog",True) #创建有元素的元组,元组中元素的类型可以不同 p
python中的元组tuple+字典dict+集合set
Jackey_Song的博客
02-27 869
上一篇文章：Python中的字节bytes+列表lists 本片目录元组tuple元组的介绍元组的创建元组与列表相同的操作元组中不允许的操作元组与列表之间的转换字典dict集合set下一篇文章 元组tuple 元组的介绍 元组也是序列结构，但是是一种不可变的序列，可以简单理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。 元组的创建 元组与列表相同的操作 元组中不允许的操作 元组与列表之间的转换 字典dict 集合set 下一篇文章 ...
Python 元祖与集合
weixin_39974866的博客
05-09 937
集合1、特点 (1)集合是没有顺序的概念。所以不能用切片和索引操作。     （判断2个集合是否相等，之和元素本身有关，和顺序无关。） (2)互异性（集合你不存在两个相同的元素）  —— 可以用来筛选列表、字典等重复的元素 (3)可迭代2、操作    * 创建集合set():可变的 frozenset()：不可变的    * 添加元素add:添加一个字符串     eg:a.add('love'...
python学习---元祖和集合
tylglpc的专栏
12-11 1556
**元组：**1、特点：1、**有序**的集合 2、通过**偏移**来取数据 3、属于**不可变**的对象，**不能在原地（对象本身）修改**内容，没有排序，修改等操作。 4、形式:a=(1,2,3,4)Q:那为什么有列表还要有元组呢? 元组不可变的好处:保证数据的安全，比如我们传给一个不熟悉的方法或者数据接口，确保方法或者接口不会改变我们的数据从而导致程序问题。 2、tuple（元祖）类型转换
python列表元组字典集合
09-06
在Python编程语言中，有四种常用的集合数据类型，它们分别是列表(List)、元组(Tuple)、字典(Dictionary)和集合(Set)。列表是一种有序和可更改的集合，允许重复的成员。元组是一种有序且不可更改的集合，也允许重复的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值