py notes 3

show e-04 in full format in python

If you want to represent a number like e-04 in full decimal format, you need to multiply it by 10 to the power of the exponent. Here's how you can do it in Python:

num = 1e-04
full_format = num * 10**-4

print(full_format)

This will output 0.0001, which is the full format representation of e-04.

In this code, 10**-4 represents 10 raised to the power -4, which is 0.0001. Then, num * 0.0001 gives you the full format representation of e-04, which is 0.0001.

apply Decimal in ndarray in python

To apply the Decimal type to elements in a NumPy ndarray, you can use NumPy's vectorize function along with the Decimal constructor. Here's how you can do it:

import numpy as np
from decimal import Decimal

# Define a function to convert elements to Decimal
def to_decimal(x):
    return Decimal(str(x))

# Create a NumPy array
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5])

# Apply the Decimal function to each element of the array
decimal_arr = np.vectorize(to_decimal)(arr)

print(decimal_arr)

This code will convert each element in the NumPy array arr to a Decimal. Note that we convert each element to a string before converting it to a Decimal to avoid potential precision issues when directly converting floating-point numbers to Decimal.

Keep in mind that using Decimal with NumPy arrays can be less efficient than using native NumPy operations with native data types (e.g., float). So, consider whether using Decimal is necessary for your specific use case.

how-to-disable-python-warnings

To disable Python warnings, you can use the warnings module in Python. Here's how you can do it:

import warnings

# Disable all warnings
warnings.filterwarnings("ignore")

# Disable specific warning by category
warnings.filterwarnings("ignore", category=DeprecationWarning)

# Disable specific warning by message
warnings.filterwarnings("ignore", message="Some specific warning message")

You can place these lines at the beginning of your script or at the entry point of your program to disable warnings globally.

However, it's generally not recommended to disable warnings indiscriminately, as warnings often provide important information about potential issues in your code. It's usually better to address the underlying causes of warnings instead of ignoring them altogether.

If you're using a Jupyter Notebook, you can also use the %matplotlib inline magic command to suppress Matplotlib's warnings specifically:

%matplotlib inline

This command should be placed at the beginning of your notebook to prevent Matplotlib from displaying warning messages.

how to apply filterwarnings in the project + python

To apply filterwarnings to your entire Python project, you can set it up in the entry point of your application or script. This ensures that the warning settings are applied globally throughout your project. Here's how you can do it:

Create a Main Script or Entry Point: Identify the main script or entry point of your Python project. This is usually the script that you run to start your application or the script that kicks off your project's functionality.
Import and Apply filterwarnings: In your main script or entry point, import the warnings module and apply the desired warning filters using filterwarnings().
```
import warnings

# Apply filterwarnings to ignore specific warning categories
warnings.filterwarnings("ignore", category=DeprecationWarning)
```
You can adjust the warning filter settings according to your project's requirements.
Run Your Project: Once you've added the filterwarnings configuration to your main script or entry point, simply run your project as usual. The warning settings will be applied globally throughout the execution of your project.

By applying filterwarnings in your main script or entry point, you ensure that the warning settings are consistent across your entire project. However, keep in mind that it's generally a good practice to only suppress warnings that you explicitly intend to ignore, and it's often better to address the underlying causes of warnings in your code. Additionally, remember to document any intentional suppression of warnings for the benefit of other developers who may work on your project.

default import file in all python

In Python, there's no built-in mechanism for automatically importing a default file in all scripts or modules. However, you can achieve similar functionality by setting up a Python module that contains common utility functions or configurations and then importing that module in your scripts or modules as needed.

Here's a general approach you can follow:

Create a Module with Common Functions/Configurations: Create a Python module (e.g., common.py) that contains the functions, classes, or configurations that you want to be available across your project.
```
# common.py

def utility_function():
    pass

# Other common functions, classes, or configurations
```
Import the Module in Your Scripts or Modules: In your Python scripts or modules, import the common module and use the functions, classes, or configurations defined within it.
```
# my_script.py

import common

common.utility_function()
```
(Optional) Make the Module Available Everywhere: If you want the common module to be available globally without needing to specify its import in every script or module, you can add its path to the PYTHONPATH environment variable or install it as a package that can be imported using pip.
```
export PYTHONPATH=/path/to/common/module:$PYTHONPATH
```
Alternatively, you can install the module as a package using pip install . or pip install -e . from the directory containing the common module's setup.py file.
Use the Common Module in Your Project: Now you can use the functions, classes, or configurations defined in the common module across your project by importing it in your scripts or modules.

