元祖、hash了解、字典、集合类型

元祖:

原则跟列表差不多,也是存一组数,只是它一旦创建,便不能再修改,所以又叫只读列表。

创建:

names = (‘alex‘, ‘mike‘, ‘eric‘)

特性:

1.可存放多个值

2. 不可变。 但,元祖本身不可变,如果元祖中还包含其他可变元素,这些可变元素还可以改变。

3. 按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序

功能:

1.index

2.count

3.slice(切片)

改变可变元素示例:

n = ( 1,2,5,8,[ ‘a‘, ‘b‘], 9)

n[4][2] = ‘B‘

则n就变成了  ( 1,2,5,8,[ ‘a‘, ‘B‘], 9)

使用场景:

1. 显示的告知别人,此处数据不可修改

2. 数据连接配置信息等

Hash:

hash,被叫做“散列”或者“哈希”,就是把任意长度的输入,通过散列算法,变换成固定长度的输出,该输出就是散列值。 这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来唯一的确定输入值。简单来说,就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

特征:

hash值得计算过程是依据这个值的一些特征计算的,这就要求被hash的值必须固定,因此被hash的值必须是不可变的

不可变类型:数字、字符串、元祖

可变类型:  列表

语法: hash(‘abc‘)

用途:

文件签名、

md5加密(密码明文变密文,md5的特性是无法反解)

密码验证

字典:

字典是一种key - value的数据类型,通过前面的key能够找出后面的value。

创建:

{key1:value1,key2:value2}

1、键与值用冒号“:”分开;
2、项与项用逗号“,”分开;3. key的值不能重复

查询字典的某条信息: info[ key值 ]

