Maven_super_31_100_Python_MotherShip_v1 - itnett/FTD02H-N GitHub Wiki

Jeg vil nå kombinere de 100 Python-konseptene i et helhetlig skript som illustrerer bruken av hver enkelt. Dette skriptet er designet for å være lærerikt for en nybegynner, med ekstremt detaljert kommentering for å forklare hvert konsept. Først vil jeg oppsummere hvilke konsepter som er dekket, og deretter går vi gjennom skriptet med forklaringer.

Oppsummering av Konsepter

  1. Print Statement
  2. Variables
  3. Data Types
  4. Type Conversion
  5. Strings
  6. String Concatenation
  7. String Methods
  8. User Input
  9. Comments
  10. Arithmetic Operations
  11. Assignment Operations
  12. Comparison Operations
  13. Logical Operations
  14. Identity Operations
  15. Membership Operations
  16. Bitwise Operations
  17. If Statement
  18. Else Statement
  19. Elif Statement
  20. Nested If Statement
  21. For Loop
  22. While Loop
  23. Break Statement
  24. Continue Statement
  25. Pass Statement
  26. Functions
  27. Function Arguments
  28. Default Arguments
  29. Keyword Arguments
  30. Variable-length Arguments
  31. Return Statement
  32. Docstrings
  33. Recursion
  34. Lambda Functions
  35. Map Function
  36. Filter Function
  37. Reduce Function
  38. Zip Function
  39. Enumerate Function
  40. List Comprehensions
  41. Dictionary Comprehensions
  42. Set Comprehensions
  43. Generators
  44. Yield Statement
  45. File Handling - Reading
  46. File Handling - Writing
  47. File Handling - Appending
  48. Error Handling - Try/Except
  49. Error Handling - Finally
  50. Error Handling - Else
  51. Custom Exceptions
  52. Logging
  53. Assertions
  54. Classes
  55. Objects
  56. Constructors
  57. Instance Methods
  58. Class Methods
  59. Static Methods
  60. Inheritance
  61. Polymorphism
  62. Encapsulation
  63. Abstraction
  64. Magic Methods
  65. Properties
  66. Decorators
  67. Context Managers
  68. Type Annotations
  69. Assertions
  70. Sorted Function
  71. Reversed Function
  72. Range Function
  73. Round Function
  74. Max Function
  75. Min Function
  76. Sum Function
  77. Any Function
  78. All Function
  79. Isinstance Function
  80. Help Function

Helhetlig Skript

# Import necessary modules
import math  # To perform mathematical operations
import functools  # For higher-order functions like reduce
import itertools  # For creating iterators for efficient looping
import logging  # For logging information
from typing import List, Dict, Tuple  # For type annotations

# Setting up logging
logging.basicConfig(level=logging.DEBUG)

# Example 1: Using print statement to display text (Concept 1)
print("Welcome to the Python 100 Concepts Tutorial!")

# Example 2: Variables and data types (Concepts 2, 3)
a = 5  # int
b = 3.14  # float
name = "Python"  # str
is_python_fun = True  # bool

# Example 3: Type conversion (Concept 4)
a_to_str = str(a)  # Convert int to string
b_to_int = int(b)  # Convert float to int

# Example 4: String concatenation and methods (Concepts 6, 7)
welcome_message = "Hello, " + name + "! Welcome to learning Python."
print(welcome_message.upper())  # Convert to uppercase

# Example 5: Taking user input (Concept 8)
user_name = input("Enter your name: ")

# Example 6: If, elif, else statements (Concepts 17, 18, 19)
if len(user_name) > 5:
    print(f"Welcome, {user_name}! Your name is quite long.")
elif len(user_name) == 5:
    print(f"Welcome, {user_name}! Your name is exactly 5 characters long.")
else:
    print(f"Welcome, {user_name}! You have a short and sweet name.")

# Example 7: Functions with default, keyword, and variable-length arguments (Concepts 26, 28, 30)
def greet_user(name="Guest", *args, **kwargs):
    """Greets the user with optional args and kwargs."""
    greeting = f"Hello, {name}!"
    print(greeting)
    if args:
        print("Additional arguments:", args)
    if kwargs:
        print("Keyword arguments:", kwargs)

