Kivy 项目51斩百词 2

MRWord\utils\youdao.py

import uuid
import requests
import hashlib
import time
import json
import logging

# pip install beautifulsoup4
from bs4 import BeautifulSoup
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/538.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/538.36'
}

def get_audio(name, url):
    """ 获取url中的读音并写入MP3文件夹中 """
    logging.info(url)
    r = requests.get(url, headers=headers)
    logging.info('requests is running')
    if r.status_code == 200:
        with open("mp3/%s.mp3" % name, "wb") as code:
            code.write(r.content)
            logging.info("download %s mp3 successfully" % name)
    else:
        logging.info('aidUrl to return error: %d' % r.status_code)

code.write()

在Python中，code.write() 是文件对象的一个方法，用于将字符串数据写入到文件中。在这个特定的上下文中，code 是一个文件对象，它已经被以二进制写入模式（"wb"）打开，因此它可以用来写入二进制数据，比如音频文件的内容。

这里是 code.write() 方法的基本用法：

with open("filename.ext", "wb") as code:  
    # 假设 data 是一个二进制字符串或者字节对象  
    data = b"This is some binary data."  
    code.write(data)

在示例中，code.write(r.content) 用于将HTTP GET请求返回的二进制内容（通常是音频文件的原始数据）写入到文件中。r.content 是一个字节串（bytes object），它包含了从URL下载的数据。

%d

在 Python 中，%d 是一个旧的字符串格式化操作符，用于将整数（integer）插入到字符串中的指定位置。这个操作符与 % 格式化方法一起使用，它允许你指定一个或多个占位符，并在调用格式化方法时提供相应的值来替换这些占位符。

下面是一个使用 %d 的 Python 示例：

num = 123  
formatted_string = "The number is: %d" % num  
print(formatted_string)

这段代码会输出：

The number is: 123

在这个例子中，%d 是一个占位符，它会被后面的 num 变量的值（即 123）所替代。

然而，值得注意的是，从 Python 2.6 开始，引入了新的字符串格式化方法，如 str.format()，它在 Python 3 中得到了进一步的改进和推广。使用 str.format() 方法，你可以更灵活、更清晰地格式化字符串。

以下是使用 str.format() 的示例：

num = 123  
formatted_string = "The number is: {}".format(num)  
print(formatted_string)

这段代码的输出与之前的示例相同。

在 Python 3.6 及以上版本中，还引入了 f-string（格式化字符串字面量），这是一种更简洁、更直观的方式来格式化字符串：

num = 123  
formatted_string = f"The number is: {num}"  
print(formatted_string)

f-string 以 f 或 F 开头，并在大括号 {} 中包含要格式化的表达式。在这个例子中，{num} 会被 num 变量的值（即 123）所替代。

class OfficialAPI:
    """ 调用有道云API """
    UPI_DAO_URL = 'http://openapi.youdao.com/api'
    # 请重新申请
    APP_KEY = ''
    APP_SECRET = ''

    @staticmethod
    def encrypt(sign_str):
        hash_algorithm = hashlib.sha256()
        hash_algorithm.update(sign_str.encode('utf-8'))
        return hash_algorithm.hexdigest()

encrypt   美/ɪnˈkrɪpt/  v.把……加密，将……译成密码

algorithm  美/ˈælɡərɪðəm/  n.（尤指计算机）算法，运算法则

.hexdigest()

在Python的hashlib模块中，哈希对象（比如SHA-256）有一个.hexdigest()方法，这个方法用于获取哈希值的十六进制表示（hexadecimal digest）。

hexadecimal   美/ˌheksəˈdesɪml/   n.十六进制

当你对一个字符串或字节串使用哈希函数（如SHA-256）时，你得到的是一个固定长度的字节串，这个字节串代表了输入数据的哈希值。但是，这个字节串对于人类来说不是很容易阅读或处理，所以.hexdigest()方法被用来将这个字节串转换为一个十六进制字符串。

十六进制是一种基数为16的数制系统，它使用0-9的数字和A-F的字母来表示数值。由于一个字节（byte）有8位（bit），它可以有256个不同的值（从00000000到11111111），这些值可以很容易地用两个十六进制数字来表示（从00到FF）。因此，一个哈希值的字节串可以很容易地转换为一个十六进制字符串。

例如，如果你有一个SHA-256哈希值的字节串，它将是256位长（即32字节），.hexdigest()方法将返回一个64个字符长的十六进制字符串，其中每个字符要么是0-9的数字，要么是A-F的字母。

下面是一个简单的示例，展示了如何使用hashlib.sha256()和.hexdigest()方法：

import hashlib  
  
def encrypt(sign_str):  
    hash_algorithm = hashlib.sha256()  
    hash_algorithm.update(sign_str.encode('utf-8'))  
    return hash_algorithm.hexdigest()  
  
# 使用示例  
sign_str = "Hello, world!"  
hashed_str = encrypt(sign_str)  
print(hashed_str)  # 输出类似：b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

请注意，由于哈希函数是确定性的（对于相同的输入，总是产生相同的输出），并且不可逆（不能从哈希值恢复原始输入），所以它们通常用于验证数据的完整性和创建数字签名，而不是用于加密数据（尽管“encrypt”这个名字可能会让人产生这样的误解）。

truncate  美/ˈtrʌŋkeɪt/   v.截断，删节；把……截成平面

def truncate(): 

    @staticmethod
    def truncate(q):
        if q is None:
            return None
        size = len(q)
        return q if size <= 20 else q[0:10] + str(size) + q[size - 10:size]

这段代码定义了一个名为 truncate 的静态方法，用于“截断”一个给定的对象 q（尽管从方法内部看，这个对象应该是一个字符串或类似的可索引对象）。但是，该方法的实现有些特殊，我会为你逐步解释：

