字典、集合与字符串——Python基础语法

最新推荐文章于 2023-02-11 14:02:10 发布

黄乐荣

最新推荐文章于 2023-02-11 14:02:10 发布

阅读量333

点赞数 1

分类专栏： Python

本文链接：https://blog.csdn.net/weixin_43717681/article/details/104064439

版权

Python 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

Python3中有六个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple(元组）、Set（集合）、Dictionary（字典）

不可变数据（3个）：Number、String、Tuple
可变数据（3个）：List、Dictionary、Set

字典

基本概念

字典是无序的对象集合，使用键-值（key-value）对存储，具有极快的查找速度，字典不支持下标
键（key）必须使用不可变类型
同一个字典中，键（key）必须是唯一的
字典的每个键值key=>value对用冒号：分割，每个键值对之间用逗号，分割，整个字典包括在==花括号{ }==中，格式如下所示：
（dic={key1:value1,key2:value2}）
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取

常用方法

方法	描述
keys（）	返回字典中键的列表
values（）	返回字典中值得列表
items（）	返回字典的键和相应值
clear（）	删除字典中的所有条目
copy（）	返回字典高层结构的一个拷贝，但不复制嵌入结构，而只复制对那些结构的应用
update（x）	用字典中的键值对更新字典内容
get（x[,y]）	返回键x，若未找到该键返回none，若提供y，则未找到x时返回y

字典键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一

dict = { ' a ' : 1, ' b ' : 2, ' b ' : ' 3 '}
dict[ ' b ']
输出：' 3 '
dict
输出： { ' a ' : 1,  ' b ' : ' 3 '}

创建字典：基础语法方法

字典中值可以取任何数据类型，但键必须是不可变的，如字符串、数字或元组（如：dict = { 'Alice ': '2112 ',‘beth’:‘3434’,‘Cecil’:‘5665’}）
也可这样创建字典
（如：dict1={‘abc’:234}
dict2={‘abc’:123,98.6:37} ）

创建字典：dict函数

使用dict函数，通过其他映射（比如字典）或者（键，值）序列对创建字典

items=[('name','Charry'),('age',42)]#方括号代表列表，圆括号代表里边有两个元组，每个元组有两个元素，这两个元素转换时就变为了键和值
d=dict(items)
print(d)
输出：{‘name’:'Charry','age':42}

dict函数也可以通过关键字参数来创建字典

d=dict(name=‘Charry',age=42)
print(d)
输出：{'name':'Charry','age':42}

字典元素修改、添加与删除

当以指定“键”为下标为字典元素赋值时，有两种含义：1、若改键存在，表示修改该键对应的值；2、若不存在，表示添加一个新元素
使用字典对象的update（）方法可以将另一个字典的元素一次性全部添加到当前字典对象，如果两个字典中存在相同的键，则以另一个字典中的值为准对当前字典进行更新

sock = { ' Ip ': '192.168.1.1 ', 'port ': 80}
scok.update({ ' Ip ': '192.168.1.1 ','protocol ':'TCP '})
print(sock)
输出：{ ' Ip ': '192.168.1.1 ', 'port ': 80'，protocol ' : ' TCP  '}

可以使用字典对象的pop（）删除指定“键”对应的元素，同时返回对应的“值”
popitem（）方法用于删除字典的一个键对，并返回一个包含两个元素的元组，其中的两个元素分别是字典元素的键和值
也可以使用del删除指定的值对应的元素

增加：

dict={'name':'YYQX','age':20,'gender':'男'}
dict['id']='ZaiZi'
print(dict)
输出：
{'name': 'YYQX', 'age': 20, 'gender': '男', 'id': 'ZaiZi'}

删除：

del()/del:删除字典或删除字典中指定键值对
clear（）：清空字典

dict={'name':'YYQX','age':20,'gender':'男'}
dict['id']='ZaiZi'
print(dict)
del  dict['id']
print(dict)

查找：

key值查找
get（）：字典序列.get（key，默认值）。如果当前查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None
keys（）
values（）
items（）

dict={'name':'YYQX','age':20,'gender':'男'}
print(dict['name'])
print(dict.get('name'))
print(dict.get('id','ZaiZi'))
print(dict.get('id'))
print(dict.keys())
print(dict.values())
print(dict.items())
输出：
YYQX
YYQX
ZaiZi
None
dict_keys(['name', 'age', 'gender'])
dict_values(['YYQX', 20, '男'])
dict_items([('name', 'YYQX'), ('age', 20), ('gender', '男')])

循环遍历：

遍历字典的key
遍历字典的value
遍历字典的元素
遍历字典的键值对

dict={'name':'YYQX','age':20,'gender':'男'}
for key in dict.keys():
    print(key)
for value in dict.values():
    print(value)
for item in dict.items():
    print(item)
for key,value in dict.items():
    print(f'{key}={value}')    
输出：
name
age
gender
YYQX
20
男
('name', 'YYQX')
('age', 20)
('gender', '男')  
name=YYQX
age=20
gender=男

集合

概述

Python集合是无序、可变的容器对象，所有元素放在一对大括号中，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，不允许重复
集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据，包含列表等可变类型数据的元组也不能作为集合的元素
集合中的元素是无序的，元素存储顺序和添加顺序并不一致
集合不支持使用下标直接访问特定位置上的元素，也不支持使用random中的choice（）函数从集合中随机选取元素，但支持使用random模块中的sample（）函数随机选取部分元素

set（集合）

set和dict类似，也是一组key的集合，但不存储value。在set中，没有重复的key。
set是无序的

创建：

创建集合使用{}或set{}，但是如果要创建空集合只能使用set（），因为{}用来创建空字典

set1=set()
print(type(set1))
set2={}
print(type(set2))
set3={10,20,30,40,50}
print(set3)
set4={10,20,30,10,20,30,40,50}
print(set4)
set5={'abcdefgh'}
print(type(set5))
print(set5)
set6=set('abcdefgh')
print(set6)
print(type(set6))
输出：
<class 'set'>
<class 'dict'>
{40, 10, 50, 20, 30}
{40, 10, 50, 20, 30}
<class 'set'>
{'abcdefgh'}
{'b', 'f', 'e', 'c', 'a', 'g', 'd', 'h'}
<class 'set'>

增加：

add（）：s.add(x):将元素x添加到集合s中，如果元素已存在，则不进行任何操作
update（）：s=update(x):将x的元素添加到集合s中，x可以是列表、元组、字典等

set1={10,20}
set1.update([30,40,50])
print(set1)
set1.update([100])
print(set1)
输出：
{40, 10, 50, 20, 30}
{100, 40, 10, 50, 20, 30}
#set1.update(100）该语句系统会报错，因为100是一个int型，而不是一个序列

删除：

remove（）：删除集合中的指定数据，如果数据不存在则报错
discard（）：删除集合中的指定数据，如果数据不存在也不报错
pop（）：随机删除集合中的某个数据，并返回这个数据

set1={10,20,30,40,50}
set1.remove(10) #报错
print(set1)
set1.discard(60) #不报错
print(set1)
del_num=set1.pop()
print(del_num)
print(set1)
输出：
{40, 50, 20, 30}
{40, 50, 20, 30}
40
{50, 20, 30}

查找：

in：判断数据在集合序列
not in：判断数据不在集合序列

set1={10,20,30,40,50}
print(10 in set1)
print(10 not in set1)
输出：
True
False

字符串

概述

字符串是用双引号或者单引号括起来的一个或多个字符
字符串可以保存在变量中，也可以单独存在
字符串属于不可变对象，所有方法都是返回处理后的字符串或者字节串，不对原字符串进行任何修改
Python没有单独的字符类型，一个字符就是长度为1 的字符串
可以用type（）函数测试一个字符串类型
字符串是一个字符序列：字符串最左端位置标记为0。从最右端为-1

转义

Python语言转义符：.在字符串中进行转义，表示该字符\与后面相邻的一个字符共同组成了一个新的含义
输出带有引号的字符串，可以使用转义符

print("\"你好\"")
输出："你好”

如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

print('yyqx\n')
print(r'YYQX\n')
输出：
yyqx

YYQX\n

字符串操作

单个索引辅助访问字符串中的特定位置

str1="Hello,world"
print(str1[1])

Python中字符串索引从0开始，一个长度为L的字符串最后一个字符为L-1
Python同时允许使用负数从字符串右边末尾位置向左边进行反向索引，最右侧索引是-1
可以通过两个索引值确定一个位置范围，返回这个范围的子串（< string >[ < start>:< end >：步长]
start和end都是整数型数值，这个子序列从索引start开始直到索引end结束（不包括end位置）
字符串可以通过+或*进行连接

加法操作将两个字符串连接成为一个新的字符串
乘法操作生成一个尤其本身字符串重复连接而成的字符串
x in x:如果x是s的子串，返回true，否则返回false
str[N:M]:切片，返回子串

len（）函数能返回一个字符串的长度
大多数数据类型都可以通过str函数转换为字符串
可以通过for和in组成的循环来遍历字符串中每个字符

字符串处理方法

< string >.upper():字符串中小写转大写
< string >.lower():字符串中大写转小写
< string >.strip()：删除字符串两侧空白字符去除指定字符
       lstrip：删除字符串左侧空白字符
       rstrip：删除字符串右侧空白字符
< string >.split():按指定字符分割字符串为数组
< string >.join():连接两个字符串序列
< string >.find():搜索指定字符串
< string >.replace:字符串替换
< string >.capitalize:将字符串第一个字符大写
< string >.title:将字符串每个单词首字母大写
< string >.swapcase:大写转换为小写，小写转换为大写
< string >.startswitch()\endswitch():检查字符串是否是以指定字符串substr开头或结束，是则返回True
for < var> in < string >:字符串迭代
< string >.replace(str1,str2,[,max]):把将字符串中的str1替换成str2，如果max指定，则替换不超过max次
< string >.maketrans():创建字符映射的转换表
< string >.translate(str):根据str给出的映射转换表转换string字符
< string >.ljust(长度，填充字符):返回一个原字符串左对齐，并使用fillchar填（默认空格）充至对应长度width的新字符串，
rjust（）、center（）类似
< string >.isalpha():如果字符串至少有一个字符并且所有字符都是字母，则返回True，否则False
< string >.isdigit():如果字符串只包含数字则返回True，否则返回False
< string >.isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
< string >.isspacel():如果字符串中只包含空白（空格），则返回True

相关代码

a='hello Python'
print(a)
print(type(a))

a='hello ' \
  'Python'#直接敲回车
print(a)
print(type(a))

b="Hello Python"
print(b)
print(type(b))

c='''Hello
Python'''  #三引号回车不会额外添加任何字符
print(c)
print(type(c))

c="I'm Tom"
print(c)

c='I\'m Tom'
print(c)
输出：
hello Python
<class 'str'>
hello Python
<class 'str'>
Hello Python
<class 'str'>
Hello
Python
<class 'str'>
I'm Tom
I'm Tom

str='0123456789'
print(str[2:5:1]) #234
print(str[2:5:2]) #24
print(str[2:5]) #234
print(str[:5]) #01234
print(str[2:]) #23456789
print(str[::-1]) #9876543210
print(str[-4:-1]) #678 下标-1代表最后一个数据，一次向前类推
print(str[-4:-1:-1]) #不能选取出数据，从-4到-1开始，选取方向为从左到右，但是-1步长，为从右向左
#如果选区方向和步长方向有冲突，则无法选取数据
print(str[-1:-4:-1]) #987

mylist='hello'
mylist.rjust(10,'1')
'11111hello'
mylist.ljust(10,'1')
'hello11111'
mylist.center(10,'1')
'11hello111'

mystr='It is a virus'
print(mystr.startswith('It'))
print(mystr.startswith('I'))
print(mystr.endswith('Y'))
print(mystr.endswith('virus'))
print(mystr.endswith('s'))
输出：
True
True
False
True
True

查找：

find（）：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1
语法：字符串序列.find(子串，开始位置下标，结束位置下标)
index（）：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常
语法：字符串序列.index(子串，开始位置下标，结束位置下标)
rfind():和find（）功能相同，但查找方向为右侧开始
rindex():和index（）功能相同，但查找方向为右侧开始
count():返回某个子串在字符串中出现的次数

YYQX='Yyqx XiZi AXi YangZai ZaiZi Yyqx XiZi AXi YangZai'
print(YYQX.find('Yyqx')) #0
print(YYQX.find('Yyqx',15,40)) #28
print(YYQX.find('yyqx')) # -1
print(YYQX.count('AXi')) # 2
print(YYQX.rindex('ZaiZi')) # 22
print(YYQX.index('ZaiZi')) # 22
print(YYQX.rfind('YangZai')) # 42
print(YYQX.find('YangZai')) #14

修改：

replace（）:替换
语法：字符串序列.replce(旧子串，新子串，替换次数)
split（):按照指定字符分割字符串
语法：字符串序列.split(分割字符，num)
num表示分割字符出现的次数，即将来返回数据个数为num+1个
join（）：多个字符合并为一个新的字符
语法；字符或子串.join(多字符串组成的序列)

YYQX='Yyqx XiZi AXi YangZai ZaiZi Yyqx XiZi AXi YangZai'
new_YYQX=YYQX.replace('Yyqx','yyqx')
print(new_YYQX) 
#yyqx XiZi AXi YangZai ZaiZi yyqx XiZi AXi YangZai
print(YYQX)
#Yyqx XiZi AXi YangZai ZaiZi Yyqx XiZi AXi YangZai
new_YYQX1=YYQX.replace('Yyqx','yyqx',1)
print(new_YYQX1) 
#yyqx XiZi AXi YangZai ZaiZi Yyqx XiZi AXi YangZai
#字符串是不可变类型//调用replace函数后，原有字符串并未修改，修改后的数据是函数的返回值

YYQX12='Yyqx and XiZi and AXi and YangZai and ZaiZi'
new_YYQX12=YYQX12.split('and')
print(new_YYQX12)
#['Yyqx ', ' XiZi ', ' AXi ', ' YangZai ', ' ZaiZi']
#分割后，返回一个列表，丢失分割字符
new_YYQX121=YYQX12.split('and',2)
print(new_YYQX121) 
#['Yyqx ', ' XiZi ', ' AXi and YangZai and ZaiZi']

list1=['aa','bb','cc']
new_list1='---'.join(list1)
print(new_list1) 
#aa---bb---cc

黄乐荣

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字典、集合与字符串——Python基础语法

字典基本概念字典是无序的对象集合，使用键-值（key-value）存储，具有极快的查找速度键（key）必须使用不可变类型同一个字典中，键（key）必须是唯一的字典的每个键值key=>value对用冒号：分割，每个键值对之间用逗号，分割，整个字典包括在花括号{}中，格式如下所示：（dic={key1:value1,key2:value2}）常用方法方法描述...
复制链接

扫一扫

专栏目录