Получение пользовательского ввода в python с input()

Содержание:

Введение

Строки (strings) в Python представляют собой последовательности из одного или более знаков (букв, цифр, символов). И хотя мы можем использовать эту последовательность в каких-то операциях, сама она является неизменной. То есть строку нельзя изменить, не создав при этом другой объект, занимающий иной адрес в памяти.

Благодаря широкому распространению текста в повседневной жизни, строка является важным типом данных, присутствующим в мире программирования.

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

Converting with Strings

A string is a sequence of one or more characters (letters, numbers, symbols). Strings are a common form of data in computer programs, and we may need to convert strings to numbers or numbers to strings fairly often, especially when we are taking in user-generated data.

Converting Numbers to Strings

We can convert numbers to strings through using the method. We’ll pass either a number or a variable into the parentheses of the method and then that numeric value will be converted into a string value.

Let’s first look at converting integers. To convert the integer to a string value, you can pass into the method:

When running in the Python interactive shell with the command in a terminal window, you’ll receive the following output:

The quotes around the number 12 signify that the number is no longer an integer but is now a string value.

With variables we can begin to see how practical it can be to convert integers to strings. Let’s say we want to keep track of a user’s daily programming progress and are inputting how many lines of code they write at a time. We would like to show this feedback to the user and will be printing out string and integer values at the same time:

When we run this code, we receive the following error:

We’re not able to concatenate strings and integers in Python, so we’ll have to convert the variable to be a string value:

Now, when we run the code, we receive the following output that congratulates our user on their progress:

If we are looking to convert a float to a string rather than an integer to a string, we follow the same steps and format. When we pass a float into the method, a string value of the float will be returned. We can use either the float value itself or a variable:

We can test to make sure it’s right by concatenating with a string:

We can be sure our float was properly converted to a string because the concatenation was performed without error.

Converting Strings to Numbers

Strings can be converted to numbers by using the and methods.

If your string does not have decimal places, you’ll most likely want to convert it to an integer by using the method.

Let’s use the example of the user Sammy keeping track of lines of code written each day. We may want to manipulate those values with math to provide more interesting feedback for the user, but those values are currently stored in strings:

Because the two numeric values were stored in strings, we received an error. The operand for subtraction is not a valid operand for two string values.

Let’s modify the code to include the method that will convert the strings to integers, and allow us to do math with values these that were originally strings.

The variable is automatically an integer, and it is equal to the numeric value of 58 in this example.

We can also convert the numbers in the example above to float values by using the method in place of the method. Instead of receiving the output of , we’ll receive the output of , a float.

The user Sammy is earning points in decimal values

In this case, using the operand with two strings is a valid operation, but it is concatenating two strings rather than adding two numeric values together. So, our output looks unusual since it just places the two values next to each other.

We’ll want to convert these strings to floats prior to performing any math with the method:

Now that we have converted the two strings to floats, we receive the anticipated result that adds to .

If we try to convert a string value with decimal places to an integer, we’ll receive an error:

If we pass a decimal value in a string to the method we’ll receive an error because it will not convert to an integer.

Converting strings to numbers enables us to quickly modify the data type we are working with so that we can perform operations on numeric values that were originally cast as strings.

Присвоение значений переменным

Переменные Python не требуют явного объявления для резервирования пространства памяти. Объявление присваивается автоматически, когда вы присваиваете значение переменной. Знак равенства (=) используется для присвоения значений переменным.

Операнд слева от оператора =  является именем переменной, а операнд справа от оператора = является значением, которое хранится в переменной. Например,

#!/usr/bin/python3

counter = 100          # Целочисленная переменная
miles   = 1000.0       # Переменная с плафающей точкой
name    = "John"       # Строковая переменная

print (counter)
print (miles)
print (name)

Здесь 100, 1000.0 и «John» являются значениями, присвоенными счетчику, милям и переменной имени, соответственно. Это дает следующий результат:

100
1000.0
John

Десятичные дроби в Python

Встроенный в Python класс float выполняет некоторые вычисления, которые могут нас удивить. Мы все знаем, что сумма 1.1 и 2.2 равна 3.3, но Python, похоже, не согласен.

>>> (1.1 + 2.2) == 3.3
False

Оказывается, что числа с плавающей запятой реализованы в Python как двоичные дроби, поскольку компьютер понимает только двоичную систему счисления (0 и 1). По этой причине большинство известных нам десятичных дробей не может быть точно сохранено на нашем компьютере.

