Добавление списка python

Хранение данных в массивах

При попытке сохранения значения в массиве — автоматически будет создан массив, если он не существовал ранее, но при попытке извлечь значение из массива, который не был определен — массив не будет создан. Например:

// $addresses не определен до этого момента
echo $addresses;                    // ничего 
echo $addresses;                       // ничего
$addresses = 'spam@cyberpromo.net';
echo $addresses;                       // печать "Array"

Можно использовать простое присваивание для инициализации массива в программе:

$addresses = 'spam@cyberpromo.net';
$addresses = 'abuse@example.com';
$addresses = 'root@example.com';
// ...

Мы объявили индексный массив с целыми индексами, начиная с 0.

Ассоциативный массив:

$price = 15.29;
$price  = 75.25;
$price   = 50.00;
// ...

Более простой способ инициализации массива состоит в использовании конструкции Array(), которая строит массив из ее аргументов:

$addresses = array(
     'spam@cyberpromo.net', 
     'abuse@example.com',
     'root@example.com'
);

Чтобы создать ассоциативный массив с помощью Array(), используйте => символ, отделяющий индексы от значений:

$price = array(
    'Gasket' => 15.29,
    'Wheel'  => 75.25,
    'Tire'   => 50.00
);

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

$price = array('Gasket'=>15.29,'Wheel'=>75.25,'Tire'=>50.00);

Чтобы создать пустой массив, нужно вызвать конструкцию Array() без аргументов:

$addresses = Array(  );

Вы можете указать начальную ключ в массиве, а затем список значений. Значения вводятся в массив, начиная с ключа с последующим увеличением:

$days = array(1 => 'Monday',   'Tuesday', 'Wednesday',
                   'Thursday', 'Friday',  'Saturday', 'Sunday');
// 2 is Tuesday, 3 is Wednesday, etc.

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

$whoops = array('Friday' => 'Black', 'Brown', 'Green');
// same as
$whoops = array('Friday' => 'Black', 0 => 'Brown', 1 => 'Green');

Слияние массивов

Для слияния двух ассоциативных массивов предусмотрен оператор +:

$Ket=’перс’;
$Ket=’сиам’;
$Dog=’питбуль’;
$Dog=’мастиф’;

$Animals = $Ket + $Dog;

print_r($Animals); //выведет массив

1 2 3 4 5 6 7 8

$Ket’kat1’=’перс’; $Ket’kat2’=’сиам’; $Dog’dog1’=’питбуль’; $Dog’dog2’=’мастиф’; $Animals=$Ket+$Dog; print_r($Animals);//выведет массив

В этом примере массив $Animals будет содержать все элементы массивов $Ket и $Dog.Причем порядок следования элементов будет зависеть от порядка, в котором массивы сливаются. Так проявляется направленность массивов, она заставляет оператор + стать некоммутативным, т.е. $Ket + $Dog не равно $Dog + $Ket.

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

$Mass3= array_merge($Mass1, $Mass2);
print_r($Mass3); //выведет массив

1 2 3 4 5 6 7

$Mass1=’name’; $Mass1=’sname’; $Mass2=’phone’; $Mass2=’email’; $Mass3=array_merge($Mass1,$Mass2); print_r($Mass3);//выведет массив

Теперь массив $Mass3 содержит все элементы массивов $Mass1 и $Mass2.

Если один из параметров в функции array_merge() не является массивом, интерпретатор выведет сообщение об ошибке.

Array.isArray

Массивы не
образуют отдельный тип языка. Они основаны на объектах. Поэтому typeof не может
отличить простой объект от массива:

console.log(typeof {}); // object
console.log (typeof ); // тоже object

Но массивы
используются настолько часто, что для этого придумали специальный метод: Array.isArray(value). Он возвращает
true, если value массив, и false, если нет.

console.log(Array.isArray({})); // false
console.log(Array.isArray()); // true

Подведем итоги
по рассмотренным методам массивов. У нас получился следующий список:

