Как узнать номер символа в питоне

В этом уроке мы узнаем, как найти значение кода символа ASCII в Python и отобразить результат. ASCII — это аббревиатура, обозначающая американский стандартный код для обмена информацией. Определенное числовое значение дается различным символам, которые компьютеры должны хранить и обрабатывать в ASCII.

ASCII чувствительна к регистру. Один и тот же символ, имеющий разный формат (верхний и нижний регистр), имеет разное значение. Например, значение ASCII “A” равно 65, а значение ASCII “a” равно 97.

Пример 1:

 
K = input("Please enter a character: ")   
   
print("The ASCII value of '" + K + "' is ", ord(K)) 

Выход:

1#

Please enter a character: J 
The ASCII value of 'J' is 74 

2#

Please enter a character: $ 
The ASCII value of '$' is 36 

В приведенном выше коде мы использовали функцию ord() для преобразования символа в целое число, то есть значение ASCII. Эта функция используется для возврата кодовой точки Unicode данного символа.

Пример 2:

 
print("Please enter the String: ", end = "") 
string = input() 
string_length = len(string) 
for K in string: 
    ASCII = ord(K) 
    print(K, "t", ASCII) 

Выход:

Please enter the String:  
 "JavaTpoint# 
"   34 
J   74 
a   97 
v   118 
a   97 
T   84 
p   112 
o   111 
i   105 
n   110 
t   116 
#   35 

Юникод также является методом кодирования, который используется для получения уникального номера символа. Хотя ASCII может кодировать только 128 символов, тогда как текущий Unicode может кодировать более 100 000 символов из сотен сценариев.

Мы также можем преобразовать значение ASCII в соответствующее символьное значение. Для этого мы должны использовать chr() вместо ord() в приведенном выше коде.

Пример 3:

 
K = 21   
J = 123 
R = 76 
print("The character value of 'K' ASCII value is: ", chr(K))   
print("The character value of 'J' ASCII value is: ", chr(J))   
print("The character value of 'R' ASCII value is: ", chr(R)) 

Выход:

The character value of 'K' ASCII value is:  
The character value of 'J' ASCII value is: { 
The character value of 'R' ASCII value is: L 

Заключение

В этом руководстве мы обсудили, как пользователь может преобразовать значение символа в значение ASCII, а также как получить значение символа данного кода ASCII.

Строки

Содержание

• Строки
  • Тип str
  • Доступ к символам и срезы строк
  • Конкатенация и неизменяемость строк
  • Сравнение строк
• Некоторые методы строк
  • Поиск
  • Подсчёт
  • Замена
  • Разбиение и объединение
• Префикс-функция, алгоритм Кнута-Морриса-Пратта, Z-функция
• Контест №12

Строки

Строки предоставляют возможность хранить и оперировать с данными, представленными в виде последовательности символов.
Язык Python из «коробки» имеет широкую поддержку строк и позволяет обращаться с символами из самых разных алфавитов.

Тип str

Для взаимодействия со строками в языке есть встроенный тип str.
Его литералом являются одиночные ' или двойные кавычки ".
Символы (код), заключенный между кавычками будет восприниматься Python, как строка:

>>> s1 = 'Привет! Я строка!'
>>> s2 = "Привет! Я тоже строка!"
>>> type(s1)
<class 'str'>
>>> type(s2)
<class 'str'>

Строка может быть пустой: '' или "".

Чтобы воспользоваться кавычками внутри строки, есть два пути:

1. Воспользоваться в качестве литерала одним видом кавычек, а внутри строки пользоваться вторым видом кавычек;
2. Экранировать кавычки внутри строки с помощью символа экранирования (escape character) , он же называется обратной косой чертой.

Например:

>>> s4 = ''Я внутри одинарных кавычек', а "я внутри двойных"'
>>> s4
''Я внутри одинарных кавычек', а "я внутри двойных"'
>>> print(s4)
'Я внутри одинарных кавычек', а "я внутри двойных"

Здесь в качестве литерала взяты одинарные кавычки, для первой части фразы используется экранирование, а для второй двойные.

Более того, для удобного написания многострочной строки (простите), можно воспользоваться тройными одинарными или тройными двойными кавычками, причём внутри такой строки экранирование не понадобится:

>>> multiline_str = '''Я первая строка
... I'm the second line
... А я третья!'''
>>> multiline_str
"Я первая строкаnI'm the second linenА я третья!"
>>> print(multiline_str)
Я первая строка
I'm the second line
А я третья!

Заметьте, что во второй строке экранирование кавычки не понадобилось (I'm).

Также, вы могли заметить, что при вызове в интерактивном режиме строка отображается в виде, в котором представлена в программе, и только при печати print() отображается ожидаемо.
В случае печати чисел это было не заметно.

Напоследок, небольшой список часто используемых экранированных последовательностей (escape sequence):

• символ новой строки n
• табуляция t, с помощью табуляции можно получать удобные для чтения таблицы
• кавычки ', "
• обратная косая \

Доступ к символам и срезы строк

Так же, как и список, строка это упорядоченная последовательность.
Если список это последовательность объектов произвольного типа, то строка это последовательность символов.

Можно узнать длину строки, получить символ на определённой позиции и даже получить срез строки:

>>> s = "Hello, World!"
>>> len(s)
13
>>> s[0]
'H'
>>> s[7:]
'World!'
>>> s[::2]
'Hlo ol!'

Конкатенация и неизменяемость строк

Простейшая операция над двумя строками это конкатенация — приписывание второй строки в конец первой:

>>> str_1 = "ABC"
>>> str_2 = "def"
>>> str_1 + str_2
'ABCdef'
>>> str_2 + str_1
'defABC'

Более того, с помощью символа умножения * можно конкатенировать строку с самой собой несколько раз:

>>> str_1
'ABC'
>>> str_1 * 10
'ABCABCABCABCABCABCABCABCABCABC'
>>> 5 * str_1
'ABCABCABCABCABC'
>>> str_1
'ABC'
>>> str_2
'def'
>>> (str_1 + str_2) * 5
'ABCdefABCdefABCdefABCdefABCdef'

Строки являются неизменяемым типом в Python.
При попытке изменения символа на какой-то позиции произойдёт ошибка:

>>> s = 'ваза'
>>> s[0] = 'б'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

На самом деле, в примерах по конкатенации Python создавал новые объекты строк.
Даже операция инкрементирования создаёт новую строку, в чём можно убедиться, узнав их идентификатор (в данном случае это равносильно адресу в памяти):

>>> s = 'a'
>>> id(s)
4465232176
>>> s += 'b'
>>> s
'ab'
>>> id(s)
4466564720

Сравнение строк

Строки в Python можно сравнивать между собой.

Сначала посмотрим на сравнение символов.

>>> '0' < '1'
True
>>> 'a' < 'b'
True
>>> '.' < ','
False

И если с символами 0, 1, a, b результат интуитивен, то последнее сравнение (знаков препинания) неочевидно.

Не будем гадать. Существует кодовая таблица символов, которая приписывает каждому символу порядковый номер. При сравнении символов сравниваются их порядковые номера.

В языке Python, чтобы узнать порядковый номер символа, воспользуйтесь функцией ord(s)

>>> '.' < ','
False
>>> ord('.')
46
>>> ord(',')
44
>>> 46 < 44
False

Сразу приведём функцию, обратную функции ord, это функция chr(i)

>>> ord('a')
97
>>> chr(97)
'a'

Историческим стандартом кодовых таблиц символов является таблица ASCII (American standard code for information interchange). Изначально таблица содержала 128 символов (по 7 бит на символ), затем она была расширена до 256 символов, где первые 128 символов остались без изменений, а вторая половина отводилась под национальные алфавиты, что породило множество национально-специфичных кодировок.

Современный стандарт — кодировка Unicode. Python работает с ней. Целью данной кодировки является создать «алфавит» для любых естественных и выдуманных языков и символов вообще. В Unicode первые 128 символов — символы ASCII.

Рекомендуется ознакомиться с таблицей ASCII. Например, здесь. Вы заметите, что символы алфавитов расположены в алфавитном порядке. Как раз за этим и кроется «интуитивность» сравнения 'a' < 'b'.

В Unicode также сохраняется этот удобный паттерн и для других языков, но стоит быть осторожным

>>> 'б' < 'ё'
True
>>> 'Б' < 'Ё'
False

Поскольку, скажем, буквы расположены непрерывно в ASCII, то вы можете проверять, является ли символ буквой (строчные и заглавные случаи нужно рассматривать отдельно).

>>> 'a' <= '0' <= 'z'
False
>>> 'a' <= 'y' <= 'z'
True

Аналогично этому примеру попробуйте написать условие проверки символа на десятичную цифру.

Итак, отдельные символы сравниваются по их порядковым номерам. Как же сравниваются строки? Всё просто. Так же, как слова отсортированы в словаре в алфавитном порядке, так же и в машинном представлении, только алфавитом является кодовая таблица (в случае Python это Unicode).

То есть, сравниваем строки посимвольно слева направо. Если символы разные, то меньшей строкой является та, у которой порядковой номер символа меньше. Если же символы одинаковые, то сравниваем следующие два символа. Если мы достигли конца одной строк в таком сравнении, до сих пор не выявив, кто меньше, то меньшей считается более короткая строка.

>>> 'aa' < 'aaa'
True
>>> 'ab' < 'aaa'
False

В первом примере первые два символа строк совпадают, однако в строке aa два символа, а в строке aaa — три. В этом случае меньшей строкой является та, что короче.

Во втором примере первые два символа совпадают, вторые же нет. Поскольку порядок ord('b') > ord('a'), то получаем False.

Некоторые методы строк

У строк в Python огромное количество методов.
Не верите?
Вот они:

str.capitalize()
str.casefold()
str.center(width[, fillchar])
str.count(sub[, start[, end]])
str.encode(encoding="utf-8", errors="strict")
str.endswith(suffix[, start[, end]])
str.expandtabs(tabsize=8)
str.find(sub[, start[, end]])
str.format(*args, **kwargs)
str.format_map(mapping)
str.index(sub[, start[, end]])
str.isalnum()
str.isalpha()
str.isascii()
str.isdecimal()
str.isdigit()
str.isidentifier()
str.islower()
str.isnumeric()
str.isprintable()
str.isspace()
str.istitle()
str.isupper()
str.join(iterable)
str.ljust(width[, fillchar])
str.lower()
str.lstrip([chars])
static str.maketrans(x[, y[, z]])
str.partition(sep)
str.replace(old, new[, count])
str.rfind(sub[, start[, end]])
str.rindex(sub[, start[, end]])
str.rjust(width[, fillchar])
str.rpartition(sep)
str.rsplit(sep=None, maxsplit=-1)
str.rstrip([chars])
str.split(sep=None, maxsplit=-1)
str.splitlines([keepends])
str.startswith(prefix[, start[, end]])
str.strip([chars])
str.swapcase()
str.title()
str.translate(table)
str.upper()
str.zfill(width)

Мы разберём только некоторые из них (для остальных есть help(str.method_name)

Поиск

Метод str.find ищет подстроку в строке и возвращает индекс начала найденной подстроки.
Если вхождение не найдено, вернётся -1:

>>> s = 'Hello, World!'
>>> s.find('World')
7
>>> s[7]
'W'
>>> s.find('Universe')
-1

Этот метод имеет два необязательных аргумента start и end.
Если их указать, то поиск будет осуществляться в срезе строки s[start:end]:

>>> s
'Hello, World!'
>>> s.find('o')
4
>>> s[3:6]
'lo,'
>>> s.find('o', 7)
8
>>> s[7:10]
'Wor'

И, как видно, str.find осуществляет поиск первого вхождения подстроки, начиная слева.

Чтобы осуществить поиск подстроки, начиная справа (т.е. с конца) строки, можно воспользоваться методом str.rfind.
Сравните:

>>> s
'Hello, World!'
>>> s.rfind('o')
8
>>> s.find('o')
4

Метод str.rfind имеет тот же интерфейс, что и str.find: он имеет два необязательных аргумента, чтобы задать диапазон поиска и возвращает -1, если подстрока не найдена.

Подсчёт

Методом str.count можно подсчитать количество вхождений подстроки в строку:

>>> s = 'Пингвины не любят окна.'
>>> s.count('а')
1
>>> s.count('ин')
2
>>> s.count('яблоки')
0

Диапазон поиска можно указать так же, как в str.find.

Замена

Для замены подстроки в строке существует метод str.replace:

>>> src = 'Пингвины не любят окна.'
>>> replaced = src.replace('Пингвины', 'Даже окна')
>>> src
'Пингвины не любят окна.'
>>> replaced
'Даже окна не любят окна.'

Так как строки в Python неизменяемые, то str.replace на базе исходной строки создает и возвращает новую.

У этого метода есть дополнительный параметр — количество производимых замен.
Если этот параметр выставлен в -1 (значение по умолчанию), то произойдёт замена всех вхождений.

>>> s = 'aaaaa'
>>> s.replace('a', 'b')
'bbbbb'
>>> s.replace('a', 'b', 3)
'bbbaa'

Разбиение и объединение

По существу, вы уже знакомы с этими операциями и применяли их.

Можно разбивать строку на основе подстроки с помощью str.split.
Результатом этой операции является список.
Например, может стоять задача по разбиению предложения на слова:

>>> sentence = 'Пингвины не любят окна.'
>>> sentence.split()
['Пингвины', 'не', 'любят', 'окна.']
>>> sentence2 = 'вставка, выбор, пузырёк, подсчёт, Хоар, слияние'
>>> sentence2.split(', ')
['вставка', 'выбор', 'пузырёк', 'подсчёт', 'Хоар', 'слияние']

В первом случае в качестве подстроки для разбиения используется значение по умолчанию: разбиение по символам, обозначающих пустое пространство (пробелы, табуляция, перенос строки).
Во втором случае разбиение задано явно — по подстроке ', '.

Больше примеров:

>>> sentence3 = 'вставка -- выбор -- пузырёк -- подсчёт -- Хоар -- слияние'
>>> sentence3.split()
['вставка', '--', 'выбор', '--', 'пузырёк', '--', 'подсчёт', '--', 'Хоар', '--', 'слияние']
>>> sentence3.split('--')
['вставка ', ' выбор ', ' пузырёк ', ' подсчёт ', ' Хоар ', ' слияние']
>>> sentence3.split(' -- ')
['вставка', 'выбор', 'пузырёк', 'подсчёт', 'Хоар', 'слияние']

У str.split есть ещё один необязательный аргумент — количество разбиений.

Итак, str.split разбивает строку по подстроке и возвращает список строк.
Обратная операция это объединение массива строк в одну строку, она осуществляется с помощью str.join:

>>> sentence3 = 'вставка -- выбор -- пузырёк -- подсчёт -- Хоар -- слияние'
>>> sort_algs = sentence3.split(' -- ')
>>> sort_algs
['вставка', 'выбор', 'пузырёк', 'подсчёт', 'Хоар', 'слияние']
>>> ''.join(sort_algs)
'вставкавыборпузырёкподсчётХоарслияние'
>>> ' '.join(sort_algs)
'вставка выбор пузырёк подсчёт Хоар слияние'
>>> ' + '.join(sort_algs)
'вставка + выбор + пузырёк + подсчёт + Хоар + слияние'

Этот метод более гибкий для входных данных и позволяет объединять не только список строк, но и любой другой итерируемый объект.
Главное, чтобы этот объект содержал только строки:

>>> ' '.join(range(10))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found
>>> ' '.join(map(str, range(10)))
'0 1 2 3 4 5 6 7 8 9'

The standard module unicodedata defines a lot of properties, but not everything. A quick peek at its source confirms this.

Fortunately unicodedata.txt, the data file where this comes from, is not hard to parse. Each line consists of exactly 15 elements, ; separated, which makes it ideal for parsing. Using the description of the elements on ftp://ftp.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.html, you can create a few classes to encapsulate the data. I’ve taken the names of the class elements from that list; the meaning of each of the elements is explained on that same page.

Make sure to download ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt and ftp://ftp.unicode.org/Public/UNIDATA/Blocks.txt first, and put them inside the same folder as this program.

Code (tested with Python 2.7 and 3.6):

# -*- coding: utf-8 -*-

class UnicodeCharacter:
    def __init__(self):
        self.code = 0
        self.name = 'unnamed'
        self.category = ''
        self.combining = ''
        self.bidirectional = ''
        self.decomposition = ''
        self.asDecimal = None
        self.asDigit = None
        self.asNumeric = None
        self.mirrored = False
        self.uc1Name = None
        self.comment = ''
        self.uppercase = None
        self.lowercase = None
        self.titlecase = None
        self.block = None

    def __getitem__(self, item):
        return getattr(self, item)

    def __repr__(self):
        return '{'+self.name+'}'

class UnicodeBlock:
    def __init__(self):
        self.first = 0
        self.last = 0
        self.name = 'unnamed'

    def __repr__(self):
        return '{'+self.name+'}'

class BlockList:
    def __init__(self):
        self.blocklist = []
        with open('Blocks.txt','r') as uc_f:
            for line in uc_f:
                line = line.strip(' rn')
                if '#' in line:
                    line = line.split('#')[0].strip()
                if line != '':
                    rawdata = line.split(';')
                    block = UnicodeBlock()
                    block.name = rawdata[1].strip()
                    rawdata = rawdata[0].split('..')
                    block.first = int(rawdata[0],16)
                    block.last = int(rawdata[1],16)
                    self.blocklist.append(block)
            # make 100% sure it's sorted, for quicker look-up later
            # (it is usually sorted in the file, but better make sure)
            self.blocklist.sort (key=lambda x: block.first)

    def lookup(self,code):
        for item in self.blocklist:
            if code >= item.first and code <= item.last:
                return item.name
        return None

class UnicodeList:
    """UnicodeList loads Unicode data from the external files
    'UnicodeData.txt' and 'Blocks.txt', both available at unicode.org

    These files must appear in the same directory as this program.

    UnicodeList is a new interpretation of the standard library
    'unicodedata'; you may first want to check if its functionality
    suffices.

    As UnicodeList loads its data from an external file, it does not depend
    on the local build from Python (in which the Unicode data gets frozen
    to the then 'current' version).

    Initialize with

        uclist = UnicodeList()
    """
    def __init__(self):

        # we need this first
        blocklist = BlockList()
        bpos = 0

        self.codelist = []
        with open('UnicodeData.txt','r') as uc_f:
            for line in uc_f:
                line = line.strip(' rn')
                if '#' in line:
                    line = line.split('#')[0].strip()
                if line != '':
                    rawdata = line.strip().split(';')
                    parsed = UnicodeCharacter()
                    parsed.code = int(rawdata[0],16)
                    parsed.characterName = rawdata[1]
                    parsed.category = rawdata[2]
                    parsed.combining = rawdata[3]
                    parsed.bidirectional = rawdata[4]
                    parsed.decomposition = rawdata[5]
                    parsed.asDecimal = int(rawdata[6]) if rawdata[6] else None
                    parsed.asDigit = int(rawdata[7]) if rawdata[7] else None
                    # the following value may contain a slash:
                    #  ONE QUARTER ... 1/4
                    # let's make it Python 2.7 compatible :)
                    if '/' in rawdata[8]:
                        rawdata[8] = rawdata[8].replace('/','./')
                        parsed.asNumeric = eval(rawdata[8])
                    else:
                        parsed.asNumeric = int(rawdata[8]) if rawdata[8] else None
                    parsed.mirrored = rawdata[9] == 'Y'
                    parsed.uc1Name = rawdata[10]
                    parsed.comment = rawdata[11]
                    parsed.uppercase = int(rawdata[12],16) if rawdata[12] else None
                    parsed.lowercase = int(rawdata[13],16) if rawdata[13] else None
                    parsed.titlecase = int(rawdata[14],16) if rawdata[14] else None
                    while bpos < len(blocklist.blocklist) and parsed.code > blocklist.blocklist[bpos].last:
                        bpos += 1
                    parsed.block = blocklist.blocklist[bpos].name if bpos < len(blocklist.blocklist) and parsed.code >= blocklist.blocklist[bpos].first else None
                    self.codelist.append(parsed)

    def find_code(self,codepoint):
        """Find the Unicode information for a codepoint (as int).

        Returns:
            a UnicodeCharacter class object or None.
        """
        # the list is unlikely to contain duplicates but I have seen Unicode.org
        # doing that in similar situations. Again, better make sure.
        val = [x for x in self.codelist if codepoint == x.code]
        return val[0] if val else None

    def find_char(self,str):
        """Find the Unicode information for a codepoint (as character).

        Returns:
            for a single character: a UnicodeCharacter class object or
            None.
            for a multicharacter string: a list of the above, one element
            per character.
        """
        if len(str) > 1:
            result = [self.find_code(ord(x)) for x in str]
            return result
        else:
            return self.find_code(ord(str))

When loaded, you can now look up a character code with

>>> ul = UnicodeList()     # ONLY NEEDED ONCE!
>>> print (ul.find_code(0x204))
{LATIN CAPITAL LETTER E WITH DOUBLE GRAVE}

which by default is shown as the name of a character (Unicode calls this a ‘code point’), but you can retrieve other properties as well:

>>> print ('%04X' % uc.find_code(0x204).lowercase)
0205
>>> print (ul.lookup(0x204).block)
Latin Extended-B

and (as long as you don’t get a None) even chain them:

>>> print (ul.find_code(ul.find_code(0x204).lowercase))
{LATIN SMALL LETTER E WITH DOUBLE GRAVE}

It does not rely on your particular build of Python; you can always download an updated list from unicode.org and be assured to get the most recent information:

import unicodedata
>>> print (unicodedata.name('U0001F903'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: no such name
>>> print (uclist.find_code(0x1f903))
{LEFT HALF CIRCLE WITH FOUR DOTS}

(As tested with Python 3.5.3.)

There are currently two lookup functions defined:

• find_code(int) looks up character information by codepoint as an integer.
• find_char(string) looks up character information for the character(s) in string. If there is only one character, it returns a UnicodeCharacter object; if there are more, it returns a list of objects.

After import unicodelist (assuming you saved this as unicodelist.py), you can use

>>> ul = UnicodeList()
>>> hex(ul.find_char(u'è').code)
'0xe8'

to look up the hex code for any character, and a list comprehension such as

>>> l = [hex(ul.find_char(x).code) for x in 'Hello']
>>> l
['0x48', '0x65', '0x6c', '0x6c', '0x6f']

for longer strings. Note that you don’t actually need all of this if all you want is a hex representation of a string! This suffices:

 l = [hex(ord(x)) for x in 'Hello']

The purpose of this module is to give easy access to other Unicode properties. A longer example:

str = 'Héllo...'
dest = ''
for i in str:
    dest += chr(ul.find_char(i).uppercase) if ul.find_char(i).uppercase is not None else i
print (dest)

HÉLLO...

and showing a list of properties for a character per your example:

letter = u'Ȅ'
print ('Name > '+ul.find_char(letter).name)
print ('Unicode number > U+%04x' % ul.find_char(letter).code)
print ('Bloc > '+ul.find_char(letter).block)
print ('Lowercase > %s' % chr(ul.find_char(letter).lowercase))

(I left out HTML; these names are not defined in the Unicode standard.)