python3--字符串、列表、元组、字典、集合

字符串

切片：

s1 = "liweiqiang"

# 使用切片获取多个元素
 s1[0:3]
# 起始和结尾的索引号可以省略
 s1[:3]
 s1[1:]
# 索引可以使用 负数
 s1[2:-1]

步长

• 步长就是每数几个取一个的意思
• 步长是正数时，是从左向右开始操作
• 步长是负数时，是从右向左操作

In [19]: s2 = 'abcdefg'

In [20]: s2[::2]
Out[20]: 'aceg'

In [21]: s2[::-1]
Out[21]: 'gfedcba'

In [22]: s2[::-2]
Out[22]: 'geca'

方法：

len()       统计序列数据的长度
	
in          成员判断
 	
strip()     去除字符串两端的空白字符（空格、\t、 \n）

split()     分割返回值是列表 默认使用空白字符作为分隔符（空格、\t、 \n）

strip()     返回的是字符串，所以可以连续操作

replace()   替换

startswith()   判断字符串以什么为开头

endswith()     判断字符串以什么为结尾

列表

# [] 
li = [ ] # 创建一个空列表
l2 = ['lwq','lzy']
# list（） 从其他类型转换
In [2]: list('hello ')
Out[2]: ['h', 'e', 'l', 'l', 'o', ' ']
# 从字符串转换 split（）
In [3]: 'www.lwq.com'.split('.')
Out[3]: ['www', 'lwq', 'com']

方法：

len()    
方法是一个内置函数，可以统计序列类型的数据结构的长度。

in  
判断元素是否存在于列表中。


append() 
向列表的最后位置，添加一个元素，只接收一个参数。


insert()  
向原列表的指定位置插入一个元素，接收两个参数，
li.insert(0, 521)            第一个是索引号，第二个是要插入的元素。


remove()
 移除列表中某个指定的元素，没有返回值，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素
li.remove(521)


pop()

 从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。
li.pop()   # 删除列表中的最后一个元素
li.pop(2)    #删除列表中第二个索引号对应的元素，并且返回这个元素。

元组

t1 = ()    # 创建 空 元素的元组

方法：

count 统计一个元素在元组内出现的次数
index 返回一个元素在元组内的索引

字典

• 字典在 Python 中极为重要，是属于映射类型的数据结构。
• 字典有一对儿大括号组成 {},
• 字典内的元素都是成对儿出现的 {“a”: 1}, 他们用英文的冒号(:)隔开, 左边叫做键(key),右边的叫值(value), 通常叫做键值对儿。
• 每个元素用英文的逗号 (,) 隔开 {“a”: 1, “b”: 2}

创建字典

创建字典可以使用一对儿大括号， 也可以使用 dict()
>>> d1 = {}
>>> type(d1)
<class 'dict'>
>>> d2 = dict()
>>> type(d2)
<class 'dict'>
>>> d3 = {"size": 8096}
>>>

字典的 key 和 value

• 在一个字典中，key 不允许有重复 （重复的会覆盖掉）
• key并且必须是 python 中不可变的数据类型
• 字典中的 value 可以是 Python 中任意的一个数据对象:

>>> {"a": 1, "a": 10}
{'a': 10}

方法：

获取字典中的 key 和 value

• 检查字典中是否存在某个 key

可以使用 in 关键字
>>> d = {"a": 1, "b": 2}
>>> 'a' in d
True
>>> 'c' in d
False
>>>

• 使用 [] 获取指定 key 的 value

    In [48]: d = {"a": 1, "b": 2}
    
    In [49]: d['a']
    Out [49]: 1
这种方式是非常的高效做法，推荐使用。
但是有个问题，假设获取字典中不存在的 key 的值会报错

• 使用字典的 get() 方法

- >>> dic = {'a': 1, 'b': 2}
>>> dic.get('a')    # 获取到 'a' 对应的值(value)
1
>>>
>>> dic.get('c')    # key 不存在字典中，则返回 None
>>>
>>> v = dic.get('c')
>>> type(v)
<class 'NoneType'>
>>> dic.get('c', '5')  # key 不存在，返回指定的值
'5'
>>>

• 循环字典的 key 和 value

字典对象的 items() 方法会获取到字典的 key 和 value, 它是一个可迭代对象

In [49]: dic_map.values()
Out[49]: dict_values(['manufacturer', 'pod_name', 'sn'])

In [50]: for k, v in dic_map.items():
    ...:     print(k, v)
Manufacturer manufacturer
Product Name pod_name
Serial Number sn