Для добавления/удаления элементов
push(…items)	добавляет элементы в конец
pop()	извлекает элемент с конца
shift()	извлекает элемент с начала
unshift(…items)	добавляет элементы в начало
splice(pos, deleteCount, …items)	начиная с индекса pos, удаляет deleteCount элементов и вставляет items
slice(start, end)	создаёт новый массив, копируя в него элементы с позиции start до end (не включая end)
concat(…items)	возвращает новый массив: копирует все члены текущего массива и добавляет к нему items (если какой-то из items является массивом, тогда берутся его элементы)
Для поиска среди элементов
indexOf/lastIndexOf(item, pos)	ищет item, начиная с позиции pos, и возвращает его индекс или -1, если ничего не найдено
includes(value)	возвращает true, если в массиве имеется элемент value, в противном случае false
find/filter(func)	фильтрует элементы через функцию и отдаёт первое/все значения, при прохождении которых через функцию возвращается true
findIndex(func)	похож на find, но возвращает индекс вместо значения
Для перебора элементов
forEach(func)	вызывает func для каждого элемента. Ничего не возвращает
Для преобразования массива
map(func)	создаёт новый массив из результатов вызова func для каждого элемента
sort(func)	сортирует массив «на месте», а потом возвращает его
reverse()	«на месте» меняет порядок следования элементов на противоположный и возвращает изменённый массив
split/join	преобразует строку в массив и обратно
reduce(func, initial)	вычисляет одно значение на основе всего массива, вызывая func для каждого элемента и передавая промежуточный результат между вызовами

Видео по теме

JavaScipt #1: что это такое, с чего начать, как внедрять и запускать

JavaScipt #2: способы объявления переменных и констант в стандарте ES6+

JavaScript #3: примитивные типы number, string, Infinity, NaN, boolean, null, undefined, Symbol

JavaScript #4: приведение типов, оператор присваивания, функции alert, prompt, confirm

JavaScript #5: арифметические операции: +, -, *, /, **, %, ++, —

JavaScript #6: условные операторы if и switch, сравнение строк, строгое сравнение

JavaScript #7: операторы циклов for, while, do while, операторы break и continue

JavaScript #8: объявление функций по Function Declaration, аргументы по умолчанию

JavaScript #9: функции по Function Expression, анонимные функции, callback-функции

JavaScript #10: анонимные и стрелочные функции, функциональное выражение

JavaScript #11: объекты, цикл for in

JavaScript #12: методы объектов, ключевое слово this

JavaScript #13: клонирование объектов, функции конструкторы

JavaScript #14: массивы (array), методы push, pop, shift, unshift, многомерные массивы

JavaScript #15: методы массивов: splice, slice, indexOf, find, filter, forEach, sort, split, join

JavaScript #16: числовые методы toString, floor, ceil, round, random, parseInt и другие

JavaScript #17: методы строк — length, toLowerCase, indexOf, includes, startsWith, slice, substring

JavaScript #18: коллекции Map и Set

JavaScript #19: деструктурирующее присваивание

JavaScript #20: рекурсивные функции, остаточные аргументы, оператор расширения

JavaScript #21: замыкания, лексическое окружение, вложенные функции

JavaScript #22: свойства name, length и методы call, apply, bind функций

JavaScript #23: создание функций (new Function), функции setTimeout, setInterval и clearInterval

Основы

Давайте начнём с простой функции, которая оперирует ключами и значениями элементов массивов. Одной из таких функций является array_combine(), которая создаёт новый массив из двух существующих: первый использует для создания ключей, второй в качестве значений:

$keys = ;
$values = ;

$array = array_combine($keys, $values);
print_r($array);

// Array
// (
// 	 => blue
// 	 => green
// 	 => orange
// )

В этом же разрезе вам могут пригодиться функции array_values(). Она извлекает из ассоциативного массива значения; array_keys() возвращает только ключи заданного массива; array_flip() меняет местами ключи и значения:

print_r(array_keys($array)); // 
print_r(array_values($array)); // 
print_r(array_flip($array));

// Array
// (
// 	 => sky
// 	 => grass
// 	 => orange
// )

3.1. Тривиальные типы и неинициализированные переменные

Конструкторы и деструкторы можно назвать ключевыми элементами объектной модели С++. При создании объекта обязательно вызывается конструктор, а при удалении — деструктор. Но проблемы совместимости с С вынудили сделать некоторое исключение, и это исключение называется тривиальные типы. Они введены для моделирования сишных типов и сишного жизненного цикла переменных, без обязательного вызова конструктора и деструктора. Сишный код, если он компилируется и выполняется в С++, должен работать так же как в С. К тривиальным типам относятся числовые типы, указатели, перечисления, а также классы, структуры, объединения и массивы, состоящие из тривиальных типов. Классы и структуры должны удовлетворять некоторым дополнительным условиям: отсутствие пользовательского конструктора, деструктора, копирования, присваивания, виртуальных функций.

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

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

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

