code: 
  
  
  
  
  
  
  import random
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase = 0.0_1  ,	_lowerCAmelCase = 1000  ,	_lowerCAmelCase = -1  ,	):
            UpperCAmelCase__			:     Any										= sample
            if len(self.sample		) == 0:
                 raise ValueError("""Sample data can not be empty"""		)
            UpperCAmelCase__			:     Any										= target
            if len(self.target		) == 0:
                 raise ValueError("""Target data can not be empty"""		)
            if len(self.sample		) != len(self.target		):
                 raise ValueError("""Sample data and Target data do not have matching lengths"""		)
            UpperCAmelCase__			:     Dict										= learning_rate
            UpperCAmelCase__			:     Any										= epoch_number
            UpperCAmelCase__			:     Tuple										= bias
            UpperCAmelCase__			:     Any										= len(_lowerCAmelCase		)
            UpperCAmelCase__			:     int										= len(sample[0]		)  # number of columns in dataset
            UpperCAmelCase__			:     list										= []
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            for sample in self.sample:
                 sample.insert(0  ,	self.bias		)
  
            for _ in range(self.col_sample		):
                 self.weight.append(random.random()		)
  
            self.weight.insert(0  ,	self.bias		)
  
            UpperCAmelCase__			:     Optional[int]										= 0
  
            while True:
                 UpperCAmelCase__			:     Dict										= False
                 for i in range(self.number_sample		):
                      UpperCAmelCase__			:     int										= 0
                      for j in range(self.col_sample + 1		):
                           UpperCAmelCase__			:     Union[str, Any]										= u + self.weight[j] * self.sample[i][j]
                      UpperCAmelCase__			:     Optional[Any]										= self.sign(_lowerCAmelCase		)
                      if y != self.target[i]:
                           for j in range(self.col_sample + 1		):
                                UpperCAmelCase__			:     List[Any]										= (
                                    self.weight[j]
                                    + self.learning_rate
                                    * (self.target[i] - y)
                                    * self.sample[i][j]
                                )
                           UpperCAmelCase__			:     str										= True
              # print('Epoch: \n',epoch_count)
                 UpperCAmelCase__			:     Optional[int]										= epoch_count + 1
                 # if you want control the epoch or just by error
                 if not has_misclassified:
                      print(("""\nEpoch:\n""", epoch_count)		)
                      print("""------------------------\n"""		)
                      # if epoch_count > self.epoch_number or not error:
                      break
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            if len(self.sample		) == 0:
                 raise ValueError("""Sample data can not be empty"""		)
            sample.insert(0  ,	self.bias		)
            UpperCAmelCase__			:     Any										= 0
            for i in range(self.col_sample + 1		):
                 UpperCAmelCase__			:     Tuple										= u + self.weight[i] * sample[i]
  
            UpperCAmelCase__			:     Any										= self.sign(_lowerCAmelCase		)
  
            if y == -1:
                 print(("""Sample: """, sample)		)
                 print("""classification: P1"""		)
            else:
                 print(("""Sample: """, sample)		)
                 print("""classification: P2"""		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            return 1 if u >= 0 else -1
  
  
  
  SCREAMING_SNAKE_CASE__		:       str   							=							[
      [-0.6508, 0.1097, 4.0009],
      [-1.4492, 0.8896, 4.4005],
      [2.0850, 0.6876, 12.0710],
      [0.2626, 1.1476, 7.7985],
      [0.6418, 1.0234, 7.0427],
      [0.2569, 0.6730, 8.3265],
      [1.1155, 0.6043, 7.4446],
      [0.0914, 0.3399, 7.0677],
      [0.0121, 0.5256, 4.6316],
      [-0.0429, 0.4660, 5.4323],
      [0.4340, 0.6870, 8.2287],
      [0.2735, 1.0287, 7.1934],
      [0.4839, 0.4851, 7.4850],
      [0.4089, -0.1267, 5.5019],
      [1.4391, 0.1614, 8.5843],
      [-0.9115, -0.1973, 2.1962],
      [0.3654, 1.0475, 7.4858],
      [0.2144, 0.7515, 7.1699],
      [0.2013, 1.0014, 6.5489],
      [0.6483, 0.2183, 5.8991],
      [-0.1147, 0.2242, 7.2435],
      [-0.7970, 0.8795, 3.8762],
      [-1.0625, 0.6366, 2.4707],
      [0.5307, 0.1285, 5.6883],
      [-1.2200, 0.7777, 1.7252],
      [0.3957, 0.1076, 5.6623],
      [-0.1013, 0.5989, 7.1812],
      [2.4482, 0.9455, 11.2095],
      [2.0149, 0.6192, 10.9263],
      [0.2012, 0.2611, 5.4631],
  ]
  
  SCREAMING_SNAKE_CASE__		:       int   							=							[
      -1,
      -1,
      -1,
      1,
      1,
      -1,
      1,
      -1,
      1,
      1,
      -1,
      1,
      -1,
      -1,
      -1,
      -1,
      1,
      1,
      1,
      1,
      -1,
      1,
      1,
      1,
      1,
      -1,
      -1,
      1,
      -1,
      1,
  ]
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
  
        SCREAMING_SNAKE_CASE__		:       Any   							=							Perceptron(
            sample=samples, target=target, learning_rate=0.01, epoch_number=10_00, bias=-1
        )
        network.training()
        print("""Finished training perceptron""")
        print("""Enter values to predict or q to exit""")
        while True:
              SCREAMING_SNAKE_CASE__		:       list   							=							[]
              for i in range(len(samples[0])):
                    SCREAMING_SNAKE_CASE__		:       Optional[int]   							=							input("""value: """).strip()
                    if user_input == "q":
                          break
                    SCREAMING_SNAKE_CASE__		:       Union[str, Any]   							=							float(user_input)
                    sample.insert(i, observation)
              network.sort(sample)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from .stack import Stack
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase					)   -> bool:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Stack[str]										= Stack()
       UpperCAmelCase__			:     str										= {"""(""": """)""", """[""": """]""", """{""": """}"""}
       for bracket in parentheses:
            if bracket in bracket_pairs:
                 stack.push(__lowerCamelCase					)
            elif bracket in (")", "]", "}"):
                 if stack.is_empty() or bracket_pairs[stack.pop()] != bracket:
                      return False
       return stack.is_empty()
  
  
  if __name__ == "__main__":
        from doctest import testmod
  
        testmod()
  
        SCREAMING_SNAKE_CASE__		:       Any   							=							["""((()))""", """((())""", """(()))"""]
        print("""Balanced parentheses demonstration:\n""")
        for example in examples:
              SCREAMING_SNAKE_CASE__		:       List[str]   							=							"""""" if balanced_parentheses(example) else """not """
              print(f'''{example} is {not_str}balanced''')
  
  
  
  
  
  
  