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

一、字符串

在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])