1. 方法定义：

   • @staticmethod：这是一个装饰器，表示这个方法是静态的。静态方法不需要类的实例即可调用，也不传递类本身作为第一个参数（如通常的实例方法那样）。但是，从这段代码中我们可以看到，尽管使用了 @staticmethod，方法仍然接受一个参数 q。

2. 方法逻辑：

   • 检查 q 是否为 None：

     • 如果 q 是 None，则直接返回 None。

   • 获取 q 的长度：

     • 使用 len(q) 获取 q 的长度，并将其存储在变量 size 中。

   • 判断是否需要截断：

     • 如果 q 的长度 size 小于或等于 20，则直接返回 q（不进行任何操作）。
     • 如果 q 的长度 size 大于 20，则进行截断。

   • 截断逻辑：

     • 取 q 的前10个字符：q[0:10]
     • 拼接 q 的长度（转换为字符串）：str(size)
     • 取 q 的最后10个字符：q[size - 10:size]
     • 将上述三部分拼接起来，并返回结果。

3. 注意：

   • 这种截断方式可能不是通常意义上的截断。通常，我们可能只是简单地取字符串的前N个字符或前N个字符加“...”作为省略。但这里的实现方式保留了字符串的开头10个字符、结尾10个字符，并在中间插入了整个字符串的长度。
   • 如果 q 不是字符串或不可索引的对象（例如列表、元组等），这段代码会抛出异常。因为 len() 和索引操作 [:] 仅适用于这些类型的对象。

总的来说，这个 truncate 方法实现了一种特殊的字符串截断方式，并使用了静态方法的装饰器。但考虑到其特殊的截断逻辑，这个方法可能不是所有情况下都适用。

q[size - 10:size] 是一个Python的切片操作，用于从字符串（或类似的可切片对象）q 中获取最后10个字符。这里我详细解释一下这个操作：

• size 是字符串 q 的长度。
• size - 10 计算出从字符串末尾往前数第10个字符的索引位置（在Python中，字符串索引是从0开始的）。
• q[size - 10:size] 获取从索引 size - 10 到索引 size - 1 的子串（注意切片操作是左闭右开的，即包括开始索引但不包括结束索引）。

举个例子，如果 q 是字符串 "HelloWorldHowAreYouToday"，那么 size 就是 25。那么 size - 10 就是 15，对应的字符是 A（大写字母A）。因此，q[size - 10:size] 将返回 "AreYouToday"。

这种切片操作在处理可能很长的字符串时特别有用，因为它允许你快速获取字符串的某个部分，而不需要复制整个字符串。这在处理大量数据或性能敏感的应用中尤为重要。

def connect(self, q):

    def do_request(self, data):
        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
        return requests.post(self.YOU_DAO_URL, data=data, headers=headers)

    def connect(self, q):
        data = {}
        data['from']= 'EN'
        data['to']='zh-CHS'
        data['signType'] = 'v3'
        curtime = str(int(time.time()))
        data['curtime'] = curtime
        salt =str(uuid.uuid1())
        sign_str = self.APP_KEY + self.truncate(q) + salt + curtime + self.APP_KEY
        sign = self.encrypt(sign_str)
        data['appKey'] = self.APP_KEY
        data['q'] = q
        data['salt']= salt
        data['sign'] = sign
        response = self.do_request(self, data)
        content_json = json.loads(response.content)
        # error_code 为0时，表示查询正常
        error_code = content_json['errorCode']

        if error_code =='0':
            # 英式音标
            phonetic = '[' + content_json['basic']['phonetic'] + ']'
            # j解释
            explains_list = content_json['basic']['explains']
            explains = "\n".json(explains_list)
            # 源语言发音地址
            origin_speak_url = content_json['speakUrl']
            get_audio(q, origin_speak_url)

            context = {'code': error_code, 'phonetic':phonetic, 'explains': explains}
        else:
            context = {'code': error_code}
        return context

content_json['basic']['explains']

在Python中，content_json['basic']['explains'] 是一个字典（或JSON对象）的嵌套访问方式。

这里假设 content_json 是一个Python字典，该字典有一个键 'basic'，其值也是一个字典，而这个内部字典又有一个键 'explains'。

以下是一个简单的示例来解释这种结构：

# 假设这是从JSON解析得到的Python字典  
content_json = {  
    "basic": {  
        "name": "Example",  
        "explains": "This is an example explanation"  
    },  
    "other_key": "Other value"  
}  
  
# 访问 'basic' 下的 'explains'  
explains = content_json['basic']['explains']  
print(explains)  # 输出: This is an example explanation

但是，如果你试图访问一个不存在的键，Python会抛出一个KeyError。为了避免这种情况，你可以使用.get()方法或try-except块：

# 使用 .get() 方法，如果键不存在则返回 None 或指定的默认值  
explains = content_json['basic'].get('explains', 'Default explanation')  
print(explains)  # 如果 'explains' 存在，则输出其值；否则输出 'Default explanation'  
  
# 使用 try-except 块  
try:  
    explains = content_json['basic']['explains']  
except KeyError:  
    explains = 'Key not found'  
print(explains)  # 如果 'explains' 存在，则输出其值；否则输出 'Key not found'

class ReptileYouDao:

