'
Sitat:
Men såpass ny Python som du kjører skal inkludere en launcher, og installeringen av den skal automatisk assosiere Python-filer med den. Så du skal kunne kjøre scriptet ved å dobbeltklikke på fila eller bare kjøre "sti/til/scriptetditt.py" i kommandolinjen. Dersom dobbeltklikkingen fører til noe annet i stedet, kan du se om å åpne med launcheren er et alternativ om du høyreklikker og velger "Åpne med..." eller hva det heter. |
Ok, da tror jeg kanskje det er Anaconda3/Spyder som roter det til. .py-filer er ikke assosiert med noe som helst på min pc. Dette kan jeg selvsagt gjøre noe med, men jeg har ikke sett noe standalone kommandolinje med installasjonen jeg bruker.
|
Pån igjen :)
Jeg har to lister med strings, en som inneholder en setning og en annen med visse uønskede bokstaver. setning = ["Jexg", "hayr", "ezn", "katæt", "soøm", "heteår", "Hans"] letters = ["x", "y", "z", "æ", "ø", "å"] Jeg ønsker å lage en funksjon som sjekker om elementer fra letters finnes i setning og erstatter disse uønskede bokstavene med "", slik at resultatet blir ["Jeg", "har", "en", "katt", "som", "heter", "Hans"]. Hvordan får jeg til dette? Har prøvd med doble for-løkker og tror dette kan være veien å gå, men blir så forvirret av å håndtere to lister samtidig. Anyone? Jeg har et ganske ufullstendig forslag som ikke virker (duh), men er jeg ikke inne på noe her? Kode:
nySetning = [] Så jeg antar at jeg må bruke en else statement for å appende de ønskede bokstavene til nySetning i tillegg.. |
Kanskje du kan kjøre en enkel Replace?
|
Tja. Mange måter å gjøre dette på. For å prøve å "fikse" din måte, så ville jeg vel kanskje gjort noe som dette:
Kode:
setning = ["Jexg", "hayr", "ezn", "katæt", "soøm", "heteår", "Hans"] |
Kode:
new_sentence = [] |
Pre-kompilert regex er rimelig raskt på veldig store lister.
Mulig en generator hadde vært mer fornuftig om du har veldig mye data å sjekke. Kode:
#!/usr/bin/env python |
Takker:)
Jeg fikk ikke ditt forslag til å virke, liasis, da new_sentence blir lik som sentence. Ditt forslag virker , Realist1. For større lister blir sikkert dette ganske tidkrevende og det finnes sikkert bedre måter å gjøre det på, men jeg tar til takke med dette :) Jeg skal teste kjøretid med ditt eksempel opp mot de andre, Goophy :) Takk! |
For bitte små lister som dette er map eller list comprehension raskest.
Nøstede for-løkker er bare treigt. |
Noen forslag til hvordan jeg løser dette med list comprehension da? Helt uten å importere moduler.
|
Kode:
[word.translate(None, ''.join(letters)) for word in setning] |
Det har du veldig rett i Provo :)
Kunne du ha forklart meg hvordan koden din virker? translate og join er nytt for meg. |
Sitat:
Edit: en annen ting som kan være lurt, er å fyre opp python i terminal eller powershell og leke med funksjoner der om dokumentasjonen fremstår litt tunglest. |
Xasma: Det er det som noen ganger kan være problemet, at dokumentasjonen forvirrer meg ytterligere. Veldig greit å få ting forklart på en enkel måte av og til. Men takk for tipset om å teste i terminal, det skal jeg gjøre :)
|
String-metoden translate() gjør først og fremst en oversettelse, eller et ombytte, av characters i henhold til en translation table. Men den tar også et ekstra argument, deletechars, som er en streng med characters som skal slettes fra strengen den kalles på, og det er den funksjonaliteten jeg brukte i koden over. Ettersom jeg ikke var interessert i noe øvrig bytte av characters, sendte jeg bare None som translation table.
String-metoden join() tar en liste av strenger som argument, og bruker strengen den kalles på som delimiter og spleiser sammen alle strengene i listen. Så om du skriver for eksempel "+-+".join(["Hei", "sveis", "Pope"]), så vil den returnere strengen "Hei+-+sveis+-+Pope". I koden over brukte jeg en tom streng som delimiter, slik at den bare spleiset sammen alle bokstavene i letters-listen til en sammenhengende streng. Selvsagt kunne man jo bare definert dem som en streng i utgangspunktet og sluppet å kalle join(), men jeg gikk ut fra at du kanskje ikke hadde denne muligheten. |
Sitat:
Sitat:
Kode:
>>> setning = ["Jexg", "hayr", "ezn", "katæt", "soøm", "heteår", "Hans"] Kode:
>>> setning = ["Jexg", "hayr", "ezn", "katæt", "soøm", "heteår", "Hans"] Sitat:
En eller flere linjer til hadde gjort det klarere. Kode:
>>> ''.join(c for x in setning for c in x+' ' if c not in 'xyzæøå').split() |
Nå har jeg tullet meg borti noe som kalles bitwise operators som jeg ikke skjønner skjønner så mye av.
Det gjelder følgende tegn: <<, >>, &, |, ~, ^. Jeg fant en forklaring på det, men får det ikke til å stemme helt når jeg tester i Python. Sitat:
1) Den første er grei. Da vil x<<y = 5 * 2^7= 640. 2 ) Den andre er litt rar, men gjetter at det har med integerdivisjon å gjøre, så derfor får jeg ikke noe spesielt vettugt ut når jeg prøver x>>y = 5/(2^7) = 5/128. Blir bare 0, men det gir mening hvis man ikke regner med tatt mellom 0 og 1. 3) Hæ? Kode:
2&2 Kode:
2|2 6) Hæ? Kode:
2^2 Grunnen til at jeg kom inn på dette var at jeg fikk se en kode med to lister (a og b) etterfulgt av set(a) | set(b), hvor set skal plukke ut unike verdier av en liste i uordnet rekkefølge. |
Du må se på bits og hva som foregår når man sender de parvis, basert på posisjon inn i logiske porter og hva som da kommer ut.
Si du har 0110(6) og 1011(11) og gjør en bitwise AND-operasjon: da sammenligner du hvert bit, og hver gang begge tallene har 1 i samme posisjon, får du ut 1. Her er begge 1 kun i 2. posisjon, og dermed beholder du denne, mens de andre blir 0, og vi får 0010(2). Så kan vi gjøre det samme med OR-operasjon: her trenger du kun at en av de to er 1, og dermed får du 1111, siden vi kan finne minst en ener i hver posisjon. Til sist har vi XOR-operasjon: her ser vi etter 1'ere igjen, men her kan maksimalt én av input bitsene være 1, og dermed får vi 1101. Når du leker med disse kan det være lurt å bruke bin(int), da får du ut hvordan de ser ut i bit-format. |
Takk for flott svar :) Jeg har ikke sett på bits enda, nei.
Hva er det som står i parenteser etter bits-rekkene(?) dine? Testet bin(int) og det var naturligvis også helt nytt, men her er det mulig å lære ting :) Takk igjen! |
Sitat:
Bitmanipulasjon brukes i mye rart, kryptering bruker f.eks XOR-ing i visse implementasjoner, men også mye annet. Bitmanipulasjon er hendig til en del ting, men for de aller fleste ikke noe mer enn en kuriositet. |
Sitat:
I titallssystemet, hvor vi i praksis overfører fra titallssystemet til titallssystemet: 5 = 5*100 17 = 7*100 + 1*101 54987 = 7*100 + 8*101 + 9*102 + 4*103 + 5*104 For å gjøre om binært til titallssystemet: 1010bin = 0*20 + 1*21 + 0*22 + 1*23 = 10. Det heksadesimale tallsystemet er som alle andre, bare at det har 16 som base. Siden det må være 16 siffer, er sifrene 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E og F. Fremgangsmåten er lik: 7D4Ahex = 10*160 + 4*161 + 13*162 + 7*163 = 32074. Man kan lett bli forvirret av andre tallsystemer om man ikke har erfaring med det. Men det kan hjelpe på forståelsen å visualisere et mekanisk telleapparat av typen man bruker for å telle flypassasjerer og liknende. Hver gang man trykker på knappen, øker tallet med 1. Der har man en rekke hjul, antallet avhenger av hvor mange siffer den har, ikke utseendemessig ulikt snurrehjulene på en vanlig mekanisk kodelås som ofte er på kofferter og hengelåser, eller tellehjulene på gamle kassettspillere. Først begynner apparatet på 000, om det har tre siffer. Når du trykker på knappen, snurrer det første hjulet en tidels runde rundt, og viser sifferet 1, slik at apparatet nå viser 001. Trykker du igjen går det til 002, også videre. Når du har kommet til det siste sifferet, 9, så vil det som skjer når du trykker være at det første hjulet snurrer over til 0 igjen, men drar med seg neste hjul en tidels runde, slik at det nå står 010. Så går det til 011, 012, 013 også videre. Ved 019 vil neste trykk gjøre at første hjul drar med seg andre hjul over en tidelsrunde til, slik at man kan lese 020. Hjul nummer to vil også dra med seg hjul nummer tre, når det går rundt fra det høyeste til det laveste sifferet, så på 099 vil neste trykk dra første hjul over til laveste siffer, som drar andre hjul over til laveste siffer, som drar tredje hjul over på 1, slik at man får 100 – hundre, altså. Så er det bare å bytte base. Heksadesimalt er det akkurat det samme som skjer, men der har man sifrene A, B, C, D, E og F i tillegg. Så hjulet har 16 posisjoner (0-F) i stedet for ti (0-9). Når det første hjulet snurrer fra F (desimalt 15) til 0, drar det med seg neste hjul et hakk, og det heksadesimale telleapparatet viser 010 der det desimale telleapparatet viser 016. Neste er 011, så 012 også videre. Binært, samme prinsipp, bare at der har vi kun to siffer, og ikke ti eller 16. Du begynner å telle, og apparatet går fra 000 til 001. Allerede neste trykk går nederste hjul fra høyeste til laveste siffer, og drar med seg det foran et hakk, så man får 010. Neste trykk gir 011. Deretter drar det første hjulet med seg det andre hjulet som drar med seg det tredje hjulet, og vi får 100. Og sånn fortsetter det videre oppover. |
Jøss, har hørt om nuller og enere før, men at det var sånn det hang sammen var jeg ikke klar over.
Bit-rekkene(?) kan være lengre enn fire plasser? Hvis ikke kan man ikke få større tall enn 1111(17)? Hvor viktig er dette for Pythonprogrammering i praksis? Har ikke vært nevnt i informatikkfaget jeg har. Sweet Jesus, Provo. Åpenbaring :) Takker og bukker! |
Bit-rekkene kan være mye lenger enn fire plasser. På en datamaskin ofte 32 eller 64, men det avhenger av datatypen. Dette er ikke spesielt viktig for python-programmering, med mindre du programmerer noe hvis hensikt er bitmanipulasjon.
Jeg burde vel nevnt at det er noen knep for å representere negative tall, og også desimaltall, men det blir fort litt mer avansert enn nødvendig for å forstå det helt grunnleggende. (Og binært 1111 er desimalt 15, ikke 17 ;)) |
Edit: mente 15, ikke 17.
Hehe, her går det unna. Akkurat, derav 32- og 64-bit som man har hørt om et helt liv! |
Nå har jeg holdt på med classes i et par dager. Jeg skjønner at classes kan være effektivt fordi det muliggjør gjenbruk av kode i form av "inheritance" osv, men til mitt (ganske enkle) bruk klarer jeg meg lenge med funksjoner. Jeg antar at classes blir mer nyttig ettersom koden blir mer avansert.
Anyways, jeg kommer sannsynligvis til å få classes på eksamen og jeg lurer på om dette er riktig bruk av classes: Kode:
from math import sqrt poly1.calculate_X() |
Sitat:
|
Nice :) Og det fungerer bare når klassen inneholder kun en method?
|
Det som er nydelig med klasser, er at det abstraherer vekk en god del av koden din, og kan innkapsle logikk for å passe på at klassevariablene er gyldige. I funksjonen du lister over, så er det egentlig ikke noen vits, ettersom du antageligvis bare kommer til å kalle calculate_X én gang. Da hadde det vært like greit å ha en modul som het ABCformula, med funksjonen calculate_X(a,b,c). Med den første løsningen blir det 2-3 kodelinjer: (import), instansiering, kall. Med den andre så blir det 1-2 linjer: (import), kall. Det ville gitt mer mening om klassen kunne løse flere typer polynomer eller noe, slik at det var litt mer dynamisk hva du ga inn, og forskjellig hva du ville ha ut.
Klasser blir litt mer nyttige når du ønsker å ha en instans av noe, som du kan gi en initialtilstand og så gjøre operasjoner basert på den tilstanden. Det mest nyttige er i situasjoner hvor du er nødt til å lagre mellomtilstander, og så gi denne tilbake igjen til neste runde av en kalkulasjon eller for en tilstandsmaskin. En ting jeg bruker klasser til, er ting som kjører i tråder og skal ha én instans per ressurs - gjerne i en egen tråd. Si at du kommuniserer med et eller annet objekt, som ikke er ditt eget program. Det kan være en mikrokontroller som du snakker UART/SPI med, en socket som snakker med en terminal-service/nettside e.l. Her er det veldig greit å ha en klasse som du kan gi start-parametere til (baudrate/comport eller adresse/port), og så har klassen funksjoner som lar deg sende og lese et visst antall bytes, samt lukke forbindelsen. Tenk så at du ønsker å snakke med ti slike enheter samtidig, fra samme kodebase. Fordelen med å ha det som klasse-instanser, er at du ikke trenger å huske noe annet enn hva instansen heter. Med en gang du har gitt klassen den informasjonen den trenger, så er det "off your hands". Du kommuniserer nå bare via å gjøre funksjonskall på instans-objektet. Instansen selv kan huske hvem som skal kobles til, holde styr på hvorvidt forbindelsen fortsatt er oppe, og lagre unna både inngående og utgående data. Enten for å spare det til du har tid å lese det, eller for å skrive masse data til en treig enhet. Du kan enkelt spørre alle instansene (i loop) om de har noe data til deg. Det er superenkelt å lukke alle ressursene. Alternativet hadde vært en haug med funksjoner som tok masse input-parametre for å finne ut hvilken tilkobling du mener. En annen ting er også arv, hvor du kan arve en funksjon og så gjøre noe spesielt i den nye klassen. Tidligere har jeg brukt dette for spesielle logg-objekter som må skrive ut alt i XML, slik at neste system kan tolke resultatet. Da har jeg en klasse som kan bygge meldinger på riktig format, men som bare skriver alt ut til stdout. Så lager jeg flere klasser som arver den originale, men i stedet skriver ut til en fil, eller utfører operasjoner på hele XML-strukturen før den skrives (konverterer til et annet format, kjører syntax-sjekker, komprimerer den, fjerner duplikater e.l.). I stedet for å ha en ultra-generell XMLLogger-klasse som tar femten parametre, så har jeg i stedet 5 mini-klasser på et par kodelinjer, som hver har et beskrivende navn over hva de gjør (XMLFileLogger, XMLNoDuplicateLogger). (Jeg husker ikke nøyaktige navn, men det understreker uansett poenget. Det var for et continuous integration-system som MÅTTE ha alt på et forhåndsbestemt format). Python har også generatorer, som kan brukes som en slags mellomting mellom funksjoner og klasser. Si at du ønsker å få ut en god del Fibonacci-tall, men ikke alle på én gang pga. minnebegrensninger. Da kan du gjøre noe sånt som dette: Kode:
def Fibonacci(n): |
Alle tidspunkt er GMT +2. Klokken er nå 23:01. |