В стандартной библиотеке С++11 есть шаблоны, называемые свойствами типов (заголовочный файл ). Один из них позволяет определить, является ли тип тривиальным. Выражение имеет значение , если тривиальный тип и в противном случае.

Удаление элементов из массива

Удалить элемент немножко сложнее, чем его добавить. Чтобы удалить элемент из конца массива, можно использовать pop():

var myArray = ;  
myArray.pop();  
console.log(myArray); // 

Метод pop() всегда удаляет последний элемент в массиве и возвращает его.

Вы так же можете использовать splice() метод:

var myArray = ;  
myArray.splice(2, 1); // удалить элемент с индексом 2  
console.log(myArray); // 

В отличии от метода splice(), который используется для добавления элементов, здесь вторым аргументом идет 1, которая говорит, что мы хотим удалить элемент с индексом 2 (или 3-ий по счету). В данном случае удалился элемент «lupin».

Вы можете удалить элемент массива используя оператор delete:

var myArray = ;  
console.log(myArray.length); // 4  
delete myArray; // удалить Eliza
console.log(myArray.length); // 4  
console.log(myArray); // 

Первое важное замечание: delete() не изменяет длину массива после удаления элемента (даже, если это был последний элемент в массиве). Второе: delete() изменяет значение удаляемого элемента на undefined, поэтому при обращении myArray = undefined

Хороший способ удалить элемент из массива — использовать John Resig’s Array.remove. Ниже пример использования, взятый с его страницы:

// Array Remove - By John Resig (MIT Licensed)  
Array.prototype.remove = function(from, to) {  
  var rest = this.slice((to || from) + 1 || this.length);  
  this.length = from < 0 ? this.length + from : from;  
  return this.push.apply(this, rest);  
};  

// Удаление 2 элемента из массива
array.remove(1);  
// Удаление 2-ого элемента с конца массива  
array.remove(-2);  
// Удаление второго и третьего элемента
array.remove(1,2);  
// Удаление последнего и предпоследнего элемента  
array.remove(-2,-1);

Возможно вы захотите посмотреть решение by Viral Patel, одну из функций в , или jQuery’s grep().

Дополнительно, в JavaScript есть метод shift(), который удаляет первый элемент в массиве и возвращает его значение. Посмотрим код:

var myArray = ;  
console.log(myArray.length); // 4  
var firstItem = myArray.shift();  
console.log(firstItem); // Matt Kramer  
console.log(myArray.length); // 3  
console.log(myArray); // 

С помощью метода shift() мы удалили элемент, но сохранили его значение в нашей переменной firstItem. Длина массива изменилась с 4 на 3.

Этот метод может быть полезен вместе с методом push(). Используя их вместе мы можем эффективно выстраивать очередь элементов в массиве. Мы сохраняем длину массива удаляя элемент с начала и добавляя новый в конец.

Наоборот, мы можем использовать метод unshift() для добавления элемент в начало массива:

var myArray = ;  
console.log(myArray.length); // 3  
myArray.unshift("chime bar", "tan-tan");  
console.log(myArray.length); // 5  
console.log(myArray); // 

Используя метод unshift() с методом pop(), вы можете создавать очереди в обратную сторону, добавляя элементы в начало и удаляя с конца массива.

6.1. Создание и удаление динамического массива

Если некоторый тип, переменная, значение которой может определяются в процессе выполнения программы, то инструкция

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

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

В C++11 появилась возможность использовать список инициализации.

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

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

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

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

В остальных отношениях указатель , возвращаемый оператором , является просто указателем на начало массива, через него нельзя (во всяком случае «законно») получить размер массива, этот размер надо хранить отдельно. Соответственно с динамическим массивом нельзя использовать диапазонный .

Функция explode() и implode()

Данные функции часто используют при работе с массивами.

• explode() — служит для разбиения какой-либо строки на более мелкие части (например, эти части разделяются в строке спецсимволом)
• implode() — служит слияния нескольких небольших строк в одну большую, причем не впритык, а вставляя между ними разделитель

Синтаксис explode():

list explode(string $token, string $Str )

1	list explode(string$token,string$Str,int$limit)