class ReptileYouDao:

    @staticmethod
    def get_base_message(word):

        logging.info('is ready to send http request')
        response = requests.get('http://dict.youdao.con/search?q=%s&keyfrom=new-fanyi.smartResult'% word, headers=headers)
        logging.info(response)
        html = response.text
        soup = BeautifulSoup(html, 'html.parser')  #结构化文本soup
        try:
            explains = soup.find(name='div', attrs={'class': 'trans-container'}).get_text().strip()
            explains = explains[:explains.find('[')]
            from common import sub_str_len, instance_new_line
            explains = sub_str_len(explains, 3)
            phonetic = soup.find(name='span', attrs={'class': 'phonetic'}).get_text() #音标
            examples = soup.find(name='div', attrs={'class': 'examples'}).get_text()   #例句
            examples_en = instance_new_line(examples.split('\n')[1], 50)
            examples_cn = instance_new_line(examples.split('\n')[2], 50, is_cn=True)
            url = 'http://dict.youdao.com/dictvoice?audio=%s' % word
            get_audio(word, url)
            context = {'error_code': 0, 'phonetic':phonetic, 'explains':explains, 'examples_en':examples_en, 'examples_cn':examples_cn}
        except Exception:
            logging.info('%s can\'t import' % word)
            context = {'error_code': 404}
        return context

reptile   美/ˈreptaɪl/     n.爬行动物；（非正式）卑鄙的人

soup = BeautifulSoup(html, 'html.parser')

soup = BeautifulSoup(html, 'html.parser') 是 Python 中使用 BeautifulSoup 库来解析 HTML 或 XML 文档的一个常见语句。这里，BeautifulSoup 是一个 Python 库，用于从 HTML 和 XML 文件中提取数据。

BeautifulSoup() 是 BeautifulSoup 库中的一个主要函数（在 Python 中通常通过类的构造函数实现，尽管从用法上它看起来像一个函数），用于将输入的 HTML 或 XML 文档字符串解析成一个复杂的树形结构，这个结构允许你使用各种方法来搜索、遍历和修改文档。

当你调用 BeautifulSoup() 时，你需要至少传递两个参数：

1. 第一个参数是你要解析的 HTML 或 XML 字符串。
2. 第二个参数是一个解析器名称，它告诉 BeautifulSoup 使用哪个解析器来解析文档。

除了这两个参数，BeautifulSoup() 还可以接受其他可选参数，如 features（在某些解析器中使用）和 from_encoding（指定输入字符串的编码）。

这里有一个简单的例子，展示了如何使用 BeautifulSoup() 来解析一个 HTML 字符串：

from bs4 import BeautifulSoup  
  
html_doc = """  
<html><head><title>The Dormouse's story</title></head>  
<body>  
<p class="title"><b>The Dormouse's story</b></p>  
  
<p class="story">Once upon a time there were three little sisters; and their names were  
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,  
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and  
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;  
and they lived at the bottom of a well.</p>  
  
<p class="story">...</p>  
"""  
  
soup = BeautifulSoup(html_doc, 'html.parser')  
  
# 搜索和遍历文档  
for link in soup.find_all('a'):  
    print(link.get('href'))

在上面的例子中，我们首先从 bs4 模块中导入了 BeautifulSoup 类。然后，我们定义了一个包含 HTML 内容的字符串 html_doc。接着，我们使用 BeautifulSoup() 函数和 html.parser 解析器来解析这个 HTML 字符串，并将结果存储在 soup 变量中。最后，我们使用 find_all() 方法来搜索所有的 <a> 标签，并打印出它们的 href 属性值。

 soup.find()

soup.find() 是 BeautifulSoup 库中的一个方法，用于在解析后的 HTML 或 XML 文档树中搜索第一个匹配的标签或字符串。这个方法返回文档中的第一个匹配项，如果没有找到匹配项，则返回 None。

find() 方法接受多个参数，其中最重要的是第一个参数，它通常是一个标签名、类名、ID 或其他搜索条件。你还可以使用关键字参数（如 attrs）来指定更复杂的搜索条件。

下面是一些使用 soup.find() 的例子：

示例 1：按标签名搜索

from bs4 import BeautifulSoup  
  
html_doc = """  
<html><head><title>示例页面</title></head>  
<body>  
    <p class="intro">这是一个介绍。</p>  
    <p class="content">这是页面内容。</p>  
</body>  
</html>  
"""  
  
soup = BeautifulSoup(html_doc, 'html.parser')  
  
# 查找第一个 <p> 标签  
p_tag = soup.find('p')  
print(p_tag)  # 输出：<p class="intro">这是一个介绍。</p>

示例 2：按类名搜索

# 查找 class 属性为 "content" 的第一个标签  
content_tag = soup.find(attrs={'class': 'content'})  
print(content_tag)  # 输出：<p class="content">这是页面内容。</p>

示例 3：按 ID 搜索

如果你的 HTML 文档中有元素的 ID，你可以直接使用 id 参数来搜索它：

# 假设有 <div id="main">...</div>  
main_div = soup.find(id='main')  
print(main_div)  # 如果存在，则输出对应的 <div> 元素

示例 4：按文本内容搜索

虽然 find() 本身不支持直接按文本内容搜索，但你可以结合 string 属性来间接实现：

# 查找包含特定文本的第一个标签  
tag_with_text = soup.find(string="这是一个介绍。")  
print(tag_with_text.parent)  # 输出包含该文本的 <p> 标签

请注意，在上面的例子中，string 参数搜索的是标签内的文本内容，而不是标签的属性。要获取包含该文本的整个标签，你需要访问 parent 属性。

find() 方法还有其他参数和用法，但以上示例应该涵盖了最常见的用法。如果你需要搜索多个匹配的标签，你应该使用 find_all() 方法，它会返回一个包含所有匹配项的列表。

get_text()

        BeautifulSoup: BeautifulSoup 是一个用于解析HTML和XML的Python库。你可以使用它来从HTML或XML元素中提取文本。虽然BeautifulSoup没有直接的 get_text() 方法，但你可以使用 .get_text() 或 .text 来达到相同的效果。

from bs4 import BeautifulSoup  
  
html_doc = """  
<html><head><title>The Dormouse's story</title></head>  
<body>  
<p class="title"><b>The Dormouse's story</b></p>  
  
<p class="story">Once upon a time there were three little sisters; and their names were  
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,  
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and  
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;  
and they lived at the bottom of a well.</p>  
  
<p class="story">...</p>  
"""  
  
