00:03: hey everyone
00:04: this is nick dear verdict teaching you
00:05: financial modeling today
00:07: we're going to be doing an introduction
00:09: to advanced financial modeling
00:12: so this lecture series has
00:15: two main purposes one is
00:19: to provide an ending to
00:22: the first course of financial modeling
00:25: with python and excel
00:27: and give kind of a roadmap of where you
00:30: can go
00:30: in the future to learn more advanced
00:32: topics
00:34: then the other reason is that this
00:36: serves as a jumping-off point for
00:38: a new course that i'm creating advanced
00:41: financial modeling
00:42: with python so
00:45: it's going to be a little bit slower
00:47: releasing
00:48: all the content for that course because
00:51: the first course
00:52: was developed as part of university of
00:55: florida
00:56: and now this advanced course is just
01:00: on my own doing it um
01:03: so i'm going to be releasing videos
01:06: hopefully
01:06: uh weekly or so um on additional more
01:10: advanced topics
01:12: but in the meantime i also give you a
01:14: lot of resources
01:16: in this lecture series so that you can
01:18: go out and learn these topics on your
01:19: own
01:20: as well and then we'll have
01:23: videos looking into each of the
01:26: particular areas that we're going to
01:27: introduce
01:28: in this lecture series
01:31: so we're also going to just quickly
01:36: recap here what we covered in
01:39: the first course so that if anyone is
01:42: coming in to try and do the advanced
01:44: course they can get a good idea of
01:47: what they didn't get from the first
01:49: course
01:52: so we covered both excel in python
01:55: basics
01:56: in in the first course um
01:59: and that includes you know just general
02:03: python programming as well as building
02:06: full-on financial models
02:08: and as well as excel we kind of
02:11: took the basics for granted and then
02:13: focused on building the financial models
02:16: and also in both tools how to structure
02:18: things appropriately
02:21: such that for larger models you're not
02:23: going to end up with this
02:24: mess you're going to be able to stay
02:26: organized
02:29: um so some of the areas that we covered
02:33: in that
02:35: in the first course are
02:37: [Music]
02:39: how to do a couple different kinds of
02:42: financial modeling looking at cash flow
02:44: modeling
02:45: and probability modeling as well as
02:48: different ways that we can
02:50: extend the base model using sensitivity
02:53: analysis
02:54: scenario analysis and monte carlo
02:56: simulations
03:00: and looking at the particular types of
03:02: financial models that we covered
03:04: in the first course uh we looked at a
03:08: retirement
03:09: model how much you need to save to
03:12: retire
03:13: uh with a certain amount at a certain
03:14: time we looked at capital budgeting
03:18: in order to analyze a project and find
03:21: out
03:21: whether it's a profitable project
03:25: we looked at also
03:28: evaluating giving a loan to someone else
03:30: and
03:32: factoring in the probability of default
03:35: into that and bankruptcy and recovery
03:38: and all of that
03:40: and the last part of the course
03:42: developed the discounted cash flow
03:44: valuation of a stock both the estimation
03:47: of the weighted average cost of capital
03:50: as well as the forecasting of the future
03:54: free cash flows
03:59: but there's a lot more to financial
04:01: modeling
04:02: um really that course is still kind of
04:05: just hitting on the basics of everything
04:08: um and so this lecture series
04:11: we're going to look at a number of
04:13: different areas where you can continue
04:15: to expand
04:16: in the future with your skills so that
04:19: you can
04:20: become an advanced financial modeler
04:25: so those areas
04:29: include additional types of financial
04:32: models
04:33: it includes also
04:35: [Music]
04:36: pipelines how we get data into the model
04:39: in an automated way
04:41: it's going to cover some additional math
04:43: tools
04:46: in terms of um you know additional
04:50: mathematical capabilities we can build
04:52: into our models such as
04:53: symbolic computation and optimization
04:58: and a few more things we can look at
05:00: there
05:01: advanced statistical models
05:04: we're going to look at particularly
05:07: for python how we can present the
05:11: results from the model because
05:12: you know with excel it's it's fairly
05:14: straightforward you just have the
05:15: spreadsheet you format it well
05:17: with python there's a lot more to the
05:20: story but there's a lot more possibility
05:22: there as well
05:24: we're also going to look at
05:27: additional programming topics that you
05:29: can learn both
05:30: uh python specifically as well as more
05:33: general
05:34: programming topics which are helpful
05:37: and we'll also just cover some you know
05:39: general extra resources that you can use
05:42: to continue learning
05:44: so that's the overview of
05:48: all the areas that we're going to cover
05:51: in the advanced financial modeling with
05:54: python course
05:55: and for the rest of this lecture series
05:57: we're just going to go through each area
05:59: and give kind of the highlights of what
06:01: we're going to be looking at
06:02: as well as resources that you can go out
06:05: and learn on your own
06:07: and then going forward i will be
06:09: releasing more lectures
06:11: on each of these topics as well
06:14: so if you want to get notified about
06:17: when i'm going to be releasing those
06:18: feature videos please just go ahead and
06:21: subscribe
06:22: on youtube and you will be notified
06:25: so that's a quick overview of the
06:28: introduction to advanced financial
06:30: modeling so thanks for listening
06:32: and see you next time

00:03: hey everyone
00:03: this is nick duraburtis teaching you
00:05: financial modeling today we're going to
00:07: be taking a look
00:08: at some more types of financial models
00:12: that we did not cover in the
00:15: financial modeling with python and excel
00:17: course but that
00:19: we may look at in the advanced financial
00:21: modeling with python course
00:24: um and so the point of this video is not
00:27: to list every possible financial model
00:30: but instead to look at what some of the
00:33: most common
00:34: models are and just briefly
00:37: discuss them so
00:42: um the first model that we're looking at
00:46: here
00:47: is uh portfolio models
00:50: it's a general class of models portfolio
00:52: evaluation portfolio optimization
00:55: so these are all about putting together
00:57: a portfolio of different assets
01:00: and determining the risk and return on
01:03: that portfolio
01:07: and oftentimes you want to choose
01:10: how to allocate the assets such that you
01:13: will
01:14: maximize the amount of return that
01:16: you're getting for the amount of risk
01:17: that you're taking on
01:22: then we have additional funds needed
01:24: models
01:25: so this is about trying to forecast
01:29: about uh how much money how much capital
01:33: the company is going to need to raise
01:35: in order to satisfy operations in the
01:39: next period
01:40: so we actually already in the
01:44: original course covered a lot of what we
01:47: need here
01:49: because in order to do the dcf model
01:52: we had to learn how to work with the
01:54: financial statements and forecast the
01:56: financial statements
01:58: and that's exactly what you're doing
02:00: here as well you're going to forecast
02:02: the financial statements
02:04: and then you are determining uh based
02:06: upon that
02:07: how much cash you're going to need to
02:09: raise
02:11: through either debt or equity so
02:14: not too much of an extension beyond what
02:17: we've already done there but it is a
02:18: common class of models
02:22: and then there are lease or owned models
02:24: where
02:25: you're evaluating some asset and the
02:28: rental rate
02:29: on that asset and how much it costs to
02:31: purchase it and trying to make a
02:33: decision about that um
02:37: we have event studies um are looking at
02:40: something that
02:41: occurs at some point in time and then
02:44: trying to understand
02:46: what changed because of that event so
02:49: it's kind of looking through
02:51: historical data in order to
02:54: look for a pattern that was caused by
02:56: the event
03:00: we have m a merger and acquisition
03:03: models so this is
03:06: looking at one company evaluating
03:10: purchasing another company and how that
03:13: is going to
03:14: affect the financials of the combined
03:17: company
03:19: and so it's basically
03:22: again the dcf model um
03:26: got us a lot of the way towards building
03:28: this out
03:30: it's basically um
03:33: you take the the parent company
03:36: and the the company that's being
03:38: purchased and you kind of combine their
03:40: financials together
03:42: and do a dcf on the combined financials
03:46: um and that allows you to determine
03:49: the value of the combined company and
03:52: you compare that to the value of
03:55: the parent company um and that
03:58: difference there
03:59: is going to be the value of the
04:03: company that's going to be acquired to
04:06: the acquirer
04:08: um and so that can
04:11: help in setting the price in an m a
04:13: transaction
04:17: then we have lbo leveraged buyout models
04:22: so this is a
04:25: particular type of m a model which is
04:28: focused on uh taking out a large amount
04:32: of debt and using that
04:34: to purchase the firm so
04:37: again the m a model is a dcf model
04:41: with a little bit extra added to it
04:45: the lbo is an m a model with a little
04:47: bit extra added to it as well
04:51: and so it's basically just
04:54: modeling the debt side of this model in
04:57: a lot more detail
04:58: saying that you know you're going to
05:00: have different tranches of debt
05:02: with different seniority and what are
05:03: going to be the cost of each of those
05:06: and using that to evaluate
05:10: the again purchase price of the
05:14: targeted firm
05:17: and ensuring that you're going to be
05:18: able to pay back the debt and all of
05:19: that
05:22: um and there are lots of models
05:26: around valuing derivatives
05:30: um you know options swaps forwards
05:34: uh any kind of derivative um
05:38: forward and future models tend to be
05:41: quite simple
05:42: um swaps are not
05:46: that complicated options are where
05:48: things tend to get
05:49: fairly complicated in the models with
05:51: with quite a bit of math
05:53: going on but
05:56: if you're interested in going into
05:58: derivatives it's definitely makes sense
06:00: to
06:00: check these out
06:04: debt models we did cover um you know
06:07: evaluating a loan
06:09: uh from the perspective of a lender um
06:13: in the in the first course but there are
06:15: a lot of debt models that we didn't
06:16: cover
06:17: um so one example here is
06:21: immunization models which uh are about
06:26: saving about uh having the right amount
06:29: of cash at the right time
06:30: in the future uh such that you're gonna
06:34: invest um in low enough for a securities
06:38: in order to meet that objective
06:41: uh but you wanna try to maximize your
06:43: return
06:44: while still ensuring that you're gonna
06:46: meet that objective
06:49: term structure models try to explain
06:53: the yields on different maturities of
06:56: bonds
06:57: and default adjusted
07:00: return models uh are for evaluating the
07:03: returns on
07:05: debt instruments once you consider the
07:07: default as well so
07:10: the the model that we looked at in the
07:12: course is
07:13: uh you know sort of in this regard of of
07:15: trying to adjust for the default
07:17: and the value of debt
07:22: and then value at risk is another
07:28: type of uh
07:32: yeah i guess we can call it a model it's
07:34: you know i don't know if it's much more
07:36: than a calculation but
07:37: um it's trying to quantify
07:42: what's the maximum that you're going to
07:45: lose
07:47: with a certain probability like i'm 95
07:51: confident i'm not going to lose more
07:52: than a thousand dollars in one day
07:55: are the kind of statements that you can
07:57: make with the
07:59: vir analysis we did actually look
08:03: at monte carlo simulation and within
08:07: monte carlo simulation we looked at
08:10: evaluating the different quantiles of
08:13: the distribution of the outcome and that
08:15: actually will achieve
08:17: this same value at risk concept
08:20: but there are also ways to go about that
08:22: without doing a monte carlo simulation
08:24: in certain contexts such as portfolio
08:27: settings
08:32: and again that's not a comprehensive
08:34: list of financial models that's just
08:36: kind of the most main ones that you see
08:38: commonly out there
08:40: that we didn't cover in the first course
08:44: um and so i'm giving some
08:48: links here in the slides so definitely
08:50: download the slides from the course
08:51: website to look at
08:53: these resources and we have a few here
08:57: that are excel based resources
09:01: so right now as far as free financial
09:04: modeling resources out there
09:06: the vast majority are focused on excel
09:09: um
09:10: so it can be useful just to get an idea
09:12: about the models and learn about
09:14: you know the the finance side of things
09:16: that goes into the model
09:18: and then you can try to go and recreate
09:19: it in python if you're interested in
09:21: that
09:23: or wait for when i'll be releasing
09:26: videos on doing some of these things in
09:27: python
09:28: um i also found a couple free python
09:32: financial
09:33: modeling related resources um
09:38: what i've seen in these is that they
09:39: don't tend to have very good
09:42: coding standards um that
09:45: the authors of these courses are
09:48: certainly know what they're doing they
09:50: certainly
09:51: have good finance experience but they're
09:53: maybe uh you know not as advanced
09:55: working with python and so
09:57: don't follow as as good of coding
09:59: conventions
10:01: as we do in this course
10:05: so that's a quick overview of some of
10:08: the main types of financial models that
10:11: we didn't cover in the first course but
10:13: i hope to cover
10:14: in the advanced course
10:18: and some resources for you to go out and
10:20: learn these things on your own as well
10:22: so thanks for listening and see you next
10:26: time

