Anonymní profil Pavel – Programujte.com

#57 Kit
Hm, pokud jde o F#, na linuxu se bez problémů používá v produkčním prostředí s Mono. Ale jde určitě o odvážnou volbu. :)

Co jsem viděl, tak si lidé stěžovali spíš na to, že nejsou nástroje srovnatelné s VS Studiem. Ale podle mne je VS Code s Ionide výborné. Ionide se vyvíjí velice rychle.

Navíc F# je součástí Dotnet Core, ale tam je na nějaké hodnocení příliš brzy. Zkrátka, pokud bys chtěl F# vyzkoušet, Linux není vysloveně překážka.

F# je jedinečně navržený a podle mne stojí za seznámení. Clojure je také výborný, ale není pro každého.

Hodně štěstí. :)

PS: Mimochodem,  kdybys měl shodou okolností nějaké zkušenosti s VS Code + PHP, docela by mne to zajímalo. Jeden kamarád se mne na to nedávno ptal, ale protože jde PHP mimo mne, nebyl jsem schopný mu odpovědět.

#55 Kit
Editor napíše, ale nepřečte. :)

Já osobně považuji čtení OOP kódu za nesmírně obtížné. Člověk skáče z místa na místo a nikde se nic podstatného neděje.

Podle mne bys dávno skončil například tady:

http://lucasmreis.github.io/blog/type-driven-domain-modelling-part-1/

Kdyby sis ovšem nevybral dva jazyky, které ti budou pokud možno házet klacky pod nohy :) Ale proti gustu...

#53 Kit
PHP a Java, drobet masochismus, ne?

Jsi si jistý, že se neupíšeš?

Kolik takových tříd musíš vytvořit? Notabene když musíš používat návrhové vzory, kterým by ses mohl alespoň částečně vyhnout, kdybys měl k dispozici moderní vlastnosti C#, abychom zůstali v OOP mainstreamu.

#51 Kit
Ale já ti rozumím, na tvém místě bych to dělal podobně.

Jenom bych použil jiný jazyk, protože bych se v Javě upsal.

#48 Kit
A co když tvůj interface vyžaduje setter nebo getter? Což, jak jsem se díval, je v Javě naprosto v pořádku.

V každém případě bych žádnému začátečníkovi Javu nedoporučoval. Z mého pohledu je to mastodont, který prostě zastaral. Clojure je jiná liga, popřípadě Scala. Ale ani jeden bych nedoporučil začátečníkovi, možná že Groovy by byla pro začátečníka nejlepší volba, pokud to musí být JVM. 

#46 Kit
Trochu jsem si zabádal, a hele, ona to není nakonec nic jiného než ta ohraná písnička na téma mutability/immutability. Nebylo mi moc jasné oč jde, když settery a gettery nejsou nakonec nic jiného než metody, obzvlášť v Javě a v principu nejde o nic jiného než návrhový vzor vložený přímo do jazyka, který Java zjevně podporuje.

Jinak samozřejmě změna stavu objektu je zlo, které  propagují a propagovaly OOP jazyky (ale Java není OOP, že ne?), ale že se jednou dožiju toho, že mi někdo bude přes Javu vnucovat principy, které jsou vlastní FP jazykům, to bych tedy nečekal. A co další FP prvky? Kolik se jich do Javy podařilo propašovat kromě anonymních funkcí?

Je ti alespoň jasné, že bez persistentních typů budeš mít potíže s výkonem, když budeš psát své OOP takhle? Nebo chceš přes metody měnit vnitřní stav objektů, to ale pak není nic jiného než převlečený setter?

#43 ondrej39
To nejspíš bude věc názoru.

#29 Kit

Proto tam také nejsou zjednodušené gettery a settery jako třeba v C# - jsou to nežádoucí konstrukce. Tím nás tlačí do zápisu takového objektového kódu, ve kterém tyto konstrukce mít nebudeme.

Prosím, můžeš mi to vysvětlit? Jaké konstrukce tedy Java podporuje?

#1 Lukáš

https://networkx.github.io/

