字符串,列表,元组,字典,集合

本文详细介绍了Python中的五种主要数据结构:字符串、列表、元组、字典和集合。内容涵盖它们的定义、特点、操作方法以及彼此之间的对比。例如,字符串的索引、切片、查找、拆分和编码,列表的增删改查及排序,元组的创建与访问,字典的添加、删除和修改操作,以及集合的添加、删除和关系运算。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

目录

存储类型

一,字符串

1.字符串的索引(index)

 2.字符串切片:

3.字符串的查找

4.字符串的拆分

5.字符串的替换

6.字符串的修饰

7.字符串的变形

8.字符串的判断

9.字符串的编码

二,列表

1.通过索引获取列表中的元素:

2.列表的循环遍历

3.列表的添加

4.列表的删除

5.列表的修改和查找

6. 列表的排序

7.列表的深浅拷贝

三,元组

 1.创建元组和查看类型

2,访问元组

3.修改元组

4元组的遍历

5.元组一个逗号的魅力

四,字典

1.字典的增加操作   

2.删除操作

3.修改操作

4.查找操作

五,集合

1.添加操作

2.删除操作

3.遍历集合

4.关系:

六,对比


存储类型

名称 定义 格式

字符串

字符串是一个有序的,不可修改的,元素以引号包围的序列。

python字符串的定义:双引号或者单引号中的数据,就是字符串;字符串和字符串之间可以想加

 

列表

列表是一个有序的,可修改的,元素以逗号分割,以中括号包围的序列。

列表的索引和字符串的索引类似,但不完全相同,因为列表可以修改,所以我们可以通过列表的索引来修改列表。可变数据类型

变量名= [元素1,元素2,元素3,...]

元组

元组是有序的,不能修改。

  1. .通过()来定义:变量名=(1,2,3,4,) 。以逗号分割的,以小括号包围的序列。
  2. .通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst)      不可变数据类型

变量名=(1,2,3,4,)

字典

字典是一个无序的,可以修改的,元素呈键值对的形式,以逗号分割的,以大括号包围的序列;

字典是python基础数据类型当中唯一一个映射关系的数据类型;

由于字典无序,所以我们定义字典和字典生成之后的元素的顺序是不同的

可变数据类型

字典格式: 变量名={key;value,key:value...}

集合

集合与之前列表、元组类似,可以存储多个数据,但是这些数据是不重复的(具有自动去重功能)。

