Функция ord() в Python: числовой код символа для программистов

ord(character)

# Получение кодов для букв английского алфавита
print(ord('A')) # Выведет: 65
print(ord('Z')) # Выведет: 90
print(ord('a')) # Выведет: 97
print(ord('z')) # Выведет: 122

# Получение кодов для цифр
print(ord('0')) # Выведет: 48
print(ord('9')) # Выведет: 57

# Получение кодов для специальных символов
print(ord(' ')) # Выведет: 32 (пробел)
print(ord('!')) # Выведет: 33
print(ord('@')) # Выведет: 64

try:
print(ord('AB')) # Вызовет ошибку
except TypeError as e:
print(f"Ошибка: {e}") # Выведет: Ошибка: ord() expected a character, but string of length 2 found

# Сравнение символов
if ord('A') < ord('B'):
print("A идет перед B в таблице кодировки") # Будет выведено

# Проверка, является ли символ заглавной буквой (для ASCII)
char = 'Q'
if 65 <= ord(char) <= 90:
print(f"{char} – заглавная буква") # Будет выведено

# Проверка, является ли символ цифрой (для ASCII)
char = '7'
if 48 <= ord(char) <= 57:
print(f"{char} – цифра") # Будет выведено

def caesar_cipher(text, shift):
"""
Шифрует текст методом Цезаря со смещением shift.
Работает только с английскими буквами.
"""
result = ""
for char in text:
if char.isalpha():
ascii_offset = ord('a') if char.islower() else ord('A')
# Формула: (код_символа – смещение_алфавита + сдвиг) % 26 + смещение_алфавита
encrypted_char = chr((ord(char) – ascii_offset + shift) % 26 + ascii_offset)
result += encrypted_char
else:
result += char
return result

# Пример использования
original = "Hello, World!"
encrypted = caesar_cipher(original, 3)
decrypted = caesar_cipher(encrypted, -3)

print(f"Оригинал: {original}")
print(f"Зашифрованный текст: {encrypted}")
print(f"Расшифрованный текст: {decrypted}")

def is_palindrome(text):
"""
Проверяет, является ли строка палиндромом, игнорируя регистр и не-буквы.
"""
# Преобразуем все символы в нижний регистр и удаляем не-буквы
clean_text = ""
for char in text:
if char.isalpha():
# Преобразование в нижний регистр с помощью ord()
if 65 <= ord(char) <= 90: # Если заглавная буква
clean_text += chr(ord(char) + 32) # Преобразуем в строчную
else:
clean_text += char

# Проверяем, является ли очищенный текст палиндромом
return clean_text == clean_text[::-1]

# Примеры использования
test_strings = [
"A man, a plan, a canal: Panama",
"Race a car",
"No 'x' in Nixon"
]

for s in test_strings:
print(f"'{s}' {'является' if is_palindrome(s) else 'не является'} палиндромом")

def analyze_character_frequency(text):
"""
Анализирует частоту символов в тексте и возвращает отсортированные результаты.
"""
frequency = {}

for char in text:
if char in frequency:
frequency[char] += 1
else:
frequency[char] = 1

# Сортировка по частоте (от большей к меньшей)
sorted_freq = sorted(frequency.items(), key=lambda x: x[1], reverse=True)

return sorted_freq

# Пример использования
sample_text = "Python is a programming language that lets you work quickly and integrate systems effectively."
frequencies = analyze_character_frequency(sample_text)

print("Частота символов:")
for char, count in frequencies[:10]: # Топ-10 символов
print(f"'{char}' (ASCII: {ord(char)}): {count} раз")

def validate_password(password):
"""
Проверяет силу пароля на основе следующих критериев:
- Длина не менее 8 символов
- Содержит как минимум одну цифру
- Содержит как минимум одну заглавную букву
- Содержит как минимум одну строчную букву
- Содержит как минимум один специальный символ
"""
if len(password) < 8:
return False, "Пароль должен содержать не менее 8 символов"

has_digit = False
has_upper = False
has_lower = False
has_special = False

for char in password:
code = ord(char)

if 48 <= code <= 57: # Цифры (0-9)
has_digit = True
elif 65 <= code <= 90: # Заглавные буквы (A-Z)
has_upper = True
elif 97 <= code <= 122: # Строчные буквы (a-z)
has_lower = True
else: # Специальные символы
has_special = True

messages = []
if not has_digit:
messages.append("Должна быть хотя бы одна цифра")
if not has_upper:
messages.append("Должна быть хотя бы одна заглавная буква")
if not has_lower:
messages.append("Должна быть хотя бы одна строчная буква")
if not has_special:
messages.append("Должен быть хотя бы один специальный символ")

is_valid = has_digit and has_upper and has_lower and has_special
message = "Пароль соответствует требованиям" if is_valid else ", ".join(messages)

return is_valid, message