00:02: hey everyone
00:03: this is nick nirovertis teaching you
00:05: financial modeling
00:06: today we're going to be learning about
00:08: data pipelines
00:09: for financial modeling this is part of
00:12: our introduction
00:13: to the advanced financial modeling with
00:16: python course
00:19: so pipelines
00:23: uh basically we can think of data
00:26: pipeline
00:27: as what gets the data into your model
00:31: your model has all the logic on the
00:34: inside but you still need
00:36: the inputs into the model the data in
00:38: order to
00:40: get some kind of conclusion out of the
00:42: model um
00:44: and so sometimes your model is very
00:47: hypothetical and you're just putting
00:50: inputs in
00:50: and then you don't really need a data
00:52: pipeline but sometimes
00:54: you are pulling in financial data
00:58: stock prices uh you know other
01:02: other sources of data and you need to
01:05: process them
01:07: maybe you need to put different sources
01:09: together maybe you need to clean things
01:11: up
01:12: maybe you need to aggregate things in
01:15: some way
01:17: in order to actually work with your
01:19: model
01:21: and the data pipeline
01:26: is there whether you automate it or not
01:29: uh you can do a manual data pipeline
01:33: um but there are definitely advantages
01:36: to
01:36: automating it so we we think about
01:40: generally
01:42: two main uh sections
01:45: of a data pipeline one is the collection
01:49: of the data how do you get it in the
01:51: first place
01:52: and the other is what we call
01:55: wrangling the data which is a process of
01:58: cleaning the data up
02:00: and reformatting it in such a way that
02:03: it's ready to be used
02:05: by your model
02:09: so again you can do all this manually
02:13: um and that's what a lot of people are
02:16: doing
02:16: especially with excel models
02:20: um but you can
02:23: save yourself a lot of time by
02:26: automating these steps
02:27: um but you do have to consider how this
02:31: model is being used
02:33: if you're you know using this model
02:36: to generate a report every single week
02:40: and every week there's 30 minutes
02:43: of manual work to do this data pipeline
02:46: to go
02:48: get the data that you need and then uh
02:51: put things together and modify it in a
02:53: way that's
02:53: ready for your model you're spending a
02:55: half an hour every week doing this
02:58: um well maybe it makes sense to automate
03:01: that
03:02: maybe spend a few hours one time to
03:04: automate it
03:06: and the results of that are going to pay
03:09: off over time because then you're not
03:10: spending that 30 minutes every week
03:13: you put the cost in one time to automate
03:15: it and then
03:17: it just goes and it runs on its own you
03:19: click button and you've got the report
03:21: you don't have to worry about the data
03:23: um but uh
03:27: you know if this is a model you're just
03:29: going to use one time
03:30: or you're not re-running it very often
03:33: then maybe it doesn't make sense to go
03:35: through and automate all this
03:36: i mean if you want to do it for a
03:38: learning exercise sure go ahead
03:40: but ultimately the main the main thing
03:42: with the automation here is you're
03:44: trying to save time
03:45: and so if you're going to spend way
03:46: longer automating it than just doing it
03:49: manually
03:50: then probably just do it manually
03:53: but there are other advantages to the
03:55: automated approach
03:56: beyond just saving time
04:00: one is that you are going to eliminate
04:04: the possibility for
04:06: human error you know as long as you
04:10: write the code correctly
04:12: then it's going to do the exact same
04:13: thing with your data every time
04:17: and so you're not going to have to worry
04:18: about accidentally missing a step in
04:20: your process
04:22: or you know handling one one row of the
04:25: data
04:26: accidentally differently than all the
04:27: others or something like that
04:29: which could cause a mistake in your your
04:31: model and and
04:32: the report from your model so if it's
04:35: all automated
04:36: you're gonna expect to get the same
04:38: results every time
04:41: and another uh good advantage is that it
04:44: can open up new possibilities
04:47: because maybe you know you're running
04:48: this report every week and
04:50: um you know everyone only considered
04:53: ever doing it weekly because it does
04:55: take 30 minutes of manual effort to put
04:57: it together
04:58: but now that you could click a button
05:00: and you get the report
05:02: well maybe you just set that up on a
05:04: schedule and now
05:05: every hour that report is generated and
05:07: everyone always has
05:09: the most timely information possible
05:13: and nobody would have ever have dreamed
05:15: of doing that before because
05:17: you know basically it would become
05:18: someone's full-time job to keep
05:20: generating that report
05:21: and now it's just automated it happens
05:23: automatically in the background
05:26: um so there's a lot of value
05:29: in automating your data pipeline
05:33: but again it there's trade-offs and if
05:36: you're going to spend 10 hours to
05:37: automate
05:38: to save you know five minutes that
05:40: you're going to do a few times
05:42: it probably doesn't make sense
05:46: so looking at the data collection side
05:48: um
05:50: we can get data into our models from a
05:53: number of different ways
05:56: usually you're going to be accessing the
05:59: internet in some way to get the data
06:02: whether that's from a website or it's
06:04: from you know
06:05: shared server where someone has an excel
06:07: file or it's from a database or from an
06:10: api
06:12: you know all these are ultimately going
06:14: over the internet at some point to get
06:15: the data
06:16: [Music]
06:18: um
06:20: and when we think about data which is on
06:25: websites um if you can manually get that
06:29: data somehow
06:30: through a website then you can automate
06:32: that process
06:33: via web scraping so whether that's you
06:36: know
06:37: going to some site and downloading some
06:39: file
06:40: or it's actually you know there's a
06:42: table on some site and you want to
06:43: extract the data from that table
06:45: um or even just you know random piece of
06:48: information on a web page
06:50: and you want to um you know look at 3
06:52: 000
06:53: different of these similar web pages and
06:55: get that same information out of each
06:56: one
06:57: you can do all these things with web
06:59: scraping
07:00: um so
07:04: it doesn't even have to be structured um
07:07: you know you could um
07:10: go to say yahoo finance and just grab
07:14: some of the key statistics
07:16: and then do it for every every company
07:19: that yahoo finance has and have
07:20: thousands and thousands
07:22: of companies in your data set all
07:24: through this
07:25: web scraping process though
07:28: i'm not going to endorse specifically
07:30: using yahoo finance they do have
07:33: terms of service against this but i'm
07:36: just
07:36: giving that as a possible example
07:40: um another source of
07:44: common source of data is through apis
07:47: so there you send a web request to the
07:50: api
07:50: and it responds with the data
07:54: usually in either a json or an xml
07:58: format and then you can bring that into
08:01: your model
08:04: um and for
08:08: um both web scraping
08:12: and or accessing apis
08:16: you can use the request package in
08:19: python
08:20: it's an easy way to send web requests um
08:23: so if you have a website that's very
08:26: simple
08:26: it doesn't uh use javascript in order to
08:30: load and display the data then request
08:33: is a good fit in order to
08:36: get that web page and extract the
08:38: information and
08:40: if it's a site that does use a lot of
08:43: javascript to display the data
08:45: or you just really prefer to work
08:49: with a browser instead of like the
08:52: command line interface
08:54: selenium is a package which is useful
08:58: for that because
09:00: it actually drives a web browser so you
09:02: can have chrome or firefox
09:05: just up on the screen and you run some
09:07: code and you see
09:09: uh that the page is changing in firefox
09:11: or you're pulling information out
09:13: etc and so it's a nice like kind of
09:16: visual way to go through it you can
09:17: actually see what happens in the browser
09:19: as you run the code
09:22: [Music]
09:23: and then databases
09:26: are another general way that you're
09:29: going to get
09:30: information into your model
09:33: and typically sql databases are the most
09:36: common
09:38: business databases out there sometimes
09:42: it's nosql databases and there
09:44: are packages which help work with those
09:46: as well
09:47: depends on which database but sql
09:50: is more general more common
09:54: and you can use the same approaches
09:57: regardless of
09:58: what type of sql database it is
10:02: so you're you're not going to get 100
10:06: away from sql like sql
10:10: is a query language
10:14: that lets you write
10:17: these queries which are going to extract
10:19: information from a database
10:21: um or update the database and things
10:23: like that
10:25: um so you are still going to have to
10:27: know a little bit of sql
10:29: or at least understand the basics
10:33: but python can help you
10:38: work with these sql databases such that
10:40: you don't actually have to write
10:42: sql code you can use python
10:46: you can use sql alchemy which lets you
10:49: create
10:50: sql queries with python code
10:54: and pandas also has a read sql
10:58: function so if you just want to bring in
11:02: one database table and bring it into
11:05: your model
11:07: then pandas is going to be a good
11:09: approach for that you can just
11:10: read it in and if you need to do more
11:13: complex queries
11:15: across multiple tables and things like
11:16: that then
11:18: sql alchemy can be a good choice to help
11:20: you with that
11:23: also if you um need to take the result
11:27: of your model and store it into a
11:28: database then
11:30: sql alchemy is also more helpful for
11:33: that than panas
11:39: so that's the data cleaning side and
11:41: then looking at the data wrangling side
11:43: of data pipelines
11:45: so we have already worked with pandas
11:48: in the first course and that is going to
11:50: be your best
11:51: general purpose uh package to use for
11:54: wrangling data because
11:56: you can do so many different
11:57: manipulations of the data with it
12:00: um so that's kind of the gold standard
12:02: in python for wrangling data
12:05: but we didn't cover it in the necessary
12:08: detail
12:09: to cover you know everything that you
12:11: would expect to run into in data
12:13: cleaning
12:15: so i'll give some resources on where you
12:17: can learn more
12:18: about pandas to cover all these cases
12:22: some of the main areas we didn't cover
12:24: but are useful
12:26: for this are um
12:29: we covered a little bit on selecting
12:31: data but you know more advanced
12:33: selecting of data merging different data
12:36: sets together um
12:38: grouping and doing aggregations within
12:42: those groups
12:43: like you know maybe you have sales for
12:46: each
12:46: uh you know store in your company and
12:49: you want to get
12:50: sales by region so group
12:53: by the region and and some across the
12:56: stores
12:59: and reshaping the data in different ways
13:02: and that includes
13:04: resampling if you have some time series
13:07: and you need to change the frequency of
13:09: the time series
13:12: um so the reason this is not called just
13:15: data cleaning
13:17: is because cleaning generally refers to
13:20: well you know if there's missing values
13:22: in there you need to remove
13:24: or there's uh you know invalid data in
13:27: there
13:27: like errors or there's other outliers
13:30: you want to remove
13:31: that part is generally referred to as
13:33: cleaning
13:34: um whereas there's the other side which
13:38: is
13:39: you might have perfectly cleaned data
13:41: but it's still not
13:43: in the structure that you need for your
13:44: model
13:46: so then this kind of reformatting of the
13:48: data
13:49: um by combining it with other data
13:51: aggregating
13:52: um selecting different parts of it etc
13:56: um that's kind of the data reformatting
13:59: side of things and together they make up
14:01: the data wrangling
14:04: one other thing i just want to mention
14:06: in here that helps with
14:08: the data cleaning side of things
14:12: is regular expressions so regular
14:14: expressions are actually
14:16: their own kind of mini programming
14:18: language on their own
14:20: uh exactly they're actually supported in
14:22: a lot of different
14:23: programming languages with the same
14:25: syntax
14:26: um and their ways of matching different
14:30: strings and extracting parts out of
14:32: those strings
14:33: so especially in the context of
14:37: web scraping where you're just pulling
14:39: in a you know
14:40: big html file and you want to extract
14:43: certain parts of it
14:44: these are really useful and also
14:47: sometimes you just
14:48: get you know choosing your data
14:52: which this can help with like
14:56: you know maybe there's a percent sign on
14:59: the end you got to remove that and then
15:01: um you know convert it into decimal
15:04: um so this can help with things like
15:06: that
15:10: and so i'm giving you a number of
15:12: different
15:13: resources here to help you learn these
15:15: topics
15:16: in the meantime until i'm able to post
15:19: additional lectures
15:20: on uh focusing on these topics
15:23: so um there's a couple resources which
15:28: are related to the web scraping
15:30: with browser um so just an introduction
15:33: to selenium
15:35: um and then there's this other python
15:37: package called helium
15:39: which makes a little bit easier to use
15:42: selenium
15:43: so i would kind of look at the first one
15:45: just to get an understanding of
15:47: what all this is and then look at the
15:49: second for maybe an easier way to do it
15:52: um and then also looking at
15:56: um requests which which helps you with
15:59: this kind of more basic web scraping as
16:01: well as
16:01: accessing apis
16:05: and couple resources on pamus
16:10: so the introduction to pandas which
16:14: uh has a lot of stuff we've already
16:16: covered with pandas but also
16:18: gives quick intros on the remaining
16:20: topics and then
16:22: you know the full um
16:25: uh cookbook in pandas which gives you
16:27: strategies for for a bunch of more
16:30: advanced uh data pipeline related tasks
16:36: a couple resources on regular
16:39: expressions
16:41: i think it's useful to go through an
16:43: intro just to understand them
16:46: but then they are somewhat complicated
16:50: i myself even generally pull up the
16:53: reference
16:53: when i write regular expressions so it's
16:56: nice to have that
16:58: um and then
17:01: a few resources on sql alchemy
17:04: i'm giving an overview um
17:07: as uh you know getting started with it
17:10: and then the
17:11: full documentation as well
17:14: so that covers an introduction
17:18: to data pipelines and financial models
17:22: and i hope in the future to release
17:26: more dedicated videos on
17:31: both uh data collection and
17:34: uh wrangling and looking at web scraping
17:37: and all of these more individual topics
17:39: but you have these resources to go off
17:42: of
17:42: in the meantime so thanks for listening
17:46: and see you next time