#16 Ovrscout
Samozřejmě. Souhlasím s tebou, pokud chceš říct, že to pro sto čísel nebude tak nebude fungovat. Navrhl bych třeba toto:

from random import shuffle
cisla = list(range(100))
shuffle(cisla)
nahodna_cisla_70 = cisla[:70]

Ale v podstate tohle za tebe řeší *sample* z knihovny *random*. Předpokládám, že ta ti funguje, jak má?

#12 peter

Nechceš se podívat nahoru a trochu se zamyslet? Jaká je podle tebe pravděpodobnost, že ve 100 případech bude (random() < 0.7) == True. Kolem 70%. Co myslíš? Takže co to nekomplikovat? :)

#1 allicce

Nešlo prostě o tohle?
 

from random import random

if random() < 0.7:
   print("Zasažen s pravděpodobností 70%")
else:
   print("Nezasažen s pravděpodobností 30%") 

#1 python_test

Pokud jde o tu želvu, myslel jsi toto?

from turtle import Turtle
julie = Turtle()

def vykresli(zelva, start, data, koef = 1):
    julie.pu()
    julie.goto(*start)
    julie.pd()
    julie.setheading(0)
    for delka, uhel in data:
        zelva.forward(delka *  koef)
        zelva.right(uhel)

data = ((10, 45),
        (10, -45),
        (10, -45),
        (10, -315),
        (10, 90),
        (30, 90),
        (10, 45),
        (10, -45),
        (10, -45),
        (10, 90))

vykresli(julie, (0,0), data, 0.5)
vykresli(julie, (40,40), data, 1)
vykresli(julie, (80, 80), data, 2)

#1 honzax

Zjednodušeně řečeno, máš 3 hlavní možnosti.

https://www.quora.com/Python-Web-Frameworks-Should-I-go-for-Django-Pyramid-or-Flask-for-backend

Ale přijde mi, že hledáš něco, co s Pythonem nemá moc společného.

#1 Dominik

Pro jistotu, abych vysvětlil, jak by měl takový kód třeba vypadat. Tu lambdu samozřejmě použít nemusíš :)
 

from random import randint

def vypocitej(minimum, maximum, rozsah):
    data = tuple(randint(minimum, maximum) for i in range(rozsah))
    return data, min(data), max(data), sum(data)/len(data)

def main():
    data, min_, max_, prumer = vypocitej(* map(lambda x: int(input(x)),
                                               ("Min: ", "Max: ", "Rozsah")))
    print("Data: ", data)
    print("Minimum: ", min_)
    print("Maximum: ", max_)
    print("Průměr: ", prumer)

main()

#1 Dominik
Úplně nejjednodušší je zkrátka napsat, že globální list1 není tentýž jako lokální list1, který máš v těle funkce.

Ale...

Copak tě nikdo nevaroval před globálními proměnnými? Víš, že existuje nějaký return? A ten cvičící tě neupozornil, že takto bys to neměl dělat?

#8 Petra
Jsi ve špatném vlákně, tady se řeší Python. Ale princip je stejný.

Nejprimitivnější řešení je něco na tento způsob:

using System.Collections.Generic;
var klavesy = new Dictionary<char, int>();
klavesy.Add('a', 1);
klavesy.Add('b', 2);
Console.WriteLine(klavesy['a']);

Tohle ti ale asi nebude fungovat. Jenom tady na vyzkoušení.

http://csharppad.com/

Prostě si udělej slovník, ve kterém na tvrdo zadáš očekávané vstupy. Pokud je písmeno ve slovníku, vrátíš číslo. Pokud není, vrátíš něco jiného. 

#5 Petra
Visual studio je prostředí. Jaký používáš programovací jazyk? Python, C#, F#, VB.NET?

#1 Eva

Pokud si jakoukoliv posloupnost setřídíš podle velikosti, pak takové setříděné pole má na svých koncích největší a nejmenší číslo. Tím pádem máš tři úkoly vyřízené. Můžeš použít nějaký jednoduchý algoritmus, jako když si doma skládáš karty, například pomocí list a jeho metody insert.

Anebo si můžeš najít nějaký  třídící algoritmus na internetu :)

