06-课堂笔记-包相关

复习

'''
装饰器
@wraper  # fn = wraper(fn)
def fn(): pass
​
def wrap(arg):
  def outer(func):
    # 可以用arg
    def inner(*args, **kwargs):
      # 可以用arg
      res = func(*args, **kwargs)
      return res
    return inner
  return outer
​
@wrap('实参')
def fn(): pass
​
# 更改inner的文档注释指向
from functools import wraper
​
三元表达式：a if a > b else b
​
列表、字典推导式: [v for v in iterable] {k: v for k, v in iterable}
['奇数' if v % 2 == 1 '偶数' for v in range(1, 11)]
​
迭代器:
# 有__iter__() => 可迭代对象
# 有__next__() => 迭代器对象
# for迭代器
# enumerate => 为可迭代对象生成索引
​
生成器：自定义的迭代器
# range
def fn():
  msg = yield 1 
  yield 2
obj = fn()
obj.__next__()
obj.send(msg)
​
递归:函数的自调用
# 回溯
# 递堆
# 条件与出口
​
匿名函数：lambda
​
​
内置函数：max | min | sorted | map | reduce
max(dic, key=lambda k: dic[k])
​
​
​
'''

今日内容

'''
1.模块
  -- 模块的概念
  -- 模块的使用
  -- 解决循环导入
  
2.包
  -- 包的概念
  -- 包的管理 ***
​
​
3.常用模块
  -- sys | os | time | datetime | json | random
  -- re | logging | hashlib
'''

 

 

模块

# 模块的概念：一系列功能的集合体，可以给其他文件提供功能（数据）
​
'''
常见的四种模块：
1.使用python编写的.py文件
2.把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
3.使用C编写并链接到python解释器的内置模块
4.已被编译为共享库或DLL的C或C++扩展
'''
​
​
# 模块的创建与使用
# 1.将具有共性的功能放在一个py文件中，这样的文件就可以称之为模块
# 2.将封装好的模块对外提供功能
# 3.在要使用模块功能的地方进行导入 => 使用功能
# 语法：import 模块名
​
​
​
# m1.py
def t1():pass
def t2():pass
def t3():pass
​
​
# 导入模块完成了哪些事
import m1  # m1名字就是模块m1的文件对象，存放的是m1文件的地址
# import导入模块完成的事情：
# 1.将被导入的模块编译成模块名对应的pyc文件
# 2.从上至下执行被调用模块的所有代码，形成模块的名称空间，将模块中产生的所有名字存放在模块的名称空间中
#       -- t1,t2,t3存放在m1模块的名称空间中
# 3.在要使用模块的文件(当前文件)的名称空间中产生一个与模块名同名的名字指向模块的名称空间
# print(m1)
​
​
# 重点：在一个文件中直接使用名字，一定找当前文件中的名字
​
# 执行文件与模块的名称空间如果建立起联系的：通过导入的模块名，所以执行文件访问模块文件中的名字用
#   -- 模块名.模块中的名字

 

模块别名

import 模块名 as 别名
​
# 1.模块名与当前文件中的名字发生冲突，用起别名解决冲突
# 2.优化模块名
# 注意：一旦起别名，别名就指向了模块地址，模块名就没有要指向模块地址的必要，那么就失效

 

 

模块的多次导入

# 第一次导入模块，已经完成导入模块的三步，
# 编译=>运行(产生名称空间存放名字)=>执行文件产生名字指向模块的名称空间
​
# 再次导入：前两步是重复操作，所以只会在当前文件再产生一个名字指向模块的名称空间
​
​
# 理由：前两步操作已经将资源放置内存中，从内存中查找速度极高，优先找内存
​
import m1
import m1
# 相当于：a = 10 | a = 10
​
import m1
import m1 as m
# 相当于：a = 10 | b = a

 

模块在链式导入时的执行流程

# 执行文件.py
print('加载')
import m1  # 进入m1, m1全部走完回到这里
print('结束')
​
# m1.py
print('m1 开始')
x = 10
import m2  # 进入m2, m2全部走完回到这里
print('m1 结束')
​
# m2.py
print('m2 开始')
y = 20
print('m2 结束')
​
'''
加载
m1 开始
m2 开始
m2 结束
m1 结束
结束
'''
# 注：在执行文件中访问20 
print(m1.m2.y)

 

 

FROM...IMPORT 语法

