一、基础应用

#!/usr/bin/python
# -*- coding: UTF-8 -*-
from tkinter import *
from tkinter import ttk
root = Tk()
# 创建TK实例，它初始化 Tk 并创建其关联的 Tcl 解释器。它还创建了一个顶级窗口，称为根窗口，用作应用程序的主窗口。

frm = ttk.Frame(root, padding=10)
# 创建一个框架小部件（容器），在本例中，它将包含我们接下来将创建的标签和按钮。该框架适合在根窗口内。

frm.grid()
# grid()方法用于指定标签在其包含框架小部件中的相对布局（位置），类似于 HTML 中的表格的工作方式。

ttk.Label(frm, text='你好，世界',).grid(column=0, row=0)
ttk.Button(frm, text='按钮', command=root.destroy).grid(column=1, row=0)
# 添加组件，并进行相应的属性配置

root.mainloop()
# mainloop()方法将所有内容都显示在显示器上，并响应用户输入，直到程序终止。

# 点击下载事件
def download_template_one(event):
    """
    下载模板一
    :return:
    """
    filepath = askdirectory()
    copyfile(local_path + '/TemplateOne.xlsx', filepath + '/商品信息模板一.xlsx')
    tips('文件已下载完成，即将自动打开，请注意查看')
    os.startfile(filepath + '/商品信息模板一.xlsx')
Label1 = Label(self.root, text='下载周报模板一', fg='blue', font=('宋体', 10, "underline"))
Label1.bind("<Button-1>", download_template_one)
Label1.place(x=195, y=174)


# 获取组件文字颜色
self.canvas_color.cget("foreground")
# 将获取到的16进制颜色转10进制三位RGB颜色
color = self.canvas_color.cget("foreground")[1:]
self.data['画布']['颜色'] = (
    int('0x' + color[0:2],16),
    int('0x' + color[2:4],16),
    int('0x' + color[4:],16))

# 绑定位置
object_ui.set_screen_size(490, 250 + 13 * hang_num, object_ui.T_UI.windows.winfo_x(), object_ui.T_UI.windows.winfo_y())

二、注意、常见的相应事件

place_forget

grid_forget

pack_forget
一： 鼠标事件
# 鼠标左键单击
<Button-1>                                                                     
# 鼠标中键单击
<Button-2>                                                                     
# 鼠标右键单击
<Button-3>                                                                     
# 
<1> = <Button-1> =<ButtonPress-1>
# 
<2> = <Button-2> = <ButtonPress-2>
# 
<3> = <Button-3> =<ButtonPress-3>
# 鼠标左键拖动
<B1-Motion>                                                                
# 鼠标中键拖动
<B2-Motion>                                                                
# 鼠标右键拖动
<B3-Motion>                                                                
# 鼠标左键释放
<ButtonRelease-1>                                                    
# 鼠标中键释放
<ButtonRelease-2>                                                    
# 鼠标右键释放
<ButtonRelease-3>                                                    
# 鼠标左键双击
<Double-Button-1>                                                    
# 鼠标中键双击
<Double-Button-2>                                                    
# 鼠标右键双击
<Double-Button-3>                                                    
# 鼠标指针进入控件
<Enter>                                                                        
# 鼠标指针离开控件
<Leave>                                                                      

二：键盘事件
# 回车
<Return>                                                                      
# Break键
<Cancel>                                                                     
# BackSpace键
<BackSpace>                                                             
# Tab键
<Tab>                                                                          
# Shift键
<Shift_L>                                                                     
# Alt键
<Alt_L>                                                                        
# Control键
<Control_L>                                                               
# Pause键
<Pause>                                                                     
# Caps_Lock键
<Caps_Lock>                                                           
# Escapel键
<Escape>                                                                   
# PageUp键
<Prior>                                                                        
# PageDown键
<Next>                                                                        
# End键
<End>                                                                         
# Home键
<Home>                                                                      
# 左箭头
<Left>                                                                          
# 上箭头
<Up>                                                                           
# 右箭头
<Right>                                                                      
# 下箭头
<Down>                                                                    
# Print Screen键
<Print>                                                                       
# Insert键
<Insert>                                                                      
# Delete键
<Delete>                                                                   
# F1
<F1>                                                                                                                                                            .
# F12键
<F12>                                                                         
# Num_Lock键
<Num_Lock>                                                            
# Scroll_Lock键
<Scroll_Lock>                                                         
# 任意键
<key>                                                                        

三： 可打印的字符：

<KeyPress-a>

<KeyRelease-a>
shift+a
A                                                                                 
shift+b
B                                                                                 

四： 组合键：
# Shift+Up
<Shift-Up>                                                                
# Alt+Up
<Alt-Up>                                                                    
# Ctrl+Up
<Control-Up>                                                           
# Ctrl+shift+a
<Control-A>                                                             

五：窗体事件：
# 改变大小或位置
<Configure>                                                           
# 当组件变为可视状态时触发
<Visibility>                                                             
# 当组件由显示状态变为隐藏状态时触发
<Unmap>                                                               
# 当组件由隐藏状态变为显示状态时触发
<Map>                                                                    
# 当组件从原本被其他组件遮盖的状态中暴漏出来时触发
<Expose>                                                              
# 组件获得焦点时触发
<FocusIn>                                                             
# 组件失去焦点时触发
<FocusOut>                                                          
# 当窗体由于系统协议要求在堆栈中置顶或压底时触发
<Circulate>                                                           
# 当窗体的颜色或外貌改变时触发，Tk中忽略此细则
<Colormap>                                                         
# 当窗体的属性被删除或改变时触发，属于TK的核心
<Property>                                                           
# 当组件被销毁时触发
<Destroy>                                                            
# 与组件选项中的state项有关，表示组件由不可用变为可用时触发
<Activate>                                                            
# 与组件选项中的state项有关，表示组件由可用变为不可用时候触发
<Deactiavte>                                                       

六： Event
# 事件被触发的控件
widget                                                                  
# 鼠标距离窗体左上角的位置（坐标）
x, y                                                                        
# 鼠标距离屏幕左上角的位置（坐标）
x_root, x_y                                                          
# 键盘事件对应的字符代码
char                                                                      
# 键盘事件对应的字符串
keysym                                                                 
# 键盘事件对应的按键码
keycode                                                               
# 鼠标事件对应的按键码
num                                                                      
# 控件的新大小
width, height                                                       
# 事件类型
type                                                                      

 列子

# encoding: utf-8

from Tkinter import *

class MouseKeyEventDemo:
    def __init__(self):
        # 窗口和标题
        window = Tk()
        window.title("鼠标键盘事件")

        # 打包一个白色画布到窗口
        canvas = Canvas(window, width=200, height=200, bg="white")
        canvas.focus_set()  # 让画布获得焦点,对于键盘
        canvas.pack()

        # 绑定鼠标左键事件，交由processMouseEvent函数去处理，事件对象会作为参数传递给该函数
        canvas.bind(sequence="<Button-1>", func=self.processMouseEvent)

        # 绑定鼠标键盘事件，交由processKeyboardEvent函数去处理，事件对象会作为参数传递给该函数
        canvas.bind(sequence="<Key>", func=self.processKeyboardEvent)

        # 消息循环
        window.mainloop()

    # 处理鼠标事件，me为控件传递过来的鼠标事件对象
    def processMouseEvent(self, me):
        print("me=", type(me))  # me= <class>

        print("位于屏幕", me.x_root, me.y_root)
        print("位于窗口", me.x, me.y)
        print("位于窗口", me.num)

    # 处理鼠标事件，ke为控件传递过来的键盘事件对象
    def processKeyboardEvent(self, ke):
        print("ke.keysym", ke.keysym)  # 按键别名
        print("ke.char", ke.char)  # 按键对应的字符
        print("ke.keycode", ke.keycode)  # 按键的唯一代码，用于判断按下的是哪个键</class></key></button-1>

MouseKeyEventDemo()

三、常规用法

1、常用组件及事件绑定（开发模板）

常用组件常见事件博文

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# @Time : ${DATE} ${TIME}
# @Author : 小周
# @Demand : ${demand}
# @File : ${NAME}.py
# @Software: ${PRODUCT_NAME}
import os.path
import random
import threading
import time
from datetime import timedelta, date
from tkinter import *
from tkinter import messagebox
from tkinter.filedialog import askopenfilename
from urllib import request

import cv2
import numpy as np
import openpyxl
import sys
import pandas as pd
import pyautogui
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver import ActionChains
from selenium.webdriver.support.wait import WebDriverWait
from common import universal