By following this approach, you can effectively achieve the concept of a "default import file" that contains common functionality or configurations used across your Python project.

logging.basicConfig + print only on file + python

To configure the logging module to log only to a file and suppress printing to the console, you can use basicConfig to set up logging handlers. Here's how you can do it:

import logging

# Configure logging to write to a file
logging.basicConfig(filename='example.log', level=logging.DEBUG)

# Get the root logger
logger = logging.getLogger()

# Remove any existing handlers from the root logger
for handler in logger.handlers[:]:
    logger.removeHandler(handler)

# Add a file handler to the root logger
file_handler = logging.FileHandler('example.log')
logger.addHandler(file_handler)

# Log messages
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

# This will not print to the console
print('This will not be logged')

# This will also not print to the console
logging.info('This will not be logged either')

In this example:

We configure logging to write to a file named example.log at the DEBUG level.
We retrieve the root logger and remove any existing handlers from it.
We add a FileHandler to the root logger to log messages to the file.
We log messages at different levels (debug, info, warning, error, critical).
The print statement and subsequent logging call will not output anything to the console; they will only be logged to the file specified.

how-to-solve-modulenotfounderror-no-module-named-in-python/

If you encounter a ModuleNotFoundError: No module named 'module_name' error in Python, it means that Python is unable to find and import the specified module. Here are several steps you can take to resolve this issue:

Check Module Name Spelling: Ensure that you've spelled the module name correctly. Python is case-sensitive, so make sure the capitalization matches.
Check Module Installation: If you're trying to import a third-party module, make sure that it's installed in your Python environment. You can use pip, Python's package manager, to install missing modules. For example:
```
pip install module_name
```
Check Module Availability: Ensure that the module is available in the Python path. Some modules may need to be installed separately or may not be included in the standard library.
Check Python Path: Check if the module is located in one of the directories listed in the sys.path variable. You can print sys.path to see the directories Python searches for modules.
```
import sys
print(sys.path)
```
Check Virtual Environment: If you're using a virtual environment, make sure you've activated it before running your script or program. The virtual environment may have its own set of installed modules.
Check File Names and Locations: If you're importing a module from another file, ensure that the file is located in the same directory as your script or is in a directory listed in the Python path.
Check Python Version: Some modules may be available only for specific versions of Python. Make sure that the module you're trying to import is compatible with your Python version.
Check for Typos and Syntax Errors: Double-check your code for any typos or syntax errors that may be causing the import statement to fail.
Check ImportError Message: Sometimes, the ImportError message provides additional information about why the module couldn't be imported. Review the message to see if it gives any clues about the issue.

By following these steps, you should be able to diagnose and resolve the ModuleNotFoundError: No module named 'module_name' error in Python.

check string available in list in python

To check if a string is available in a list in Python, you can use the in keyword or use the count() method. Here are examples of both methods:

Using the in keyword:

my_list = ['apple', 'banana', 'orange']

# Check if 'banana' is in the list
if 'banana' in my_list:
    print('banana is in the list')
else:
    print('banana is not in the list')

# Check if 'grape' is in the list
if 'grape' in my_list:
    print('grape is in the list')
else:
    print('grape is not in the list')

Using the count() method:

my_list = ['apple', 'banana', 'orange']

# Check if 'banana' is in the list
if my_list.count('banana') > 0:
    print('banana is in the list')
else:
    print('banana is not in the list')

# Check if 'grape' is in the list
if my_list.count('grape') > 0:
    print('grape is in the list')
else:
    print('grape is not in the list')

Both methods will output:

banana is in the list
grape is not in the list

Choose the method that best fits your specific use case and coding style. Using the in keyword is generally more Pythonic and concise.

get file extension python

To get the file extension from a file path or filename in Python, you can use the os.path.splitext() function. Here's how:

import os

file_path = '/path/to/your/file.txt'

# Split the file path into base name and extension
file_name, file_extension = os.path.splitext(file_path)

# Print the file extension
print("File extension:", file_extension)

This code will print the file extension of the given file path, which in this case would be ".txt".

If you only have the filename without the path, you can still use the same method:

import os

file_name = 'your_file.txt'

# Split the file name into base name and extension
base_name, file_extension = os.path.splitext(file_name)

# Print the file extension
print("File extension:", file_extension)

This will still print ".txt" as the file extension. The os.path.splitext() function splits the given path into a tuple containing the base name and the extension.

call rest api in python

To call a REST API in Python, you can use the requests library, which is a popular HTTP library for making HTTP requests. Here's a basic example of how you can use requests to make a GET request to a REST API endpoint:

import requests

# Define the API endpoint URL
url = 'https://api.example.com/data'

# Make a GET request to the API endpoint
response = requests.get(url)

# Check if the request was successful (status code 200)
if response.status_code == 200:
    # Print the response content (JSON data or text)
    print(response.json())  # Use response.json() if the response contains JSON data
    # Alternatively, use response.text to get the response as a string
else:
    print('Failed to fetch data:', response.status_code)

In this example:

We import the requests library.
We define the URL of the API endpoint we want to call.
We use requests.get() to make a GET request to the specified URL.
We check if the request was successful (status code 200) and print the response content if it was.
If the request was not successful, we print an error message along with the status code.

You can also make POST, PUT, DELETE, or other types of requests using requests.post(), requests.put(), requests.delete(), etc., depending on the requirements of the REST API you are interacting with. Additionally, you may need to include headers, query parameters, or request body data depending on the specific API endpoint you are working with.

print json with tab + python

To print JSON data with an indentation (tabs), you can use the json.dumps() function from the json module in Python. This function allows you to serialize Python objects to JSON format with customizable formatting options, including indentation. Here's how you can do it:

import json

# Sample JSON data
data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

# Serialize the JSON data with indentation
json_str = json.dumps(data, indent=4)

# Print the indented JSON string
print(json_str)

In this example:

We import the json module.
We define a sample JSON data dictionary data.
We use json.dumps(data, indent=4) to serialize the JSON data with an indentation of 4 spaces.
The resulting JSON string with indentation is printed using print(json_str).

This will print the JSON data with each nested level indented by 4 spaces. You can adjust the indent parameter to customize the indentation size according to your preference. If you prefer to use tabs for indentation, you can simply specify indent='\t' instead of indent=4.

add headers in request post

To add headers to a POST request using the requests library in Python, you can pass a dictionary containing the headers to the headers parameter of the requests.post() function. Here's how you can do it:

import requests

# Define the API endpoint URL
url = 'https://api.example.com/data'

# Define the headers to be included in the request
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer your_access_token'
}

# Define the data to be sent in the POST request
data = {
    'key': 'value'
}

# Make a POST request to the API endpoint with headers and data
response = requests.post(url, headers=headers, json=data)

# Check if the request was successful (status code 200)
if response.status_code == 200:
    # Print the response content (JSON data or text)
    print(response.json())  # Use response.json() if the response contains JSON data
    # Alternatively, use response.text to get the response as a string
else:
    print('Failed to fetch data:', response.status_code)

In this example:

We define the URL of the API endpoint we want to call.
We define the headers to be included in the request as a dictionary.
We define the data to be sent in the POST request as another dictionary.
We make a POST request to the API endpoint using requests.post(), passing the URL, headers, and data as parameters.
We check if the request was successful and print the response content if it was.

Make sure to replace 'your_access_token' with your actual access token and adjust the 'Content-Type' header according to the data you are sending. You can include any additional headers required by the API in the headers dictionary.

decrease 2 in each number in a list + python

To decrease each number in a list by 2 in Python, you can use a list comprehension or a loop to iterate through the list and subtract 2 from each element. Here's how you can do it:

Using a list comprehension:

# Original list
original_list = [10, 20, 30, 40, 50]

# Decrease each number in the list by 2
decreased_list = [x - 2 for x in original_list]

print(decreased_list)

Using a loop:

# Original list
original_list = [10, 20, 30, 40, 50]

# Create an empty list to store the decreased numbers
decreased_list = []

# Iterate through the original list and decrease each number by 2
for num in original_list:
    decreased_list.append(num - 2)

print(decreased_list)

Both approaches will produce the same output, which is [8, 18, 28, 38, 48], where each number in the original list is decreased by 2. Choose the one that you find more readable or fits better in your code context.

how-do-i-check-whether-a-file-exists-without-exceptions in python

To check whether a file exists without raising exceptions in Python, you can use the os.path.exists() function from the os module. This function returns True if the file exists and False otherwise. Here's how you can use it:

import os

file_path = '/path/to/your/file.txt'

if os.path.exists(file_path):
    print(f"The file '{file_path}' exists.")
else:
    print(f"The file '{file_path}' does not exist.")

Replace '/path/to/your/file.txt' with the actual file path you want to check.

Using os.path.exists() is a straightforward way to check for the existence of a file without raising exceptions. It's a simple and efficient approach that works across different platforms.

replace key name in dictionary in python

To replace a key name in a dictionary in Python, you can create a new dictionary with the updated key names and values, or you can modify the existing dictionary in place. Here's how you can do it:

Creating a new dictionary with updated key names:

# Original dictionary
original_dict = {'old_key1': 'value1', 'old_key2': 'value2', 'old_key3': 'value3'}

# New dictionary with updated key names
new_dict = {new_key if old_key == 'old_key1' else old_key: value 
            for old_key, value in original_dict.items()}

print(new_dict)

Modifying the existing dictionary in place:

# Original dictionary
original_dict = {'old_key1': 'value1', 'old_key2': 'value2', 'old_key3': 'value3'}

# Replace the key name in the original dictionary
original_dict['new_key1'] = original_dict.pop('old_key1')

print(original_dict)

In both approaches, 'old_key1' is replaced with 'new_key1'. You can adjust the condition or key names as needed for your specific use case. Make sure to handle cases where the old key doesn't exist in the dictionary to avoid errors.

do lowercase all keys in a dictionary in python

To lowercase all keys in a dictionary in Python, you can create a new dictionary with lowercase keys by iterating over the original dictionary's items and converting the keys to lowercase. Here's how you can do it:

# Original dictionary
original_dict = {'Key1': 'value1', 'Key2': 'value2', 'Key3': 'value3'}

# Create a new dictionary with lowercase keys
lowercase_dict = {key.lower(): value for key, value in original_dict.items()}

print(lowercase_dict)

This will create a new dictionary lowercase_dict with all keys converted to lowercase, while preserving the values from the original dictionary. Note that this approach does not modify the original dictionary; it creates a new one with the desired modifications.

sublist with random items in python

If you want to create a sublist with random items from a given list in Python, you can use the random.sample() function. Here's how you can do it:

import random

# Original list
original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Number of items to select randomly
num_items = 3

# Create a sublist with random items
random_sublist = random.sample(original_list, num_items)

print(random_sublist)

In this example, random.sample() selects num_items random elements from original_list without replacement, meaning that each element is selected only once. The selected elements are then returned as a new list, random_sublist.

You can adjust num_items to specify how many random items you want to select for your sublist.

check number inside string python

If you want to check if a string contains a number in Python, you can use regular expressions (re module) or iterate through the characters of the string and check each character if it's a digit. Here's how you can do it using both methods:

Using regular expressions:

import re

def contains_number(string):
    return bool(re.search(r'\d', string))

# Test the function
print(contains_number("abc123"))  # True
print(contains_number("abc"))     # False

Using iteration:

def contains_number(string):
    for char in string:
        if char.isdigit():
            return True
    return False

# Test the function
print(contains_number("abc123"))  # True
print(contains_number("abc"))     # False

Both approaches will return True if the string contains at least one digit, and False otherwise. Choose the method that best fits your specific use case and coding style.

check number inside string python

If you want to check if a string contains a number in Python, you can use a loop to iterate through each character of the string and check if it is a digit using the isdigit() method. Here's how you can do it:

def contains_number(string):
    for char in string:
        if char.isdigit():
            return True
    return False

# Test cases
print(contains_number("abc123"))  # Output: True
print(contains_number("abc"))     # Output: False

This function contains_number() takes a string as input and returns True if the string contains at least one digit, and False otherwise.

In the example above:

"abc123" contains at least one digit, so contains_number("abc123") returns True.
"abc" does not contain any digits, so contains_number("abc") returns False.

You can use this function to check if a string contains a number in your Python code.

list1 - list2 in python

If you want to get the difference between two lists in Python, you can use list comprehension or the difference() method if you are working with sets. Here are both approaches:

Using list comprehension:

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

# Get the elements in list1 that are not in list2
difference = [x for x in list1 if x not in list2]

print(difference)  # Output: [1, 2]

Using sets:

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

# Convert lists to sets and get the difference
difference = list(set(list1) - set(list2))

print(difference)  # Output: [1, 2]

Both approaches will give you the elements that are present in list1 but not in list2. Choose the one that fits your preference or requirements.

how-to-make-sys-argv-arguments-optional

To make sys.argv arguments optional, you can check the length of sys.argv and provide default values or handle the absence of arguments accordingly. Here's how you can do it:

import sys

# Check if arguments are provided
if len(sys.argv) > 1:
    arg1 = sys.argv[1]
    arg2 = sys.argv[2]
else:
    # Provide default values or handle the absence of arguments
    arg1 = "default_value1"
    arg2 = "default_value2"

# Now you can use arg1 and arg2 in your code
print("Argument 1:", arg1)
print("Argument 2:", arg2)

In this example:

We check if there are more than 1 arguments in sys.argv, which indicates that arguments have been provided.
If arguments are provided, we assign them to variables arg1 and arg2.
If no arguments are provided, we set default values for arg1 and arg2.
You can adjust the default values or handling logic according to your specific requirements.

By implementing this logic, your script can handle cases where command-line arguments are optional. If no arguments are provided, default values are used, and if arguments are provided, they are used instead.

list to string python

To convert a list to a string in Python, you can use the join() method of strings. Here's how:

my_list = ['apple', 'banana', 'cherry']

# Join the elements of the list with a separator (e.g., comma)
result_string = ', '.join(my_list)

print(result_string)

Output:

apple, banana, cherry

In this example, join() concatenates each element of the list my_list into a single string, using the specified separator (, in this case). The resulting string is stored in result_string. Adjust the separator as needed for your specific use case. If the elements of the list are not strings, you will need to convert them to strings before using join().

python regex

Regular expressions, often abbreviated as regex or regexp, are sequences of characters that define a search pattern. They are widely used for string manipulation tasks such as search, match, replace, and validation. In Python, you can work with regular expressions using the re module. Here's an overview of some commonly used functions and syntax:

re.search(pattern, string): Search for the first occurrence of pattern within string.

Example:

import re

result = re.search(r'hello', 'hello world')
if result:
    print('Found')
else:
    print('Not Found')

re.match(pattern, string): Match pattern at the beginning of string.

Example:

import re

result = re.match(r'hello', 'hello world')
if result:
    print('Found')
else:
    print('Not Found')

re.findall(pattern, string): Find all occurrences of pattern within string.

Example:

import re

results = re.findall(r'\d+', 'There are 3 apples and 5 oranges')
print(results)  # Output: ['3', '5']

re.sub(pattern, repl, string): Replace occurrences of pattern in string with repl.

Example:

import re

new_string = re.sub(r'\d+', 'X', 'There are 3 apples and 5 oranges')
print(new_string)  # Output: 'There are X apples and X oranges'

Regular Expression Patterns:
- \d: Matches any decimal digit; equivalent to [0-9].
- \w: Matches any alphanumeric character; equivalent to [a-zA-Z0-9_].
- .: Matches any character except a newline.
- *: Matches zero or more occurrences of the preceding element.
- +: Matches one or more occurrences of the preceding element.
- ?: Matches zero or one occurrence of the preceding element.
- ^: Matches the start of the string.
- $: Matches the end of the string.

These are just some basic functionalities of regular expressions in Python. Regular expressions are powerful tools for string manipulation and pattern matching, and they offer many more features and options for advanced usage.

list files with specific pattern

To list files with a specific pattern in Python, you can use the os module along with list comprehension to filter the files based on the desired pattern. Here's how you can do it:

import os

# Directory path
directory = '/path/to/directory'

# Desired pattern
pattern = '.txt'  # For example, to list all files ending with '.txt'

# List files with the specific pattern
files_with_pattern = [file for file in os.listdir(directory) if file.endswith(pattern)]

# Print the list of files
for file in files_with_pattern:
    print(file)

In this example:

Replace '/path/to/directory' with the path to the directory where you want to search for files.
Set pattern to the specific pattern you want to match. For example, '.txt' will match all files ending with '.txt'.
The list comprehension [file for file in os.listdir(directory) if file.endswith(pattern)] iterates over all files in the specified directory and filters them based on whether their names end with the specified pattern.
Finally, the list of files matching the pattern is printed.

You can adjust the pattern variable to match the specific pattern you need for your use case.

argsparse multiple values for single argument + python

To handle multiple values for a single argument using argparse in Python, you can use the nargs parameter in the add_argument() method. The nargs parameter specifies how many arguments should be consumed for the option. Here's how you can use it:

import argparse

# Create ArgumentParser object
parser = argparse.ArgumentParser(description='Process some integers.')

# Add argument with multiple values
parser.add_argument('--values', nargs='+', help='List of values')

# Parse the command-line arguments
args = parser.parse_args()

# Access the list of values provided
if args.values:
    print('List of values:', args.values)
else:
    print('No values provided')

In this example:

nargs='+' specifies that the --values option can accept one or more values.
The values provided for the --values option will be stored as a list in args.values.
You can access the list of values using args.values.

Here's how you would use this script from the command line:

python script.py --values 1 2 3 4

This would output:

List of values: ['1', '2', '3', '4']

You can provide any number of values separated by spaces after --values on the command line, and they will be parsed into a list in your script.

Previouspy notes 2 Nextpy notes 4

Last updated 1 year ago