00:02: hey everyone
00:03: this is nick dear brotis teaching you
00:04: financial modeling
00:06: today we're going to be talking about
00:08: advanced mathematical tools
00:10: for financial modeling this is part of
00:13: our
00:13: lecture series that introduces the new
00:17: advanced
00:17: financial modeling with python course
00:20: and wraps up the prior financial
00:23: modeling with python and excel course
00:27: so we
00:30: um already covered um you know kind of
00:33: the basic
00:34: mathematical tools for financial
00:36: modeling
00:38: in the first course um
00:41: that includes algebra some basic
00:44: probability theory
00:45: and some basic kind of statistical tools
00:49: um including regressions standard
00:52: deviation etc
00:55: um and in general
00:58: this is going to get you through most
01:00: financial models
01:02: most financial models don't have very
01:04: complicated math
01:05: in them um it's typically mostly algebra
01:10: and a little bit of probability and
01:11: statistics
01:13: um now some of them do
01:17: definitely take more math um derivatives
01:20: models
01:21: are a good example especially looking at
01:24: options
01:25: um and you know any more exotic
01:28: derivatives
01:30: um they certainly take more complicated
01:33: math
01:34: um then also if you're going to build
01:38: some more
01:39: really custom financial models you might
01:41: end up doing
01:42: quite a bit of math but for
01:45: most of the models that you're going to
01:47: see you know thinking about
01:49: most of the models we talked about in
01:52: the other main financial
01:54: models we didn't cover um
01:57: most of those are not going to really
01:58: take any additional math tools beyond
02:01: what we've learned
02:04: but i think it is still useful to cover
02:06: these basic tools
02:08: or more advanced tools
02:12: in case people do end up working on
02:15: those models
02:16: which are more mathematical
02:19: so one which which is um
02:24: useful in a lot of different settings
02:27: is optimization so optimization
02:30: lets you maximize or minimize some
02:33: quantity in your model and
02:37: often in finance we want to do that
02:40: right we want to
02:40: get the most profit or mpv
02:44: we want to have the least risk or least
02:46: loss
02:48: and so optimization out of all the math
02:52: tools is definitely
02:53: the most relevant to the most financial
02:56: models
02:58: and in python we can use the scipy
03:02: library to help us with optimization
03:05: it's it's kind of the standard library
03:07: for doing optimization in python
03:10: um and
03:14: in general when you think about
03:15: optimization
03:17: and we're saying maximize or minimize
03:19: here
03:20: but when you look you'll find generally
03:22: just uh people talking about minimizing
03:25: and not about maximizing
03:28: and similarly in scipy you'll see
03:30: minimization functions but
03:32: not maximization functions
03:35: and that's because minimization and
03:38: maximization are actually the same
03:40: thing
03:44: and you can
03:47: um make them equivalent to each other by
03:50: just adding a negative sign
03:52: um you just take your your
03:56: everything that you want to maximize
03:57: function you want to maximize you know
04:00: your model function which outputs the
04:01: mpv
04:03: you want to maximize that mpv well you
04:06: just
04:06: write one more function which takes the
04:09: negative
04:11: of that result and returns it
04:14: and now you want to max minimize that
04:17: and that's going to maximize the mpv
04:21: so you always minimize if you want to
04:23: maximize something
04:25: just add a minus sign for it
04:29: um then
04:31: [Music]
04:33: where i was mentioning the you know
04:34: really custom complex
04:36: financial models that's where computer
04:40: symbolic algebra system is helpful
04:44: so if you have a lot of complicated
04:47: algebra
04:48: going on in your model or calculus you
04:51: know you need to take derivatives
04:52: integrals
04:53: of symbolic equations uh
04:57: you can use senpai in python to help
05:00: with that so you can actually
05:02: have equations as code and
05:06: you can you know uh
05:10: combine different equations solve
05:11: systems of equations you can
05:14: take derivatives and integrals um
05:17: etc so and you just work with these
05:20: things as python objects
05:22: so you can like have a list of equations
05:25: and iterate through that list and do
05:27: things with each of the equations
05:29: um and you can also take any of these
05:33: uh equations symbolic equations
05:37: and convert it into a python function
05:40: which is going to you know take all the
05:43: inputs of the
05:44: variables in the equation and give you
05:47: uh
05:48: the result of that so
05:51: very useful if you have some complicated
05:53: symbolic math
05:54: that you need to do
05:57: uh then we also have
06:01: levenshtein distance so this
06:04: is a calculation of how similar
06:08: two different strings are um
06:12: so you know it would say like cat
06:15: is similar to bat but cat
06:19: is not similar to remote
06:22: um so it gives you a numeric score to
06:26: quantify this
06:28: um so this is useful for financial
06:31: models mainly in the context of the data
06:33: pipelines
06:35: in that you can
06:39: say extract
06:44: you know maybe there's some some noise
06:45: in your whatever data you're collecting
06:48: such that um you know say it's like
06:52: uh you scanned in some financial
06:54: statements on paper
06:56: and now you've done um optical character
06:59: recognition ocr
07:01: and now you've got all that
07:04: represented electronically but there
07:05: were some errors and transferring that
07:07: over
07:09: so this
07:12: edit distance leverage time distance you
07:14: know you could um
07:16: use that on say the statement items and
07:18: if somebody doesn't match up
07:20: well maybe it still has a 95 similarity
07:22: and so you can still match it up
07:25: um a lot of different settings where
07:28: that's useful
07:29: but mainly in the data pipeline process
07:33: in the context of financial models
07:37: and then looking more specifically at
07:39: statistics
07:42: additional tools so we already covered
07:45: ordinarily squares ols
07:46: regressions and if someone just says run
07:50: a regression
07:50: that's generally what they're talking
07:52: about um
07:54: so that covers the majority of cases
07:58: but there are a lot of other regression
08:01: models
08:02: out there
08:05: you know there are full courses out
08:07: there econometrics courses on
08:10: all the different types of models that
08:11: you can run and how you can
08:14: get conclusions and predictions out of
08:16: them um
08:19: it's definitely outside the scope of
08:21: this course to discuss all the different
08:22: possible ways
08:24: um but i'll just mention a couple here
08:26: which are useful
08:28: uh logistic regression uh
08:31: is useful when your dependent variable
08:34: whatever you're trying to explain is a
08:37: probability
08:38: itself like say you're trying to
08:41: determine what affects the probability
08:43: of default
08:45: um then using a logistic regression
08:47: would make sense
08:50: and then panel regression with fixed
08:54: effects
08:55: is a very nice technique
08:58: for when you have multiple different
09:01: things that you observe
09:03: over time so if you have
09:06: multiple different companies financials
09:08: over time
09:09: multiple different stock prices over
09:11: time et cetera
09:14: and you want to run a regression with
09:16: those data
09:17: then panel regression is generally a
09:20: good fit
09:21: and fix effects basically allow you to
09:24: control
09:24: for whatever is not changing
09:28: within these companies over time
09:33: or whatever you know
09:37: whatever happens in a certain time
09:38: period that affects all the companies in
09:40: that time period
09:42: it can also help you control for that um
09:46: so definitely take a look at that if
09:48: you've got multiple different things
09:50: that you're tracking over time and you
09:51: want to do a regression on that
09:56: i mentioned back in the forecasting
09:58: lecture
10:00: that we didn't cover a lot of different
10:03: time series
10:04: models so you can go back and look at
10:07: that lecture i gave some resources there
10:09: on how you can go
10:10: learn about additional models there
10:15: and then um machine learning and ai
10:19: are useful to classify and predict
10:24: different quantities so classification
10:26: is about
10:28: you know assigning into groups um
10:32: you know is this is this picture
10:35: of a cat or is it not of a cat uh that's
10:39: classification and then predicting
10:40: prediction is about trying to determine
10:43: the specific quantitative value of
10:45: something
10:46: so you might be trying to predict
10:48: tomorrow's stock price
10:51: and you can use a machine learning model
10:53: for that
10:55: or you could be trying to classify is
10:57: the stock going to go
10:58: up in the next period or is it going to
11:00: go down in the next period
11:04: so and there's a lot of different
11:06: applications
11:08: for this and it
11:11: sounds a lot more complicated than it is
11:15: to carry out certainly it's a whole
11:17: field
11:18: there's a lot of complication there but
11:20: there are
11:21: high-level packages out there that make
11:23: this process fairly easy
11:26: for the vast majority of tasks that you
11:29: would
11:30: want to apply this to if you need to
11:33: have a really really high performance
11:35: model
11:36: or it's for a very specialized task
11:39: then um you know there's going to be a
11:42: lot of complicated work to go into it
11:44: but
11:45: in general uh for probably 99
11:49: of of potential applications
11:53: it really is not difficult to build
11:55: these if you can run an ols
11:57: regression with stats models you can run
12:00: their machine learning model with
12:02: scikit-learn
12:03: now it does take a little more knowledge
12:06: to understand when you should apply
12:08: each model in what situation but there
12:10: are also
12:12: auto machine learning packages which
12:15: kind of
12:16: go through that process for you
12:20: so that can reduce the entire machine
12:21: learning process
12:23: once you have your data prepared and
12:24: ready to go
12:27: then just down to like four or five
12:28: lines of code
12:30: um so a lot of people get threatened by
12:33: just
12:33: hearing ai it sounds really complicated
12:36: um but
12:40: people have automated so much of this
12:42: process that
12:43: it's not that difficult as an average
12:46: user of machine learning
12:51: so then um the resources i'm showing
12:54: here
12:54: that you can use to learn these topics
12:56: in the meantime until i'm able to
12:58: post any more particular lectures on
13:00: them we have
13:03: uh how to approach optimization using
13:05: scipy
13:06: how to use senpai in order to do
13:09: computer algebra
13:10: and calculus and things like that
13:13: we can use the fuzzy wuzzy package in
13:16: order to calculate levenshtein distance
13:18: in an easy way
13:21: we can look at
13:24: doing logistic regression using stats
13:27: models and this is kind of a softer
13:29: introduction
13:29: to that same thing with panel regression
13:34: so there we can use a package called
13:36: linear models
13:38: which is focused almost exclusively on
13:42: panel
13:43: approaches and
13:46: there's a uh basically a full list of
13:49: the models that are available in staff
13:50: models which is
13:52: quite a few um and then
13:55: linear models also has additional models
13:57: beyond the basic panel regression
14:00: um and there's some additional
14:02: statistics related tools in scipy that i
14:04: like there
14:05: um and then i added um a few different
14:09: resources here on machine learning
14:11: um so just kind of a general um
14:14: you know light introduction to it a
14:17: couple different resources for that
14:21: and then looking at
14:26: using a couple different libraries so
14:28: generally
14:30: scikit-learn is the kind of
14:34: gold standard for easy machine learning
14:37: in python
14:38: as long as you don't need it to be
14:40: really high performance
14:42: um and then keras has emerged as
14:45: the um you know easy high-level library
14:49: for doing
14:49: deep learning which is what people
14:52: generally refer to
14:54: uh are referring to when they say ai
14:59: and did i mention this
15:02: auto machine learning where
15:05: [Music]
15:06: you don't even have to pick what model
15:08: you're going to use like that part is
15:10: also automated um
15:12: there's this package called auto sklearn
15:16: where you just put a few lines and you
15:18: have a well fitted uh
15:19: machine learning model so um
15:23: pretty interesting that we've hit that
15:25: point in development
15:26: in that field that you really don't
15:29: have to know much at all and you can go
15:32: and apply machine learning
15:35: so that's a quick introduction
15:39: to more advanced mathematical tools
15:42: which are relevant to financial modeling
15:47: and again i hope to be able to post
15:49: additional lectures
15:50: on these topics more specifically but
15:52: you have these resources to go off for
15:54: for now so thanks for listening and see
15:57: you next time