# Примеры паролей для проверки
passwords = [
"password123",
"Password123",
"Password!123",
"pass"
]

for pwd in passwords:
valid, msg = validate_password(pwd)
print(f"Пароль '{pwd}': {'✅ Валиден' if valid else '❌ Невалиден'} – {msg}")

# Демонстрация взаимосвязи ord() и chr()
char = 'A'
code = ord(char)
print(f"Символ: {char} -> Код: {code}") # Символ: A -> Код: 65

char_again = chr(code)
print(f"Код: {code} -> Символ: {char_again}") # Код: 65 -> Символ: A

# Проверка равенства
print(f"Исходный символ == восстановленный символ: {char == char_again}") # True

# Генерация английского алфавита
alphabet = [chr(code) for code in range(ord('a'), ord('z') + 1)]
print("Английский алфавит:", "".join(alphabet))

# Генерация диапазона цифр
digits = [chr(code) for code in range(ord('0'), ord('9') + 1)]
print("Цифры:", "".join(digits))

# Генерация таблицы ASCII (печатаемые символы)
printable_ascii = [chr(code) for code in range(32, 127)]
print("Печатаемые ASCII-символы:", "".join(printable_ascii))

def custom_upper(text):
"""
Преобразует строку в верхний регистр, используя ord() и chr()
"""
result = ""
for char in text:
# Проверяем, является ли символ строчной буквой a-z (коды 97-122)
if 97 <= ord(char) <= 122:
# Преобразуем в заглавную букву (разница 32)
result += chr(ord(char) – 32)
else:
result += char
return result

def custom_lower(text):
"""
Преобразует строку в нижний регистр, используя ord() и chr()
"""
result = ""
for char in text:
# Проверяем, является ли символ заглавной буквой A-Z (коды 65-90)
if 65 <= ord(char) <= 90:
# Преобразуем в строчную букву (разница 32)
result += chr(ord(char) + 32)
else:
result += char
return result

# Пример использования
text = "Hello, Python!"
print(f"Оригинал: {text}")
print(f"Верхний регистр: {custom_upper(text)}")
print(f"Нижний регистр: {custom_lower(text)}")

def rle_encode(text):
"""
Реализация алгоритма RLE сжатия с использованием ord() и chr()
"""
if not text:
return ""

encoded = ""
count = 1
current_char = text[0]

for i in range(1, len(text)):
if text[i] == current_char:
count += 1
else:
# Добавляем символ и его количество
encoded += current_char + chr(count + 48) # 48 – код символа '0'
current_char = text[i]
count = 1

# Добавляем последнюю группу
encoded += current_char + chr(count + 48)

return encoded

def rle_decode(encoded_text):
"""
Декодирование RLE-сжатого текста
"""
if not encoded_text or len(encoded_text) % 2 != 0:
return "Ошибка: некорректный формат"

decoded = ""

for i in range(0, len(encoded_text), 2):
char = encoded_text[i]
count = ord(encoded_text[i+1]) – 48 # Преобразуем код обратно в число
decoded += char * count

return decoded

# Пример использования
original = "AAABBBCCDAA"
encoded = rle_encode(original)
decoded = rle_decode(encoded)

print(f"Оригинал: {original}")
print(f"Закодировано: {encoded}")
print(f"Декодировано: {decoded}")
print(f"Исходный текст == декодированный: {original == decoded}")

# Смещение символов (например, для шифрования)
def shift_char(char, offset):
"""Смещает символ на указанное количество позиций в таблице Unicode"""
return chr((ord(char) + offset) % 65536)

# Среднее значение между двумя символами
def middle_char(char1, char2):
"""Возвращает символ, находящийся между двумя указанными"""
middle_code = (ord(char1) + ord(char2)) // 2
return chr(middle_code)

# Примеры использования
print(f"A + 1 = {shift_char('A', 1)}") # B
print(f"Z – 1 = {shift_char('Z', -1)}") # Y
print(f"Символ между A и Z: {middle_char('A', 'Z')}") # M

# Примеры кодов для различных символов Unicode
examples = [
('A', "Латинская заглавная A"),
('Я', "Кириллическая заглавная Я"),
('你', "Китайский иероглиф 'ты'"),
('♠', "Пиковая масть"),
('€', "Символ евро"),
('😊', "Эмодзи 'улыбающееся лицо'")
]

for char, description in examples:
print(f"Символ: {char} | Описание: {description} | Unicode-код: {ord(char)}")

# Примеры многобайтовых символов
complex_examples = [
('🌍', "Эмодзи земного шара"),
('👨‍👩‍👧‍👦', "Эмодзи семьи"),
('🏳️‍🌈', "Радужный флаг")
]

for char, description in complex_examples:
try:
print(f"Символ: {char} | Описание: {description} | Unicode-код: {ord(char)}")
except TypeError as e:
print(f"Ошибка при обработке {char}: {e}")

