Python入门-基本数据类型进阶（list，dict，tuple，set）

最新推荐文章于 2020-11-23 20:01:08 发布
最新推荐文章于 2020-11-23 20:01:08 发布
阅读量308 收藏
点赞数
分类专栏： Python入门 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msmso/article/details/107320974
版权

摔烂

一、列表

1、定义

在[]内,用逗号分隔开多个任意数据类型的值

l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

2、类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3] 
>>> list({"name":"jason","age":18}) #结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

3、使用（正取or反取）

按索引存取值(正向存取+反向存取)：即可存也可以取

正向取(从左往右)

my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]  
tony

反向取(负号表示从右往左)

my_friends=['tony','jason','tom',4,5]
>>> my_friends[-1]  
5

对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错

>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]

4、切片(顾头不顾尾，步长)

**顾头不顾尾：**取出索引为0到3的元素

>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]

步长： 0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素

>>> my_friends[0:4:2]  
['tony', 'tom']

5、长度（len）

>>> len(my_friends)
5

6、成员运算（in和not in）

>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

7、添加元素（append，extend，insert）

# append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']

# extend()一次性在列表尾部添加多个元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']

# insert()在指定位置插入元素
>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

8、删除（del，remove，pop）

# del删除没有返回值
>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l
[11,22,44]

# pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22

# remove()括号内指名道姓表示要删除哪个元素，没有返回值
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None

9、其他（reverse，sort，clear，count，index）

# reverse()颠倒列表内元素顺序    # l=l[::-1]也可以实现颠倒
>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]
# sort()给列表内所有元素排序
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]

# clear（）删除内容列表内容
l = [11,22,3,42,7,55]
l.clear()
print(l) # []

# count()查找元素在列表内重复的次数
l1=[11,22,333,333,333,]
print(l1.count(333)) # 3
# 没有则返回0

# index（）index（）方法返回字符串内子字符串的索引（如果找到）。 如果未找到子字符串，则会引发异常。
l1=[11,22,333,333,333,]
res=l1.index(333，0，3)
# res=l1.index(444) # 报错
print(res) # 2

二、元祖

1、作用

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取。

2、定义

# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")

# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

3、类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

4、取用

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:

5、切片(顾头不顾尾，步长)

>>> tuple1[0:6:2] 
(1, 15000.0, 22)

6、长度

>>> len(tuple1)  
6

7、成员运算

>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False

三、字典

1、定义

在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型。

# 通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

2、类型转换

# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

3、使用

# 按key存取值：可存可取
# 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'

# 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

3、长度

dic = {'name': 'xxx','age': 18,'hobbies': ['play game', 'basketball']}
print(len(dic)) # 3

4、成员运算

dic = {'name': 'xxx','age': 18,'hobbies': ['play game', 'basketball']}
>>> 'name' in dic  # 判断某个值是否是字典的key
True

5、删除（popitem，del，pop）

>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对，有返回值，代表的是取走操作
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}

# 万能删除，没有返回值，代表的是单纯的删除
d={'k1':111,'k2':222}
del d['k1']
print(d) # {'k2': 222}

# popitem（）随机删,返回一个元组
res=d.popitem()

6、键keys()值values()键值对items()

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])

# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])

# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

7、循环

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
# age
# hobbies
# name

# 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
# age
# hobbies
# name

# 只遍历value
>>> for key in dic.values():
...     print(key)
... 
# 18
# ['play game', 'basketball']
# xxx

# 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
# ('age', 18)
# ('hobbies', ['play game', 'basketball'])
# ('name', 'xxx')

8、其他 get()，update()，fromkeys()，setdefault()

# get()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

# update()

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

# fromkeys()
>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

# setdefault()
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

四、集合

1、作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于，去重、关系运算。

2、 定义

在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1： 元素必须是不可变类型；
2： 集合内没有重复的元素；
3： 集合内元素无序，去重之后无法保留原来的顺序。

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式。
d = {} # 默认是空字典 
s = set() # 这才是定义空集合，一定要用set关键字。

3、类型转换

但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

