# history

source:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'go*')
      plt.show()

source_raw:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'go*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'go*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'go*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis()
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis(-6, 6, -6, 6)
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis(-6, 6, -6, 6)
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis([-6, 6, -6, 6)]
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis([-6, 6, -6, 6)]
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.xlabel('Real')
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.xlabel('Real')
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.xlabel('Real')
      plt.ylabel('Imaginary ')
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()

source_raw:
  def complex_plot(nums):
      print(nums)
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.xlabel('Real')
      plt.ylabel('Imaginary ')
      plt.axis([-6, 6, -6, 6])
      plt.plot(x, y, 'g*')
      plt.show()


source:
  def which(pgm):
      path = os.getenv("PATH")
      for p in path.split(os.path.pathsep):
          p = os.path.join(p, pgm)
          if os.path.exists(p) and os.access(p, os.X_OK):
              return p
      return None

source_raw:
  def which(pgm):
      path = os.getenv("PATH")
      for p in path.split(os.path.pathsep):
          p = os.path.join(p, pgm)
          if os.path.exists(p) and os.access(p, os.X_OK):
              return p
      return None


source:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.show()
      

source_raw:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.show()
      


source:
  x = [num.real for num in nums]
  y = [num.imag for num in nums]
  plt.plot(x, y, 'g*')
  plt.show()

source_raw:
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.show()
      


source:
  nums = data90
  x = [num.real for num in nums]
  y = [num.imag for num in nums]
  plt.plot(x, y, 'g*')
  plt.show()

source_raw:
  nums = data90
  x = [num.real for num in nums]
  y = [num.imag for num in nums]
  plt.plot(x, y, 'g*')
  plt.show()


source:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.axis(min(x)-1, max(x)+1, min(y)-1, max(y)+1)
      plt.show()
      

source_raw:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.axis(min(x)-1, max(x)+1, min(y)-1, max(y)+1)
      plt.show()
      


source:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.axis([min(x)-1, max(x)+1, min(y)-1, max(y)+1])
      plt.show()
      

source_raw:
  def complex_plot(nums):
      x = [num.real for num in nums]
      y = [num.imag for num in nums]
      plt.plot(x, y, 'g*')
      plt.axis([min(x)-1, max(x)+1, min(y)-1, max(y)+1])
      plt.show()
      


source:
  def isLeapYear(self):
      return self.yy % 4 == 0 and (
              self.yy % 100 != 0 or self.yy % 400 == 0)

source_raw:
      def isLeapYear(self):
          return self.yy % 4 == 0 and (
                  self.yy % 100 != 0 or self.yy % 400 == 0)


source:
  def isLeapYear(year):
      return year % 4 == 0 and (
              year % 100 != 0 or year % 400 == 0)

source_raw:
      def isLeapYear(year):
          return year % 4 == 0 and (
                  year % 100 != 0 or year % 400 == 0)


source:
  def isLeapYear(year):
      return year % 4 == 0 and (
              year % 100 == 0 and year % 400 == 0)

source_raw:
      def isLeapYear(year):
          return year % 4 == 0 and (
                  year % 100 == 0 and year % 400 == 0)


source:
  class NeuralNetwork:
      def __init__(self, self.args*, **self.kwargs):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))

source_raw:
  class NeuralNetwork:
      def __init__(self, self.args*, **self.kwargs):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))


source:
  class NeuralNetwork:
      def __init__(self, *self.args, **self.kwargs):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))

source_raw:
  class NeuralNetwork:
      def __init__(self, *self.args, **self.kwargs):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))


source:
  class NeuralNetwork:
      def __init__(self):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))

source_raw:
  class NeuralNetwork:
      def __init__(self):
          # Define HyperParameters
          self.inputLayerSize = 2
          self.hiddenLayerSize = 3
          self.outputLayerSize = 1

          # Weights (Parameters)
          self.w1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)
          self.w2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)

      def forward(self, x):
          # Propogate inputs throught network
          self.z2 = np.dot(x, self.w1)
          self.a2 = self.sigmoid(self.z2)
          self.z3 = np.dot(self.a2, self.w2)
          yHat = self.sigmoid(self.z3)
          return yHat

      def sigmoid(self, z):
          # Apply sigmoid activation function
          return 1 / (1 + np.exp(-z))


source:
  testInput = np.arange(-6, 6, 0.01)
  print(len(testInput))
  plot(testInput, sigmoid(testInput), linewidth=2)
  grid(1)

source_raw:
  testInput = np.arange(-6, 6, 0.01)
  print(len(testInput))
  plot(testInput, sigmoid(testInput), linewidth=2)
  grid(1)


source:
  for row in rows:
      cell = row.find_elements(By.TAG_NAME, 'td')
      print(list(c.text for c in cell))

source_raw:
  for row in rows:
      cell = row.find_elements(By.TAG_NAME, 'td')
      print(list(c.text for c in cell))


source:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3]) > 60 or int(cells[4]) > 60 or int(cells[5]) > 60:
          student_above_60.append(cells)

source_raw:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3]) > 60 or int(cells[4]) > 60 or int(cells[5]) > 60:
          student_above_60.append(cells)


source:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3]) > 60 or int(cells[4]) > 60 or int(cells[5]) > 60:
          student_above_60.append(cells)
          

source_raw:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3]) > 60 or int(cells[4]) > 60 or int(cells[5]) > 60:
          student_above_60.append(cells)
          


source:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
          student_above_60.append(cells)

source_raw:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
          student_above_60.append(cells)


source:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
          student_above_60.append(cells)
          

source_raw:
  for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
          student_above_60.append(cells)
          


source:
  for row in rows[1:]:
     cells = row.find_elements(By.TAG_NAME, 'td')
     if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
         student_above_60.append(list(cell.text for cell in cells))