Tohle bys měl řešit jako matematickou úlohu, ne programátorskou.Možná by ti pomohlo SymPy. Sestav si rovnice a vyřeš je :)

http://www.sympy.org/en/index.html

#5 Task1337
Chápu,

v každém případě jsem ti doporučil si pro sudoku udělat slovník. Jeho klíči jsou souřadnice jako tuple (x,y)

Slovník jsem vytvořil pomocí slovníkové komprehenze a jako výchozí jsem dal hodnotu None, tedy nic.

Hodnotu můžeš zadat pomocí:

sudoku[(1,2)] = 10

Pokud se pokusíš zadat neexistující souřadnice, dostaneš tuším IndexError

r9 = range(1,10) je uložená posloupnost od 1 - 9.

POkud si ji chceš prohlédnout, musíš si ji rozbalit, například takto: tuple(r9)

product je například toto:

>>> list(product("ab", "xyz"))
[('a', 'x'), ('a', 'y'), ('a', 'z'), ('b', 'x'), ('b', 'y'), ('b', 'z')]

V našem případě ti to vytvoří 81 uspořádaných dvojici od 1,1 do 9,9

#3 Task1337

Globální proměnné nepoužívej, ušetříš si spoustu starostí.

Jinak můžeš pro reprezentaci sudoku použít slovník:

from itertools import product
r9 = range(1,10)

sudoku = {(x,y): None for x,y in product(r9, r9)}

print(sudoku)

Co je thismodule.plocha?

1,2,3

Setřídíš podle x od nejmenšího

1

2

3

Setřídíš podle x od největšího vynásobením -1

-3

-2

-1

#3 Marek
To se mi moc nezdá. Ale neporadím ti, protože nevím.

Pochybuji,

ale co tak zkusit http://kivy.org/#home

#1 Marek
Seznam knihoven i s licencemi

https://pypi.python.org/pypi

#7 Standa
Abych pravdu řekl, moc se mi nezdá to, co jsi napsal. Neznám ArcPy, ale předpokládám, že ho dělal někdo, kdo umí v Pythonu programovat. Můžeš dát příklad toho, co myslíš. A vypsat nápovědu pomocí funkce help() k té konkrétní funkci?

#5 Standa
No, zatím se nauc používat funkce a zkrat ten výsledný kód, ať se ti neopakuji dokola stale stejne radky. S tím co jsem ti napsal, bys mel kod zredukovat cca o 90%, pokud jsem se dobre dival :)

#1 PiranhaGreg
Php přirozeně ne.

Na takové věci se běžně používá python, což je pro tebe asi nejlepší volba.

Další možnosti ani nemá cenu zmiňovat, přece jen jsou zatím dost exotické jako R nebo F#.

#3 Standa
Hezky, prostor pro přepsání tam určitě je :) Objektově to ani psát nemusíš, stačí když se naučíš funkce. Jít do objektů, když tam nemáš ani funkce je trochu moc hrrr :)

Například toto se ti opakuje pořád dokola:

gr98 = "C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\98_gr_mod.las"   # nastaveni cesty zdrojovych dat
gr99 = "C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\99_gr_mod.las"
gr100 = "C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\100_gr_mod.las"
gr101 = "C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\101_gr_mod.las"
 

A přitom je to stále totéž:

def vytvor_cesty(adresar, soubory):
    return [adresar+soubor for soubor in soubory]

soubory = "98_gr_mod.las", "99_gr_mod.las", "100_gr_mod.las", "101_gr_mod.las"
adresar = "C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\"
print(vytvor_cesty(adresar, soubory))

#vytvori list, který můžeš použít do funkce
['C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\98_gr_mod.las',
 'C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\99_gr_mod.las',
 'C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\100_gr_mod.las',
 'C:\\Data LLS pro IGA\\data_IGA_klasif\\ground_default_classified\\101_gr_mod.las']

#1 PetrS
http://stackoverflow.com/questions/12723818/print-to-standard-printer-from-python

#3 VitPet
A opravdu ti to funguje? while 1 dvakrát za sebou?

Mimochodem, gtk nepotřebuješ...

