wwwoldi.ru

About Me

Dashy

Hello word I am dashy Guy

Разное

Python sort array: How to Sort Array in Python

alexxlab
No Comments

Содержание

Метод List.sort в Python

Из этого урока вы узнаете о методе сортировки списка Python. Вы увидите, как использовать его со списками с помощью примеров.

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

Метод sort выполняет сортировку элементов списка в восходящем или нисходящем направлении. Его синтаксис выглядит следующим образом:

List_name.sort(key = …, reverse = ...)

Когда метод sort() вызывается без аргументов, по умолчанию он сортируется в порядке возрастания. У него нет возвращаемого значения.

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

Обратите внимание, что это не связано со встроенной функцией sorted(). Метод sort изменяет старый список, тогда как sorted() создает новую отсортированную последовательность.

Как работает метод sort

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

Если в качестве аргумента указать «reverse = true», список будет отсортирован в порядке убывания.

Основной параметр — это шаги, которые должен пройти метод при сортировке списка элементов. Значение, данное ключу, может быть функцией или простым вычислением и т.д.

Сортировка списка чисел в порядке возрастания
Natural_numbers = [1,4,23,3,2,1,0,9,7]
Natural_numbers.sort()
print(Natural_numbers)

# [0, 1, 1, 2, 3, 4, 7, 9, 23]
Сортировка списка чисел в порядке убывания
Natural_numbers = [1,23,4,25,22,3,4,5,9,7,5]
Natural_numbers.sort(reverse = True)
print(Natural_numbers)

# [25, 23, 22, 9, 7, 5, 5, 4, 4, 3, 1]
Сортировка списка строк в порядке возрастания
Fruits = ["Apple", "Banana", "Tomato", "Grapes"]
Fruits.sort()
print(Fruits)

# ['Apple', 'Banana', 'Grapes', 'Tomato']
Сортировка списка строк по убыванию
Fruits = ["Apple", "Banana", "Tomato", "Grapes"]
Fruits.sort(reverse = True)
print(Fruits)

# ['Tomato', 'Grapes', 'Banana', 'Apple']
Сортировка списка с помощью функции (по возрастанию)
# Сортируем на основе 2-го элемента
def keyFunc(item):
   return item[1]

# Неупорядоченный список
unordered = [('b', 'b'), ('c', 'd'), ('d', 'a'), ('a', 'c')]

# Сортировка списка с помощью ключа
unordered.sort(key=keyFunc)

# Вывести отсортированный список
print('Ordered list:', unordered)
Ordered list: [('d', 'a'), ('b', 'b'), ('a', 'c'), ('c', 'd')]
Сортировка списка с помощью функции (по убыванию)
def keyFunc(item):
   return item[1]

unordered = [('b', 'b'), ('c', 'd'), ('d', 'a'), ('a', 'c')]
unordered.sort(key=keyFunc, reverse = True)
print('Ordered list:', unordered)
Ordered list: [('c', 'd'), ('a', 'c'), ('b', 'b'), ('d', 'a')]

Топ-5 алгоритмов сортировки на Python

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

Разберем 5 самых распространенных алгоритмов и реализуем их в Python.

Bubble Sort (пузырьковая сортировка)

Этот вид сортировки изучают в начале знакомства с дисциплиной Computer Science, поскольку он максимально просто демонстрирует саму концепцию сортировки.

При этом подходе осуществляется перебор по списку и сравнение соседних элементов. Они меняются местами в том случае, если порядок неправильный. Так продолжается до тех пор, пока все элементы не расположатся в нужном порядке. Из-за большого количества повторений у пузырьковой сортировки его сложность в худшем случае — O(n^2).

def bubble_sort(arr):
    def swap(i, j):
        arr[i], arr[j] = arr[j], arr[i]

    n = len(arr)
    swapped = True
    
    x = -1
    while swapped:
        swapped = False
        x = x + 1
        for i in range(1, n-x):
            if arr[i - 1] > arr[i]:
                swap(i - 1, i)
                swapped = True