集合对象还支持交集(intersection),差集(difference)、并集和对称差集(sysmmetric_difference)

  1.  变量名={元素1,元素2,元素3,...}
  2. . 变量名=set(序列) 例如 变量名=set(元组,自动,字符串

一,字符串

1.字符串的索引(index)

 2.字符串切片:

切片的语法:[起始:结束:步长]      字符串[start:end:step]

             默认取法:字符串[start:end,step] 这三个参数都有默认值、start;默认值为0;end  默认值未字符串结尾元素;step  默认值为1

a = 'abcdefgh'
print(a[0:5:1])     #abcde
print(a[1:5:1])     #bcde
print(a[1:5:])     #bcde
print(a[1:5:2])     #bd
print(a[:5:])     #abcde
print(a[::])     #abcdefgh
print(a[::-1])     #hgfedcba  #步长从右向左
print(a[-8:-2:1])    #abcdef
print(a[-2:-8:-1])     #gfedcb   包头不包尾

ret = a[0:5:1]
print(ret)        #abcde

ret=a[3]        # d 是索引
print(ret)


a = 'abcdefgh'
print(type(a))
length=len(a)           #<class 'str'>
print(type(length))    # <class 'int'>
print(length)          # 8

3.字符串的查找

  

 

 

字符串的查找

count

计数功能,返回自定字符在字符串当中的个数

 

find

查找,返回从左第一个指定字符的索引,找不到返回-1

 

rfind

查找,返回从右第一个指定字符的索引,找不到返回-1

 

index

查找,返回从左第一个指定字符的索引,找不到报错

 

rindex

查找,返回从右第一个指定字符的索引,找不到报错

s='hello,world python'
ret =s.count('orl')
print(ret)      # 1
retx =s.count('l')
print(retx)        # 3
ret1=s.find('l')
print(ret1)           #2
ret2 = s.find('ld')
print(ret2)       #9   包含第查找的数
ret3= s.find('hhh')
print(ret3)     #  -1   找不到就返回-1  从左往右查找
ret4 = s.rfind('l')
print(ret4)            # 9 从右往左查找
ret5= s.rfind('hhh')
print(ret5)         # -1  找不到的返回 -1


s='hello,world python'
ret = s.index('l')
print(ret)            # 2 从左到右找
ret1=s.rindex('l')
print(ret1)        # 9 从右向左 找

 

4.字符串的拆分

字符串的分割

partition

把mystr以str分割成三部分,str前,str自身和str后

字符串的分割

splitlines

按照行分隔,返回一个包含各行作为元素的列表,按照换行符分割

字符串的分割

split

按照指定的内容进行分割

s='hello world python'
ret = s.partition('world')   #分成(前,本身,后)三部分
print(ret)                  #v('hello ', 'world', ' python')


s='hello\tworld\tpython'        #  \t 分割    \n 换行
ret = s.splitlines()
print(ret)               #['hello world python']
s='hello\tworld\tpython'        
ret = s.splitlines()
print(ret)               #  ['hello\tworld\tpython']


s='hello\nworld\npython'
ret = s.splitlines()   #  keepends=False  默认
print(ret)          #['hello', 'world', 'python']
ret = s.splitlines(keepends=True)   # 显示换行符
print(ret)         # ['hello\n', 'world\n', 'python']

s='hello world python'
ret=s.split('r')          # 去除分离字符,分成两部分,生成列表
print(ret)           # ['hello wo', 'ld python']
ret1=s.split('l')
print(ret1)         #['he', '', 'o wor', 'd python']

 

5.字符串的替换

字符串的替换

replace

从左到右替换指定的元素,可以指定替换的个数,默认全部替换

 

translate

按照对应关系来替换内容 from string import maketrans

s='hello world python'
ret = s.replace('o','0')   # 字符串用字符串替换
print(ret)                #  hell0 w0rld pyth0n
ret1 = s.replace('o','0',2)     # 2,为指定从左往右总共替换两个
print(ret1)               # hell0 w0rld python

s='hello world python'
intab = 'ol'   #o--->a   l---->e
outab = 'ae'
ret2=str.maketrans(intab,outab)
s1 = s.translate(ret2)
print(s1)

 

6.字符串的修饰

字符串的修饰

center

让字符串在指定的长度居中,如果不能居中左短右长,可以指定填充内容,默认以空格填充

 

ljust

让字符串在指定的长度左齐,可以指定填充内容,默认以空格填充

 

rjust

让字符串在指定的长度右齐,可以指定填充内容,默认以空格填充

 

zfill

将字符串填充到指定的长度,不足地方用0从左开始补充

 

format

按照顺序,将后面的参数传递给前面的大括号

 

strip

默认去除两边的空格,去除内容可以指定

 

rstrip

默认去除右边的空格,去除内容可以指定

 

lstrip

默认去除左边的空格,去除内容可以指定

s = 'hello'
print(s)
ret = s.center(10)
print(ret)               #  hello
ret1 = s.center(12,'*')
print(ret1)              #***hello****


s = 'hello'
print(s)
ret = s.ljust(13)
print(ret)               #hello        #
ret2 = s.ljust(13,'*')    
print(ret2)              #hello********#


s = 'hello'
ret= s.zfill(13)
print(ret)                 #00000000hello#

s='  hello python  '
ret = s.strip()      #默认去除两边的空格
print(ret)           #hello python#
s='***hello world****'
ret = s.strip('*')     #去除*
print(ret)              #hello world#  
s='  hello python  '
print(s)
ret = s.rstrip()
print(ret)          #  hello python#   去除右边的空格键
s='  hello python  '
ret=s.lstrip()
print(ret)          #hello python  #  去除左边的空格键
s='**hello python  '
ret = s.lstrip('*')
print(ret)          #hello python  #   去除左边的*


name = 'zs'
age=10
msg = '大家好!我叫{},今年年龄{}'.format(name,age)
print(msg)            #大家好!我叫zs,今年年龄10
msg = '大家好!我叫{0},今年年龄{0},住在那{1}'.format(name,age)
print(msg)        #大家好!我叫zs,今年年龄zs,住在那10

msg = '大家好!我叫{0},我叫{1},我叫{0},年龄{1}'.format('张三',18)
print(msg)     #大家好!我叫张三,我叫18,我叫张三,年龄18

print('大家好,我叫{name},住在{where},年龄{age}'.format(name='zs',where='bj',age=19))
        #大家好,我叫zs,住在bj,年龄19

print('大家好,我叫{name},住在{name},年龄{age}'.format(name='zs',age=19))
             #大家好,我叫zs,住在zs,年龄19


 #***   < 表示 向左对齐, ^ 表示居中对齐, >表示向右对齐      :[填充字符][对齐方式 <^>][宽度]
print('我叫{:*^5},年龄{:&<7}'.format('张三风',50))
    #我叫*张三风*,年龄50&&&&&

msg = '长方形的长是{:.2f},宽{:.3f},面积{:.2f}'
chang = 5/3
kuan = 9/4
area = chang*kuan
print(msg.format(chang,kuan,area))     # 长方形的长是1.67,宽2.250,面积3.75

 

7.字符串的变形

 

 

 

 

 

字符串的变形

upper

将字符串当中所有的字母转换为大写

lower

将字符串当中所有的字母转换为小写

swapcase

将字符串当中所有的字母大小写互换

title

将字串符当中的单词首字母大写,单词以非字母划分

capitalize

只有字符串的首字母大写

expandtabs

把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8

# s='hello python'
# ret=s.upper()
# print(ret)    #将所有的小写换成大写 #HELLO PYTHON
# s='HELLO PYTHON'
# ret = s.lower()
# print(ret)     #hello python  将大写改成小写

# s='Hello Python'
# ret = s.swapcase()
# print(ret)            #hELLO pYTHON  将大小写互换

# s='hello python'
# ret=s.title()
# print(ret)     #Hello Python  将每个单词首个字母大写

# s='hello python'
# ret=s.capitalize()
# print(ret)            #Hello python 将字符串的首个字母大写

# s='hello\tpython'
# ret = s.expandtabs()
# print(ret)          #hello   python  将\t转换为8个字符,
# s='hello\tpython'
# ret =s.expandtabs(tabsize=10)
# print(ret)        #hello     python#  空格数=tabsize-前面的字符数

 

8.字符串的判断

 字符串的判断

isalnum

判断字符串是否完全由字母或数字组成

 

isalpha

判断字符串是否完全由字母组成

 

isdigit

判断字符串是否完全由数字组成

 

isupper

判断字符串当中的字母是否完全是大写

 

islower

判断字符串当中的字母是否完全是小写

 

istitle

判断字符串是否满足title格式

 

isspace

判断字符串是否完全由空格组成

 

startswith

判断字符串的开头字符,也可以截取判断

 

endswith

判断字符串的结尾字符,也可以截取判断

 

split

判断字符串的分隔符切片

s='adbf123om'
s1 = s.isalnum()
print(s1)              #True  判断字符串是否有数字或字母组成
s2 ='num_123num'
s3 =s2.isalnum()
print(s3)          #False

s='bunm123nij'
s1=s.alpha()
print(s1)          #False  #判断字符串是否有字母组成
s='EVCmkmc'
s1=s.isalpha()
print(s1)         #True

s='123n4cid'
s1=s.isdigit()
print(s1)          #False    判断字符串是否有数字组成
s='12455'
s1=s.isdigit()
print(s1)           #True

s='HELLO PYTHON'
s1=s.isupper()
print(s1)         #True  判断字符是否是大写组成
s='hEllo pytHon'
s1 =s.isupper()
print(s1)             #False

# s='hEllo pytHon'
# s1 =s.islower()
# print(s1)             #False  判断字符是完全有小写字母组成
# s='asdvgbf'
# s1 = s.islower()
# print(s1)                #True

s='Hello Python'
s1=s.istitle()
print(s1)           #True   判断每个单词的首字母是否大写
s='Hello python'
s1= s.istitle()
print(s1)        #False

# s= '    '
# s1=s.isspace()
# print(s1)          #True   判断字符串是否有空格组成
# s='  s   '
# s1 =s.isspace()
# print(s1)            #False

# s='hello world'
# s1=s.startswith('lo')
# print(s1)              #False    判断开头是否有指定的字符开头
# s='hello world'
# s1=s.startswith('h')
# print(s1)                 #True

# s = 'hello world'
# s1=s.endswith('ld')
# print(s1)          #True  判断末尾是否是指定字符
s = 'hello world'
s1=s.endswith('o')
print(s1)            #False
s = 'hello world'
s1=s.endswith('w',3,6)
print(s1)              #False
ret=s.endswith('w',3,7)
print(ret)               #True  包头不包尾

s='hello world'
s1=s.split('o')       #分离并消除  生成列表
print(s1)                #['hell', ' w', 'rld'] 

 

9.字符串的编码

encode是编码,将字符串转换成字节码。str-->byte
decode是解码 ,将字节码转换成字符串。 byte-->str

s='我'
# ret = s.encode()            #默认编码表
# print(ret)              #  b'\xe6\x88\x91'
# ret1= ret.decode()
# print(ret1)                 #  我
# s='我'
# ret2=s.encode(encoding="gbk")
# print(ret2)                  #b'\xce\xd2'
# ret3 = ret2.decode(encoding='gbk')  #指定什么编码表就用什么编码解,否则报错
# print(ret3)                          #我

10.   len()   ord()   chr()


# ret=len('中国')
# print(ret)           #2

# print(ord('A'))     #65
# print(chr(65))          #A

二,列表

1.通过索引获取列表中的元素:

# name= ['zs','历史',1]
# print(name)             #['zs', '历史', 1]
# print(type(name))       #<class 'list'>
# ret = name[1]      #1为指定位置
# print(ret)       #历史

2.列表的循环遍历

name= ['zs','历史',1]
for i in name:
    print(i)

#输出:
zs
历史
1

 

 

 

列表的添加

append

追加,在列表的尾部加入指定的元素

 

extend

将指定序列的元素依次追加到列表的尾部(合并),不会去重复内容

 

insert

将指定的元素插入到对应的索引位上,注意负索引倒序插入,超过索引就会在末尾插入

 

 

列表的删除

pop

弹出,返回并删除指定索引位上的数据,默认删除索引为-1的数据(从右向左删除)

 

remove

从左往右删除一个指定的元素

 

del

删除整个列表或列表的数据,del是python内置功能,不是列表独有的

列表的查找

注:列表没有find方法

count

计数,返回要计数的元素在列表当中的个数

 

index

查找,从左往右返回查找到的第一个指定元素的索引,如果没有找到,报错

列表的排序

reverse

顺序倒序

 

sort

按照ascii码表顺序进行排序

 

3.列表的添加

append、insert、extend方法、’+’ 加法     join()


lst= ['zs','历史',1]
lst.append('白骨精')
print(lst)
lst.insert(1,'袭人')   #指定位置添加
print(lst)          #['zs', '袭人', '历史', 1]
lst.extend('凯伦')
print(lst)             #['zs', '历史', 1, '凯', '伦']
lst1=['赵云','马超','秦琼']
lst.extend(lst1)
print(lst)           #['zs', '历史', 1, '凯', '伦', '赵云', '马超', '秦琼']
lst2= lst +lst1
print(lst2)          #['zs', '历史', 1, '凯', '伦', '赵云', '马超', '秦琼']

s='hello'
s1='-'.join(s)
print(s1)           #  h-e-l-l-o

 

4.列表的删除

pop、remove、 clear、del 函数

# lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
# lst.pop(0)      #指定位置删除索引,若没有就报错
# print(lst)           # ['卢俊义', '张顺', '吕布', '悟空', '平儿']
# lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
# lst.remove('张顺')    #根据内容删除
# print(lst)           #['聂赫留朵夫', '卢俊义', '吕布', '悟空', '平儿']

lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
lst.clear()      # 删除里列表面内容
print(lst)      #[]

lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
del lst      #清空内存
print(lst)      #报错

5.列表的修改和查找

               修改使用索引 lists[0]=’xx’

lst= ['许诸','荀彧','徐庶','鲁肃']
lst[0]='吕布'      #指定替换
print(lst)          #['吕布', '荀彧', '徐庶', '鲁肃']

              查找操作:

             1.使用索引,2.index()方法,3.count()统计,4.切片

name_list=['薛宝钗','春','夏','秋','冬']
name=name_list[0]       # 通过索引查找
print(name)          #薛宝钗

list=['笔','墨','纸','砚']
num= list.count('纸')    #查找内容个数
print(num)        #1
index=list.index('纸')      #查找内容位置
print(index)            #2
ret= list.index('墨',1,3)      #(查找内容,开始位置,结束位置)
print(ret)                   #1

length=len(list)       #查元素个数
print(length)         #4


lst=['a','d','w',3,'h','u']
ret = lst[1:4:1]           #[开启位置,终止位置,步长]
print(ret)                 #['d', 'w', 3]

6. 列表的排序

         sort、reverse

lst=['kaiwen','maliya','rula','duone']
lst.sort()        #升序排列   默认reverse = False
print(lst)          #['duone', 'kaiwen', 'maliya', 'rula']

lst.sort(reverse=True) #降序排列
print(lst)              #['rula', 'maliya', 'kaiwen', 'duone']

lst.reverse()     #翻转
print(lst)        #['duone', 'rula', 'maliya', 'kaiwen']

7.列表的深浅拷贝

   浅拷贝  cope :修改一层浅拷贝并不能修改内容,修改第二层,浅拷贝也被修改

l1=[1,2,['霍金','季羡林','anney']]
ret = l1[2][2] #获取anney
print(ret)          #anney
l2=l1.copy()
print(l1,id(l1))          # [1, 2, ['霍金', '季羡林', 'anney']] 18152200
print(l2,id(l2))          # [1, 2, ['霍金', '季羡林', 'anney']] 18171912

l1=[1,2,['霍金','季羡林','anney']]
l2=l1.copy()
l2[1]=222                  # 修改第一层内容
print(l1,id(l1))         #[1, 2, ['霍金', '季羡林', 'anney']] 12077064
print(l2,(id(l2)))       #[1, 222, ['霍金', '季羡林', 'anney']] 12057352

l1=[1,2,['霍金','季羡林','anney']]
l2=l1.copy()
l2[2][0]='唐三'          #修改第二层
print(l1,id(l1))       #[1, 2, ['唐三', '季羡林', 'anney']] 10877704
print(l2,id(l2))       #[1, 2, ['唐三', '季羡林', 'anney']] 10897416

      

     深拷贝    导入 copy 模块。第一层,第二层都改了

Import copy

copy.deepcopy()

import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
print(l1,id(l1))        #[1, 2, ['霍金', '季羡林', 'anney']] 18986184
print(l2,id(l2))        #[1, 2, ['霍金', '季羡林', 'anney']] 18986696
 
import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
l2[0]='11111'
print(l1,id(l1))     #[1, 2, ['霍金', '季羡林', 'anney']] 18920648
print(l2,id(l2))     #['11111', 2, ['霍金', '季羡林', 'anney']] 18921160


import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
l2[2][0]='唐三'
print(l1,id(l1))          #[1, 2, ['霍金', '季羡林', 'anney']] 18855112
print(l2,id(l2))          #[1, 2, ['唐三', '季羡林', 'anney']] 18855624

 

三,元组

 1.创建元组和查看类型

tup = (1,2,3,4,5,6)
print(tup)               #(1, 2, 3, 4, 5, 6)
print(type(tup))          #<class 'tuple'>


lst=[1,2,3,4,'s','f',5]
tup = tuple(lst)        #列表转换成元组
print(tup)             #(1, 2, 3, 4, 's', 'f', 5)

2,访问元组

#单元组访问
tup=(1,2,3,4,'s','f',5,'hello')
print(tup[0])    #1
print(tup[-2])     #5
print(tup[0:4])    #(1, 2, 3, 4)
print(tup[0:6:2])    #(1, 3, 's')  从左向右,隔一个取一个
print(tup[:4])     #(1, 2, 3, 4)
print(tup[0:])     #(1, 2, 3, 4, 's', 'f', 5, 'hello')
print(tup[::])       #(1, 2, 3, 4, 's', 'f', 5, 'hello')
print(tup[-1:-6:-2])  #('hello', 'f', 4)    从右向左隔一个取一个

#多维元组访问
s=(('拿破仑',1),('迈顿',2),('白起',3))
print(s[0])         #('拿破仑', 1)
print(s[1][0])      #迈顿

#多个变量来接受元组
tup=('拿破仑','迈顿','白起')
name1,name2,name3=tup
print(name1)        #拿破仑
print(name2)        #迈顿
print(name3)        #白起

3.修改元组

tup = ('zs',1,'方鸿渐',['白骨精','貂蝉','西施'])
# tup[0]='范蠡'
# print(tup)         #报错

tup[3].append('范蠡')
print(tup)      #('zs', 1, '方鸿渐', ['白骨精', '貂蝉', '西施', '范蠡'])


tup[3].insert(1,'孙悟空')
print(tup)      #('zs', 1, '方鸿渐', ['白骨精', '孙悟空', '貂蝉', '西施'])

4元组的遍历

s=(('拿破仑',1),('迈顿',2),('白起',3))
for s1 in s:
    print(s1)
    for s2 in s1:
        print(s2)

#输出:
('拿破仑', 1)
拿破仑
1
('迈顿', 2)
迈顿
2
('白起', 3)
白起
3

for name,num in  s:
    print(name)
    print(num)

输出:
拿破仑
1
迈顿
2
白起
3

for name,num in  s:
    print(name,num)

输出 
拿破仑 1
迈顿 2
白起 3

5.元组一个逗号的魅力

元组的查找

index

从左往右返回第一个遇到的指定元素的索引,如果没有,报错

 

count

返回元组当中指定元素的个数

# tup=('1')
# print(type(tup))      #<class 'str'>

tup = (1,)
print(type(tup))       #<class 'tuple'>

tup=(1)
print(type(tup))         #<class 'int'>

tup=('a','s','f','q','z','a','g','q')
print(tup.index('q'))     #3
#print(tup.index('a',1,6))   #5  (查找内容,从1到6范围)
ret=tup.index('a',1,len(tup))
print(ret)           #5

print(tup.count('a'))         #2

 

四,字典

dic={'name':'孙悟空','age':1000,'height':60}
print(dic)             #{'age': 1000, 'height': 60, 'name': '孙悟空'}
print(type(dic))       #<class 'dict'>

1.字典的增加操作   

       通过key : info[key]= value       

       Setdefault(key,default_value)

dic={'name':'孙悟空','age':1000,'height':165}
dic.setdefault('weight',50)    #添加  ,用逗号隔开
print(dic)                 #{'height': 165, 'age': 1000, 'name': '孙悟空', 'weight': 50}

dic.setdefault('where','花果山')
print(dic)             #{'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}

2.删除操作

 

字典的删除

pop

弹出,返回并删除指定键对应的值

 

popitem

随机弹出一个键值元组,这里随机的原因是因为字典无序

 

clear

清空字典

 

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
dic.pop('age')   #非、删除指定的关键字的键值对
print(dic)         #{'where': '花果山', 'name': '孙悟空', 'height': 165}

dic.popitem()           #{'height': 165, 'where': '花果山', 'name': '孙悟空'}
print(dic)              #{'height': 165, 'age': 1000, 'where': '花果山'}随机删除一个

dic.clear()
print(dic)         #{}对字典进行清空 

del dic         #del 与 字典之间是空格隔开
print(dic)         #报错,删除内存

3.修改操作

              通过key来修改内容 info[key]=value

               update()方法

dic={'name':'孙悟空','age':1000,'height':60}
dic['age']=800        #更改
print(dic)              #{'name': '孙悟空', 'age': 800, 'height': 60}
  
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
# dic1={'name':'八戒','hobby':'美女'}
# dic.update(dic1)
# print(dic)        #{'age': 1000, 'hobby': '美女', 'height': 165, 'where': '花果山', 
                   'name': '八戒'}

