- Fotók, videók mobillal
- Három célcsoportra fókuszál az Edge 50 széria
- Poco F5 - pokolian jó ajánlat
- Samsung Galaxy S21 és S21+ - húszra akartak lapot húzni
- iPhone topik
- Apple iPhone 15 Pro Max - Attack on Titan
- Biztosan lesz itthon Google Pixel 9, azt is tudjuk, hogy hol lehet majd megvenni
- Milyen okostelefont vegyek?
- Samsung Galaxy S21 FE 5G - utóirat
- Samsung Galaxy S9 és S9+ duplateszt
Hirdetés
-
Biztosan lesz itthon Google Pixel 9, azt is tudjuk, hogy hol lehet majd megvenni
ma Az áprilisi tréfák ideje lejárt, ahogy az innen-onnan beszerezhető Pixeleké is. Ősztől indul a hivatalos magyarországi forgalmazása a Google telefonjának.
-
Speciális Gauid 3-akat kap Kína
ph A korlátozott fogyasztású modellek elvileg exportálhatók lesznek a keleti országba.
-
AMD Radeon undervolt/overclock
lo Minden egy hideg, téli estén kezdődött, mikor rájöttem, hogy már kicsit kevés az RTX2060...
Új hozzászólás Aktív témák
-
cousin333
addikt
Remek, hogy megnyílt ez a topik, már én is gondolkoztam azon, hogy kellene egy. Viszont most éppen se kérdésem, se kérdés...
Kissé mondjuk meglep, hogy ilyen gyér itt a forgalom. Ami a Python nyelvet illeti, mindenkinek csak ajánlani tudom. Nyilván nem való mindenre, de sok mindent képes egyszerűen, hatékonyan és logikusan megoldani. Ami "érdekessége", hogy használható szkript módban is, tehát egy sor, egy parancs, ami azonnal végre is hajtódik (kivéve persze az if, for, while és egyéb nyalánkságokat), vagy éppen írhatunk egy komplett programot sima Wordpad-ben is.
Amire felhívnám a figyelmet! A 2.5.2-es verzió szép és jó, kellően kiforrott. De 1-2 hónapon belül elkészül a 3-as változat (más néven Python 3000), ami visszafelé nem kompatibilis módon jópár dolgot megváltoztat. Szóval aki most kezdené el tanulni, az szerintem inkább az utóbbival tegye, hogy szokja... Pillanatnyilag a beta 3 érhető el Linux, és a beta 2 Windows alá. Néhány változás a 2.5.2-höz képest: [link]
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
No, akkor elindítanám a felemelkedés útján ezt rendkívül aktív topikot...
Tehát a kérdésem:Van egy listám, mondjuk:
gyumolcs = ['alma', 'körte', 'banán', 'szilva', 'barack']
Ezen mennék végig egy for ciklussal:
for elem in gyumolcs:
print elemNamost, hogyan lehetne (menet közben) megmondani, hogy éppen hanyadik elemnél járok a listában? Az, hogy felveszek mondjuk egy count változót, amit folyamatosan inkrementálgatok, az triviális. Még esetleg az is belefér, ha az index() - gyumolcs.index('banán') - metódussal lekérem a sorszámot, de ezzel baj van, ha több 'banán' is szerepel a listában... Nincs erre valamilyen célszerűbb, egyszerűbb módszer? Lehetne persze így is:
for i in range(len(gyumolcs)):
print gyumolcs[i]Ebben az esetben az i lesz a sorszám, de ez a megoldás jóval kevésbé elegáns, nem vall a Pythonra.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
No, a megoldás úgy tűnik az enumerate() függvény használata, ami tuple-ket ad vissza. Tehát pl. két mód a használatára (az előbbi példánál maradva):
1.
for i,elem in enumerate(gyumolcs):
print elem # ez lesz a gyümölcsnév
print i # ez lesz az aktuális sorszám2.
for elem in enumerate(gyumolcs):
print elem[1] # ez lesz a gyümölcsnév
print elem[0] # ez lesz az aktuális sorszám[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
-
#15
cousin333
addikt
nickwearby
#13
cousin333
addikt
válasz
nickwearby
#13
üzenetére
esetleg:
python fájlneve
python.exe elérési úttal fájlneveVagy használd az IDLE-t, és onnan nyisd meg a py fájlt, majd F5.
"We spared no expense"
-
cousin333
addikt
Na, akkor kissé pörgessük meg a topikok...
Szóval, lenne egy feladatom. Adott egy szöveges fájl az alábbi felépítéssel:
a b c d
1 2 3 4
5 6 7 8
9 8 7 6
5 4 3 2Tehát van egy x hosszúságú fejléc, és alatta soronként azonos számú szám. A fejléc az első sor, a számsorokból száma tízezres nagyságrendű (egy sorban kb. 10 elem található, de ez az érték - elvileg - minden sornál fix). A sorok elemei között tabulátor karakter található.
A feladat egy olyan csv fájl létrehozása lenne, ami az említett fejléccel kezdődik, megadott számú sort átlagol és kiírja az eredményt az új fájl egyetlen sorába. Tehát, a fenti példánál maradva a kiírt fájl ez lenne (ha a megadott sorszám mondjuk 2):
a b c d
3 4 5 6
7 6 5 4Mert a 3 az az eredeti fájl első két sora első elemeinek az átlaga: (1+5)/2, a 4 az a másodiké: (2+6)/2 és így tovább, remélem érthető. Ha a számsorok száma nem egésszámú többszöröse az átlagolás számának, akkor a kimaradó elemek nyugodtan elhagyhatóak. A programnak nem kell hülyebiztosnak lennie, tehát nem kellenek bele mindenféle extra ellenőrzések, kivételkezelések, meg ilyesmik.
A programnak a feldolgozandó fájl nevét, és az osztások számát (hogy hány soronként átlagoljon) kellene bekérnie a futás során. A kimeneti fájl neve nyugodtan lehet a bemeneti fájl módosított verziója.
A cél az lenne, hogy egy minél egyszerűbb, minél hatékonyabb és minél "Pythonosabb" kód szülessen.
+1 feladat: Képes legyen felismerni, ha egy számsor esetleg a kelleténél kevesebb elemből áll, és kijelezze a sor számát, ahol ez először előfordul.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
cousin333
#18
üzenetére
Ennyire ne tépjétek magatokat...
Amúgy alant látható a saját megoldásom, hátha az meghozza a vitakedvet...
fileName, cnt = input('Fajl neve? '), int(input('Oszto? '))
with open('d:\\' + fileName + '.txt', 'r') as iF:
allData = [line.strip('\n').split('\t')[1:] for line in iF]
header, datas = allData[0], [[float(x) for x in elem] for elem in allData[1:]]
with open('d:\\' + fileName + '_avg.csv', 'w') as oF:
oF.write(';'.join(header)+'\n')
for x in range(len(datas)//cnt):
s = datas[x*cnt:(x+1)*cnt]
oF.write(';'.join([str(round(sum([elem[i] for elem in s])/len(s))) for i in range(len(header))])+'\n')[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
zotya7895
#21
üzenetére
Üdv!
Elég nagy a pangás ebben a fórumban, szóval nézd el nekem , hogy csak most válaszolok. Szóval előbb a hivatalos oldalról le kell tölteni a legfrissebb verziót (ami jelenleg a 3.0.1-es). Ezt feltelepíted, és elindítod az IDLE nevű környezetet. Innentől kezdve már írogathatod is a programokat. A mikéntről olvashatsz magyar nyelvű könyvet, amiben az alapoktól indulnak.
Amúgy leginkább programot, vagy játékot készíthetsz vele. Honlapot is lehet, csak ahhoz kevés lesz, más nyelvek is kellenek mellé (sőt, inkább azok).
Szerintem a futtatókörnyezettel meg az ajánlott könyvvel el lehet sajátítani az alapokat, onnan meg már tudni fogod, merre szeretnél tovább menni.
"We spared no expense"
-
cousin333
addikt
válasz
zotya7895
#24
üzenetére
Szerintem az ilyesmit nem lehet elég korán kezdeni. Esetleg érdemes lehet alapvetően a számítógépek működésével, és magával a programozással (tehát nem egy konkrét nyelvvel) kapcsolatos könyveket is olvasgatni, de a programozói gondolkodást el lehet sajátítani egy programnyelven keresztül is (valamilyen szinten).
Kezdő nyelvként a Python szerintem ideális, mert egyszerűen el lehet vele indulni (minden benne van, ami kell, könnyen telepíthető, a kód akár soronként futtatható), logikus, egyszerű, és rákényszeríti a felhasználót a szép, strukturált kódra. Mindemellett kellően komplex dolgok is megvalósíthatók vele a későbbiek folyamán.
Ha valami kérdésed van, tedd fel nyugodtan, ha tudok, válaszolok rá (én sem vagyok egy guru, de majd igyekszem).
"We spared no expense"
-
cousin333
addikt
válasz
zotya7895
#28
üzenetére
Látod, most megfogtál
Olyan könyvre gondolok itt elsősorban, ami a programozás folyamatával és nem konkrétan egy adott programozással kapcsolatos. Tudom, hogy léteznek ilyen könyvek, de nekem személyesen még nem volt hozzájuk szerencsém.
Ezt mondjuk nem ismerem, de jónak tűnik, ilyesmire gondoltam.
Az "először"-t inkább visszavonom, legalábbis "párhuzamosan"-ra módosítanám. Egy olyan nyelvvel kellene kezdeni, mint a Python, mert egyszerű és könnyen átlátható. Ennek gyakorlati eredménye is van (a program, amit írsz), és mindjárt példákat látsz az egyes témákra, nem csak a száraz elméletet. Általában a jobbfajta, az egyes programozási nyelvekkel kapcsolatos könyvek is nyújtanak némi általános programozási ismereteket.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
"A fordítással a compile-ra gondoltam, exe-t gyártani a forrásból"
Értem én, de mondom, hogy erre nincsen szükség, ha egyszer fenn van a Python futtatókörnyezet.
"És milyen fejlesztőkörnyezetet tudnál ajánlani, aminek valamilyen jól használható, a Microsoft Visual C-hez hasonló kialakítású kezelőfelülete van ?"
Igazság szerint nem ismerem különösebben a Visual C-t. Alapfokúbb dolgokhoz szerintem jó a "gyári" környezet, esetleg megtámogatva egy Notepad++-szerű alkalmazással. Komolyabbakhoz valóban rendelkezésre áll az említett Eclipse + PyDev. Működni működik, mert próbáltam, de nekem nincs rá szükségem.
"De elöször akkor a python.org-ról a "Python 2.6.2 Windows installer (Windows binary -- does not include source) ", meg a Java Runtime enviroment kell, nem ?"
Igen. A Java az alap Pythonhoz nem szükséges és szerintem az Eclipse is tartalmazza, ami neki kell.
"Én csak ebből gondolom, hogy menne Windows XP-n is, egyébként nem értek a Pythonhoz."
Letöltöd a win-es telepítőt és felteszed, onnantól kezdve mennie kellene, mert abban minden benne van, ami kell. A 3-assal azért nem volt jó, mert az visszafelé nem kompatibilis.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
zotya7895
#37
üzenetére
Üdv!
Nem kell, mindenesetre nem árt. A legfontosabb, hogy magyar nyelvű segítséged legyen, a Pythonhoz (is) léteznek magyar nyelvű könyvek. Az utasítások angolul vannak a programokban, így az angoltudás megkönnyíti a memorizálásukat és a használatukat, de nem követelmény, elég, ha bebiflázod.
Ami még fontos, az az angol szemlélet: magyarul max. kommentezni szabad,magyar változónevek határesetet képeznek, a lényeg az angol karakterek használata (ékezetmentesség).
"We spared no expense"
-
cousin333
addikt
Na, megint megkísérlem feldobni a topikot. Szóval volt egy problémám, amit szerencsére már sikerült megoldani.
Adva van egy függvény, az egyszerűség kedvéért ez (a lényeg a több argumentum):
>>> def osszeg(a,b):
return a+bAdott emellett két (nem feltétlenül, de most jelenesetben) egyforma hosszúságú lista:
>>> a = [1,2,3,4]
>>> b = [5,6,7,8]A cél az volna, hogy párosával hívjuk meg velük az osszeg függvényünket. Erre egy megoldás lehet a map függvény használata.
>>> x = list(map(osszeg, a, b))
>>> print(x)
[6, 8, 10, 12]Látható tehát, hogy a kívánt eredményt kaptuk. De mi van akkor, ha nem ilyen listáink vannak, hanem tuple-jet tartalmazó lista, amiket például így kaphatunk:
>>> c = list(zip(a,b))
>>> print(c)
[(1, 5), (2, 6), (3, 7), (4, 8)]A kérdés, hogy ezt hogyan rakhatjuk be a map függvényünkbe. Nekem úgy tűnik, sehogy, helyette list comprehension-t kell használni, valahogy így:
>>> d = [osszeg(i,j) for i,j in zip(a,b)]
>>> print(d)
[6, 8, 10, 12]A kérdés azonban nem a-ra és b-re vonatkozott elsősorban, hanem c-re, tehát egy tuple-kből álló listára. Mint mondtam, a map-al nekem nem sikerült a list comprehension-nal (ennek mi a magyar neve?) viszont igen. Így:
>>> e = [osszeg(i,j) for i,j in c]
>>> print(e)
[6, 8, 10, 12]Köszönöm, csak ennyit akartam mondani, hátha valakinek segítségére voltam.
ui: Tényleg ennyire nem használja senki ezt a programnyelvet?
Lehet, hogy kellene írnom valami ismertetőt róla, bár én magam sem vagyok egy guru. De ebben a nyelvben éppen az a jó, hogy egyszerűen megtanulható, könnyen használható már alapszintű ismeretekkel is...
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Nem állítom, hogy mindent értek az itt szereplőkből (array-t például még sosem használtam), de azért pár dolog nyitásnak. Ha hülyeséget írtam, akkor javítsatok!
Globális hibák:
- a sorok végére nem kell pontosvessző
- a behúzás mértéke nagyon is számít
- nincs kapcsos zárójel sem (legalábbis nem ebben a formában)import GUI, menu
importálja a GUI és menu modulokat, ha jól láttam, ezek nincsenek benne az alap nyelvbenchoices :=array("Subotica";t"Palic");
egy tömb létrehozása; értékadás, tehát kettőspont nem kell; "t" típuskódot én nem látok, és nem is oda kell tenni (az array azonos típusú elemek listája); az elválasztó a vessző, nem a pontosvessző, szóval inkább:
choices = array('u', ['Subotica', 'Palic'])index == appuifw.popup_array(choicess: u"Select:");
Őszintén szólva ez nem tudom, mi akar lenni, az appuifw valami Symbianos cucc Ami biztos rossz, az a kettős egyenlőségjel, illetve a pontosvessző a végén, valamint a choices változónév el lett írva.$prom = 12;
Nem kezdődhet dollárjellel a változó neve, és pontosvessző sem kell.
prom = 12def calculate($prom);
echo $prom+50
Inkább így kellene:
def calculate(prom):
return prom+50calculate();
Pontosvessző nem kell, függvényparaméter viszont igen. Pl.:
calculate(13)if index = 0:
appuifw.note(u"Subotica");
elseif index = 1;
{
appiufw.note(u"Palic")
}
Ez sem az igazi, inkább:
if index == 0:
appuifw.note(u'Subotica')
elif index == 1:
appiufw.note(u'Palic')Remélem azért segítettem valamelyest...
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
privacy99
#119
üzenetére
Üdv!
A te példád alapján, de nem teljesen azt folytatva (szóval még dolgozni kell rajta), nekem ez jött ki. Hozzáteszem, hogy én Python 3.2.3-at használtam, ami nem teljesen kompatibilis a 2.7-es szériával (amit a kódod alapján te használtál). Szóval a kód:
# előregyártott fejléc a sorok egyes elemeihez
rekord = ['Kod', 'Repter', 'Terv', 'Indulas', 'Terminal', 'Megjegyzes']
# a fájl megnyitása olvasásra, ez a "with" szerkezetes megoldás a végén be is zárja azt, a fájl objektum neve (a példád alapján) f1
with open('d:\\text.txt', 'r') as f1:
# adatok beolvasása soronként, sorvégi újsor karakterek ("\n") levágása
# egy-egy sor szétbontása tabulátorokkal határolt elemekre
# könyvtár-listát hoz létre az elemekből a "rekord" nevű fejlécekkel
# az üres sorokat kihagyja
# 'Terminal': '1', 'Indulas': '05:59', 'Terv': '06:00'}
adatok = [dict(zip(rekord, i.strip('\n').split('\t'))) for i in f1 if i != '\n']
# teljes fájl beolvasva az "adatok" nevű listába
# példa az első elemre (adatok[0]):
# {'Megjegyzes': 'Felszállt', 'Repter': 'London Luton', 'Kod': 'W62201', ...
# 'Terminal': '1', 'Indulas': '05:59', 'Terv': '06:00'}
# az időkülönbségek számításához kell ez a könyvtár
from datetime import datetime as ido
# végignézzük az összes bejegyzést
for adat in adatok:
terv = ido.strptime(adat['Terv'], '%H:%M') # a "terv" egy időobjektum lesz a szövegből a megadott formátummal
teny = ido.strptime(adat['Indulas'], '%H:%M') # a "teny" egy időobjektum lesz a szövegből a megadott formátummal
kulonb = teny - terv # a két időpont különbsége (egy datetime.timedelta objektum)
adat['Diff'] = kulonb.total_seconds() / 60 # a differenciát hozzáírjuk (mp -> perc)
#megnyitunk egy másik fájl adatmentésre
with open('d:\\kimenet.txt', 'w') as f2:
# kiírjuk bele azokat az elemeket (a megadott adatokkal, tabulátorral elválasztva), amiknél az időkülönbség pozitív
[f2.write('\t'.join([elem['Kod'], elem['Repter'], str(elem['Diff'])]) + '\n') for elem in adatok if elem['Diff'] > 0]Vannak benne kommentek is, remélem azzal együtt érthető lesz. Ha egy sorban nincs várható időpont az a beolvasásnál nem baj, feltéve, hogy a tab-ok ki vannak neki hagyva. A számolásnál már gond lehet
, ott bele kell nyúlni a kódba valamiféle vizsgálattal.[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Feltételezem, hogy mondjuk az emberek nevű listában már minden beolvasott név szerepel. Ekkor le kell generálni az összes lehetséges permutációt, hiszen "Eszter köszönti Bélát", de kell egy "Béla köszönti Esztert" is. Ez alapból szépen sorba lesz rendezve, tehát meg kell keverni őket. A kód:
import itertools
import random
variaciok = list(itertools.permutations(emberek, 2))
random.shuffle(variaciok)A random.shuffle helyben keverget, tehát a bemenet és a kimenet egyaránt a variaciok nevű változó. Innen már csak le kell generálni a mondatokat, ami elég egyszerűen megy:
mondatok = [i[0]+' köszönt '+i[1]+' nevű ismerősének.' for i in variaciok]
Ezután ezt ki kell íratni a konzolra, fájlba... stb. Szerintem kb. ennyi. Ez működik 2, vagy akár 100 embernél is.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
Jim Tonic
#268
üzenetére
Úgy tudom, a Qt Designer a Qt íróinak a terméke, a PyQt (meg mondjuk egyes Python disztribúciók, pl. Winpython) csak integrálja a csomagjában.
Ez, ahogy egy kicsit a neve is mutatja csak egy tervező alkalmazás. GUI elemeket lehet rendezgetni, egyszerű interakciókkal és paraméter-állítgatással. Az eredményt mentheted ui kiterjesztésű fájlként. Eddig nincs semmi köze a Pythonhoz!
Az ezután jön. Vagy az ui-ból generálsz py-t egy integrált (PyQT-s?) alkalmazással, vagy ezt röptében teszed meg az PyQt uic moduljával, ami képes közvetlenül az ui fájlt betölteni. A végeredmény minkét esetben egy py állomány lesz (utóbbi esetben csak a memóriában), amit sima Pythonban (PyQt-vel) is írhattál volna, csak így azért egyszerűbb...
Innentől kezdve a funkciókat, interakciókat neked kell lekódolnod Pythonban.
ui: Nem tudom, meddig jutottál a vizsgálódásaiddal, de ha nem mondtam semmi újat, akkor tekintsd tárgytalannak ezt a hozzászólást...
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Elvileg egy alap Python és a Spyder nevezetű IDE képes ilyesmikre.
Amit én használok, az a Winpython. Van benne minden, mint a búcsúban (neked nyilván sok is lesz), választható 2.7.x vagy akár 3.4.x (esetleg korábbiak), 32 és 64 bit egyaránt. Ja és nem kell telepíteni sem, csak kicsomagolni. Igaz úgy már >1GB...
. Van benne Python + hadseregnyi modul (numpy, matplotlib, pandas, sympy...) + Spyder + IPython + Qt konzol + Qt Designer is. És ingyenes.[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Igen, a Spyder egy jó kompromisszumnak tűnik. Kellően sokrétű, mégis egyszerűen használható marad, ráadásul a Python a célnyelv (ellenben pl. az Eclipse-el). És persze ingyenes.
Egy másik érdekes IDE a PyCharm. Ez egy kereskedelmi szoftver, nem csak Pythonhoz, de van ingyenes Community Edition is, ami a mi szempontunkból teljes értékűnek tekinthető.
Ha pedig szkript és mondjuk adatfeldolgozás, akkor egyértelműen IPython Notebook.
Az androidos kérdésedhez nem tudok hozzászólni.
"We spared no expense"
-
cousin333
addikt
-
cousin333
addikt
Nem ismerem a Tk-t. Viszont:
A Tkinter.Tk() osztálynak nincsen delete metódusa (azért akad ki). Van viszont deletecommand, meg destroy. Gondolom az utóbbi funkcionalitása kellene.
A justify attribútum a több soros szövegekre vonatkozik. Ami neked kell elvileg, az az anchor.
ui: Nem tudom, milyen szerkesztőt használsz, de a jobbak automatikus kiegészítése felajánlja egy adott objektumhoz a lehetséges attribútumok/metódusok listáját. Amit meg nem ad fel (lásd delete) az általában nincs is.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Szerintem a Spyder jó választás lenne, esetleg a PyCharm. Mindkettőben van konzol és kódszerkesztő egyaránt, és Linuxra is elérhetőek.
Egyelőre csak próbaként használtam gui könyvtárakat. Amire jelenleg nekem kell, arra az IPython Notebook is tökéletes - ami nem gui lib! -, érdemes megismerkedni vele. Ha egyszer továbblépnék a "rendes" GUI-k irányába, akkor valószínűleg a PyQt-t választanám a Qt Designerrel (bemutató). Ez egy drag-n-drop szerkesztő, az elmentett guit, meg pár sor kóddal betöltheted és használatba veheted. Esetleg kisebb, erre épülő könyvtárakat, mint a guiqwt.
Jelenleg Windows alatt a WinPython-t használom. Ez egy Python disztribúció, ami többek közt a fenti eszközöket integrálja magába. Mint a neve is mutatja, ez Windows only, de vannak más, cross-platform csomagok is, pl. Anaconda. De persze ez csak kényelmi lehetőség, a Python mellé egyenként is felteheted a csomagokat. A pip a te barátod.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Pedig szerintem érhetően leírja. A két import közti különbség:
from numpy import * # 1. megoldás
import numpy # 2. megoldásAz első esetben a teljes névtartományt (namespace-t) beimportálod és így írhatod például azt, hogy x = linspace(0, 10, 101)
A második esetben csak a modult töltöd be és ekkor azt kell írnod, hogy x = np.linspace(0, 10, 101)
Az első eset nyilván egyszerűbb, de nem elég kifejező. Ha van egy másik importált csomagod szintén egy linspace függvénnyel, akkor mi történik? Nyilván az utolsónak importált számít, de ezt egy másik felhasználó nem fogja tudni, mert nincs benne a kódban, hanem a pylab-bal lett beimportálva, ami "valamit még csinált".
A lényeg, hogy bizonyos szintaktikai egyszerűsítésekért cserébe összekuszálja a szálakat és feladja az egyértelműséget. ("Explicit is better than implicit.") Meg hogy jobban hasonlítson mondjuk a Matlab-ra. Én is mérnök vagyok, én sem akarom túlbonyolítani, de azért ennyi még belefér.
VI alatt mit értesz? Virtual instrument?
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Nos, nem kell feltétlenül a repóban lennie:
Anaconda: Innen le tudod tölteni az sh kiterjesztésű fájlt. Ha most kezditek a pythonosdit, akkor szerintem a 3.4-es verziót használjátok (lásd az "I want Python 3.4" linket). Ha letöltötted, akkor parancssorból telepíted, az itt leírtak alapján. Ha lefutott, akkor a parancssorba beírva, hogy spyder már el is indul a Spyder.
Szintén parancssorba írva, hogy:
conda install numpy
már települ is a kérdéses csomag legfrissebb verziója a függőségeivel együtt.A GUI létrehozásához szerintem a Qt Designer egy jó választás, ha az iPython notebook - ami szintén feltelepül az Anacondával együtt - esetleg nem felel meg a célra. Telepítése parancssorból egyszerűen:
sudo apt-get install qt4-designerA QtDesigner-ben elkészíted a GUI-t majd elmented egy ui kiterjesztésű fájlba. Ezt aztán be tudod olvasni Pythonból ezen kód alapján.
ui: A fenti telepítési műveleteket sikeresen teszteltem Ubuntu 14.10-el. Egyébként Windows alatt használom a WinPython-t...
Remélem tudtam segíteni.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Ha nem félsz a kérdéses problémánál kicsit jobban belemenni, akkor érdemes megismerkedni a Pandas csomaggal, mert sok hasznos okosságot tud az efféle manipulációkhoz. Ebben vannak függvények pl. csv fájlok beolvasására, ahol azt is megadhatod, hogy milyen típus az adott oszlop. Vagy - ami neked kell - több oszlopból összeállíthatsz egy dátumot. Valahol itt kezd, és görgess lefele.
Egyébként meg talán a numpy és a time modulok környékén kellene keresgélni. De szerintem hosszabb távon jobban jársz a Pandas-zal.
"We spared no expense"
-
cousin333
addikt
válasz
cousin333
#350
üzenetére
Na, meg is van egy megoldás. Innen lestem el. A mi esetünkben (interaktív konzolt feltételezve, amihez nem kell külön print) így néz ki:
import pandas as pd
from datetime import datetimeLétrehozzuk a DataFrame objektumot, ami egy oszlopból áll, és ami a dekódolt dátum:
parse = lambda x: datetime.strptime(x, '%Y.%m.%d %H %M')
data = pd.read_csv('R:\\teszt.csv', sep=';', header=None, parse_dates={'Date': [0,1,2]}, date_parser=parse)Egy új oszlop létrehozása New néven, amiben a dátum a kívánt formázással szerepel:
data['New'] = data.Date.apply(datetime.strftime, format='%Y.%m.%d.%H.%M.')
Majd mindezt kiírjuk egy másik csv fájlba:
data.to_csv('R:\\result.csv', sep=';')Elsőre talán macerásnak tűnik, de valójában elég rugalmas, és később is sok mindenre felhasználható. Ráadásul csak 6 sor!
[ Szerkesztve ]
"We spared no expense"
-
#354
cousin333
addikt
pokerecske1
#353
cousin333
addikt
válasz
pokerecske1
#353
üzenetére
Szia!
A Pandas modul teljesen jó a célra, mert tud két olyan dolgot, ami neked kell:
- dátum-oszlopok beolvasása
- dátumok újramintavételezéseAz elsőt már a beolvasásnál érdemes aktiválni, így a dátum lesz az index:
data = pd.read_csv('data.csv', header=None, index_col=0, parse_dates=True, names=['X', 'Y'])Ha sok az adat, esetleg gyorsíthat, ha még beteszed, hogy infer_datetime_format=True. Egyáltalán: jó, ha olvasgatod a read_csv metódus súgóját. Pl. a fenti sor feltételezi, hogy az index oszlop (a 0.) tartalmazza a dátumot.
Érdemes lehet kiíratni az első pár sort, hogy lásd, mi történt:
data.head()Ha van index oszlopod (ami most maga a dátum), akkor az ábrázolás innen egyszerűen:
data.plot()A másik, amit szeretnél, hogy napi/óránkénti bontásban ábrázolja (vagy más osztásban), pl.:
data.resample('H', how='mean') # óránkénti bontás
data.resample('M', how='mean') # havi bontásÁbrázoláshoz egyszerűen add hozzá, hogy plot:
data.resample('M', how='mean').plot()"We spared no expense"
-
#356
cousin333
addikt
pokerecske1
#355
cousin333
addikt
válasz
pokerecske1
#355
üzenetére
Tehát ha jól értem, akkor a megadott (több napos) intervallumon belül szeretnéd az adott órák az átlagát kiszámolni, tehát mondjuk elsejétől ötödikéig kiszámítani a 00:00 és 01:00 közötti értékek átlagát, majd az 01:00 és 02:00 közöttiekét, egészen 23:00-24:00-ig. A megoldás a GroupBy, ami egy kulcsot vár. Esetünkben:
kulcs = lambda x: x.hour
data.groupby(by=kulcs).mean()vagy összevontan, és adott időtartományra:
data['2013-5-20':'2013-5-30'].groupby(lambda x: x.hour).mean().plot()
ui: Ha nem muszáj, akkor nem érdemes mindig új DataFrame-et létrehozni (AO_mm = ...), elég, ha egyszer van meg az adat és annak a nézeteit ábrázolod.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
Vasinger!
#371
üzenetére
Milyen témakörben gondolkodsz? Kicsit talán lehetne konkrétabb is a kérdés, akkor válaszolni is könnyebb. Ha meg algoritmus érdekel, akkor mindegy, hogy Python, C, Java vagy akármi.
Ami így most eszembe jutott, az a Pandas modul (ami eredetileg pénzügyi feladatokra íródott, pl. részvényárfolyam), vagy a Scikit-learn, ami meg általános felhasználásra, pl. regresszió számításhoz. A honlapjukon vannak fenn példák és videók. Esetleg még valami Youtube csatorna egy PyCon előadással az adott témában.
"We spared no expense"
-
#385
cousin333
addikt
AeSDé Team
#384
cousin333
addikt
válasz
AeSDé Team
#384
üzenetére
Sokat írtál, de nem eleget...
Például, hogy mit használsz a fejlesztésre: gondolom Python + IDLE.Én alapvetően három irányt javasolnék.
Az első az általános Python ismeretek szélesítése, hogy a főbb funkciók készség szintjén, helyesen rögzüljenek. Ilyen lehet az adattípusok, ciklusok, beépített függvények alapos megismerése. List comprehension, generátorok, rendezés... stb.
A második a Python, mint fejlesztési környezet alapszintű megismerése: fejlesztői környezetek (Spyder, PyCharm, IPython...) disztribúciók (WinPython, Anaconda, Canopy).
A harmadik irány az ismerkedés beépített (pl. os) és külsős modulokkal és azok funkcióival. Azok közül is első körben a szerintem legfontosabbakkal: numpy, matplotlib, pandas. A Python interpretált nyelv, tehát egy import sor után már lehet is interaktívan kísérletezni a függvényekkel. Szerintem ez a nyelv egyik legnagyobb előnye.
A fentiek egy része mondjuk túlmutat a puszta érettségin, de te is írtad, hogy erre szeretnél továbbmenni, így ártani semmiképp sem fog...
. A végén meg neked kell eldönteni, hogy műszaki-matematikai adatelemzést akarsz grafikonokkal, vagy adatbázis-kezelést, vagy grafikus programokat, vagy játékot fejleszteni... stb.Feladatnak meg teljesen jók az érettségi példák (pl. innen). Nem kell feltétlenül egy egész feladatot egyszerre megcsinálni, elég megnézni, hogy milyen tipikus részfeladatok vannak, és azoknak utána nézni. Pl. különböző fájlok beolvasása, azok rendezése, műveletvégzés az adatokon, összehasonlítás, csoportosítás. Nem tudom, érettségin használhatóak-e 3rd party modulok, de mondjuk a Pandas nagyon is alkalmas ezen feladatokra.
Ha van valami konkrét kérdésed - mondjuk akár a feladatokkal kapcsolatban - akkor tedd fel nyugodtan. Ilyen általános kérdésre momentán nem tudok egyebet válaszolni.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Sejtettem, hogy az int lesz a hiba, de látom már megtaláltad. Az említett hibakezeléssel kapcsolatban egy javaslat: fájl megnyitásához használd a kontextus-kezelőt (context-manager) a with kulcsszóval. Ez egy már beépített funkcionalitás, ami egyszerűbbé teszi a fájlok kezelését. A beolvasás így nézne ki vele:
with open('file.txt', 'r') as f:
lines = f.readlines()
a = raw_input ("Kerlek add meg a sor szamat: ")A with blokk megnyitja a fájlt, és a benne lévő kód feldolgozza. A blokk (behúzás) végén a fájl automatikusan bezárásra kerül. with és with
ui: Tudom, hogy ez vita forrása, de ha most ismerkednék a Pythonnal, én a 3-as verzióval kezdenék...
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Ez egy kicsit pongyola lesz, de talán segít...
Python:
- Python futtatókörnyezet
- része az IDLE nevezetű parancssoros Python interpeter
- ez A hivatalos Python telepítés, lásd itt
- vannak benne továbbá gyári modulok különböző feladatokra
- Linuxos analógiával élve ez a kernelSpyder IDE:
- egy népszerű, nyilt forráskódú fejlesztői környezet
- ez önmagában kevés, csak kód szerkesztésre van, magát a kódot a Python futtatókörnyezet hajtja végre
- külsős emberkék fejlesztik
- sokkal összetettebb és komolyabb, mint a "gyári" IDLE
- kódszerkesztő, súgó, aktuális változók listája
- párhuzamosan futtatható, független interpreter környezetek külön füleken (mint sok IDLE egymás mellett)
- más példák 3rd party IDE-re: PyCharm vagy Ninja IDEAnaconda:
- egy Python fejlesztői csomag
- ez konkrétan kereskedelmi, aminek ingyenes változata is van
- benne van a Python "alapcsomag", a Spyder IDE (a fejlesztéshez) és egyéb, külsősök által fejlesztett hasznos modulok (pl. Numpy)
- más példák: WinPython (ingyenes) vagy Canopy (kereskedelmi)
- Linuxos analógiával ezek a disztribúciók (Ubuntu, Mint, Debian...)A Codeskulptor tulajdonképpen olyan, mint pl. a Spyder, csak a kódot, amit a webes felületen beírsz egy szerveren lévő Python interpreter futtatja le, nem a saját géped.
Könyvből jó sok féle van, különösen, ha beszélni angol:
Byte of Python
Think Python
Dive Into Python
...[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
Igen, valahogy úgy.
Ami a GUI-t illeti: Pythonban több út is vezet az igazsághoz. Egyszerű modul elvileg a tkinter ami tulajdonképen része az alap Python telepítésnek. Segíteni nem tudok benne, sose használtam...
Másik, komolyabb opció a Qt keretrendszer, amit a pyqt és társai tesznek használhatóvá. A korábban említett WinPython disztribúcióban pl. benne van minden, ami ehhez kell, például a Qt designer nevű program, amivel kézzel gyárthatsz (drag'n'drop módszerrel) égy ui kiterjesztésű GUI leíró fájt, amit pár sor kóddal Pythonban is használatba vehetsz. Szerintem nem triviális, de sokat ki lehet hozni belőle. video
Az általad említett feladathoz ugyanakkor szerintem remekül passzolna az IPython, újabb nevén Jupyter, ami egy továbbfejlesztett parancssori környezet, Az IPython Notebook ugyanakkor a böngészőben futtatja a Pythont! Egy vagy több soros cellákba írhatsz kódot (vagy szöveget), amit cellánként lehet végrehajtani, akár tetszőleges sorrendben. Nagyon jó adatok feldolgozásához, kísérletezgetéshez. A cella kimenete lehet szöveg (pl. mint a print), grafikon (pl. matplotlib), de már használhatsz widgeteket (lásd gomb és csúszka, meg ilyenek). Ezek elmenthetők HTML-ként is és megoszthatók. Az IPython egy külön csomag, de alapból benne van az Anaconda és Winpython disztribúciókban.
Ha statisztikai szoftvert szeretnél írni, akkor nagyon tudom ajánlani a pandas modult (bemutató, bemutató2). Sok hasznos, praktikus funkció, bőséges dokumentáció. Ez a csomag is része az Anaconda és a Winpython disztribúcióknak.
[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
XP NINJA
#446
üzenetére
Így első blikkre azért nem működött a második feladatod a függvényes módszerrel, mert nem is hívtad meg. A végén feladat_2 helyett feladat_2()-t kellett volna írni.
Szerintem egyébként mindkét megoldás lehet jó, bár az ilyen egymásra épülő feladatoknál talán nagyobb "érettséget" sugall egy harmadik módszer: a kettő kombinációja. Ilyenkor folyamatosan adod hozzá a függvényeket, amik egy jól meghatározott funkciót hajtanak végre, ami nem feltétlenül esik egybe a (teljes) kiírásbeli feladattal. Ezeket pedig egy "fő programban" hívogatod meg szükség szerint.
A példádban ott a 2. feladat, ami annak eldöntése, hogy foglalt-e egy hely, vagy sem. Ebből készíthetnél egy foglaltsag_ellenorzes(lista, x, y) nevű függvényt, ami csak annyit csinál, hogy megnézi a lista-t, hogy az x, y hely foglalt-e (igen/nem), majd a feladathoz kapcsolódva megcsinálod a "körítést". Pl:
def foglaltsag_ellenorzes(lista, sor, szek):
if lista[sor][szek] == "x":
print("A szek foglalt")
else:
print("A szek ures")
# 2. feladat
sorszam = int(input("Adja meg a sor szamat: "))
szekszam = int(input("Adja meg a szek szamat: "))
foglaltsag_ellenorzes(lista, sorszam-1, szekszam-1)Ha már egyszer elkészült egy függvény, vagy megvan egy adat, akkor azt nem kell ismételni. Mondjuk a hármas példában feleslegesen olvasod be újra a foglaltsag.txt fájlt, hiszen azt már az első feladatnál megtetted. De ahhoz is lehetne egy sima fajl_beolvasas(fajlnev) függvényed, aminek csak a fájl listába olvasása lenne a dolga.
Két további megjegyzés a beolvasáshoz: jobb lenne mindezt a with kifejezéssel megtenni, ami automatikusan zárja is a fájlt. A másik, hogy szerintem felesleges a sorokat is külön listaelemekre bontani, hiszen egy-egy sor az tulajdonképpen egy sztring, ami eleve karakterenként indexelhető. Pl.:
def fajl_beolvasas(fajlnev):
with open(fajlnev, "r") as f:
lista = [line.strip() for line in f]
return lista
lista = fajl_beolvasas("foglaltsag.txt")[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
cousin333
#449
üzenetére
A "logikai függvényesítés" előnye a feladatszám-központúval szemben, hogy az 1-es feladat is könnyebben megoldható, hiszen ott nem is egy, hanem két hasonló felépítésű fájlt kell beolvasni. Így az előző hozzászólásom utolsó sora helyett elég ennyi kiegészítés:
fog_lista = fajl_beolvasas("foglaltsag.txt")
kat_lista = fajl_beolvasas("kategoria.txt")"We spared no expense"
-
cousin333
addikt
válasz
cousin333
#449
üzenetére
Így belegondolva az általam megadott példában talán célravezetőbb lenne, ha elrejtenénk a felhasználó elől a tényt, hogy a lista számozása nullától indul. Továbbá nem kellene a függvénynek többet csinálnia, mint amennyi szükséges, majd a program írója eldönti mihez kezd az információval. Tehát talán inkább ezt írnám:
def foglaltsag_ellenorzes(lista, sor, szek):
# Ennek az eredménye igaz vagy hamis (True/False)
return lista[sor-1][szek-1] == "x"
# 2. feladat
sorszam = int(input("Adja meg a sor szamat: "))
szekszam = int(input("Adja meg a szek szamat: "))
# Az if a visszatérési értéket vizsgálja
if foglaltsag_ellenorzes(lista, sorszam, szekszam):
print("A szek foglalt")
else:
print("A szek ures")[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
XP NINJA
#452
üzenetére
"Nem törekszem a legeslegegyszerűbb módra, annak szerintem még nincs itt az ideje, de ezt én is túlzásnak érzem."
Szerintem a Python nyelv egyik legjobb tulajdonsága, hogy alapból egyszerű és logikus szerkezeteket használ. Teljesen felesleges elbonyolítani a dolgokat, érdemes egyből az egyszerűre rámenni.
Ami a megoldásodat illeti, az első feladatban két fájlt is be kéne olvasni, nem csak a foglaltsag.txt-t. A 4. feladat sem jó, mert nem az a kérdés, hogy melyik kategóriájú székből van a legtöbb, hanem hogy melyikből adták el a legtöbbet. Ehhez viszont valahol fel kéne használni a lista nevű listádat, ami sehol nem szerepel.
Az én megoldásom alább látható. Nem ellenőriztem le valós adatokkal és azt sem állítom, hogy nem létezik szebb vagy egyszerűbb megoldás a problémákra. Most ennyire tellett:
print("1. feladat")
def fajl_beolvasas(fajlnev):
with open(fajlnev, 'r') as f:
adat = [sor.strip('\n') for sor in f]
return adat
fog_lista = fajl_beolvasas("foglaltsag.txt")
kat_lista = fajl_beolvasas("kategoria.txt")
print("2. feladat")
def foglaltsag_ellenorzes(lista, sor, szek):
if lista[sor][szek] == "x":
return True
else:
return False
sor = int(input("A sor szama? "))
szek = int(input("A szek szama? "))
if foglaltsag_ellenorzes(fog_lista, sor, szek):
print("A szek mar foglalt")
else:
print("A szek meg ures")
print("3. feladat")
# Összefűzzük a foglaltságokat egyetlen sztringbe, hogy egyszerűbb legyen számolni
fog_sztring = "".join(fog_lista)
# Az alábbi formázás automatikusan egész százalékokat ír ki
uzenet = "Eddig {} jegyet adtak el, ami a nezoter {:.0%}-a"
foglalt_db = fog_sztring.count("x")
print(uzenet.format(foglalt_db, foglalt_db/len(fog_sztring)))
print("4. feladat")
# Összefűzzük a kategóriákat is egyetlen sztringbe, hogy egyszerűbb legyen számolni
kat_sztring = "".join(kat_lista)
# A kategorizált ülőhelyeket egy szótárba (dictionary) tesszük. Elsőre mind üres.
kategorizalt = {"1": 0, "2": 0, "3": 0, "4": 0, "5": 0}
# Végigmegyünk a foglaltsági fájlon, és megszámoljuk a foglalt kategorizált üléseket
for i, fogl in enumerate(fog_sztring):
if fogl == "x":
kateg = kat_sztring[i] # A kategória neve, ami a kategoria.txt fájlban volt
kategorizalt[kateg] += 1
legtobb = max(kategorizalt, key=kategorizalt.get)
print("A legtobb jegyet a {} kategoriaban adtak el".format(legtobb))
print("5. feladat")
arak = {"1": 5000, "2": 4000, "3": 3000, "4": 2000, "5": 1500}
bevetel = 0
for kat in kategorizalt:
bevetel += kategorizalt[kat] * arak[kat]
print("A pillanatnyi bevetel: {}Ft".format(bevetel))
print("6. feladat")
egyedul = 0
for sor in fog_lista:
# Ha a sor elején van egy egyedülálló üres hely
if sor.startswith("ox"):
egyedul += 1
# Ha a sor végén van egy egyedülálló üres hely
if sor.endswith("xo"):
egyedul += 1
# Ha a soron belül vannak egyedülálló üres helyek
egyedul += sor.count("xox")
print("A nezoteren jelenleg {} egyedulallo ures hely van".format(egyedul))
print("7. feladat")
sum_lista = []
for i, sor in enumerate(fog_lista):
sum_sor = []
for j, szek in enumerate(sor):
if szek == "x":
sum_sor.append("x")
else:
sum_sor.append(kat_lista[i][j])
sum_lista.append(sum_sor)
with open("szabad.txt", "w") as f:
[f.write(line + '\n') for line in sum_lista][ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
XP NINJA
#459
üzenetére
sonar megoldása jó, de mivel a Pythonban a sztring iterable, egy sima for ciklussal végig lehet menni rajta. Ezért nem hiszem, hogy mindenáron listát kell csinálni belőle.
Ha pedig sztring, akkor a függvények a Python string metódusok.
Pl. sonar példájával élve ez is működik:
>>> s = "python"
>>> s[3]
'h'[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
LógaGéza
#458
üzenetére
Itt a PySerial dokumentációja a kérdéses modullal: [link]
Ezek alapján a kód a következő (létezik az, hogy nekem nincs egyetlen COM portom sem? Az Eszközkezelő sem említi őket
Majd holnap én is kipróbálom):# Valahol a kód elején a többi importtal
import serial.tools.list_portsA port lista létrehozása a comports() függvénnyel. Ez egy generátor objektumot hoz létre, amiből a portok így adódnak:
ports = list(serial.tools.list_ports.comports())Ennek a listának az elemei a dokumentáció szerint 3 elemű tuple-k. Ebből nekünk az elsőre van szükségünk (ami igazából a nulladik), azt adjuk be a serial.Serial() objektumnak. Ha csak az első elemek kellenek, akkor a fenti helyett egyszerűen írjuk ezt:
ports = [p[0] for p in serial.tools.list_ports.comports()]Ez elvileg működik, mint írtam, COM port hiányában nem tudom most kipróbálni... De holnap biztos megteszem, mert a téma engem is érdekel.
A kérdéses kódban pedig a 85-87-es sort kell módosítani, imigyen:
for p in serial.tools.list_ports.comports():
print(p)
self.combobox_port.append_text(p[0])[ Szerkesztve ]
"We spared no expense"
-
cousin333
addikt
válasz
cousin333
#462
üzenetére
Folytatás: a 25-26-os sort meg le kell cserélni erre, és elvileg már működik is:
self.ser = serial.Serial(self.combobox_port.get_active_text())LógaGéza: Korábban amúgy nekem sem ment a listázás, pedig jó lett volna, de akkor nem így próbáltam. Talán ezzel már menni fog.
[ Szerkesztve ]
"We spared no expense"
Tehát a kérdésem:
Új hozzászólás Aktív témák
- Samsung Galaxy S21 Ultra 12/256GB Phantom Black (újszerű)
- ASUS ROG STRIX RTX 3060 Ti OC LHR - eladó!
- HP Elitebook 840 G8 I5-1145G7 16GB Ram 256GB SSD Magyar + Garancia
- Ducky One 3 Silent Red Full Size Magyar Garanciával eladó
- Thermaltake Gamer PC / i7 4770 / 16GB RAM / GTX 1660 6GB / 500W / SSD+HDD / Garancia