# 可以进入模块导具体的名字
​
from m1 import a
# from导入的三步：
# 前两步同import导入
# 第三步：在执行文件起一个与模块中名字相同的变量指向那个名字的地址：a = m1.a
​
​
# 起别名
from m1 import b as bbb  # bbb = m1.b
print(bbb)
​
​
# 了了解：不推荐
from m1 import *
# 1）默认将m1中的所有不是以_开头的名字进行导入，在当前执行文件中可以直接使用模块中的名字
# 2）本质导入的是m1模块中__all__管理的名字 ['a', 'b']，被管理的名字可以任意自定义(可以包含_开头)
# 3) 这种方式的导入，名字不能被起别名，一旦发生名字冲突，无法解决
​
​

模块的两种执行方式

自执行

# 在模块中的__name__ = '__main__'

 

作为模块被导入执行

# 在模块中的__name__ = '模块名'

 

共存

# 模块文件
​
# 先写所有的模块资源(数据 与 函数)
pass
​
# 模块最下方
if __name__ == '__main__':
    # 自执行的逻辑代码
    pass

 

 

模块的加载顺序

# 内存 > 内置 > sys.path的路径顺序遍历 自定义模块（自己写的，系统写的第三方，别人写的第三方）
​
​
# 环境变量: 只是辅助于当前运行的项目，不会影响系统，也不会影响其他项目，所有可以随意操作
import sys
sys.path  # 存放各种模块文件夹路径的列表，可以任意操作来绝对导入自定义模块的顺序

 

IMPORT与FROM...IMPORT:导入的方式采用的是绝对路径

# 绝对路径的依赖：环境变量 sys.path
​

 

环境变量的项目运行

# 在实际开发中，多文件夹之间的模块导入，结构层次杂乱无章，如何规律且准确的进行导包
​
# 如：项目下part8a	est.py 导入part8am1.py | part8am2.py| part7cm3.py
from part8.a import m1
from part8.a.b import m2
from part7.c import m3
# 只需要保证项目目录在环境变量中即可
​
​

项目目录分析

'''
bin: 可执行文件
conf：项目的配置文件
core：项目核心文件，主要的业务逻辑代码
db：数据库相关文件
interface：接口文件
lib：项目的依赖库
log：日志文件
static：静态资源
tmp：临时文件
'''
​
​
# 如何将项目所在目录添加至环境变量
# 比如执行文件 项目目录in
un.py => 项目目录添加到环境变量的语句
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

 

循环导入

# *****

# 问题：彼此相互导入，并使用彼此的名字，如果导入在名字产生之前，就会导致找不到名字，从而出现循环导入错误

# 解决：将名字的产生定义在导入模块之前（延迟导入）

# m1.py
xxx = 666
from m2 import yyy

# m2.py
yyy = 888
from m1 import xxx

 

 

包

# 包:一系列模块的集合体，可以给其他文件提供功能（数据）
# 很多模块的功能相似,将他们统一管理,放在一个文件夹中,该文件夹就称之为 包

# 注：包与普通文件夹不一样，包中必须有__init__文件，py3中可以省略，系统会默认添加，py2中必须手动添加否则报错

 

导包

import 包名
import 包名 as 别名

# 导包的三步
# 1) 创建包下__init__文件对应的pyc文件
# 2) 执行__init__文件产生包的名称空间,将__init__文件中的名字放置到包的名称空间中
# 3) 在执行的导包文件中产生一个包名指向包的名称空间 = __init__文件的名称空间

# __init__文件中出现的名字都可以直接用 包名.名字 来使用

# 包m的__init__.py文件
num = 666

# 导包文件
imprt m
print(m.num)

包的管理

# 1.导包的以.开头的语法，属于包内语法，因为存在.语法开头的导包文件，都不能自执行
# 2.导包的以.开头的语法，只能和 from 结合使用
# 3.在包中的任意模块中都可以使用.语法访问包中其他模块中的名字
# 4.包中.代表当前目录，再添加一个.也就是..代表上一级目录

---

 

 

模块

'''
模块：一系列功能的集合体
​
常见的四种模块：
1.使用python编写的.py文件
2.把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
3.使用C编写并链接到python解释器的内置模块
4.已被编译为共享库或DLL的C或C++扩展
'''

模块的搜索路径

'''
搜索顺序：内存 => 内置模块 => sys.path
​
1.导入模块会优先在内存中查找
2.内存中没有被加载的话，再去查找内置模块
3.还没有查找到，就根据sys.path中的路径顺序逐一查找
​
'''

 

模块导入的执行流程

'''
导入模块的指令：
  -- 相对于 函数名() 调用函数体，函数调用会进入函数体，从上至下逐句解释执行函数体代码
  -- 导入模块，会进入模块文件，从上至下逐句解释执行模块文件代码
  -- 如果在模块中又遇到导入其他模块，会接着进入导入的模块，从上至下逐句解释执行文件中代码，依次类推
'''

 