dic1={'ability':'打妖怪','teacher':'唐三藏'}
dic.update(dic1)  #遇到重复关键字进行修改,不重复进行添加
print(dic)   #{'age': 1000, 'height': 165, 'ability': '打妖怪', 'name': '孙悟空', 
                     'teacher': '唐三藏', 'where': '花果山'}

4.查找操作

字典的取值

keys

返回一个包含字典所有key的列表

 

values

返回一个包含字典所有vaule的列表

 

get

以键取值,如果指定键不存在,默认返回None,可以指定返回内容

 

update

以字典格式更新指定键的内容,如果键不存在,创建键和值

 

items

返回字典键值呈元组形式的格式

 

len

测量字典,键值对的个数(整体)

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
name=dic['name']      #根据关键字查找找内容
print(name)        #孙悟空
name=dic.get('name')   #根据键获取值
print(name)            #孙悟空
name=dic.get('how')    #
print(name)           #  若关键字不存在返回None

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
key=dic.keys()     #获取所有key键
print(key)         #dict_keys(['height', 'age', 'name', 'where'])
print(type(key))        #<class 'dict_keys'>
value=dic.values()    #获取值
print(value)      #dict_values([1000, '花果山', '孙悟空', 165])
print(type(value))  #<class 'dict_values'>
item=dic.items()    #把字典中的键值转换成元组
print(item)  #dict_items([('where', '花果山'), ('height', 165), ('age', 1000), ('name', '孙悟空')])
print(type(item))   #<class 'dict_items'>

