如果这是您的本地用户crontab,那么当脚本运行时,当前目录将设置为您的主目录, /home/eric .你可能做了类似的事情 sqlite3.connect('quotebot.db') 。该文件不存在,sqlite3很乐意为您创建一个新的空数据库。

如果您需要家庭以外的文件,则必须使用绝对路径,或者使用 os.path.dirname(__file__) .

分两个阶段进行。使用字典建立唯一列表,然后转换为字典列表:

from collections import defaultdict

vpcs = [{'ResourceOwnerId': '111111111111', 'ResourceType': 'vpc', 'ResourceId': 'vpc-aaaaa'},
        {'ResourceOwnerId': '222222222222', 'ResourceType': 'vpc', 'ResourceId': 'vpc-ccccc'},
        {'ResourceOwnerId': '111111111111', 'ResourceType': 'vpc', 'ResourceId': 'vpc-ddddd'}]

accum = defaultdict(list)
for vpc in vpcs:
    accum[vpc['ResourceOwnerId']].append( vpc['ResourceId'] )

print(accum)

acc_list = []
for k, v in accum.items():
    acc_list.append(
        {
            "account_number": k,
            "vpc": v
        }
    )

print(acc_list)

输出:

defaultdict(<class 'list'>, {'111111111111': ['vpc-aaaaa', 'vpc-ddddd'], '222222222222': ['vpc-ccccc']})
[{'account_number': '111111111111', 'vpc': ['vpc-aaaaa', 'vpc-ddddd']}, {'account_number': '222222222222', 'vpc': ['vpc-ccccc']}]

或者,对于那些喜欢一句台词的人:

...
acc_list = [ { "account_number": k, "vpc": v } for k, v in accum.items()]
print(acc_list)

在第二行中,Python对赋值语句的右侧求值,这将创建一个使用旧绑定的字符串 greeting .只有在对该表达式求值之后,它才会处理赋值运算符,该运算符将该字符串绑定到名称。这都是线性的。

浮点数和整数也是不可变的。只有列表和字典是可变的。实际上,目前还不清楚在任何情况下如何修改integer对象。你指不到物体的内部。重要的是要记住,在这种情况下:

i = 3
j = 4
i = i + j

最后一行只是创建一个新的整数/浮点对象并将其绑定到 i 。所有这些都不会试图修改integer对象 3 .

我写了这篇文章,试图描述Python对象和我们使用的名称之间的区别:

https://github.com/timrprobocom/documents/blob/main/UnderstandingPythonObjects.md

你的循环只是在第一个随机数上循环,这绝对不是你想要的。你需要一个“永远”的循环,当用户想要停止时它就会退出。请注意,您需要在该循环中分配数字。还请注意,您不需要转换为字符串。

import random 
print('Python Slot Machine')

while True:
    random_num1 = random.randint(0,2)
    random_num2 = random.randint(0,2)
    random_num3 = random.randint(0,2)

    print(random_num1, random_num2, random_num3)
    if random_num1 == random_num2 == random_num3:
        print('You matched 3!')
    elif random_num1 == random_num2 or random_num1 == random_num3 or random_num2 == random_num3:
        print('You matched 2!')
    else:
        print('You lost')

    if input("Go again?  y/n: ") == "n":
        break

只需先将列转换为字符串:

import pandas as pd
df = pd.DataFrame({'col':['G5051', 'G5052', 5053, 'G5054']})
print(df['col'].astype(str).str.lower())

这里有一个更好的方法。

import ast
s = ast.literal_eval(s)
entries = [a[0] for a in s]

看看这是否为您提供了一个关于如何通过2D数组进行枚举的提示,如下所示:

for y,row in enumerate(connect_four):
  for x,item in enumerate(row):
    print( f"The contents of {y},{x} is {item}." )

记住这一点 index 返回该行中第一个匹配项的索引。在这种情况下,这几乎永远不会是你想要的。

你根本不需要解析日期和时间。它们只是线。 考虑这个解决方案:

import json 

data = """\
22-10-2018,01:00:00,7.6,Station1
22-10-2018,01:15:00,9.0,Station1
22-10-2018,01:30:00,6.3,Station1
22-10-2018,01:45:00,4.1,Station1
22-10-2018,02:00:00,4.5,Station1
22-10-2018,02:15:00,7.3,Station1
22-10-2018,02:30:00,6.1,Station1
23-10-2018,01:30:00,6.3,Station2
23-10-2018,01:45:00,4.1,Station2
23-10-2018,02:00:00,4.5,Station2
23-10-2018,02:15:00,7.3,Station2
23-10-2018,02:30:00,6.1,Station2""".splitlines()

outdata = []
anydata = {}
lastkey = None
for line in data:
    date,time,temp,stn = line.split(',')
    if (stn,date) != lastkey:
        if anydata:
            outdata.append(anydata)
        lastkey = stn,date
        anydata = { "Station": stn, "Date": date, "Temps": [] }
    anydata["Temps"].append( (time,float(temp)) )
outdata.append(anydata)

print(json.dumps(outdata))

