从最终图像可以看出，部分节点签名被“截断”：
如果缩小字体，则铭文将不那么明显。编码：
import networkx as nx
import matplotlib.pyplot as plt
edges = [(0, 2), (1, 2), (2, 3)]
G = nx.Graph()
G.add_edges_from(edges)
pos = nx.spring_layout(G)
# получим метки узлов
labels = dict((i, str(i)*10) for i in range(4))
# рисуем граф
nx.draw(G, pos=pos, with_labels=False)
# рисуем метки
nx.draw_networkx_labels(G, pos=pos, labels=labels)
plt.savefig('labels.png')
有一个类似的列表[(1,2), (3,4), (5,6)]。如何优雅地将它分成两个这样的列表？：
[1,3,5]
[2,4,6]
问题不在于如何去做，而是有一个现成的功能可以将它们分开（类似于“解压缩”）
好吧，以防万一，代码，我是怎么做的：
tlist = [(1, 2), (3, 4), (5, 6)]
list1 = [a for a, _ in tlist]
list2 = [b for _, b in tlist]
print(list1, list2)
我想这样做：
list1, list2 = unzip(tlist, valuecount=2)
代码优化任务：
有这样一个元组列表：
['Moscow','NewYork', 2), ('Washington','London', 1), ('London','NewYork', 4)]
从中你需要得到这个：
[('Moscow', 'NewYork'), ('Washington', 'London'), ('London', 'NewYork')]
那些。仅提取每个元组的前 2 个元素。
除了使用列表推导和 Pandas 库之外，还有什么巧妙的方法吗？
我的代码：
# исходный список картежей
list_of_tuples_big = [('Moscow','NewYork', 2), ('Washington','London', 1), ('London','NewYork', 4)]
# с помощью генератора оставим только первые два элемента каждого кортежа
list_of_tuples_small = [(city1, city2) for city1, city2, _ in list_of_tuples_big]
PS 元组作为列表的元素是一种约定，它可以被列表替换。
有这样一行'\u041c\u0422\u0421_WSD'，其中前三个字符是俄语字母 MTS，然后是英文的 _WSD。如何将其转换为“可读”形式。
我的代码：
s = '\u041c\u0422\u0421_WSD'.encode('utf-8').decode('utf-8')
如果分解成部分：
# кодируем в bytes
s = '\u041c\u0422\u0421_WSD'.encode('utf-8')
# декодируем в строку
s = s.decode('utf-8')
我与“编码”有很大的差距，所以我不明白这种转换是如何工作的。请帮助我了解谁遇到了这个问题。
需要从一组随机字符中提取包含姓名、姓氏等的单词。例如，从这组词中：
3kshjfsdhf9834r
Henry11
34r9jsadfsdf
Jackson33
3d2d32ddffjkj
Alex
得到这个：
Henry11
Jackson33
Alex
到目前为止，我正在考虑计算单词中的元音和辅音，然后留下元音和辅音一定比例的单词。第二种选择是使用字典，但我不确定是否存在包含所有姓名和姓氏的字典，并且还必须考虑俄语姓名和姓氏。
也许有一些来自“时尚”机器学习世界的现成解决方案？
几天来，我无法理解 Future 和 Task 对象之间的区别。更准确地说，我不确定我是否完全理解使用的内容和位置。
从文档中可以看出，在 asyncio 中有三种类型的 curutin 对象，任务（Task）和期货（Future）（我们称之为）。任务是计划在事件循环中运行的curout。
当协程被包装到具有 asyncio.create_task() 之类的函数的任务中时，协程会自动安排为很快运行
期货是某种存储异步操作可能结果的对象。
Future 表示异步操作的最终结果
那些。为了启动 curutina 以异步模式执行，您需要使用asyncio.create_task，但是为什么我们需要ensure_future呢？它出现在所有 asyncio 代码示例中。我在 stackoverflow 上找到了一个相关问题，但在我看来，那里没有正常的答案。下面是我使用不同选项启动 curutin 的代码 - 结果总是相同的：
import asyncio
import time
async def fetch(n):
await asyncio.sleep(n)
print(time.time())
return n
loop = asyncio.get_event_loop()
# coros = [asyncio.ensure_future(fetch(i)) for i in range(2)]
# coros = [fetch(i) for i in range(3)]
coros = [loop.create_task(fetch(i)) for i in range(2)]
results = loop.run_until_complete(asyncio.gather(*coros))
print(results)
使用选项 2 和 3，这是可以理解的，因为根据文档，gather 将 curutins 转换为任务，但他们为什么使用ensure_future. 该文档还说最好使用create_task.
另请参阅 create_task() 函数，它是创建新任务的首选方式。
总而言之，我想听听关于未来是什么、它与任务有何不同以及在何处使用它的简单解释。
有两个字典列表：
types- 包含有关体育部分名称和一位访问者访问日期的信息。
user_list- 包含有关也去过这个健身房的人的信息以及他们的访问日期。
types = [{'type':'tango', 'date':'200118'},
{'type':'box', 'date':'110217'},
{'type':'strip', 'date':'170518'}]
user_list = [{'name':'maxim', 'date':'200118'},
{'name':'ivan', 'date':'110217'},
{'name':'elena', 'date':'051018'},
{'name':'gleb', 'date':'170518'},
{'name':'magas', 'date':'110217'},
{'name':'ivan', 'date':'170518'},
{'name':'maxim', 'date':'110217'}]
有必要从第二个列表中选择与第一个列表中指定的日期相同的访问者。还有一个条件：他们不止一次在同一个日期。
最终结果应该是这样的列表：
[{'date': '110217', 'name': 'ivan'}, {'date': '170518', 'name': 'ivan'}, {'date': '200118', 'name': 'maxim'}, {'date': '110217', 'name': ‘maxim'}]
如果解释不同，则需要从第二个列表中选择存在于第一个列表中且在第二个列表中多次出现的“日期”字段的值的行。以下是我的解决方案，我真的不喜欢。部分代码可以用生成器替换，但也许有人知道更优化的工具？
types = [ {'type':'tango', 'date':'200118'},
{'type':'box', 'date':'110217'},
{'type':'strip', 'date':'170518'}]
user_list = [{'name':'maxim', 'date':'200118'},
{'name':'ivan', 'date':'110217'},
{'name':'elena', 'date':'051018'},
{'name':'gleb', 'date':'170518'},
{'name':'magas', 'date':'110217'},
{'name':'ivan', 'date':'170518'},
{'name':'maxim', 'date':'110217'}]
dates = [dct['date'] for dct in types]
names = list(set([dct['name'] for dct in user_list]))
goodusers = []
for name in names:
res = []
for u in user_list:
if u['name']==name and u['date'] in dates:
res.append(u)
if len(res)>1:
goodusers += res
print(goodusers)
有必要启动几个会话并让每个会话执行一定数量的请求。我想指出，有必要有几个会话，而不仅仅是一个，正如几乎所有 aiohttp 示例中所展示的那样。下面是其中的代码：
在此之前，我尝试通过一个会话完成所有操作，并且一切正常，因为我使用了使用上下文管理器的示例中的代码，它本身关闭了会话，并且在示例中使用了一层“沉浸式” .
import asyncio
import aiohttp
import math
# генератор который будет разрезать списки
def listpartial(inlist, n):
if n > 0:
s = math.ceil(len(inlist) / n)
for q in range(s):
yield inlist[q * n:(q + 1) * n]
# собсвенно загрузчик страниц
async def fetch(num, session):
try:
url = f'https://en.wikipedia.org/wiki/{num}'
async with session.get(url) as r:
await asyncio.sleep(0.1, 0.3)
return await r.text(encoding='utf-8')
except Exception as e:
print('fetch', e)
return ''
async def runfetchers(numlist, session):
tasks2 = []
# создам количество задач на загрузку каждого элемента
for num in numlist:
task = asyncio.ensure_future(fetch(num, session))
tasks2.append(task)
responses = await asyncio.gather(*tasks2)
return responses
async def run(allnums):
tasks = []
sessions = []
# получии объект генератор который будет выдавать списки по 20 элементов
numlist = listpartial(allnums, 20)
# создам 3 сессии и столько же задач и запущу их
for _ in range(3):
session = aiohttp.ClientSession()
sessions.append(session)
task = asyncio.ensure_future(runfetchers(next(numlist), session))
tasks.append(task)
responses = await asyncio.gather(*tasks)
# закрываю открытые сессии
# ?????? как закрыть вот эти сессии
# for i in sessions:
# sessions[i].close()
return responses
if __name__ == '__main__':
nums = [x for x in range(1200)]
loop = asyncio.get_event_loop()
future = asyncio.ensure_future(run(nums))
res = loop.run_until_complete(future)
print(res)
下面给出了我的问题的答案（再次感谢），但同时我编写了一个以不同方式解决我的问题的代码，也许它对某人会派上用场：
# собсвенно загрузчик страниц
async def fetch(num, session):
try:
url = f'https://en.wikipedia.org/wiki/{num}'
async with session.get(url) as r:
await asyncio.sleep(0.1, 0.3)
return await r.text(encoding='utf-8')
except Exception as e:
print('fetch', e)
return ''
# запустим сессию, которая запустит несколько запросов
# и потом сама себя закроет
async def start_sesssion(numlst):
async with aiohttp.ClientSession() as session:
futs = [asyncio.create_task(fetch(n, session)) for n in numlst]
return await asyncio.gather(*futs)
if __name__ == '__main__':
nums = [x for x in range(1200)]
numlist = listpartial(nums, 20)
loop = asyncio.get_event_loop()
futures = [loop.create_task(start_sesssion(next(numlist))) for i in range(3)]
result = loop.run_until_complete(asyncio.gather(*futures))
print(result)
有必要检查列表中的单词是否包含lst在字符串中string。下面的代码正在运行，但显然不是最佳选择。而且我也不确定正则表达式是否很快。
string = 'hello world people'
lst = ('foo', 'bar')
r = False
for x in lst:
if string.find(x) != -1:
r = True
break
print('Contains words:', r)
在观看了Pycon关于 Python 内存使用的演讲之一之后，我想知道 pymler.asizeof 和 sys.getsizeof 模块函数之间的真正区别是什么。为清楚起见，考虑一个测量各种对象尺寸的示例。
from pympler import asizeof
from collections import namedtuple
from sys import getsizeof
class CLASS:
def __init__(self, x1, x2, x3):
self.x1 = x1
self.x2 = x2
self.x3 = x3
class SLOTS:
__slots__ = ['x1', 'x2', 'x3']
def __init__(self, x1, x2, x3):
self.x1 = x1
self.x2 = x2
self.x3 = x3
NTUPLE = namedtuple('NTUPLE', 'x1 x2 x3')
tpl = ('str', 111, 22.22)
ntuple = NTUPLE('str', 111, 22.22)
vClass = CLASS('str', 111, 22.22)
vSlots = SLOTS('str', 111, 22.22)
print('Pympler#',
'namedtuple:', asizeof.asizeof(ntuple),
'tuple:', asizeof.asizeof(tpl),
'class:', asizeof.asizeof(vClass),
'slots:', asizeof.asizeof(vSlots))
print('Sys#',
'namedtuple:', getsizeof(ntuple),
'tuple:', getsizeof(tpl),
'class:', getsizeof(vClass),
'slots:', getsizeof(vSlots))
结论：
Pympler# namedtuple: 184 tuple: 184 class: 448 slots: 176
Sys# namedtuple: 72 tuple: 72 class: 56 slots: 64
在这个例子中，我想自己了解哪些结构占用的空间最少，但是在使用时，asizeof.asizeof最小的对象是槽，当用函数测量时getsizeof，最小的对象是类。作为搜索的结果，我找不到这些函数之间差异的详细描述，在视频中，演讲者只注意到它getsizeof返回的大小没有，例如，dict 对象的大小。
保存字典的结果有这样的json数据：
{'id':1, 'name':'Garry \"Hotdog\"'}
问题 #1：这个 json 不是标准的，它的 Deserialization(json.loads) 会导致错误，因为引号是单引号。 'name' 元素内的问题 #2包含“引号内的引号”，即 用双引号普通替换单引号并不能解决问题。
我尝试使用 json.dumps 函数，然后将对象传递给 json.loads，但由于某种原因，返回的不是字典，而是字符串。
import json
str_json = "{'id':1, 'name':'Garry \"Hotdog\"'}"
dmp = json.dumps( str_json )
jstr = json.loads(dmp)
print(jstr['id'])
错误：
TypeError: string indices must be integers
请告诉我如何在没有“因果关系”的情况下快速解析“这样的”json？
这是一个类似的问题，但没有人回答（
我刚刚开始学习 python，出现了几个关于“最小化”代码的问题。例如，re.findall() 函数返回一个找到的字符串列表，但我总是需要一个，为了“安全”地得到它，我必须在分配之前检查列表的长度：
re_email = re.findall('pattern',string)
if len(re_email):
#получаю первый элемент который мне и нужен
email = re_email[0]
或者，在使用 bs4 函数时，不要立即应用下面的 get_text() 函数，因为可能找不到对象并且会引发异常。想要这样：
name = html.find(iprop="usrname").get_text()
它是这样的：
item_name = html.find(iprop="usrname")
name = ''
if item_name:
name = item_name.get_text()
是否有可能以某种方式缩短这些结构的编写时间？
下面是代码，理论上应该是启动进程，通过锁改变全局变量glob（应该是20）。但实际上glob变量最后并没有变化，就好像退出函数时值没有保存一样：
glob = 10
def printer(item, lock):
global glob
lock.acquire()
try:
glob = glob + 10
print('proc {0} var {1}'.format(item,glob))
finally:
lock.release()
lock = Lock()
for i in range(1):
p = Process(target=printer, args=(i, lock))
p.start()
p.join()
print(glob)