print(len(dic))      #4

字典的遍历字典的判断

in

判断指定的键是否在字典当中,即将被废除,之后我们python3用in

 

for ...in ...

通过for ... in ...:的语法结构,我们可以遍历字符串、列表、元组、字典等数据结构。

 

 

not in

判断指定的键是否不在字典当中

 

in

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
if 'name' in dic:      #判断name(即关键字)是否在字典中  
    print("xx")        #在输出xx
else:
    print('nono')      #不在输出nono
 
not  in

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
if 'name'  in dic:      #判断name(即关键字)是否在字典中
    print("xx")        #不在在输出xx
else:
    print('nono')      #在输出nono

for     in

dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for key  in  dic:
    print(key)     #输出关键字

for key  in dic.keys():
    print(key)


输出:
height
name
where
age


dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for value in dic.values():
    print(value)           #获取关键字的值

输出:
165
1000
孙悟空
花果山


dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for item in dic.items():           #获取所有键值对,以元组的形式返回
    print(item)

输出:
('name', '孙悟空')
('where', '花果山')
('height', 165)
('age', 1000)


for key,value  in  dic.items():
    print(key,value)

输出:

height 165
name 孙悟空
age 1000
where 花果山

五,集合

1.添加操作

    Add()、update()

set={'a',2,'寒冰'}
set.add('猪猪侠')    #添加
print(set)         #{'猪猪侠', 2, '寒冰', 'a'}