这将为每个站/日期组合生成一个元素,该组合包含时间/温度组合列表:

timr@tims-gram:~/src$ python x.py | jq .
[
  {
    "Station": "Station1",
    "Date": "22-10-2018",
    "Temps": [
      [
        "01:00:00",
        7.6
      ],
      [
        "01:15:00",
        9
      ],
      [
        "01:30:00",
        6.3
      ],
      [
        "01:45:00",
        4.1
      ],
      [
        "02:00:00",
        4.5
      ],
      [
        "02:15:00",
        7.3
      ],
      [
        "02:30:00",
        6.1
      ]
    ]
  },
  {
    "Station": "Station2",
    "Date": "23-10-2018",
    "Temps": [
      [
        "01:30:00",
        6.3
      ],
      [
        "01:45:00",
        4.1
      ],
      [
        "02:00:00",
        4.5
      ],
      [
        "02:15:00",
        7.3
      ],
      [
        "02:30:00",
        6.1
      ]
    ]
  }
]

这是你在两点之间划一条线的方法。这是基于Bresenham的算法。你知道哪个方向变化最大,这就是你的“主要”方向。然后,在每一步,你都会朝着主方向移动一个。你保留一个“误差项”,它跟踪你需要在“小”方向上移动多远,当它穿过整个单元时,你也会在小方向上移动。还要注意的是,在numpy术语中,Y坐标(行)应始终位于第一位。

import cv2 as cv
import numpy as np
dim_x = 50
dim_y = 50

x1,y1 = (8,8)
y2,y2 = (40,30)

# Are we increasing in X?

deltax = x2 - x1
deltay = y2 - y1

dirx = 1 if deltax > 0 else -1
diry = 1 if deltay > 0 else -1

# Which direction is major?

if deltax > deltay:
    steps = deltax
    xmajor = 1
else:
    steps = deltay
    xmajor = 0

error = 0

pic = np.zeros((dim_y,dim_x))
pic[y1,x1] = 255
pic[y2,x2] = 255
for count in range(steps):
    if xmajor:
        x1 += dirx
        error += deltay
        if error >= deltax:
            y1 += diry
            error -= deltax
    else:
        y1 += diry
        error += deltax
        if error >= deltay:
            x1 += dirx
            error -= deltay
    pic[y1,x1] = 255
    print(x1,y1)
cv.imwrite("frame.png", pic)

文件上说,“两者都不是 r1 也没有 r2 应该有副本吗 key :重复的存在将使输出非常不可靠。请注意,算法不会查找重复项。".

http://pyopengl.sourceforge.net/pydoc/numpy.lib.recfunctions.html

熊猫有一个更传统的连接功能,如果你想走那么远的话。

应该清楚地知道如何扩展现有资源。看在上帝的份上,不要多次重复JSON加载。

data = json.loads(children.text)
firstNames = [k['firstname'] for k in data['children']]

分块上传的开销更大,因此它们只允许上传大于20MB的文件。对于较小的文件,请使用普通 upload 应用程序编程接口。事实上,他们推荐正常的 上载 高达50MB。

你需要从函数中返回一些东西。然后,当递归返回时,需要将这个(最低有效)数字添加到从父级得到的数字中。

def decimalToBinary(num):
    s = ''
    if num > 1:
        s = decimalToBinary(num // 2)
    return s + str(num%2)
number = int(input("Enter any decimal number:"))
print(decimalToBinary(number))

你告诉它,数据将以URL编码的形式出现,但事实并非如此 request 默认情况下是这样的。我相信你需要:

resp = http.request(
        "POST",
        "https://core.syhapp.com/hpca/oauth/token",
        fields={
            "grant_type": "client_credentials",
            "client_id": "YYYYYYYYY",
            "client_secret": "XXXXXXXXX"
        },
        encode_multipart = False
    )

要求 取代 Content-Type 标题,所以根本没有必要指定它。

__call__ 只是对象创建的间接部分。你的例子并不像你想象的那样——它没有调用 dict.__call__ .只有你这么做了才会打电话 x() 哪里 x 是一个 dict 例子

字典 恰好是一个对象本身,类型 class 这个 班 类型有一个 __打电话__ 方法,它允许您编写 x = dict() 这个 class.__call__ 方法触发对象创建。

对象创建包括 __new__ 和 __init__ .

您的列表数据中有错误。我将字符串“],”替换为字符串“],\n”,以便查看结构。第30条输入错误:

...
['2022-04-01T14:00:00Z', '2022/04/01 00:58:53', '-', 'Csm Slatina', 'ACS Vedita Colonesti MS', '-', '-', '-', '-', '-'],
['2022-04-01T14:00:00Z', '2022/04/01 00:58:53', '-', 'CSM Flacara Moreni', 'ACS FC Academica Clinceni 2', '-', '-', '-', '-', '-'],
[2.36, '-'],
['2022-04-01T14:00:00Z', '2022/04/01 00:58:55', '-', 'Dinamo Bucuresti II', 'CS Real Bradu', 1.93, '-', '-', '-', '-'],
['2022-04-01T14:00:00Z', '2022/04/01 00:58:56', '-', 'FCSB II', 'FC Arges II', '-', '-', '-', '-', '-'],
...