http://stackoverflow.com/questions/3129322/how-do-i-get-monitor-resolution-in-python

#3 Patrik
A jsi si jistý, že používáš python3. Pokud jsi v linuxu, tak když napíšeš python, dostaneš se většinou do pythonu 2.

Ve většině distribucí bys měl myslím napsat python3.

#18 Priwi
Ahoj,

jen bych ti chtěl doporučit dvě věci:

1/  Používej python 3.4,,  pokud nemusíš jinak

2/ Pokud umíš anglicky, podívej se na checkio.org

#14 Priwi
Sice nevím, proč používáš dvojkový python, ale kolega nahoře má pravdu. Ve dvojkové řadě vytváří range list, to jest zabírá paměť; ve trojkové je range totéž co dříve xrange. V tomhle případě můžeš zkusit použít while

i, end = 10**8, 10**9

while i < end:

    soubor.write(i)

    i += 1

#11 peter
I když se bojím, že ten článek nepochopíš, proč na něj sem nedát odkaz.

http://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/

Srovnávat php s pythonem, toť odvaha.I když v tomhle případě spíš obrovská neznalost.

Za nulte, range je funkce, která (zjednodušeně) vrací posloupnost čísel. Např.

for i in range(0,10.2):

    print(i)

Za prve, nevím.

Za druhé, viz za nulté). print odsazuje jeden řádek automaticky. Jinak help(print), argumenty sep a end by ti mohly pomoci.

Za třetí, chceš říct, že potřebuješ řetězec, protože python nebude psát 001 místo 1.

Tady tohle dělá, co asi potřebuješ.

for i in range(10**9):

   print("{0:0>8}".format(i))

#7 Priwi
Omlouvam se, ale to nebylo pro tebe :)

Stejne to tak nedelej, udelej si normalni funkci, lambdy nepouzivej.

Abych neprozrazoval všechno, stačí ti jen dva funkce str a len.

Napovím ti, ze je jednodussí zjistit pocet znaku v retezci - na to, co potřebujes.

Analýza dat a vědecké výpočty:

http://it-ebooks.info/book/1041/

scipy.org, numpy.org, http://ipython.org/

Dotykové aplikace

kivy.org

3d Grafika

blender.org

http://www.freecadweb.org/

http://www.makehuman.org/

Algoritmy:

checkio.org

Stačí si vybrat :)

#6 sliziky
Nebo použij format, to je srozumitelnější a modernější a dělá to totéž co %. % je ale stručnější.

"Obvod je {}.".format(obvod)

#1 Libor
Když je "totálně jednoduchý", tak proč si s ním nevíš rady?

Zkus zapojit mozek, tady máš částečné řešení:

 

def sifruj(klic, text):
    return "".join(chr(c if (96 < c < 123) else
                       (c%122+96) if c > 122 else c+26) for c in
                        map(lambda x: x+klic, text.encode()))

test = "abcxyz"
print(sifruj(2,test))
print(sifruj(-2, test))

#pro příliš malá nebo velká čísla je potřeba funkci doladit
print(sifruj(-102, test))
print(sifruj(500, test))

#1 Kuba
Tohle by ti mělo stačit, abys pochopil princip. Ta druha funkce bude podobná, ale to už snad zvladneš.

KLAVESY = (
            ("a","b","c"),
            ("e", "f", "g"),
            ("h", "i","j", "k")
            )

def preved(text):
    prevod = list()
    for pismeno in text:
        for i, klavesa in enumerate(KLAVESY):
            if pismeno in klavesa:
                prevod.append((klavesa.index(pismeno)+1) * str(i+1))
                break
        else:
            prevod.append("?")
    return " ".join(prevod)

print(preved("afjxa"))
# Vypise "1 22 333 ? 1"

#10 sliziky
Ano, přesně tak. Můžeš použít ten prográmek, aby ses podíval. Ovšem, aby se ti to projevilo, musel bys použít podstatě vyšší stupen prvků, abys videl

V podstate bys mel dostat neco jako O(n*log(n) + 2*n) => O(n*log(n)), bere se v potaz jen ten nejvyšší stupen bez případných koeficientů.