00:02: hey everyone
00:03: this is nick dearbortis teaching you
00:05: financial modeling
00:06: today we're going to be learning about
00:09: how to
00:09: improve the presentation of python
00:13: models this is part of our lecture
00:15: segment that introduces
00:17: the advanced financial modeling with
00:19: python course
00:20: and closes out the financial modeling
00:23: with python and excel course
00:26: so we um
00:31: in the first course the financial
00:33: modeling with python excel course
00:35: we have just been focusing on um
00:39: having the model in a jupyter notebook
00:42: and
00:43: uh doing a little formatting on the
00:45: output within the jupiter notebook
00:47: so turning out strings that
00:51: explain the result rather than just
00:54: showing a number
00:56: using data frames and styling the data
00:59: frames
01:00: um using number formatting to get the
01:03: numbers formatted appropriately
01:04: using plots in order to add some visuals
01:09: to it
01:12: but we didn't really go beyond that
01:15: um and when we think about the excel
01:18: side of things
01:19: it's very straightforward right like
01:22: uh the model
01:25: is what you see um and so if you just
01:28: kind of organize things well in the
01:30: model
01:31: and you format it well um in excel
01:34: then that's gonna be all you really need
01:36: to do and that's kind of the end of the
01:38: story
01:40: but for python it's definitely more
01:44: complicated um
01:47: in terms of how you're going to present
01:49: your results
01:51: because there's a lot of different
01:52: possibilities
01:55: so on one hand it can be
01:59: you know some additional steps to get
02:00: your model ready
02:02: results from your model ready to present
02:04: to someone else
02:06: but on the other hand you have such a
02:09: larger
02:10: uh array of options and possible
02:13: ways that you can present your model
02:18: and some of them don't
02:21: really take uh much work at all like i
02:24: mean
02:24: you can already go with the way that we
02:26: covered in in the first course of just
02:28: you know having everything in the
02:29: jupiter notebook as long as you
02:32: have all the clear sections uh and you
02:34: have the markdown in there kind of
02:37: explaining what's going on
02:39: that's still a pretty good presentation
02:40: medium it's not bad
02:43: and it doesn't take much extra effort um
02:47: that's kind of the easiest
02:50: method um
02:54: but at least at least i guess ideal
02:57: for the end consumer of your model if
03:00: they're a non-technical
03:02: consumer um because
03:05: you know when you look at an excel model
03:08: all the formulas are hidden unless you
03:10: click into cells
03:11: but when you look at a jupiter notebook
03:13: all the code is there
03:15: no matter what um and so someone
03:18: who has no idea about python or what
03:22: you're doing in this model is just
03:24: trying to read through and get the
03:25: results um
03:27: you know they're gonna have to go
03:28: through that code as well and you can
03:30: tell them just you know ignore the code
03:32: but it's still in there
03:35: and it can be distracting from the
03:38: results
03:39: um so we'll discuss a few different
03:42: approaches we can take with python
03:44: to present your results um
03:47: going from the extremes of you know just
03:51: have everything in one jupiter notebook
03:53: they can just skip over the code uh to
03:56: all the way to
03:58: uh creating actually a web application
04:01: where they can interact with your model
04:04: by just changing the inputs and seeing
04:06: all the outputs right there
04:07: dynamically updating and everything um
04:11: but of course that takes the most effort
04:14: to get there
04:15: um and so we'll cover some options in
04:17: between as well
04:21: so one thing which is quite simple
04:24: that we can do um so this is just going
04:28: one step beyond everything in the
04:29: jupiter notebook
04:31: um is to try to just separate out
04:34: some of that logic um so
04:38: you um just take
04:42: all the main classes and functions in
04:44: the model
04:45: and you put them into separate dot py
04:48: files
04:49: and the python modules and that way you
04:52: can
04:52: import those into the jupyter notebook
04:55: but it's not going to
04:56: show all of the functioning class
04:58: definitions
04:59: in the notebook um so then it's
05:03: you know just you import a couple things
05:06: maybe it's even just one function which
05:07: is just
05:08: you know run your model and then it
05:10: spits out all of the
05:11: output from it um and then you know
05:14: there's only a couple lines of code in
05:16: there so it's really not distracting at
05:18: all
05:18: to a non-technical person all your code
05:21: is just offloaded into these separate
05:23: python files
05:27: so this already goes a long way
05:30: to making your model more readable
05:34: for a non-technical consumer but one
05:38: drawback you still have here is it's
05:39: still a jupiter notebook
05:42: and so they still have to have python in
05:44: their system
05:46: they still have to have jupiter set up
05:49: and everything
05:51: and have to understand how to open a
05:53: jupiter notebook which
05:55: um you know at this if you've gone
05:57: through the first course it's
05:58: straightforward at this point right but
06:00: you know when you got started with that
06:02: course you probably didn't know how to
06:03: open jupiter notebook either
06:05: and so you know you would then have to
06:07: go explain this to your boss or whoever
06:09: how to even open this thing um
06:13: and so there's still drawbacks with this
06:16: approach
06:19: so kind of the next way going towards
06:22: making it easier and cleaner for the
06:24: non-technical person
06:26: but taking a little bit more work to get
06:28: there is going to creating reports
06:31: um so if the
06:35: um consumers of your model don't need to
06:39: play around with it at all they just
06:41: want to get you know what are the
06:42: results
06:43: from you running the model then reports
06:46: are a good fit
06:50: and there are three different
06:53: um general ways that you
06:56: can go to making kind of a
07:00: prepared report um in addition to
07:03: outputting to an excel file so you can
07:05: always output it to an excel file
07:08: and um you can
07:11: even do some formatting from the python
07:14: code into the excel file
07:17: so that's one route
07:20: and then you can go where you don't even
07:22: need to have excel
07:24: to view the results which the main
07:27: approaches there would be
07:28: html and css latex
07:31: and going directly to a pdf
07:37: so if your ultimate goal is just to get
07:39: a pdf
07:40: then you can just go directly to that
07:43: but also
07:44: both the html and css approach and the
07:46: latex approach
07:49: are going to allow conversion into a pdf
07:52: as well
07:54: so you know generally personally i have
07:57: not
07:57: tended to go for the direct pdf
07:59: solutions
08:01: because i can go for one of the other
08:03: formats
08:04: and then i'm not only able to have it in
08:07: a pdf but also in other formats as well
08:10: um so html css
08:13: natively can be loaded up in a browser
08:16: um
08:17: so you can view it like a web page and
08:19: then
08:20: uh latex can also be converted to html
08:24: and so you can
08:25: convert it to pdf view it that way or
08:27: convert it to html css
08:29: and view it in a web browser
08:34: and
08:39: in building this report basically you're
08:41: going to have some kind of
08:43: layout in the report and then you're
08:45: going to want to drop your data
08:46: into it your results into the certain
08:48: spots and the report
08:50: and this kind of general structure is
08:52: referred to as templating
08:55: and those are generally easier to go
08:57: through doing
09:00: html and latex approaches than with the
09:02: direct
09:04: pdf approach so another reason that
09:07: i don't generally recommend going direct
09:09: to pdf
09:10: but if that is all that you you know
09:13: that's all you're ever going to need is
09:14: a pdf
09:15: and you're not comfortable with html and
09:18: css or latex
09:20: then it can make sense to do that
09:24: um and when we get to the resources
09:27: section i'll talk about
09:29: um some of the packages that are
09:30: generally used for these different
09:34: approaches
09:36: um so then we get all the way to the
09:40: other extreme of the best experience
09:44: for the non-technical user of your model
09:47: um but also the most work on your end
09:51: as the creator of the model to set this
09:53: up
09:54: and that is creating an app out of your
09:57: model
09:58: um which some people
10:02: watching this right now may think i'm
10:04: crazy to say create an
10:05: app out of your financial model um
10:09: it sounds on the service like a huge
10:11: amount of work
10:12: but it's really not um
10:16: there are ways you can actually just
10:18: take an entire jupiter notebook and
10:20: convert it into an app
10:22: with no effort on your end um
10:25: and then there's also ways to extend
10:27: your jupiter notebook
10:29: to make it into an app in a more custom
10:32: way that you
10:33: want um so
10:36: with neither of these approaches do you
10:38: have to go and just you know completely
10:41: like go and learn you know full-on
10:43: software engineering to create full
10:44: stack apps and then totally recreate
10:46: your model
10:47: like that's not what i'm talking about
10:49: here it's
10:50: using some packages which are going to
10:51: help you basically add on to your model
10:54: to convert it into an app
10:57: which is easier than it sounds
11:01: now you can go all the way to creating a
11:04: web app from scratch
11:05: um certainly that's a route to go but
11:08: that's like going even further in that
11:09: extreme direction that's
11:11: probably going to be a lot more work
11:13: than you want to
11:15: uh you know do for this model ultimately
11:18: you know you've you've got your model
11:20: done you just need to show off the
11:21: results
11:22: you don't want to be spending days or
11:24: weeks on end to
11:25: build out a full-on scalable web app
11:30: you can just use these packages to
11:31: convert your jupyter notebook instead
11:35: um the the big advantage of
11:38: publishing this as an app is that the
11:42: uh someone who knows absolutely nothing
11:44: about python
11:46: does not have python on their computer
11:48: um
11:50: and maybe doesn't even know anything
11:52: about financial modeling
11:55: they can play around with your model
11:56: they can adjust the inputs
11:58: they can see how it changes the outputs
12:01: um
12:02: try different things you're basically
12:04: building like a dashboard they can play
12:05: around with
12:07: and try out different things and see the
12:09: results
12:10: um so this could end up saving you time
12:13: if uh
12:14: you have a working relationship with
12:16: your boss where
12:18: you have a model and then you bring the
12:20: results and they say well you know try
12:22: it with these different things and you
12:23: run back and
12:24: change your model around and then
12:25: generate another report and bring them
12:27: that and
12:28: says oh we'll try these other things and
12:30: you're just going back and forth well
12:31: you know
12:32: you could eliminate that whole cycle if
12:34: there's an app that your
12:36: boss could just play around with and see
12:38: all the results
12:40: um so this is definitely the most
12:43: polished way to go as far as presenting
12:45: the results
12:46: but it is uh you know certainly more
12:50: complicated to do that
12:51: so not that complicated to convert your
12:54: jupiter notebook directly to an
12:56: app
12:59: and one other thing i want to talk about
13:02: on
13:03: presenting your results in python is
13:06: um looking at interactive
13:10: plots because we did some some basic
13:13: plots with pandas
13:14: and well even before getting the
13:16: interactivity
13:17: we can make more advanced plots
13:21: customize them in lots of different ways
13:24: take a look at
13:25: the matplotlib library which
13:28: is what pandas uses in the background to
13:30: generate the plots
13:31: so you can do lots and lots of different
13:34: customizations there basically anything
13:36: you can imagine
13:37: you can create a maplotlib very flexible
13:42: um but there's also these interactive
13:46: plots
13:47: where you see the plot but then you can
13:50: zoom into it
13:51: you can select certain points out of it
13:53: and get more information
13:56: and you can interact with the different
13:57: ways maybe there are drop downs to
13:59: change and look at different things in
14:00: the plot
14:02: etc so
14:05: there are a number of libraries out
14:06: there which help with this such as
14:09: bokeh altair plotly
14:14: holoviews there are a lot lots of them
14:17: out there
14:19: and they can make a really
14:22: nice experience for using your model and
14:24: kind of really drilling into the results
14:29: now of course uh the interactivity
14:33: only makes sense if there's actually um
14:36: you know code running behind it if uh
14:40: you're just generating a pdf report you
14:42: can't have that interactivity
14:44: um but if you're if if the
14:47: person viewing your model is running the
14:49: jupyter notebook itself
14:51: then it can work or if you go and create
14:53: an app
14:54: then it can also work um
14:59: and i mentioned hollow views
15:01: specifically
15:02: um has a really interesting plotting
15:05: library
15:06: where not only does it support these
15:08: interactive plots
15:10: uh but also it's it's kind of a
15:13: whole new way to do plotting you
15:16: basically
15:17: just kind of um you tell it things about
15:20: your data
15:22: and then it can kind of understand your
15:23: data to be able to generate the right
15:26: interactive plots
15:28: um so you can still customize things
15:31: but um i find that it can
15:34: generate these interactive plots with um
15:37: very little effort
15:38: in general so i definitely recommend
15:39: checking that out
15:42: and as far as the resources which you
15:44: can go and
15:45: use to learn these topics in the
15:47: meantime before i'm able to go out
15:50: and uh produce lecture videos on them
15:54: there's a couple resources here
15:58: on creating reports html css reports
16:03: and getting that to a pdf
16:07: and also a guide specifically looking at
16:10: jinja to help with this
16:11: templating jinja is a library that's
16:14: made specifically for templating
16:16: regardless of um what the ultimate
16:20: output format is um
16:23: and then i mentioned going directly to
16:25: the pdf
16:27: so you can use report lab for that
16:32: and you can go direct to latex
16:35: using uh the pi ex latex
16:38: library which i am actually the author
16:42: of
16:42: so if you run into any issues with that
16:46: library
16:46: definitely just reach out to me and i'll
16:48: be happy to help
16:51: but it's it's very nice for um
16:55: i use it a lot for generating pdfs from
16:57: my models
16:59: um because you can just create python
17:02: objects
17:04: which ultimately render into latex and
17:07: then
17:07: generate the pdf from it so you don't
17:10: have to think about latex you don't have
17:12: to think about how you generate a pdf
17:14: from latex
17:15: you just create some python objects and
17:17: you ultimately get a pdf
17:18: so it's a pretty nice library to work
17:21: with
17:23: um and then some more resources on
17:27: matplotlib looking at holo views
17:30: as well and then
17:34: some resources on building the apps
17:38: from your model so panel is a library
17:41: that you can use if you want to
17:44: do a little more customization on what
17:46: your app is going to look like how you
17:48: interact with it
17:50: it allows you to you know add little
17:54: widgets and stuff
17:55: to your jupyter model
18:00: tutorial on that as well
18:04: and then voila is
18:07: what i was talking about which helps you
18:09: just
18:10: take your existing jupiter notebook and
18:13: just
18:13: convert it into a web app like
18:15: essentially zero effort required
18:18: um so
18:20: [Music]
18:23: that that's definitely useful if you
18:25: want to get to a web app with as little
18:26: effort as possible
18:29: um and anvil
18:32: and bill is another option for that that
18:35: is not completely free i think that's a
18:39: paid service
18:40: um and then a couple of resources here
18:44: um should anyone want to go and learn
18:47: more full-on full-stack web development
18:51: um to build really custom things
18:54: um which again that's a lot more work i
18:57: would
18:57: not recommend that for the majority of
18:59: people that just want to
19:01: display the results of their model um
19:04: but it is an interesting direction to go
19:05: down if you want to do really custom
19:07: things
19:08: or have a really scalable application
19:13: so that's an overview on
19:17: how you can present your model results
19:19: in
19:20: python and i hope in the future to
19:24: release more videos on each of these
19:26: particular topics
19:27: in this area so thanks for listening and
19:30: see you next time