soup = BeautifulSoup(html_doc, 'html.parser')  
print(soup.p.get_text())  # 注意：这里通常使用 .get_text() 或 .text

注意：在BeautifulSoup中，.get_text() 是旧版本的API，而 .text 是新版本的推荐方法。

        

ListProperty([])

ListProperty 是Kivy框架中用于定义列表类型属性的一个类。使用ListProperty，你可以为某个类的实例定义一个列表属性，并为该属性提供默认值、绑定事件等。

下面是一个简单的Kivy示例，展示了如何使用ListProperty：

from kivy.properties import ListProperty  
  
class MyWidget(Widget):  
    my_list = ListProperty([])  
  
    def __init__(self, **kwargs):  
        super(MyWidget, self).__init__(**kwargs)  
        # 你可以在这里修改my_list的值  
        self.my_list = [1, 2, 3]  
  
    def on_my_list(self, instance, value):  
        print(f"my_list changed to: {value}")  
  
# 创建一个MyWidget实例，并监听my_list的变化  
w = MyWidget()  
w.bind(my_list=w.on_my_list)  
  
# 修改my_list的值，这会触发on_my_list方法  
w.my_list = [4, 5, 6]

在这个例子中，MyWidget 类有一个名为my_list的列表属性，该属性使用ListProperty([])进行定义，并给出了一个空列表作为默认值。当my_list的值发生变化时，会触发on_my_list方法。

MRWord\pages\addwordpage\addword.py

from kivy.app import App
from kivy.uix.recycleview.views import RecycleDataViewBehavior
from kivy.uix.button import Button
from kivy.properties import BooleanProperty, ListProperty, StringProperty, ObjectProperty
from kivy.uix.recyclegridlayout import RecycleGridLayout
from kivy.uix.behaviors import FocusBehavior
from kivy.uix.recycleview.layout import LayoutSelectionBehavior
from kivy.uix.popup import Popup
from MRWord.db.sqlite3_connect import select_data, insert_data

from MRWord.custom_gestures.gesture_box import GestureBox
from MRWord.utils.common import num_of_word_to_study


class TextInputPopup(Popup):
    obj = ObjectProperty(None)
    obj_text = StringProperty("")

    def __init__(self, obj, **kwargs):
        super(TextInputPopup, self).__init__(**kwargs)
        self.obj = obj
        self.obj_text = obj.text
        self.insert_today()

    def insert_today(self):
        """today表添加数据"""
        global word_id
        try:
            word_id = int(self.obj_text)
        except ValueError:
            select_id = "SELECT id FROM word WHERE word = '%s'" % self.obj_text
            rows = select_data(select_id)
            for row in rows:
                for col in row:
                    word_id = col
        finally:
            # 插入数据并更新word表添加次数
            insert_sql = "INSERT INTO today(word_id) SELECT '%d' WHERE NOT EXISTS(SELECT 1 FROM today WHERE word_id = '%d')" % (
            word_id, word_id)
            update_sql = "UPDATE word SET add_times = add_times + 1 WHERE id = '%d'" % word_id
            insert_data(insert_sql)
            insert_data(update_sql)
            print('%s is successful to add' % self.obj_text)

def add_word_to_review():
App.get_running_app().screen_manager.transition.direction = 'right'
App.get_running_app().screen_manager.current = 'Review'

这段代码定义了一个名为 add_word_to_review 的函数，它似乎是为了在Kivy（一个Python库，用于开发多触摸应用）应用中从一个屏幕过渡到另一个屏幕而设计的。具体来说，这段代码的功能如下：

1. 设置过渡方向：App.get_running_app().screen_manager.transition.direction = 'right'

这行代码获取当前正在运行的应用（App.get_running_app()），并访问其screen_manager属性。它接着更改transition的direction属性为'right'，这意味着当从一个屏幕过渡到另一个屏幕时，过渡动画的方向将是向右的。
2. 改变当前屏幕：App.get_running_app().screen_manager.current = 'Review'

这行代码也获取了当前正在运行的应用的screen_manager，并设置其current属性为'Review'。这意味着应用将导航到名为Review的屏幕。

为了完全理解这段代码，你需要知道以下几点：

• 你的应用应该使用了Kivy的ScreenManager来管理多个屏幕。
• 你应该有一个名为Review的屏幕定义在你的应用中。
• App.get_running_app()是Kivy提供的一个方法来获取当前正在运行的应用实例。
• screen_manager是App类的一个属性（或者是在你的应用中定义的一个类似的属性），它应该是一个ScreenManager对象。

class SelectableRecycleGridLayout(FocusBehavior, LayoutSelectionBehavior, RecycleGridLayout):
    """将选择和焦点行为添加到视图中"""


class SelectableButton(RecycleDataViewBehavior, Button):
    """Add selection support to the Button"""
    index = None
    selected = BooleanProperty(False)
    selectable = BooleanProperty(True)

    def on_touch_down(self, touch):
        """ Add selection on touch down """
        if super(SelectableButton, self).on_touch_down(touch):
            return True
        if self.collide_point(*touch.pos) and self.selectable:
            return self.parent.select_with_touch(self.index, touch)

    def on_press(self):
        popup = TextInputPopup(self)

kivy.uix.behaviors 的FocusBehavior

在 Kivy 框架中，kivy.uix.behaviors.FocusBehavior 是一个行为（Behavior），它使得一个控件（Widget）能够获得和失去焦点。这对于需要键盘输入或特定交互的控件（如文本框、按钮等）特别有用。

当你将 FocusBehavior 添加到一个控件时，这个控件将获得以下功能：