#8 sliziky
To také není nic jednoduchého, pokud nejde vyslovené o jednoznačné případy.

U většiny algoritmů budeš rád, když stanovíš nejhorší možný případ, přičemž někdy se ti to nemusí podařit: (viz Časová složitost a třídy P a NP na wikipedii)

Proto jsem ti úmyslně odpovídal pouze na tvůj dotaz, jaký je rozdíl mezi vnořenou smyčkou a smyčkami za sebou.

Když se podíváš na wikipedii:

http://cs.wikipedia.org/wiki/Asymptotick%C3%A1_slo%C5%BEitost

Najdeš tam toto:

Například časová složitost [O(N)] (tzv. lineární) říká, že doba trvání práce algoritmu se zvýší přibližně tolikrát, kolikrát se zvýší velikost vstupu. Na druhou stranu u složitosti [O(N^2)] se doba trvání průběhu zvyšuje kvadraticky, tedy pokud se zvýší délka vstupu dvakrát, potřebný čas se zvýší čtyřikrát. U časové složitosti [O(1)] naopak na délce vstupu vůbec nezáleží a potřebný čas je stále stejný. Podobně je tomu i u prostorové složitosti, jen s tou změnou, že se jedná o potřebné paměťové (prostorové) nároky v závislosti na délce vstupních dat.

Což jsem ti ukázal pomocí jednoduchého prográmku.

Co ti tedy není jasné?

#6 sliziky
Není zač, pokud se chceš podívat, jaký je rozdíl ve škálování, můžeš si zkusit tenhle jednoduchy program pro python 3.x. Na nem krásně uvidíš rozdíl mezi x*n a n**2.

from turtle import Turtle
def jedna_smycka(n):
    return sum(1 for i in range(n))

def x_smycek(n,x):
    return x * jedna_smycka(n)

def vnorena_smycka(n):
    return n * jedna_smycka(n)


x = 10 # pocet smycek za sebou
prvky = 100  # pocet prvků, jak program škáluje s počtem prvků 
t = Turtle()
vyska = vnorena_smycka(prvky) + 10
t.screen.setworldcoordinates(0,0, prvky+20,
                             vyska)
t.up()
t.goto(0,vyska*0.9)
t.down()
t.write("Počet prvků: {}:".format(prvky))
t.hideturtle()

jedna = Turtle()
jedna.pencolor("red")
x_smycka = Turtle()
x_smycka.pencolor("blue")
kvadraticka = Turtle()
kvadraticka.pencolor("green")

for i in range(prvky):
    jedna.goto(i, jedna_smycka(i))
    x_smycka.goto(i, x_smycek(i,x))
    kvadraticka.goto(i, vnorena_smycka(i))

jedna.write("O(n) Jedna smyčka.")
x_smycka.write("O(n) Počet smyček: {}.".format(x))
kvadraticka.write("O(n**2) Kvadratická.")

Připojen obrázek.

#1 sliziky
Dvě smyčky za sebou jsou O(n), přesněji řečeno

jedna smyčka O(n)

dvě stejné smyčky za sebou O(2n) => O(n)

Jednoduše, je to stále lineární.

#7 Rasty
Pokud máte chuť, existuje několik výborných knih přeložených do češtiny:

http://knihy.nic.cz/files/nic/edice/mark_pilgrim_dip3_ver3.pdf

#4 Rasty

Prostě zkuste toto, tohle je přímo z dokumentace k pythonu 3.4.

import tkinter as tk

class Application(tk.Frame):
    def __init__(self, master=None):
        tk.Frame.__init__(self, master)
        self.pack()
        self.createWidgets()

    def createWidgets(self):
        self.hi_there = tk.Button(self)
        self.hi_there["text"] = "Hello World\n(click me)"
        self.hi_there["command"] = self.say_hi
        self.hi_there.pack(side="top")

        self.QUIT = tk.Button(self, text="QUIT", fg="red",
                                            command=root.destroy)
        self.QUIT.pack(side="bottom")

    def say_hi(self):
        print("hi there, everyone!")

root = tk.Tk()
app = Application(master=root)
app.mainloop()