set={'a',2,'寒冰'}
set.update('霍雨浩','王冬')  #分离成每个字符
print(set)          #{2, '雨', '寒冰', '浩', '霍', 'a', '王', '冬'}

set={'a',2,'寒冰'}
set.update('ac','cd')  #自动消除重复的
print(set)             #{'a', 2, 'c', '寒冰', 'd'}

set={'a',2,'寒冰'}
set2={'ac','cd'}      #集合里添加集合
set.update(set2)
print(set)          #  {'ac', 2, 'cd', 'a', '寒冰'} 

2.删除操作

     pop、remove、clear、del

set={'唐三','沐白','朱竹青','奥斯卡'}
set.pop()       #随机删一个
print(set)       #{'唐三', '奥斯卡', '朱竹青'}


set={'唐三','沐白','朱竹青','奥斯卡','猪八戒'}
set.remove('猪八戒')  #指定删除
print(set)     #{'朱竹青', '唐三', '沐白', '奥斯卡'}
set.clear()       #清除集合内的内容
print(set)      #set()= 集合

del set
print(set)      #<class 'set'>

3.遍历集合

set={'唐三',2,'朱竹青','奥斯卡','猪八戒','ac'}
for i in set:
    print(i)

输出:
2
唐三
猪八戒
ac
奥斯卡
朱竹青

