Tokenizing Strings with Python

```python
def tokenize_file(file_path):
    """Reads a file and tokenizes its contents."""
    try:
        with open(file_path, 'r') as file:
            text = file.read()
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found.")
        return []

    tokens = text.split()
    return tokens

# Example usage
file_path = 'example.txt'
tokens = tokenize_file(file_path)
print(tokens)
```

Explanation:
- The `tokenize_file` function takes a `file_path` as input.
- It opens the file using `with` statement and reads its contents into the `text` variable.
- If the file is not found, it prints an error message and returns an empty list.
- The `text` is tokenized using `str.split()`, which splits the string by whitespace characters.
- The resulting list of tokens is returned.

```python
import re

def tokenize_string(text):
    """Tokenizes a string using regex, splitting by non-word characters."""
    pattern = r'\W+'  # Match one or more non-word characters
    tokens = re.split(pattern, text)
    # Filter out empty strings
    tokens = [token for token in tokens if token]
    return tokens

# Example usage
text = "Hello, 123! This... is@sample.com"
tokens = tokenize_string(text)
print(tokens)  # Output: ['Hello', '123', 'This', 'is', 'sample', 'com']
```

Explanation:
- The `tokenize_string` function takes a `text` string as input.
- The regular expression pattern `r'\W+'` matches one or more non-word characters (digits, punctuation, whitespace).
- `re.split(pattern, text)` splits the string by the matched non-word characters.
- The resulting list of tokens may contain empty strings, so we filter them out using a list comprehension: `[token for token in tokens if token]`.
- The final list of tokens containing only word characters is returned.

```python
from nltk.tokenize import word_tokenize, sent_tokenize

def tokenize_file(file_path, tokenizer):
    """Tokenizes the contents of a file using the provided tokenizer function."""
    try:
        with open(file_path, 'r') as file:
            text = file.read()
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found.")
        return []

    tokens = tokenizer(text)
    return tokens

# Example usage with word_tokenize
file_path = 'example.txt'
tokens = tokenize_file(file_path, word_tokenize)
print("Word tokens:", tokens)

# Example usage with sent_tokenize
file_path = 'example.txt'
tokens = tokenize_file(file_path, sent_tokenize)
print("Sentence tokens:", tokens)
```

Explanation:
- The `tokenize_file` function takes a `file_path` and a `tokenizer` function as input.
- It opens the file using `with` statement and reads its contents into the `text` variable.
- If the file is not found, it prints an error message and returns an empty list.
- The `text` is tokenized using the provided `tokenizer` function.
- The resulting list of tokens is returned.
- In the example usage, the function is called with both `word_tokenize` and `sent_tokenize` from NLTK to demonstrate tokenization at word and sentence levels, respectively.

```python
import spacy

def tokenize_with_pos(text):
    """Tokenizes text using spaCy and returns tokens with part-of-speech tags."""
    nlp = spacy.load('en_core_web_sm')
    doc = nlp(text)
    tokens_with_pos = [(token.text, token.pos_) for token in doc]
    return tokens_with_pos

# Example usage
text = "The quick brown fox jumps over the lazy dog."
tokens_and_pos = tokenize_with_pos(text)
print(tokens_and_pos)
# Output: [('The', 'DET'), ('quick', 'ADJ'), ('brown', 'ADJ'), ('fox', 'NOUN'), ('jumps', 'VERB'), ('over', 'ADP'), ('the', 'DET'), ('lazy', 'ADJ'), ('dog', 'NOUN'), ('.', 'PUNCT')]
```

Explanation:
- The `tokenize_with_pos` function takes a `text` string as input.
- It loads the English language model using `spacy.load('en_core_web_sm')`.
- The `text` is tokenized and processed using `nlp(text)`, which creates a `doc` object containing the tokens and their linguistic annotations.
- A list comprehension `[(token.text, token.pos_) for token in doc]` is used to create a list of tuples, where each tuple contains the token text and its part-of-speech tag (`token.pos_`).
- The resulting list of tuples is returned.
- In the example usage, the function is called with a sample text, and the output shows the tokens along with their part-of-speech tags.

```python
def byte_level_tokenize(text):
    """Tokenizes text at the byte level, returning a list of byte values."""
    byte_tokens = []
    for char in text:
        byte_tokens.append(ord(char))
    return byte_tokens

# Example usage
text = "Hello, World!"
byte_tokens = byte_level_tokenize(text)
print(byte_tokens)
# Output: [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
```

Explanation:
- The `byte_level_tokenize` function takes a `text` string as input.
- It initializes an empty list `byte_tokens` to store the byte values.
- It iterates over each character `char` in the `text` string.
- For each character, it appends its byte value `ord(char)` to the `byte_tokens` list.
- Finally, the function returns the `byte_tokens` list containing the byte values of all characters in the input text.
- In the example usage, the function is called with the string `"Hello, World!"`, and the output shows the corresponding byte values for each character.