dic = { ‘neo‘: [‘a‘,‘b‘,‘c‘], ‘alex‘: [ ‘c‘, ‘m‘,‘n‘}

修改字典某条信息:

dic[‘neo‘][1] = ‘B‘ 

则字典dic就变成了   {‘neo‘: [‘a‘, ‘B‘, ‘c‘], ‘alex‘: [‘c‘, ‘m‘, ‘n‘]}

特性:

1. key-value结构

2. key必须可hash,必须为不可变数据类型、必须唯一

3. 可以存放任意多个值,值可以修改,可以不唯一

4. 无序

5. 查找速度快

key必须可hash和查找速度快:计算机需要先利用hash把key值转化成一个数字,然后再利用“折半查找”(二分查找,算法的一种)的方式去找key的hash值,查询次数大概是2的n次方。(字典不是利用二分法)

字典添加:dic[ key ] = value   #value可以是任意类型

info = {‘student1‘: ‘ Tenglan Wu‘, ‘student2‘: ‘Cangjingkou‘, ‘student3‘: ‘Jiatengying‘}

info[ ‘ student4‘ ] = ‘abc‘

则字典info变成: {‘student1‘: ‘ Tenglan Wu‘, ‘student2‘: ‘Cangjingkou‘, ‘student3‘: ‘Jiatengying‘, ‘ student4‘: ‘abc‘}

修改:info[student2] = ‘苍井空‘

字典info变成: {‘student1‘: ‘ Tenglan Wu‘, ‘student2‘: ‘Cangjingkou‘, ‘student3‘: ‘Jiatengying‘, ‘ student2‘: ‘苍井空‘}     #添加的顺序是随机的,因为字典的无序性。

查找:

1. 标准用法: ‘student2‘ in info      # in是新的语法,用于判断字典info里面是否有‘student2‘这个key值,输出" True" 或者" False "。

如:if ‘student2‘ in info:   #  如果student2是info的key值

2. 获取用:1: info.get(‘student2‘)   #  如果有该键值则获取键值对应的value, 如果没有则输出None。

3. 获取用法2: info[‘student2‘]    # 有该键值则获取该键值,没有则会报错。  所以通常使用 info.get()

删除:

1. info.pop(键值)  #删除该键值及其对应的值。

2. info.popitem()   # 随机删除字典里的某个元素

3. del info(键值)

修改:

字典多层嵌套修改:

方法: 多层嵌套就是找到一级之后,再一层一层往下找,一个key一个key往下找。(很常见)

其他方法:

info.clear()   # 清空字典

info.copy()   # 跟列表的copy一模一样

info.keys()   # 获取所有的key值,放到一个列表里面

info.values()   # 获取所有的value,放到一个列表里面

info.items()    #是把info所有的key和value放到一个小元祖里面。

例:   info.itmes()  为  dict_items([(‘student1‘, ‘ Tenglan Wu‘), (‘student2‘, ‘Cangjingkou‘), (‘student3‘, ‘Jiatengying‘)])   #把这些元祖再放到一个列表里面

dic1.update(dic2)    #效果类似于列表里面list1.exptend(list2)。    把dic2和dic1合并起来, 如果dic2和dic1有重复的key值, 就用dic2 key值所对应的value 覆盖 dic1 key值所对应的value,也就是所谓的update(更新)。

注:列表里的list1.extend( list2) 的效果 类似于  list1 += list2

info.setdefault.( key1, value1)   #  如果key这个键值在info字典里面本来就存在,那么info没有变化; 如果key这个键值在info里面不存在, 就把键值为key1,value值为value1的元素添加到字典info里面

info.fromkeys( [‘key1‘, ‘key2‘, ‘key3‘] , value1]      #  批量往info字典里面添加“键值为key1,value值为value1”、“键值为key2,value值为value1”和“键值为key3,value值为value1”的元素, 如果不输入“ ,value ” , 则往info里面就只添加了键值分别为key1、 key2和 key3但value值为空的元素。

字典的循环:

for k in info:

print(k)      #  注意:  打印的只是键值key。 只是键值在循环。

for k in info:

print( k, info[k] )     # 这种方式能把键值、value值都打印出来

集合类型:

iphone7 = [ ‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ ]

iphone8 = [ ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ ]

如何找出同时买了iPhone7和8的人 ?

常规做法:  循环列表iphone7里面的人, 然后判断7里面的人是否在 iphone8里面 (交集)

iphone7 = [ ‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ ]

iphone8 = [ ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ ]

#定义一个空列表:同时买了7和8的人
both_list = [ ]

#循环7里面的人,一个个判断这些人是否也在8里面,在的话就添加到both_list
for name in iphone7:
    if name in iphone8:    #if ...in.. 语法
        both_list.append(name)    # 不能利用 " a = both_list.append(name)  print(a)"来打印交集列表, 因为这个函数没有返回值,所以打印出的结果是“None”
print(both_list)   #注意:print(both_list),否则意思就变了

#打印结果:[‘alex‘, ‘jack‘]

找出只买了iPhone7的人? (差集)

iphone7 = [ ‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ ]

iphone8 = [ ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ ]

only7 = [ ]

for name in iphone7:
    if name not in iphone8:     #if...not in...语法
        only7.append(name)
print(only7)

#打印结果:
[‘rain‘, ‘old_driver‘]

集合定义:

集合是一个无序的、不重复的数据组合,它的作用如下:

1. 去重,把一个列表变成集合,就自动去重了;

2.关系测试,测试两组数据之间的交集、并集、差集等关系。

语法:

s = { 1, 2,3,4,‘a‘, ‘b‘ }   #中间没有冒号(:)

空集合的类型是“字典”, 但按照集合的语法定义后,类型就是“集合”了 。

假如我定义了如下集合:

s = { 1, 2, 2, 2, 2, 3}

它会自动变成  s = { 1, 2, 3 }

列表(元祖也可以转)转成集合: set( list)

如:  list1 = [ 1,2,3]

set(list1) 就成了  { 1, 2, 3 }

添加:s.add(元素)    # 如果添加的元素原集合中已存在,就添加不进去。  # 只能添加一个元素

删除: s.pop( )    # 随机删除集合元素

s.remove( 元素 )   #删除该元素, 如果该元素不存在则会报错

s.discard(元素)    #删除该元素, 如果该元素不存在也不会报错

合并: s1.update( s2)     # 表面上看是s1和s2的合并, 其实是把s2 update到s1中, 所以最后的结果是: s2不变, 但s1变成了s2和原先s1的合并。效果类似于 s1 += s2

也可以利用 s.update() 往集合里面添加列表, 如:

s1 = { 1,2,3, ‘a‘}

s1.update( [‘A‘,‘B‘,‘C‘ ] )

s1就变成了 : {1, 2, 3, ‘A‘, ‘C‘, ‘B‘, ‘a‘}       #利用这种方式可以向集合里面批量 添加元素

s.clear( )      #  清空

判断集合关系:

交集1: s1.intersection( s2 )

并集2: s1 & s2

如上面的同时买了iPhone7和8的人:

iphone7 = [ ‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ ]
iphone8 = [ ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ ]

print(iphone7.intersection(iphone8))    # 疑问:跟上面利用循环求交集相比, 这个可以利用打印函数“iphone7.intersection(iphone8)”来直接打印,为什么list.append()和list.extend(list1)就没有返回值、不能直接打印? 哪些函数有返回值哪些没有 ?  还是说 s.intersection()不是一个函数 ?
# 或者 print( iphone7 & iphone8 )

#输出结果: {‘jack‘, ‘alex‘}

差集1:s1.difference(s2)   # s1对s2的差集   #s1和s2的位置不能互换

差集2: s1 - s2    # s1对s2的差集

如上面只买了iphone7的人:

iphone7 = {‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ }
iphone8 = { ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ }

print(iphone7.difference(iphone8))
# 或者  print(iphone7 - iphone8)

#输出结果: {‘old_driver‘, ‘rain‘}

并集1: s1.union( s2 )    #会自动去重

并集2:   s1 | s2

iphone7 = {‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ }
iphone8 = { ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ }

print(iphone8.union(iphone7))

#输出结果:
{‘old_driver‘, ‘old_boy‘, ‘shanshan‘, ‘jack‘, ‘rain‘, ‘alex‘}

对称差集: s1.symmetric_difference( s2 )    #  相当于s1和s2的并集 减去  s1和s2的交集   #s1和s2的位置互换不会影响最后结果

如: 只购买了 iphone7和iphone8中 一个型号的人  :

iphone7 = {‘alex‘, ‘rain‘, ‘jack‘, ‘old_driver‘ }
iphone8 = { ‘alex‘, ‘shanshan‘, ‘jack‘, ‘old_boy‘ }

print(iphone7.symmetric_difference(iphone8))

#输出结果为:{‘old_boy‘, ‘shanshan‘, ‘rain‘, ‘old_driver‘}

子集关系:

子集1:  s1.issubset( s2 )   #判断s1是否为s2的子集,

子集2:  s1<=s2;

超集1:  s1.issuperset( s2 )    # 判断s1是否为s2的超集(父集)

超集2:  s1>= s2

判断关系:

s1.isdisjoint( s2)    # 判断两个集合是否不相交

in,,not in:    # 判断某元素是否在集合内

== ,!= :     # 判断两个集合是否相等

s1.difference_update(s2)   # 把s1和s2差集的结果赋值给s1。

s1.intersection_update( s2 )   #把s1和s2交集的结果赋值给s1。



原文地址:https://www.cnblogs.com/neozheng/p/8317459.html

时间: 2024-10-12 12:21:30

元祖、hash了解、字典、集合类型的相关文章

python-数据类型,元祖,列表,字典,文件操作篇

python----数据类型,元祖,列表,字典,文件操作篇1.布尔类型:Ture False 非0即真 非空即真 空(None a=''空字符串) 条件判断返回的都是True或者False2.字符串: 注:字符串的所有操作,不改变原字符串值 常用的操作方法 .count() .find() #回不存在的元素,返回-1 .join() .encode() .decode()#bytes类型才有的(bytes:二进制类型) .endswith('.txt')#字符串是否以xx结尾 startswit

Python三种基础数据类型:列表list,元祖tuple和字典dict

Python的三种基本数据类型,列表list,元祖tuple和字典dict 列表List:python最基础的数据类型,列表内的数据项不需要具有相同的类型,可以包含重复值.列表包括两个模块,元素及对应的索引,其中索引正值表示从头开始取,负值表示倒项取数. 操作:索引.切片.加.减.乘.检查成员 索引:查看某个索引的值my_list[1],查看系列的值my_list[1:5] 切片:my_list[1:5],注意:my_list[::n]该用法表示从取的元素开始取第n元素,依次类推 加和乘:表示对

swift_简单值 | 元祖 | 流程控制 | 字符串 | 集合

//: Playground - noun: a place where people can play import Cocoa var str = "Hello, playground" //这里先提及下, //Swift中的属性的定义 //属性名首字母只能是字母,下划线 //首字母后也只能是数字,字母,下划线 /****************************************常量与变量**/ /**************常量的定义*/ //语法上就是使用let关

python----基础之数据类型(元祖,字典,集合)

元祖 元祖的定义和特性 定义:列表已经介绍过,现在介绍一种与类表相似的类型,叫做元祖,只不过把[]改成(). 特性: 1.可以存放多个指 2.不可变 3.按照从左往右的顺序定义元祖的元素,下标从0开始依次顺序访问,有序 元祖的创建与常用类型 1 # 创建 2 >>> we = (11, 22, 33, 44, 55) 3 >>> we 4 (11, 22, 33, 44, 55) 5 >>> type(we) 6 <class 'tuple'&g

06 列表、字典、集合、元祖的内置方法

1.列表内置方法l=[1,2,3,4,5,6,7] res = l.clear() print(res)#None 因此.clear方法没有返回值 print(l)#[] 现在列表为空了 将列表反转reserse() l = [1,2,1,3,4,5,6,7] l.reverse() print(l)#[7, 6, 5, 4, 3, 1, 2, 1] sort()排序l1 = [43,6,1,7,99] l1.sort(reverse=False) # 可以通过指定参数来修改默认的拍讯规则(降序

python中的元祖与字典

元祖的介绍 python中的元祖与列表类似,不同之处在于元祖的元素不可修改.元祖使用小括号,列表使用方括号 <1>访问元祖                                    执行结果: <2>修改元祖                                         执行结果: 说明:python中不允许修改元祖的数据,包括不能删除其中的值 <3>元祖的内置函数count.index index和count与字符串和列表中的用法相同 例

列表和元祖

在python中,最基本的数据结构为序列.序列中的每个元素都有编号,即位置或索引.其中第一个元素的索引为0,第二个元素的索引为1,依次类推.从0开始指的是相对于序列开头的偏移量.用负索引表示序列末尾元素的位置. 序列概述 Python三种序列:列表.元祖.字符串. 列表和元祖的不同在于,列表是可以修改的,而元祖不可以.(想想为什么有的内置函数返回元祖的原因.) 在自己编写程序的时候,几乎所有的情况都可使用列表来代替元祖.一种情况例外,将元祖作用作字典键.(字典键是不允许修改的.) 列表用中括号来

如何表示只有一个元素的元祖

在Python中我们经常会用到几种序列类型,列表(List),元祖(Tuple)与字典(Dict) 其中元祖使用小括号来表示,且不可以修改元素值 t = ('a', 'b', 1, 2) 但是 当元祖只有一个元素的时候比较特殊,用type()打印结果 t = (1) print(type(t)) # <class 'int'> 明明是元祖的格式,为什么识别为 int 型呢 这是因为当只有一个元素的时候,对于int型或字符型来讲,只是相当于运算的一个优先级,系统没有当作元祖的格式 如果要表示只有

字符串,列表,元祖,字典,集合的内置方法

一. 数字类型 1.1 整型int   1.用途: 记录年龄\等级\各种号码 2.定义方式: age=18 age=int(18) x=int('123') #只能将纯数字的字符串转换成整型 print(type(x)) print(int(3.7)) #这个小数部分没有了 3.常用操作+内置的方法           ( 赋值\比较\算术) 该类型总结:   存一个值  ;  不可变(1.可变:值变,id不变.可变==不可hash 2.不可变:值变,id就变.不可变==可hash) 判断是否哈