Давайте рассмотрим пример. Мы не можем представить дробь 1/3 как десятичное число. Это даст 0.33333333.

Получается, что десятичная дробь 0,1 приведет к бесконечно длинной двоичной дроби 0,000110011001100110011 … и наш компьютер хранит только ее конечное число.

Это будет только приблизительно 0,1, но никогда не будет равным 0,1. Следовательно, это ограничение нашего компьютерного оборудования, а не ошибка в Python.

>>> 1.1 + 2.2
3.3000000000000003

Чтобы преодолеть эту проблему, мы можем использовать десятичный модуль decimal, который поставляется с Python. В то время как числа с плавающей запятой имеют точность до 15 десятичных знаков, десятичный модуль имеет заданную пользователем точность.

import decimal

# Результат: 0.1
print(0.1)

# Результат: Decimal('0.1000000000000000055511151231257827021181583404541015625')
print(decimal.Decimal(0.1))

Этот модуль используется, когда мы хотим выполнить десятичные вычисления с высокой точностью.

Понимание функции Python Astype ()

Перед темным погружением глубоко в концепцию преобразования типа данных с методом Python Astype () сначала рассмотрим следующий сценарий.

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

Это когда преобразование столбцов данных входит в изображение.

Способ Python Astype () позволяет нам установить или преобразовывать тип данных существующего столбца данных в набор данных или кадр данных.

При этом мы можем изменить или преобразовать тип значений данных или одиночных или нескольких столбцов, чтобы вообще другую форму с помощью функции ASTYPE ().

Давайте теперь будем подробно сосредоточиться на синтаксисе функции ASSTYPE () в предстоящем разделе.

Подсказки типов и модуль mypy

У динамически типизированных языков, таких как Python, есть свои мощные преимущества, но есть и некоторые недостатки. Одним из недостатков является возникновение ошибок выполнения (runtime error) когда Python не производит принудительного преобразования типов. В результате могут возникать баги, которые с увеличением длины кода становится все трудней найти.

Подсказки типов реализованы в Python начиная с версии 3.5. А более старые версии могут не поддерживать данный функционал.

Давайте посмотрим простой пример без подсказок типов и модуля mypy.

Данная функция предназначена для вычитания целочисленных значений. Она принимает на вход два целых числа и возвращает их разность.

def sub_this(x,y):
    return 'Subtraction'
print(sub_this(8,'hello')) 

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

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

mypy — это модуль Python, который помогает в проверке статических типов. Он использует собственную динамическую проверку Python или неявную («утиную») типизацию с подсказкой самого типа.

Для начала вам нужно установить сам модуль mypy:

Далее вам нужно создать файл с именем mypy_example.py на своем локальном компьютере и сохранить туда следующий код:

def sub_this(x:int,y:int) -> int:
    return 'Subtracted two integers'
print(sub_this(8,4)) 

Это простая программа, которая принимает два целых числа в качестве входных данных в параметре, а после ‘->’ показывает тип возвращаемых данных, который также является целочисленным (‘int’). Но хотя функция должна возвращать целочисленное значение (int), возвращается строка ‘Subtracted two integers’.

Запустите указанный выше код в терминале следующим образом:

После этого будет показана ошибка, указывающая на несоответствие типов (должен быть ‘int», а выдается ‘str’).

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

def sub_this(x:int,y:int) -> int:
    return x - y
print(sub_this(8,4)) 

Мы видим, что программа выполняется успешно, никаких проблем не обнаружено.

Повторение строк

Однажды у вас могут возникнуть обстоятельства, при которых вы захотите использовать Python для автоматизации некоторых задач. И одной из таких задач может стать многократное повторение строки в тексте. Для того чтобы это осуществить, потребуется воспользоваться оператором , который, как и оператор , отличается от . При использовании с одной строкой и одним числом становится оператором повторения, а не умножения. Он лишь повторяет заданный текст указанное число раз.

Давайте выведем на экран 9 раз с помощью оператора .

print("Sammy" * 9)

SammySammySammySammySammySammySammySammySammy

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

Последовательности

Ещё одно понятие из математики. Там, последовательность – есть нумерованный набор элементов, в котором возможны их повторения, а порядок имеет значение. Определение Питона схоже с математическим: здесь последовательностью зовётся упорядоченная коллекция объектов.

str (строка)

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

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

Строки, строки everywhere!

list (список)