00:03: hey everyone
00:04: this is nick dearmartis teaching you
00:05: financial modeling
00:07: today we're going to be talking about
00:09: programming skills
00:11: that are useful for more advanced
00:13: financial models
00:14: this is part of our lecture series that
00:16: introduces the
00:18: new course on advanced financial
00:20: modeling with python
00:21: and also closes out the first course on
00:24: financial modeling with python and excel
00:28: so in the first
00:32: course we certainly cover uh you know
00:35: basic
00:36: python programming everyone completing
00:37: that course should
00:39: feel comfortable that um they have kind
00:42: of a handle on basic python
00:46: but we
00:50: still are only getting really kind of a
00:52: quick brush of everything there's still
00:54: a number of different areas of python
00:58: that we haven't explored
01:01: which would be used fairly commonly in
01:04: more general
01:05: programming settings um
01:09: and some of these are going to be useful
01:11: as you go to expand to
01:12: building additional models and data
01:15: pipelines for those models and
01:17: everything like that
01:21: thankfully python is one of those
01:24: programming languages
01:25: where you don't need to be an expert to
01:27: get things done
01:29: as long as you have a handle on basic
01:32: python
01:33: you can manage to work your way through
01:36: most tasks
01:38: and you don't have to you know
01:39: understand
01:41: really advanced um code structures
01:45: which are good for scalability and
01:47: maintenance
01:48: it's good to learn those over time but
01:50: you can just get started just kind of
01:53: throwing some code in there and it'll
01:54: work
01:57: but if you do go and learn better
02:00: structure for your code and better
02:03: and more advanced programming techniques
02:07: then all of a sudden new things become
02:10: possible and things which were difficult
02:12: before become easy
02:15: so there's a lot more
02:18: to learn beyond what we've already
02:19: looked at in the first course
02:24: and beyond just thinking about python
02:26: programming there are also
02:28: general software engineering practices
02:31: that we can look at and learn from
02:35: in order to become better uh financial
02:38: modelers as well
02:42: so looking at some of those um
02:45: general programming things we can learn
02:47: from
02:49: um so these are the kinds of things that
02:52: um you know software engineers that that
02:55: build software all day
02:57: are doing on a day-to-day basis
03:00: and that you don't see as often and
03:03: the finance industry but um
03:07: it's good to learn from these things um
03:09: to become better programmers
03:11: and build better financial models
03:12: because of that
03:16: so um
03:19: if you're going to take one thing away
03:21: from this lecture
03:23: it should be that you should use a
03:25: version control
03:27: version control is a way
03:30: of tracking the code over time in a
03:33: project
03:34: you track not only
03:37: the code over time but all the changes
03:39: that are being made to the code
03:42: and it also allows multiple people to
03:45: work on the code
03:46: a lot easier without
03:50: going into a lot of detail here um
03:54: you basically can create separate
03:56: branches
03:57: of the code which means that
04:01: people can start from the same code and
04:03: go in different directions with it
04:05: and then you can merge those branches
04:06: back together later so both people can
04:09: be working on the code at the same time
04:11: changing different things about the code
04:14: and then you ultimately bring it
04:15: together
04:16: without having to go through a big
04:18: manual process to do that
04:20: most this is going to be automated
04:23: through the version control software
04:27: and because you have this full history
04:30: um you can do things like um
04:33: well i'm gonna just try something really
04:36: experimental
04:37: i'm gonna tear apart the code totally
04:38: change it and then if it doesn't work
04:41: out well i'll just go back to where i
04:43: was before
04:44: you have basically the entire history of
04:47: the project every change that's been
04:49: made
04:49: throughout um so
04:53: this is a really really useful skill to
04:55: learn for programming
04:57: um i highly highly recommend that you
05:00: learn this
05:03: especially if you're going to start
05:04: working in teams for
05:06: your models then it becomes even more
05:09: necessary
05:10: but even as an individual working on a
05:13: project
05:14: it's still very useful because
05:17: uh you can always revert changes if they
05:20: don't work out
05:21: and you can go and try things and you
05:23: know maybe you're you're trying
05:24: something and it's not working out but
05:26: you want to come back to it later
05:27: well you just leave it in this branch
05:28: over here you go back onto the main code
05:31: you can keep uh you know doing whatever
05:34: changes and then
05:35: you know when you have some free time
05:36: come back to this branch and try to get
05:38: it to work out
05:39: and you can even bring over the changes
05:41: that you've made in the meantime from
05:42: the main branch
05:44: um so becomes way way more flexible to
05:47: work with the code
05:48: and you don't worry about losing
05:50: anything
05:52: so i use this for every single uh
05:55: programming
05:55: project that i do no matter how big or
05:58: small
06:00: so i highly recommend that you do this
06:04: and git is
06:07: the gold standard here there used to be
06:09: other options which which people used uh
06:12: you know fairly commonly like mercurial
06:15: and subversion
06:16: uh but git is nowadays what everyone is
06:20: using
06:20: so it's really not even a decision
06:22: anymore just use git
06:24: for your version control um
06:28: and then git
06:31: itself will work just locally on your
06:33: machine not being hooked up to anything
06:36: um but you can kind of uh
06:39: supercharge git by um
06:42: sharing that um repository that git
06:46: repository into some kind of platform
06:51: github is by far the most common
06:54: place and if you look up basically any
06:57: open source project it's on github
07:00: the git repository is shared through
07:02: github
07:03: um and what this allows
07:06: is it makes your code public or you can
07:09: have private repositories as well
07:11: um it allows much easier sharing
07:15: of the code with others so then once you
07:18: have the code on github
07:19: someone else can come and pull that code
07:21: down and make some changes and
07:23: make a request to you know merge their
07:26: changes back into the main code
07:29: and so it enables a lot easier
07:31: collaboration
07:33: in a very organized way
07:39: automated testing is another
07:42: general area of
07:46: a general pattern that that we can use
07:48: that we can
07:49: draw from the software engineers
07:53: and automated testing is a little bit
07:55: meta
07:56: it's writing code which checks that your
07:59: code
07:59: is working properly um so you're
08:03: you know you might think with your model
08:05: you go and you run it and you check and
08:07: you look at the results
08:08: and make sure the results are sensible
08:11: right and that's your
08:12: your testing um but you could also
08:16: say you know i know if i put in this
08:18: input in the model i know i'm supposed
08:20: to get this output
08:21: now you just write some code that says
08:24: hey
08:25: run the model uh get the output from the
08:28: model
08:29: compare that output to my expected
08:31: output
08:32: if those things don't match up then
08:35: throw an error the test fails
08:36: uh if they match up then do nothing the
08:39: test pass is fine
08:42: so then you just run this code which
08:44: tests your code
08:45: anytime you make changes and then you
08:48: can ensure that you haven't broken
08:50: the functionality so this is
08:54: you know basically essential for
08:56: building large applications and so
08:57: software engineers do this all the time
09:00: um but we can bring that over to our
09:02: financial models
09:03: as well especially in larger more
09:06: complex
09:07: financial models that have a lot of
09:08: different parts you can kind of test
09:10: each part
09:11: individually to ensure that nothing is
09:14: breaking as you go and add additional
09:16: changes
09:20: input validation is basically checking
09:23: that the inputs are uh
09:27: in the way that you expect to get them
09:28: so are they the correct data types
09:31: are they in the the type of range that
09:33: you would expect
09:34: you know if it's a retirement model and
09:36: you're putting starting salary if it's a
09:38: negative number
09:39: then you throw an error saying oh uh
09:42: starting salary can't be negative
09:44: or if it's uh you know they try to put
09:47: abc the string for the starting salary
09:50: then you're going to also throw an error
09:52: starting salary should be a number not a
09:54: string
09:57: so it's not you know
10:01: necessary to do this for your model but
10:03: it's nice for when
10:04: other people if you have other people
10:06: just using your model
10:08: directly because they may not
10:11: totally understand what the
10:14: all the inputs are supposed to be and so
10:17: they make made mistakes
10:19: in setting up the inputs and what this
10:21: validation does is it will just
10:23: immediately tell them exactly what that
10:25: mistake is
10:27: you know you you gave a string when it
10:28: should have been a number for the
10:30: starting salary
10:32: versus if you just let it fail in your
10:33: model well it's like
10:35: now you're trying to like add a string
10:37: and a number and it's like oh can't
10:39: add type str to type float
10:42: and then you just see this long stack
10:44: trace and that's what uh
10:46: what the user of your model sees is uh
10:48: this weird error
10:49: and they they think that your model is
10:51: broken they don't think
10:53: that they use it incorrectly they just
10:55: think it's broken because they see this
10:57: weird error they don't understand coming
10:59: out of it
11:00: so if you have that input validation
11:03: then the error is going to say
11:04: exactly what they did wrong and so
11:07: they'll be able to
11:08: fix that rather than coming to you and
11:10: saying hey this thing broke
11:12: can you help me because it broke uh and
11:14: then you go and say oh well you used it
11:16: incorrectly
11:17: here's how you use it uh just you know
11:20: saves you that
11:21: that whole issue
11:25: um and then if you're starting to go to
11:29: this
11:29: you know in the fir in the financial
11:31: modeling with python and excel course we
11:33: generally cover just having everything
11:34: in one jupyter notebook
11:36: and so jupiter is serving as your ide um
11:41: but if you start to go to the structure
11:43: where you're going to offload code
11:44: into separate python files and have a
11:48: really
11:48: more mature project structure um
11:51: then i would recommend going to using an
11:53: integrated development
11:54: environment ide in order to help you
11:58: write that and maintain that code
12:01: um so pycharm and vs code
12:04: are the two that i would recommend they
12:06: are by far the most popular
12:08: in the python space and generally i
12:11: would say
12:13: if you're really focused on writing
12:15: python code
12:16: go with pycharm it's it's really built
12:18: for python
12:20: if you know you're going to be writing
12:22: python code but you're also going to be
12:23: writing in other languages as well
12:26: then vs code can be a better choice
12:28: because it's you know more natively
12:30: multi-language support
12:35: and also if you have very limited system
12:38: resources on your machine then
12:39: probably go for vs code because it's a
12:41: more lightweight editor
12:46: but pycharm definitely does do a better
12:49: job
12:49: specifically with python so that's why i
12:52: recommend it
12:53: if that's primarily what you're doing
12:57: um and then we have this whole concept
13:00: of continuous integration continuous
13:02: deployment or ci cd for short
13:07: and that's basically thinking about all
13:09: the things that you might have to do in
13:11: your project
13:14: like you know for your financial model
13:16: it might be
13:18: running the data pipeline to get the
13:19: data and then running the model
13:21: and then generating the report from the
13:23: model and then you know maybe emailing
13:25: that report to somebody
13:27: you can automate all these steps and
13:30: that's referred to as a ci cd pipeline
13:33: um
13:34: so you can um you know
13:37: do all those things i mentioned for a
13:39: financial model or if you're building a
13:41: python package you can also
13:43: you know deploy that that python package
13:45: or if it's a web app you can deploy the
13:47: web app
13:49: you can have it automatically format
13:50: your code so it looks nicer you can have
13:53: it
13:54: run all the tests the automated tests
13:56: that you've written
13:57: make sure that nothing breaks so this
14:01: is just all about automating as much as
14:03: possible in the process
14:07: so that's the general programming topics
14:08: and then we have some additional python
14:10: topics as well
14:12: um so one thing that we didn't really
14:14: cover
14:16: [Music]
14:17: is is working with files on the file
14:19: system we covered working with excel
14:21: files
14:22: loading them in through pandas and excel
14:24: wings
14:26: but you can just work with more
14:27: generally any kind of file
14:29: using the built-in python modules os
14:33: pathlib and shoe till
14:36: so check those out one basic data type
14:40: we didn't cover in python are sets
14:42: so sets um have
14:45: unique items and they're not ordered
14:49: um so it's just you know you have a
14:52: bunch of
14:53: different things it takes the unique
14:54: ones of those
14:56: but you can also do intersections
14:58: between sets you can do unions
15:01: um you know intersection being what are
15:03: the overlapping things between these two
15:05: sets
15:06: union being you know take all the things
15:08: from both sets
15:09: put them into a new set um et cetera
15:13: so those that definitely have certain
15:15: applications
15:18: um and then there's you know
15:21: we covered a little bit working with
15:22: classes um
15:25: but we didn't cover at all how to
15:28: customize the built-in behavior of
15:32: python objects
15:33: using dunder methods or double
15:35: underscore methods
15:37: um so that's um
15:42: like you know how we we use the fin
15:44: statement
15:45: library in the class and when you look
15:48: at a financial statements object from
15:51: that library
15:52: it prints out the whole income statement
15:54: and the balance sheet right
15:57: so how you know me as the creator of the
16:00: library how did i get it to do that
16:03: when you just look at the financial
16:05: statements in a jupiter cell
16:07: it was setting one of these dunder
16:10: methods
16:11: uh particularly there it's underscore
16:14: underscore
16:15: repr wrapper uh
16:20: is able to uh set that and for jupiter
16:23: you have
16:24: wrapper underscore html which is going
16:26: to be the html representation
16:28: of your object um but this is just an
16:32: example
16:32: you can override basically any behavior
16:34: of a python object
16:36: so you want to add two things together
16:39: and make
16:40: wanna make it display an animation sure
16:43: you can do that
16:45: you override the underscore underscore
16:47: add method
16:48: and that's gonna make it run whatever
16:50: you logic you define there when you add
16:52: two of these objects together um
16:55: so actually in the fin statement library
16:57: you can take two financial statements
16:58: and add them together and it will go and
17:00: add all the different financial
17:01: statement items together
17:04: so i have that logic implemented on the
17:06: financial statements class
17:08: in the dunder add method
17:11: there it has the logic to go through
17:13: each of the statement items and add them
17:14: together
17:16: and then create a new financial
17:17: statements object and return that
17:21: um so you can basically
17:25: totally change the way that you work
17:26: with python by creating really
17:28: interesting packages
17:30: by overriding these thunder methods
17:34: um we
17:37: [Music]
17:39: only looked at one decorator in the
17:40: course that was the data class decorator
17:43: which converts
17:44: a regular class into a data class
17:48: but decorators allow you to modify
17:52: a class or a function so you just place
17:56: it above the definition
17:57: and it will modify it
18:01: so it's definitely a more advanced
18:05: pattern
18:06: but it can be useful in certain cases
18:09: like maybe
18:13: you know you have a bunch of um
18:15: functions in your model
18:17: and normally they don't really print
18:19: anything out you just
18:20: ultimately get the output at the end um
18:24: but you're debugging the model and so
18:26: you want to see
18:27: you know what's getting spit out for
18:29: each step of the model
18:31: maybe you have a decorator which you put
18:34: on the top of every function
18:36: and depending on the value of some
18:38: variable it either
18:40: prints the output or doesn't print the
18:41: output and then you just change this one
18:44: variable
18:45: and then that will make it all of a
18:46: sudden that every function
18:48: is printing its output you switch it
18:50: back and now
18:51: none of them are printing the output
18:54: so lots of different applications
18:56: there's just an example
18:58: um then we have this concept of pickling
19:03: so a pickling is a way to take a python
19:06: object
19:07: and put it into a file such that you can
19:10: later
19:10: in a new python session load that
19:15: file and get your python object back
19:20: so if you have some kind of custom
19:23: classes in your model that you need to
19:25: store
19:26: this can be a good way to do it
19:30: um and then type annotations
19:35: are a way of
19:39: adding a little bit to your python code
19:40: to say what type
19:42: everything is is it a string is it a
19:45: float is it
19:46: a list is a list of floats is it a list
19:48: of strings
19:49: etc um
19:52: and this will make it easier to read
19:55: your code
19:57: because it's clear what type of data is
19:59: flowing through
20:02: and when you use an ide it's going to
20:05: really
20:06: um kind of uh
20:10: make it a lot better experience because
20:14: you'll see in your ide well if you say
20:17: you know this thing is a string
20:19: and then you put a dot on the end of it
20:20: well it will suggest all the string
20:22: methods for you right there
20:24: or if you then try and add that to
20:26: something which you've said as a number
20:27: it will say it'll highlight that
20:29: immediately you haven't even run the
20:31: code but it highlights it immediately
20:32: and says oh you can't add a string to a
20:34: number
20:35: because it understands that one is a
20:36: string and the other is a number it's
20:38: going to know that that will raise an
20:39: error once you do ultimately run it
20:41: and it's going to highlight it before
20:43: you ever even get there
20:45: so you can catch your mistakes a lot
20:46: sooner uh with the combination of an ide
20:50: and type annotations so
20:54: definitely recommend going in that
20:55: direction
20:57: um and then you know again in the first
21:01: course we
21:02: discussed you know just having
21:03: everything in one jupiter notebook
21:05: that's not really a good long-term
21:06: structure you want to split out your
21:09: code into modules and packages so
21:11: so modules are just um text files and in
21:14: in dot py that have python code in them
21:17: and packages are just folders
21:20: which have a certain python module
21:24: called
21:25: init.pui
21:28: and then it has modules inside of it as
21:30: well
21:31: um so nothing too complicated there
21:37: but it helps you keep things really well
21:40: separated and reuse code between
21:43: different models and projects
21:47: and then virtual environments are a way
21:50: of basically
21:52: you know isolating everything for one
21:54: project all the
21:55: packages that you're using in that
21:57: project keeping them separate from
21:58: another project
22:02: so it may not be clear why you would
22:04: want to do this as someone who's just
22:06: getting into python
22:09: but any experienced python programmer is
22:12: going to be using these things
22:14: religiously because they have run into
22:17: issues when they haven't used them
22:19: that's kind of the natural progression
22:21: you just have all these projects going
22:23: everywhere you're not really thinking
22:24: about the environment and then something
22:26: breaks in one project and it affects
22:29: other projects and all of a sudden all
22:31: your things are broken you're just like
22:32: what is going on
22:34: nothing works anymore everything is
22:36: broken on all my projects
22:38: like this is a nightmare and that's why
22:41: virtual environments are really
22:43: necessary here
22:45: if you're only ever going to have one
22:47: python project on your computer
22:49: you don't need a virtual environment but
22:52: as soon as you think about having
22:53: multiple projects
22:54: uh you should definitely consider using
22:56: virtual environments because it totally
22:58: isolates one project
23:00: from another project
23:05: and then looking at um the resources
23:09: so i'm providing a lot of links on all
23:12: these things so you can go out and learn
23:13: them on your own
23:15: i do want to post videos on some of
23:17: these topics
23:19: but in the meantime you'll have these
23:20: resources
23:23: so here's want to get started with git
23:25: and github
23:27: and then there are apps out there that
23:30: make
23:30: working with git and github easier
23:32: github desktop is one of those
23:37: an introduction to automated testing and
23:40: input validation
23:41: [Music]
23:42: the two different ides that i mentioned
23:44: pycharm and vs code
23:47: an introduction to cicd
23:50: and then looking at actually doing ci cd
23:54: using github and github's built-in ci cd
23:58: system github actions
24:02: working with files in python um
24:05: both in intro and going to more advanced
24:07: usage
24:09: um then looking at how to use sets
24:13: um how to work with these dunder methods
24:16: to
24:16: to customize object behavior
24:21: some more resources on data class
24:24: additional things we can do with data
24:25: classes um
24:28: how i can basically achieve uh you know
24:31: the financial statement display
24:33: in the fin statement package in jupiter
24:36: how you can specifically add that
24:38: or whatever you want to display for your
24:40: particular classes
24:44: how you can get started working with the
24:46: decorators
24:47: to modify existing uh classes and
24:50: functions
24:51: um how you can pickle these
24:55: python objects to store them for later
24:57: with pickle and dill
25:01: a introduction to type annotations in
25:04: python
25:05: how to better structure your python
25:07: projects with packages and modules
25:11: an introduction to virtual environments
25:13: and
25:14: why you might want to use them what they
25:15: are um as well as a package called pipi
25:19: and v
25:20: that makes working with virtual
25:22: environments easier
25:25: so that's an overview on additional
25:29: programming topics that are useful as
25:32: you start to get more advanced
25:34: um with financial modeling and python
25:37: so thanks for listening and see you next
25:40: time