如果你修正了数据,它的排序就会很好。

改善效果追踪

你可以通过

para_planiha = [k for k in para_planiha if len(k) > 2]

tkinter 与所有GUI框架一样,是事件驱动的。当你创建这些标签或采取任何行动时,都不会立即采取任何行动。所做的就是发送消息。这些消息将一直排在消息队列中,直到您到达 mainloop .主循环调度并处理所有这些消息,从而采取行动。

所以,在运行循环时,屏幕上什么都没有。你所做的只是将时间延迟到主窗口设置完毕。

所以,你需要做的是使用 win.after 每0.2秒请求一次回调。在该回调中,您将添加下一个字符,并请求另一个回调。你一次做一个。我会创建一个包含要显示的字母的全局列表。每次通话消耗一个字母,直到列表为空。

to_be_drawn = []

def callback():
    if not to_be_drawn:
        return
    nxt = to_be_drawn.pop(0)
    ab.set( ab.get() + nxt )
    win.after( 200, callback )

def start_typing(text):
    was_empty = not to_be_drawn
    text = text.replace('[','').replace(']','').replace(',','')
    to_be_drawn.extend( list(text) )
    if was_empty:
        win.after( 200, callback )

start_typing( "Hello, kitty!" )

def get_level(s):
    return s.count('-')

def translate(test_list):
    seg_ids = []
    levels = [0]*9
    last_level = 99
    for an_ele in test_list:
        level = get_level(an_ele)
        if level <= last_level:
            levels[level] += 1
        else:
            levels[level] = 1
        seg_ids.append( '_'.join(str(k) for k in levels[:level+1]))
        last_level = level
    return seg_ids

print(translate(['heading', 'heading','sub-heading', 'sub-heading', 'heading', 'sub-heading', 'sub-sub-heading', 'sub-sub-heading', 'sub-heading', 'sub-heading', 'sub-sub-heading', 'sub-sub-heading','sub-sub-heading', 'heading']))

输出:

['1', '2', '2_1', '2_2', '3', '3_1', '3_1_1', '3_1_2', '3_2', '3_3', '3_3_1', '3_3_2', '3_3_3', '4']

这将最大级别数固定为9。你可以通过设置 levels=[0] 然后,如果新的水平已经超过了终点,那么就扩展它,但这一点得到了理解。

看看这句话:

input_check("Do you know the rules?\n", rules(), "Ok. Starting game...")

当您这样做时,Python将调用 rules 立即运行,以便将结果传递给 input_check 你的 规则 函数打印出一堆东西,然后有完全相同的行,这将调用 rules() 一次又一次,一次又一次,一次又一次。。。它从来没有机会打电话 输入检查 .它还在处理参数。

如果要传递函数对象但不调用它,请不要使用参数:

input_check("Do you know the rules?\n", rules, "Ok. Starting game...")

请注意 输入检查 函数将继续调用传入的函数。你不需要在里面再打电话 规则 .

改善效果追踪

这和你想的不一样:

  if yes_no.lower() == "n" or "no":

解析为:

  if (yes_no.lower() == "n")   or "no":

既然“不”是真的,那么if将永远被接受。您应该使用以下选项之一:

  if yes_no.lower() in ("n" or "no"):
  if yes_no.lower()[0] == "n":

接下来,你有这个:

  if yes_no.lower() == "n" or "no":
    function

在这里,您确实想调用函数,因此需要添加参数:

  if yes_no.lower()[0] == "n":
    function()

这将创建一个dict列表和一个包含键的列表。这就是你想要的吗?

import json

jdata = json.loads(data)
jheader = []
jrows = []
for key,parts in jdata.items():
    if not jheader:
        jheader = list(parts[0].keys())
    jrows.extend(parts)

修复索引后,还有其他问题。“Mergesort”应该就地进行排序,修改原始列表。你没有那样做;你在试图建立一个新的列表。这意味着您需要返回已创建的列表,并在下一步中使用它。

然后, c 不能是全球性的。它是“merge”函数的本地调用,因此每个调用都有自己的副本。最后,每个合并步骤只处理列表的一部分。你必须复制你没有改变的部分。这似乎有效:

def mergesort(a,low,high):
    if low<high:
        mid=(high+low)//2
        a = mergesort(a,low,mid)
        a = mergesort(a,mid+1,high)
        a = merge(a,low,mid,high)
    return a
def merge(a,low,mid,high):
    c = a[:low]
    i=low
    j=mid+1
    while i<=mid and j<=high:
        if a[i]<=a[j]:
            print(a[i])
            c.append(a[i])
            i+=1
        else:
            print(a[i])
            c.append(a[j])
            j+=1
    c.extend( a[i:mid+1] )
    c.extend( a[j:] )
    return c

a=[4,2,7,0,9,6,5]
c = mergesort(a,0,len(a)-1)
print(c)