ROSS RHEINGANS-YOO: Hoi, ik ben Ross.
En dit is een CS50 seminar.
Het zal u van de programmering in C te programmeren in Python.
>> Python is een scripttaal.
Het is grotendeels zoals C in syntax, hoewel sommige
van de technische details van hoe dat syntax wordt uitgevoerd
zijn iets anders.
Het is minder krachtig dan C in sommige opzichten.
Het is minder expressief voor waar precies in uw computer
geheugen wordt aangelegd, hoe het wordt aangelegd,
wanneer het de vrijheid en dat soort dingen.
>> Het is nuttiger dan C in sommige opzichten, want het is makkelijker om te programmeren.
De taal, wat mensen, meer intuïtief.
En echt, het doel is voor dat het sneller programmeren
en mogelijk langzamere te voeren.
>> Nu, als u denkt over de tijd
u besteed aan uw laatste probleem set schrijven
uw code tegen de hoeveelheid tijd die je besteedt
op uw laatste probleem stellen de uitvoering van uw code,
je zou denken dat de taal die tweemaal zo snel te schrijven,
en tweemaal zo langzaam uit te voeren, kan zijn een verbetering ten opzichte C in sommige opzichten.
Zeker als je probeert te schrijven kleine programma's kleine dingen doen,
Python is een nuttige taal naar keuze.
>> Aan het eind van deze seminarie, Ik hoop dat je
in staat zijn om het te maken keuze in toekomstige projecten
over welke taal correct gebruik, geen idee
dat één taal is corrigeren de hele tijd.
Een paar dingen over wat het seminar is.
Dit seminar is niet bedoeld om leer je Python vanaf nul.
Python is zeer vergelijkbaar C, en ik ga ervan uit
dat je een CS50 student, of iemand met eenzelfde bekendheid met C.
>> Als je CS50 student probleem rond set 6,
dus je hebt zien veel dingen in C, ik geef je
de grote verschillen, en enkele van de dingen
dat Python verschillende maken en speciale en nuttig,
maar ik ben niet van plan te gaan voor wat een programmeertaal is
en hoe programma's te schrijven.
Toch zal dit seminar leren u een Python-programma's te schrijven
als je een van de weinige groepen.
Opnieuw zullen we kijken naar hoe zou je psets-- implementeren
die moeten 1-6 in Python-- en bieden pointers
de officiële documentatie voor toekomstig gebruik.
Het andere ding dat is belangrijk over de manier waarop dit gesprek is toegewezen,
Deze video zal worden online, met dank aan CS50,
dus je moet niet het gevoel dat je nodig hebt om notities te maken.
U kunt altijd terug gaan en kijken ernaar later als referentie.
Daarnaast zijn de slides zijn nu beschikbaar
op deze site, die moet neem je een Google-doc doen.
Het is een iets verkorte versie van wat ik heb laten zien op het scherm.
>> Men voorzichtig waarschuwing voordat we springen, Python 3
is een andere taal in Python 2.
Ze zien er een stuk hetzelfde; er zijn zeer lichte technische verschillen
dat de programma's zal leiden geschreven in Python 2
niet kunnen worden uitgevoerd in de Python 3 milieu.
>> De CS50 apparaat wordt geleverd met Python standaard maakt gebruik van Python 2.
U kunt dit controleren door typen in de opdrachtregel
python version, die moet geven 2.7.6 van het huidige apparaat.
Probeer Python 3, die wel werken in het toestel,
Als Python standaard 2.X.Y, hetzij op het apparaat of op uw eigen machines.
Je moet Python 3 altijd vervangen in dit gesprek dat ik schrijf Python.
Als uw machine running 2 standaard type
Python 3 om te kunnen daadwerkelijk volgen langs en deze dingen uit te voeren.
>> Daarnaast zal ik u wijzen op nu officieel middelen.
docs.python.org/3--~~V zorgvuldige dat is een 3 en niet een 2--
heeft nuttig gevonden.
Tutorial zal u door veel van dezelfde dingen
dat ik nu doe, behalve in de vorm van tekst.
Reference is bruikbaar als een referentie voor de taal,
en Standard Library geeft u een aantal van de extensies
met extra functionaliteit.
>> Dus een eerste Python programma.
Aan de linker hebben wij standaard C, aan de rechterkant, hebben we Python.
Je zou hebben erkend dit probleem is het
een van de eerste opgave sets in CS50, en deze
oplossen behulp van dezelfde oplossing.
Nu, de reden dat we kijken naar deze naast elkaar
is, zodat we kunnen kijken naar syntactische verschillen.
Eén van de olifanten in de kamer dat u recht zou hebben opgemerkt
van de vleermuis, is dat Python heeft geen hoofdfunctie wikkelen rond de code.
Dus in C, een bos van je schrijft bestanden, je ze met elkaar te verbinden,
en het programma begint met de uitvoering op dit ding heet int main.
>> In Python, schrijf je een bestand dat u het bestand uit te voeren,
het programma begint met de uitvoering aan het begin van het bestand.
Dus het gaat om te beginnen bovenaan bestand
ga naar beneden totdat het iets anders vinden.
Indien hij constateert een functie-definitie, het zal niet eigenlijk dat code uit te voeren,
zal eenvoudig de functie te definiëren.
Maar hier, toen de eerste programma is n gelijk aan 10,
het eerste ding dat dit programma zal doen is deze waarde van 10
en zet het in een variabele genaamd n.
>> Spreken van die lijn, een van andere things-- dit sorry--
betekent dat C's, je ze schrijven,
je zult ze maken, dat zal beroepen sommige clang commando's,
en dan zul je een run resulterende executable.
Python-programma's, je loopt de tekst file-- dit mario.py misschien
zijn dit bestand dat liet ik gewoon u-- je dat bestand uitvoeren
en je zult uitvoeren, en de inhoud ervan
zal worden uitgevoerd door de Python-interpreter.
U kunt dit doen in je IDE.
>> Dus als ik een bestand Hallo, die heeft gewoon deze inhoud.
Dit is eigenlijk Python 2, 3 niet Python, dus niet doen
zorgen over de syntaxis voor nu.
Maar ik zal lopen Python, op hello.py en het loopt.
>> Een andere manier die ik kan gebruiken Python dat Ik zal niet omgaan met zo veel in dit gesprek,
is als ik typ Python, is het zakt me in een omgeving waar
Ik kan het voeden Python lijn per lijn.
Dus hier, als ik typ afdrukken ruimte 'hello, world'.
Typ in te voeren.
Het zal me spuwen dat de resultaten terug dat individuele lijn onmiddellijk.
>> Dit kan nuttig zijn.
In deze lezing zal ik dingen op dia's.
En dus je zult in staat zijn om te volgen langs ofwel hier, of door te schrijven
eigenlijke bestanden en het uitvoeren van hen.
>> Maar, terug te gaan naar deze code, een ander ding
dat je zou kunnen hebben noticed-- goed, er is
twee dingen die je misschien opvalt aan deze blokken.
De eerste, eerder meer alledaagse, dat de Python heeft geen trailing puntkomma.
>> Puntkomma zijn optioneel overal en onschadelijk overal.
Je kunt ze toevoegen.
Het zou de mensen die schrijven maken Python voor een leven snicker naar je
achter je rug, want ze zijn niet nodig.
Ze zijn vaak een teken van wordt gehouden over uit C. De ontwerpers van de taal
het gevoel dat het meer duidelijk op deze manier en dat het niet nodig is te verklaren
elke keer als je eindigt een lijn.
>> Een ander vreemde ding over deze n is het geen type bevestigd.
Een van de magische stukken Python-- en ik ga het magie noemen,
maar er zijn zeer technische redenen waarom het
works-- een van de magie stukjes Python
dat variabelen kunnen uitbreiden of krimpen tot welke data bevatten
soorten je zou hen willen.
>> Dus dit is een 10.
Als later neer ik toegewezen aan deze n 0.5, zou het dat 0,5.
Het maakt niet uit dat het een int hier en zweven er, iets dat dit n gebruikt
zal, min of meer, kunnen puffen mee als het wordt van beide.
Tenzij er een aantal zeer reële reden waarom het de gegevens niet kunnen gebruiken
typt dat n momenteel heeft, op welk punt het zal krijgen
ingeklemd en gooi een fout, en dat soort dingen.
>> Maar hier, Python niet echt schelen wat
het is dat ik ga aan de stok in deze zin, als je dit ding wilt?
Dit ding in dat?
Ja, het is een soort van een ding.
Ik zal het blijven in het einde.
Het zal een probleem later, als iemand die wil dat doel gebruiken
kan niet omgaan.
Dit is een van de belangrijkste verschillen tussen de Python en C
dat maakt het eenvoudig om schrijf zeer grote C-programma's
en vergemakkelijkt schrijven zeer kleine Python programma.
>> De voor de syntax is niet erg verschillend in wat het doet.
Het is iets anders in de manier waarop het wordt uitgedrukt.
Dus dit is een zeer, zogenoemde Pythonic, manier van schrijven.
voor rij in het bereik (n), is de scala van nummers van 0 tot en met n,
inclusive onderaan en exclusief de top.
Het is dus van 0 tot n-1, dat is precies wat de C-code aan het doen is,
behalve dat het een stuk makkelijker om naar te kijken misschien.
>> Het betreffende blok is niet afgezet met bretels,
maar het is op weg door deze inspringen.
Dus al deze lijnen vier plaatsen naar rechts,
of als over een olifant breedte.
En dat zijn degenen die zijn zal worden uitgevoerd voor dit.
Als ik verknoeien de inspringen op deze en I
duwen die printen terug naar de oorspronkelijke inspringen,
die afdruk laat de lus.
In tegenstelling tot C, waarbij ik hier eigenlijk moet dat gesloten brace bewegen.
>> Dit betekent dat je geen fouten krijg dat uit springen op je omdat je
zet een brace in verkeerde plaats.
Het betekent wel dat je fouten krijgen dat uit springen op je omdat je
ingesprongen een lijn verkeerd.
Dus het maakt inkepingen super voorzichtig.
Hopelijk was je zijn super voorzichtig met je inspringen toch,
en dus dit is niet zo veel meer van een last.
>> Maar een basisregel voor Python, en we zullen een paar van deze hebben
dat we door zullen gaan door de loop van het gesprek,
is proberen natuurlijke syntax voordat er iets opzoeken.
Dus deze syntaxis, voor dit aantal in het bereik,
is zeer onderscheidend qua stijl.
Veel dingen in Python we zullen zien het nemen van dit formulier.
>> En dus als je komen met een nieuw object
dat moet je in staat zijn om itereren over deze, in dit formaat,
blijkt dat het waarschijnlijk ondersteunt dat formaat.
We gaan niet super diep in te gaan de technische redenen waarom dat is waar.
>> Maar het is een handig intuïtie te hebben als je het naderen van Python-programma's,
dat dit ding gewoon gaat werken.
Probeer het.
Opstarten van de Command Line Tolk, zien of het werkt,
verder gaan met de dingen, voordat u het zelfs nodig om de openstelling van Google en zeggen:
wat is de syntaxis voor dit bijzondere ding?
Veel Python je kon ontdekken gewoon door te proberen.
>> Dit is als nog vergelijkbaar C dan de fors zijn.
Merk op dat er geen haakjes.
De haakjes, weer, onschadelijk maar overbodig.
Er is een dubbele punt aan het einde net als de lussen,
opnieuw, de relatieve blokken ingesprongen plaats afgezet met bretels.
Dit is anders bij de oorspronkelijke niveau van inspringen,
en de relevante blok weer ingesprongen.
Die werken precies zoals ze doen in C.
>> Dit is eigenlijk heel veel hetzelfde.
Nogmaals, print verliest één teken off van printf Je passeert enkele snaren.
Het blijkt strings kan ofwel worden gemarkeerd
door enkele aanhalingstekens of dubbele aanhalingstekens.
Er is geen verschil, behalve dat binnen
van enkele aanhalingstekens u kunt gebruiken dubbele aanhalingstekens met overgave,
en niet hoeven te ontsnappen allemaal.
En de binnenkant van dubbele aanhalingstekens, je kan enkele aanhalingstekens met overgave te gebruiken
zonder ze te ontsnappen.
Als je wilde mengen hen, kunt u zeker
opzoeken online hoe dat te doen.
>> Je zult zien dat hier opmerken, Ik heb aangenomen in eind = deze zaak.
Dit is een voorbeeld van een facultatieve argument, dat is een van die dingen
dat Python ondersteunt die maakt het heel nuttig.
Zo druk heeft eigenlijk een heleboel argumenten, die gewoonlijk
ingesteld op hun standaard waarde, maar ik heb hier
besloten om het een zogenaamde einde overschrijven.
De reden dat ik overschrijven met een lege string
is dat print in Python, door Standaard drukt een nieuwe lijn
nadat het ding dat je het ook verteld.
>> Dus deze hash is eigenlijk gaat afdrukken van een hash in een nieuwe regel.
En als ik niet wil hash uit te printen een nieuwe regel na, dan moet ik zeggen
niet afgedrukt één.
Maar toch zo, het een laatste ding dat Dit programma mist dat men is
include bovenaan.
Print wordt gebakken in Python dus in principe dat er geen koptekst of module
die je nodig hebt om te omvatten, hoewel indien gewenst
om andere dingen te omvatten in een Python-script,
Ik zou het doen in een zeer vergelijkbare format-- de woorden zijn net iets anders.
>> Ik heb gezegd dat we niet een van de belangrijkste hier nodig,
omdat de Python begint uitvoeren bovenaan.
Als ik wilde wrap dit in functie ik
zou het doen als ik dit-- zou zeker functie naam te zeggen,
argumenten zou hier gaan en we zullen zie een aantal van die later, colon,
en dan weer, dit hele set off block
wat is operationeel blokkeren voor die functie.
Dus dit is de definitie van de functie.
En er is een verklaring, dan naar beneden hier, kan ik gewoon bellen met de functie.
En nogmaals, het programma interpreter, beginnend aan de bovenzijde,
ziet dit is de definitie.
Het zal deze niet uitgevoerd totdat hier te komen, en dan is het net, oh
nu heb je noemde, heb ik denk dat ik moet het uit te voeren.
>> Een ding dat is heel gebruikelijk te zien in Python-bestanden,
vooral Python bestanden die worden vrijgegeven aan het publiek
en ontwikkelde by-- en ontwikkeld en gehandhaafd, is iets van dit formulier.
Dit is zo omdat basically-- Python, begin je aan de top
en dan naar beneden te voeren naar de bodem, Ik als ik had net Mario riep hier
dan is elke keer dat ik opgenomen in dit bestand een ander bestand, want ik wilde gebruiken
is Mario functie, dat andere bestand zou hebben ook deze oproep aan Mario in.
En toen ik liep, dat bestand, zou Mario noemen.
>> Dus het is mogelijk dat slechts I wil dit uitvoeren als ik heb eigenlijk
geëxecuteerd dit specifieke bestand.
En zo kan ik dit verpakken in een idioom als deze, waar ik zeg,
Als de naam van deze executie milieu is de belangrijkste,
dan wil ik deze dingen te doen.
Anders iemand anders kan use-- onder mijn function--
Mijn bestand, en alleen maar om toegang tot deze functies
zonder de dingen lopen dat ik wil uitvoeren in dit bestand.
Dit is weer optioneel maar heel gebruikelijk.
>> Deze dingen zijn entirely-- zijn precies het zelfde tussen C en Python,
zeker in 3.
Ik denk dat in 2, de divisie operator Soms geeft u terug drijft wanneer
u geopereerd ints, en ofwel je dat wilde of je dat niet deed.
Maar plus, min, en tijden werkt precies zoals je zou verwachten,
behalve op iets meer soorten.
Dus je kunt praalwagens vermenigvuldigen met ints, en dat soort dingen.
>> set werkt precies hetzelfde.
U kunt twee gelijke tekens te gebruiken.
inequals-- groter dan, minder dan, dit soort things--
de betekenissen die U bent vertrouwd met hen.
>> Indien C gebruik maakt van deze operatoren, Python maakt gebruik van iets meer Engels
leesbaar degenen.
Dus in plaats van twee, ampersands, u letterlijk typ het woord "en", "of"
of niet."
Net als in uw if-- in uw voorwaardelijke verklaringen,
we eerder zagen dat deze syntaxis in C correspondeert met de syntaxis in Python.
En er is niet veel anders daar, met uitzondering van een klein beetje
interpunctie rond de zijkanten.
Nogmaals, waarbij C zou anders indien, Python gebruikt elif,
maar deze zijn meestal maaiveld veranderingen.
>> Iteratie als dit is vaak geschreven in dit idioom in Python.
U kunt dit soort vervaardigen ding met een while lus aan de buitenkant
als je wilde, maar u zeker niet hoeft te doen.
En nogmaals, als je wilde de printen elementen van een array
je zou doen op deze manier.
Een van de leuke dingen over Python hoewel,
is dat je niet nodig hebt dit paradigma gebruiken,
en u kunt gebruik maken van een iets meer elegant één.
U zegt dat voor een in Ary.
>> Dus in plaats van hier te gaan en loopt over de indexen,
en dan uit te trekken afzonderlijke elementen,
vertel je de voor te eigenlijk alleen lopen over de elementen zelf.
En dan wat u ook doet binnenkant kan direct opereren
op de elementen, dat is vrij leuk.
En we zullen see-- we zullen gebruiken opnieuw en opnieuw dat idioom
als we door code.
>> Dit is weer een voorbeeld van iets dat ik zal
bellen Python magie, maar er zijn zeer technische redenen waarom het werkt.
En er zijn technische dingen die nodig hebt om waar over array in orde
dit te laten werken achter de schermen.
Het ding is dat de meeste soorten die je zou verwachten dit te laten werken
hebben gehad voor deze geïmplementeerd u in de ingebouwde taal.
>> Een ander ding dat het leuk zou zijn als dit werkt in elke taal,
maar er zijn een aantal redenen waarom het niet kan, afdrukken deze string keer dit aantal.
Blijkt dat in Python, dit precies doet wat je wilt, dat is gewoon leuk,
en betekent dat we kunnen eigenlijk dit programma te verminderen, opnieuw mario.c.
Eerder dan iteratie veel, we kunnen gewoon zeggen, ik wil wat aantal,
Ik wil het aantal hashes, en sommige hashes eind.
En nogmaals, maken we gebruik van dit formaat.
>> Hier, we passeren in een variabele op deze manier.
Nogmaals, we hoeven niet te zeggen wat voor soort variabele het is,
en de enige keer dat we krijgt fouten tijdens runtime.
Als iemand probeert om iets te gaan,
het zal prima in de functie komen.
Als we hier wig omdat dit niet het ding dat je bereiken dan kunt maken,
Ik zal een runtime error er te komen, en ik moet het debuggen op die manier.
Maar in de tussentijd heb ik niet heel voorzichtig te zijn wat
wordt doorgegeven, mits de feitelijke uitvoering het allemaal werkt zeer netjes.
>> Ik kon dit zelfs een beetje schoner
gebruik van een bepaalde ingebouwde functie op strings, die recht rechtvaardigen.
Dit is slechts een nuttige functie rondslingeren de bibliotheek.
Het is in de documentatie als je gaan zoeken.
En ik zeg, nou ik ga moeten deze string, een getal van hashes,
en ik zou graag het-- pad rechts te rechtvaardigen het uit met spaties om deze lengte.
>> Ook dit is in het documentatie, die ons-- brengt
Ik kom eigenlijk doorklikken these-- die brengt ons bij onze tweede regel
voor Python-- standaard bibliotheek functie methoden zijn uw vrienden.
En het is vaak de moeite waard op zoek gaan naar Ik vraag me af
als er een ding dat alleen dit doet.
Er is waarschijnlijk.
Als je wilt naar pad uit een string, als je wilt
graag het terug te nemen de helft van een string, als je wilt
graag te zoeken door een string, als u wilt een paar dingen smash
samen met een string met een komma tussen hen,
Er zijn standaard bibliotheek functies hiervoor.
>> En het maakt je leven makkelijker als je ze kunt gebruiken
in plaats van het uit te rollen alles op je eigen
op de vijf regels code hier, vijf regels code hier.
Dat begint eigenlijk bij optellen tot real time.
>> Een van de interessante dingen over hoe dit wordt genoemd.
Je zult merken dat er een dot ding.
Ik heb een object aan de linkerkant, en dan riep ik een dot van een functie.
Dit is één van de paradigma's die Python gebruikt voor het bevestigen van methoden om objecten.
We zullen praten over wat dit is heel kort eind,
maar weet dat we kunnen beide werken op dingen door het nemen van dat ding te zeggen dot
wat dan ook, of door te bellen een functie die neemt
dat object en een aantal andere argumenten.
>> Dit zijn dus twee manieren dingen gedaan te krijgen in Python.
En of een bepaald functionaliteit geïmplementeerd
in deze stijl of dit stijl is iets dat je
moeten kijken omhoog totdat u een knie te krijgen waarvoor men is het waarschijnlijk te vallen.
Er is een min of meer samenhangende filosofie achter Python
dat je vooral absorberen door het schrijven van een stuk in.
Op een gegeven moment, welke van deze iets zullen zo worden uitgevoerd
wordt natuurlijk.
Voor nu, het is gewoon iets je leert als je erachter
elke individuele zaak.
>> Dus standaard bibliotheek functies zijn je vrienden,
en ze laten je dingen schrijven dat nemen dit veel ruimte echt kort,
echt elegant.
En dit is in feite waarschijnlijk leesbaar, zou ik zeggen, dan de C-programma
daar.
Niet aan het feit dat zo noemen kort u een hele olifant passen
in de ruimte die we hebben gered.
>> Een ander ding, dit is een implementatie van mario dat is punt C, waarvan ik denk dat
is de kortste kun je het krijgen.
Het heeft niet het get int, maar het moeilijk codes van de waarde van 10
Net zoals dit doet.
Blijkt dat deze klokken in op 84 karakters, terwijl Python is 64.
En dit is oneindig veel meer leesbaar dan dit afval hier.
Dus Python is efficiënter in de ruimte.
Het is iets minder efficiënt in de tijd, maar niet veel.
>> Lijsten zijn een belangrijk ding Python.
We hebben ze niet gezien, maar ze werken net als arrays doen in C.
Dus hier, kunt u verklaren ze, je kunt ze overgaan in een ding.
Nu pleinen heeft een scala aan deze dingen.
Nogmaals, we hebben niet verklaard type, maar als we ooit proberen om het te gebruiken,
iets dat je zou verwachten werken op een array van integers
gaat werken een reeks integers.
>> Dit is een ding dat je absoluut niet kan
in C, omdat de geheugen is het zo handen op,
maar is zeer gemakkelijk te doen in Python.
Als ik wil dat mijn array groter, ik kan voegt een element aan het en het is prima.
>> Wat gebeurt er achter de schermen?
De tolk zal gaan buiten en krijgen wat geheugen,
en misschien zal het een te krijgen beetje extra geheugen,
dus ik denk niet dat ik niet heb elke keer realloc.
Maar hoeveel meer geheugen is het nodig?
Dit zijn geen beslissingen die je moet maken,
Dit zijn beslissingen die de tolk gaat doen.
>> Hier zien we bereik kan neem twee argumenten,
maar het is nog steeds inbegrepen zijn van de top, zodat we daar voeg 1.
Dit is een idioom, dat een nog slimme manier om dit soort dingen te schrijven.
Het heet lijst begrip, en hier wat we zeggen
is Ik wil graag in te zetten i kwadraat voor elke waarde van i in dit bereik.
Deze zaak aan de rechter zou een andere zijn array, en dit ding aan de linkerzijde
voor een bepaalde functie dat zou ik in een variabele
en geef me een aantal resultaat.
>> Wat ik ga doen is, Ik ga bouwen
een array dat al deze dingen voor elke waarde in dit bereik.
En dit is super elegant, super korte, en het is heel duidelijk wat het betekent.
Dit is een van de things-- dit weer,
één van-- zeer karakteristiek van de redenen dat mensen zoals Python.
Als je van de programmering als dit, dan Python
is een taal die je misschien leuk om te leren.
>> En nogmaals, er zijn technische redenen waarom dit werkt.
Maar wat ons betreft, we meer of minder niet schelen.
>> Dus als je wilt afdrukken lijsten, een aantal van dezelfde uitdrukkingen bruikbaar.
Voor ik in deze reeks, konden we index door alle dingen
en dan print ze allemaal uit.
En je zult zien hier len.
Als u ooit hebt willen krijgen de lengte van de array, die
zeer gemakkelijk in Python, het is heel moeilijk in C.
Dit zou precies uitprinten wat je zou verwachten.
Wij konden ook, zoals we eerder hebben gezien, itereren over de elementen in matrix
direct, en dan gewoon praten over hen, in plaats van de index
terug in de matrix telkens.
>> En dit is een ding dat je kunt doen.
Dus in C, als je vraagt ​​om iets als dit, zou druk zeggen,
dat is een array van integers.
Dat is zeker niet een touwtje, ik kan niet afdrukken.
Python meer of minder niet schelen.
Het is net als, is er een manier die ik kan dit tot een koord draaien in?
Ja, ik zal dat doen.
En dus zal ik gewoon af te drukken dat uit.
Dit betekent dat u kunt like-- deze dingen doen
de meeste van de harde delen van het spel van de vijftien, schriftelijke
heel kort in Python.
>> Je zult zien dat er een beetje van-- hier
Ik heb een geheel getal geworpen naar een string, en ik moet dat handmatig doen.
En ik ga toe te voegen aan een andere reeks,
of anderszins Python in de war raakt.
Maar of als je toevoegen van een string naar een integer,
ben ik veronderstel om een ​​te krijgen integer rug of een string terug?
Maar nogmaals, als je gewoon str bellen op een ding,
en het kan in elke mogelijke wereld worden omgezet in een tekenreeks,
het zal waarschijnlijk omgezet in een tekenreeks.
>> Hier zien we het gebruik van geneste lijst begrip
links, wat indexeren, waarvan is precies zoals je zou worden gebruikt om het,
en sommige afdrukken uit dingen.
Nogmaals, we hebben gedefinieerd wat functies en wij noemen ze neer
in de belangrijkste toen we eigenlijk het bestand.
return werkt precies zoals je zou verwachten van het werken met C. zoeken,
we kunnen opzetten dingen zoals dit-- hier is de lijst begrip
Er is een opdracht aan een variabele, en kunnen we eigenlijk doen het nog gemakkelijker.
We hoeven niet te zoeken te schrijven, omdat ingebouwd in de taal
is als dit ding is in deze array.
Return true, anders return false.
Dus dat is het geheel van de vondst.
>> Het geheel van de soort impliceert bellen sorteren,
die is-- er implementaties dit ingebouwd in bepaalde C libraries.
Als u dit wilt soort achteruit, je
kan overschrijven deze optionele argument in omgekeerde met een ware.
En als je wilt over te sorteren strings, dat is ingebouwd in ook.
>> Dus dit is niet te zeggen dat zijn dingen die je nodig hebt om elke dag doen,
maar het idee is dat deze is de filosofie van Python,
dat al deze dingen die je zou soort van willen doen zijn ingebouwd.
En de meeste standaard functies, dus een soort, lengte, wat dan ook,
ondersteunen de meeste logisch zinvolle inbreng.
U belt len ​​op een array dezelfde zoals je oproep Len op een string.
Je multiply-- je snaren afstand op dezelfde manier als arrays afstand.
>> De meeste standaard functies dat mensen op te bouwen,
en de meeste third-party bibliotheken die mensen
bouwen, omdat ze emuleren het ontwerp van de standaard bibliotheek,
genoemd kan worden op alles wat je bent zoals, waarom dit niet gewoon werken,
in C. Min of meer, het zal werken in Python
omdat mensen werken achter de figuur wat een ding is en dan werken
adequaat op.
Dus nogmaals, technische achtergrond, maar het maakt ons leven gemakkelijker als programmeurs.
>> Dus hier is bestand I / O. file I / O heeft veel kleine dingen die het ingewikkeld te maken,
en dus zijn er middelen online, maar in een notendop,
bel je open op een bestand naam van een bepaald type.
Dus dat is te lezen, lezen en schrijven, schrijven of toevoegen.
Je leest een aantal personages uit en je afdrukken die,
krijg je Hello!
Ik bedoel, als dit bestand had Hello!
Daarin roepen om te lezen, en wat je terug krijgt
een tekenreeks die alle over de rest van de matrix,
of alle overige bestanden.
Als u opnieuw te bellen lezen, je bent aan het einde van het bestand,
en zo krijg je niet alles en dus je zult sluiten.
Nogmaals, dit is .close plaats dicht bestand, zoals het in C. zou zijn
Dit is min of meer omdat f een ding, en je wilt voor f te sluiten.
Maar basic file I / O is niet bijzonder ingewikkeld.
Nogmaals, als je wilt een bestand te openen, indien u wilt een bepaalde lijn te lezen,
je kunt krijgen van bepaalde line-- er ingebouwde plug-ins voor.
Als je wilt naar een schrijven ding, kunt u dit schrijven.
Indien u graag individuele uit te schrijven beten, kunt u die schrijven.
En als u wilt herhalen via lijnen van een bestand
individueel, zoals wij deden in een stuk van een paar weken geleden, kun je dat doen om.
Nogmaals, de meeste objecten die je zou graag in staat zijn om over te herhalen
ondersteuning itereren over hen.
In Pythons, een bestand is misschien een wat Ik wil graag herhalen dan regel voor regel.
Als het een woordenboek van woorden en ik was
proberen om deze individuele krijgen woorden uit, dan, binnen deze lus,
lijn Het gaat worden elk woord op zijn beurt en dit
zal worden uitgevoerd voor elke lijn in het bestand tot het einde van het bestand.
En nogmaals, als ik uitgeprint elk lijn, de lijnen komen met nieuwe lijnen,
dus ik ben het instellen van het einde terug naar een zaak als deze.
Dan zou ik de inhoud van mijn bestand.
>> Het tweede ding die actief is in sommige opzichten, zoals lijsten, en in sommige opzichten
als iets substantieel krachtiger,
zijn woordenboeken, die echt zijn cool om te gebruiken, maar zijn in principe hash
tafels in vermomming.
Je één met precies creëren twee karakters, dat is geweldig
Als u geprobeerd om het uit te voeren hash tabel voor uw probleem set,
weet je veel pijn, dat kan zijn.
Maar mensen hebben gedaan het, en deed het zo goed,
dat je niet hoeft te zorgen over het meer.
>> Dan kunt u individuele zaken te voegen.
Hash tables-- of woordenboeken niet bijzonder
schelen wat je opslaan in hen.
Dus als sommige inzendingen zijn nummers, en sommige inzendingen zijn lijsten,
als sommige inzendingen zijn ook andere woordenboeken, en sommige inzendingen zijn strings,
Python niet veel zorg.
>> Nogmaals, als je erin verwacht een string en wat je terug te krijgen
is een array, dat is jouw probleem.
En misschien is het de schuld van degene dacht dat het was om dingen
in het woordenboek, misschien was u.
Als dat was iemand anders, hopelijk waren ze
goed gedragen over wat ging in het woordenboek
en geen valkuilen te verlaten voor u om te vallen.
>> Maar de standaard functies geef je terug goed opgevoede dingen.
Dus ze zeggen dat dit rendement terug een woordenboek van strijkers,
dan alles wat je gaat om eruit te komen van een string.
Als je een deel van dit doen en het reizen je, nou, dat zou kunnen zijn op je.
Python geeft je zeker genoeg touw om jezelf te hangen, als je wilt.
Nu kunnen we individuele uitprinten elementen van deze en deze terug
precies wat je zou verwachten.
Precies wat je zou verwachten, denk ik, is een zin die ik gebruik veel,
maar dat is min of minder hoe Python werkt.
Als u vragen om een ​​ding dat niet is , zal Python gooien een fout
en het zal je stoppen uit welk programma je in.
Het zal eigenlijk uitprinten meer informatie dan dat,
het zal wijzen u-- het zal voeg een lijn, en zo.
>> En, nogmaals, misschien willen we om itereren over woordenboeken
en vind alle dingen erin.
Hier zijn we dan itereren twee dingen tegelijkertijd.
En dus zullen we het doen met een sleutel, waarde, maar dan uitprinten al deze.
>> En als we wilden cast-- als we eigenlijk dit liep,
zouden we wat problemen, omdat hebben on-- toen we gingen met David,
het kon niet add-- als we niet werp het eerste van een reeks,
we konden niet toevoegen die array snaren op een string.
Maar als we wierp het naar een touwtje, iets wat we krijgen
als dit, dat is misschien wat we zouden willen lezen.
>> En dit is speller.
We lezen in de dingen.
Dus we kunnen lezen in individuele woorden als lijnen.
We afhakken de laatste ding, dus dikke min 1
chomps uit het laatste wat we-- het laatste teken van een string.
We zullen zeggen.
OK, elk van deze krijgt ingevoegd in dit woordenboek,
mapping naar een waarde van 1.
Wij doen niet bijzonder zorg over die ene,
maar het is er gewoon te zeggen, ach, dit ding zal ik in het woordenboek gezet.
Want later wat we gaan doen is dat we
gaan zeggen, nou, als het het woordenboek helemaal.
>> Nogmaals, deze controle voor lidmaatschap is up besturingssysteem
met een heel ander algoritme dan zal het in een lijst
maar wij noemen het op dezelfde manier, waarop is een aantal van die Python zoethoudertje
dingen zodat ze gemakkelijker te gebruiken.
En nogmaals, we hebben gezien dit soort dingen eerder.
Dit is in principe vinden, of het is precies dezelfde syntax
zoals, maar werkt op een volledig andere structuur.
En we niet bijzonder schelen.
Dus dat zijn de dingen die je werden gevraagd om uit te voeren voor de speller.
In dit tempo gaan we krijgen min of meer al het psets gedaan.
>> Publiek: Dus dat eigenlijk komt net terug
als verkeerd gespeld als het niet overeenkomen met iets in het woordenboek?
ROSS RHEINGANS-YOO: Ja, ja.
En ja, dit is een aanpassing van een Probleemverzameling
die vraagt ​​u om precies dat te doen.
>> Publiek: Waarom is de lijn min 1 is er?
ROSS RHEINGANS-YOO: So als je itereren
over een bestand vraagt door lijnen, de lijnen
komen met een nieuwe lijn karakter Aan het einde van de het-- minus 1
is gewoon om te winkelen die af.
Dit is een bijzonder flexibel manier van indexering in de dingen.
Dus als je een string, en je zou willen, nou ik ben
gaan om te beginnen bij de drie karakter en ik ga om te gaan tot het einde.
3 colon zal dat voor u doen.
Als je net als ik wil beginnen bij de begint en naar de laatste minus 1
karakter, colon minus 1.
En als je wilde gaan van de derde naar de min eerste,
dan je zou zeggen 3 minus 1.
>> Bovendien, als u wilt indexeren in dingen te rekenen vanaf de achterkant,
je gewoon index met minus cijfers.
Omdat, waarbij C zou ontploffen of misschien
voeden u andere geheugenproblemen je niet hoeft de toegang tot, hoor je kunt zeggen min 1
betekent de laatste, maar 1 teken in een tekenreeks.
>> Modules zijn version-- zijn analogen bibliotheken in C
en zijn nuttig voor een heleboel dingen.
Een heleboel dingen die je zou willen doen in Python,
Naast eenvoudige manipulatie van variabelen
U wilt haak in de grotere bibliotheken met grotere
interfaces en meer mogelijkheden voor interactie
met andere delen van de wereld.
sys is een van die met een bos van hulpmiddelen
die bruikbaar zijn voor interactie het systeem zelf
en zal importeren als import sys.
>> Er is meer documentatie van dat, dat je hier zou kunnen gaan,
of u kon vinden op Google door googlen Python sys.
U typt in te voeren.
De eerste schakel gaat worden de documentatie in Python 2,
de tweede link gaat zijn de documentatie Python 3.
>> En als we schreef een bestand dat leek zoals dit-- Als in het bijzonder, zijn we
kijken die op command line argumenten,
zoals we geleerd om zeer doen vroeg in deze klasse.
Dat is niet moeilijk. Je kunt krijgen argv,
dat is een van die dingen die wordt uitgevoerd door sys.
Het is niet ingebouwd in de basispakket, maar nogmaals, je
kan het uit te breiden door het importeren die functionaliteit van sys.
U zult het sys noemen.
boeiend.
Hier is er argv.
Er is eigenlijk geen argc in sys, omdat je
kan het zo gemakkelijk door te bellen len.
We vervolgens afgedrukt dat uit, dan hebben we liep op onze terminal echo-args.py.
We krijgen weer een array, die is dit eerste argument.
Nogmaals, dit is argv 0, hetgeen de de naam van de zaak, die werd genoemd.
Als we noemden het met extra argumenten, zouden we hen terug.
Dit is een manier om command line argumenten.
Als u wilt vlaggen waar je draaien bijzondere dingen op of override
een bepaalde standaard, argparse is je vriend.
En nogmaals je dat online aan python argparse bij Google.
>> Er zijn een paar van nut modules die je jezelf met behulp
en nogmaals, als je tijd doorbrengen van deze taal importeren jsons
voor het lezen in en uit JSON bestanden, niet zo ingewikkeld.
U opent een bestand, je json.load genoemd op dat bestand en je krijgt weer een ding.
Wat is dat ding?
Het is een JSON object.
Waar dat json heeft array, de Python heeft arrays.
Waar dat json heeft associatieve arrays, Python's
woordenboeken, strijkers, en getallen, enzovoort.
U wilt dumpen dat uit, je het openen van een nieuw bestand, je dump noemen,
en belastingen en stort aan gaan in en uit de snaren.
>> Ook krijgt augurk genoemd in principe hetzelfde interface.
Het is iets handig als je dumpen Python objecten.
Dus als je ooit hebt willen besparen een uitvoering van de huidige status
van een variabele voor een toekomstige draaien van uw programma,
augurk is Python's bibliotheek om dat te doen.
>> Als je een soort van variabele die kunnen worden uitgeschreven
zoals in woorden en tekens en bytes-- als dit woordenboek,
we kunnen opschrijven, we zou het opschrijven als
als een json object, dat was letterlijk deze karakters.
En dan zou het erg makkelijk zijn voor een mens te openen up-- openstellen
en lees het.
Als we niet bijzonder zorg over de mens te lezen,
We kunnen nog efficiënter verpakken in vormen die zich later kunnen worden uitgepakt
of dat later zou worden opgeblazen.
Daarbij bespaart 80% van de ruimte die uw objecten zou kunnen
als u schreef ze handschrift.
>> U belt augurk veel hetzelfde way-- dump, belasting,
en dan krijg je je spullen terug.
Dus als je zeer schrijven korte Python-programma's die
wil de staat te redden, en dan lees ze later terug, dit soort dingen
zijn je vrienden.
Dat je kon heel ze gemakkelijk dumpen als JSON.
Meeste Python objecten kunnen dumpen de JSON
als er een hoop die structureel ze kunnen worden weergegeven op die manier.
>> Dit zijn slechts het topje van de ijsberg op modules die nuttig zijn.
Dus sys, os, multiprocessing, zijn soort elementaire werkpaarden voor zaken
we nodig hebben om te communiceren met het bestandssysteem os.,
zoals os.isfile, os.isdirectory, os.makefile, dit zijn je vrienden.
Als u wilt communiceren met een bepaald bestand
json, augurk, csv.
Als u wilt communiceren met web pagina's, de urllib voor het krijgen van http
pagina's. bs4-- BeautifulSoup-- het is een prachtige parser voor html.
Je loopt het op een html en je krijg deze geneste array object nu,
die je dan kunt doorkruisen lookin, met als gewoon op zoek naar
indien is in, die is fantastisch.
>> Er is een heleboel pakketten voor running--
voor het doen van bijzonder mathy dingen.
Dus als je wilt vermenigvuldigen, omkeren, transformeren matrices,
numpy wordt gebruikt door mensen over de hele wereld voor.
scipy is nog nuttiger instrumenten in die richting.
sklearn-- machine learning, natuurlijke taalverwerking,
super handig spul, krijgt geïmplementeerd in Python hele tijd.
>> En nogmaals, duurt iets langer write-- sorry,
duurt iets langer om te draaien, maar de reden dat de echte ingenieurs de neiging
gebruik Python is omdat je de neiging om geblokkeerde op je schrijven van de code, vrij
dan uw computer waarop de code.
Dus als je gaat om een ​​schrijven programma, dat veel andere mensen
gaat gebruiken altijd, zoals Linux, u
kan het schrijven in C. Als u gaat een berekening motor schrijven,
u in Python zou kunnen schrijven als je nodig om het te veranderen om de paar maanden.
Sommige mensen zouden schrijven in C omdat ze als dat.
>> Dus hebben we import sys gezien als een manier om dingen
het krijgen van de module in uw programma.
U kunt ook importeren als een bijnaam, als je wilt.
Weer multiprocessing is een pijn uittypen elke keer, dus importeren als mp
en dan wanneer je gebruiken in het programma,
je zult zeggen mp.process, of wat je hebt.
Als u wilt importeren slechts één ding,
dus urllib heeft een ding genaamd verzoek, dus je kunt gewoon importeren dat.
Later, zul je niet inroepen als urllib.request, maar net als verzoek
zelf.
>> En je kunt alles importeren uit een module als je wilt.
Dit is soms geen goede idea-- dit meestal niet een goed idee, eigenlijk.
Omdat je very--, want als er iets in dat de module heeft een naam die u
wilden ergens anders te gebruiken in het programma, kan je niet.
>> En het is niet altijd duidelijk dat dat het geval is.
Om ervoor te zorgen dat wat je deed was veilig,
je moet openstellen de module en bekijk alle
van de namen die eindigen in er-- alle functies,
alle variabelen die leven in die module,
want je brengt alle deze in uw lokale namespace.
>> Dus mensen dit doen.
Het wordt algemeen aanbevolen dat u dit niet doet.
Maar mensen doen dit allemaal de tijd, omdat ze
lui en wil niet uittypen mp.
iets, ooit.
>> Al dat gepraat over modules breng me rond om een ​​kort gesprek
hoe je programma's te ontwerpen in Python.
De eerste stap is om te controleren om te zien of iemand anders heeft al het ding gedaan,
of gedaan van 90% van het ding.
De kans is groot dat ze waarschijnlijk, en je moet gaan krijgen hun ding en lopen dat.
Of schrijf een wrapper eromheen aan te passen aan uw doel.
Het is pas daarna over niet dat je dan zou
gaan en write-- beginnen na te denken over hoe je dit ding met elkaar zou zetten.
Er zijn veel dingen die er zijn, en dat is
één van de meest bruikbare dingen over Python.
Net als de taal elegant, de taal
is gemakkelijk te gebruiken, maar ook omdat het is zo elegant en eenvoudig te gebruiken,
mensen zijn met behulp van het voor een lange tijd en er is een heleboel dingen
die er zijn dat u kunt harnas voor uw eigen gebruik.
>> Dus de laatste regels van de Python is, iemand anders heeft al waarschijnlijk geschreven
een module voor die, iemand anders heeft al
waarschijnlijk geschreven een bibliotheek voor.
Voordat u probeert om een ​​ding te doen, kijk om te zien of het wordt geïmplementeerd.
Het is niet zo moeilijk.
Alle modules die ik opgemaakt voorheen en misschien één uitzondering,
vooraf geïnstalleerd op elke standaard Python installatie.
En zo met een oproep tot importeren wat dan ook, je
hebben al die functionaliteit binnen handbereik.
>> Beginnen te wrap up dit praten, er zijn een paar dingen
dat ik vertrok als zwarte dozen en soort verdoezeld,
en er is een paar witte leugens die ik heb verteld dat omwille van eerlijkheid,
Ik zal in ieder geval punt hier, zelfs als ik zal niet
go super diep in allemaal en hun technische uitleg.
>> Veel van de dingen dat ik magie heb geroepen
is wat andere mensen zouden noemen object georiënteerd programmeren.
Dus er zijn veel things-- dus variabelen zijn zeer vaak niet
eenvoudige bytes zit, geheugen, maar erg ingewikkeld
objecten die intern hebben staat over de functies en veel
van verborgen variabelen, veel verborgen functionaliteit die
laat je ze om te zetten in strings, waarmee u itereren over hen.
En als je writing-- en de reden dat zij
hebben al deze rijke functionaliteit omdat de people--
De architecten van de language-- gegaan
door en voor elke standaard object, zet in de functionaliteit
te zeggen dat dit is hoe dit is hoe dit gaat werken
als iemand wil herhalen over.
>> Dus alles dat iemand zou kunnen misschien willen dan herhalen,
logica heeft geschreven handmatig over hoe je bent
verondersteld om itereren over dat object.
Alles wat u eventueel zou willen gedumpt in een string is logisch geschreven.
Dit is de functie die u bellen als Wilt u dit te dumpen naar een string.
Dit is de reden waarom je kunt roepen len op de dingen, dit
is de reden waarom u kunt bellen in, dit is Daarom kunt u bellen als in op alles
dat je zou willen, omdat die allen dragen met hen
de technische know-how om dat te doen.
>> Dit is iets dat ik ben super niet van plan in te gaan.
Maar voor wat in de lijst is subtiel verschillend van C-stijl voor loops,
en je kunt alles van op lezen internet als je geïnteresseerd bent.
Er is een schaduwzijde voor alle van deze, die ik noemde,
zodat er twee dingen.
De eerste is dat dit object georiënteerde programmeren voegt veel overhead
willekeurige dingen, dus je uiteindelijk met behulp van veel meer geheugen;
je uiteindelijk met behulp van een beetje meer tijd dan je zou anders.
De other-- maar hoe meer verraderlijke donkere kant aan deze
is, als dingen gewoon doen als je ze wilt
zonder dat u super hard na te denken of dit een int moet
of dat er moet een vlotter, kan het zijn dat hier
je een int te produceren, maar hier je denken, maar ze zullen het jammer always--,
het zou hier kunnen zijn dat je een float produceren,
maar als je naar het tweede deel van uw programma, je denken,
oh goed, maar ze zullen altijd geef me een int.
En als ze dat niet doen, is het mogelijk dat je ergens ingeklemd,
als u probeert te gebruiken die voor het indexeren in een array, of wat dan ook.
>> Zodat een van de echte nuttige dingen over C is
het dwingt je om echt te denken harde voordat u any--
voordat u een variabele brengen in het leven, net als wat
is het type van de variabele.
En het gaat om dat type voor alle tijd.
>> Dit is niet waar Python, en inderdaad, je
can-- als je gewoon soort van gaan op het gehoor,
en u een aantal beslissingen nemen een manier om op één plaats,
en sommige beslissingen een manier in de andere plaats
zonder dat genoeg spullen achter de scènes in de andere plaats
om dingen goed te vangen, je kan een aantal zeer vreemde fouten krijgen.
En het programma kan blijven draaien voor een zeer lange tijd, omdat het
het doen van een hoop werk te zeggen, goed dit ding kan op deze manier werken,
dus ik ga op die manier uit te voeren.
>> En inderdaad, dat duwt doorsturen door middel van een heleboel kleine fouten
betekent dat vaak wanneer een fout is eigenlijk slecht
en je hoeft eigenlijk wil om het te repareren, het eindigt mijl away-- het programma
eindigt stoppen mijl afstand vanaf het moment dat u uw fout had.
En zo een ding dat we zouden willen programma's te maken, sometimes-- één ding
dat we graag programma's te doen als we het debuggen
is niet luid en niet erg snel wanneer er iets misgaat.
>> Python is erg slecht op dat.
Python is erg goed in het niet falende en rolling forward
met onverwachte dingen.
Dus dit is handig als je schrijft kleine programma's.
Wanneer u ingewikkeld bugs het soms
duurt lang om ze te plagen uit.
>> Dus er is een donkere kant aan alle van deze, net als het werkt gewoon.
Het werkt net als je zou verwachten dat het.
Behalve dat wanneer dit niet gebeurt, kom je in een heel andere plaats
en proberen te achterhalen waar Het was, dat je fout ging.
>> Garbage collection is-- dus een ding dat je zal merken
is dat een van deze dingen, die Ik heb in existence-- gebracht
deze arrays, die woordenboeken, deze objecten, deze files-- nooit te bevrijden.
Er was geen oproep tot vrij in een van deze toespraak.
En dat was op de C-side, omdat wij nooit in die dingen.
>> Maar in Python-kant, is er geen gratis.
Dingen automatisch krijgen bevrijd wanneer Python
denkt dat je niet op zoek naar hen.
Het is echt goede dingen niet bevrijden die je zou nog steeds mogelijk zijn op zoek naar,
maar dit betekent dat als je ga dit grote ding te wijzen,
en je bent zoals, oh Ik ben klaar met het nu,
het is moeilijk om te vertellen Python u klaar bent met het nu.
>> Kunt u soms instellen die variabele voor niemand te zijn,
en dan hoop dat uiteindelijk de garbage collector
komt door en reinigt het uit.
Maar nogmaals, je niet controle over dat.
En een van de redenen dat mensen gebruik maken van C voor echt prestaties kritische dingen,
is dit vermogen om echt weet wanneer het geheugen wordt toegewezen
en wanneer het is bevrijd, en hebben veel controle over te zeggen,
Ik gebruik geen herinnering meer dan ik nodig heb.
Dat is iets dat Python is niet zo geweldig.
Publiek: Mag ik je een vraag stellen?
Wat heb je bedoelt met niet hard?
>> ROSS RHEINGANS-YOO: Dus als er iets fout gaat
en je bent in het debuggen mode, zou je heel vaak
wilt dat uw programma om u te vertellen waar precies het is misgegaan,
en niet gewoon rustig stoppen.
Maar je zou eigenlijk te drukken uit allerlei informatie over
zoals hier was dit.
Dit gebeurde Als u afdrukt een wen-- als je het runnen van een web server--
>> PUBLIEK: [onverstaanbaar]
>> ROSS RHEINGANS-YOO: Ja, als je draait een webserver,
is het soms slecht als je bent altijd ontdoen van fouten,
en je zegt, goed dat werkte niet.
Ik ga om te stoppen.
Ik ga gewoon negeren het en houden de hand is.
Want dan kun je in honderden van deze fouten en niet zien.
>> Het zou zeker nuttig zijn voor het debuggen doeleinden
Als elke keer dat uw webserver maakte een fout, had je duurzaam verslagen van dat.
Misschien heb je zelfs willen het programma om te stoppen, zodat die records
Laat je niet bedolven onder dingen.
Maar nogmaals, dat is in de debugging modus.
>> Vaak in productiemodus, de wereld is een beetje anders.
En in kleine scripts die ik ben actief, waarbij het ding dat ik zei te doen
misschien maar een klein beetje af zijn van wat ik zou willen doen,
Vervolgens soort duwen door fouten is iets wat je zou willen.
En in die gevallen zeker Python verdient echt haar begint.
>> Het laatste wat ik niet praten in dit-- dat ik niet over praten
maar kan echt ergerlijke de eerste keer dat u een van deze fouten,
en de tweede en derde en vierde keer dat je er een hebt deze fouten.
Python, ik noemde die het gebruikt witte ruimte
u welk niveau van inspringen vertellen en wat functioneel blok je in,
behandelt tabbladen en ruimtes anders.
Dus als je het tabblad meer dan vier, en dan de volgende regel heeft vier ruimtes,
zelfs als ze verschijnen als hetzelfde bedrag in uw editor,
Python hen niet behandelen hetzelfde.
>> In feite, Python behandelt tabbladen en ruimtes zoals olie en water.
Ze zijn gewoon verschillende dingen.
Er is geen bepaalde lengte die een tab is,
zodat het is niet als een tab is gelijk aan 8 ruimten, en dus zou je rond te krijgen
op die manier.
Zoals, wanneer het zegt, wat niveau van de witte ruimte Ik ben op,
het eigenlijk zoekt een patroon van spaties en tabs.
En ja, de beste manier om te gaan met deze is om altijd spaties hele tijd.
>> En inderdaad, in het Cloud9 IDE en de CS50 IDE,
uw Tab-toets inserts vier ruimten in plaats
van een tabblad, dat is super handig.
Hoewel nogmaals, als je een Python geschreven programma met tabs, dat zou fijn zijn,
het is gewoon als iemand ging naar binnen en probeerde toe te voegen
een enkele regel aan uw programma dat had vier ruimten voor elke tab,
zou breken.
En het zou een manier te breken dat is echt niet zichtbaar is.
Hoewel de eigenlijke fout bericht dat het gooit
heeft te maken met nieuwe inspringen hier niet te verwachten,
of-- als het over streepje en het lijkt erop dat het verkeerd is,
het is waarschijnlijk omdat is er een tab-ruimte probleem.
Ze zijn nog steeds razend te debuggen.
De grootste geheel dit gesprek, dat ik niet
krijgen, want het is echt een ingewikkeld, subtiel onderwerp
en die nodig zijn om eventuele doen was niet van de dingen die we tot nu toe gedaan,
een concept genaamd tupels.
Ze zijn er net als de arrays die je niet kunt wijzigen.
Ze wennen all over the place, omdat ze zijn nuttig voor veel dingen
die matrices zijn niet bruikbaar voor.
>> Maar als je wilt om een ​​array te maken, en dan beloven de tolk die u
nooit zal willen wijzigen dat thing-- In feite, als u wilt wijzigen,
je zult een nieuwe met het nieuwe te maken waarden in het-- dat zijn tupels.
In plaats van het produceren ze met vierkante haken,
u ze produceren met ronde haken.
Waarom je deze dingen zou gebruiken, is een beetje een kwestie. .
Het enige ding dat ik zal zeggen dat je
tupels kan als indices voor woordenboeken.
Je kunt geen arrays gebruiken als indices voor woordenboeken.
En waarom is, nogmaals, technische en Ik ben niet van plan te lopen in.
>> De PSET die ik niet heb aangeraakt in dit gesprek is pset6.
Dus hier is hoe je d ' implementeren a-- hier
hoe je pset6 zou implementeren in Python.
Met in het achterhoofd de Python ontwerp-cyclus, het eerste ding
dat je doet als je bent schrijven van programma's is check
om te zien of iemand het al heeft gedaan.
>> In feite, als je wilt om serve-- Apache 50
doet deze benadering, behalve dat het komt niet
standaard geïnstalleerd op Linux machines.
Python doet, en het python eenvoudige http-server doet ook.
Als je ooit op een Linux-machine, of de Cloud9 IDE buiten CS50
en je wilt deze stroom te dienen directory naar een bepaalde haven,
python-m SimpleHTTPServer poort dient dat.
U kunt ook importeren de eenvoudige http-server
en het kreeg veel functionaliteit als je wilt het aanpassen, of wijzigen,
of worden gerund het-- harnas aan run je eigen server diensten.
>> Dus dat is Python in een notendop.
En dit is CS50.
Dank je.