APPID = 41
DEBUG = True

if DEBUG:
    share_root_path = "./../../../rpa_frame"  # 测试阶段共享文件路径
    local_path = "."  # 测试阶段，本地资源地址
else:
    share_root_path = '.'  # 上线阶段，共享文件路径
    local_path = './app/appcode_' + str(APPID)  # 上线阶段，本地资源地址

def getData():
    """
    用于读取缓存数据
    """
    data = universal.getcache(universal.getuid(), APPID)
    if not data:  # 如果数据为空，则返回空字典
        data = {}
    return data

def setData(data):
    """
    用于覆盖缓存数据
    """
    universal.setcache(universal.getuid(), APPID, data)

def create_driver(download_address='./'):
    # 创建浏览器对象
    options = webdriver.ChromeOptions()
    prefs = {
        'profile.default_content_settings.popups': 0,
        'download.default_directory': download_address,
    }
    # 设置开发者模式
    options.binary_location = share_root_path + "/brower/chrome/chrome.exe"
    options.add_experimental_option('excludeSwitches', ['enable-automation'])
    options.add_experimental_option('prefs', prefs)

    driver = webdriver.Chrome(options=options, executable_path=share_root_path + "/brower/chrome/chromedriver")
    driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
        "source": """
                    Object.defineProperty(navigator, 'webdriver', {
                        get: () => undefined
                    })
                """
    })

    driver.maximize_window()  # 最大化窗口
    return driver


def send_email(to_addr, subject, content, from_addr=u"RPA@innshine.com", password=u"HuiShang567"):
    """
    用于邮件放送，from_addr， password,取默认值即可
    :param to_addr:     接收方地址
    :param subject:     邮件主题
    :param content:     邮件正文内容
    :param from_addr:   发送方地址
    :param password:    发送方密码
    :return:
    """
    msg = MIMEText(content,'html','utf-8')
    msg['From'] = u'<%s>' % from_addr
    msg['To'] = u'<%s>' % to_addr
    msg['Subject'] = subject

    smtp = smtplib.SMTP_SSL('smtp.exmail.qq.com', 465)
    smtp.set_debuglevel(1)
    smtp.ehlo("smtp.exmail.qq.com")
    smtp.login(from_addr, password)
    smtp.sendmail(from_addr, [to_addr], msg.as_string())

# 提示系统运行中，单开一个线程
def tips_run():
    def stop_run():  #
        value = messagebox.askokcancel(title="警告", message="确定中断程序吗？")
        if value:
            GUI_TK.root.destroy()
            sys.exit(0)

    root = Toplevel()
    root.protocol('WM_DELETE_WINDOW', stop_run)
    root.geometry(f'{268}x{95}+{10}+{10}')
    root.title('注意')
    Label(root, text="*✧⁺˚⁺ପ(๑･ω･)੭ु⁾⁾ 程序运行中，请稍等").place(x=20, y=20)
    Button(root, text='中断程序', command=stop_run).place(x=100, y=50)


def tips(t):
    messagebox.showinfo('提示', t)


def row_column(row, column):
    column = column.upper()
    row = row - 1
    if len(column) == 1:
        column = ord(column) - ord('A')
    else:
        column = (ord(column[0]) - ord('A') + 1) * 26 + ord(column[1]) - ord('A')
    return row, column


class TkInterface:
    """
    Tk图形界面
    """

    def __init__(self, root):
        self.root = root
        self.file_path = StringVar()
        self.file_name = StringVar()
        self.date = StringVar()

    def tips(self, tip):
        messagebox.showinfo('提示', tip)
        self.root.iconify()

    def draw_data(self):
        self.file_path.set("未选择文件")
        self.file_name.set("未选择文件")
        self.date.set((date.today() + timedelta(days=-1)).strftime("%Y-%m-%d"))

        def setaccount():
            """
            配置账号信息
            :return:
            """
            photo_show = PhotoImage(file=share_root_path + "/icon/show_pwd.png")
            photo_x = int(photo_show.width() / 15)
            photo_y = int(photo_show.height() / 15)
            photo_show = photo_show.subsample(photo_x, photo_y)

            photo_noshow = PhotoImage(file=share_root_path + "/icon/noshow_pwd.png")
            photo_x = int(photo_noshow.width() / 15)
            photo_y = int(photo_noshow.height() / 15)
            photo_noshow = photo_noshow.subsample(photo_x, photo_y)

            # 点击次数
            DoubleNum = 0
            # 获取缓存中的数据
            data = getData()
            try:
                name = data['账号']
                pwd = data['密码']
                email_addr = data['邮箱地址']
            except:
                name = ''
                pwd = ''
                email_addr = ''

            def show_pwd():
                """
                显示密码
                :return:
                """
                nonlocal DoubleNum
                DoubleNum += 1
                if DoubleNum % 2:
                    ent2.config(show='')
                    show_button.config(image=photo_show)
                else:
                    ent2.config(show='*')
                    show_button.config(image=photo_noshow)

            Temporary_window = Toplevel(self.root)
            Temporary_window.title('请配置参数')
            Temporary_window.geometry('350x190+440+250')

            frame = Frame(Temporary_window)
            frame_left = Frame(frame)
            frame_right = Frame(frame)

            Label(frame_left, text='请输入店铺账号：').grid(row=2, column=0, sticky=E, pady=3)
            Label(frame_left).grid(pady=10)
            Label(frame_left, text='请输入店铺密码：').grid(row=3, column=0, sticky=E, pady=3)
            Label(frame_left).grid(pady=5)
            Label(frame_left, text='请输入邮箱地址：').grid(row=4, column=0, sticky=E, pady=3)
            Label(frame_left).grid(pady=5)

            ent1 = Entry(frame_right)
            ent1.insert("insert", name)
            ent1.grid(row=1, column=0, pady=7, padx=2, sticky=W)

            ent2 = Entry(frame_right)
            ent2.config(show='*')
            ent2.insert("insert", pwd)
            ent2.grid(row=2, column=0, pady=7, padx=2, sticky=W)

            ent3 = Entry(frame_right)
            ent3.insert("insert", email_addr)
            ent3.grid(row=3, column=0, pady=7, padx=2, sticky=W)

            frame.place(x=35, y=25)
            frame_left.grid(row=0, column=0, sticky=NE)
            frame_right.grid(row=0, column=1, sticky=NW)

            def save():
                """
                保存设置
                :return:
                """
                data['账号'] = ent1.get()
                data['密码'] = ent2.get()
                data['邮箱地址'] = ent3.get()

                setData(data)

                Temporary_window.destroy()


            def close():
                Temporary_window.destroy()

            Button(Temporary_window, text='确定', command=save).place(x=110, y=145)
            Button(Temporary_window, text='取消', command=close).place(x=210, y=145)

            show_button = Button(Temporary_window, image=photo_noshow, borderwidth=0, command=show_pwd)
            show_button.place(x=290, y=68)

            self.root.mainloop()

        def selectfile(path, name):
            """
            选择文件
            :return:
            """

            def setpath():
                filepath = askopenfilename()
                path.set(filepath)
                name.set(filepath.split('/')[-1])

            return setpath

        frame = Frame(self.root)
        frame_left = Frame(frame)
        frame_right = Frame(frame)

        Label(frame_left, text='请选择天猫客服周报文件：').grid(row=2, column=0, sticky=E, pady=3)
        Label(frame_left).grid(pady=5)
        Label(frame_left, text='请输入需获取的数据日期：').grid(row=4, column=0, sticky=E, pady=5)

        Button(frame_right, text='点击选择', command=selectfile(self.file_path, self.file_name)).grid(row=2, column=0,
                                                                                                  sticky=W, pady=3)
        Label(frame_right, textvariable=self.file_name).grid(row=3, column=0, sticky=W, pady=3)
        txt = Text(frame_right, height=1, width=20)
        txt.insert("insert", self.date.get())
        txt.grid(row=4, column=0, pady=7, padx=2, sticky=W)

        frame.place(x=15, y=15)
        frame_left.grid(row=0, column=0, sticky=NE)
        frame_right.grid(row=0, column=1, sticky=NW)

        def start_button():
            GUI_TK.root.withdraw()
            thread_tip = threading.Thread(target=tips_run, daemon=True)
            thread_tip.start()
            start_run(date, self.file_path.get())
            GUI_TK.root.destroy()

        Button(self.root, text='开始运行', command=start_button).place(x=170, y=115)
        Button(self.root, text='账号设置', command=setaccount).place(x=110, y=115)

        self.root.mainloop()


