Премини към съдържанието

Препоръчан отговор


Здравейте, имам въпрос защо това дава грешка:

table = 
"       +           +          n" +
"   %s   +     %s     +    %s    n" %(grid[0][0] , grid[0][1] , grid[0][2]) +
"       +           +          n" +
"++++++++++++++++++++++++++++++n" +
"       +           +          n" +
"   %s   +     %s     +    %s    n" % (grid[1][0],grid[1][1],grid[1][2]) +
"       +           +          n" +
"++++++++++++++++++++++++++++++n" +
"       +           +          n" +
"   %s   +     %s     +    %s    n" % (grid[2][0],grid[2][1] ,grid[2][2]) +
"       +           +          n" 
 
аз мога и на един ред да ги напиша, но просто някак си не ми харесва.

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

 

Здравейте, имам въпрос защо това дава грешка:

table = 
"       +           +          n" +
"   %s   +     %s     +    %s    n" %(grid[0][0] , grid[0][1] , grid[0][2]) +
"       +           +          n" +
"++++++++++++++++++++++++++++++n" +
"       +           +          n" +
"   %s   +     %s     +    %s    n" % (grid[1][0],grid[1][1],grid[1][2]) +
"       +           +          n" +
"++++++++++++++++++++++++++++++n" +
"       +           +          n" +
"   %s   +     %s     +    %s    n" % (grid[2][0],grid[2][1] ,grid[2][2]) +
"       +           +          n" 
 
аз мога и на един ред да ги напиша, но просто някак си не ми харесва.

 

Доколкото имам спомени питон не толерира линии на повече от един ред. Направете си цикъл и печатайте отвътре

П.П. Всъщност два цикъла един в друг ще свършат великолепна работа :)

  • Харесва ми 1

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

П.П. Всъщност два цикъла един в друг ще свършат великолепна работа :)

Тва не е C :) Мислете по змийски:
empty_line = "       +           +          n"filled_line = "   %s   +     %s     +    %s    n"plus_line = "++++++++++++++++++++++++++++++n"rows = [empty_line + filled_line%tuple(i) + empty_line for i in grid]table = "".join([i + plus_line for i in rows[:-1]]) + rows[-1]
Даже аналогично могат да се създадат и стринговете горе, но нямам време сега, така ще може да печата произволно големи таблици а не като тази с твърд размер.

...

Две забележки към автора: желателно е да ползвате новите форматни спецификатори. ползвайте тага code. Редактирано от flare (преглед на промените)
  • Харесва ми 2

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Благодаря много за бързите отговори.

Относно двете забележки на flare: за втората - много се извинявам, съвсем изключих.Относно първата имате предвид 

print("{}".format(x)) 

вместо 

print("%s" % x) 

? Преди се бях чудил кое е по-читаво, ама свикнах с това с процентчето. 

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Благодаря много за бързите отговори.Относно двете забележки на flare: за втората - много се извинявам, съвсем изключих.Относно първата имате предвид ? Преди се бях чудил кое е по-читаво, ама свикнах с това с процентчето.