Список – это ещё один вид последовательностей… Здесь стоит остановиться и отметить, что последовательности в Python бывают изменяемыми и неизменяемыми. Список – изменяемая последовательность, а строки и кортежи – нет. Таким образом, список можно определить, как упорядоченную и изменяемую коллекцию, состоящую из объектов произвольных типов.

Само название списков говорит об их предназначении быть объектами для хранения наборов данных. Список покупок, подарков, результатов матчей, ip клиентов или объектов типа Student. Списки в Python – это эдакие массивы из прочих языков «на максималках».

tuple (кортеж)

Кортежи в языке Python можно рассматривать, как неизменяемые списки со всеми вытекающими:

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

Переменные в Python

В большинстве языков программирования переменная является именованным местоположением, используемым для хранения данных в памяти. Каждая переменная должна иметь уникальное имя, называемое идентификатором. Принято думать о переменных как о контейнерах, которые содержат данные и эти данные могут быть извлечены или изменены позже, во время программирования.

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

Объявление переменных в Python

В отличии от других языков программирования, в Python переменные не нуждаются в объявлении для резервирования места в памяти. «Объявление переменной» или «инициализация переменной» происходит автоматически, когда мы присваиваем значение переменной.

Присвоение значения переменной в Python

Вы можете использовать оператор присваивания =, чтобы присвоить значение переменной.

блок 1

Пример 1: Объявление и присвоение значения переменной

message = 'hello'

В данном примере мы присвоили переменной message значение hello. Чтобы вывести значение переменной на экран нужно вызвать функцию print()

print(message)

Вы увидите следующее:

hello

Вам не нужно указывать тип переменной во время присвоения значения. Python язык с динамической типизацией, поэтому на этапе присвоения интерпретатор «понял» что переменная message имеет тип str (string, строка). При этом, далее вы можете присвоить этой переменной значение 123 и ее тип автоматически сменится на int (integer, число).

Пример 2: изменение значения переменной, изменение типа переменной

message = 'bye'
print(message)
print(type(message))
message = 123
print(message)
print(type(message))

В этом примере мы сначала изменили значение на другую строку, затем присвоили переменной значение типа int. Как видите никаких ошибок это не спровоцировало.

Пример 3: Присвоение нескольких значений нескольким переменным на одной строке

Иногда можно присваивать значения сразу нескольким переменным на одной строке:

a, b, c = 1, 'hello', 12

Эта запись то же самое что и:

a = 1
b = 'hello'
c = 12

Не стоит злоупотреблять этим способом, он несколько снижает читабельность кода.

Если мы хотим присвоить одно и то же значение нескольким переменным одновременно, мы можем сделать следующим способом:

a = b = c = 15

В результате, все три переменные будут типа int и содержать в себе значение 15.

2.МЕТОД REDUCE()

Функция reduce() определена в модуле functools Python. Он получает два аргумента, функцию и итерацию, но возвращает только одно значение. Теперь давайте рассмотрим его пример, который поможет нам лучше понять этот метод.

import functools 
import operator  
  
def convertTuple(tup): 
   .reduce(operator.add, (tup)) 
    return str
  

name = ('P', 'Y', 'T', 'H', 'O','N','P','O','O','L') (name) 
print(str)

Выход:

В приведенном выше примере сначала мы импортировали модуль functools. Далее мы импортировали оператор, который отвечает за выполнение основных математических операций. Затем мы использовали метод reduce, после чего определили кортеж. После этого мы преобразуем кортеж, как было определено ранее, для печати строки.

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

Конкатенация строк означает соединение строк вместе от первого до последнего символа для создания новой строки. Для соединения строк используется оператор . При этом имейте в виду, что если мы работаем с числами, будет оператором , а если со строками оператором конкатенации.

Давайте соединим строки и вместе с помощью функции :

 print("Sammy" + "Shark")

SammyShark

Следите за тем, чтобы никогда не использовать оператор «+» между двумя разными типами данных. Например, мы не можем объединять строки и числа вместе. И вот что произойдет, если мы вдруг попробуем это сделать:

print("Sammy" + 27)

TypeError: Can't convert 'int' object to str implicitly

Если бы мы захотели создать строку , мы могли бы это сделать поставив число в кавычки , таким образом . Преобразование числа в строку может быть полезным, когда мы, например, имеем дело с индексами или телефонными номерами. Например, когда нам нужно объединить телефонный код страны и телефонный номер, но при этом мы не хотим их складывать .

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

Типы данных кортежей в Python