Selection Sort (сортировка выбором)

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

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

def selection_sort(arr):        
    for i in range(len(arr)):
        minimum = i
        
        for j in range(i + 1, len(arr)):
            
            if arr[j] < arr[minimum]:
                minimum = j

        
        arr[minimum], arr[i] = arr[i], arr[minimum]
            
    return arr

Insertion Sort (сортировка вставками)

Подписывайтесь на телеграм каналы

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

def insertion_sort(arr):
        
    for i in range(len(arr)):
        cursor = arr[i]
        pos = i
        
        while pos > 0 and arr[pos - 1] > cursor:
            
            arr[pos] = arr[pos - 1]
            pos = pos - 1
        
        arr[pos] = cursor

    return arr

Merge Sort (сортировка слиянием)

Сортировка слиянием — элегантный пример использования подхода «Разделяй и властвуй». Он состоит из двух этапов:

  1. Несортированный список последовательно делится на N списков, где каждый включает один «несортированный» элемент, а N — это число элементов в оригинальном массиве.
  2. Списки последовательно сливаются группами по два, создавая новые отсортированные списки до тех пор, пока не появится один финальный отсортированный список.
def merge_sort(arr):
    
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    
    left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])

    
    return merge(left, right, arr.copy())


def merge(left, right, merged):

    left_cursor, right_cursor = 0, 0
    while left_cursor < len(left) and right_cursor < len(right):
      
        
        if left[left_cursor] <= right[right_cursor]:
            merged[left_cursor+right_cursor]=left[left_cursor]
            left_cursor += 1
        else:
            merged[left_cursor + right_cursor] = right[right_cursor]
            right_cursor += 1
            
    for left_cursor in range(left_cursor, len(left)):
        merged[left_cursor + right_cursor] = left[left_cursor]
        
    for right_cursor in range(right_cursor, len(right)):
        merged[left_cursor + right_cursor] = right[right_cursor]

    return merged

Quick Sort (быстрая сортировка)

Как и сортировка слиянием, быстрая сортировка использует подход «Разделяй и властвуй». Алгоритм чуть сложнее, но в стандартных реализациях он работает быстрее сортировки слиянием, а его сложность в худшем случае редко достигает O(n^2). Он состоит из трех этапов:

  1. Выбирается один опорный элемент.
  2. Все элементы меньше опорного перемешаются слева от него, остальные — направо. Это называется операцией разбиения.
  3. Рекурсивно повторяются 2 предыдущих шага к каждому новому списку, где новые опорные элементы будут меньше и больше оригинального соответственно.
def partition(array, begin, end):
    pivot_idx = begin
    for i in xrange(begin+1, end+1):
        if array[i] <= array[begin]:
            pivot_idx += 1
            array[i], array[pivot_idx] = array[pivot_idx], array[i]
    array[pivot_idx], array[begin] = array[begin], array[pivot_idx]
    return pivot_idx

def quick_sort_recursion(array, begin, end):
    if begin >= end:
        return
    pivot_idx = partition(array, begin, end)
    quick_sort_recursion(array, begin, pivot_idx-1)
    quick_sort_recursion(array, pivot_idx+1, end)

def quick_sort(array, begin=0, end=None):
    if end is None:
        end = len(array) - 1
    
    return quick_sort_recursion(array, begin, end)

Функция sorted python 3 и метод sort(), примеры

sorted python 3 — один из двух возможных способов сортировки данных в списках. Отличается от метода sort() тем, что не изменяет оригинальные данные.

 

Для сортировки данных Python предлагает две опции. Объектом, в котором выполняется сортировка является список (list).

 

1.

Метод sort() — принимает значения, меняет порядок и сохраняет заменяя ту информацию, которая существовала изначально. Изначально заданные данные изменяются и оказываются навсегда утерянными.

Для демонстрации возьмем список из чисел

>>> numbers = [5, 32, 97, 4, 11, 90]