class ExcelRW:
    """
    excel自动化读写操作
    """

    def __init__(self, path):
        self.path = path
        self.wb = openpyxl.load_workbook(path)  # keep_vba=True

    def read(self, row, column):
        """
        读取表中的数据
        按条件筛选数据，并返回相应的值
        :param row: 行数，如：1,2,3
        :param column: 列名，如：a,b,c
        :return:返回对应筛选后的数据
        """
        row, column = row_column(row, column)
        all_data = pd.read_excel(self.path, sheet_name=2)
        data_df = all_data[
            all_data['客户'].map(lambda x: x == '四川') &
            all_data['商品名称'].map(lambda x: '休闲鞋' in x)
            ]
        data = data_df.iloc[row, column]
        return data

    def write(self, index, row, column, data):
        """
        向表中写入'数字型'数据
        :param index: 第几张表，第一张表对应index为0
        :param row:  行数，如：1,2,3
        :param column: 列名，如：a,b,c
        :param data: 数据
        :return: 无返回值
        """
        column = column.upper()
        if len(column) == 1:
            column = ord(column) - ord('A') + 1
        else:
            column = (ord(column[0]) - ord('A') + 1) * 26 + ord(column[1]) - ord('A') + 1
        sheet_names = self.wb.sheetnames
        sh = self.wb[sheet_names[index]]
        sh.cell(row, column, data).data_type = "int"

    def save(self):
        self.wb.save(self.path)


class Automatic:
    """
    网页自动化操作
    """

    def __init__(self, driver):
        self.driver = driver
        self.action = ActionChains(self.driver)  # 鼠标事件
        self.wait = WebDriverWait(driver, 3, 0.5)  # 显性等待事件
        self.tm_url = 'https://loginmyseller.taobao.com/'
        self.jd_url = 'https://shop.jd.com/login/index.action'

    def mouse_hover(self, xpath):
        """
        鼠标悬停事件，无返回对象
        :param xpath:
        :return:
        """
        self.action.move_to_element(self.find(xpath)).perform()

    def obvious_wait(self, xpath):
        """
        显性等待事件，用来处理可能出现的点击事件，无返回对象
        :param xpath:
        :return:
        """
        try:
            self.wait.until(lambda x: x.find_element_by_xpath(xpath)).click()
        except:
            pass

    def find(self, xpath, obj=None):
        """
        寻找元素，不一定有，常用来做日期选择，返回element对象
        :param obj: 需要进行查找点击的前置对象,默认为self.driver
        :param xpath:
        :return:
        """
        if not obj:
            obj = self.driver
        return obj.find_element_by_xpath(xpath)

    def sure_click(self, xpath, obj=None):
        """
        一定要点击的元素，无返回对象
        :param obj: 需要进行查找点击的前置对象,默认为self.driver
        :param xpath:
        :return:
        """
        if not obj:
            obj = self.driver
        while True:
            try:
                obj.find_element_by_xpath(xpath).click()
                break
            except:
                pass

    def sure_text(self, xpath, obj=None):
        """
        一定要得到的元素值，返回文本内容
        :param obj: 需要进行查找点击的前置对象,默认为self.driver
        :param xpath:
        :return:
        """
        if not obj:
            obj = self.driver
        while True:
            try:
                text = obj.find_element_by_xpath(xpath).text
                if not text:
                    text = obj.find_element_by_xpath(xpath).get_attribute("textContent")
                    if not text:
                        text = obj.find_element_by_xpath(xpath).get_attribute("value")
                if text:
                    return text
            except:
                pass

    def login_tm(self, name, pwd):
        """
        登录天猫平台
        :param name: 账号
        :param pwd: 密码
        :return:
        """

        # 处理滑块验证
        def check_yzm(check_yzm_span):
            """
            处理滑动验证码，没有测试
            :param check_yzm_span:
            :return:
            """
            # 实例化一个动作链关联游览器
            action = ActionChains(self.driver)
            # 使用鼠标动作链进行点击并悬浮
            action.click_and_hold(check_yzm_span)
            # 滑动验证码
            action.move_by_offset(xoffset=350, yoffset=0).perform()
            time.sleep(1)
            # 再次点击登录按钮
            self.find('//*[@id="login-form"]/div[4]/button').click()

        def huakuai():  # 如果有滑块，则进入内层嵌套表单，并进行滑块处理
            while True:
                try:
                    self.driver.switch_to.frame('baxia-dialog-content')
                    check_yzm_span = self.find('//*[@id="nc_1_n1z"]')  # 延时定位滑动验证码标签，避免点击登录按钮之后，出现滑动验证码，不需要验证的情况
                    check_yzm(check_yzm_span)  # 处理滑动验证码
                except:
                    break
            time.sleep(1)

        self.driver.get(self.tm_url)
        self.driver.maximize_window()
        self.driver.switch_to.frame('alibaba-login-box')  # 进入iframe表单

        time.sleep(2)
        # 这里可能存在账号被记录，所以需要清空
        while self.find("//input[@id='fm-login-id']").get_attribute('value') != '':
            self.find("//input[@id='fm-login-id']").clear()
        while self.find("//input[@id='fm-login-password']").get_attribute('value') != '':
            self.find("//input[@id='fm-login-password']").clear()

        self.find("//input[@id='fm-login-id']").send_keys(name)  # 输入账号
        self.find("//input[@id='fm-login-password']").send_keys(pwd)  # 输入密码
        self.obvious_wait("//button[@type='submit']")  # 点击登录

        time.sleep(1)
        # 如果有滑块，则进入内层嵌套表单，并进行滑块处理
        huakuai()
        # 判断是否需要点击验证，再次滑动滑块
        while True:
            try:
                self.find("//div[@id='`nc_1_refresh1`']").click()
                self.driver.switch_to.default_content()
                huakuai()
            except:
                break

        # 如果存在短信验证，则提醒用户手动验证
        try:  # 1、直接跳转至短信验证页面
            self.driver.switch_to.default_content()  # 跳出滑块表单，点击登录
            self.driver.switch_to.frame('alibaba-login-box')
            try:
                time.sleep(5)
                self.find("//label[contains(text(), '验证码')]")
                tips('需要验证码，请手动完成后点击确定')
            except:
                self.obvious_wait("//button[@type='submit']")
        except:
            pass

        if self.driver.title == '验证码拦截':  # 跳转至另一个短信验证页面
            tips('需要验证码，请手动完成后点击确定')

        while True:
            if self.driver.title == '天猫千牛工作台':
                time.sleep(3)
                self.obvious_wait("//i[contains(@class, 'on-close')]")  # 存在提示信息，点击关闭
                break

        self.obvious_wait("//i[contains(@class, 'on-close')]")

    def logout_tm(self):
        """
        注销天猫账号
        :return:
        """
        self.driver.get('https://myseller.taobao.com/home.htm#/index')
        self.sure_click("//div[@class='login-info']/a[2]")

    def login_jd(self, name, pwd):
        """
        登录京东平台
        :param pwd: 账号
        :param name: 密码
        :return:
        """

        def Drag_the(block, juli, aLocal, H, W):
            """
            用于移动滑块
            """
            x = block.location.get('x')
            y = block.location.get('y')
            x1 = aLocal.get('x')
            y1 = aLocal.get('y')
            pyautogui.moveTo(x + x1 + W, y + y1 + H, duration=0.1)
            pyautogui.mouseDown()
            # 分为多段滑动
            count = 0
            i = 1
            o = 0
            while count < juli * 0.8:
                q = random.randint(10, 20)
                if q > o:
                    # print(q)
                    count += q
                    pyautogui.moveTo(x + x1 + W + count, y + y1 + H, duration=random.randint(1, 9) / (i * 100))
                    o = q
                    i += 1
                elif q == o:
                    # print(q)
                    count += q
                    pyautogui.moveTo(x + x1 + W + count, y + y1 + H, duration=random.randint(1, 9) / (i * 100))
                    o = 0
                    i += 1
            o = 10
            while count >= juli * 0.8 and count < juli:
                q = random.randint(1, 8)
                if q <= o:
                    # print(str(q)+"..")
                    count += q
                    pyautogui.moveTo(x + x1 + W + count, y + y1 + H, duration=random.randint(1, 9) / (i * 100))
            pyautogui.moveTo(x + x1 + W + juli - 2, y + y1 + H, duration=0.2)
            time.sleep(0.8)
            pyautogui.moveTo(x + x1 + W + juli - 1, y + y1 + H, duration=0.2)
            pyautogui.mouseUp()

        self.driver.get('https://shop.jd.com/')
        self.driver.maximize_window()
        # 获取屏幕大小
        winW, winH = pyautogui.size()
        self.sure_click("//div[contains(text(),  '账户登录')]")
        a = self.driver.find_element_by_id('loginFrame')
        # 获得iframe的网页位置
        iframeLocal = a.location
        h = self.find('//body')
        # 获得网页body的大小
        bodySize = h.size
        # 获得网页与屏幕顶端的高度差
        WHH = winH - bodySize.get('height')
        self.driver.switch_to.frame(a)
        self.driver.find_element_by_id('loginname').clear()
        self.driver.find_element_by_id('loginname').send_keys(name)
        self.driver.find_element_by_id('nloginpwd').clear()
        self.driver.find_element_by_id('nloginpwd').send_keys(pwd)
        try:
            time.sleep(1)
            self.driver.find_element_by_id('paipaiLoginSubmit').click()
        except:
            pass
        time.sleep(1)
        while True:
            try:
                bl = self.driver.find_element_by_class_name('JDJRV-smallimg > img')
            except NoSuchElementException:
                bl = False
            if bl != False:
                # 用于找到登录图片的大图
                bigimg = self.driver.find_element_by_class_name('JDJRV-bigimg > img').get_attribute("src")
                # 获得网页的显示的图片宽度
                htmlsize = self.driver.find_element_by_class_name('JDJRV-bigimg').size['width']
                # 用来找到登录图片的小滑块
                smallimg = self.driver.find_element_by_class_name('JDJRV-smallimg > img').get_attribute("src")
                # 背景大图命名
                backimg = "backimg.png"
                # 滑块命名
                slideimg = "slideimg.png"
                # 下载背景大图保存到本地
                request.urlretrieve(bigimg, backimg)
                # 下载滑块保存到本地
                request.urlretrieve(smallimg, slideimg)
                # 获取图片并灰度化
                block = cv2.imread(slideimg, 0)
                template = cv2.imread(backimg, 0)
                # 获取下载下来大图的宽
                bigsize = list(template.shape)[1]
                # 获取下载下来滑块的宽
                slidesize = list(block.shape)[1]

                # 获得缩放比例
                bili = htmlsize / bigsize
                # print(bili)
                # 二值化后的图片名称
                blockName = "block.jpg"
                templateName = "template.jpg"
                # 将二值化后的图片进行保存
                cv2.imwrite(blockName, block)
                cv2.imwrite(templateName, template)
                block = cv2.imread(blockName)
                block = cv2.cvtColor(block, cv2.COLOR_RGB2GRAY)
                block = abs(255 - block)
                cv2.imwrite(blockName, block)
                block = cv2.imread(blockName)
                template = cv2.imread(templateName)
                # 获取偏移量
                result = cv2.matchTemplate(block, template,
                                           cv2.TM_CCOEFF_NORMED)  # 查找block在template中的位置，返回result是一个矩阵，是每个点的匹配结果
                # print(result)
                x, y = np.unravel_index(result.argmax(), result.shape)
                # print("x方向的偏移", int(y*bili), 'x:', x, 'y:', y)
                # 获取滑块
                element = self.driver.find_element_by_class_name('JDJRV-smallimg > img')
                Drag_the(element, y * bili, iframeLocal, WHH, slidesize * bili / 2)
                time.sleep(3)
            else:
                break

        # 看是否需要短信验证
        while True:
            try:
                self.find("//a[text()='短信验证']").click()
                tips('需要短信验证，请手动完成后点击确定')
                break
            except:
                break

        while True:
            if self.driver.title == '京东商城:商家后台':
                self.obvious_wait("//div[@aria-label='公告提醒']/button")  # 存在提示信息，点击关闭
                self.obvious_wait("//div[@aria-label='京麦提示']/button")  # 存在提示信息，点击关闭
                break

    def logout_jd(self):
        """
        注销京东账号
        :return:
        """
        while True:
            try:
                self.driver.find_element_by_xpath("//a[contains(text(), '退出')]").click()
                break
            except:
                pass

    def get_data(self):

        self.login_tm('多走路旗舰店:数据', 'zhoucheng1234')
        time.sleep(5)
        self.logout_tm()
        time.sleep(5)
        self.login_jd('多走路旗舰店angel', 'zhoucheng1234')
        time.sleep(5)
        self.logout_jd()
        time.sleep(1000)