4、使用

4.1 关系运算

>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True

# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False


# 7.子集 是否被包含
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

4.2 去重

# 集合去重复有局限性

# 1. 只能针对不可变类型

# 2. 集合本身是无序的，去重之后无法保留原来的顺序示例如下>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

4.3 其他

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

5.练习题

集合类型简单练习题

帅兰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python中内置数据类型list,tuple,dict,set的区别和用法
09-21
主要给大家介绍了Python中内置数据类型list,tuple,dict,set的区别和用法，都是非常基础的知识，十分的细致全面，有需要的小伙伴可以参考下。
【Python/C++混合编程——基于API接口】
MFL_xiaotaiye的博客
06-01 369
C++调用python程序，API接口
【C语言】合并，排序两个链表
奇峰小筑
05-27 896
#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> typedef struct stu{ int id; //学号 char sex[10]; //性别 float score; //成绩 struct stu *next; //下一节点的
Psexec.exe,Windows服务器接入工具
XIDIAN01081208的专栏
04-01 2313
最近工作要用利用代码登录到Windows服务器，执行一些命令。发现一个好用的微软免费工具PSTool。 下载地址：https://technet.microsoft.com/en-us/sysinternals/bb896649.aspx 主要是该工具中的psexec.exe。该工具可以将本地的应用程序列如.bat脚本文件传输到远程服务器执行. 如：psexec.exe \\192.168.
python类型强制转换_python 基础之自动类型转换和强制类型转换
weixin_39620252的博客
11-23 174
一：自动类型转换自动类型转换注意针对Number数据类型来说的当2个不同类型的数据进行运算的时候,默认向更高精度转换数据类型精度从低到高:bool int float complex#关于bool类型的两个值：True转化成整型是1 False转化成整型是0#bool + intres = True + 2print(res)# bool + floatres = True + 4.45print...
（七）Spark——Structured Streaming
fseast的博客
10-06 1126
目录一、Structured Streaming 概述二、Structured Streaming 快速入门1. 导入依赖2. 具体实现3. 测试结果4. 代码说明三、Structured Streaming 编程模型1. 基本概念1.1 输入表1.2 结果表1.3 输出1.4 快速入门代码的再次说明2. 处理事件-时间和延迟数据(Handling Event-time and Late Data...
Python 的内置数据类型：列表 list、元组 tuple、字典 dict、集合 set.
12-21
Python数据类型：list list 是一种有序集合，由于Python是动态语言，所以 list 中包含的元素并不要求都必须是同一种数据类型，我们完全可以在 list 中包含各种数据。 访问列表中最后一个元素：L[-1]，索引值为 -1。...
python(list,tuple,set,dict)
12-21
迭代)tuple(练习：赋值，统计成绩)setset(用法)set(成员操作符，可迭代)set(集和)set(练习：去重)dictdict(用法)dict(成员操作符，迭代)dict(增，删，查)dict(练习：统计随机数)dict(练习：生成卡号)其他用法(最大...
python的dict,set,list,tuple应用详解
12-24
本文深入剖析了python中dict,set,list,tuple应用及对应示例，有助于读者对其概念及原理的掌握。具体如下： 1.字典(dict) dict 用 {} 包围 dict.keys(),dict.values(),dict.items() hash(obj)返回obj的哈希值，如果...
成员初始化列表-适用场合
weixin_34166847的博客
08-10 189
1. 简述     主要的场合有四类：初始化对象成员，初始化基类的成员，初始化const成员，初始化引用成员。对于const成员和引用成员，比较简单，这两种变量都要求初始化后不能赋值，因此，只能在成员初始化列表中进行初始化，其他地方不行。本文主要介绍初始化对象成员和初始化基类成员这两种情况。   2. 初始化对象成员     具体分为两种情况：第一，该对象具有“无参数的构造函数”，使用初始...
Elasticsearch倒排索引
https://gitee.com/hello-piper/PiperChat
08-22 186
什么是倒排索引? 假设有这么几条数据 ID Name Age Sex 1 Kate 24 Female 2 John 24 Male 3 Bill 29 Male ID是Elasticsearch自建的文档id，那么Elasticsearch建立的索引如下: Name: Term Posting List Kate 1 John 2 Bill 3...
普元EOS RichWeb(富客户端)实践总结
Jarvis_技术专栏
10-09 9742
    最近公司未来一银行项目要使用到普元的EOS，客服是普元合作机构，没办法，必须将系统在EOS平台上部署开发，认真学习了2个星期，对EOS6.0的印象还是非常的好。丰富的页面开发组件，SOA我不是特别特别的说的出来，看了SOA相关文档和对比传统的开发模式，EOS的思想非常值得学习，EOS里面的组件设计，能更好的增加代码的可重复性，模块的独立性，这对于一个大型银行系统来说，所带来的好处不言而喻。
最全的Python 3类型转换指南
Python追梦
09-17 1212
int 支持转换为 int 类型的，仅有 float、str、bytes，其他类型均不支持。 需要Python3的教程私信回复我【01】即可获取视频教程 1.float -> int 会去掉小数点及后面的数值，仅保留整数部分。 2.str -> int 如果字符串中有数字(0-9)和正负号(+/-)以外的字符，就会报错。 3.bytes -> int 如果 byt...
VC如何在VC5中控制工具条的停靠位置
热门推荐
guomei的专栏
02-22 1万+
 2005-09-01如何在VC5中控制工具条的停靠位置 - [VC专栏]作者：宋立波 在VC5 中开发大型应用程序时，工具条通常是程序中必不可少的重要功能因素， 其中工具条在整个窗口中的停靠位置尤其关键，它直接影响到程序界面的外观形 象。下面针对笔者实际开发中各类工具条停靠位置的控制过程，详细阐述其实现 技巧。 　　一、标准工具条停靠位置的控制 　　VC5 应用程序向导生
2019.10.25链表1
KaiFcookie的博客
10-27 142
typedef的用法 CASE 1 #include<stdio.h> typedef int ZHAGNSAN;//为int再重新多取一个名字，ZHAGNSAN等价于int typedef struct Student { int sid; char name[100]; char sex; }ST; int main(void) { int i=10;//等价于ZHANG...
C语言自定义类型（结构体，枚举，联合）的学习总结
-五月的博客
08-05 1050
结构体 结构的基础知识 结构是一些值的集合，这些值称为它的成员，一个结构的各个成员可能具有不同的类型。每个结构成员都有自己的名字，它们是通过名字访问的。 结构的声明 在声明结构时，必须列出它包含的所有成员。这个列表包括每个成员的类型和名字。 struct tag { member-list; }variable-list; tag是结构体标签；member-list是成员列...
PYTHON内置数据类型（ list ,tuple ,dict,set）
流星球
03-22 678
list Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，list 是一种有序的集合，可以随时添加删除其中元素list可以同时包含字符串和数字，注意字符串要用 ” 两个单引号括起来，相当于一种数组，可以用索引方式访问单个元素，可以顺序访问， 从0开始到N-1，或者逆序访问，-1，表示倒数第一个，-2倒数第二个 添加新元素 append() 总是把新的元素添加
Python基础(2)-其他数据类型(list,tuple,dict和set)
爱的lama的博客
07-07 175
list Python内置的数据类型是列表：list。其是一种有序的集合，可以随时删除添加其中的元素。比如： 1. 如何获取元素个数 变量classmates就是一个list，用len() 可以获得list元素个数 2. 访问list中每个位置的元素。 list_name[n] #访问第n+1个元素，索引从0开始，和C中数组一样，访问过界会报错，n也可以为负整数，list_name...
python中dict的使用方法
u011300968的博客
07-14 587
定义字典的方法 为不存在的字典元素设置默认值
python list tuple dict set
最新发布
09-06
Python中的list（列表），tuple（元组），dict（字典）和set（集合）是常见的数据结构。 1. 列表（list）是一个可变的、有序的元素集合。可以通过方括号[]来创建一个列表，列表中的元素可以是任意类型，并且可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值