• 循环中添加字段键值对

In [1]: from subprocess import getoutput

In [2]: cmd = "dmidecode -qt 1"

In [3]: ret = getoutput(cmd)

In [4]: ret
Out[4]: 'System Information\n\tManufacturer: Smdbmds\n\tProduct Name: KVM\n\tVersion: 3.0\n\tSerial Number: d7944669-3028-4617-8fc2-9cd3e04aad59\n\tUUID: d7944669-3028-4617-8fc2-9cd3e04aad59\n\tWake-up Type: Power Switch\n\tSKU Number: Not Specified\n\tFamily: Smdbmds\n'

In [5]: ret.splitlines()
Out[5]:
['System Information',  # 注意这里没有冒号 :, 其他的有
 '\tManufacturer: Smdbmds',  # 注意这里前面有 Tab 键，到时候需要处理一下
 '\tProduct Name: KVM',
 '\tVersion: 3.0',
 '\tSerial Number: d7944669-3028-4617-8fc2-9cd3e04aad59',
 '\tUUID: d7944669-3028-4617-8fc2-9cd3e04aad59',
 '\tWake-up Type: Power Switch',
 '\tSKU Number: Not Specified',
 '\tFamily: Smdbmds']

In [6]: for line in ret.splitlines():
   ...:     if ':' in line:
   ...:         k, v = line.split(": ")
   ...:         print(k, v)
   ...:
	Manufacturer Smdbmds
	Product Name KVM
	Version 3.0
	Serial Number d7944669-3028-4617-8fc2-9cd3e04aad59
	UUID d7944669-3028-4617-8fc2-9cd3e04aad59
	Wake-up Type Power Switch
	SKU Number Not Specified
	Family Smdbmds
    
In [8]: prod_info = {}
   ...: for line in ret.splitlines():
   ...:     if ':' in line:
   ...:         k, v = line.split(": ")
   ...:         # 去除前面的 \t tab 键
   ...:         k = k.strip()
   ...:         if k == "Manufacturer":
   ...:             prod_info["manufacturer"] = v
   ...:         elif k == "Product Name":
   ...:             prod_info["prod_name"] = v
   ...:         elif k == "Serial Number":
   ...:             prod_info["sn"] = v
   ...:
   ...:

In [9]: pod_info
Out[9]:
{'manufacturer': 'Smdbmds',
 'prod_name': 'KVM',
 'sn': 'd7944669-3028-4617-8fc2-9cd3e04aad59'}

• update 方式

>>> disk = {"disk": [10240]}
>>> info.update(disk)
>>> info
{'cpu': 4, 'memory': [4096, 4096], 'disk': [10240]}
>>>

集合

• 在 python 中集合看起来像是只有 key 的字典

• {‘disk’,‘cpu’,‘memory’,‘motherboard’}

• 在 python 解释器中表现为 set

• 集合内的元素不允许重复

高效创建集合和转换

set()
>>> s1 = set()  # 创建一个空集合
>>> type(s1)
<class 'set'>
>>>

转换

In [99]: set('disk')
Out[99]: {'d', 'i', 'k', 's'}

In [100]: set(['disk','cpu','memory'])
Out[100]: {'cpu', 'disk', 'memory'}

In [101]: set(('disk','cpu','memory'))
Out[101]: {'cpu', 'disk', 'memory'}

In [102]: set({'disk': '560G','cpu': '4'})
Out[102]: {'cpu', 'disk'}

集合运算

• & 交集
  获取两个集合都有的元素

In [55]: s1 = {"192.168.1.51",  "192.168.1.45"}

In [56]: s2 = {"192.168.1.51", "192.168.1.78"}

In [57]: s1 & s2
Out[57]: {'192.168.1.51'}

• | 并集

把两个集合的元素合并在一起，产生一个新的集合

 In [60]: s1 | s2
Out[60]: {'192.168.1.45', '192.168.1.51', '192.168.1.78'}

• -差集

返回第一个集合中独有的元素。
就是只保留在第一个集合中出现并且不在第二个集合中出现的元素

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.78", "192.168.1.51"}

In [61]: s1 - s2
Out[61]: {'192.168.1.45'}

In [62]: s2 - s1
Out[62]: {'192.168.1.78'}

• ^异或运算

获取两个集合的分别独有的元素，组合为一个新的集合对象。

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.78", "192.168.1.51"}

In [63]: s1 ^ s2
Out[63]: {'192.168.1.45', '192.168.1.78'}