Първото е по-ново, по-гъвкаво и с повече възможности. С процентчето не може да направиш примерно:
some_string = "{2:s}{1:s}{0:s}{1:s}{2:s}".format(*tuple('tor'))print(some_string)
Малко е безсмислено, само илюстрирам възможностите за разбъркване и повтаряне на параметрите. Може в някой момент да махнат старото от Python, и тогава ще трябва да пренаписвате кода за съвместимост.Тъй като Python е много портваем, е лошо да го осакатявате от това, ако не ви струва много. Затова и ви съветвам да ползвате този формат. Редактирано от flare (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Имам и още един въпрос.Чета тези tutorials  в официалния сайт.Но следното малко ме озадачи.Не мога да го схвана защо е така, може да е просто метод,който се приема по този начин при компилиране и да не може да се схване така "логически" ( т.е. направен е за удобство), но може пък просто да не го разбирам аз и тогава ще ми е гузно,че не съм го разбрал.Става въпрос за това:

 

def parrot(voltage, state='a stiff', action='voom'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.", end=' ')
    print("E's", state, "!")

= {"voltage""four million""state""bleedin' demised""action""VOOM"}
parrot(**d)

 
Ще изведе това:
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
 
Първо ми стана малко странно, че взема елементите на речника в дадената поредност,в която са написани в речника ( тъй като нали речника не ни гарантира ред).След това си казах, че вероятно това **d взема директно елементите един след друг както са си написани (има ли тук нещо друго, което трябва да знам за последователността,в която се взимат в случая).След това възникна следното зачудване: **d обхожда key- овете на речника т.е. взима например "voltage" и го поставя на първо място и така с всеки от останалите. Добре, но тогава, не трябва ли да визуализира "voltage", където имаме написан voltage (в print) ? А то един вид визуализира d["voltage]. Защо става така? Нещо не съм допрочел като съм препускал из тези работи ли или просто това е направено за удобство и не се приема така буквално както аз разсъждавам.
Благодаря предварително.
  • [*]
Отговор [*]Докладвай [*]Редактиране [*]
 
[*] 

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Имам и още един въпрос.Чета тези tutorials  в официалния сайт.Но следното малко ме озадачи.Не мога да го схвана защо е така, може да е просто метод,който се приема по този начин при компилиране

Интерпретиране :P

и да не може да се схване така "логически" ( т.е. направен е за удобство), но може пък просто да не го разбирам аз и тогава ще ми е гузно,че не съм го разбрал.Първо ми стана малко странно, че взема елементите на речника в дадената поредност,в която са написани в речника ( тъй като нали речника не ни гарантира ред).След това си казах, че вероятно това **d взема директно елементите един след друг както са си написани (има ли тук нещо друго, което трябва да знам за последователността,в която се взимат в случая).След това възникна следното зачудване: **d обхожда key- овете на речника т.е. взима например "voltage" и го поставя на първо място и така с всеки от останалите. Добре, но тогава, не трябва ли да визуализира "voltage", където имаме написан voltage (в print) ? А то един вид визуализира d["voltage"]. Защо става така? Нещо не съм допрочел като съм препускал из тези работи ли или просто това е направено за удобство и не се приема така буквално както аз разсъждавам.Благодаря предварително.

А на мен ми е странно, че ти е нелогично :)Значи, параметрите на една функция/метод могат да бъдат представени и като списък (тоест редът е важен) - това e стандартния начин на ползване - и като речник (тоест името на параметъра е важно). Кой от начините ще използва интерпретаторът, зависи от начина на извикване на функцията:Ако подаваш параметрите стандартно ще ползва списък - тоест всеки последователен елемент ще се подаде като пореден параметър.
parrot('a', 'b', 'c')
Аналогично, може да подадеш направо готова последователност с оператора *, който я "разгъва", така да се каже.
abc = ['a','b','c]parrot(*abc)
Както ти спомена, речниците не са подредени (или по-точно подредбата им не зависи директно от потребителя). Тогава интерпретатора ги търси по имена и може да ги подаваш в произволен ред:
parrot(state='a', action='b', voltage ='c')
или, както е в примера. От него е очевидно, че оператора за "разгъване" на речник е две звездички, не една. Ако се питаш защо, в Python всеки речник може да се разглежда и като списък от ключовете му, подредени по хеш. Може да пробваш, като махнеш едната звездичка от примера ;)Във всички тези случаи, ако подадеш последователност с по-малко стойности от броя параметри, Python ще използва стойностите по подразбиране за останалите. Ако не за всички останали параметри има стойности по подразбиране или си подал повече, това е недопустима ситуация и ще получиш exception. Редактирано от flare (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

По-скоро ми беше убягнало това ТЪРСИ. След като го написахте ми стана ясно.

 

Ето още едно подобно приложение на речници и такива подобни работи, за които питах по-горе:

new = { "food" :"awesome" , "today": "beautiful"}print(" This is {today} {food}  day".format(**new))

Също така какво ще направи :

map(lambda n: n**2, [0, 1, 2, 3, 4, 5])

На мен ми изписва : <map object at 0x00000000034D5898>

Извинете ме за невежеството, но за тази lambda или не и пише много от приложенията или пък има кодове подобни на горния.

Също така можете ли да ми кажете къде е приложима и евентуално къде има смисъл и къде е добра практика да се прилага ( тъй като това, че може да се използва не значи, че е добре да се използва)

Благодаря предварително.

Поздрави!

Редактирано от rusrusrus (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Извинете ме за невежеството, но за тази lambda или не и пише много от приложенията или пък има кодове подобни на горния.Също така можете ли да ми кажете къде е приложима и евентуално къде има смисъл и къде е добра практика да се прилага ( тъй като това, че може да се използва не значи, че е добре да се използва)Благодаря предварително.Поздрави!

Ламбда функция е малка и проста безименна функция, чиято идея е единствено краткост.Съвсем аналогично щеше да е да напишеш:
def n_squared(n):    return(n**2)map(n_squared,  [0, 1, 2, 3, 4, 5])
И веднага се вижда смисълът от нея - напълно ненужно е да правиш цяла отделна функция за нещо толкова просто и очевидно като повдигане на квадрат.Ламбда функциите се използват обикновено като параметър на друга функция, примерно като сравняваща функция при сортиране и т.н.Сега за map object-а. Както ти писах по-рано, в Python 3.x някои "неща" са направени "мързеливи". Това значи, че Python само си запомня, какво си му казал да направи, но не го прави, докато реално не ползваш резултата от него. В случая, си казал че ти трябва нова поредица, копто е съставена от квадратите на дадения списък. Съответно ти се връща обект, от който можеш да получиш именно тази поредица. Но реално квадратите ще се сметнат само ако ги ползваш, примерно:
m = map(lambda x: x*x,  [0, 1, 2, 3, 4, 5])i = next(m)print(i)i = next(m)print(i)for i in m:    print(i)
Забележи, че елементите се "изразходват". Ако искаш да получиш резултата, като истински списък, по-добрият вариант е list comprehension:
[x*x for x in [0, 1, 2, 3, 4, 5]]
Редактирано от flare (преглед на промените)
  • Харесва ми 1

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Регистрирайте се или влезете в профила си за да коментирате

Трябва да имате регистрация за да може да коментирате това

Регистрирайте се

Създайте нова регистрация в нашия форум. Лесно е!

Нова регистрация

Вход

Имате регистрация? Влезте от тук.

Вход

×

Информация

Поставихме бисквитки на устройството ви за най-добро потребителско изживяване. Можете да промените настройките си за бисквитки, или в противен случай приемаме, че сте съгласни с нашите условия за ползване.