循环导入

'''
模块之间出现了环状导入，如：m1.py 中导入了m2，m2.py 中又导入了m1
​
循环导入的问题：
  -- 导入模块是要使用模块中的变量
  -- 正常逻辑都是在文件最上方先完成对模块的导入，再在下方定义自身模块变量，以及使用导入的模块中的变量
  -- 由于导入模块的特殊机制，第一次导入模块会编译执行导入的模块，也就是会进入模块逐句执行模块内容，再次导入只是使用内存中的名字
  -- 就会出现下面的情况，m2在使用m1中的变量x，但变量x却并未产生，这就出现了循环导入问题
  
m1.py文件
import m2
x = 10
print(m2.y)
​
m2.py文件
import m1
y = 10
print(m2.x)
​
解决循环导入的问题：延后导入
1、将循环导入对应包要使用的变量提前定义，再导入响应的包
2、将导包的路径放倒函数体中，保证存放导包逻辑的函数调用在要使用的变量定义之后
​
重点：
问题：from导包极容易出现循环导入问题
解决：取消from导入方式，采用import导入方式
'''

 

包

'''
一系列功能模块的集合体
  -- 包就是管理功能相近的一系列模块的文件夹
  -- 该文件夹包含一个特殊文件__init__.py
  -- 文件夹名就是包名，产生的包名就是指向__init__.py的全局名称空间
  
导包完成的三项事：
1.编译执行包中的__init__.py文件，会在包中__pycache__创建对应的pyc文件
2.产生__init__.py文件的全局名称空间，用来存放__init__出现的名字
3.产生包名指向__init__.py文件的全局名称空间 | 指定变量名指向包中指定名字
'''

 

包中模块的使用：IMPORT

'''
module文件夹
  -- __init__.py
  -- m1.py
​
test.py文件
import module
# 在该文件中使用包
'''
​
# 1.__init__.py文件中产生的普通名字可以直接使用
'''
__init__.py
x = 10
​
test.py
print(module.x)
'''
​
# 2.管理的模块中出现的名字，要通过 包名.模块名 间接使用
'''
m1.py
num = 10
​
__init__.py
import module.m1
​
test.py
print(module.m1.num)
'''

 

包的嵌套

# 在包中再定义包
# 连包的导入
import 父包.子包
​
# 重点：导包的.语法，在所有点左侧都必须是包
# 正确案例：
import 父包.子包
import 父包.子包.模块
# 错误案例
import 父包.子包.模块.名字

 

包中模块的使用：FROM...IMPORT

'''
使用规则与import差不多，但是导包的.语法需严格执行，就是所有点左侧都必须是包
'''

 

导包的两种方式

# 绝对导入：通过sys.path方式来实现
# 相对导入：通过包内.语法来实现

 

绝对导入

# 将对应的文件夹添加至sys.path中，就可以直接导入对应文件夹下的模块

 

相对导入

# 相对导入是存在于包内的语法
# .代表当前文件夹
# ..代表上一级文件夹

# 存在.语法的文件，不能作为执行文件

 

 

TIME：时间

'''
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
'''

'''
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
'''

 

CALENDAR：日历

'''
判断闰年：calendar.isleap(year)
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
# 注：0代表星期一
'''

 

DATATIME：可以运算的时间

'''
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datatime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
'''

 

SYS：系统

'''
命令行参数List，第一个元素是程序本身路径：sys.argv
退出程序，正常退出时exit(0)：sys.exit(n) 
获取Python解释程序的版本信息：sys.version
最大int值：sys.maxsize | sys.maxint
环境变量：sys.path
操作系统平台名称：sys.platform
'''

# 可以实现py文件作为脚本文件执行,实现外部往内部传参
def copy(old_file, new_file):
    print('复制%s操作成%s' % (old_file, new_file))
def move(old_file, new_file):
    print('移动%s操作成%s' % (old_file, new_file))

method_map = {
    'copy': copy,
    'move': move
}
if len(sys.argv) > 3:
    cmd = sys.argv[1]
    old_file = sys.argv[2]
    new_file = sys.argv[3]

    if cmd in method_map:
        method_map[cmd](old_file, new_file)
    else:
        print('该功能暂未提供')
# 启动cmd命令行，用python解释器直接执行python文件，传入指定的参数

 

OS：操作系统