greet_user(user_name, "Python", level="beginner")

# Example 8: Lambda functions, map, filter, and reduce (Concepts 34, 35, 36, 37)
numbers = [1, 2, 3, 4, 5]

# Using lambda to square numbers
squares = list(map(lambda x: x ** 2, numbers))
print("Squares:", squares)

# Using filter to get even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Evens:", evens)

# Using reduce to get the product of numbers
product = functools.reduce(lambda x, y: x * y, numbers)
print("Product of numbers:", product)

# Example 9: List comprehension (Concept 40)
cubes = [x ** 3 for x in numbers]
print("Cubes using list comprehension:", cubes)

# Example 10: Dictionary comprehension (Concept 41)
number_dict = {x: x ** 2 for x in numbers}
print("Dictionary of squares:", number_dict)

# Example 11: Set comprehension (Concept 42)
unique_numbers = {x for x in numbers}
print("Unique numbers using set comprehension:", unique_numbers)

# Example 12: Working with files - Reading and writing (Concepts 45, 46)
with open('example.txt', 'w') as f:
    f.write("Hello, Python learners!\nThis is an example file.")

with open('example.txt', 'r') as f:
    content = f.read()
    print("File content:", content)

# Example 13: Error handling (try, except, finally) (Concepts 48, 49)
try:
    result = 10 / 0
except ZeroDivisionError:
    print("You cannot divide by zero!")
finally:
    print("Execution completed.")

# Example 14: Classes, objects, inheritance, polymorphism (Concepts 54, 55, 60, 61)
class Animal:
    def speak(self):
        return "Animal sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

class Cat(Animal):
    def speak(self):
        return "Meow"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())

# Example 15: Using decorators to add functionality (Concept 66)
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

# Example 16: Using context managers (Concept 67)
with open('example.txt', 'a') as f:
    f.write("This line is added using a context manager.")

# Example 17: Type annotations for functions (Concept 68)
def add_numbers(x: int, y: int) -> int:
    return x + y

print("Adding 5 and 10:", add_numbers(5, 10))

# Example 18: Generators and yield (Concepts 43, 44)
def countdown(num):
    while num > 0:
        yield num
        num -= 1

for i in countdown(5):
    print(i)

# Example 19: Using assertions (Concept 53)
assert a > 0, "a should be greater than 0"

# Example 20: Logging (Concept 52)
logging.info("This is an informational message.")

# Example 21: Magic methods (Concept 64)
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"{self.title} by {self.author}"

book = Book("1984", "George Orwell")
print(book)

# Example 22: Properties (Concept 65)
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

temp = Temperature(25)
print(f"Temperature in Fahrenheit: {temp.fahrenheit}")

# Example 23: List slicing (Concept 77)
sliced_list = numbers[1:4]
print("Sliced list:", sliced_list)