Python je universální programovací jazyk, vhodný prakticky na cokoliv.

Takže ano, okenní aplikace v něm můžeš dělat bez problémů.

Například tady:

http://programujte.com/clanek/2007112801-preklad-dokumentace-tkinteru/

Tkinter je součástí oficiální distribuce, stačí import tkinter a mrknout do dokumentace. Ale jsou i jiné frameworky, takže se nemusíš bát. Možná nejjednodušší je IronPython s návrhářem v SharpDevelopu.

Pokud jde o distribuci:

http://www.py.cz/DistribuceProgramu

Pěkná ukázka je třeba MakeHuman:

http://www.makehuman.org/

Jde o 3d aplikaci naprogramovanou v pythonu :)

#8 rimeska
Vždycky se můžeš utěšovat tím, že váš učitel jako pedagog naprosto selhal ... tak naprostý nezájem o věc musí být na mašli. Ale ta úloha je pěkně vymyšlená.

#9 lukas.balaz
Nu, tak jsem to zrovna nemyslel. Checkio ti pomůže stát se lepším programátorem v jakémkoli jazyce, Nicméně abys mohl začít potřebuješ python a angličtinu.

Ber to jako výzvu. Vzdát  to můžeš vždycky :)

Tady si můžeš udělat obrázek oč jde.

http://www.checkio.org/mission/open-labyrinth/

#5 rimeska
Není zač, stejně to nebude stačit :)

Musíš ještě načíst data ze souboru, prohnat je tou funkcí a zase do souboru zapsat.

Mimochodem, co budeš říkat, až se tě ten učitel zeptá, jak ta tvoje funkce funguje?

#2 lukas.balaz
Pokud neděláš s pythonem, co takhle začít?

Zkus checkio.org, pokud se o svátcích nudíš :)

#3 rimeska
Tohle by ti mohlo stačit. Teď by ses měla zeptat, v čem je to kouzlo, abys neumřela ehm... vždyť víš :)

from random import shuffle

def zadej_slovo(slovo:str):
    if len(slovo) > 3:
        prvni, *prostredek, posledni = slovo
        shuffle(prostredek)
        return prvni + "".join(prostredek) + posledni
    else:
        return slovo

print(zadej_slovo("pokusny"))
# >>> psunoky

#1 John
POkud ti nevadí angličtina, pak zkus:

http://it-ebooks.info/book/3526/

Přinejmenším začátek ti hodně napoví.

Základní testování vypadá asi takto:

def secti(x,y):
    return x + y


if __name__ == "__main__":
    assert secti(5,6) == 11, "kladná čísla"
    assert secti(-5,-6) == -11, "záporná čísla"
    assert secti(complex(1,1), complex(1,1)) == complex(2,2), "komplexní"

Když spustíš tenhle modul, tj. bude hlavní "__main__", pak každý assert zkontroluje, zda se návratová hodnota funkce rovná předpokládané. Pokud ne, vyhodí ti výjimku.

V tomhle případě je to samozřejmě zbytečné, ale u složitějších funkcí oceníš, že pokud změníš kód, probehne ti vždy kontrola správnosti. POkud funkce vrací něco, co nemá, testování tě hned upozorní.

No snad jsem to podal dost jasně :)

#1 Skywalker00

from random import randrange

...
ctverec[i].append(randrange(1,10))  # rozsah záleží na tobě, v tomhle případě to bude 1 až 9

http://it-ebooks.info/book/3515/

#4 Lukáš
Nemusíš jít ani do miliónů, stačí se nedopočítat do 10 :)

>>> 0.1*10 == sum(0.1 for i in range(10))
False

Prijde mi, že se tak trochu opakuju, ale v tomhle případě je odpověď jasná :)

Přihlas se na:  checkio.org

Takhle vypadají tamější úkoly:

http://www.checkio.org/mission/open-labyrinth/

Já jen podotknu, že i c# je v dnešní době multiplatformní :)

http://xamarin.com/

Co toto?

https://pythonhosted.org/openpyxl/