def convert_cyrillic_to_latin(text):
"""
Простая транслитерация кириллицы в латиницу
"""
conversion_map = {
ord('а'): 'a', ord('б'): 'b', ord('в'): 'v', ord('г'): 'g',
ord('д'): 'd', ord('е'): 'e', ord('ё'): 'yo', ord('ж'): 'zh',
ord('з'): 'z', ord('и'): 'i', ord('й'): 'y', ord('к'): 'k',
ord('л'): 'l', ord('м'): 'm', ord('н'): 'n', ord('о'): 'o',
ord('п'): 'p', ord('р'): 'r', ord('с'): 's', ord('т'): 't',
ord('у'): 'u', ord('ф'): 'f', ord('х'): 'kh', ord('ц'): 'ts',
ord('ч'): 'ch', ord('ш'): 'sh', ord('щ'): 'sch', ord('ъ'): '',
ord('ы'): 'y', ord('ь'): '', ord('э'): 'e', ord('ю'): 'yu',
ord('я'): 'ya'
}

# Добавляем заглавные буквы
capital_map = {}
for cyrillic_code, latin_char in conversion_map.items():
# Получаем заглавную букву, добавляя разницу между строчными и заглавными
capital_cyrillic_code = cyrillic_code – 32 if cyrillic_code != ord('ё') else ord('Ё')
capital_map[capital_cyrillic_code] = latin_char.capitalize()

conversion_map.update(capital_map)

# Применяем преобразование
result = ""
for char in text:
char_code = ord(char)
if char_code in conversion_map:
result += conversion_map[char_code]
else:
result += char

return result

# Пример использования
russian_text = "Привет, мир! Как дела?"
transliterated = convert_cyrillic_to_latin(russian_text)
print(f"Оригинал: {russian_text}")
print(f"Транслитерация: {transliterated}")

def validate_unicode_ranges(text, allowed_ranges):
"""
Проверяет, что все символы в тексте находятся в допустимых диапазонах Unicode.

Параметры:
- text: проверяемый текст
- allowed_ranges: список кортежей (start, end) с допустимыми диапазонами Unicode

Возвращает:
- True, если все символы допустимы, иначе False и список недопустимых символов
"""
invalid_chars = []

for char in text:
char_code = ord(char)
if not any(start <= char_code <= end for start, end in allowed_ranges):
invalid_chars.append((char, char_code))

if invalid_chars:
return False, invalid_chars
else:
return True, []

# Пример использования: проверка, что текст содержит только латинские, кириллические буквы и базовую пунктуацию
allowed_ranges = [
(32, 126), # Базовые ASCII символы (включая латиницу и пунктуацию)
(1040, 1103), # Кириллические символы
(0, 31), # Управляющие символы (например, новая строка)
]

texts_to_check = [
"Hello, world! Привет, мир!",
"Hello, мир! 😊"
]

for text in texts_to_check:
valid, invalid = validate_unicode_ranges(text, allowed_ranges)
if valid:
print(f"Текст '{text}' содержит только допустимые символы")
else:
print(f"Текст '{text}' содержит недопустимые символы:")
for char, code in invalid:
print(f" – '{char}' (код: {code})")

def custom_unicode_sort(strings, ordering=None):
"""
Сортирует строки с учетом пользовательского порядка символов.

Параметры:
- strings: список строк для сортировки
- ordering: словарь весов символов для сортировки
"""
if ordering is None:
# По умолчанию используем стандартную сортировку по Unicode
return sorted(strings)

def get_string_weight(s):
"""Рассчитывает вес строки для сортировки"""
weight = []
for char in s:
char_code = ord(char)
# Если символ есть в ordering, используем его вес, иначе код символа
char_weight = ordering.get(char_code, char_code)
weight.append(char_weight)
return weight

return sorted(strings, key=get_string_weight)

# Пример: кастомная сортировка с учетом русского алфавита
# В этом примере мы ставим русские буквы перед латинскими
cyrillic_first_ordering = {}

# Даем русским буквам меньший вес
for i, code in enumerate(range(ord('А'), ord('я') + 1)):
cyrillic_first_ordering[code] = i

# Латинским буквам даем больший вес
for i, code in enumerate(range(ord('A'), ord('z') + 1)):
cyrillic_first_ordering[code] = i + 1000

# Пример сортировки
mixed_strings = ["Apple", "Яблоко", "Banana", "Банан", "Cherry", "Вишня"]

# Стандартная сортировка (по Unicode)
std_sorted = sorted(mixed_strings)
print("Стандартная сортировка:", std_sorted)

# Кастомная сортировка (кириллица перед латиницей)
custom_sorted = custom_unicode_sort(mixed_strings, cyrillic_first_ordering)
print("Кастомная сортировка:", custom_sorted)