day07 元组类型 字典类型 集合
元组:元组就是一个不可变的列表
1、用途:当我们需要记录多个同种属性的值,并且只有读的需求,没有改的需求,应该用元组。
2、定义方式:在()内用逗号分隔开多个任意类型的元素
t=(‘egon’)#注意:当元组内只有一个元素时,必须加逗号,t=tuple(('egon)),
print(t,type(t))
print(t[0])
数据类型转换:
t=tuple('hello')
print(t,type(t))
常用操作+内置方法
3.1优先掌握的操作
1、按索引取值(正向取+反向取 ):只能取
t=(‘a’,'b','c')
t[0]='A'
2 切片,(顾头不顾尾,步长)
t=('a','b','c')
print=(t[0:2])
3长度
print(len(t))
4成员运算in 和 not in
t=('a','b','c','d')
print('a' in t)
5循环
t=('a','b','c','d')
for item in t:
print(item)
3.2需要掌握的操作
t=('a','b','c','d',(1,2,3))
print(t.count('b')数B的数量
print(t.index('b',2,4)在2和4之间查找‘b’的索引
总结:
可以存多个值
有序
不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
0 1 2
t=(1,'a',['m'n])
print(id(t[0]),id(t[1]),id(t[2]))
t[2][0]='m'
print(id(t[0]),id(t[1]),id(t[2]))
t[2]的内存地址没有改变所以元组的内存地址不变=========================================================================
集合类型
一:引入
# pythons=['李铁蛋','张全蛋','王铜蛋','赵银蛋','oldboy','艾利克斯']
# linuxs=['kevin','egon','tank','艾利克斯','王铜蛋']
#
# l=[]
#
# for item in pythons:
# if item in linuxs:
# l.append(item)
#
# print(l)
二、集合(set)
1、用途:
1.1做关系运算
1.2去重
2、定义方式:在{}内用逗号分隔开多个元素,多个元素必须满足以下条件
2.1每个元素必须是不可变类型
2.2集合内元素不能重复
2.3集合无序
s={1,1.1,'aaa',1,1,1,1}
print(s,type(s))
注意点:
d={}#默认定义为字典
print(type(d))
s=set()
print(s,type(s))
数据类型转换
s=set('hello')
print(s)
3、常用操作+内置的方法
pythons={'李铁蛋’,‘张全蛋’,‘王银蛋’,‘oldboy’,‘艾利克斯’
linuxs={'kevin','egon','tank','艾利克斯’,‘王铜蛋 ’}
#
求刚报名pythons课又报名linuxs课时的学员:交集
res=pythons&linuxs
print(res)
res1=pythons.intersection(linuxs)
print(res1)
求所有的学员姓名:并集
res=pythons-linuxs
print(res)
print(pythons.difference(linuxs))
res=linuxs-pythons
print(res)
求没有同时报名两门课程的学员:对称差集
res=pythons^linuxs
print(res)
print(pythons.symmertrip_difference(linuxs))
父集/子集;
包含与被包含关系:
s1={1,2,3}
s2={3,1,2}
print(s1==s2)
s1={1,2,3}
s2={3,1,2}
print(s1>=s2)
print(s1.issuperset(s2))
print(s2<=s1)
print(s2.issuperset(s))
长度len
print(3 in s1)
成员运算in和not in
掌握的操作
1,s1={'a','b','cc','2','3'}
print(id(s1))
2,s1.update({3,4,5})
print(s1,id(s1))
3,s1.add(4)
print(s1)
4,res=s1.pop()
print(res)
5,res=s1.remove('b')
print(s1)
print(res)
6,s1={1,2,3}
s2={1,2,3}
s1.difference_update(s2)#s1=s1-s2
print(s1)
s1.intersection_update(s2)#s1=s1&s2
print(s1)
s1.symmetric_difference_update(s2)#s1=s1^s2
print(s1)
'''
s1={1,2,3}
s1.remove(4)
s1.discard(3)
print(res)#None
'''
'''s1={1,2,3}
s2={4,5,6}
print (s1.isdisjoint(s2))
'''
类型总结
1,可以存多个值
2,无序
3,set可变类型
4,去重
name=['egon','egon','keven','keven','alex','alex']
方法:
l=[]
for name in names:
if name not in l ;
l.append(name)
print(l)
2,如果去重的对象都是不可变类型并且不要求结果跟原来的顺序一致,那么就用set解决
# res=set(names)
# # print(res)
# l=list(res)
# print(l) info=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'egon','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
l=[]
for dic in info:
if dic not in l:
l.append(dic)
print(l)
字典类型:
# ======================================基本使用======================================
1、用途:记录多个不同属性的值
2、定义方式:在{}内用逗号分隔开多个元素,每一个元素都是key:value的形式,其中value可以是任意类型,Key必须是不可变类型(通常应该str类型)
dic={1:'aaa',1.3:'bbc',(1,2,3):'ccc','xxx':'ddd'}#dic=dict()
dic={'x':1'x':'2','x':3}
print(dic)
数据类型转换:dict
li=(['name','egon'],('age',18),('gender','male')
dic={}
for k,v in li:
dic[k]=v
dic=dict(li)
dic=dict(x=1,y=2,z=3)
print(dic)
3\常用操作+内置的方法
3.1、优先掌握的操作
1、按key存取值:可存可取
dic={'name':'egon','age':18,'gender':'male'}
print(dic['name'])
print(id(dic))
dic['name']=EGON
print(dic,id(dic))
dic['height']=1.81#/如果key不存在新增一组key:value
print(dic)
l=['a']
l[1]='b'
2、长度len
dic={'name':'egon','age':18,'gender':'male'}
print(len(dic))
3、成员运算in 和not in
dic={'name':'egon','age':18,'gender':'male'}
print('name' in dic)
4、删除
dic={'name':'egon','age'=18,'gender':'male'}
del dic['name'] 删除的通用操作,拿到的返回值为None
print(dic)
t=dic.popitem() 无序删除,可以拿到返回值
print(t,type(t))
v=dic.pop('name') 可以指定删除数据,根据key来删除
print(v)
5、键keys(),值value(),键值对items()
dic={'name':'egon','age':18,'gender':'male'}
keys=dic.keys()
print=(keys)
取到的值:['gender','name','age']
values=dic.values()
print(values)
取到的值:['male','eon',18]
items=dic.items()
print(items)
取到的值:[('gender','male'),('age',18),('name','egon')]
print(list(keys))
print(list(values))
print(list(items))
5、循环
for k in dic.keys():
print(k)
for k in dic:
print(k)
for k,v in dic.items():
print(k,v)
for v in dic.values():
print(v)
7、get 取值:值存在,则取值,值不存在,则返回None
dic={'name':'egon','age':18,'gender':'male'}
if 'xxx' in dic:
print(dic['xxx'])
else:
print(None)
v=dic.get('age')
print(v)
3.2需要掌握的操作
dic.fromkeys() 给一个列表附上空值。
li=['name','age','gender']
dic={}
for k in li :
dic[k]=None
print(dic)
dic={}.fromkeys(li,None)
print(dic)
dic.update() 更新功能:如果原字典存在则替换,如果原字典不存在则新增
old_dic={'name':'egon','age':18,'gender':'male'}
new_dic={'x'=1,'name':'EGON'}
old_dic.update.(new_dic)
print(old_dic)
dic.setdefault(k,v):执行完毕后是为了保证字典中必须有这么一个k
dic={'name':'egon','age':18,‘gender’:'male'}
v=dic.setdefault('helght',1.81)字典中没有‘height’这个键,则新增
print(dic)
print(v)
v=dic.setdefault('name','EGON')字典中有‘name’这个键,则新增
print(dic)
print(v)
v=dic.setdefault('name','EGON')#字典中有‘name’这个键,不修改字典
print(dic)
print(v) 拿到的是字典里原有的‘egon’
#setdefault 的原理分析:
k='name'
v='EGON'
if k not in dic:
dic[k]=v
print(dic)
======================================该类型总结====================================
存多个值
无序
可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,ID就变,不可变==可hash)
day07 元组类型 字典类型 集合的更多相关文章
- Python黑帽编程2.3 字符串、列表、元组、字典和集合
Python黑帽编程2.3 字符串.列表.元组.字典和集合 本节要介绍的是Python里面常用的几种数据结构.通常情况下,声明一个变量只保存一个值是远远不够的,我们需要将一组或多组数据进行存储.查询 ...
- python基础知识3——基本的数据类型2——列表,元组,字典,集合
磨人的小妖精们啊!终于可以归置下自己的大脑啦,在这里我要把--整型,长整型,浮点型,字符串,列表,元组,字典,集合,这几个知识点特别多的东西,统一的捯饬捯饬,不然一直脑袋里面乱乱的. 一.列表 1.列 ...
- python数据类型之元组、字典、集合
python数据类型元组.字典.集合 元组 python的元组与列表类似,不同的是元组是不可变的数据类型.元组使用小括号,列表使用方括号.当元组里只有一个元素是必须要加逗号: >>> ...
- python学习Day6 元组、字典、集合set三类数据用法、深浅拷贝
一.深浅拷贝 1. 值拷贝 ls1 = ls2 不开辟空间,指针跟着走.(直接将ls1中存放的地址拿过来,内存中不会开辟新的空间,所以你怎么变,我也跟着变.)(ls1内部的所有类型的值发生改变,l ...
- python_列表、元组、字典、集合对比
列表.元组.字典.集合 列表.元组.字典.集合对比 比较项 列表 元组 字典 集合 类型名称 list tuple dict set 定界符 [] () {} {} 是否可变 是 否 是 是 是否有序 ...
- Python 学习笔记(1)Python容器:列表、元组、字典与集合
Python容器:列表.元组.字典与集合 列表: 1.列表 的创建 使用[ ] 或者 list()创建列表:empty_list = [ ] 或者 empty_list= list() 使用list( ...
- python基础语法3 元组,字典,集合
元组: ========================元组基本方法===========================用途:存储多个不同类型的值定义方式:用过小括号存储数据,数据与数据之间通过逗号 ...
- Python中列表,元组,字典,集合的区别
参考文档https://blog.csdn.net/Yeoman92/article/details/56289287 理解Python中列表,元组,字典,集合的区别 列表,元组,字典,集合的区别是p ...
- Python中列表、元组、字典、集合与字符串,相关函数,持续更新中……
本篇博客为博主第一次学 Python 所做的笔记(希望读者能够少点浮躁,认真阅读,平心静气学习!) 补充: 列表.元组和字符串共同属性: 属于有序序列,其中的元素有严格的先后顺序 都支持双向索引,索引 ...
- 菜鸟学IT之python3关于列表,元组,字典,集合浅认识!
作业来源:https://edu.cnblogs.com/campus/gzcc/GZCC-16SE1/homework/2753 一.列表,元组,字典,集合分别如何增删改查及遍历. 列表 # 列表的 ...
随机推荐
- eureka ... is an unknown property 在 application.properties 中
问题如图 在application.properties中无法识别eureka 解决方式 (想了想这个好像是在某个依赖里面来的)发现 eureka 是在 某个依赖里面 所以添加了以下之后就解决了 ...
- G - WiFi Password Gym - 101608G (异或思维题+曲尺)
题目链接:https://cn.vjudge.net/contest/285962#problem/G 题目大意:给你n和m,n代表有n个数,然后让你找出一个最长的区间,使得这个区间内的所有的数的‘’ ...
- pwnable.kr col
collision - 3 pt 连接上查看col.c源码 分析一下代码, 1.hashcode等于一个固定的值 2.check_password函数取输入数据,4个一组,将输入的字符转成int,然后 ...
- TensorFlow学习笔记之--[compute_gradients和apply_gradients原理浅析]
I optimizer.minimize(loss, var_list) 我们都知道,TensorFlow为我们提供了丰富的优化函数,例如GradientDescentOptimizer.这个方法会自 ...
- SQL Server - SQL语言组成 (DML、DDL、DCL、DQL的区别)
转载自:https://www.cnblogs.com/dato/p/7049343.html 作者:Dato.zeng --------------------------------------- ...
- V4L2开发要点【转】
转自:https://blog.csdn.net/mr_raptor/article/details/7441141 首先来看 Read/Write ,如果 VIDIOC_QUERYCAP 调用返回的 ...
- python3+requests库框架设计06-测试脚本
在项目下新建TestCase文件夹,然后新建.py文件在文件中写关于接口具体的测试脚本,一般我喜欢按照模块来分,一个模块一个.py文件,建议以test开头命名文件 把配置文件改成这样 url:http ...
- c#基础之异常处理
在开发过程中,经常遇到各种各样的小问题,很多是由于基础不牢固,没有经常总结导致的.遇到重复的问题可能可根据以往经验处理,但是对问题本身引发的原因进行深入的了解.工作很多年,但是c#基础像一层冰一样,可 ...
- The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path 解决办法
♦ 未在 Java构建路径中 找到父类 "javax.servlet.http.HttpServlet" ♦ 解决办法: 项目右击 → Build Path → 右侧 Add L ...
- C++面向对象的特点
C++面向对象的特点 面向对象的特点主要有: 封装, 继承, 多态; 现在自己的简单理解如下, 但要明白具体怎么实现, 背后的原理是什么? 什么是封装, C++怎么实现封装 封装的大致可以分为: 函数 ...