#8 site
V tom případě začínáš od konce. V pythonu tohle naprogramovat sice lze, ale bude tě to stát moc práce. Stáhni si SharpDevelop a naklikej si okenní aplikaci, jakou chceš. Pak už bude jen na tobě, jestli to bude v IronPythonu, C# , Boo nebo VB.net.

Stejně bych ti doporučoval c#. Python sice je vhodný pro začátečníky, ale ne v tom smyslu, jak si to představuješ ty :)

Navíc výsledek nemusíš instalovat. Pokud bude na počítači správná verze .net frameworku, bude ti stačit vytvořit přenosný exe soubor.

#38 VitPet
A je to opravdu ten samý soubor? Nepleteš si cesty? Nemáš třeba dva stejně pojmenované soubory na různých cestách? Správně bys měl udělat toto. Nastavit si proměnnou třeba:

cesta =  "/home/lenka/documents/Alchimist_lab/gamesave.txt"

A tu pak k otevírání toho samého souboru. Takhle nemůžeš vědět, jestli tam nemáš někde chybu.
 

Mimochodem, ty globální proměnné bys opravdu neměl používat :)

#1 Webstrider

Ahoj,

sotva můžeš očekávat významnější zrychlení od multiprocessingu. Opravte mne, pokud se mýlím, ale jestli máš 0,2 fps, pak rovnoměrným rozdělením (v ideálním případě) mezi dvě jádra, získáš maximálně 0,4 fps, což zdaleka není to, co bys potřeboval :)

Takže by ses měl zaměřit na hledání úzkých hrdel svého programu. Ty pak můžeš řešit pomocí vhodnějšího algoritmu, nebo knihovnou v céčku anebo na internetových fórech.  Docela jistě ale nemůžeš čekat, že se někdo bude prodírat tvým kódem ve volném čase :)

Takže sem hoď třeba jen tu pasáž, kterou bys chtěl zrychlit. V tom ti někdo snad pomůže.

#18 KIIV

Vy jste zřejmě ukázkový případ člověka, o kterém Guido mluví zde:

Guido o trolech

Přiznám se, že jsem mu to měl za zlé, ale teď už ho docela chápu :)

Kromě toho, že váš příspěvek toto vlákno nijak neobohatil, si pletete pojmy s dojmy:

Modul threading je určený pro současné vykonávání částí programu.

zatímco modul multiprocessing je určený pro využití  vícenásobných procesorů, což je to, oč vám asi jde.

CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing or concurrent.futures.ProcessPoolExecutor. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.

#10 ČeV

že případný test na interval hodnot by asi pomocí setu nešel,

Nu zdá se, že musím poděkovat za zajímavý nápad. Tohle by mne nikdy nenapadlo nebýt vaší poznámky. Takže si můžete připsat body za autorství. Doufám, že kód je jasný, případně se ptejte :). Sám se ale přiznám, že jsem nečekal, že to takto bude fungovat :)

V každém případě můžete pomocí této konstrukce zjišťovat přesně to, co asi chcete.

>>> testy = [(1),           # jedna hodnota
             (1,3),         # více hodnot
              range(6,10)]  # interval 6 až 9
>>> for test in testy:
	print(7 in test)

	
False
False
True
>>> 

#5 ČeV
Nu, jde o několik mírně pokročilých témat. Nevím, jestli to bude dost jasné. Když tak se ptejte :)

V každém případě to není právě ideální případ, je to spíš java nebo c# :) Ale odděluje zpracování množiny účtu od jejich samotných hodnot.

EDIT: I když o tom tak přemýšlím, začínám mít dojem, že oddělení logiky od dat se děje u pythonu automaticky. Možná že hledáte něco, co se od dob Cobolu dramaticky změnilo v samotném návrhu jazyka :)

# Obecná třída účet, i když nemusí jít o třídu, ale třeba o cokoliv
class Ucet():
    pass


# funkce pro zpracování množiny účtů
def zpracuj_ucet(ucty):
    # Ve smyčce zpracuji všechny účty
    for ucet in ucty:
        ...

        
# Vytvořím instanci třídy účtu
ucet1 = Ucet()

# Vytvořím množinu účtů s jedním účtem
mnozina_uctu = [ucet1]