Кортеж похож на список в Python. В Python тип данных кортежа является неизменяемым. Это означает, что кортежи не могут быть изменены, в отличие от списков. В Python кортежи могут содержать различные значения типов данных. Кортежи заключены в круглые скобки. Давайте рассмотрим код, иллюстрирующий кортежи в Python.

Пример – Код Python для иллюстрации «кортежа» в Python

first = (1, 2, 3)
second = (4, 5, 6)

print("len(first) : ", len(first))
print("max(first) : ", max(first))
print("min(first) : ", min(first))
print("first + second :", first + second)
print("first * 3 : ", first * 3)
print("1 in first : ", 1 in first)
print("5 not in second : ", 5 not in second)

Выход:

В этом примере показано несколько основных операций с кортежами. Функция len() возвращает количество элементов в первом кортеже. Функция max() возвращает максимальное значение, а функция min() — минимальное. Оператор сложения добавляет два кортежа, оператор умножения умножает кортеж. Оператор in определяет, находится ли значение в кортеже.

Как получить доступ к символам в строке?

Мы можем получить доступ к отдельным символам, используя индексирование, и диапазон символов, используя срезы. Индекс начинается с 0. Попытка получить доступ к символу вне диапазона индекса вызовет ошибку IndexError. Индекс должен быть целым числом. Мы не можем использовать float или другие типы, это приведет к ошибке TypeError.

Python допускает отрицательную индексацию для своих последовательностей.

Индекс -1 относится к последнему элементу, -2 — ко второму с конца элементу и т.д. Мы можем получить доступ к ряду элементов в строке, используя оператор среза (двоеточие).

str = 'programfiles'
print('str = ', str)

# Первый символ
print('str = ', str)

# Последний символ
print('str = ', str)

# Срез, символы со второго по пятый
print('str = ', str)

# Срез, символы с шестого по второй с конца
print('str = ', str)

Преобразование строки Python в int

Метод Python позволяет преобразовать любое значение типа String в целочисленное значение.

Синтаксис:

int(string_variable)

Пример:

string_num = '75846'
print("The data type of the input variable is:\n")
print(type(string_num))

result = int(string_num)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string to int:\n")
print(result)

Выход:

The data type of the input variable is:
<class 'str'>
The data type of the input value after conversion:
<class 'int'>
The converted variable from string to int:
75846

Python также предоставляет нам эффективный вариант преобразования чисел и значений типа String в целочисленные значения с определенной базой в соответствии с системой счисления.

Синтаксис:

int(string_value, base = val)

Пример:

string_num = '100'
print("The data type of the input variable is:\n")
print(type(string_num))

print("Considering the input string number of base 8....")
result = int(string_num, base = 8)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string(base 8) to int:\n")
print(result) 

print("Considering the input string number of base 16....")
result = int(string_num, base = 16)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string(base 16) to int:\n")
print(result) 

В приведенном выше фрагменте кода мы преобразовали «100» в целочисленное значение с основанием 8 и основанием 16 соответственно.

Выход:

The data type of the input variable is:

<class 'str'>
Considering the input string number of base 8....
The data type of the input value after conversion:

<class 'int'>
The converted variable from string(base 8) to int:

64
Considering the input string number of base 16....
The data type of the input value after conversion:

<class 'int'>
The converted variable from string(base 16) to int:

256

Синтаксис – Astype () Функция

Посмотрите на синтаксис ниже!

DataFrame.astype(dtype, copy=True, errors='raise')
  • dtype : Тип данных, который мы хотим обратиться к всему кадру данных.
  • Скопировать : Установив его к Правда Это создает еще одну копию набора данных, принудительного изменения к нему изменения.
  • Ошибки : Установив его к ‘ поднять «Мы позволяем исключениям быть повышенным функцией. Если нет, мы можем установить его на ‘ игнорировать ‘.

Поняв синтаксис функции, давайте теперь сосредоточимся на реализации одинакового!

1. Python Astype () с dataframe

В этом примере мы создали Dataframe от Словарь Как показано ниже, используя метод.

Пример:

import pandas as pd 
data = {"Gender":, "NAME":}

block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
block.dtypes

Выход:

Давайте посмотрим на исходные типы данных клавиш.

Original Data frame:

  Gender    NAME
0      M    John
1      F  Camili
2      F  Rheana
3      M  Joseph
4      F  Amanti
5      F   Alexa
6      F    Siri

Gender    object
NAME      object
dtype: object