4.关系:

  1. 交集(&  或者 intersection) 取公共部分
  2. 并集。(| 或者 union) 取去除重复部分内容
  3. 差集。(- 或者 difference)取set1或者set2中除去公共部分的内容
  4. 反交集。(^ 或者 symmetric_difference)
  5. 子集。(< 或者 issubset)
  6. 超集。(> 或者 issuperset)
set1={1,2,3,4,'a','f',2,'d',2,'e'}
set2={3,4,'q','e','g',7,9}
print(set1)           #{1, 2, 3, 4, 'a', 'd', 'f', 'e'}
print(set2)          #'g', 3, 4, 7, 9, 'q', 'e'}
print(set1&set2)       #{3, 4, 'e'}
print(set1.intersection(set2))      #{'e', 3, 4}  交集

set1={1,2,3,4,'a','f','d','e'}
set2={3,4,'q','e','g',7,9}          #并集
print(set1|set2)       #{'q', 1, 2, 3, 4, 'd', 'g', 7, 'e', 9, 'f', 'a'}
print(set1.union(set2))#{'g', 1, 2, 3, 4, 7, 9, 'q', 'a', 'd', 'e', 'f'}
print(set1-set2)   #{'a', 1, 2, 'd', 'f'}     #差集
print(set1.difference(set2))       #{1, 2, 'a', 'd', 'f'}
print(set1^set2)      #{1, 2, 7, 9, 'a', 'q', 'd', 'g', 'f'}
print(set1.symmetric_difference(set2))  #{1, 2, 'f', 'g', 7, 9, 'd', 'q', 'a'}


set1={1,2,3,4,5,'a','d'}
set2={1,2,3,'a'}
print(set1<set2)          #False    子集
print(set1.issubset(set2))  #False   
print(set1>set2)          #True    超集
print(set1.issuperset(set2))   #True

六,对比

数据类型比较

字符串

列表

元组

字典

是否有序

是否可修改

方法多少

很多

一般

很少

较多

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值