laikmatis pythone

print "File: %s, Size: %s bytes, Device address: %s, Device Port: %d" %(sourcefile, size, address, serviceport)
    print "Waiting on user to accept the file..."
    try:                    
        client = lightblue.obex.OBEXClient(address, serviceport)
        client.connect()
        client.put({"name": sourcefile}, file (sourcefile, "r"))
        client.disconnect()
        blacklist = 'false'
        print "Done!"

    except lightblue._obexcommon.OBEXError, error:

        print "User don't want to accept the file, user added to blacklist."
        blacklist = 'true'

va kodas su siunciant per lightblue. patenka i try bloka ir prisijungus prie irenginio (turbut po komandos connect) telefone issoka pranesimas ar keistis duomenimis? galima spaust yes, no arba nieko nedaryt. nedarant nieko po 30 sek suveikia timeoutas ir patenkama i except bloka. cia kode pas mane jokie timeout nenusistato, mastau kad cia naudoja kazkokia default reiksme, ja reiktu man pakeist is 30 sek i 10 arba net 5.

tai ar kas nors turetu minciu del to? as galvoju gal reik megint konfiguruoti pati bluetooth adapteri per hci komandas, bet kiek bandziau tai timeout reiksmes ten neiseina keisti. galbut variantas butu keisti sistemos tcp timeout?

Pan, tai taip ir nepavyko paleisti to kodo. Bandžiau rankomis įsidiegti tą obex, bet kažkaip jis skiriasi nuo to, kuri pas tave naudojamas, nes nėra pusės metodų.

kad veiktu tas kodas kuri parasiau reikia isidiegti lightblue biblioteka. ja per apt-get galima rasti ir tada kodas veiktu teisingai nurodzius irenginio adresa, porta ir siunciama faila. galiu pateikti pilnesni kodo varianta jeigu reik.

turiu dar klausimeli biski ir is kitos operos. kai kuriose programos vietose as formuoju toki address lista, t.y. sarasa irenginiu kuriem siunciamas failas. ji galima suprast kaip masyva. taigi noreciau suzinot tokius aspektus susijusius su masyvais: kaip jau i esanti, suformuota masyva iterpti viena nauja irasa kuris butu pats pirmas masyvo elementas? ta prasme kad visi senieji masyvo elementai pasistumtu per viena pozicija uz naujai iterpto iraso. dar vienas klausimas kaip is turimo address listo suformuoti du atskirus masyvus pakaitomis i juos surasant elementus. rezultate noriu kad butu pirmajame masyve 1, 3, 5 elementai, kitam masyve 2, 4 ir t.t. zinau kad tai paprasta padaryt, bet gal pythonas suteikia galimybe tai rasyti nesukant ciklo ir nepriskirinejant atskirai kiekvieno elemento.

Aciu

Dėl bluetooth padėti niekuo negaliu, bandžiau įsidiegti lightblue, bet kaip ir sakiau, gavau kažką ne tą, toliau ir nesiaiškinau. Su bluetooth neteko dirbti.

Dėl masyvų, Python šioje vietoje turi ypač daug priemonių!

Dėl elemento įterpimo į pradžią:
Pirmas variantas:

>>> lst = ['a', 'b', 'c']
>>> lst.insert(0, 'x')
>>> lst
['x', 'a', 'b', 'c']

Antras variantas, veikiantis greičiau su tam skirta biblioteka:

>>> from collections import deque
>>> queue = deque(['a', 'b', 'c'])
>>> queue.appendleft('x')
>>> queue
deque(['x', 'a', 'b', 'c'])

Jei elementus į sąrašo pradžią įterpinėsi gan dažnai, tada siūlyčiau naudoti deque dėl greitesnio veikimo.

Dėl masyvo dalinimo, galima naudoti List Comprehensions:

>>> lst = [1, 2, 3, 4, 5]
>>> [lst[i] for i in range(0, len(lst), 2)]
[1, 3, 5]
>>> [lst[i] for i in range(1, len(lst), 2)]
[2, 4]

Bet pagal aukščiau pateiktą pavyzdį, ciklas bus prasukamas du kartus. Todėl efektyviau būtų naudoti vieną paprastą ciklą:

>>> a, b = [], []
... for i, v in enumerate(lst):
...     if i % 2:
...         b.append(v)
...     else:
...         a.append(v)
... a, b
([1, 3, 5], [2, 4])

na is principo kai is vieno masyvo reik padaryti du tai nera sunku, vienam lyginiai, kitam nelyginiai. o ka daryt kai reikia masyva padalinti i 7 dalis? tarkim turiu koda kuris adresu masyva dalina i dvi dalis ir perduoda tam tikra adresa i tam tikra kodo vieta. stai kaip tai realizuota:

fff = open ('devices.txt','r')

    i = 0
    address = "xx"
    while len(address) > 0:
        address = fff.readline().rstrip("\n")

        i = i + 1
        lyginis = 1
        if i % 2 > 0:
            lyginis = 0
        if devid == "0":
            if lyginis == 0:
                lightblue.obex.sendfile(address, 9, path+"/"+sourcefile)    

        elif devid == "1":
            if lyginis == 1:    
                lightblue.obex.sendfile(address, 9, path+"/"+sourcefile)    

        else:
            sys.exit(1)


    fff.close

as savo atveju noriu padaryt kad butu daroma tas pats, tik dalinama ne i 2, o i 7 dalis ir butu 7 skirtingos salygos

if devid == "0"
if devid == "1"
if devid == "2"