1. 焦点管理：控件可以接收和失去焦点。当控件获得焦点时，它通常会变得高亮显示或更改其视觉样式。
2. 键盘事件：当控件获得焦点时，它可以接收和处理键盘事件（如按键按下和释放）。
3. 焦点切换：控件可以通过编程方式设置或失去焦点，也可以通过用户交互（如点击或触摸）来切换焦点。

要使用 FocusBehavior，你需要将其作为一个基类与你自己的控件类一起使用，或者将其作为一个混合（mixin）类添加到现有的控件类中。

以下是一个简单的示例，演示如何将 FocusBehavior 添加到自定义的 MyWidget 类中：

from kivy.app import App  
from kivy.uix.widget import Widget  
from kivy.uix.behaviors import FocusBehavior  
from kivy.properties import BooleanProperty  
  
class MyWidget(FocusBehavior, Widget):  
    focused = BooleanProperty(False)  
  
    def on_focus(self, instance, value):  
        # 当焦点改变时触发  
        if value:  
            print("MyWidget has focus")  
        else:  
            print("MyWidget lost focus")  
  
    def on_key_down(self, key, modifiers):  
        # 处理键盘按下事件  
        if key == 27:  # 如果按下的是 ESC 键  
            App.get_running_app().stop()  
  
class MyApp(App):  
    def build(self):  
        return MyWidget()  
  
if __name__ == '__main__':  
    MyApp().run()

在这个示例中，我们创建了一个名为 MyWidget 的自定义控件，它继承了 FocusBehavior 和 Widget。当 MyWidget 获得或失去焦点时，on_focus 方法会被触发，并打印相应的消息。此外，我们还重写了 on_key_down 方法来处理键盘按下事件。在这个例子中，如果按下的是 ESC 键，则应用会停止运行。

kivy.uix.behaviors 的FocusBehavior 的常用方法

在 Kivy 的 kivy.uix.behaviors.FocusBehavior 中，有几个重要的方法和属性，它们用于处理和管理控件的焦点。以下是一些常用的方法和属性：

属性

1. focused:
   • 类型: BooleanProperty
   • 描述: 表示控件当前是否拥有焦点的属性。这个属性是只读的，你不能直接设置它，但可以通过其他方式（如点击或编程方式）来改变焦点状态。

方法

1. focus():
   • 描述: 请求控件获得焦点。这并不意味着控件一定会获得焦点，但会触发一个请求。焦点管理系统会决定哪个控件应该获得焦点。
2. defocus():
   • 描述: 请求控件失去焦点。同样，这只是一个请求，焦点管理系统会处理这个请求。
3. _keyboard_focused(instance, value, *largs):
   • 描述: 这是一个私有方法，用于处理当控件的焦点状态改变时的事件。通常，你不需要直接调用这个方法，但可以在你的类中重写它以在焦点改变时执行自定义操作。
4. on_focus(instance, value, *largs):
   • 描述: 当控件的焦点状态改变时触发的事件处理器。你可以在你的类中重写这个方法以在控件获得或失去焦点时执行自定义操作。value 参数表示新的焦点状态（True 表示获得焦点，False 表示失去焦点）。
5. **on_keyboard_down(self, key, scancode=None, codepoint=None, modifiers=None, kwargs):
   • 描述: 当控件有焦点且键盘上的某个键被按下时触发的事件处理器。你可以在这个方法中处理键盘输入。
6. **on_keyboard_up(self, key, scancode=None, codepoint=None, modifiers=None, kwargs):
   • 描述: 当控件有焦点且键盘上的某个键被释放时触发的事件处理器。

示例

以下是一个简单的示例，演示了如何在自定义控件中使用 FocusBehavior 并重写 on_focus 方法：

from kivy.app import App  
from kivy.uix.label import Label  
from kivy.uix.behaviors import FocusBehavior  
from kivy.properties import BooleanProperty  
  
class FocusableLabel(FocusBehavior, Label):  
    focused = BooleanProperty(False)  
  
    def on_focus(self, instance, value):  
        if value:  
            print("FocusableLabel has focus")  
            # 在这里可以添加当控件获得焦点时要执行的代码  
        else:  
            print("FocusableLabel lost focus")  
            # 在这里可以添加当控件失去焦点时要执行的代码  
  
class MyApp(App):  
    def build(self):  
        return FocusableLabel(text='Click or touch me to focus', size_hint=(None, None), size=(200, 100))  
  
if __name__ == '__main__':  
    MyApp().run()

在这个示例中，我们创建了一个名为 FocusableLabel 的自定义控件，它继承了 FocusBehavior 和 Label。我们重写了 on_focus 方法以在控件获得或失去焦点时打印消息。当你点击或触摸这个标签时，它应该会获得焦点，并在控制台中打印相应的消息。

from kivy.uix.recycleview.views 的RecycleDataViewBehavior

RecycleDataViewBehavior 是 Kivy 框架中 RecycleView 组件的一部分，用于在 RecycleBoxLayout 或 RecycleGridLayout 布局的 RecycleView 中定义可交互的数据项（或称为视图）。这个行为（Behavior）通常与某种视图（如 Label、Button 或自定义的视图）一起使用，以提供对 RecycleView 数据项的选择、按下和其他交互事件的响应。

在 Kivy 的 RecycleView 系统中，RecycleDataViewBehavior 通常与 RecycleBoxLayout 或 RecycleGridLayout 一起使用，以定义如何在屏幕上布局和显示数据项。数据项本身（即视图）可以是任何 Kivy 控件，但通常它们会继承 RecycleDataViewBehavior 以获得与 RecycleView 交互的能力。

例如，在翻牌游戏中，你可能有一个表示卡牌的自定义控件，这个控件继承自 Label 和 RecycleDataViewBehavior。这样，当卡牌被点击或选中时，你可以通过 RecycleDataViewBehavior 提供的方法来更新卡牌的显示状态（例如，翻转卡牌或显示其背面的信息）。