>>> numbers.sort()

>>> numbers

[4, 5, 11, 32, 90, 97]

 

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

 

2.

Функция sorted() — выполняет сортировку элементов списка и сохраняет новые значения в качестве копии. Исходный список или значение исходной переменной остается в том же виде, в котором было задано.

sorted() является BIF, т.е. built in function.

 

>>> numbers = [5, 32, 97, 4, 11, 90]

>>> numbers2 = sorted(numbers)

>>> print (numbers)

[5, 32, 97, 4, 11, 90]

>> print (numbers2)

[4, 5, 11, 32, 90, 97]

 

Оба рассмотренных варианта позволяют выбирать порядок сортировки. Чтобы порядок стал убывающим передается аргумент reverse=True. По умолчанию сортировка происходит в возрастающем порядке — от меньшего значения к большему.

 

Сортировка по убыванию sorted()

>>> numbers2 = sorted(numbers, reverse=True)

>>> print (numbers2)

[97, 90, 32, 11, 5, 4]

 

 

Сортировка по убыванию sort()

>>> numbers.sort(reverse=True)

>>> print(numbers)

[97, 90, 32, 11, 5, 4]

 

 

Python BIF

Посмотреть все BIF можно следующим образом:

>>>dir(__builtins__)

 

Вызвать справку по определенной встроенной функции

>>> help(sorted)

 

Читайте про создание модуля в Python.

sort | NumPy


numpy.sort(a, axis=-1, kind='quicksort', order=None)

Функция sort() возвращает отсортированную копию массива.

Параметры:
a — массив NumPy или подобный массиву объект.
Исходный массив.
axis — целое число (необязательный параметр).
Определяет ось вдоль которой выполняется сортировка элементов. Если равен None, то сортировка выполняется по сжатому до одной оси представлению исходного массива. По умолчанию axis = -1, что соответствует сортировке по последней оси массива.
kind — строка (необязательный параметр).
Одна строка из множества {'quicksort', 'mergesort', 'heapsort', 'stable'}, которая указывает на алгоритм сортировки. Значение 'stable' приводит к автоматическому выбору устойчивого, лучшего алгоритма для типа данных сортируемого массива. По умолчанию kind = 'quicksort'.
order — строка или список строк (необязательный параметр).
В случае, когда массив a является структурированным, и его полям присвоено имя, то данный параметр позволяет указать порядок в котором они должны учавствовать в сортировке Если указаны не все поля, то неуказанные будут использоваться в том порядке в котором они перечислены в dtype структурированного массива.
Возвращает:
ndarray — массив NumPy
отсортированную копию исходного массива a с той же формой и типом данных.

Замечание

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

>>> import numpy as np
>>> 
>>> 
>>> a = np.random.randint(0, 100, 10)
>>> a
array([64, 88,  2, 17, 89,  2, 77, 10, 70, 83])
>>> 
>>> np.sort(a)    #  возвращает копию
array([ 2,  2, 10, 17, 64, 70, 77, 83, 88, 89])
>>> 
>>> a.sort()      #  меняет исходный массив
>>> a
array([ 2,  2, 10, 17, 64, 70, 77, 83, 88, 89])

Параметр kind позволяет выбрать один из трех алгоритмов сортировки: ‘quicksort’, ‘mergesort’ или ‘heapsort’. Каждый из алгоритмов делает временную копию данных при выполнении сортировки по всем осям кроме последней, так что сортировка только по последней оси выполняется быстрее всего и занимает меньше всего места.

Сортировка в массивах содержащих действительные числа и nan всегда сначала выполняется над действительными числами, а уже затем над nan.

Сортировка комплексных чисел выполняется лексикографически: если действительная и мнимая часть не равна nan то сортировка выполняется по действительной части, но если действительные части равны, то порядок определяется их мнимыми частями. Расширенный порядок сортировки: [R + Rj, R + nan, nan + Rj, nan + nan], где R — действительное число.

