Put Options

Introduction

Previously, we have discussed call options, and several strategies for it's trading.

Now, we are going to discuss put options and some of their strategies.

As was mentioned before, this kind of contracts gives to owner right of selling underlying asset for a predetermined price.

Long Put

The first strategy we are going to discuss - is Long Put.

Analogically to Long Call, here trader buys several contracts, and expects that stock price will fall, so there will be an opportunity to earn money by selling stocks for a higher price.

Here is an approximate graphical representation of this strategy:

Here, similarly to the case of Long Call, trader receives profit from exercising options not when stock price falls slightly below the strike price, but when it declines so, that exercising option could allow him to compensate all spendings on contracts plus earn necessary sum.

Here is a code example of computing profit under the specified conditions:


              12345678910111213
            
# Defining all necessary variables
option_price = 1
number_put = 10
strike_price = 30
stock_price = 32
# Defining function `long_put` which will perform computations
def long_put(option_price, number_put, strike_price, stock_price):
  profit = (strike_price - stock_price) * number_put - option_price * number_put
  if stock_price > strike_price:
    profit = - option_price * number_put
  return profit
# Printing computed output
print(long_put(option_price, number_put, strike_price, stock_price))

Short Put

The second strategy - is Short Put.

Here trader expects, that stock price will rise up, so - there is no need in put contracts, and the best option - is to sell them.

Also we should notice, that despite it wasn't mentioned into previous chapter - absolutely analogically could be defined strategy called Short Call, where trader expects, that stock price will fall, and so sells all contracts.

Here is an example of graphical representation for the corresponding strategy:

Here, situation is pretty much inverse to the Long Put case.

Here is a code implementation:


              12345678910111213
            
# Defining all necessary variables
option_price = 1
number_put = 10
strike_price = 30
stock_price = 32
# Defining function `short_put` which will perform computatioons
def short_put(option_price, number_put, strike_price, stock_price):
  profit = - (strike_price - stock_price) * number_put + option_price * number_put
  if stock_price > strike_price:
    profit = option_price * number_put
  return profit
# Printing computed output
print(short_put(option_price, number_put, strike_price, stock_price))

Married Put

The last strategy we are going to discuss in this chapter - is Married Put.

Here trader buys stocks, and put options, one per each stock.

This strategy is used in case, when trader expects stock prices to rise up, but, in the same time, wants to make 'insurance' for the case of decline.

Here is a graphical representation of dependencies between stock price and received profit:

Here flat region, where stock price is below the strike one - could be explained in a way, that money made from exercising options compensate loss from a declined stock price.

Also, we can see code for this strategy:


              123456789101112
            
option_price = 4
number_put = 10
strike_price = 30
stock_price = 32
def married_put(option_price, number_put, strike_price, stock_price):
  stock_profit = number_put * (stock_price - strike_price)
  long_profit = number_put * (strike_price - stock_price) - option_price * number_put
  if stock_price > strike_price:
    long_profit = - number_put * option_price
  profit = stock_profit + long_profit
  return profit
print(married_put(option_price, number_put, strike_price, stock_price))

Everything was clear?

Section 2. Chapter 3