这里是一个简化的示例，展示了如何使用 RecycleDataViewBehavior：

from kivy.app import App  
from kivy.uix.recycleview import RecycleView  
from kivy.uix.recycleboxlayout import RecycleBoxLayout  
from kivy.properties import BooleanProperty, StringProperty  
from kivy.uix.behaviors import RecycleDataViewBehavior  
from kivy.uix.label import Label  
  
class SelectableLabel(RecycleDataViewBehavior, Label):  
    index = None  
    selected = BooleanProperty(False)  
    selectable = BooleanProperty(True)  
  
    def refresh_view_attrs(self, rv, index, data):  
        """ Update the label based on the selected state. """  
        self.index = index  
        self.text = str(data['text'])  
        self.selectable = data['selectable']  
        if self.selectable:  
            if self.selected:  
                # Change the visual appearance of the label when selected  
                self.background_color = [1, 0, 0, 1]  # Red  
            else:  
                self.background_color = [1, 1, 1, 1]  # White  
  
    def on_touch_down(self, touch):  
        """ Add selection on touch down. """  
        if super(SelectableLabel, self).on_touch_down(touch):  
            return True  
        if self.collide_point(*touch.pos) and self.selectable:  
            self.parent.select_with_touch(self.index, touch)  
            return True  
  
    def apply_selection(self, rv, index, is_selected):  
        """ Respond to the selection of items in the view. """  
        self.selected = is_selected  
  
class RV(RecycleView):  
    def __init__(self, **kwargs):  
        super(RV, self).__init__(**kwargs)  
        self.data = [{'text': str(x), 'selectable': True} for x in range(40)]  
  
    def select_with_touch(self, index, touch):  
        """ Toggle selection of item with given index on touch. """  
        self.rv_data_adapter.select_view(index)  
  
class TestApp(App):  
    def build(self):  
        return RV()  
  
if __name__ == '__main__':  
    TestApp().run()

在这个示例中，SelectableLabel 继承自 RecycleDataViewBehavior 和 Label，并提供了对选择状态的响应。RV 类是一个 RecycleView，它使用 SelectableLabel 作为其数据项，并定义了一个方法来处理触摸事件以选择数据项。

RecycleDataViewBehavior 的常用方法

RecycleDataViewBehavior 是 Kivy 框架中 RecycleView 组件提供的一个行为，通常用于为 RecycleView 的数据项（或视图）添加交互功能。当你从 kivy.uix.recycleview.views 导入 RecycleDataViewBehavior 并将其与某个控件（如 Label 或 Button）结合使用时，你可以利用这个行为提供的一些常用方法。

以下是 RecycleDataViewBehavior 提供的一些常用方法：

1. refresh_view_attrs(rv, index, data):
   这个方法通常在数据项被创建或更新时被调用。它接受三个参数：rv（RecycleView 实例）、index（数据项的索引）和 data（与数据项关联的数据字典）。你可以在这个方法中更新你的视图以反映新的数据或状态。

2. apply_selection(rv, index, is_selected):
   当数据项的选择状态改变时，这个方法会被调用。它接受三个参数：rv（RecycleView 实例）、index（数据项的索引）和 is_selected（一个布尔值，表示数据项是否被选中）。你可以在这个方法中更新你的视图以反映新的选择状态。

3. select() 和 deselect():
   这两个方法不是直接由 RecycleDataViewBehavior 提供的，但它们是常用的选择逻辑的一部分。你通常会在你的视图类中重写这些方法，以便在数据项被选中或取消选中时执行特定的操作。这些方法可能会调用 apply_selection 或其他方法来更新视图的状态。

4. on_touch_down(touch)、on_touch_move(touch)、on_touch_up(touch):
   这些方法是用于处理触摸事件的。你可以在 RecycleDataViewBehavior 的子类中重写它们，以添加自定义的触摸处理逻辑。例如，在 on_touch_down 方法中，你可以检查触摸事件是否发生在你的视图上，并据此执行相应的操作（如选择或取消选择数据项）。

5. 其他属性:
   除了上述方法外，RecycleDataViewBehavior 还定义了一些属性，如 index（数据项的索引）、selected（一个布尔值，表示数据项是否被选中）和 selectable（一个布尔值，表示数据项是否可以被选中）。你可以在你的视图类中使用这些属性来跟踪和更新数据项的状态。

    def on_touch_down(self, touch):
        """ Add selection on touch down """
        if super(SelectableButton, self).on_touch_down(touch):
            return True
        if self.collide_point(*touch.pos) and self.selectable:
            return self.parent.select_with_touch(self.index, touch)

 

*touch.pos

collide_point

在 Kivy 框架中，collide_point 是一个常用于 Widget 类的方法，用于检查给定的点（通常是一个坐标对 (x, y)）是否位于该 Widget 的几何区域内。这个方法对于处理触摸事件、鼠标点击或者任何与屏幕坐标相关的交互都非常有用。

collide_point 方法接收两个参数，分别对应 x 和 y 坐标，然后返回一个布尔值：

• 如果点位于 Widget 的内部（包括边界），则返回 True。
• 如果点位于 Widget 的外部，则返回 False。

这里是一个简单的示例，展示了如何使用 collide_point 方法：

from kivy.app import App  
from kivy.uix.button import Button  
from kivy.uix.floatlayout import FloatLayout  
  
class TestApp(App):  
    def build(self):  
        layout = FloatLayout()  
        btn = Button(text='Touch Me', pos_hint={'center_x': 0.5, 'center_y': 0.5})  
  
        def on_touch_down(instance, touch):  
            if btn.collide_point(*touch.pos):  
                print("Button was touched!")  
                return True  
            return False  
  
        layout.bind(on_touch_down=on_touch_down)  
        layout.add_widget(btn)  
        return layout  
  
if __name__ == '__main__':  
    TestApp().run()