# zpracuj nějak ucty
zpracuj_ucet(mnozina_uctu)

# Přidám další účet
ucet2 = Ucet()
mnozina_uctu.append(ucet2)

# opět zpracuju všechny účty
zpracuj_ucet(mnozina_uctu)
    

V pohodě, doufám, že jsi už na to přišel :)

No, nevím, jestli si ze mne neděláš srandu, ale dobrá.

1/ Set breakpoint - program doběhne až do stanoveného místa, odkud ho můžeš pomocí step krokovat nebo dál pomocí go nechat dál běžet

2/ Go - program běží do dalšího breakpointu nebo do konce

3/ Step - provede každý jeden řádek, včetně volání modulů, atd

4/ Over - přeskočí volání funkce

5/ Out  - vyskočí z iterace, např. cyklu for

6/ Quit - ukončí debugger

Locals - aktuální stav lokálních proměnných

Globals - aktuální stav globálních proměnných

Stack - ukazuje, na kterém řádku právě jsi

Source - vyznačí v editoru prováděný řádek.

Nejlepší je mít debug a editor vedle sebe na monitoru. Stav proměnných se průběžně mění. Ideální je si nastavit breakpoint někde před místem, které chceš zkoumat a pak si ho odkrokovat.

Od toho tam jsou volby OVER a OUT . A v editoru Set breakpoint

https://www.youtube.com/watch?v=kpyDMK9ZeV4

Udělej to obráceně. Napřed zaškrtni v shell volbu debug a teprve potom spusť F5 svůj program.

#1 ČeV
Zdravím,

chtělo by to příklad. Nejsem si jistý, co myslíte.

Možná by pomohlo toto:

if x in (1,2,3,4):

    x += 1 #třeba

nebo zkrácený zápis:

x if x in (1,2,3,4) else 0

Popřípadě můžete použít typ set, což je přímo množina prvků.

Ahoj všichni,

omlouvám se, pokud budu nosit dříví do lesa, ale rád bych upozornil všechny, kteří se zajímají o python, že existují stránky checkio.org.

Stručně řečeno, jde o hru o programátory, nebo ještě lépe o soubor různorodých úloh, které se řeší pomocí jazyka python. Samotné úlohy jsou přitom postavené tak, že jejich řešení je poučné i pro ty, kteří python nemají v plánu používat, protože většinou vycházejí ze základů programování, které jsou společné pro všechny jazyky.

Pro úspěšný postup ve hře je nutná základní znalost angličtiny a pythonu,

Taková perlička na závěr, dramatický trailer :)

A co tak si vytisknout tuto:

http://knihy.nic.cz/files/nic/edice/mark_pilgrim_dip3_ver3.pdf

Když se ti bude líbit, myslím si ji můžeš i koupit tištěnou.

nebo tuto:

http://howto.py.cz/

Můžeš si to vyzkoušet tady:

https://pythex.org/?regex=%28\d\d%3A\d\d%3A\d\d%29&test_string=tdklk%20af%20sfa%20adfadfas%20asdfaf%2012%3A32%3A34%20sdfadj&ignorecase=0&multiline=0&dotall=0&verbose=0

1/ POkud používáš Idle, pak v Shellu zaškrtní debugger.

2/ Zaškrtni všechna čtyři políčka v Debug control a  pak spusť svůj kód.

3/ A pak mačkej Step v Debug Control a snaž se pochopit, co se děje.

Hodně štěstí

#3 VitPet
Prosím, použij debugger, ať víš, jak se ti to chová a kde je zakopaný pes. Pak napiš, na kterém řádku se chová program jinak, než jsi předpokládal..

#1 Petr Ká
Linky si přepni pro svou verzi pythonu

Ve skutečnosti myslím, že nehledáš modul threading ale balík multiprocessing:

https://docs.python.org/2/library/multiprocessing.html#module-multiprocessing

anžto:

multiprocessing is a package that supports spawning processes using an API similar to the threading module. The multiprocessing package offers both local and remote concurrency, effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.

Modul threading ti ve skutečnosti, alespoň v cpythonu nepomůže s tvým problémem, jelikož:

CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.