Python入门（三）--- 元组，字典，集合

Python入门（三）

回顾

1 基本数据类型

• str
• int
• bytes
• float
• bool (True / False)

s = 'hello'

bytes(s, encoding="utf-8")  # 编码

str(b'hello', encoding="utf-8")  # 解码

2 判断条件

==
!=

and

or

(... or ...) and ...

不加小括号，and 优先级高
or   and

3 数学运算

+  -  *   /  
// 整除
幂运算 ：**
取余： %

4 字符串

''  ""  """函数文档"""  ''' '''
s = ''

s.isdigit()
s.split()  # 分隔 awk  空格，\t \n
s.splitlines()  # 等同于 s.split('\n')
s.strip()  # 去除两端空白字符，也同传参，去除两端的指定字符
s.replace('old', 'new', [n])  替换， 可以通过 n ,指定替换多少个，n 是一个整数

>>> s = "hello"
>>> s.replace('l', 'I')
>>> 'heIIo'
>>> s.replace('l', 'I', 1)
>>> 'heIlo'

s.lower()
s.index()  # 获取 指定当个字符串在整字符串对象中索引

s.isalpha() # 判断是否都字母
s.startswith
s.endswith

5 列表

li = []

li.append()  # 追加元素，只接收一个参数：字符串 列表 元组 字典
li.insert()  # 两个参数，索引 值
li.remove()  # 删除指定元素
li.pop()  # 默认删除最后一个，也可以传递具体的索引

6 循环

被迭代的元素：

• 字符串
• 列表
• 元组
• 字典
• 文件对象

>>> range(3)
range(0, 3)
>>> range(300000)
range(0, 300000)
>>> for i in range(5):
...    print(i)
...
0
1
2
3
4
>>> for i in range(1, 5):
...    print(i)
...
1
2
3
4
>>> for i in range(1, 5, 2):
...     print(i)
...
1
3
>>>

元组的取值

元组也是序列类型的数据，取值和切片和列表的操作一样

In [33]: t1 = (1, 2, 3, ['a', 'b'])
In [34]: t1[3][0]=0
In [35]: t1
Out[35]: (1, 2, 3, [0, 'b'])

元组的方法

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

In [117]: t1 = (1, 'hello', ['a', 'b'])

In [118]: t1.                         # 按 Tab 键
              count() index()      # 可以看出没有可以改变其自身的方法


In [119]: t1.count('hello')  # 统计一个元素在元组中出现的次数
Out [119]: 1

In [120]: t1.index(1)  # 返回一个元素在元组中的索引号
Out [120]: 0

元组的相对不可变

元组本身是不可变的，就是元组内的元素是不可变的，一旦创建一个元组，这个元组内的元素个数和数据都是固定的了
相对不可变的意思是，元组内的元素自身是可变的数据对象，就可以通过修改这个可变元素，来间接改变元组的样子。

说下面的示例之前，先说一个内置函数 id(), 这个函数可以返回python 中一个对象的内存地址（id 号）

In [119]: id('hello')
Out[119]: 4478905344

In [120]: id(t1)
Out[120]: 4479260568

In [121]: id(t1[-1])
Out[121]: 4478661192

元组是相对不可变的

假设我想把上个示例中的元组 t1 中的最后一个元素，修改为 ['a']

In [122]: t1[-1]
Out[122]: ['a', 'b']

In [123]: t1[-1] = ['a']

TypeError                             Traceback (most recent call last)
 in 
----> 1 t1[-1] = ['a']

TypeError: 'tuple' object does not support item assignment

可以看到，我们不能通过元组的索引就地复制为 ['a']
但是，元组中的最后一个元素是列表，列表中的元素是可以改变的，所以可以直接操作列表本身就行

In [129]: t1 = (1,'hello', ['a', 'b'])

In [130]: t1[-1]
Out[130]: ['a', 'b']

In [131]: id(t1[-1])           # 改变前的 id
Out[131]: 4473983368

In [132]: t1[-1].pop()
Out[132]: 'b'

In [133]: t1
Out[133]: (1, 'hello', ['a'])

In [134]: id(t1[-1])          # 改变后的 id
Out[134]: 4473983368

for 循环元组

t = ('qfedu.com', 1314, 521)

for item in t:
    print(item)

元组的优点

1. 占用内存空间小
2. 元组内的值不会被意外的修改
3. 可作为字典的键
4. 函数的参数是以元组形式传递的

字典

特性

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

创建字典

创建字典可以使用一对儿大括号， 也可以使用 dict()

字典的 key

在一个字典中，key 不允许有重复
并且必须是 python 中不可变的数据类型
如：
整型 浮点型 布尔值 字符串 元组

In [35]: dict([('a',1),['b',2]])
Out[35]: {'a': 1, 'b': 2}

In [36]: dict([('a',1),('b',2)])
Out[36]: {'a': 1, 'b': 2}

In [37]: dict(['a1','b3'])
Out[37]: {'a': '1', 'b': '3'}

字典中的 value

字典中的 value 可以是 Python 中任意的一个数据对象:

• 整型、浮点型、布尔值、字符串、列表、元组、字典、函数对象

In [43]: def foo():
    ...:     print("hello")
    ...: 

In [44]: d = {'func':foo}

In [48]: foo
Out[48]: 

In [48]: foo
Out[48]: 

In [49]: foo()
hello

In [50]: d['func']()
hello

python2 代码使用中文
#!/usr/bin/env python
#coding:utf-8
print (“百度”)

In [3]: d= {"a":1,"b":2,"c":3,"d":5}

In [4]: li = []

In [5]: for k, v in d.items():
   ...:     if v > 2:
   ...:         li.append((k, v))
   ...: 

In [6]: li
Out[6]: [('c', 3), ('d', 5)]

In [7]: d = {'a':1,"b":2,"c":4,'d':'hello'}

In [11]: int == type("dd")
Out[11]: False

In [12]: int == type(1)
Out[12]: True

In [13]: str == type("dd")
Out[13]: True

In [8]: str_dic = {}

In [9]: for k, v in d.items():
   ...:     if type(v) == str:
   ...:         str_dic[k] = v
   ...: 

In [10]: str_dic
Out[10]: {'d': 'hello'}

获取厂商名称主板信息

dmidecode -qt 1

获取内存信息

dmidecode -qt 17

集合 去重

set()

>>> s1 = set()
>>> type(s1)
<class 'set'>

交集

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'}