Функция получает строку, заданную в ее втором аргументе, и пытается найти в ней подстроки, равные первому аргументу. Затем по месту вхождения этих подстрок строка «разрезается» на части, помещаемые в массив-список, который возвращается в результате. Если задан параметр $limit, то учитываются только первые($limit-1) участков «разреза». Таким образом, возвращается список из не более чем $limit элементов. Это позволяет нам проигнорировать возможное наличие разделителя в тексте последнего поля, если мы знаем, что всего полей, скажем, 6. Вот пример:

$pizza = «piece1 piece2 piece3 piece4 piece5 piece6″;
$pieces = explode(» «, $pizza);
echo $pieces; // piece1
echo $pieces; // piece2

1 2 3 4

$pizza=»piece1 piece2 piece3 piece4 piece5 piece6″; $pieces=explode(» «,$pizza); echo$pieces;// piece1 echo$pieces1;// piece2

Строкой разбиения может быть не только один символ, но и небольшая строка.

Синтаксис implode():

string implode(string $glue, list $List)

1	stringimplode(string$glue,list$List)

Она получает ассоциативный массив $List, заданный во втором параметре, и «склеивают» его значения при помощи «строки-клея» $glue из первого параметра. Вместо списка во втором аргументе можно передавать любой ассоциативный массив — в этом случае будут рассматриваться только его значения.

6.2. Управление жизненным циклом динамического массива

Стандартный интеллектуальный указатель можно использовать для управления жизненным циклом динамического массива (см. ). Он имеет частичную специализацию для массивов, которая перегружает оператор вместо оператора и использует оператор в качестве удалителя по умолчанию. Вот пример:

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

Перебор массива

Довольно часто при написании сценариев, приходится перебирать все элементы некоторого массива. Если массив список то его элементы можно перебрать с помощью функции count() и цикла for:

($i=0; $i<count($mass); $i++)

echo $mass;

1 2 3

($i=;$i<count($mass);$i++) echo$mass$i;

С ассоциативным массивом все немного сложнее. Рассмотрим пример:

$base = array(

«Petrov Ivan» => «1989-03-20»,
«Sidorov Semen» =>»1990-09-09″,

);

for (reset($base); ($k=key($base)); next($base)) echo «$k родился {$base}<br>»;

1 2 3 4 5 6 7 8

$base=array( «Petrov Ivan»=>»1989-03-20», «Sidorov Semen»=>»1990-09-09», ); for(reset($base);($k=key($base));next($base))echo»$k родился {$base}<br>»;

В массивах есть такое понятие как текущий элемент. Функция reset() просто устанавливает этот элемент на первую позицию в массиве. Функция key() возвращает ключ, который имеет текущий элемент. Функция next() перемещает текущий элемент на одну позицию вперед.

Помимо своей основной задачи, функции reset() и next(), возвращают некоторые значения:

• reset() — возвращает значение первого элемента массива (false если массив пуст);
• next() — возвращает значение элемента, следующего за текущим (fals если такого элемента нет).

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

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

Гораздо удобнее использовать метод прямого перебора. Суть метода заключается в том, чтобы сразу на каждом «витке» цикла одновременно получать и ключ, и значение текущего элемента. Не будем описывать устаревший способ перебора с помощью функции each() и перейдем к foreach.

Перебор циклом foreach

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

foreach ($base) as $k =>$v) echo ‘$k родился $v’;

1	foreach($base)as$k=>$v)echo’$k родился $v’;

Подробнее ознакомиться с механизмом работы данного цикла можно в статье о циклах.

Добавление элементов в массив.

Вы можете использовать свойство length для добавления новых элементов в массив:

var myArray = ;  
myArray = "Yahoo!";  
console.log(myArray); // 

Это сработает, т.к. элементы массива нумеруются с нуля, а length на единицу больше. Length всегда эквивалентно index + 1, поэтому очень легко добавить новый элемент в конец массива. Странно, но вы можете добавить элемент на позицию, которая намного больше, чем длина самого массива:

var myArray = ;  
myArray = "Lindsey Buckingham";  
console.log(myArray);  
//   
console.log(myArray.length); // 100

var myArray = ;  
myArray.push("Ringo Starr", "George Martin");  
console.log(myArray);  
// 

Метод push() всегда возвращает новую длину массива (в нашем случае 5). Добавить элемент можно с помощью splice():

var myArray = ;  
myArray.splice(2, 0, "cashew"); // adds "cashew" into index 2  
console.log(myArray); // 

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

Разделение массива.

Мы можете создать новый массив, содержащий 1 или более элементов из существующего массива, используя функцию slice():

var myArray = ;  
var myNewArray = myArray.slice(4);  
console.log(myNewArray); // 

Метод slice() принимает 1 или 2 аргумента. Если передан 1 аргумент (индекс), то новый массив создается из всех элементов старого, начиная с данного индекса. Если передано 2 аргумента, то новый массив создается из элементов, начиная с первого аргумента и до элемента с индексом, переданным во втором параметре, не включая последний. Чтобы было понятней, посмотрим код ниже:

var myArray = ;  
var myNewArray = myArray.slice(0, 4);  
console.log(myNewArray); // 

В данном случае 0, 4 означает взять элементы с 0 индекса по 3, включительно.

Инициализация массива

Массив можно инициализировать поэлементно:

1 2 3 4

$Mass=’name’; $Mass=’sname’; $Mass=’phone’; $Mass=’email’;

Операция [] всегда добавляет элемент в конец массива, присваивая ему при этом такой числовой индекс, который бы не конфликтовал с уже имеющимися в массиве(т.е. выбирается номер, превосходящий все имеющиеся цифровые ключи в массиве).

Кроме этого можно воспользоваться инструкцией list() — она позволяет присваивать переменным значения элементов массива:

list ($name, $surname, $phone) = $Mass;

1	list($name,$surname,$phone)=$Mass;

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

Существует еще один способ инициализации функции array():

1	$Mass=array(‘name’,’sname’,’phone’,’email’);

Ддя ассоциативного массива:

1	$Mass=array(‘name’=>’Иван’,’sname’=>’Иванович’,’phone’=>’89092551235′,’email’=>’ivanov@mail.ru’);

Можно использовать сокращенную запись:

1	$Mass=’name’,’sname’,’phone’,’email’;

Массивы на экран выводятся оператором print_r(). С его помощью выведем содержание массива $Mass на экран следующим образом:

print_r($Mass);

1	print_r($Mass);

Должно получиться:

1	Array(=name1=sname2=phone3=email)

Давайте разберемся что же все это значит. Array — это обозначение типа данных т.е. в нашем случае массива. Далее выводятся все 5 элементов заложенные нами в этот массив. Цифры в квадратных скобках — это ключи каждого элемента массива или можно сказать нумерация элементов массива. При инициализации массива можно сразу же указать индексы элементов( и вовсе не обязательно соблюдать порядок нумерации):

1 2 3 4

$Mass1=’name’; $Mass3=’sname’; $Mass9=’phone’; $Mass82=’email’;

Если же индекс не указывать(как показано в предыдущем примере) то, PHP автоматически присвоит элементу индекс, на единицу больше последнего, т.е. добавит элемент в конец массива.

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

Многомерные массивы

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

$baza = array(
‘Иванов’ => array(‘Имя’=>’Иван’, ‘Отчество’=>’Иванович’,
‘Год рождения’=>’1980’),
‘Петров’ => array(‘Имя’=>’Семен’, ‘Отчество’=>’Семенович’,
‘Год рождения’=>’1985’)
)

1 2 3 4 5 6

$baza=array( ‘Иванов’=>array(‘Имя’=>’Иван’,’Отчество’=>’Иванович’, ‘Год рождения’=>’1980’), ‘Петров’=>array(‘Имя’=>’Семен’,’Отчество’=>’Семенович’, ‘Год рождения’=>’1985’) )

Доступ к элементу такого массива осуществляется путем указания двух ключей:

echo $baza;

1	echo$baza’Иванов»Год рождения’;

После этого на экране увидим цифру 1980.

Утилитой mtk

Для запуска MTK на андроиде можно использовать стороннее программное обеспечение, которое также скачивается из репозитория Google Play. Рассмотрим подробно процедуру на примере апплета «Инженерное меню МТК». Она работает только со смартфонами на базе процессора типа МТК. Действия по смене идентификатора выполняются достаточно просто:

• Запускаем приложение и нажимаем на строчку «Инженерное меню МТК»;
• Смартфон перенаправит пользователя в инженерное меню, где идем по маршруту «Connectivity», затем «CDS Information», а далее в «Phone Information»;
• Идентификатор вводится последовательно в строки Phone 1 и Phone

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

Что с олеофобным покрытием делают защитные стёкла