Python





```python
import xml.etree.ElementTree as ET
from xml.etree.ElementTree import tostring
from xml.etree.ElementTree import Element
from io import BytesIO
root = Element("tag")
child = Element("child1", attrib={"jh": "123", "oi": "12312"})
child.text="dasd"
child2 = Element("child2", attrib={"jh": "123"})
child2.text="dasd"
root.append(child)
root.append(child2)
# print(tostring(root, encoding='utf8', method='xml').decode())
et = ET.ElementTree(root)
f = BytesIO()
et.write(f, encoding='utf-8', xml_declaration=True)
print(f.getvalue().decode())  # your XML file, encoded as UTF-8
```

写入到文件
```python
tree = ET.ElementTree(root)
tree.write("output.xml", encoding="utf-8", xml_declaration=True)  #保存时无缩进，添加缩进需要借用dom
```

带缩进地写入到文件
```python
import xml.etree.ElementTree as ET
from xml.dom import minidom
def saveXML(root, filename, indent="\t", newl="\n", encoding="utf-8"):
    rawText = ET.tostring(root)
    dom = minidom.parseString(rawText)
    with open(filename, 'w') as f:
        dom.writexml(f, "", indent, newl, encoding)
```

xml 生成 ＜?xml version=‘1.0‘ encoding=‘utf-8‘?＞ python

[https://stackoverflow.com/questions/39276248/creating-an-md5-hash-of-a-zipfile](https://stackoverflow.com/questions/39276248/creating-an-md5-hash-of-a-zipfile)




```python
import hashlib
def get_MD5(file_path):
    chunk_size = 8192
    h = hashlib.md5()
    with open(file_path, 'rb') as f:
        while True:
            chunk = f.read(chunk_size)  # 文件太大就需要chunk_size
            if len(chunk):
                h.update(chunk)
            else:
                break
    return h.hexdigest()
print(get_MD5('./apptest.py'))
print(get_MD5('./test.zip'))
```

文件小的时候一句话就好：

```python
file = "./cls94_20230515_V1.0.6.mnn"
# 打印md5
import hashlib
print(hashlib.md5(open(file, 'rb').read()).hexdigest())
```

python 计算文件 哈希值 md5 计算 压缩文件哈希值

python内建函数hash()针对不可变对象提供计算哈希值，但我觉得没啥用，可能这个函数的唯一作用就是python字典用了这个函数实现哈希。





python内建库hashlib库提供了很多哈希算法。

哈希算法也称为散列算法，就是把不可变对象依靠着哈希函数映射到一串字符。

`哈希函数（不可变对象）= 哈希结果`

性质：

- 1 不可变对象有无穷多个，哈希结果长度一般是唯一的，也就是说哈希结果个数是有限个。那么从无限个到有限个的映射，必然有哈希冲突：两个不一样的不可变对象映射到了同一个哈希结果。

- 2 显而易见的是，哈希结果的长度越长，能表示的不可变对象越多，冲突可能会少。

- 3 sha256就是一种哈希函数。长度还挺高。256个二进制位！

- 4 同一个不可变对象每次出来的哈希结果必须相同！

- 5 哈希函数计算得越快越好，这是哈希的用途理念决定的。

- 6 相似的不可变对象的哈希结果需要相差很大。

- 7 知道哈希结果反推出不可变对象，必须是一件不可能的事情。

![在这里插入图片描述](/static/img/images/00682.png)

```python
import hashlib
import traceback
for i in ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512',
 'blake2b', 'blake2s',
 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512'):
    try:
        print(i,'------------>')
        print(getattr(hashlib, i)("block_string".encode()).hexdigest())
    except:
        traceback.print_exc()
        print(i)
```


结果

>md5 ------------>

3042e468364703bfc1d2fd07306cb44b

sha1 ------------>

9560f723997057817cd85d068d3b579761122f1b

sha224 ------------>

32bbdcf30cca685f4aceaca23855596b9cd758844f4e9c81c449689e

sha256 ------------>

8f4a106f3a2c581fa60a968c74bf5e7b2ed4c03aa9739dadd197d6aae0c7d343

sha384 ------------>

047c4bbb27e91c2957bd588031dbadb86879ce2a12181c817077433a0f54dcfd23b16f22d8234b5d2be38ec0e7c97c54

sha512 ------------>

b796f690a39228c45952c3f5a1d12ca8086d4333c95b0855e31e7bcbcc1d88b0e8d250cbd89d9f11183733862d78b76984d16b316d512163a83b45f269912723

blake2b ------------>

2f2d7350968dd64f75fa7d045c6bbb70fedd20950e026d03c299f1aad29300572cc7f389e6eb4e5c8603d39dab720dc4087f200de51983d4683f74bd5aa36b61

blake2s ------------>

931e57c1ed77bfc3854a900dd4e5403d69ad4bb73d38289c214bd2abd508f874

sha3_224 ------------>

b25758d1ff393afa0c5bb07f9e7e3170d7bdf87c94a299db2c747a0c

sha3_256 ------------>

97ae01c43d6a0151fa4fd80fe565b39811950308fad5b8fac4b89515084f7307

sha3_384 ------------>

d9a5d65d50c0b8364686e5752fb990d3bb03314255b83924992a451c51ec45e679c60b379c86ff5f6aba9b11c9a928ea

sha3_512 ------------>

8cb00f6b561d411ecb8ec9b0de57ae34ddece0ac3cf10f1c338629815a7301113de00d4ffc7f8da510ff46bc0cbc62bb944d2d9896bfc3e416485c60a4d66e6d

python hashlib库 sha256算法 md5

Python





```python
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('-p', '--port', default=5000, type=int, help='port to listen on')
args = parser.parse_args()
port = args.port
```

python ArgumentParser 简单使用

* 1 普通字典





首先，看看python里面的基础字典使用，下面代码会出错，因为字典里没有key值"k2"存在。
```python
d = {"k1": 123}
print(d["k2"])
```

---

* 2 普通字典的get()

python里字典的get()方法获取key的value，如果没有key，返回默认项,默认项可以是任意对象。

但是，get方法不会改变字典本身。

下面的代码演示了这一原则。
```python
d = {"k1": 123}
print(d.get('k2', 45))
print(d.get('k2', []))
print(d)
```

ouput:

```
45
[]
{'k1': 123}
```

---

* 3 collections.defaultdict()

collections.defaultdict 在最初需要设置默认返回的对象，当找不到key时候，自动创建一个键值对到原字典，原字典会改变。
```python
from collections import defaultdict
d = defaultdict(int)
d['k1'] = 123
print("普通的", d)
print(d['k2'])
print("查找了一个不存在的key后的d", d)
```

output

```
普通的 defaultdict(<class 'int'>, {'k1': 123})
0
查找了一个不存在的key后的d defaultdict(<class 'int'>, {'k1': 123, 'k2': 0})
```


---

* 4 collections.defaultdict() 的应用场景

做一些数据统计的时候，比如直方图，统计每个类别有多少数量，开始也不知道有多少类别。

下面代码演示了这一场景，统计s字符串中各个字母的数量个数。

```python
from collections import defaultdict
s = 'mississippi'
d = defaultdict(int)
for k in s:
    d[k] += 1
print(d.items())
```

output

```
dict_items([('m', 1), ('i', 4), ('s', 4), ('p', 2)])
```

collections.defaultdict() dict 区别 使用 dict.get() python 使用场景

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。