source_raw:
   for row in rows[1:]:
      cells = row.find_elements(By.TAG_NAME, 'td')
      if int(cells[3].text) > 60 or int(cells[4].text) > 60 or int(cells[5].text) > 60:
          student_above_60.append(list(cell.text for cell in cells))


source:
  sum = 0
  for i in range(1000000000):
      if i % 3 == 0 or i % 5 == 0:
          sum += i
          print(i)

source_raw:
  sum = 0
  for i in range(1000000000):
      if i % 3 == 0 or i % 5 == 0:
          sum += i
          print(i)


source:
  options.binary_location = '/usr/bin/librewolf'
  service = webdriver.FirefoxService('/usr/bin/geckodriver')
  driver = webdriver.Firefox(options=options, service=service)
  driver.quit()

source_raw:
  options.binary_location = '/usr/bin/librewolf'
  service = webdriver.FirefoxService('/usr/bin/geckodriver')
  driver = webdriver.Firefox(options=options, service=service)
  driver.quit()


source:
  options.binary_location = '/usr/bin/librewolf'
  service = webdriver.FirefoxService('/usr/bin/geckodriver')
  driver = webdriver.Firefox(options=options, service=service)

source_raw:
  options.binary_location = '/usr/bin/librewolf'
  service = webdriver.FirefoxService('/usr/bin/geckodriver')
  driver = webdriver.Firefox(options=options, service=service)


source:
  from pandas import DataFrame
  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.svm import SVC

source_raw:
  from pandas import DataFrame
  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.svm import SVC


source:
  for checkbox in checkboxes:
      print(checkbox.is_selected())
      print(checkbox.get_attribute('name'))
      

source_raw:
  for checkbox in checkboxes:
      print(checkbox.is_selected())
      print(checkbox.get_attribute('name'))
      


source:
  for checkbox in checkboxes:
      print(checkbox)
      print(checkbox.is_selected())
      print(checkbox.get_attribute('name'))
      

source_raw:
  for checkbox in checkboxes:
      print(checkbox)
      print(checkbox.is_selected())
      print(checkbox.get_attribute('name'))
      


source:
  for checkbox in checkboxes:
      print(checkbox.get_attribute('name'), end=":")
      print(checkbox.is_selected())
      

source_raw:
  for checkbox in checkboxes:
      print(checkbox.get_attribute('name'), end=":")
      print(checkbox.is_selected())
      


source:
  checked_count = 0
  unchecked_count = 0
  for checkbox in checkboxes:
      print(checkbox.get_attribute('name'), end=" : ")
      selected = checkbox.is_selected()
      if selected:
          print("Selected")
          checked_count += 1
      else:
          print("Not selected")
          unchecked_count += 1
          

source_raw:
  checked_count = 0
  unchecked_count = 0
  for checkbox in checkboxes:
      print(checkbox.get_attribute('name'), end=" : ")
      selected = checkbox.is_selected()
      if selected:
          print("Selected")
          checked_count += 1
      else:
          print("Not selected")
          unchecked_count += 1
          


source:
  def describe(data):
      for col in data.columns:
          print("Column name is", col)
          print("Data Type is", data[col].unique())
          print("Null value count =", data[col].isnull().sum())
          print("Unique values =", data[col].nunique())
          print("Unique Values:", data[col].unique())

source_raw:
  def describe(data):
      for col in data.columns:
          print("Column name is", col)
          print("Data Type is", data[col].unique())
          print("Null value count =", data[col].isnull().sum())
          print("Unique values =", data[col].nunique())
          print("Unique Values:", data[col].unique())


source:
  def describe(data):
      for col in data.columns:
          print("Column name is", col)
          print("Data Type is", data[col].dtype)
          print("Null value count =", data[col].isnull().sum())
          print("Unique values =", data[col].nunique())
          print("Unique Values:", data[col].unique())

source_raw:
  def describe(data):
      for col in data.columns:
          print("Column name is", col)
          print("Data Type is", data[col].dtype)
          print("Null value count =", data[col].isnull().sum())
          print("Unique values =", data[col].nunique())
          print("Unique Values:", data[col].unique())


source:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4d %4d %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

source_raw:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4d %4d %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))


source:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4d %4d %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4d %4d %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4s %4s %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      for col in data.columns:
          format = "%20s %10s %4s %4s %s"
          print(format %("Column", "Data", "Null", "Unique", "Unique"))
          print(format %("Name", "Type", "Count", "Count", "Values"))
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%20s %10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%20s %10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(data[col], data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%20s %10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%20s %10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %4s %4s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print()
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print()
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column", "Data", "Null", "Unique", "Unique"))
      print(format %("Name", "Type", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data", "Null", "Unique", "Unique"))
      print(format %("", "Type", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data", "Null", "Unique", "Unique"))
      print(format %("", "Type", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 60)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

  describe(data)


source:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))

source_raw:
  def describe(data):
      format = "%-30s %-10s %6s %6s %s"
      print(format %("Column Name", "Data Type", "Null", "Unique", "Unique"))
      print(format %("", "", "Count", "Count", "Values"))
      print('-' * 65)
      for col in data.columns:
          print(format %(col, data[col].dtype, data[col].isnull().sum(),
                        data[col].nunique(), data[col].unique()))


source:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length
          

source_raw:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length
          


source:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if minimum = 0:
          minimum = length
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length

source_raw:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if minimum = 0:
          minimum = length
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length


source:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if minimum == 0:
          minimum = length
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length

source_raw:
  minimum = maximum = 0
  for col in data.columns:
      length = len(data[col])
      if minimum == 0:
          minimum = length
      if length > maximum:
          maximum = length
      if length < minimum:
          minimum = length


