8-900-374-94-44
| .186 | |
| .model TINY | |
| .code | |
| org 100h | |
| start: | |
| ;—————————————————————— | |
| ;Приглашение | |
| mov ah,9h | |
| lea dx,str1 | |
| int 21h | |
| ;Ввод числа | |
| mov ah,0ah | |
| lea dx,maxlen | |
| int 21h | |
| ;Подготовка к циклу | |
| xor ax,ax ;обнуляется регистр | |
| lea di,string ;di — индексный регистр | |
| xor ch,ch ;обнуляется регистр | |
| mov cl,len ;Число цифр в буфере | |
| mov si,10 ;si содержит множитель 10 | |
| xor bh,bh ;обнуляется регистр | |
| ;цикл1 | |
| m1: | |
| mul si ;умножить ax на si(10) | |
| mov bl,[di] ;к произвдению добавить число | |
| cmp bl, 30h ;сравнение | |
| jl err ;если меньше | |
| cmp bl, 39h ;сравнение | |
| jg err ;если больше | |
| sub bl,30h ;отнять 30h | |
| add ax,bx ;добачить число к сумме ax | |
| inc di ;инкремент di | |
| loop m1 ;повтор цикла | |
| mov number,ax ;переместить регистр ax number | |
| mov ah,02h ;новая строка | |
| mov dx,0dh | |
| int 21h | |
| mov dx,0ah | |
| int 21h | |
| ;Подготовка к циклу | |
| mov ah,9h ;вывод сообщения | |
| lea dx,star ;символы — звезды | |
| mov cx,number ;число цикла = новая строка | |
| m2: | |
| int 21h | |
| loop m2 | |
| ret | |
| err: | |
| mov ah,9h | |
| lea dx,errmsg | |
| int 21h | |
| ret | |
| ;————————————————————— | |
| str1 db «Введите число: «,0dh,0ah,’$’ | |
errmsg db 0dh,0ah,»Число введено некорректно. $» | |
| maxlen db 5h | |
| len db 0h | |
| string db 4h dup(20h) | |
| star db ‘*$’ | |
| number dw ? | |
| end start |
Та же история с float() — число с плавающей точкой. Иначе обе эти функции возвращают ошибку TypeError…
Ниже приведен полный код программы, в которой 5 функций:# ~*~ coding: utf8 ~*~
def clear_string(str, to_int = None):
"""
Чистим строку от "мусора" - нечисловых символов.
"""
new_str = ""
for s in str:
# сначала ищем точку (вдруг число с плавающей точкой)
# при этом в новой строке не должно быть больше одной точки
# и в условии to_int не определен
if s == ".
" and "." not in new_str and not to_int:
new_str += s
else:
try:
i = int(s)
new_str += s
except:
pass
return new_str
def str_to_int(str):
"""
Преобразование стоки в целое число
"""
# попробуем воспользоваться самым простым методом
try:
return int(str)
except:
# если не получилось, то проверяем почему? допускаем, что было передано не целое число в строке
if "." in str:
str = str[0:str.find(".")]
return str_to_int(str)
else:
# если уж совсем дела плохи, то возвращаем 0
return 0
def check_int(str):
try:
int(str)
return True
except:
return False
def str_to_float(str):
"""
Преобразование стоки в число с плавающей точкой
"""
# попробуем воспользоваться самым простым методом
try:
return float(str)
except:
# других вариантов не осталось. скорее всего функция приняла на входе мусор
return 0
def check_float(str):
try:
float(str)
return True
except:
return False
# есть у нас незатейливая строка
str = "a23d.d.5ff6"
# проверяем функцию чистки строки
print("Чищеная строка: %s" % clear_string(str))
print("Чищеная строка с to_int: %s" % clear_string(str, to_int=True))
# до преобразования строки в число следовало бы почистить ее
print("Преобразуем мусор в целое число: %s" % str_to_int(str))
print("Преобразуем чищеную строку в целое число: %s" % str_to_int(clear_string(str)))
# преобразуем строку в число с плавающей точкой
print("Преобразуем мусор в число с плавающей точкой: %s" % str_to_float(str))
print("Преобразуем чищеную строку в число с плавающей точкой: %s" % str_to_float(clear_string(str)))
print("Проверяем, является ли содержимое строки целочисленным: %s" % check_int(str))
print("Проверяем, является ли содержимое чищеной строки целочисленным: %s" % check_int(clear_string(str, to_int=True)))
print("Проверяем, является ли содержимое строки числом с плавающей точкой: %s" % check_float(str))
print("Проверяем, является ли содержимое чищеной строки числом с плавающей точкой: %s" % check_float(clear_string(str))) Задачу по проверке содержимого строки на целочисленность можно было бы решить с помощью стандартной функции isdigit().
Но это слишком просто. Для наглядности и создали функцию check_int(), которая работает так же, как и isdigit().
" and "." not in new_str and not to_int:
new_str += s
else:
try:
i = int(s)
new_str += s
except:
pass
return new_str
def str_to_int(str):
"""
Преобразование стоки в целое число
"""
# попробуем воспользоваться самым простым методом
try:
return int(str)
except:
# если не получилось, то проверяем почему? допускаем, что было передано не целое число в строке
if "." in str:
str = str[0:str.find(".")]
return str_to_int(str)
else:
# если уж совсем дела плохи, то возвращаем 0
return 0
def check_int(str):
try:
int(str)
return True
except:
return False
def str_to_float(str):
"""
Преобразование стоки в число с плавающей точкой
"""
# попробуем воспользоваться самым простым методом
try:
return float(str)
except:
# других вариантов не осталось.
# Для успокоения души слишком любознательных приведу пример
"s34".isdigit()
# False
"34".isdigit()
# True
clear_string("s43de463").isdigit()
# TrueНу и напоследок, если у вас есть комментарии или более интересные задачи из выше рассмотренной области, то прошу комментировать. Попробуем решить задачу вместе.JavaScript предоставляет различные способы преобразования строкового значения в число.
На мой взгляд, лучше всего использовать объект Number в контексте, не являющемся конструктором (без ключевого слова new ):
const count = Number('1234') / /1234 Это касается и десятичных знаков.
Число — это объект-оболочка , который может выполнять множество операций.
Если мы используем конструктор ( new Number("1234") ), он возвращает нам объект Number вместо числового значения, так что будьте внимательны.
Следите за разделителями между цифрами:
Число('10,000') //NaN
Число('10.00') //10
Number('10000') //10000 В случае, если вам нужно проанализировать строку с десятичными разделителями, используйте вместо этого Intl.NumberFormat .
parseInt() и parseFloat() Другим хорошим решением для целых чисел является вызов функции parseInt() :
const count = parseInt('1234', // 1234 Не забывайте о втором параметре, который является основанием, всегда равным 10 для десятичных чисел, иначе преобразование может попытаться угадать основание и дать неожиданные результаты.
parseInt() пытается получить число из строки, которая содержит не только число:
parseInt('10 львов', 10) //10 но если строка не начинается с цифры, вы получите NaN (не число):
parseInt("Мне 10" , 10) //NaN Также, как и в случае с Number, он ненадежен с разделителями между цифрами:
parseInt('10,000', 10) //10 ❌
parseInt('10. 00', 10) //10 ✅ (считается десятичным числом, вырезано)
parseInt('10.000', 10) //10 ✅ (считается десятичной дробью, вырезано)
parseInt('10.20', 10) //10 ✅ (считается десятичной дробью, вырезано)
parseInt('10.81', 10) //10 ✅ (считается десятичным числом, вырезано)
parseInt('10000', 10) //10000 ✅ Если вы хотите сохранить десятичную часть, а не просто получить целую часть, используйте parseFloat() . Обратите внимание, что в отличие от
его брат parseInt() , он принимает только один аргумент — строку для преобразования:
00', 10) //10 ✅ (считается десятичным числом, вырезано)
parseInt('10.000', 10) //10 ✅ (считается десятичной дробью, вырезано)
parseInt('10.20', 10) //10 ✅ (считается десятичной дробью, вырезано)
parseInt('10.81', 10) //10 ✅ (считается десятичным числом, вырезано)
parseInt('10000', 10) //10000 ✅ parseFloat('10,000') //10 ❌
parseFloat('10.00') //10 ✅ (считается десятичным числом, вырезано)
parseFloat('10.000') //10 ✅ (считается десятичным числом, вырезано)
parseFloat('10.20') //10.2 ✅ (считается десятичным числом)
parseFloat('10.81') //10.81 ✅ (считается десятичным числом)
parseFloat('10000') //10000 ✅ + Один «трюк» заключается в использовании унарного оператора + перед строкой:
+'10,000'//NaN ✅ +'10.
Посмотрите, как он возвращает NaN в первом примере, что является правильным поведением: это не число.
000'//10 ✅
+'10.00' //10 ✅
+'10.20' //10.2 ✅
+'10,81'//10,81 ✅
+'10000' //10000 ✅ Math.floor() Аналогичен унарному оператору + , но возвращает целую часть, заключается в использовании Math.floor() :
Math.floor('10,000') //NaN ✅
Math.floor('10.000') //10 ✅
Math.floor('10.00') //10 ✅
Math.floor('10.20') //10 ✅
Math.floor('10.81') //10 ✅
Math.floor('10000') //10000 ✅ * 1 Как правило, это один из самых быстрых вариантов, ведет себя как унарный оператор + , поэтому он не выполняет преобразование в целое число, если число поплавок.
'10 000' * 1 //NaN ✅ '10.000' * 1//10 ✅ '10.00' * 1 //10 ✅ '10.20' * 1 //10.2 ✅ '10,81' * 1 //10,81 ✅ '10000' * 1 //10000 ✅
Каждый из этих методов имеет разную производительность в разных средах, поскольку все зависит от реализации.
В моем случае * 1 является победителем по производительности в 10 раз быстрее, чем другие альтернативы.
Попробуйте JSPerf:
Main Content
Open Live Script
В этом примере показано, как преобразовать текст в числовые значения, которые он представляет. Как правило, вам нужно выполнять такие преобразования, когда у вас есть текст, представляющий числа, которые нужно нанести на график или использовать в вычислениях. Например, текст может быть взят из текстового файла или электронной таблицы. Если вы еще не преобразовали его в числовые значения при импорте в MATLAB®, вы можете использовать функции, показанные в этом примере.
Можно преобразовать массивы строк, вектора символов и массивы ячеек векторов символов в числовые значения. Текст может представлять шестнадцатеричные или двоичные значения, хотя при преобразовании их в числа они сохраняются как десятичные значения.
Вы также можете преобразовать текст, представляющий даты и время, в значения datetime или duration , которые можно обрабатывать как числовые значения.
Рекомендуемый способ преобразования текста в значения с двойной точностью — использование функция str2double . Он может преобразовывать векторы символов, массивы строк и массивы ячеек из символьных векторов.
Например, создайте вектор символов, используя одинарные кавычки, и преобразуйте его в число, которое он представляет.
X = str2double('3.1416') X = 3.1416
Если входной параметр представляет собой массив строк или массив ячеек из символьных векторов, то str2double преобразует его в числовой массив того же размера. Вы можете создавать строки, используя двойные кавычки. (Струны имеют string тип данных , в то время как векторы символов имеют тип данных char .)
str = ["2.
718","3.1416";
«137», «0,015»] стр = 2x2 строка
"2,718" "3,1416"
"137" "0,015"
X = str2double(str)
X = 2×2
2,7180 3,1416
137,0000 0,0150
Функция str2double может преобразовывать текст, содержащий запятые (как разделители тысяч) и десятичные точки. Например, вы можете использовать str2double для преобразования переменной Balance в таблице ниже. Баланс представляет числа в виде строк с использованием запятой в качестве разделителя тысяч.
балансировка нагрузки остатки
остатки= Таблица 3×2
Баланс клиента
_________ ___________
"Диас" "13 790,00"
«Джонсон» «2456,10»
"Ву" "923,71"
T.Balance = str2double(T.Balance)
T= Таблица 3×2
Баланс клиента
_________ _______
«Диас» 1379 г.0
«Джонсон» 2456.1
"Ву" 923,71
Если str2double не может преобразовать текст в число, то возвращается значение NaN .
Хотя функция str2num также может преобразовывать текст в числа, не рекомендуется использовать . str2num использует функцию eval , которая может вызвать непреднамеренные побочные эффекты, если текстовый ввод включает имя функции. Чтобы избежать этих проблем, используйте str2double .
В качестве альтернативы вы можете преобразовать строки в значения с двойной точностью, используя функцию double . Если ввод представляет собой массив строк, то double возвращает числовой массив того же размера, что и str2double . Однако, если вход представляет собой вектор символов, то double преобразует отдельные символы в числа, представляющие их значения Unicode®.
X = двойной ("3,1416") X = 3,1416
X = двойной ('3.1416') Х = 1×6
51 46 49 52 49 54
В этом списке приведены рекомендации по преобразованию текста в числовые значения.
Чтобы преобразовать текст в числовые значения, используйте функцию str2double . Он последовательно обрабатывает строковые массивы, символьные векторы и массивы ячеек из символьных векторов.
Вы также можете использовать функцию double для строковых массивов. Однако он обрабатывает векторы символов по-разному.
Избегать str2num . Он вызывает функцию eval , которая может иметь непредвиденные последствия.
Вы можете представлять шестнадцатеричные и двоичные числа как текст или как литералы . Когда вы записываете их как литералы, вы должны использовать префиксы 0x и 0b . Когда вы представляете их в виде текста, а затем конвертируете, вы можете использовать префиксы, но они не обязательны.
Например, запишите шестнадцатеричное число как литерал.
Префикс обязателен.
D = 0x3FF
D = uint16
1023
Затем преобразуйте текст, представляющий то же значение, с помощью функции hex2dec . Он распознает префикс, но не требует его.
D = hex2dec('3FF') D = 1023
D = hex2dec('0x3FF') D = 1023
Преобразование текста, представляющего двоичные значения, с помощью bin2dec функция.
D = bin2dec('101010') D = 42
Д = bin2dec('0b101010') Д = 42
MATLAB предоставляет типы данных datetime и duration для хранения дат и времени и обработки их как числовых значений. Чтобы преобразовать текст, представляющий дату и время, используйте функции datetime и duration .
Преобразование текста, представляющего дату, в значение datetime . datetime функция распознает множество распространенных форматов даты и времени.
С = '2019-09-20'
С = '2019-09-20'
D = дата-время (C)
D = дата-время 20 сентября 2019 г.
Вы можете преобразовывать массивы, представляющие даты и время.
str = ["2019-01-31","2019-02-28","2019-03-31"]
str = 1x3 string
"31.01.2019" "28.02.2019" "31.03.2019"
D = дата и время (str)
D = 1x3 дата и время 31 января 2019 г. 28 февраля 2019 г. 31 марта 2019 г.
Если вы конвертируете текст в значения продолжительности , используйте форматы чч:мм:сс или дд:чч:мм:сс .
D = продолжительность ('12:34:56') D = продолжительность 12:34:56
bin2dec | hex2dec | стр2двойной | дата-время | продолжительность | двойной | стол