В NumPy, начиная с версии 1.12.0. алгоритм quicksort был заменен на алгоритм introsort.

Примеры

Сортировка одномерных массивов приводит к вполне ожидаемому результату:

>>> import numpy as np
>>> 
>>> a = np.random.randint(0, 100, 10)
>>> a
array([79,  6, 96,  4,  8, 70,  2, 94, 90, 83])
>>> 
>>> np.sort(a)
array([ 2,  4,  6,  8, 70, 79, 83, 90, 94, 96])

А вот многомерные массивы могут быть отсортированы по разным осям (направлениям). Например, двумерные массивы могут быть отсортированы как по столбцам так и по строкам:

>>> b = np.random.randint(0, 100, size = (6, 6))
>>> b
array([[79, 41, 17,  6, 12, 72],
       [34,  0, 13, 14,  3, 37],
       [70, 81, 28,  6, 33, 48],
       [85, 57, 18,  3, 47, 69],
       [43, 46,  5, 85,  6, 97],
       [93, 30, 98,  3,  2, 87]])
>>> 
>>> 
>>> np.sort(b, axis = 0)    #  сортировка по столбцам
array([[34,  0,  5,  3,  2, 37],
       [43, 30, 13,  3,  3, 48],
       [70, 41, 17,  6,  6, 69],
       [79, 46, 18,  6, 12, 72],
       [85, 57, 28, 14, 33, 87],
       [93, 81, 98, 85, 47, 97]])
>>> 
>>> np.sort(b, axis = 1)    #  сортировка по строкам (по умолчанию)
array([[ 6, 12, 17, 41, 72, 79],
       [ 0,  3, 13, 14, 34, 37],
       [ 6, 28, 33, 48, 70, 81],
       [ 3, 18, 47, 57, 69, 85],
       [ 5,  6, 43, 46, 85, 97],
       [ 2,  3, 30, 87, 93, 98]])

Трехмерные массивы, грубо говоря, могут быть отсортированы по «длине», «ширине» и «высоте»:

>>> c = np.random.randint(0, 100, size = (2, 3, 4))
>>> c
array([[[66, 37, 91, 72],
        [68, 55, 76, 60],
        [98, 11, 99, 38]],

       [[22, 71,  0, 78],
        [21,  0, 60, 36],
        [46, 17, 88, 29]]])
>>> 
>>> np.sort(c, axis = 2)    #  сортировка по "ширине"
array([[[37, 66, 72, 91],
        [55, 60, 68, 76],
        [11, 38, 98, 99]],

       [[ 0, 22, 71, 78],
        [ 0, 21, 36, 60],
        [17, 29, 46, 88]]])
>>> 
>>> np.sort(c, axis = 1)    #  сортировка по "длине"
array([[[66, 11, 76, 38],
        [68, 37, 91, 60],
        [98, 55, 99, 72]],

       [[21,  0,  0, 29],
        [22, 17, 60, 36],
        [46, 71, 88, 78]]])
>>> 
>>> np.sort(c, axis = 0)    #  сортировка по "высоте"
array([[[22, 37,  0, 72],
        [21,  0, 60, 36],
        [46, 11, 88, 29]],

       [[66, 71, 91, 78],
        [68, 55, 76, 60],
        [98, 17, 99, 38]]])

Если выполняется сортировка структурированного массива, то параметр order позволяет указать по какому полю выполнять сортировку:

>>> data_type = [('recruit_name', 'U10'), ('age', int),
...              ('weight', float), ('height', float)]
>>> 
>>> recruit = [('Вася', 18, 57.1, 1.96),
...            ('Петька', 25, 94.9, 1.51),
...            ('Сёмка', 30, 72.5, 1.83),
...            ('Антоха', 30, 146.8, 1.76)]
>>> 
>>> vdv = np.array(recruit, dtype = data_type)
>>> vdv
array([('Вася', 18,  57.1, 1.96), ('Петька', 25,  94.9, 1.51),
       ('Сёмка', 30,  72.5, 1.83), ('Антоха', 30, 146.8, 1.76)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])