Теперь мы применили метод ASTYPE () в столбце «гендерной» и изменили тип данных в «категории».

block = block.astype('category')
block.dtypes

Выход:

Gender    category
NAME        object
dtype: object

2. Реализация Python Astype () с набором данных

Здесь мы импортировали набор данных, используя функцию pandas.read_csv (). Вы можете найти набор данных здесь.

Пример:

import pandas 
BIKE = pandas.read_csv("Bike.csv")
BIKE.dtypes

Исходные типы данных столбцов-

temp            float64
hum             float64
windspeed       float64
cnt               int64
season_1          int64
season_2          int64
season_3          int64
season_4          int64
yr_0              int64
yr_1              int64
mnth_1            int64
mnth_2            int64
mnth_3            int64
mnth_4            int64
mnth_5            int64
mnth_6            int64
mnth_7            int64
mnth_8            int64
mnth_9            int64
mnth_10           int64
mnth_11           int64
mnth_12           int64
weathersit_1      int64
weathersit_2      int64
weathersit_3      int64
holiday_0         int64
holiday_1         int64
dtype: object

Теперь мы попытались изменить тип данных переменных «Season_1» и «TEMP». Таким образом, мы говорим, что с функцией ASTYPE () мы можем изменить типы данных нескольких столбцов в одном Go!

BIKE = BIKE.astype({"season_1":'category', "temp":'int64'}) 
BIKE.dtypes

Выход:

temp               int64
hum              float64
windspeed        float64
cnt                int64
season_1        category
season_2           int64
season_3           int64
season_4           int64
yr_0               int64
yr_1               int64
mnth_1             int64
mnth_2             int64
mnth_3             int64
mnth_4             int64
mnth_5             int64
mnth_6             int64
mnth_7             int64
mnth_8             int64
mnth_9             int64
mnth_10            int64
mnth_11            int64
mnth_12            int64
weathersit_1       int64
weathersit_2       int64
weathersit_3       int64
holiday_0          int64
holiday_1          int64
dtype: object

Преобразование в кортежи и списки

Вы можете использовать методы  и  для преобразования переданных им значений в тип данных списка и кортежа соответственно. В Python:

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

Преобразование в кортежи

Начнем с преобразования списка в кортеж. Поскольку кортеж — это неизменяемый тип данных, такое преобразование может способствовать существенной оптимизации наших программ. Метод возвращает «кортежную» версию переданного ему значения.

print(tuple())

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

Давайте используем  с переменной, представляющей список:

sea_creatures = 
print(tuple(sea_creatures))

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

Мы можем преобразовать в кортеж не только список, но и любой итерируемый тип, включая строки:

print(tuple('Sammy'))

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

print(tuple(5000))

Можно преобразовать целое число в строку, а затем в кортеж:  . Но лучше выбрать читаемый код, а не сложные преобразования.

Преобразование в списки

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

Давайте преобразуем кортеж в список. Будьте внимательны со скобками: одна пара для кортежа, вторая — для метода  , а третья — для метода :

print(list(('blue coral', 'staghorn coral', 'pillar coral')))

Квадратные скобки сигнализируют о том, что кортеж, переданный в метод  , преобразован в список.

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

coral = ('blue coral', 'staghorn coral', 'pillar coral')
list(coral)

Если мы выведем , мы получим тот же результат, что и выше.

В список можно преобразовать не только кортеж, но и строку:

print(list('shark'))

Как получить доступ к элементам кортежа?

Мы можем получить доступ к элементам кортежа через их индекс. Значение индекса начинается с 0 до длины кортежа — 1.

tuple_numbers = (1, 2, 3, 4)

print(f'First element in tuple is {tuple_numbers}')
print(f'Third element in tuple is {tuple_numbers}')

Если размер меньше указанного индекса, выдается «IndexError: индекс кортежа вне допустимого диапазона».

>>> tuple_numbers = (1, 2, 3, 4)
>>> tuple_numbers
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>>

Tuple также поддерживает отрицательную индексацию. В этом случае элемент извлекается от конца до начала. Отрицательный индекс начинается с -1 до — (длина кортежа).

tuple_numbers = (1, 2, 3, 4)

print(f'Last element in tuple is {tuple_numbers}')
print(f'Second Last element in tuple is {tuple_numbers}')
print(f'First element in tuple is {tuple_numbers}')

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

>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>> nested_tuple
3
>>> nested_tuple
4
>>> nested_tuple
5
>>> nested_tuple
6
>>> nested_tuple
7
>>>