def start_run(time, path):
    def run():
        driver = create_driver()
        auto = Automatic(driver)
        auto.get_data()
        tips('数据写入完成')

    if DEBUG:
        run()
    else:
        try:
            run()
        except BaseException as err:
            tips("出现错误:" + str(err) + ",请联系开发人员")


def start():
    global GUI_TK
    root = Tk()
    root.geometry(f'{430}x{160}+{10}+{10}')
    root.title('多走路项目周报')
    GUI_TK = TkInterface(root)
    try:
        GUI_TK.draw_data()
    except BaseException as err:
        tips('错误：' + str(err))


if DEBUG:
    start()

二、包装器

包装器是 Tk 的形状管理机制之一。 形状管理器用于指定部件在容器内的相对位置——彼此的 宿主 关系。包装器可接受定性的相对关系—— 上面 、左边 、填充 等，并确定精确的放置坐标。

主部件的大小都由其内部的 “从属部件” 的大小决定。包装器用于控制从属部件在主部件中出现的位置。可以把部件包入框架，再把框架包入其他框架中，搭建出所需的布局。此外，只要完成了包装，组件的布局就会进行动态调整，以适应布局参数的变化。

注意：只有用形状管理器指定几何形状后，部件才会显示出来。忘记设置形状参数是新手常犯的错误，惊讶于创建完部件却啥都没出现。部件只有在应用了类似于打包器的 pack() 方法之后才会显示在屏幕上。

调用 pack() 方法时可以给出由关键字/参数值组成的键值对，以便控制组件在其容器中出现的位置，以及主程序窗口大小变动时的行为。

参数参考源码

import tkinter as tk

