форкнуто от main/python-labs
main
Родитель
a77984b71e
Сommit
018b00b0d8
@ -0,0 +1,771 @@
|
||||
# Отчет
|
||||
## Тема 3.
|
||||
Операции с объектами
|
||||
## Пункт 2.
|
||||
Преобразование простых базисов типов объектов
|
||||
## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
|
||||
```py
|
||||
>>>logiz1=bool(56)
|
||||
>>>logiz1
|
||||
True
|
||||
>>>logiz2=bool(0)
|
||||
>>>logiz2
|
||||
False
|
||||
>>>logiz3=bool("Beta")
|
||||
>>>logiz3
|
||||
True
|
||||
>>>logiz4=bool("")
|
||||
>>>logiz4
|
||||
False
|
||||
```
|
||||
## 2.2 Преобразование в целое десятичное число
|
||||
```py
|
||||
>>>tt1= int(198.6)
|
||||
>>>tt1
|
||||
198
|
||||
>>>tt2=int('-76')
|
||||
>>>tt2
|
||||
-76
|
||||
>>>tt3= int('B',16)
|
||||
>>>tt3
|
||||
11
|
||||
>>>tt4=int("71",8)
|
||||
>>>tt4
|
||||
57
|
||||
>>> tt5=int("98.76")
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#34>", line 1, in <module>
|
||||
tt5=int("98.76")
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
Функция int() может преобразовывать в целое число только строки, которые содержат целое число (например, "98"). Строка "98.76" содержит десятичную точку, поэтому возникает ошибка.
|
||||
Решить эту проблему можно так:
|
||||
```py
|
||||
>>>tt5 = int(float("98.76"))
|
||||
>>>tt5
|
||||
98
|
||||
```
|
||||
## 2.3 Преобразование десятичных чисел в другие системы счисления
|
||||
```py
|
||||
>>>hh=123
|
||||
>>>dv1=bin(hh) #в двоичную сс
|
||||
>>>dv1
|
||||
'0b1111011'
|
||||
>>>vos1=oct(hh) #в восьмеричную сс
|
||||
>>>vos1
|
||||
'0o173'
|
||||
>>>shs1=hex(hh) #в шеснадцатеричную сс
|
||||
>>>shs1
|
||||
'0x7b'
|
||||
```
|
||||
Для проверки выполним обратные преобразования
|
||||
|
||||
```py
|
||||
>>>int (dv1,2)
|
||||
123
|
||||
>>int(vos1,8)
|
||||
123
|
||||
>>int(shs1,16)
|
||||
123
|
||||
```
|
||||
## Пункт 3.
|
||||
Преобразование более сложных базовых типов объектов
|
||||
## 3.1 Преобразование в строку символов с помощью функции str(<Объект>)
|
||||
```py
|
||||
>>>strk=str(23.6)
|
||||
>>>strk
|
||||
'23.6'
|
||||
>>>strk2=str(logiz3)
|
||||
>>>strk2
|
||||
'True'
|
||||
>>>strk3=str(["A","B","C"]) #Преобразуем список
|
||||
>>>strk3
|
||||
"['A', 'B', 'C']"
|
||||
>>>strk4=str(("A","B","C")) #Преобразуем кортеж
|
||||
>>>strk4
|
||||
"('A', 'B', 'C')"
|
||||
>>>strk5=str({"A":1,"B":2,"C":9}) #Преобразуем словарь
|
||||
>>>strk5
|
||||
"{'A': 1, 'B': 2, 'C': 9}"
|
||||
```
|
||||
## 3.2 Преобразование элементов объекта в список с помощью функции list(<Объект>)
|
||||
```py
|
||||
>>>spis1=list("Строка символов") #Заданная строка разделяется на символы
|
||||
>>>spis1
|
||||
['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
|
||||
>>>spis2=list((124,236,-15,908)) #Кортеж превращается в список
|
||||
>>>spis2
|
||||
[124, 236, -15, 908]
|
||||
>>>spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список
|
||||
>>>spis3
|
||||
['A', 'B', 'C']
|
||||
>>> spis4 = list({"A":1,"B":2,"C":9}.values())
|
||||
>>> spis4
|
||||
[1, 2, 9]
|
||||
```
|
||||
## 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
|
||||
```py
|
||||
>>>kort7=tuple('Строка символов') #Преобразование строки символов в кортеж
|
||||
>>>kort7
|
||||
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
|
||||
|
||||
>>>kort8=tuple(spis2) #Преобразование списка в кортеж
|
||||
>>>kort8
|
||||
(124, 236, -15, 908)
|
||||
>>>kort9=tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж
|
||||
>>>kort9
|
||||
('A', 'B', 'C')
|
||||
>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values()))
|
||||
>>> kort9
|
||||
(1, 2, 9)
|
||||
```
|
||||
## 3.4. Удаление объектов
|
||||
```py
|
||||
>>>del strk5, kort8
|
||||
Проверим
|
||||
>>>dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
|
||||
Создадим строку со своей фамилией и инициалами, преобразуем её в список, затем список – в кортеж и, наконец, кортеж – в строку.
|
||||
>>> f= 'ЦветковаТА'
|
||||
>>> spis= list(f)
|
||||
>>> spis
|
||||
['Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А']
|
||||
>>> k=tuple(spis)
|
||||
>>> k
|
||||
('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')
|
||||
>>> kk=str(k)
|
||||
>>> kk
|
||||
"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')"
|
||||
```
|
||||
## Пункт 4. Арифметические операции.
|
||||
## 4.1. Сложение и вычитание (+ и -)
|
||||
```py
|
||||
>>> 12+7+90
|
||||
109
|
||||
>>> 5.689e-1 - 0.456
|
||||
0.11289999999999994
|
||||
>>> 23.6+54
|
||||
77.6
|
||||
>>> 14-56.7+89
|
||||
46.3
|
||||
```
|
||||
## 4.2. Умножение (*)
|
||||
```py
|
||||
>>> -6.7*12
|
||||
-80.4
|
||||
```
|
||||
## 4.3. Деление (/). Результатом деления всегда будет вещественное число!
|
||||
```py
|
||||
>>> -234.5/6
|
||||
-39.083333333333336
|
||||
>>> a=178/45
|
||||
>>> a
|
||||
3.9555555555555557
|
||||
>>> type(a)
|
||||
<class 'float'>
|
||||
```
|
||||
## 4.4. Деление с округлением вниз (//). Здесь результат может быть целым или вещественным.
|
||||
```py
|
||||
>>> b=178//45
|
||||
>>> b
|
||||
3
|
||||
>>> type(b)
|
||||
<class 'int'>
|
||||
>>> c=-24.6//12.1
|
||||
>>> c
|
||||
-3.0
|
||||
>>> type(c)
|
||||
<class 'float'>
|
||||
```
|
||||
## 4.5. Получение остатка от деления (%).
|
||||
```py
|
||||
>>> 148%33
|
||||
16
|
||||
>>> 12.6%3.8
|
||||
1.2000000000000002
|
||||
>>> 56.97%6
|
||||
2.969999999999999
|
||||
```
|
||||
## 4.6. Возведение в степень (**).
|
||||
```py
|
||||
>>> 14**3
|
||||
2744
|
||||
>>> e=2.7**3.6
|
||||
>>> e
|
||||
35.719843790663525
|
||||
>>> d=2.7**3
|
||||
>>> d
|
||||
19.683000000000003
|
||||
```
|
||||
Попробуем проделать арифметические операции над комплексными числами. Создадим два
|
||||
комплексных числа
|
||||
```py
|
||||
>>> k1=(2+1j)
|
||||
>>> k2=(1+2j)
|
||||
>>> k1+k2
|
||||
(3+3j)
|
||||
>>> k2-k1
|
||||
(-1+1j)
|
||||
>>> k1*k2
|
||||
5j
|
||||
>>> k1/k2
|
||||
(0.8-0.6j)
|
||||
>>> k1**k2
|
||||
(-0.42589434775182566+0.7753703444218832j)
|
||||
>>> k1//k2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
|
||||
>>> k1%k2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
|
||||
```
|
||||
## Пункт 5. Операции с двоичными представлениями целых чисел.
|
||||
|
||||
## 5.1 Двоичная инверсия (~)
|
||||
```py
|
||||
dv1=9
|
||||
>>> dv2=~dv1
|
||||
>>> dv2
|
||||
-10
|
||||
```
|
||||
##5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
|
||||
```py
|
||||
>>> 7&9
|
||||
1
|
||||
>>> 7&8
|
||||
0
|
||||
```
|
||||
Проверим
|
||||
```py
|
||||
>>> bin(7)
|
||||
'0b111'
|
||||
>>> bin(8)
|
||||
'0b1000'
|
||||
>>> bin(7&9)
|
||||
'0b1'
|
||||
```
|
||||
## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
|
||||
```py
|
||||
>>> 7|9
|
||||
15
|
||||
>>> 7|8
|
||||
15
|
||||
>>> 14|5
|
||||
15
|
||||
>>> bin(15)
|
||||
'0b1111'
|
||||
```
|
||||
## 5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
|
||||
```py
|
||||
>>> 14^5
|
||||
11
|
||||
>>> bin(11)
|
||||
'0b1011'
|
||||
>>> bin(14)
|
||||
'0b1110'
|
||||
>>> bin(5)
|
||||
'0b101'
|
||||
```
|
||||
## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
|
||||
```py
|
||||
>>> h=14
|
||||
>>> bin(14)
|
||||
'0b1110'
|
||||
>>> g=h<<2
|
||||
>>> bin(g)
|
||||
'0b111000'
|
||||
>>> g1=h>>1
|
||||
>>> bin(g1)
|
||||
'0b111'
|
||||
>>> g2=h>>2
|
||||
>>> bin(g2)
|
||||
'0b11'
|
||||
```
|
||||
Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
|
||||
```py
|
||||
>>> bin(76)
|
||||
'0b1001100'
|
||||
>>> bin(112)
|
||||
'0b1110000'
|
||||
>>> 76&112
|
||||
64
|
||||
>>> bin(64)
|
||||
'0b1000000'
|
||||
>>> 76|112
|
||||
124
|
||||
>>> bin(124)
|
||||
'0b1111100'
|
||||
>>> 76^112
|
||||
60
|
||||
>>> g=76<<2
|
||||
>>> g
|
||||
304
|
||||
>>> bin(g)
|
||||
'0b100110000'
|
||||
```
|
||||
## 6. Операции при работе с последовательностями (строками, списками, кортежами).
|
||||
## 6.1. Объединение последовательностей (конкатенация)(+)
|
||||
```py
|
||||
>>>'Система '+'регулирования' #Соединение двух строк символов
|
||||
'Система регулирования'
|
||||
>>>['abc','de','fg']+['hi','jkl'] # Объединение двух списков
|
||||
['abc', 'de', 'fg', 'hi', 'jkl']
|
||||
>>>('abc','de','fg')+('hi','jkl') # Объединение двух кортежей
|
||||
('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
```
|
||||
## 6.2 Повторение (*)
|
||||
```py
|
||||
>>> 'ля-'*5
|
||||
'ля-ля-ля-ля-ля-'
|
||||
>>> ['ку','-']*3
|
||||
['ку', '-', 'ку', '-', 'ку', '-']
|
||||
|
||||
>>> ('кис','-')*4
|
||||
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
|
||||
>>> signal1=[0]*3+[1]*99
|
||||
>>> signal1
|
||||
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
|
||||
>>> signal2=(0,)*3+(1,)*5+(0,)*7
|
||||
>>> signal2
|
||||
(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
|
||||
```
|
||||
## 6.3. Проверка наличия заданного элемента в последовательности (in)
|
||||
```py
|
||||
>>> stroka='Система автоматического управления'
|
||||
>>> 'автомат' in stroka
|
||||
True
|
||||
>>> 'ку' in ['ку','-']*3
|
||||
True
|
||||
>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
False
|
||||
```
|
||||
## 6.4. Подстановка значений в строку с помощью оператора «%»
|
||||
```py
|
||||
>>> stroka='Температура=%g %s %g'
|
||||
>>> stroka
|
||||
'Температура=%g %s %g'
|
||||
>>> stroka % (16,' меньше ',25)
|
||||
'Температура=16 меньше 25'
|
||||
>>> stroka % (66,' меньше ',77)
|
||||
'Температура=66 меньше 77'
|
||||
>>> stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
## 7. Оператор присваивания
|
||||
## 7.1. Обычное присваивание значения переменной (=)
|
||||
>>> zz=-12
|
||||
## 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=)
|
||||
>>> zz+=5
|
||||
>>> zz
|
||||
-7
|
||||
>>> zz-=3
|
||||
>>> zz
|
||||
-10
|
||||
>>> stroka='Система'
|
||||
>>> stroka+=' регулирования'
|
||||
>>> stroka
|
||||
'Система регулирования'
|
||||
## 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
|
||||
>>> zz/=2
|
||||
>>> zz
|
||||
-5.0
|
||||
>>> zz*=5
|
||||
>>> zz
|
||||
-25.0
|
||||
## 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
|
||||
>>> zz//=2
|
||||
>>> zz
|
||||
-13.0
|
||||
>>> zz**=2
|
||||
>>> zz
|
||||
169.0
|
||||
## 7.5. Множественное присваивание
|
||||
Присваивание одного значения нескольким переменным
|
||||
>>> w=v=10
|
||||
>>> w
|
||||
10
|
||||
>>> v
|
||||
10
|
||||
Присваивание кортежа
|
||||
>>> n1,n2,n3=(11,-3,'all')
|
||||
>>> n1,n2,n3
|
||||
(11, -3, 'all')
|
||||
Присваивание списка
|
||||
>>> a1,a2,a3=[1,2,3]
|
||||
>>> a1,a2,a3
|
||||
(1, 2, 3)
|
||||
Присваивание словаря
|
||||
>>> s1,s2,s3={'один':1,'два':2,'три':3}
|
||||
>>> s1,s2,s3
|
||||
('один', 'два', 'три')
|
||||
Если необходимо присвоить значения, то это можно сделать через .values()
|
||||
>>> s1,s2,s3={'один':1,'два':2,'три':3}.values()
|
||||
>>> s1,s2,s3
|
||||
(1, 2, 3)
|
||||
Если необходимо присвоить ключи и значения, то это можно сделать через .items()
|
||||
>>> f1,f2,f3={'один':1,'два':2,'три':3}.items()
|
||||
>>> f1,f2,f3
|
||||
(('один', 1), ('два', 2), ('три', 3))
|
||||
>>> f1
|
||||
('один', 1)
|
||||
>>> f2
|
||||
('два', 2)
|
||||
>>> f3
|
||||
('три', 3)
|
||||
Присваивание множества
|
||||
>>> m1,m2,m3={0,89,6}
|
||||
>>> m1,m2,m3
|
||||
(0, 89, 6)
|
||||
Присваивание строки
|
||||
>>> c1,c2,c3='1','2','3'
|
||||
>>> c1,c2,c3
|
||||
('1', '2', '3')
|
||||
## 8. Логические операции (True или False)
|
||||
## 8.1. Операции сравнение
|
||||
```py
|
||||
>>> v==w
|
||||
True
|
||||
>>> v!=w
|
||||
False
|
||||
>>> v>w
|
||||
False
|
||||
>>> v<w
|
||||
False
|
||||
>>> v>=w
|
||||
True
|
||||
>>> v<=w
|
||||
True
|
||||
>>> 5==4
|
||||
False
|
||||
>>> 5!=4
|
||||
True
|
||||
>>> 5>4
|
||||
True
|
||||
>>> 5<4
|
||||
False
|
||||
>>> 5>=4
|
||||
True
|
||||
>>> 5<=4
|
||||
False
|
||||
```
|
||||
## 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также про-верка наличия ключа в словаре (in).
|
||||
Операции с множеством
|
||||
```py
|
||||
>>> mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
>>> 'book' in mnoz1
|
||||
True
|
||||
>>> 'cap' in mnoz1
|
||||
False
|
||||
```
|
||||
Операции со словарем
|
||||
```py
|
||||
>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
>>> 'Vologda' in dic1
|
||||
True
|
||||
>>> 'Pskov' in dic1
|
||||
False
|
||||
>>> 56 in dic1.values()
|
||||
True
|
||||
```
|
||||
Ещё пример работы со словарем:
|
||||
```py
|
||||
>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
|
||||
>>> 'UII' in dct1['Depart']
|
||||
True
|
||||
>>> dct1['Depart'][1] == 'MM'
|
||||
False
|
||||
```
|
||||
## 8.3. Создание больших логических выражений с использованием соединительных слов: логиче-ское «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
|
||||
```py
|
||||
>>> a=17
|
||||
>>> b=-6
|
||||
>>> (a>=b)and('book' in mnoz1)and not('Pskov' in dic1 )
|
||||
True
|
||||
>>> (5==4)or(a==17)
|
||||
True
|
||||
>>> (5==4)and(a==17)
|
||||
False
|
||||
>>> ((5==4)and(a==17))or(not(5==4)and(a==17))
|
||||
True
|
||||
## 8.4. Проверка ссылок переменных на один и тот же объект (is).
|
||||
```py
|
||||
>>> w=v=10
|
||||
>>> w1=['A','B']
|
||||
>>> v1=['A','B']
|
||||
>>> w1==v2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'v2' is not defined. Did you mean: 'v'?
|
||||
>>> w1==v1
|
||||
True
|
||||
>>> w1 is v1
|
||||
False
|
||||
>>> w is v
|
||||
True
|
||||
```
|
||||
Оператор is сравнивает адреса объектов в памяти. Целые числа из одной строки хранятся по одному адресу, поэтому is возвращает True. Словари же, созданные отдельно, размещаются в разных местах памяти, и is для них дает False.
|
||||
## Пункт 9. Операции с объектами, выполняемые с помощью методов.
|
||||
Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
|
||||
```py
|
||||
>>> stroka='Микропроцессорная система управления'
|
||||
>>> dir(stroka)
|
||||
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
|
||||
```
|
||||
## 9.1. Методы для работы со строками
|
||||
```py
|
||||
>>> stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1
|
||||
5
|
||||
>>> stroka.count("с") #Подсчет числа вхождений строки "с" в stroka
|
||||
4
|
||||
>>> stroka.replace(' у',' автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
>>> spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит за-данный разделитель
|
||||
>>> spis22
|
||||
['Микропроцессорная', 'система', 'управления']
|
||||
>>> stroka.upper() #Возвращает строку со всеми заглавными буквами
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
>>> stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка
|
||||
>>> stroka3
|
||||
'Микропроцессорная система управления'
|
||||
>>> stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева
|
||||
('Микропроце', 'с', 'сорная система управления')
|
||||
>>> stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа
|
||||
('Микропроцессорная си', 'с', 'тема управления')
|
||||
```
|
||||
## Mетод format
|
||||
Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
|
||||
```py
|
||||
>>> strk1='Момент времени {}, значение = {}'
|
||||
>>> strk1
|
||||
'Момент времени {}, значение = {}'
|
||||
>>> strk1.format(1,89.7)
|
||||
'Момент времени 1, значение = 89.7'
|
||||
>>> strk2='Момент времени {1}, значение = {0}:{2}'
|
||||
```
|
||||
Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргумен-тов формата. Поэтому такой способ называют основанным на позиционных аргументах. Например,
|
||||
```py
|
||||
>>> strk2.format(36.7,2,'норма!')
|
||||
'Момент времени 2, значение = 36.7:норма!'
|
||||
>>> strk3='Момент времени {num}, значение = {znch}'
|
||||
```
|
||||
Здесь в скобках указаны имена аргументов – вставок. Поэтому такой способ основан на имено-ванных аргументах.
|
||||
```py
|
||||
>>> strk3.format(znch=89.7,num=2)
|
||||
'Момент времени 2, значение = 89.7'
|
||||
```
|
||||
## 9.2. Методы для работы со списками.
|
||||
```py
|
||||
>>> spsk = [1, (2, 3), 'hello Sergey Alexandrovich', 3.14 , 'pi']
|
||||
>>> spsk.pop(2) #Удаление элемента по индексу
|
||||
'hello Sergey Alexandrovich'
|
||||
>>> spsk.append('c') #Вставка элемента в конец
|
||||
>>> spsk
|
||||
[1, (2, 3), 3.14, 'pi', 'c']
|
||||
>>> spsk.insert(2,'a') #Вставка элемента в конкретное место по индексу
|
||||
>>> spsk
|
||||
[1, (2, 3), 'a', 3.14, 'pi', 'c']
|
||||
>>> spsk.count('a') #Подсчет количества элементов по значению
|
||||
1
|
||||
## 9.3. Mетоды кортежей
|
||||
У кортежей методов меньше, тк он являетя неизменяемым и методов на добавление/удаление объекта - нет
|
||||
```py
|
||||
>>> km2=(5,'пять', 5.55, 'мопсикии',4+1j)
|
||||
>>> km2.count(5)
|
||||
1
|
||||
>>> km2.index('мопсикии')
|
||||
3
|
||||
```
|
||||
## 9.4 Методы словарей
|
||||
```py
|
||||
>>> d={'key1':1, 'key2':2,'key3':3,'key4':4}
|
||||
Cоздание копии
|
||||
```py
|
||||
>>> d1=d.copy()
|
||||
>>> d1
|
||||
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}
|
||||
```
|
||||
Возвращение значения по ключу
|
||||
```py
|
||||
>>> d.get('key3')
|
||||
3
|
||||
```
|
||||
Возвращение кортежей из пар ключ-значение
|
||||
```py
|
||||
>>> d.items()
|
||||
dict_items([('key1', 1), ('key2', 2), ('key3', 3), ('key4', 4)])
|
||||
```
|
||||
Возвращение объекта только из ключей
|
||||
```py
|
||||
>>> d.keys()
|
||||
dict_keys(['key1', 'key2', 'key3', 'key4'])
|
||||
```
|
||||
Возвращение объекта только из значений
|
||||
```py
|
||||
>>> d.values()
|
||||
dict_values([1, 2, 3, 4])
|
||||
```
|
||||
Добавление ключ-значения
|
||||
```py
|
||||
>>> d['key5']=5
|
||||
>>> d
|
||||
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
|
||||
```
|
||||
Удаление ключ-значения
|
||||
```py
|
||||
>>> d.pop('key1')
|
||||
1
|
||||
>>> d
|
||||
{'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
|
||||
```
|
||||
Очищение словаря
|
||||
```py
|
||||
>>> d.clear()
|
||||
>>> d
|
||||
{}
|
||||
```
|
||||
|
||||
## Методы множеств
|
||||
|
||||
```py
|
||||
>>> mn={1,'dva',3.33}
|
||||
```
|
||||
Добавление элемента
|
||||
```py
|
||||
>>> mn.add(4)
|
||||
>>> mn
|
||||
{1, 3.33, 4, 'dva'}
|
||||
```
|
||||
Создание копии
|
||||
```py
|
||||
>>> cop=mn.copy()
|
||||
>>> cop
|
||||
{1, 3.33, 4, 'dva'}
|
||||
```
|
||||
Удаление элемента по значению
|
||||
```py
|
||||
>>> mn.remove(1)
|
||||
>>> mn
|
||||
{3.33, 4, 'dva'}
|
||||
```
|
||||
Удаление элемента по значению
|
||||
```py
|
||||
>>> mn.discard('dva')
|
||||
>>> mn
|
||||
{3.33, 4}
|
||||
```
|
||||
Очищение множества
|
||||
```py
|
||||
>>> mn.clear()
|
||||
>>> mn
|
||||
set()
|
||||
```
|
||||
Удаление и возвращение случайного элемента из множества
|
||||
```py
|
||||
>>> cop.pop()
|
||||
1
|
||||
>>> cop
|
||||
{3.33, 4, 'dva'}
|
||||
```
|
||||
Добавление элементов
|
||||
```py
|
||||
>>> cop.update({False,'t'})
|
||||
>>> cop
|
||||
{False, 3.33, 4, 't', 'dva'}
|
||||
```
|
||||
|
||||
#Общее контрольное задание
|
||||
Преобразовать восьмеричное значение 45 в целое число.
|
||||
```py
|
||||
|
||||
>>> octv = '45'
|
||||
>>> decv = int(octv, 8)
|
||||
>>> decv
|
||||
37
|
||||
```
|
||||
Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12,
|
||||
"постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и
|
||||
значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж
|
||||
от списка?
|
||||
```py
|
||||
>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
|
||||
>>> keyD = list(D.keys())
|
||||
>>> keyD
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
>>> valD = list(D.values())
|
||||
>>> valD
|
||||
[23, 12, 78]
|
||||
>>> tupD = (keyD, valD)
|
||||
>>> tupD
|
||||
(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
|
||||
|
||||
```
|
||||
Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с
|
||||
округлением вниз, с определением после этого остатка от деления получившегося значения
|
||||
на 3 и затем возведения результата в степень 2.4.
|
||||
```py
|
||||
>>> ((1768 // 24.8) % 3) ** 2.4
|
||||
5.278031643091577
|
||||
```
|
||||
Напишите и выполните единое выражение, последовательно осуществляющее следующие
|
||||
операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее
|
||||
ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
```py
|
||||
>>> ((~(13 & 27)) ^ 14) << 2
|
||||
-32
|
||||
```
|
||||
Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки
|
||||
наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов
|
||||
этого списка.
|
||||
```py
|
||||
>>> lst = ["колебат"] * 4
|
||||
>>> lst[1] += lst[2]
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат', 'колебат']
|
||||
>>> lst.pop(2)
|
||||
'колебат'
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат']
|
||||
>>> 'аткол' in lst[1]
|
||||
True
|
||||
```
|
||||
Определить список методов, доступных у ранее созданного словаря D. Поочередно
|
||||
использовать его методы keys и values, определить, что можно получить с применением
|
||||
этих методов.
|
||||
```py
|
||||
>>> D
|
||||
{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
|
||||
>>> dir(D)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
|
||||
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
|
||||
'__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__',
|
||||
'__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__',
|
||||
'__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__',
|
||||
'__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items',
|
||||
'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
>>> D.keys()
|
||||
dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
|
||||
>>> D.values()
|
||||
dict_values([23, 12, 78])
|
||||
```
|
||||
#dict_keys и dict_values особые объекты, которые ссылаются на элементы исходного словаря.
|
||||
|
||||
Создать объект - символьную строку с текстом данного предложения. Из символьной строки
|
||||
создать список, элементами которого будут отдельные слова из созданной строки. Заменить в
|
||||
списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить
|
||||
получившийся список.
|
||||
```py
|
||||
>>> sen = "Создать объект - символьную строку с текстом данного предложения"
|
||||
>>> senl = sen.split()
|
||||
>>> senl
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl[senl.index("-")] = ","
|
||||
>>> senl
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl.remove("данного")
|
||||
>>> senl
|
||||
['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
Загрузка…
Ссылка в новой задаче