在这个示例中，我们创建了一个简单的 Kivy 应用，它包含一个位于屏幕中央的按钮。当在屏幕上按下时，on_touch_down 事件处理器会被调用，并检查触摸点是否位于按钮的区域内。如果是，它会打印一条消息并返回 True，表示事件已被处理。

请注意，collide_point 方法考虑的是 Widget 的布局位置（即 pos 属性）和大小（由 size 属性或 width 和 height 属性定义）。如果 Widget 或其父布局进行了旋转、缩放或变换，collide_point 方法仍然会基于原始的、未经变换的布局位置和大小来判断点是否位于 Widget 内部。如果你需要考虑变换后的位置和大小，你可能需要手动计算或使用其他方法。

 select_with_touch

kivy 中compundselection的 select_with_touch

Kivy 是一种用 Python 编写的开源框架，可用于创建跨平台的多点触控应用程序。其中的 CompoundSelection 是一种组合选择器，用于在具有多个子项的组合组件中选择一个或多个子项。

而 select_with_touch() 是 CompoundSelection 类中的一个方法，该方法会在用户使用触摸屏幕时被调用。当用户使用触摸屏幕时，CompoundSelection 可以根据用户的行为来选择子项。例如，当用户按下并拖动时，CompoundSelection 将选择所有与当前选择框相交的子项。

Compound Selection Behavior — Kivy 2.3.0 documentation

node   美/noʊd/      n.茎节；结，结节；结点；节点；（计算机网络的）网点；（物理，数）波节；调和函数零点；（电流或电压）零点

node

The node that received the touch. Can be None for a scroll type touch.

MRWord/pages/addwordpage\addword.kv

<SelectableButton>:
    canvas.before:
        Color:
            rgba: (.0, 0.9, .1, .3) if self.selected else (1, 1, 1, 0.1)
        Rectangle:
            pos: self.pos
            size: self.size
    background_color: (1, 1, 1, 0.1) if self.selected else (255, 255, 255, 1)
    color: (102,102,102,1)

<AddWordPage>:
    on_left_to_right_line: root.add_word_to_review()
    on_right_to_left_line: root.add_word_to_info()
    # on_top_to_bottom_line: root.add_word_refresh()
    add_word_page: add_word_page.__self__
    BoxLayout:
        id: add_word_page
        orientation: "vertical"
        canvas.before:
            Color:
                rgba: (1,1,1,1)
            Rectangle:
                pos: self.pos
                size: self.size
                source: 'image/back.jpg'

        GridLayout:
            size_hint: 1, None
            height: 65
            cols: 2

            Label:
                id: rv_add_word
                text: "\u63d0\u793a\uff1a\u70b9\u51fb\u5355\u8bcd\uff08\u6216\u5bf9\u5e94\u7f16\u53f7\uff09\u5b8c\u6210\u6dfb\u52a0\uff01"
                color: (0.24, 0.678, 0.95, 1)
                font_name: "site_packages/DroidSansFallback.ttf"

        BoxLayout:
            RecycleView:
                viewclass: 'SelectableButton'
                data: [{'text': str(x)} for x in root.data_items]
                SelectableRecycleGridLayout:
                    cols: 2
                    default_size: None, dp(40)
                    default_size_hint: 1, None
                    size_hint_y: None
                    height: self.minimum_height
                    orientation: 'vertical'
                    multiselect: True
                    touch_multiselect: True

        GridLayout:
            size_hint_y: .1
            cols: 2

            Button:
                id: rv_random_button
                text: "\u968f\u673a\u6dfb\u52a0"
                font_size: '20sp'
                color: (120,120,120,1)
                background_color: 255, 255, 255, 1
                on_press: root.add_random_words()
                font_name: "site_packages/DroidSansFallback.ttf"

            Button:
                id: return_info_button
                text: "\u5237\u65b0"
                font_size: 20
                color: (120,120,120,1)
                background_color: 255, 255, 255, 1
                on_press: root.add_word_refresh()
                font_name: "site_packages/DroidSansFallback.ttf"

add_word_page: add_word_page.__self__

在Python中，当你看到像 some_method.__self__ 这样的属性时，这通常与类实例方法（bound method）有关。但是，标准的Python库和特性中并没有一个内置的 add_word_page 方法或属性 __self__ 直接与Word文档处理相关（例如，与python-docx库或其他Word处理库）。

不过，我可以为你解释 __self__ 的概念，并猜测 add_word_page 可能是什么。

1. __self__：

   • 当一个方法被绑定到一个类的实例时，它会有一个特殊的属性 __self__，该属性指向调用该方法的实例。
   • 这在Python的内置方法和描述符（如属性）中很有用，但在常规的方法调用中不太常见。
   • 例如，在以下类中：

class MyClass:  
    def my_method(self):  
        print(self)  
  
obj = MyClass()  
method = obj.my_method  
print(method.__self__)  # 输出：<__main__.MyClass object at 0x...>

当你从实例中获取方法并引用 __self__ 时，它会返回该实例。

  2.  add_word_page：

• 这可能是一个自定义方法，用于向Word文档添加一个新页面（但请注意，Word文档并不直接有“页面”的概念，它们是基于内容的流）。
• 如果这是第三方库（如python-docx）中的方法，那么它可能是该库为了提供类似的功能而定义的。
• 但如果你看到这个属性与 __self__ 一起使用，那么它可能是一个被绑定到某个实例的方法。

如果你正在使用某个特定的库或框架，并且看到了 add_word_page 和 __self__ 的组合，那么最好的做法是查阅该库或框架的文档以获取更详细的信息。如果这是一个自定义的方法或类，那么你可能需要查看其定义以了解它的工作原理。

dd_word_page: add_word_page.__self__ 这一行似乎是错误的，或者至少是不必要的，并且可能导致混淆。