00:03: hey everyone
00:04: this is nick dear burtis teaching you
00:06: financial modeling
00:07: today we're going to be talking about
00:10: some extra resources that you can use to
00:12: learn
00:12: about python and financial modeling
00:15: topics
00:16: this is part of our lecture segment
00:18: which gives an introduction
00:20: to the new advanced financial modeling
00:23: with python course
00:24: and also closes out the financial
00:27: modeling with python and excel course
00:30: so um
00:34: here we're just looking at a few
00:36: different resources
00:37: that give general
00:40: help with python as
00:44: well as applying it to financial
00:46: modeling
00:49: so the first one here is hitchhiker's
00:51: guide to python
00:53: so this is useful
00:56: just to give an overview on a lot of
00:58: different python topics
00:59: um so some of this stuff is already
01:01: gonna be covered
01:02: um in the initial course um but it also
01:06: definitely goes further um and gives a
01:09: lot of different basics
01:10: and then also has different areas
01:13: should you need to go into any
01:16: particular
01:17: area of development so you know we
01:20: already talked about how
01:21: web scraping is useful for data
01:24: pipelines and financial
01:26: models um so some of that is there
01:30: here's a section on cicd
01:33: which we also talked about
01:38: machine learning they have some
01:39: information on that as well
01:42: um and some more just good general
01:45: recommendations on how to do things um
01:49: so then we have real python
01:53: real python is uh basically a set of
01:57: like tutorial
01:58: tutorial articles um so they
02:02: you know regularly release these
02:04: articles
02:05: um which have a lot of good content on
02:07: them
02:09: so generally it's kind of targeted at
02:11: like an intermediate
02:13: python programmer and
02:16: they have very in-depth tutorials on
02:19: particular topics and there's a lot of
02:21: stuff on here
02:23: so i really like this as a resource
02:28: then we have automate the boring stuff
02:30: with python so that's actually a book
02:33: but it's available free online
02:36: you you can um just go through and find
02:39: everything here
02:40: online um and
02:44: it covers python basics so you know a
02:46: good amount of this you can probably
02:48: mostly skip through after doing the the
02:51: first course
02:52: um but it's it's really applied to
02:56: you know kind of general things that you
02:58: might want to automate
03:00: um and how to write the particular
03:03: python code that
03:04: does that um so
03:07: really good to get started with with
03:08: just automating
03:10: um you know day-to-day tasks
03:13: this is a really good resource
03:16: and then we have practical business
03:18: python so this is a little bit similar
03:20: to real python and that it's kind of
03:22: like an article
03:23: um format just uh you know
03:27: this uh is created by chris moffitt um
03:30: he just keeps posting articles um
03:33: and it's you know particularly about
03:36: you know applying python in a business
03:38: setting
03:39: um and is generally a little bit
03:43: more introductory focused so you don't
03:46: need to be
03:47: as comfortable in python to read through
03:50: the articles
03:52: so it's another really nice general
03:55: resource
03:56: for python financial modeling
04:00: um so that
04:04: covers the additional just general
04:06: resources and
04:08: this also wraps up our introduction to
04:11: the
04:12: advanced financial modeling course and
04:13: the um
04:15: end of the financial modeling with
04:17: python and excel course
04:19: so going forward i want to
04:23: release videos on all the different
04:26: topics
04:26: that we covered in this introduction
04:29: um but i don't necessarily
04:32: have a particular order yet so i'm
04:35: definitely
04:36: looking for feedback on what people
04:38: would like to learn about first
04:41: so please go ahead and just leave a
04:43: comment about
04:44: anything that you're interested on me
04:47: expanding on
04:48: and any of these topics and you know
04:51: based on that feedback
04:53: i can look at those areas first
04:56: for the lecture topics um
04:59: because we kind of you know hit on all
05:01: the basics now with the first course
05:04: as going into more advanced stuff we
05:06: really can
05:07: can go in any order uh the order is not
05:09: so important so
05:11: i just want to see what people want to
05:13: learn the most first
05:15: and i can hem that direction
05:18: and please subscribe on youtube so that
05:21: you can be notified
05:23: as i release these videos on the
05:26: advanced
05:26: financial modeling topics
05:29: [Music]
05:30: and i hope that everyone enjoys the the
05:33: new course
05:34: and i hope that you enjoy the first
05:36: chords
05:37: as well so i would love to to hear your
05:40: feedback
05:41: um on the first course as well so feel
05:44: free to comment
05:45: about that and yeah thanks
05:49: thanks everyone for listening and i'm
05:51: excited to
05:54: branch off into all these more advanced
05:56: topics with you
05:58: thanks for listening and see you next
06:03: time