'''
生成单级目录：os.mkdir('dirname')
生成多层目录：os.makedirs('dirname1/.../dirnamen2')
重命名：os.rename("oldname","newname") 
工作目录：os.getcwd()
删除单层空目录：os.rmdir('dirname')
移除多层空目录：os.removedirs('dirname1/.../dirnamen') 
列举目录下所有资源：os.listdir('dirname')
路径分隔符：os.sep
行终止符：os.linesep
文件分隔符：os.pathsep
操作系统名：os.name
操作系统环境变量：os.environ
执行shell脚本：os.system() 
'''

 

OS.PATH：系统路径操作

'''
执行文件的当前路径：__file__
返回path规范化的绝对路径：os.path.abspath(path)  
将path分割成目录和文件名二元组返回：os.path.split(path)  
上一级目录：os.path.dirname(path) 
最后一级名称：os.path.basename(path)
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path) 
路径拼接：os.path.join(path1[, path2[, ...]])
最后存取时间：os.path.getatime(path)
最后修改时间：os.path.getmtime(path)
目标大小：os.path.getsize(path)
'''

'''
normcase函数
在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\system32\')   
'c:\windows\system32\'   
   
normpath函数
规范化路径，如..和/
>>> os.path.normpath('c://windows\System32\../Temp/')   
'c:\windows\Temp'   

>>> a='/Users/jieli/test1/\a1/\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1
'''

 

RANDOM：随机数

'''
(0, 1)：random.random()
[1, 10]：random.randint(1, 10)
[1, 10)：random.randrange(1, 10)
(1, 10)：random.uniform(1, 10)
单例集合随机选择1个：random.choice(item)
单例集合随机选择n个：random.sample(item, n)
洗牌单列集合：random.shuffle(item)
'''

 

JSON：序列化

# json: {} 与 [] 嵌套的数据
# 注：json中的字符串必须全部用""来标识
'''
序列化：对象 => 字符串
序列化成字符串：json.dumps(json_obj)
序列化字符串到文件中：json.dump(json_obj, write_file)

# 注：字符形式操作
反序列化成对象：json.loads(json_str)
从文件读流中反序列化成对象：json.load(read_file)
'''

 

PICKLE：序列化

'''
序列化：对象 => 字符串
序列化成字符串：pickle.dumps(obj)
序列化字符串到文件中：pickle.dump(obj, write_bytes_file)

# 注：字节形式操作
反序列化成对象：pickle.loads(bytes_str)
从文件读流中反序列化成对象：pickle.load(read_bytes_file)
'''

 

SHUTIL：可以操作权限的处理文件模块

# 基于路径的文件复制：
shutil.copyfile('source_file', 'target_file')

# 基于流的文件复制：
with open('source_file', 'rb') as r, open('target_file', 'wb') as w:
    shutil.copyfileobj(r, w)
    
# 递归删除目标目录
shutil.rmtree('target_folder')

# 文件移动
shutil.remove('old_file', 'new_file')

# 文件夹压缩
shutil.make_archive('file_name', 'format', 'archive_path')

# 文件夹解压
shutil.unpack_archive('unpack_file', 'unpack_name', 'format')

 

SHEVLE：可以用字典存取数据到文件的序列化模块

# 将序列化文件操作dump与load进行封装
s_dic = shelve.open("target_file", writeback=True)  # 注：writeback允许序列化的可变类型，可以直接修改值
# 序列化:：存
s_dic['key1'] = 'value1'
s_dic['key2'] = 'value2'
# 反序列化：取
print(s_dic['key1'])
# 文件这样的释放
s_dic.close()

 

LOGGING：日志模块

'''
1) root logging的基本使用：五个级别
2）root logging的基本配置：logging.basicConfig()
3）logging模块四个核心：Logger | Filter | Handler | Formater
4）logging模块的配置与使用
	-- 配置文件：LOGGING_DIC = {}
	-- 加载配置文件：logging.config.dictConfig(LOGGING_DIC) => logging.getLogger('log_name')
'''

 

RE：正则模块（重点）

'''
1）模块的基本使用
2）正则的语法
3）分组：() | (?:) | (?P<name>)
4）正则的使用方法
'''

 

HASHLIB模块：加密

import hashlib
# 基本使用
cipher = hashlib.md5('需要加密的数据的二进制形式'.encode('utf-8'))
print(cipher.hexdigest())  # 加密结果码

# 加盐
cipher = hashlib.md5()
cipher.update('前盐'.encode('utf-8'))
cipher.update('需要加密的数据'.encode('utf-8'))
cipher.update('后盐'.encode('utf-8'))
print(cipher.hexdigest())  # 加密结果码

