Untitled-3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['whirui a ne phauuu y la stouuu y si thiaa u na phuee o rw steaa y ko phieoe o by phaee u wu phiooaa u ko whiaie w ky', 'stwee o yi wheooaa i po chwaa e na shuaie a gy wharue y pa thuaia a ww shiooaa w yi shwuuu i di chaee a ru whuaio i dy', 'whwoo o ti whwooaa w mi phoeoy o gi whyaie o du thooo y ky pheeow i dy chyoo a ye shwoo e by phuooaa y se chwaa w lu', 'chiruy a sw steuuu u yw wheeoy y yu stirua w bi phaooaa e sw chuoo o hi whiuuu a he stieou u ny whyooaa w tw phiuo w kw', 'whoooaa w po shauuu e ny whoruy y po phwoo a pu sheuo u sa shyooaa a ne shuooaa u da whaeoo w ke shaooaa i ry pheooaa i pu', 'stoaa e kw shyooaa e te phuaa u be stwee w ra whyaa w ly whiaa u hw whueoe e wi chiruo e pi whuooaa u po stuooaa o hy', 'chiruw w ge whouuu u na pheuuu e rw pharui o we chuooaa w yo theee u du thiaiw u bw whoooaa e ke chyaa u mw shweoa a wi', 'thiee y bi phyoo y yy shuee u le sheee w lu phuooaa a dy whiaa a bw chioo o bi phwuo o ga shouo w gi wheee u ho', 'phouuu y ye whiaiy i yi sheeoi w ma shoaa o yy phwoo y to thuaa y gw whiuo i ku whwrui a tw whyooaa u yi thwee w lo', 'phoooaa i wa thweow i sw thwooaa a to whuuo i na shouuu y sy chwaie o la shuoo e sw sheooaa o ty phoooaa e ne thwrui u su']\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "import random\n",
    " \n",
    "\n",
    "VOWELS = [\"ee\", \"oo\", \"aa\", \"eo\", \"ai\", \"uo\", \"uuu\", \"ooaa\", \"ru\"]\n",
    "CONSONANTS = [\"t\", \"k\", \"p\", \"b\", \"d\", \"g\", \"m\", \"n\", \"h\", \"w\", \"y\", \"r\", \"s\", \"l\"]\n",
    "VOWEL = [\"a\", \"e\", \"i\", \"o\", \"u\", \"y\", \"w\"]\n",
    "\n",
    "CONSONANT_COMBINATIONS = [\n",
    "    \"ch\", \"st\", \"sh\", \"th\", \"ph\", \"wh\", \"ch\", \"sh\", \"th\", \"ph\", \"wh\", \"ch\", \"sh\", \"th\", \"ph\", \"wh\"\n",
    "]\n",
    "\n",
    "def generate_section(length: int) -> str:\n",
    "    \"\"\"Generates a section of the melody.\"\"\"\n",
    "    section = []\n",
    "    for _ in range(length):\n",
    "        vowel_combo = random.choice(VOWELS)\n",
    "        if vowel_combo in (\"ai\", \"eo\", \"ru\"):\n",
    "            vowel_combo += random.choice(VOWEL)\n",
    "        consonant = random.choice(CONSONANT_COMBINATIONS) + random.choice(VOWEL)\n",
    "        if consonant in (\"h\", \"l\"):\n",
    "            consonant += random.choice(VOWEL)\n",
    "            consonant += random.choice(CONSONANTS)\n",
    "        suffix = random.choice(VOWEL) + \" \" + random.choice(CONSONANTS) + random.choice(VOWEL)\n",
    "        section.append(consonant+vowel_combo + \" \"+ suffix)\n",
    "    return \" \".join(section)\n",
    "\n",
    "\n",
    "\n",
    "def generate_variation() -> str:\n",
    "    \"\"\"Generates a half-length section.\"\"\"\n",
    "    section = []\n",
    "    for _ in range(10):\n",
    "        vowel_combo = random.choice(VOWELS)\n",
    "        if vowel_combo in (\"ai\", \"eo\", \"ru\"):\n",
    "            vowel_combo += random.choice(CONSONANTS) + \" \" +  random.choice(VOWEL)\n",
    "        consonant = random.choice(CONSONANTS)\n",
    "        if consonant == \"h\":\n",
    "            consonant += random.choice(VOWEL)\n",
    "            consonant += random.choice(CONSONANTS)\n",
    "        elif consonant == \"w\":\n",
    "            consonant += random.choice(VOWEL)\n",
    "        suffix = random.choice(VOWEL) + \" \" + random.choice(CONSONANTS) + random.choice(VOWEL)\n",
    "        section.append(consonant+vowel_combo+suffix)\n",
    "    return \" \".join(section)\n",
    "\n",
    "\n",
    "def halve_length(melody: List[str]) -> List[str]:\n",
    "    \"\"\"Halves the length of the melody.\"\"\"\n",
    "    return [melody[i] for i in range(len(melody)) if i % 2 == 0]\n",
    "\n",
    "def remove_letters(melody: List[str]) -> List[str]:\n",
    "    \"\"\"Removes the letters from the melody.\"\"\"\n",
    "    return [melody[i] for i in range(len(melody)) if not i % 2 == 0]\n",
    "\n",
    "\n",
    "def generate_melody() -> List[str]:\n",
    "    \"\"\"Generates the melody.\"\"\"\n",
    "    return [generate_section(10) for _ in range(10)]\n",
    "\n",
    "def transpose_letters(melody: List[str]) -> List[str]:\n",
    "    \"\"\"Transposes the letters in the melody.\"\"\"\n",
    "    return [melody[i].upper() for i in range(len(melody))]\n",
    "\n",
    "def main() -> None:\n",
    "    \"\"\"Main function.\"\"\"\n",
    "    melody = generate_melody()      \n",
    "    transposed_melody = transpose_letters(melody)\n",
    "    halved_melody = halve_length(transposed_melody)\n",
    "    removed_melody = remove_letters(melody)\n",
    "    removed_halved_melody = remove_letters(halved_melody)\n",
    "    removed_encore = remove_letters(generate_melody())\n",
    "\n",
    "    final_melody = f\"{removed_melody}, {removed_halved_melody}, {removed_encore}\"\n",
    "\n",
    "\n",
    "    print(melody)\n",
    "    #print(transposed_melody)\n",
    "    #print(halved_melody)\n",
    "    ##print(removed_halved_melody)\n",
    "    #print(final_melody)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Import Google-GenerativeAI and set up a conversational chat with Gemini Pro 1.5 latest\n",
    "def "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be A Master of Understanding\n",
    "\n",
    "Why is it that some python classess don't utilize\n",
    "def _init_ self ?\n",
    "\n",
    "In Python, the __init__ method is a special method called a constructor. It is automatically invoked when a new instance (object) of a class is created, and it is used to initialize the object’s attributes. However, not all Python classes need to use the __init__ method. Here are some reasons why a class might not utilize __init__:\n",
    "\n",
    "1. Simple Classes Without Initialization Needs\n",
    "\n",
    "No Attributes to Initialize: If a class does not need to initialize any attributes or perform any setup when an object is created, it can omit the __init__ method.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class SimpleClass:\n",
    "    def greet(self): print(\"Hello, World!\") obj = SimpleClass() obj.greet()\n",
    "\n",
    "2. Using Class Methods or Static Methods\n",
    "\n",
    "Class Methods: These methods are bound to the class and not the instance. They can be used to create alternative constructors.\n",
    "\n",
    "Static Methods: These methods do not access or modify the class or instance state.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class AlternativeConstructor: @classmethod\n",
    "def create(cls): instance = cls() # Perform some setup return instance @staticmethod\n",
    "def utility_method(): print(\"This is a static method.\") obj = AlternativeConstructor.create() AlternativeConstructor.utility_method()\n",
    "\n",
    "3. Inheritance and Overriding\n",
    "\n",
    "Inherited Initialization: In some cases, a subclass might rely on the parent class’s __init__ method and not need its own.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Parent:\n",
    "    def __init__(self, value): self.value = value class Child(Parent): pass obj = Child(10) print(obj.value) # Output: 10\n",
    "\n",
    "4. Data Classes\n",
    "\n",
    "Automatic Initialization: Python’s dataclasses module can automatically generate the __init__ method based on class annotations.\n",
    "\n",
    "Example:\n",
    "Pythonfrom dataclasses import dataclass @dataclass class DataClassExample:\n",
    " name: str age: int obj = DataClassExample(name=\"Alice\", age=30) print(obj.name, obj.age) # Output: Alice 30\n",
    "\n",
    "5. Metaclasses and Custom Object Creation\n",
    "\n",
    "Custom Object Creation: Advanced use cases might involve metaclasses or custom object creation methods that do not require __init__.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Meta(type):\n",
    "    def __call__(cls, *args, **kwargs): instance = super().__call__(*args, **kwargs) # Custom initialization return instance class CustomClass(metaclass=Meta): pass obj = CustomClass()\n",
    "\n",
    "What are some common use cases for __init__ in Python classes?\n",
    "\n",
    "The __init__ method in Python classes is used for a variety of purposes, primarily to initialize the attributes of an object when it is created. Here are some common use cases:\n",
    "\n",
    "1. Initializing Instance Variables\n",
    "\n",
    "Purpose: To set up initial values for the attributes of an object.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Person:\n",
    "    def __init__(self, name, age): self.name = name self.age = age person = Person(\"Alice\", 30) print(person.name, person.age) # Output: Alice 30\n",
    "\n",
    "2. Setting\n",
    "Default Values\n",
    "\n",
    "Purpose: To provide\n",
    "default values for attributes if no specific values are provided.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Car:\n",
    "    def __init__(self, make, model, year=2020): self.make = make self.model = model self.year = year car = Car(\"Toyota\", \"Corolla\") print(car.year) # Output: 2020\n",
    "\n",
    "3. Validating Input Data\n",
    "\n",
    "Purpose: To validate the input data and ensure it meets certain criteria.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Rectangle:\n",
    "    def __init__(self, width, height): if width <= 0 or height <= 0: raise ValueError(\"Width and height must be positive numbers.\") self.width = width self.height = height rect = Rectangle(10, 5)\n",
    "\n",
    "4. Resource Allocation\n",
    "\n",
    "Purpose: To allocate resources such as opening files or establishing database connections.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class FileHandler:\n",
    "    def __init__(self, filename): self.file = open(filename, 'r')\n",
    "def read_file(self): return self.file.read()\n",
    "def __del__(self): self.file.close() handler = FileHandler(\"example.txt\") print(handler.read_file())\n",
    "\n",
    "5. Dependency Injection\n",
    "\n",
    "Purpose: To inject dependencies or other objects that the class relies on.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Service:\n",
    "    def __init__(self, repository): self.repository = repository\n",
    "def get_data(self): return self.repository.fetch_data() class Repository:\n",
    "    def fetch_data(self): return \"Data from repository\" repo = Repository() service = Service(repo) print(service.get_data()) # Output: Data from repository\n",
    "\n",
    "6. Setting Up Complex Objects\n",
    "\n",
    "Purpose: To set up complex objects that require multiple steps or configurations.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class ComplexObject:\n",
    "    def __init__(self, part1, part2): self.part1 = part1 self.part2 = part2 self.setup()\n",
    "def setup(self): # Complex setup logic self.combined = f\"{self.part1}-{self.part2}\" obj = ComplexObject(\"PartA\", \"PartB\") print(obj.combined) # Output: PartA-PartB\n",
    "\n",
    "7. Logging and Debugging\n",
    "\n",
    "Purpose: To log or debug information during object creation.\n",
    "\n",
    "Example:\n",
    "Pythonimport logging class Logger:\n",
    "def __init__(self, name): self.logger = logging.getLogger(name) self.logger.setLevel(logging.DEBUG) handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) self.logger.addHandler(handler)\n",
    "def log(self, message): self.logger.debug(message) logger = Logger(\"MyLogger\") logger.log(\"This is a debug message.\")\n",
    "\n",
    "These use cases illustrate the versatility of the __init__ method in setting up and managing the state and behavior of objects in Python.\n",
    "\n",
    "What are some best practices for using __init__ effectively?\n",
    "\n",
    "Using the __init__ method effectively in Python classes is crucial for creating well-structured and maintainable code. Here are some best practices to follow:\n",
    "\n",
    "1. Initialize All Necessary Attributes\n",
    "\n",
    "Purpose: Ensure that all attributes needed for the class are initialized within the __init__ method.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Person:\n",
    "    def __init__(self, name, age): self.name = name self.age = age\n",
    "\n",
    "2. Avoid Using Mutable\n",
    "Default Arguments\n",
    "\n",
    "Purpose: Prevent unexpected behavior by avoiding mutable\n",
    "default arguments like lists or dictionaries.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class MyClass:\n",
    "    def __init__(self, my_list=None): if my_list is None: my_list = [] self.my_list = my_list\n",
    "\n",
    "3. Use Keyword-Only Arguments\n",
    "\n",
    "Purpose: Improve code readability and prevent errors by using keyword-only arguments.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Car:\n",
    "    def __init__(self, make, model, *, year=2020): self.make = make self.model = model self.year = year\n",
    "\n",
    "4. Keep Initialization Simple\n",
    "\n",
    "Purpose: Avoid performing complex computations or time-consuming tasks within the __init__ method.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class DataProcessor:\n",
    "    def __init__(self, data): self.data = data self.processed_data = self.process_data()\n",
    "def process_data(self): # Complex processing logic return processed_data\n",
    "\n",
    "5. Use Descriptive Parameter Names\n",
    "\n",
    "Purpose: Make the code more readable and self-explanatory by using descriptive parameter names.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Book:\n",
    "    def __init__(self, title, author, publication_year): self.title = title self.author = author self.publication_year = publication_year\n",
    "\n",
    "6. Document the __init__ Method\n",
    "\n",
    "Purpose: Provide clear documentation for the __init__ method to explain the purpose of each parameter.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Employee:\n",
    "    def __init__(self, name, position, salary): \"\"\" Initialize an Employee object. :param name: The name of the employee. :param position: The position of the employee. :param salary: The salary of the employee. \"\"\" self.name = name self.position = position self.salary = salary\n",
    "\n",
    "7. Use super() for Inheritance\n",
    "\n",
    "Purpose: Ensure proper initialization of parent classes when using inheritance.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Animal:\n",
    "def __init__(self, species): \n",
    "self.species = species \n",
    "\n",
    "class Dog(Animal):\n",
    "def __init__(self, name, breed): \n",
    "    super().__init__(species=\"Dog\") \n",
    "    self.name = name \n",
    "    self.breed = breed\n",
    "\n",
    "8. Avoid Side Effects\n",
    "\n",
    "Purpose: Ensure that the __init__ method does not have side effects that could affect other parts of the program.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Logger:\n",
    "def __init__(self, log_file): \n",
    "    self.log_file = log_file # Avoid opening the file here; do it in a separate method\n",
    "\n",
    "9. Use Properties for Complex Initialization\n",
    "\n",
    "Purpose: Use properties to handle complex initialization logic that should not be in the __init__ method.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Circle:\n",
    "def __init__(self, radius): \n",
    "self.radius = radius \n",
    "\n",
    "@property\n",
    "def area(self): \n",
    "    return 3.14159 * self.radius ** 2\n",
    "\n",
    "10. Prefer Composition Over Inheritance\n",
    "\n",
    "Purpose: Use composition to include functionality from other classes rather than relying solely on inheritance.\n",
    "\n",
    "Example:\n",
    "Python\n",
    "class Engine:\n",
    "    def start(self): print(\"Engine started\") class Car:\n",
    "    def __init__(self, make, model): self.make = make self.model = model self.engine = Engine()\n",
    "def start(self): self.engine.start()\n",
    "\n",
    "By following these best practices, you can ensure that your __init__ methods are clear, efficient, and maintainable."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}