>>> 
>>> np.sort(vdv, order = 'weight')    #  сортировка по весу
array([('Вася', 18,  57.1, 1.96), ('Сёмка', 30,  72.5, 1.83),
       ('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])
>>> 
>>> np.sort(vdv, order = 'height')    #  сортировка по росту
array([('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76),
       ('Сёмка', 30,  72.5, 1.83), ('Вася', 18,  57.1, 1.96)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])

Можно указывать несколько полей, заключив их в список, но так как в нашем списке нет людей с одинаковым ростом, то результат будет такой же как и для np.sort(vdv, order = 'height'):

>>> np.sort(vdv, order = ['height', 'weight'])    #  сортировка по росту и весу
array([('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76),
       ('Сёмка', 30,  72.5, 1.83), ('Вася', 18,  57.1, 1.96)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])

Как отсортировать массив в Python

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

Использование sorted () для итерируемых объектов Python

Python использует несколько чрезвычайно эффективных алгоритмов сортировки. Например, метод sorted () использует алгоритм Timsort (который представляет собой комбинацию сортировки вставкой и сортировки слиянием) для выполнения высокооптимизированной сортировки.

С помощью этого метода можно отсортировать любой итерируемый объект Python, например список или массив.

импортный массив

# Объявить объект типа списка
list_object = [3, 4, 1, 5, 2]

# Объявить объект целочисленного массива
array_object = array.array ('i', [3, 4, 1, 5, 2])

print ('Сортированный список ->', sorted (list_object))
print ('Отсортированный массив ->', sorted (array_object))

Выход: 

Сортированный список -> [1, 2, 3, 4, 5]
Сортированный массив -> [1, 2, 3, 4, 5]

Реализация MergeSort и QuickSort

Здесь мы исследуем два других широко используемых метода сортировки, используемых на практике, а именно алгоритмы MergeSort и QuickSort .

1. Алгоритм MergeSort

Алгоритм использует восходящий подход «разделяй и властвуй», сначала разделяя исходный массив на подмассивы, а затем объединяя индивидуально отсортированные подмассивы, чтобы получить окончательный отсортированный массив.

В приведенном ниже фрагменте кода метод mergesort_helper () выполняет фактическое разбиение на подмассивы, а метод perform_merge () объединяет два ранее отсортированных массива в новый отсортированный массив.

импортный массив

def mergesort (a, arr_type):
    def perform_merge (a, arr_type, начало, середина, конец):
        # Объединяет два ранее отсортированных массива
        # a [начало: середина] и [середина: конец]
        tmp = массив.array (arr_type, [i вместо i в a])
        def compare (tmp, i, j):
            если tmp [i] <= tmp [j]:
                я + = 1
                return tmp [i-1]
            еще:
                j + = 1
                return tmp [j-1]
        я = начало
        j = середина + 1
        curr = начало
        пока я <= середина или j <= конец:
            если i <= mid и j <= end:
                если tmp [i] <= tmp [j]:
                    a [curr] = tmp [i]
                    я + = 1
                еще:
                    a [curr] = tmp [j]
                    j + = 1
            elif i == mid + 1 и j <= end:
                a [curr] = tmp [j]
                j + = 1
            elif j == end + 1 и i <= mid:
                a [curr] = tmp [i]
                я + = 1
            elif i> mid и j> end:
                сломать
            curr + = 1


    def mergesort_helper (a, arr_type, начало, конец):
        # Делит массив на две части
        # рекурсивно и объединяет подмассивы
        # снизу вверх, сортируя их
        # через Divide and Conquer
        если начало <конец:
            mergesort_helper (a, arr_type, start, (конец + начало) // 2)
            mergesort_helper (a, arr_type, (конец + начало) // 2 + 1, конец)
            Perform_merge (a, arr_type, start, (начало + конец) // 2, конец)


    # Сортирует массив с помощью mergesort_helper
    mergesort_helper (a, arr_type, 0, len (a) -1)

Контрольный пример :

а = массив.array ('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print ('Перед сортировкой слияния ->', a)
mergesort (a, 'я')
print ('После сортировки слияния ->', a)

Выход: 

Перед MergeSort -> array ('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
После MergeSort -> array ('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])

2. Алгоритм быстрой сортировки

Этот алгоритм также использует стратегию «Разделяй и властвуй», но вместо этого использует нисходящий подход, сначала разбивая массив вокруг элемента pivot (здесь мы всегда выбираем последний элемент массива в качестве стержня).

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

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

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

def quicksort (a, arr_type):
    def do_partition (a, arr_type, начало, конец):
        # Выполняет разбиение подмассива a [начало: конец]
        
        # Выбираем последний элемент как опорный
        pivot_idx = конец
        pivot = a [pivot_idx]

        # Сохраняем индекс для первого раздела
        # подмассив (элементы меньше, чем элемент сводной таблицы)
        idx = начало - 1

        def increment_and_swap (j):
            нелокальный idx
            idx + = 1
            a [idx], a [j] = a [j], a [idx]

        [increment_and_swap (j) для j в диапазоне (начало, конец), если [j] 
 Здесь метод  quicksort_helper  выполняет шаг подхода Divide and Conquer, в то время как метод  do_partition  разбивает массив вокруг оси и возвращает положение оси, вокруг которой мы продолжаем рекурсивно разбивать подмассив до и после поворот, пока не будет отсортирован весь массив.
  Контрольный пример :
b = array.array ('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print ('Перед быстрой сортировкой ->', b)
быстрая сортировка (b, 'i')
print ('После быстрой сортировки ->', b)
 
  Выход: 
Перед QuickSort -> array ('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
После QuickSort -> array ('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])
 
 Заключение 
 В этой статье мы рассмотрели алгоритмы MergeSort и QuickSort для выполнения сортировки массивов Python, чтобы понять, как мы можем использовать Divide and Conquer как сверху вниз, так и снизу вверх.Мы также вкратце рассмотрели собственный метод  sorted () , который язык предоставляет для сортировки итераций.
 Артикулы: 
.Сортировка
 - как отсортировать 2d-массив по строкам в Python? 
 Переполнение стека
  1.  Около
  2.  Продукты
  3.  Для команд
  1.  Переполнение стека
     Общественные вопросы и ответы
  2.  Переполнение стека для команд
     Где разработчики и технологи делятся частными знаниями с коллегами
  3.  Вакансии
     Программирование и связанные с ним технические возможности карьерного роста
  4.  Талант
     Нанимайте технических специалистов и создавайте свой бренд работодателя
  5.  Реклама
     Обратитесь к разработчикам и технологам со всего мира
  6.  О компании
 Загрузка…
  2.  Авторизоваться
     зарегистрироваться
  3.  текущее сообщество
     
.
 Страница не найдена · GitHub Pages 
 Страница не найдена · GitHub Pages
  Файл не найден 
 Сайт, настроенный по этому адресу, не
 содержать запрошенный файл.
 Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу. 
 Для корневых URL (например,  http://example.com/ ) вы должны предоставить
  index.html  файл.
 Прочтите полную документацию
 для получения дополнительной информации об использовании  GitHub Pages .
 .
 python - Как отсортировать список объектов на основе атрибута объектов? 
 Переполнение стека
  1.  Около
  2.  Продукты
  3.  Для команд
  1.  Переполнение стека
     Общественные вопросы и ответы
  2.  Переполнение стека для команд
     Где разработчики и технологи делятся частными знаниями с коллегами
  3.  Вакансии
     Программирование и связанные с ним технические возможности карьерного роста
  4.  Талант
     Нанимайте технических специалистов и создавайте свой бренд работодателя
  5.  Реклама
     Обратитесь к разработчикам и технологам со всего мира
  6.  О компании
 Загрузка…
.
No related posts.
Share :

Добавить комментарий

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