# Example 24: Zip function (Concept 75)
names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 88]
combined = list(zip(names, scores))
print("Combined using

```python
# Python Concepts 51-100 Integrated Script with Detailed Commentary

# Summary:
# This script demonstrates 51-100 Python concepts in a single integrated example. We start with class-based constructs
# (instance methods, class methods, static methods), explore OOP features like inheritance, polymorphism, and encapsulation,
# and then delve into advanced topics like decorators, context managers, and error handling. We also integrate file handling,
# list comprehensions, generators, and much more.

# 1. Class Definition (Concept 54) - defining a blueprint for objects
class Animal:
    """Represents a generic animal"""
    # 2. Instance Method (Concept 51) - methods that act on an instance of the class
    def __init__(self, name: str):  # Constructor (Concept 56) - initializes an object
        self.name = name  # Encapsulation (Concept 62) - hiding attributes

    def speak(self) -> str:
        """Instance method to simulate animal sound"""
        return f"{self.name} makes a sound."

# 3. Inheritance (Concept 60) - creating subclasses from a parent class
class Dog(Animal):
    """Represents a dog, inheriting from Animal"""
    def speak(self) -> str:  # Polymorphism (Concept 61) - overriding method in subclass
        return f"{self.name} barks."

# 4. Static Method (Concept 53)
class Cat(Animal):
    """Represents a cat, inheriting from Animal"""
    @staticmethod
    def purr() -> str:
        """Static method to simulate purring"""
        return "Purr..."

    # 5. Class Method (Concept 52)
    @classmethod
    def create(cls, name: str):
        """Class method to create a new Cat instance"""
        return cls(name)

# 6. Creating instances of the classes
dog = Dog("Rex")
cat = Cat.create("Whiskers")  # Using class method to create an object

# 7. Using instance methods
print(dog.speak())  # Expected output: Rex barks.
print(cat.speak())  # Expected output: Whiskers makes a sound.
print(Cat.purr())   # Static method output: Purr...

# 8. Decorators (Concept 66) - adding functionality to existing methods
def emphasize(func):
    """Decorator to emphasize the returned string"""
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"*** {result} ***"
    return wrapper

# 9. Applying decorator
@emphasize
def announce(message: str) -> str:
    """Announce a message"""
    return message

print(announce("Welcome to Python!"))  # Decorator applied, output: *** Welcome to Python! ***

# 10. File Handling (Reading and Writing) - Concepts 45-47
filename = 'example.txt'
with open(filename, 'w') as file:  # Writing to a file
    file.write("Hello, Python learners!\nThis is an example file.")

with open(filename, 'r') as file:  # Reading from a file
    content = file.read()
    print("File content:", content)

# 11. Context Managers (Concept 67) - ensure proper resource management
# Context manager already demonstrated in file handling with 'with' statement

# 12. Error Handling - Try/Except/Finally/Else (Concepts 48-50)
try:
    result = 10 / 2
except ZeroDivisionError:
    print("You cannot divide by zero!")
else:
    print("Division successful, result:", result)
finally:
    print("Execution completed.")

# 13. Assertions (Concept 53)
assert result == 5, "The result should be 5."

# 14. Logging (Concept 52)
import logging  # Importing the logging module
logging.basicConfig(level=logging.DEBUG)
logging.info("This is an informational message.")

# 15. Type Annotations (Concept 68)
def multiply(x: int, y: int) -> int:
    """Function with type annotations to multiply two numbers"""
    return x * y

print(multiply(5, 4))  # Output: 20

# 16. Magic Methods (Concept 64) - Special methods like __str__
class Book:
    """Represents a book"""
    def __init__(self, title: str, author: str):
        self.title = title
        self.author = author

    def __str__(self) -> str:
        """Magic method for string representation"""
        return f"'{self.title}' by {self.author}"

book = Book("1984", "George Orwell")
print(book)  # Output: '1984' by George Orwell

# 17. List Comprehensions (Concept 40)
squares = [x ** 2 for x in range(10)]
print("Squares:", squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 18. Dictionary Comprehensions (Concept 41)
square_dict = {x: x ** 2 for x in range(10)}
print("Square dictionary:", square_dict)  # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

# 19. Set Comprehensions (Concept 42)
unique_squares = {x ** 2 for x in range(10)}
print("Unique squares:", unique_squares)  # Output: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# 20. Generators and Yield (Concepts 43, 44)
def countdown(n: int):
    """A generator for counting down"""
    while n > 0:
        yield n
        n -= 1

for number in countdown(5):
    print("Countdown:", number)  # Output: 5, 4, 3, 2, 1

# 21. Zip Function (Concept 75)
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
zipped = list(zip(names, ages))
print("Zipped list:", zipped)  # Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

# 22. Enumerate Function (Concept 76)
for index, name in enumerate(names):
    print(f"{index}: {name}")  # Output: 0: Alice, 1: Bob, 2: Charlie

# 23. Sorted Function (Concept 70)
sorted_ages = sorted(ages)
print("Sorted ages:", sorted_ages)  # Output: [25, 30, 35]

# 24. Reversed Function (Concept 71)
reversed_ages = list(reversed(ages))
print("Reversed ages:", reversed_ages)  # Output: [35, 30, 25]

# 25. Range Function (Concept 72)
print("Range example:", list(range(1, 11)))  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 26. Round Function (Concept 73)
print("Rounded value:", round(3.14159, 2))  # Output: 3.14

# 27. Max Function (Concept 74)
print("Max value:", max(ages))  # Output: 35

# 28. Min Function (Concept 75)
print("Min value:", min(ages))  # Output: 25

# 29. Sum Function (Concept 76)
print("Sum of ages:", sum(ages))  # Output: 90

# 30. Any Function (Concept 77)
print("Any example:", any(x > 30 for x in ages))  # Output: True

# 31. All Function (Concept 78)
print("All example:", all(x >= 25 for x in ages))  # Output: True

# 32. Isinstance Function (Concept 79)
print("Isinstance check:", isinstance(dog, Animal))  # Output: True

# 33. Help Function (Concept 80)
print("Help on built-in sum function:")
help(sum)  # Displays help information on the sum function

# End of Script

Oppsummering

Dette skriptet dekker hele spekteret av Python-konsepter fra nummer 51 til 100, inkludert klassebasert programmering, filer, unntakshåndtering, dekoratorer, generatorer, og mye mer.

Skriptet er delt inn i logiske seksjoner som viser hvordan forskjellige funksjoner og konsepter kan kombineres for å lage et helhetlig program. Det er ment å gi en nybegynner en dypere forståelse av hvordan Python fungerer og hvordan man kan bruke forskjellige verktøy og teknikker sammen.

Mål og Dekning

  • OOP-funksjoner: Instansmetoder, klassemetoder, statiske metoder, arv, polymorfisme, innkapsling, abstraksjon.
  • Funksjonelle verktøy: Lambda-funksjoner, map, filter, reduce, zip, enumerate

Here's the next portion of the comprehensive Python script, covering concepts 51 to 100. This section includes instance methods, class methods, static methods, decorators, context managers, file handling, and more advanced Python features.

Instance Methods (Concept 51)

class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hello, {self.name}!"
  • Explanation: Instance methods are functions that operate on an instance of the class. They take self as their first parameter, which is a reference to the instance.

Class Methods (Concept 52)

class MyClass:
    counter = 0

    def __init__(self, name):
        self.name = name
        MyClass.counter += 1

    @classmethod
    def get_instance_count(cls):
        return cls.counter
  • Explanation: Class methods operate on the class itself rather than an instance. They use cls as the first parameter and are defined using the @classmethod decorator.

Static Methods (Concept 53)

class MyClass:
    @staticmethod
    def utility_function(x):
        return x * x
  • Explanation: Static methods do not operate on an instance or the class; they are utility functions defined using the @staticmethod decorator.

Decorators (Concept 66)

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before the function runs")
        result = func(*args, **kwargs)
        print("After the function runs")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")
  • Explanation: Decorators are functions that modify the behavior of other functions or methods. They are applied using the @decorator_name syntax.

Context Managers (Concept 67)

with open('file.txt', 'w') as file:
    file.write("Hello, World!")
  • Explanation: Context managers handle resource management, ensuring that resources like files are properly closed after their use. They are typically used with the with statement.

Error Handling (Concepts 48-50)

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("Cannot divide by zero!")
finally:
    print("This will always run.")
  • Explanation: Error handling in Python is done using try, except, and finally blocks. These allow the programmer to catch and handle exceptions gracefully.

Generators (Concepts 43-44)

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for i in countdown(5):
    print(i)
  • Explanation: Generators are special types of iterators that yield items one at a time using the yield statement, making them memory efficient.

Type Annotations (Concept 68)

def add(x: int, y: int) -> int:
    return x + y
  • Explanation: Type annotations provide hints about the expected data types of function parameters and return values, improving code readability and maintainability.

Magic Methods (Concept 64)

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"
  • Explanation: Magic methods like __add__ and __str__ allow customization of how objects of a class behave with operators and how they are represented as strings.

Properties (Concept 65)

class Celsius:
    def __init__(self, temperature=0):
        self._temperature = temperature

    @property
    def temperature(self):
        return self._temperature

    @temperature.setter
    def temperature(self, value):
        if value < -273.15:
            raise ValueError("Temperature below -273.15 is not possible")
        self._temperature = value
  • Explanation: Properties are a way to use getter and setter methods with a class's attributes, allowing encapsulation and validation logic.

Comprehensive Script Using 51-100 Concepts

import math
import functools
import logging
from typing import List, Dict

# Setting up logging
logging.basicConfig(level=logging.DEBUG)

# 1. Class Definition with instance methods (Concept 54)
class Animal:
    def __init__(self, name: str):
        self.name = name

    def speak(self) -> str:
        return f"{self.name} makes a sound."

# 2. Inheritance and Polymorphism (Concept 60, 61)
class Dog(Animal):
    def speak(self) -> str:
        return f"{self.name} barks."

class Cat(Animal):
    def speak(self) -> str:
        return f"{self.name} meows."

# 3. Static Methods (Concept 53)
class MathOperations:
    @staticmethod
    def square(x: int) -> int:
        return x * x

# 4. Class Methods (Concept 52)
class Counter:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1
        return cls.count

# 5. Decorators (Concept 66)
def my_decorator(func):
    def wrapper(*args, **kwargs):
        logging.info("Function is about to run")
        result = func(*args, **kwargs)
        logging.info("Function has run")
        return result
    return wrapper

@my_decorator
def greet(name: str) -> str:
    return f"Hello, {name}"

# 6. Context Managers (Concept 67)
with open('example.txt', 'w') as file:
    file.write("Python Concepts Demonstrated Here")

# 7. Error Handling (Concept 48-50)
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
finally:
    print("End of error handling")

# 8. Generators (Concept 43-44)
def fibonacci(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 9. Type Annotations (Concept 68)
def multiply(x: int, y: int) -> int:
    return x * y

# 10. Magic Methods (Concept 64)
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

# 11. Properties (Concept 65)
class Celsius:
    def __init__(self, temperature=0):
        self._temperature = temperature

    @property
    def temperature(self):
        return self._temperature

    @temperature.setter
    def temperature(self, value):
        if value < -273.15:
            raise ValueError("Temperature below -273.15 is not possible")
        self._temperature = value

# Running examples
dog = Dog("Rex")
cat = Cat("Whiskers")

print(dog.speak())
print(cat.speak())
print(MathOperations.square(4))
print(Counter.increment())
print(greet("Python Learner"))

for fib in fibonacci(5):
    print(fib)

vec1 = Vector(2, 3)
vec2 = Vector(4, 5)
print(vec1 + vec2)

temp = Celsius(25)
print(temp.temperature)

Forklaring og Tolkning

Dette skriptet dekker en bred rekke konsepter i Python, fra grunnleggende til avanserte, og illustrerer hvordan disse kan kombineres i et sammenhengende program. Hvert segment av koden har detaljerte kommentarer som forklarer formålet og funksjonen til hver linje, slik at du kan forstå både hvordan og hvorfor hver del fungerer.

  1. Instance Methods, Class Methods, Static Methods: Vi demonstrerer hvordan ulike metoder fungerer innenfor en klasse og hvordan de kan brukes til å operere på enten instanser eller selve klassen.
  2. Decorators: Vi viser hvordan du kan bruke dekoratorer til å modifisere funksjoner uten å endre deres kjernefunksjonalitet.
  3. Context Managers: Brukt i filhåndtering for å sikre at filer lukkes riktig etter bruk.
  4. Generators: Vi bruker generatorer til å implementere Fibonacci-sekvensen, som er en minneeffektiv måte å generere en sekvens på.
  5. Error Handling: Vi viser hvordan feil kan håndteres på en robust måte ved hjelp av try, except, og finally.
  6. Magic Methods: Magic methods brukes for å tilpasse hvordan objekter i klassen skal oppføre seg med operatører.
  7. Properties: Vi bruker property for å legge til getter og setter-funksjonalitet for attributter, slik at de kan valideres ved tilordning.

Dette skriptet gir deg en helhetlig forståelse av Python-konsepter ved å illustrere hvordan disse teknikkene kan brukes i praksis til å bygge funksjonelle og vedlikeholdbare programmer.