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

一、字符串

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

数字-number -------- int、long、float、complex这几种
字符串-string -------- "使用引号"引起来的都是字符串
元组-tuple ------------ (1,2)使用小括号引起来的元素，中间用逗号隔开.
注意如果元组(v1, )中只有一个值，一定记得要用逗号隔开，不然就无法识别为元组了
布尔值-bool --------- True及False
以上四个为Python中的不可变对象，创建后就不能改变的量-->指该变量指向内存中的值不能被改变，当改变某个变量时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址

5. 列表-list --------------- **[1, 2, 3] [\'a\', \'b\', \'c\']**中括号，里面的元素用逗号隔开 6. 字典-dict -------------- **{key1 : value1, key2 : value2}** 使用大括号＋键-值方式定义，键值之间使用 : 冒号，不同的键对值使用逗号分开

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

1.1 字符串的方法

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