首先，add_word_page 似乎被用作了两个不同的东西：

1. 一个可能是一个自定义的类（或者至少是一个标识符），它被用来定义一些事件处理函数（如 on_left_to_right_line 和 on_right_to_left_line）和内部的 BoxLayout 组件。
2. 它又被用作一个 BoxLayout 组件的ID。

然后，add_word_page: add_word_page.__self__ 这一行试图为 add_word_page 这个标识符分配一个值，但这里的上下文不明确，且通常这不是在Kivy（一个常用的Python GUI库，经常用于创建跨平台应用程序）中做这种事情的方式。

在Kivy中，通常你会在.kv文件中定义界面布局和事件处理函数，而在Python代码中定义业务逻辑。但是，add_word_page: add_word_page.__self__ 这样的语法不是Kivy的标准用法。

如果 add_word_page 是一个类的实例，并且你试图在.kv文件中引用它，那么你应该直接通过它的ID来引用它，就像你在 BoxLayout 组件上做的那样。但是，你不应该试图为它自己设置一个 __self__ 属性，因为 __self__ 是Python内部使用的，表示方法所属的对象（通常是类的实例）。

所以，我建议从.kv文件中移除 add_word_page: add_word_page.__self__ 这一行，因为它似乎是多余的，并且可能导致混淆或错误。

如果你确实需要在Python代码中引用这个 BoxLayout 组件，你可以通过其ID来访问它，例如，在Python代码中，你可以这样做：

	# 假设 root 是你的 App 或某个包含这个 BoxLayout 的 Widget 的实例
	box_layout = root.ids.add_word_page

然后你可以调用这个 BoxLayout 组件的方法或修改它的属性。

class AddWordPage(GestureBox):

data_items = ListProperty([])

在Kivy框架中，ListProperty 是一个特殊的属性类型，它允许你将一个Python列表作为类的属性，并且当列表的内容发生变化时，Kivy的事件系统能够检测到这种变化并可能触发相应的事件。这在Kivy中特别有用，因为Kivy的许多组件和属性都是基于Python的property系统，并扩展了以支持特定的Kivy特性，如事件分发。

当你看到 data_items = ListProperty([]) 这样的代码时，它通常是在一个Kivy的EventDispatcher（或其子类，如Widget或App）的类中定义的。这表示data_items是一个列表，并且当这个列表的内容发生变化时，Kivy能够检测到这种变化。

下面是一个简单的例子，展示了如何在Kivy的Widget类中使用ListProperty：
 

from kivy.app import App  
from kivy.uix.widget import Widget  
from kivy.properties import ListProperty  
  
class MyWidget(Widget):  
    data_items = ListProperty([])  
  
    def __init__(self, **kwargs):  
        super(MyWidget, self).__init__(**kwargs)  
        # 你可以在这里初始化 data_items  
        # 例如: self.data_items = [1, 2, 3]  
  
    def add_item(self, item):  
        self.data_items.append(item)  
  
class MyApp(App):  
    def build(self):  
        widget = MyWidget()  
        widget.add_item(4)  # 这会触发 data_items 的变化  
        return widget  
  
if __name__ == '__main__':  
    MyApp().run()

在上面的例子中，MyWidget类有一个data_items属性，它是一个ListProperty。你可以通过self.data_items来访问和修改这个列表。当你调用add_item方法并添加一个元素到data_items时，Kivy会检测到这个变化（尽管在这个例子中，我们并没有利用这个变化来触发任何事件）。

需要注意的是，虽然你可以像操作普通的Python列表一样操作ListProperty，但使用ListProperty的好处是Kivy能够更好地管理和检测这个列表的变化。这在你需要根据列表内容的变化来更新UI或其他属性时特别有用。

self.data_items.clear() 中的.clear()

在Python中，列表（list）对象有一个内置的clear()方法，它用于移除列表中的所有元素，使其变为一个空列表。在Kivy的上下文中，如果你有一个ListProperty属性，如data_items，并且这个属性是一个列表，那么你也可以使用clear()方法来清空它。

当你调用self.data_items.clear()时，你实际上是在调用绑定到ListProperty的列表对象的clear()方法。这会清空data_items列表中的所有元素，但不会改变data_items属性本身（它仍然是一个ListProperty对象，只是它现在指向一个空的列表）。

由于ListProperty是Kivy框架的一部分，当data_items列表的内容发生变化时，Kivy的事件系统可能会触发某些事件（比如属性观察者或绑定的更新），但这取决于你的代码是如何处理这些事件的。

下面是一个简单的例子，展示了如何在Kivy的Widget类中使用ListProperty的clear()方法：

from kivy.app import App  
from kivy.uix.widget import Widget  
from kivy.properties import ListProperty  
from kivy.clock import Clock  
  
class MyWidget(Widget):  
    data_items = ListProperty([])  
  
    def __init__(self, **kwargs):  
        super(MyWidget, self).__init__(**kwargs)  
        # 初始化 data_items  
        self.data_items = [1, 2, 3]  
  
        # 使用Clock.schedule_once来模拟一些事件，比如按钮点击后清空列表  
        Clock.schedule_once(self.clear_items, 5)  # 5秒后清空列表  
  
    def clear_items(self, dt):  
        print("Clearing items...")  
        self.data_items.clear()  # 清空列表  
        print("Items cleared:", self.data_items)  
  
class MyApp(App):  
    def build(self):  
        return MyWidget()  
  
if __name__ == '__main__':  
    MyApp().run()

在这个例子中，MyWidget类有一个data_items属性，它是一个ListProperty。在__init__方法中，我们初始化了data_items列表，并使用Clock.schedule_once来模拟一个事件（比如按钮点击），该事件会在5秒后调用clear_items方法。在clear_items方法中，我们使用self.data_items.clear()来清空列表，并打印出清空后的列表内容。