ir t.t. taip pat mano atveju adresai yra ne tekstiniame faile o duombazej, bet esme kad nesumastau kaip teisingai suskirstyti i 7 dalis, nes velgi reikia kad pvz turint masyve 15 adresu, pirmas, astuntas ir penkioliktas patektu ten kur if devid == "0", antras ir devintas ten kur if devid == "1" ir t.t. is anskto aciu.

norejau pasiklausti kaip pythone skaicius apvalinti i didesne puse? t.y man jei gavau kad ir 0.1 reikia kad suapvalintu iki 1.

bandau daryti su round, bet jis matau atvalina pagal tradicines matematikos taisykles:

>>> a=float(d)/float(n)
>>> a
1.2
>>> round(a)
1.0

siuo atveju man reiketu kad butu grazinama a reiksme 2. aciu

>>> import math
>>> math.ceil(1.2)
2.0

dar norejau paklaust kaip pythone padaryt kad neisvedinetu i terminala kiek procesu programoje yra paleista?

tarkim issikvieciu du:
cmd0 = "./btcastpushd2.py 0 %s &" % path
cmd1 = "./btcastpushd2.py 1 %s &" % path

os.system(cmd0)
os.system(cmd1)

ir tokiu kodu tikrinu kada jie bus baigti kad galeciau testi toliau:
check = "%s" % os.system("pstree | grep btcast")
while check == "0":
time.sleep (1)
check = "%s" % os.system("pstree | grep btcast")

ir cia man kas sekunde i terminala veda: |-2*[btcastpushd2.py] jei du procesai dar eina ir |-btcastpushd2.py jei likes neuzbaigtas vienas. Kaip padaryt kad tokiu pranesimu terminale neisvedinetu, o tiesiog lauktu ir tiek?

O kodėl gi šioje vietoje nepanaudojus threading modulio?

Štai perrašytas pavyzdys su threading ir queue:

from Queue import Queue
from threading import Thread

class MyThread(Thread):
    def __init__(self, queue):
        Thread.__init__(self)
        self.queue = queue

    def run(self):
        while True:
            params = self.queue.get()
            btcastpushd2(*params)
            self.queue.task_done()

queue = Queue()
for i in range(2):
    t = MyThread(queue)
    t.setDaemon(True)
    t.start()

path = ''
queue.put((0, path))
queue.put((1, path))
queue.join()
print 'done'

Čia sukuriami du demoniški threadai, kurie tiesiog kybo ir laukia, kol queue eilė bus papildyta naujais elementais. Kai tik eilė papildoma, tai kuo ji buvo papildyta įvykdoma.

Manau, čia kaip tik tai, ko tau reikia.

o kaip realizuoti toki atveji: turiu programa kurioje aprasytas grafines sasajos glade failas, aprasyti visi laukai, mygtukai ir pan. paleidus si faila galima sakyt pasileidzia grafine sasaja. taciau kai paspaudi start as noriu iskviest nauja procesa kuris galetu isvedinet duomenis i grafines sasajos laukus.

Kaip realizuoti kad dvi programos galetu naudotis ta pacia grafine sasaja? jei viskas realizuota naudojant self'us, tai ar neuztektu tai kitai programai perduoti tik self parametra, kad ji galetu naudotis textview laukais ir pan?

nesuderinamumo siuo atveju nebutu, nes viena programa naudotusi vienais langais grafineje sasajoje, kita programa - kitais. tik man idomu kokius parametrus reik perduoti, ar tik self, ar pilna lauko aprasyma?

Sveiki, turiu viena klausima i kuri galetu atsakyti daugiau paciam linuxe nei pythone besigaudantys zmones. As savo programose matavau ivairiu funkciju atlikimo laika pagal linux sisteminiu laiku skirtuma. tai atrodo mazdaug taip:

>>> import time
>>> from datetime import datetime
>>> t1 = datetime.now()
>>> time.sleep(5)
>>> t2 = datetime.now()
>>> delta = t2 - t1
>>> print(delta)
0:00:22.073000

Na kaip matome gaunu kazkoki rezultata. Mano rezultatas yra skaicius 22.073000. tai reiskia 22 sekundes ir kazkiek daliu. Mano klausimas butu toks: ar linuxe sisteminiu laiku skirtumas pateikiamas tikrai mikrosekundziu tikslumu (nes cia matau po kablelio 6 skaicius), ar linux tiesiog pateikia sekundes, o po kablelio priraso velniai zino ka? ir jei linux is tikriju geba pateikti sisteminiu laiku skirtuma iki mikrosekundziu, tai is kur zinoti kad tikrai taip ir yra, ta prasme kaip tai irodyti?

Atsimenu anksčiau, su senais kompiuteriais, jei nori sustabdyti programos vykdymą tam tikram laikui, tai laikmatis naudodavo CPU taktinį dažnį, todėl ant skirtingo pajėgumo procesoriaus skyrėsi ir programos vykdymo greitis.

Manau šiais laikais naudojamos kur kas pažangesnės priemonės geležies lygmenyje, be to šiuolaikiniai procesoriai tokie greiti, kad greičiausiai tais mikro sekundžių skaičiais galima patikėti.

Paprasčiausias pavyzdys yra 1GHz CPU, tai reiškia, kad jis gali atlikti 1 000 000 operacijų per sekundę, o tai reiškia, kad su tokiu procesoriumi be problemų galima skaičiuoti vienos mikro sekundės tikslumu. O pasitelkus visokias technines priemones įmontuotas į kompiuterį, manau taip tiksliai skaičiuoti tikrai įmanoma.

Tema perkelta iš https://legacy.ubuntu.lt/forum/viewtopic.php?f=11&t=5403