class App(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.pack()

        self.entrythingy = tk.Entry()
        self.entrythingy.pack()

        # 创建应用程序变量。
        self.contents = tk.StringVar()
        # 将其设置为某个值
        self.contents.set("this is a variable")
        # 告诉入口小部件监视这个变量。
        self.entrythingy["textvariable"] = self.contents

        # 定义当用户点击return时的回调函数。
        
        self.entrythingy.bind('<Key-Return>', self.print_contents)
                             
    # 输出当前变量的值。
    def print_contents(self, event):
        print("Hi. The current entry content is:",
              self.contents.get())

root = tk.Tk()
myapp = App(root)
myapp.mainloop()

三、关于布局

三种布局方式： 1、pack (指定相对位置，精确位置会自行调整,常用于简单的应用布局)2、grid (Grid 布局的过程就是为各个控件指定行号和列号的过程. 不需要为每个格子指定大小, Grid 布局会自动设置一个合适的大小.)3、place (Place 布局管理可以显式的指定控件的绝对位置或相对于其他控件的位置. )

参考博文grid布局详解

四、交互事件

复制'''
            1.遍历表格
            t = treeview.get_children()
            for i in t:
                print(treeview.item(i,'values'))
            2.绑定单击离开事件
            def treeviewClick(event):  # 单击
                for item in tree.selection():
                    item_text = tree.item(item, "values")
                    print(item_text[0:2])  # 输出所选行的第一列的值
            tree.bind('<ButtonRelease-1>', treeviewClick)  
            ------------------------------
            鼠标左键单击按下1/Button-1/ButtonPress-1 
            鼠标左键单击松开ButtonRelease-1 
            鼠标右键单击3 
            鼠标左键双击Double-1/Double-Button-1 
            鼠标右键双击Double-3 
            鼠标滚轮单击2 
            鼠标滚轮双击Double-2 
            鼠标移动B1-Motion 
            鼠标移动到区域Enter 
            鼠标离开区域Leave 
            获得键盘焦点FocusIn 
            失去键盘焦点FocusOut 
            键盘事件Key 
            回车键Return 
            控件尺寸变Configure
            ------------------------------
'''

五，滚动条

复制#创建滚动条示例
from tkinter import *
#创建主窗口
win = Tk()
#创建一个水平滚动条
scrollbarl = Scrollbar (win, orient=HORIZONTAL)
#水平滚动条位于窗口底端，当窗口改变大小时会在X方向填满窗口
scrollbarl.pack (side=BOTTOM, fill=X)
#创建一个垂直滚动条
scrollbar2 = Scrollbar (win)
#垂直滚动条位于窗口右端，当窗口改变大小时会在Y方向填满窗口
scrollbar2 .pack (side=RIGHT, fill=Y)
#创建一个列表框， x方向的滚动条指 令是scrollbarl 对象的set()方法，

#y方向的滚动条指令是scrollbar2对象的set()方法
mylist = Listbox (win, xscrollcommand=scrollbarl .set,
yscrollcommand= scrollbar2. set)
#在列表框内插入60个选项
for i in range(60) :
    mylist. insert (END, "火树银花合， 星桥铁锁开。暗尘随马去，明月逐人来。" + str(i))
    
#列表框位于窗口左端，当窗口改变大小时会在X与Y方向填满窗口
mylist.pack (side=LEFT, fill=BOTH)
#移动水平滚动条时,改变列表框的x方向可见范围
scrollbarl.config (command=mylist.xview)
#移动垂直滚动条时，改变列表框的y方向可见范围
scrollbar2. config (command=mylist. yview)
#开始程序循环
win. mainloop()

六、在线编辑表格

复制from tkinter import ttk
from tkinter import *
root = Tk()  # 初始框的声明
columns = ("姓名", "IP地址")
treeview = ttk.Treeview(root, height=18, show="headings", columns=columns)  # 表格
 
treeview.column("姓名", width=100, anchor='center') # 表示列,不显示
treeview.column("IP地址", width=300, anchor='center')
 
treeview.heading("姓名", text="姓名") # 显示表头
treeview.heading("IP地址", text="IP地址")
 
treeview.pack(side=LEFT, fill=BOTH)
 
name = ['电脑1','服务器','笔记本']
ipcode = ['10.13.71.223','10.25.61.186','10.25.11.163']
for i in range(min(len(name),len(ipcode))): # 写入数据
    treeview.insert('', i, values=(name[i], ipcode[i]))
 
 
def treeview_sort_column(tv, col, reverse):  # Treeview、列名、排列方式
    l = [(tv.set(k, col), k) for k in tv.get_children('')]
    l.sort(reverse=reverse)  # 排序方式
    # rearrange items in sorted positions
    for index, (val, k) in enumerate(l):  # 根据排序后索引移动
        tv.move(k, '', index)
    tv.heading(col, command=lambda: treeview_sort_column(tv, col, not reverse))  # 重写标题，使之成为再点倒序的标题
 
def set_cell_value(event): # 双击进入编辑状态
    for item in treeview.selection():
        #item = I001
        item_text = treeview.item(item, "values")
        #print(item_text[0:2])  # 输出所选行的值
    column= treeview.identify_column(event.x)# 列
    row = treeview.identify_row(event.y)  # 行
    cn = int(str(column).replace('#',''))
    rn = int(str(row).replace('I',''))
    entryedit = Text(root,width=10+(cn-1)*16,height = 1)
    entryedit.place(x=16+(cn-1)*130, y=6+rn*20)
    def saveedit():
        treeview.set(item, column=column, value=entryedit.get(0.0, "end"))
        entryedit.destroy()
        okb.destroy()
    okb = ttk.Button(root, text='OK', width=4, command=saveedit)
    okb.place(x=90+(cn-1)*242,y=2+rn*20)
 
def newrow():
    name.append('待命名')
    ipcode.append('IP')
    treeview.insert('', len(name)-1, values=(name[len(name)-1], ipcode[len(name)-1]))
    treeview.update()
    newb.place(x=120, y=(len(name)-1)*20+45)
    newb.update()
 
treeview.bind('<Double-1>', set_cell_value) # 双击左键进入编辑
newb = ttk.Button(root, text='新建联系人', width=20, command=newrow)
newb.place(x=120,y=(len(name)-1)*20+45)
 
 
for col in columns:  # 绑定函数，使表头可排序
    treeview.heading(col, text=col, command=lambda _col=col: treeview_sort_column(treeview, _col, False))
'''
1.遍历表格
t = treeview.get_children()
for i in t:
    print(treeview.item(i,'values'))
2.绑定单击离开事件
def treeviewClick(event):  # 单击
    for item in tree.selection():
        item_text = tree.item(item, "values")
        print(item_text[0:2])  # 输出所选行的第一列的值
tree.bind('<ButtonRelease-1>', treeviewClick)  
------------------------------
鼠标左键单击按下1/Button-1/ButtonPress-1 
鼠标左键单击松开ButtonRelease-1 
鼠标右键单击3 
鼠标左键双击Double-1/Double-Button-1 
鼠标右键双击Double-3 
鼠标滚轮单击2 
鼠标滚轮双击Double-2 
鼠标移动B1-Motion 
鼠标移动到区域Enter 
鼠标离开区域Leave 
获得键盘焦点FocusIn 
失去键盘焦点FocusOut 
键盘事件Key 
回车键Return 
控件尺寸变Configure
------------------------------
'''
 
root.mainloop()  # 进入消息循环

七、打开文件或文件夹

复制# 选择文件
askopenfilename()
# 选择文件夹
askdirectory()
# 选择文件保存
asksaveasfilename

八、获取treeview的值

复制treeview.item(item, option='values')

九、窗口关闭事件

复制import tkinter as tk
root = tk.Tk()
root.protocol('WM_DELETE_WINDOW', root.iconify)
root.protocol('WM_DELETE_WINDOW', root.destroy)
root.protocol('WM_DELETE_WINDOW', customized_function)
# 使用protocol函数，绑定关闭事件到一个指定的函数入口。
# 如果绑定root.iconify，点击关闭（X），就是最小化窗口，而不是关闭。

十、下拉框

复制# 新建下拉框
cmb = Combobox(self.root)
# 设置下拉框中的值
cmb['value'] = ('模板一', '模板二')
# 设置默认值，从零开始
cmb.current(1)
# 绑定选择事件
cmb.bind("<<ComboboxSelected>>", func)
# 设置下拉框长度
cmb.config(width=10)
# 一定要先设置属性，在设置布局
cmb.place(x=150, y=10)

十一、LabelFrame

复制# 新建LabelFrame，并设置大小
labelframe = LabelFrame(self.root, text='选择模板样式', height=143, width=260)
# 固定大小使其不在改变
labelframe.grid_propagate(0)
# 设置单选框
Radiobutton(labelframe, text='方案一').grid(row=0, column=0, padx=3, pady=5, sticky=W)
Radiobutton(labelframe, text='方案二').grid(row=0, column=1, padx=3, pady=5, sticky=W)
Radiobutton(labelframe, text='方案三').grid(row=0, column=2, padx=3, pady=5, sticky=W)
# Label(labelframe, bg='red').place(x=0, y=50)# grid(row=0, column=0, pady=50)
labelframe.place(x=215, y=30)

十二、单选框选定事件

复制# 单选按钮回调函数,就是当单选按钮被点击会执行该函数
def radCall():
    radSel = radVar.get()
    if radSel == 1:
        win.configure(background=COLOR1)      # 设置整个界面的背景颜色
  elif radSel == 2:
        win.configure(background=COLOR2)
    elif radSel == 3:
        win.configure(background=COLOR3)

radVar = tk.IntVar()    # 通过tk.IntVar() 获取单选按钮value参数对应的值
# 将同一组的单选框放入同一组中：variable相同
rad1 = tk.Radiobutton(win, text=COLOR1, variable=radVar, value=1, command=radCall)      
# 当该单选按钮被点击时，会触发参数command对应的函数
rad1.grid(column=0, row=5, sticky=tk.W)     # 参数sticky对应的值参考复选框的解释

rad2 = tk.Radiobutton(win, text=COLOR2, variable=radVar, value=2, command=radCall)
rad2.grid(column=1, row=5, sticky=tk.W)

rad3 = tk.Radiobutton(win, text=COLOR3, variable=radVar, value=3, command=radCall)
rad3.grid(column=2, row=5, sticky=tk.W)


# 单选框选择
VT = IntVar(self.root)
try:
    VT.set(getData()['模板'])
except:
    VT.set(1)
# 模板选择与下载
frame_week = LabelFrame(self.root, text='请选择周报模板', height=50, width=250)
Radiobutton(frame_week, text='模板一', variable=VT, value=1).grid(row=0, column=0)
# Radiobutton(frame_week, text='模板二', variable=VT, value=2).grid(row=0, column=1)
frame_week.place(x=15, y=120)
frame_week.grid_propagate(0)

Label1 = Label(self.root, text='下载模板一', fg='blue', font=('宋体', 10, "underline"))
Label1.bind("<Button-1>", download_template_one)
Label1.place(x=270, y=130)

复选框

复制def data_class_select():
    """
    数据项选择
    :return:
    """
    try:
        list_all = getData()['数据类']
    except:
        list_all = ['月销', '累计评价', '库存']

    Temporary_window = Toplevel(self.root)
    Temporary_window.title('数据项选择')
    Temporary_window.geometry('520x200+440+250')

    labelframe = LabelFrame(Temporary_window, text='请选择需要获取的数据',  height=103, width=360)
    labelframe.grid_propagate(0)

    Label(Temporary_window, text='竞店商品信息:').place(x=15, y=20)
    class_list = [
        '商品链接', '商品标题', '月销', '累计评价', '库存', '预定件数', '收藏人气', '颜色', '价格'
    ]

    for index, txt in enumerate(class_list):
        exec("self.v{} = IntVar(self.root)".format(index))
        if class_list[index] in list_all:
            exec("self.v{}.set(1)".format(index))
        else:
            exec("self.v{}.set(0)".format(index))


    rwo_s = 0
    column_s = 0
    for index, txt in enumerate(class_list):
        if column_s >= 5:
            column_s = 0
            rwo_s += 1

        exec("check{} = Checkbutton(labelframe, text=txt, variable=self.v{})".format(index, index))
        exec("check{}.grid(row=rwo_s, column=column_s)".format(index))

        column_s += 1

    def save():
        print(self)
        list_data = []
        for index, txt in enumerate(class_list):
            exec("if self.v{}.get() == 1: list_data.append(class_list[{}])".format(index, index))

        data = getData()
        data['数据类'] = list_data
        setData(data)
        Temporary_window.destroy()

    labelframe.place(x=110, y=20)
    Button(Temporary_window, text='保存设置', command=save).place(x=220, y=150)

获取复选框的文本值

复制check_flow1['text']

十三、显示图片

复制# 获取预览图
from PIL import Image, ImageTk
my_image = Image.open("./internal_data/img/Preview.jpg")
filename = ImageTk.PhotoImage(my_image)
# 相关配置
lab = Label(Temporary_window)
lab.config(image=filename)
lab.image = filename
lab.pack()

# 图片按钮
photo_show = PhotoImage(file=share_root_path + "/icon/show_pwd.png")
# 方法一
photo_x = int(photo_show.width() / 15)
photo_y = int(photo_show.height() / 15)
photo_show = photo_show.subsample(photo_x, photo_y)# 正数缩小
# 方法二
photo_show = photo_show.zoom(25, 25)
photo_show = photo_show.subsample(50, 50)



Button(self.root, text='账号设置', image=photo_show, command=setaccount).place(x=110, y=115)

十四、创建临时窗口

复制Temporary_window = Toplevel(self.root)
Temporary_window.title('请配置参数')
Temporary_window.geometry('330x150+440+250')

# 关闭临时窗口
Temporary_window.destroy()

十五、自适应多行文本框

复制def judge_email(event=None):  # 失去焦点
    i=1
    while True:
        if txt3.get(0.0, 'end')[-i] != '\n':
            break
        else:
            i+=1
    print(txt3.get(0.0, 'end')[:-i+1].split('\n'))
    for mail in txt3.get(0.0, 'end')[:-i+1].split('\n'):
        if not is_valid_email(mail):

            tips('\''+mail + '\'' + '邮箱地址格式不对，请使用公司邮箱')
            return False
    else:
        return txt3.get(0.0, 'end')[:-i+1].split('\n')

def huanhuang(event):  # 换行
    Temporary_window.geometry('350x{}+440+250'.format(170 + 20*self.hang_num))
    determine_buttion.place(x=110, y=125 + 20*self.hang_num)
    cancel_button.place(x=210, y=125 + 20*self.hang_num)
    self.hang_num += 1
    # 重点
    txt3.config(height=self.hang_num)
    
   

txt3.bind('<Return>', huanhuang)  # 组件绑定回车事件
txt3.bind('<FocusOut>', judge_email)  # 失去焦点

十六、下载模板按钮

复制def download_template_one(event):
  """
  下载模板一
  :return:
  """
  filepath = askdirectory()
  copyfile(local_path + '/TemplateOne.xlsx', filepath + '/商品信息模板一.xlsx')
  tips('文件已下载完成，即将自动打开，请注意查看')
  os.startfile(filepath + '/商品信息模板一.xlsx')


Label1 = Label(self.root, text='模板一选品表模板下载', fg='blue',
               font=('宋体', 10, "underline"))
Label1.bind("<Button-1>", download_template_one)
Label1.place(x=195, y=174)

十七、对话框

复制result=tkinter.messagebox.askokcancel ("提示"," 你确定要关闭窗口吗? ")
# 返回布尔值参数
print(result)

三、封装常用函数

1、悬浮提示窗口

复制def CreateToolTip(widget, text):
    """
    悬浮窗口提示函数
    :param widget: 悬浮组件
    :param text: 悬浮提示文本内容
    :return:
    """
    class ToolTip(object):
        """
        悬浮窗口提示
        """
        def __init__(self, widget):
            self.widget = widget
            self.tipwindow = None
            self.id = None
            self.x = self.y = 0

        # 当光标移动指定控件时显示消息
        def showtip(self, text):
            "Display text in tooltip window"
            text = str(text)
            if text == 'None' or text == '':
                text = '暂无简介'
            finalnum = len(text) % 25
            if finalnum == 0:
                b = re.findall(r'.{25}', text)
                c = '\n'.join(b)
            else:
                b = re.findall(r'.{25}', text)
                c = '\n'.join(b)
                if c == '':
                    c = text[len(text) - finalnum:]
                else:
                    c = c + '\n' + text[len(text) - finalnum:]
            # print(c)
            self.text = c
            if self.tipwindow or not self.text:
                return
            x, y, cx, cy = self.widget.bbox("insert")
            x = x + self.widget.winfo_rootx() + 30
            y = y + cy + self.widget.winfo_rooty() + 30
            self.tipwindow = tw = Toplevel(self.widget)
            tw.wm_overrideredirect(1)
            tw.wm_geometry("+%d+%d" % (x, y))
            label = Label(tw, text=self.text, justify=LEFT,
                          background="white", relief=SOLID, borderwidth=1,
                          font=("微软雅黑", "10"))
            label.pack(side=BOTTOM)
            tw.wm_attributes('-topmost', True)

        # 当光标移开时提示消息隐藏
        def hidetip(self):
            tw = self.tipwindow
            self.tipwindow = None
            if tw:
                tw.destroy()

    toolTip = ToolTip(widget)

    def enter(event):
        toolTip.showtip(text)

    def leave(event):
        toolTip.hidetip()

    widget.bind('<Enter>', enter)
    widget.bind('<Leave>', leave)

2、账号填写（单平台多账号）

复制def setaccount():
    """
    配置账号信息
    :return:
    """
    photo_show = PhotoImage(file=share_root_path + "/icon/show_pwd.png")
    photo_x = int(photo_show.width() / 15)
    photo_y = int(photo_show.height() / 15)
    photo_show = photo_show.subsample(photo_x, photo_y)

    photo_noshow = PhotoImage(file=share_root_path + "/icon/noshow_pwd.png")
    photo_x = int(photo_noshow.width() / 15)
    photo_y = int(photo_noshow.height() / 15)
    photo_noshow = photo_noshow.subsample(photo_x, photo_y)

    # 点击次数
    DoubleNum = 0
    # 获取缓存中的数据
    data = getData()
    try:
        names = data['账号']
        pwds = data['密码']
        email_addr = data['邮箱地址']
    except:
        names = []
        pwds = []
        email_addr = ''

    # def show_pwd():
    #     """
    #     显示密码
    #     :return:
    #     """
    #     nonlocal DoubleNum
    #     DoubleNum += 1
    #     if DoubleNum % 2:
    #         ent2.config(show='')
    #         show_button.config(image=photo_show)
    #     else:
    #         ent2.config(show='*')
    #         show_button.config(image=photo_noshow)

    Temporary_window = Toplevel(GUI)
    Temporary_window.title('京东店铺账号相关参数配置')
    Temporary_window.geometry('520x{}+440+250'.format(175 + 30 * len(names)))

    frame = Frame(Temporary_window)
    frame_top = Frame(frame)
    frame_right = Frame(frame)

    global row
    row = 0
    if len(names) == 0:
        Label(frame_top, text='京东账号：').grid(row=0, column=0, sticky=E, pady=3)
        ent1 = Entry(frame_top)
        ent1.grid(row=0, column=1, pady=7, padx=2, sticky=W)

        Label(frame_top, text='京东密码：').grid(row=0, column=2, sticky=E, pady=3)
        ent2 = Entry(frame_top)
        ent2.config(show='*')
        ent2.grid(row=0, column=3, pady=7, padx=2, sticky=W)
    else:
        for name, pwd in zip(names, pwds):
            Label(frame_top, text='京东账号：').grid(row=row, column=0, sticky=E, pady=3)
            Label(frame_top, text='京东密码：').grid(row=row, column=2, sticky=E, pady=3)

            exec("ent{}_1 = Entry(frame_top)".format(row))
            exec("ent{}_1.insert('insert', name)".format(row))
            exec("ent{}_1.grid(row=row, column=1, pady=7, padx=2, sticky=W)".format(row))

            exec("ent{}_2 = Entry(frame_top, show='*')".format(row))
            exec("ent{}_2.insert('insert', pwd)".format(row))
            exec("ent{}_2.grid(row=row, column=3, pady=7, padx=2, sticky=W)".format(row))

            row += 1
        row -= 1
        Temporary_window.geometry('520x{}+440+250'.format(175 + 35 * row))

    lab_email = Label(Temporary_window, text='请输入邮箱地址：')
    lab_email.place(x=35, y=70 + 35 * row)
    ent3 = Entry(Temporary_window)
    ent3.insert("insert", email_addr)
    ent3.place(x=140, y=72 + 35 * row)

    frame.place(x=35, y=25)
    frame_top.grid(row=0, column=0, sticky=NE)
    frame_right.grid(row=0, column=1, sticky=NW)

    def save():
        """
        保存设置
        :return:
        """
        name_list = []
        pwd_list = []
        indexs = 0
        for ss in frame.children['!frame'].children:
            if 'entry' in ss:
                if indexs % 2 == 0:
                    name_list.append(frame.children['!frame'].children[ss].get())
                else:
                    pwd_list.append(frame.children['!frame'].children[ss].get())
                indexs += 1

        name_list2 = []
        pwd_list2 = []

        for index in range(len(name_list)):
            if name_list[index] == '' and pwd_list[index] == '':
                continue
            elif not (name_list[index] != '' and pwd_list[index] != ''):
                tips('存在未填写完整的账号，请填写完整')
                return False

            elif '\n' in name_list[index]:
                if name_list[index][-1] == '\n':
                    pass
                else:
                    tips('存在异常账号：' + name_list[index] + '，请重新填写')
                    return False

            if name_list[index][-1] == '\n':
                name_list2.append(name_list[index][:-1])
            else:
                name_list2.append(name_list[index])

            pwd_list2.append(pwd_list[index])

        data = getData()
        data['账号'] = name_list2
        data['密码'] = pwd_list2
        data['邮箱地址'] = ent3.get()
        setData(data)

        Temporary_window.destroy()

    def newshop():  # 新增店铺
        global row
        row += 1
        Temporary_window.geometry('520x{}+{}+{}'.format(175 + 35 * row, Temporary_window.winfo_x(), Temporary_window.winfo_y()))

        Label(frame_top, text='京东账号：').grid(row=row, column=0, sticky=E, pady=3)
        Label(frame_top, text='京东密码：').grid(row=row, column=2, sticky=E, pady=3)

        ent1 = Entry(frame_top)
        ent1.grid(row=row, column=1, pady=7, padx=2, sticky=W)
        ent2 = Entry(frame_top, show='*')
        ent2.grid(row=row, column=3, pady=7, padx=2, sticky=W)

        lab_email.place(x=35, y=70 + 35 * row)
        ent3.place(x=140, y=70 + 35 * row)
        save_button.place(x=170, y=115 + 35 * row)
        new_button.place(x=300, y=115 + 35 * row)

    save_button = Button(Temporary_window, text='保存设置', command=save)
    new_button = Button(Temporary_window, text='新增账号', command=newshop)
    save_button.place(x=170, y=115 + 35 * row)
    new_button.place(x=300, y=115 + 35 * row)

3、账号填写（多平台单账号）

复制def setaccount():
    """
    配置账号信息
    :return:
    """
    photo_show = PhotoImage(file=share_root_path + "/icon/show_pwd.png")
    photo_x = int(photo_show.width() / 15)
    photo_y = int(photo_show.height() / 15)
    photo_show = photo_show.subsample(photo_x, photo_y)

    photo_noshow = PhotoImage(file=share_root_path + "/icon/noshow_pwd.png")
    photo_x = int(photo_noshow.width() / 15)
    photo_y = int(photo_noshow.height() / 15)
    photo_noshow = photo_noshow.subsample(photo_x, photo_y)

    # 点击次数
    TmDoubleNum = 0
    JdDoubleNum = 0
    # 获取缓存中的数据
    data = getData()
    try:
        tm_name = data['天猫账号']
        tm_pwd = data['天猫密码']
        jd_name = data['京东账号']
        jd_pwd = data['京东密码']
        email_addr = data['邮箱地址']
    except:
        tm_name = ''
        tm_pwd = ''
        jd_name = ''
        jd_pwd = ''
        email_addr = ''

    def show_tm_pwd():
        """
        显示密码
        :return:
        """
        nonlocal TmDoubleNum
        TmDoubleNum += 1
        if TmDoubleNum % 2:
            tm_pwd_ent.config(show='')
            show_tm_button.config(image=photo_show)
        else:
            tm_pwd_ent.config(show='*')
            show_tm_button.config(image=photo_noshow)

    def show_jd_pwd():
        """
        显示密码
        :return:
        """
        nonlocal JdDoubleNum
        JdDoubleNum += 1
        if JdDoubleNum % 2:
            jd_pwd_ent.config(show='')
            show_jd_button.config(image=photo_show)
        else:
            jd_pwd_ent.config(show='*')
            show_jd_button.config(image=photo_noshow)

    def assembly_forget():  # 组件隐藏
        email_lab.pack_forget()
        ent3.grid_forget()
        save_buton.grid_forget()
        close_buton.grid_forget()

    def fixed_size():  # 固定大小，使其不变
        frame_tm.grid_propagate(0)
        frame_jd.grid_propagate(0)

    def tm_chexk_download(event):
        """
        是否下载天猫数据
        :param event:
        :return:
        """

        if tm_v.get():  # 点击之前为1，此时表示0
            if jd_v.get():  # 0,1
                frame_tm.grid_forget()
                frame_jd.grid(row=2, column=0, sticky=NW)
                fixed_size()

                Temporary_window.geometry(
                    '350x235+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=156)
                ent3.place(x=140, y=156)
                save_buton.place(x=110, y=190)
                close_buton.place(x=210, y=190)

            else:  # 0,0
                tips('至少选择一个店铺')
                return False

        else:  # 点击之前为0，此时表示1
            if jd_v.get():  # 1,1
                frame_tm.grid(row=1, column=0, sticky=NW)
                frame_jd.grid(row=2, column=0, sticky=NW)
                fixed_size()

                Temporary_window.geometry(
                    '350x345+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=258)
                ent3.place(x=140, y=258)
                save_buton.place(x=110, y=295)
                close_buton.place(x=210, y=295)

            else:  # 1，0
                frame_tm.grid(row=1, column=0, sticky=NW)
                frame_jd.grid_forget()
                fixed_size()

                Temporary_window.geometry(
                    '350x235+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=156)
                ent3.place(x=140, y=156)
                save_buton.place(x=110, y=190)
                close_buton.place(x=210, y=190)

    def jd_chexk_download(event):
        """
        是否下载京东数据
        :param event:
        :return:
        """
        if jd_v.get():  # 点击之前为1，此时表示0
            if tm_v.get():  # 1,0
                frame_tm.grid(row=2, column=0, sticky=NW)
                frame_jd.grid_forget()

                fixed_size()

                Temporary_window.geometry(
                    '350x235+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=156)
                ent3.place(x=140, y=156)
                save_buton.place(x=110, y=190)
                close_buton.place(x=210, y=190)

            else:  # 0,0
                tips('至少选择一个店铺')
                return False

        else:  # 点击之前为0，此时表示1
            if tm_v.get():  # 1,1
                frame_tm.grid(row=1, column=0, sticky=NW)
                frame_jd.grid(row=2, column=0, sticky=NW)
                fixed_size()
                Temporary_window.geometry(
                    '350x345+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=258)
                ent3.place(x=140, y=258)
                save_buton.place(x=110, y=295)
                close_buton.place(x=210, y=295)
            else:  # 0,1
                frame_jd.grid(row=1, column=0, sticky=NW)
                frame_tm.grid_forget()
                fixed_size()

                Temporary_window.geometry(
                    '350x235+{}+{}'.format(Temporary_window.winfo_x(), Temporary_window.winfo_y()))

                assembly_forget()

                email_lab.place(x=35, y=156)
                ent3.place(x=140, y=156)
                save_buton.place(x=110, y=190)
                close_buton.place(x=210, y=190)

    def save():
        """
        保存设置
        :return:
        """
        data = getData()
        data['天猫账号'] = tm_name_ent.get()
        data['天猫密码'] = tm_pwd_ent.get()
        data['京东账号'] = jd_name_ent.get()
        data['京东密码'] = jd_pwd_ent.get()

        data['下载天猫'] = tm_v.get()
        data['下载京东'] = jd_v.get()

        data['邮箱地址'] = ent3.get()

        setData(data)

        Temporary_window.destroy()

    def close():
        Temporary_window.destroy()

    Temporary_window = Toplevel(GUI)
    Temporary_window.title('请配置参数')
    Temporary_window.geometry('350x345+440+250')

    frame = Frame(Temporary_window)
    frame_tm = LabelFrame(frame, text='天猫店铺', height=100, width=280)
    frame_jd = LabelFrame(frame, text='京东店铺', height=100, width=280)

    tm_v = IntVar(Temporary_window)
    try:
        tm_v.set(getData()['下载天猫'])
    except:
        tm_v.set(1)

    jd_v = IntVar(Temporary_window)
    try:
        jd_v.set(getData()['下载京东'])
    except:
        jd_v.set(1)

    tm_check = Checkbutton(Temporary_window, text='淘宝_生意参谋', variable=tm_v)
    jd_check = Checkbutton(Temporary_window, text='京东_商智', variable=jd_v)
    tm_check.place(x=40, y=15)
    jd_check.place(x=210, y=15)

    tm_check.bind('<Button-1>', tm_chexk_download)
    jd_check.bind('<Button-1>', jd_chexk_download)

    Label(frame_tm, text='请输入店铺账号：').grid(row=2, column=0, sticky=E, pady=3)
    Label(frame_tm).grid(pady=10)
    Label(frame_tm, text='请输入店铺密码：').grid(row=3, column=0, sticky=E, pady=3)
    Label(frame_tm).grid(pady=5)

    # 天猫店铺账号
    tm_name_ent = Entry(frame_tm)
    tm_name_ent.insert("insert", tm_name)
    tm_name_ent.grid(row=2, column=1, pady=7, padx=2, sticky=W)
    # 天猫店铺密码
    tm_pwd_ent = Entry(frame_tm)
    tm_pwd_ent.config(show='*')
    tm_pwd_ent.insert("insert", tm_pwd)
    tm_pwd_ent.grid(row=3, column=1, pady=7, padx=2, sticky=W)

    Label(frame_jd, text='请输入店铺账号：').grid(row=2, column=0, sticky=E, pady=3)
    Label(frame_jd).grid(pady=10)
    Label(frame_jd, text='请输入店铺密码：').grid(row=3, column=0, sticky=E, pady=3)
    Label(frame_jd).grid(pady=5)

    # 京东店铺账号
    jd_name_ent = Entry(frame_jd)
    jd_name_ent.insert("insert", jd_name)
    jd_name_ent.grid(row=2, column=1, pady=7, padx=2, sticky=W)
    # 京东店铺密码
    jd_pwd_ent = Entry(frame_jd)
    jd_pwd_ent.config(show='*')
    jd_pwd_ent.insert("insert", jd_pwd)
    jd_pwd_ent.grid(row=3, column=1, pady=7, padx=2, sticky=W)

    show_tm_button = Button(frame_tm, image=photo_noshow, borderwidth=0, command=show_tm_pwd)
    show_jd_button = Button(frame_jd, image=photo_noshow, borderwidth=0, command=show_jd_pwd)
    show_tm_button.place(x=250, y=48)
    show_jd_button.place(x=250, y=48)

    frame.place(x=35, y=45)
    frame_tm.grid(row=0, column=0, sticky=NE)
    # Label(frame).grid(row=1, column=0, sticky=NE)  # 占位符
    frame_jd.grid(row=2, column=0, sticky=NW)
    frame_tm.grid_propagate(0)
    frame_jd.grid_propagate(0)

    # 邮箱地址配置
    email_lab = Label(Temporary_window, text='接收异常提示邮箱：')
    email_lab.place(x=25, y=258)

    ent3 = Entry(Temporary_window)
    ent3.insert("insert", email_addr)
    ent3.place(x=140, y=258)

    save_buton = Button(Temporary_window, text='确定', command=save)
    close_buton = Button(Temporary_window, text='取消', command=close)
    save_buton.place(x=110, y=295)
    close_buton.place(x=210, y=295)

    if not tm_v.get():
        frame_jd.grid(row=1, column=0, sticky=NW)
        frame_tm.grid_forget()
        Temporary_window.geometry('350x235+440+250')

        email_lab.place(x=35, y=156)
        ent3.place(x=140, y=156)
        save_buton.place(x=110, y=190)
        close_buton.place(x=210, y=190)

    if not jd_v.get():
        frame_tm.grid(row=1, column=0, sticky=NW)
        frame_jd.grid_forget()
        Temporary_window.geometry('350x235+440+250')

        email_lab.place(x=35, y=156)
        ent3.place(x=140, y=156)
        save_buton.place(x=110, y=190)
        close_buton.place(x=210, y=190)

4、单平台，单账号填写

复制photo_show = PhotoImage(file=share_root_path + "/icon/show_pwd.png")
photo_x = int(photo_show.width() / 15)
photo_y = int(photo_show.height() / 15)
photo_show = photo_show.subsample(photo_x, photo_y)

photo_noshow = PhotoImage(file=share_root_path + "/icon/noshow_pwd.png")
photo_x = int(photo_noshow.width() / 15)
photo_y = int(photo_noshow.height() / 15)
photo_noshow = photo_noshow.subsample(photo_x, photo_y)

# 点击次数
DoubleNum = 0
# 获取缓存中的数据
data = getData()
try:
name = data['账号']
pwd = data['密码']
email_addr = data['邮箱地址']
except:
name = ''
pwd = ''
email_addr = ''

def show_pwd():
"""
显示密码
:return:
"""
nonlocal DoubleNum
DoubleNum += 1
if DoubleNum % 2:
ent2.config(show='')
show_button.config(image=photo_show)
else:
ent2.config(show='*')
show_button.config(image=photo_noshow)

frame = Frame(GUI)
frame_left = Frame(frame)
frame_right = Frame(frame)

Label(frame_left, text='请输入店铺账号：').grid(row=2, column=0, sticky=E, pady=3)
Label(frame_left).grid(pady=10)
Label(frame_left, text='请输入店铺密码：').grid(row=3, column=0, sticky=E, pady=3)
Label(frame_left).grid(pady=5)
Label(frame_left, text='请输入邮箱地址：').grid(row=4, column=0, sticky=E, pady=3)
Label(frame_left).grid(pady=5)

ent1 = Entry(frame_right)
ent1.insert("insert", name)
ent1.grid(row=1, column=0, pady=7, padx=2, sticky=W)

ent2 = Entry(frame_right)
ent2.config(show='*')
ent2.insert("insert", pwd)
ent2.grid(row=2, column=0, pady=7, padx=2, sticky=W)

ent3 = Entry(frame_right)
ent3.insert("insert", email_addr)
ent3.grid(row=3, column=0, pady=7, padx=2, sticky=W)

frame.place(x=35, y=65)
frame_left.grid(row=0, column=0, sticky=NE)
frame_right.grid(row=0, column=1, sticky=NW)

def save():
"""
保存设置
:return:
"""
try:
data = getData()
data['账号'] = ent1.get()
data['密码'] = ent2.get()
data['邮箱地址'] = ent3.get()

setData(data)
return True
except BaseException as err:
tips('错误：' + str(err))


show_button = Button(GUI, image=photo_noshow, borderwidth=0, command=show_pwd)
show_button.place(x=290, y=110)