# 其他算法
cipher = hashlib.sha3_256(b'')
print(cipher.hexdigest())
cipher = hashlib.sha3_512(b'')
print(cipher.hexdigest())

 

HMAC模块：加密

# 必须加盐
cipher = hmac.new('盐'.encode('utf-8'))
cipher.update('数据'.encode('utf-8'))
print(cipher.hexdigest())

 

CONFIGPARSER模块：操作配置文件

# my.ini
[section1]
option1_1 = value1_1
option1_2 = value1_2

[section2]
option2_1 = value2_1
option2_2 = value2_2

import configparser
parser = configparser.ConfigParser()
# 读
parser.read('my.ini', encoding='utf-8')
# 所有section
print(parser.sections())  
# 某section下所有option
print(parser.options('section_name'))  
# 某section下某option对应的值
print(parser.get('section_name', 'option_name')) 

# 写
parser.set('section_name', 'option_name', 'value')
parser.write(open('my.ini', 'w'))

 

SUBPROCESS模块：操作SHELL命令

import subprocess
order = subprocess.Popen('终端命令', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
suc_res = order.stdout.read().decode('系统默认编码')
err_res = order.stderr.read().decode('系统默认编码')

order = subprocess.run('终端命令', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
suc_res = order.stdout.decode('系统默认编码')
err_res = order.stderr.decode('系统默认编码')

 

XLRD模块：EXCEL读

			年终报表				
		教学部	市场部	咨询部	总计
Jan-19	10		15		5	30
Feb-19	10		15		5	30
Mar-19	10		15		5	30
Apr-19	10		15		5	30
May-19	10		15		5	30
Jun-19	10		15		5	30
Jul-19	10		15		5	30
Aug-19	10		15		5	30
Sep-19	10		15		5	30
Oct-19	10		15		5	30
Nov-19	10		15		5	30
Dec-19	10		15		5	30

import xlrd
# 读取文件
work_book = xlrd.open_workbook("机密数据.xlsx")
# 获取所有所有表格名称
print(work_book.sheet_names())
# 选取一个表
sheet = work_book.sheet_by_index(1)
# 表格名称
print(sheet.name)
# 行数
print(sheet.nrows)
# 列数
print(sheet.ncols)
# 某行全部
print(sheet.row(6))
# 某列全部
print(sheet.col(6))
# 某行列区间
print(sheet.row_slice(6, start_colx=0, end_colx=4))
# 某列行区间
print(sheet.col_slice(3, start_colx=3, end_colx=6))
# 某行类型 | 值
print(sheet.row_types(6), sheet.row_values(6))
# 单元格
print(sheet.cell(6,0).value) # 取值
print(sheet.cell(6,0).ctype) # 取类型
print(sheet.cell_value(6,0)) # 直接取值
print(sheet.row(6)[0])
# 时间格式转换
print(xlrd.xldate_as_datetime(sheet.cell(6, 0).value, 0))

 

XLWT模块：EXCEL写

import xlwt
# 创建工作簿
work = xlwt.Workbook()
# 创建一个表
sheet = work.add_sheet("员工信息数据")
# 创建一个字体对象
font = xlwt.Font()
font.name = "Times New Roman"  # 字体名称
font.bold = True  # 加粗
font.italic = True  # 斜体
font.underline = True  # 下划线
# 创建一个样式对象
style = xlwt.XFStyle()
style.font = font
keys = ['Owen', 'Zero', 'Egon', 'Liuxx', 'Yhh']
# 写入标题
for k in keys:
    sheet.write(0, keys.index(k), k, style)
# 写入数据
sheet.write(1, 0, 'cool', style)
# 保存至文件
work.save("test.xls")

 

XML模块

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

import xml.etree.ElementTree as ET
# 读文件
tree = ET.parse("xmltest.xml")
# 根节点
root_ele = tree.getroot()
# 遍历下一级
for ele in root_ele:
    print(ele)
    
# 全文搜索指定名的子标签
ele.iter("标签名")
# 非全文查找满足条件的第一个子标签
ele.find("标签名")
# 非全文查找满足条件的所有子标签
ele.findall("标签名")

# 标签名
ele.tag
# 标签内容
ele.text
# 标签属性
ele.attrib

# 修改
ele.tag = "新标签名"
ele.text = "新文本"
ele.set("属性名", "新属性值")

# 删除
sup_ele.remove(sub_ele)

# 添加
my_ele=ET.Element('myEle')
my_ele.text = 'new_ele' 
my_ele.attrib = {'name': 'my_ele'}
root.append(my_ele)

# 重新写入硬盘
tree.write("xmltest.xml")