Мы также можем использовать отрицательные индексы с вложенными кортежами.

>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>> 
>>> nested_tuple
7
>>> nested_tuple
4
>>> nested_tuple
4
>>> nested_tuple
6
>>> 

На изображении ниже показано, как работают индексы.

Операции со строками в Python

Есть много операций, которые могут быть выполнены со строкой, что делает ее одним из наиболее часто используемых типов данных в Python.

Конкатенация двух или более строк

Объединение двух или более строк в одну называется конкатенацией. В Python конкатенация выполняется оператором +.

Оператор * может использоваться для повторения строки в течение заданного числа раз.

str1 = 'Hello'
str2 ='World!'

# Конкатенация (объединение) строк
print('str1 + str2 = ', str1 + str2)

# Повторение строк
print('str1 * 3 =', str1 * 3)

Перебор строк

Используя цикл for, мы можем перебирать строку.

Пример для подсчета количества символа ‘l’ в строке.

count = 0
for letter in 'Hello World':
    if(letter == 'l'):
        count += 1
print(count)

Проверка на наличие символа в строке

Мы можем проверить, существует ли подстрока в строке или нет, используя ключевое слово in.

>>> 'a' in 'programfiles'
True
>>> 'at' not in 'programfiles'
False

Работа с типами в Python

Как поменять тип данных

В богатом арсенале Питона есть встроенные функции для приведения типов – , , , , , .

️ Обратите внимание: встроенная функция для приведения типа не модифицирует переданное значение, а возвращает новое значение другого типа

Отличие type() от isinstance()

В отличие от , функция возвращает не тип данных аргумента, а булево значение, говорящее о том, принадлежит объект к определенному классу или нет:

А ещё умеет проверять принадлежность объекта хотя к одному типу из кортежа, переданного в качестве второго аргумента:

Важным отличием также является то, что «знает» о наследовании. Функция воспринимает объект производного класса, как объект базового.

А вот вывод результата работы функции

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

Нововведения Python 3.9.0

Начиная с недавно вышедшей версии Python 3.9, у разработчиков больше нет необходимости импортировать абстрактные коллекции для описания типов. Теперь вместо можно использовать , то же самое происходит с , , и т.д. Полное описание этого нововведения можно прочитать тут: PEP-585.

Также добавили аннотации типов, которые в дальнейшем могут быть использованы инструментами статического анализа. где — тип переменной , а — некоторые метаданные для переменной. По оценкам некоторых авторов, эти метаданные могут быть использованы также и во время выполнения (подробности смотрите в PEP-593).

Файл

Работа с файлами, хранящимися где-то на внешнем носителе, в Python реализована в виде объектов-файлов. Они относятся к объектам базового типа, но обладают весьма характерной чертой: нельзя создать экземпляр объекта-файла при помощи литералов.

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

Операции с файлами могут быть разными, а, следовательно, разными могут быть и режимы работы с ними:

  • – выбирается по умолчанию, означает открытие файла для чтения;
  • – файл открывается для записи (если не существует, то создаётся новый);
  • – файл открывается для записи (если не существует, то генерируется исключение);
  • – режим записи, при котором информация добавляется в конец файла, а не затирает уже имеющуюся;
  • – открытие файла в двоичном режиме;
  • – ещё одно значение по умолчанию, означающее открытие файла в текстовом режиме;
  • – читаем и записываем.

Целое число

Целые числа — это целые числа. Они могут быть положительными или отрицательными. Они должны быть без десятичных значений.

Мы можем использовать функцию int(), чтобы получить целочисленное представление объекта. В объекте должен быть реализован метод __int __(), который возвращает целое число.

Давайте рассмотрим несколько примеров.

x = 10
print(type(x))

x = int("10")
print(type(x))


class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __int__(self):
        return self.id


d = Data(10)

x = int(d)
print(x)
print(type(x))

Вывод:

<class 'int'>
<class 'int'>
10
<class 'int'>

Класс String предоставляет метод __int __(), поэтому мы можем легко преобразовать строку в int с помощью метода int().

Если объект не реализует метод __int __(), функция int() выдает ошибку TypeError.

Обычно целые числа определяются на основе 10. Но мы также можем определять их в двоичном, восьмеричном и шестнадцатеричном формате.

i = 0b1010
print(i)  # 10

i = 0xFF
print(i)  # 255

i = 0o153
print(i)  # 107
Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector