Python 中的字符串（str）、字典（dict）详解及操作方法

时间：2021-08-22 14:13:10

一、字符串

在python中字符串是一种重要数据类型。其他数据类型分别为：

  1. 数字-number -------- int、long、float、complex这几种
  2. 字符串-string -------- "使用引号"引起来的都是字符串
  3. 元组-tuple ------------ (1,2)使用小括号引起来的元素，中间用逗号隔开.

    注意如果元组(v1, )中只有一个值，一定记得要用逗号隔开，不然就无法识别为元组了
  4. 布尔值-bool --------- True及False

    以上四个为Python中的不可变对象，创建后就不能改变的量-->指该变量指向内存中的值不能被改变，当改变某个变量时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址
5. 列表-list --------------- **[1, 2, 3] ['a', 'b', 'c']**中括号，里面的元素用逗号隔开
6. 字典-dict -------------- **{key1 : value1, key2 : value2}** 使用大括号＋键-值方式定义，键值之间使用 : 冒号，不同的键对值使用逗号分开

5、6皆为可变对象，指该对象所指向内存中的值可以被改变。

1.1 字符串的方法
  1. str.capitalize() 会将首字母大写
  2. str.count(x, start=None, end=None) 统计str中的指定字符x的个数，start和end为起始位和结束位
  3. str.center(num, [指定字符]) 将str字符串在num长度的字符中居中，str长度不够则第二个参数为填充字符。同 "{0:[填充字符]^[长度]}".format(str) 一样的效果
  4. str.endswith("tr") 判定str是否为指定参数，这儿为"tr"结尾，是返回True 否False
  5. str.find([指定字符]) 找到参数字符在str中的起始索引
  6. str.isalnum() str是否为阿拉伯数字、字符，是返回True
  7. str.isalpha() 是否为纯英文
  8. str.isdecimal() 是否为十进制数
  9. str.isdigit() 是否为整数
  10. str.isidentifier() 是否为合法标识符（变量名）
  11. str.islower() 字符串是否全部小写
  12. str.lower() 将字符串小写
  13. str.isupper() 字符串是否为大写
  14. str.upper() 将字符串大写
  15. '[分隔符]'.join([iterable]) 如"+".join(['1', '2', '3'])结果为'1+2+3' 分隔符的join方法参数为可循环对象
  16. str.ljust(num, '[填充符]') 扩展str长度到num，不够的位置使用填充符从右往左填充
  17. str_s.replace('s', 'S', 1) 替换目标字符，将小写s替换为大写S，只替换一个
  18. str.split(sep=None) 将字符按照sep参数分割，列表形式返回分割后的元素
  19. str.strip(chars=None) 重要默认移除字符串头和尾的 space、\n、\t ，或者移除指定参数字符
>>> str_test = '\n/home/user/lina  \t'

>>> str_test = str_test.strip()      #去除首尾的space \n \t

>>> str_test

'/home/user/lina'

>>> str_list = str_test.split('/')    #以 '/' 分割字符串

>>>str_list

['', 'home', 'user', 'lina']

>>> str_test .strip('/')   #去除首尾的‘/’

'home/user/lina'

>>>

二、字典

字典(dict)是python中唯一的一个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯一的，

在保存的时候, 根据key来计算出⼀一个内存地址然后将key-value保存在这个地址中。

这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key必须是可hash的,

如果你搞不懂什什么是可哈希, 暂时可以这样记, 可以改变的都是不可哈希的,

那么可哈希就意味着不可变. 这个是为了了能准确的计算内存地址⽽而规定的.

已知的可哈希(不可变)的数据类型: int, str, tuple, bool不可哈希(可变)的数据类型: list, dict, set（详见开头介绍python中的不可变对象）

字典其他语言中称为map，使用键-值{key:value}方式存储数据也让其具有极高的查找速度

相比于List、tuple为什么会有如此高的查找速度呢？

设想我们现在使用list、tuple来存储一个人的个人信息,一个列表存储姓名，另一个列表内用元组存其他信息，用列表索引对应
>>> p_name = ['lina', 'josh', 'alex', 'linda', 'david']

>>> p_info = [(22, 'student', 'UA), (32, 'musician', 'Germany'), (33, 'worker', 'Austrilia'), (26, 'artist', 'Russia'), ('54', 'politician', 'UA')]

>>>

假设我们要查找到某人的具体信息，那么我们就必须先从p_name中拿到他的索引index_var = p_name.index(var)，然后拿着索引index_var到p_info中去p_info[index_var]拿到具体信息，第一次查找时，我们必须遍历列表，这个过程列表元素少很快，当列表元素多了的时候，遍历就很浪费时间了，第二次查找时就是可以用二分法了。而当用字典来存储时，直接姓名哈希算法hash找到个人信息存储地址--->

>>> p_info = {'lina': (22, 'student', 'UA),

... 'josh': (32, 'musician', 'Germany'),

... 'alex': (33, 'worker', 'Austrilia'),

... 'linda': (26, 'artist', 'Russia'),

... 'david': ('54', 'politician', 'UA')}

>>> p_info['josh']

(32, 'musician', 'Germany')

这样通过名字作为索引，就可以一次直接查询到，不用去遍历整个keys，然后通过哈希算法根据key，算出value的存储地址直接拿到value。几乎不会随着字典的增大而查找速度变慢 =

注意：创建或者添加时，key是唯一的不可重复。

2.1字典的增
2.1.1直接通过 dict[索引] = value 方式增加

优点：简单方便   缺点：如果新增的key和已经存在的key重复，那就会直接更新该key对应的value

当然你也可以通过 key in dict 或者get()方法判断，key是否已经存在字典中
>>> dict1 = {'name': 'lina'}

>>> dict1['age'] = 24

>>>dict1

{'name': 'lina', 'age': 24}

>>>

>>> 'age' in dict1      #判断字典中是否存在该key存在返回True，不存在False

True

>>> dict1.get('name')  #通过字典的get()方法拿到对应的key的value

'lina'

>>> dict1.get('job')  #当key不存在时返回None

>>>
2.1.2 dict.setdefault('key', value) 设置，增加新key-value

相比于第一种方式，这样去增加值，当key不存在时，新增key-value，当key存在时，不做操作。避免了误操作修改了重要数据
>>> dict2 = {'name': 'lina'}

>>> dict2.setdefault('age', 23)    #setdefault()安全设置key-value

23

>>> dict2

{'age': 23, 'name': 'lina'}

>>> dict2.setdefault('name', 'alex')   #尝试用setdefault()设置已存在的key-value

'lina'

>>> dict2.get('name')   #可以看见，setdefault无法改变已经存在了的key-value

'lina'
2.2字典的删除
2.2.1 del dict[key] python内置函数del 删除

缺点：如果你不小心玩成del dict 这样，那你就完了，整个字典都给你删除了

2.2.2 dict.pop(key) 最常用的，标准删除格式。通过dict.pop函数，删除并返回value

安全删除建议使用

2.2.3 dict.popitem() 随机删除，当没看见

2.2.4 dict.clear() 清空字典所有元素
2.3字典的改、查
2.3.1 dict.updata(new_dict) 将一个新字典更新到原字典中，如果dict和new_dict 存在相同的key，就用新字典的key-value去更新原字典的value

2.3.2 dict[key]直接查询，缺点当key不存在时，会直接报错。建议使用dict.get(key) key存在直接返回value，不存在返回None
dict1 = {"k1": "v1",

         "k2": "v2",

         "k3": "v3"}

new_dict = {"k3": "vv3",

         "k4": "vv4"}

dict1.update(new_dict)

print(dict1)

#结果为：

{'k1': 'v1', 'k2': 'v2', 'k4': 'vv4', 'k3': 'vv3'}  #dict1中的k3-v3 更新为k3-vv3

#-------------------------------------------------------------------------------------------

#查

print(dict1["k1"])

print(dict1.get("k2")

#结果为

v1

v2
2.4 字典的遍历
2.4.1 按照keys进行遍历

语法：for key in dict:
>>> dict1 = {'a': 1, 'b': 2, 'c': 3}

>>> for key in dict1:

...     print("key:{0: <3}value:{1}".format(key, dict1.get(key)))

...

key:a  value:1

key:b  value:2

key:c  value:3
2.4.2 按照dict.items() 遍历

字典中的items 是一个个的元组，每一个元组是一个(key, valule) 的组合
dict1 = {"k1": 1,"k2": 2,"k3": 3}

for k,v in dict1.items():

    print(k,v)

#结果为

k3 v3

k1 v1

k2 v2
2.5 字典的输出
2.5.1 输出keys,， dict.keys()会输出一个由keys组成的dict_keys对象，是类似列表格式，可用list(dict.keys())转化为列表

2.5.2 输出values , 同理keys一样，是由values组成的一个dict_keys对象
>>> dict1 = {"k1": 1,"k2": 2,"k3": 3}

>>> dict1.keys()   #输出keys

dict_keys(['k3', 'k2', 'k1'])

>>> list(dict1.keys())   #转为list方法

['k3', 'k2', 'k1']

>>> dict1.values()  #输出values

dict_values([1, 2, 3])

相关文章