Эта статья возникла из личного публичного аккаунта:TechFlow, оригинальность это не просто, прошу внимания

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

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

Примечания

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

# Python中单行注释用#表示，#之后同行字符全部认为被注释。

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

""" 与之对应的是多行注释
    用三个双引号表示，这两段双引号当中的内容都会被视作是注释
"""

Основные типы переменных и операторы

Определения чисел в Python такие же, как и в других языках:

#获得一个整数
3
# 获得一个浮点数
10.0

Мы используем +, -, *, / для обозначения четырех операций сложения, вычитания, умножения и деления.

1 + 1   # => 2
8 - 1   # => 7
10 * 2  # => 20
35 / 5  # => 7.0

Здесь следует отметить, что в Python 2 операция 10/3 даст 3, а не 3,33333. Поскольку делитель и делимое являются целыми числами, Python автоматически выполняет целочисленные вычисления и округляет для нас полученное частное. Если это 10,0/3, вы получите 3,33333. В настоящее время Python2 больше не поддерживается, поэтому вам не нужно заботиться о деталях.

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

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

Если мы хотим получить целые числа, мы можем сделать это:

5 // 3       # => 1
-5 // 3      # => -2
5.0 // 3.0   # => 1.0 # works on floats too
-5.0 // 3.0  # => -2.0

Два знака деления указываютРазделять, Python сохранит для нас результат удаления остатка.

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

# Modulo operation
7 % 3  # => 1

Поддерживается в Питоневозведение в степень, мы можем использовать символ **, чтобы сделать это без вызова дополнительной функции:

# Exponentiation (x**y, x to the yth power)
2**3  # => 8

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

# Enforce precedence with parentheses
1 + 3 * 2  # => 7
(1 + 3) * 2  # => 8

логическая операция

Истина и ложь представлены в Python с заглавной буквы True и False.

True  # => True
False  # => False

Используйте и для представления и действия, или для представления или действия, а не для обозначения недействия. Вместо &&, || и !в C++ или Java .

# negate with not
not True   # => False
not False  # => True

# Boolean Operators
# Note "and" and "or" are case-sensitive
True and False  # => False
False or True   # => True

Под капотом Python,True и False на самом деле 1 и 0, так что если мы сделаем следующее, то ошибки не будет, но это логически бессмысленно.

# True and False are actually 1 and 0 but with different keywords
True + True # => 2
True * 8    # => 8
False - 5   # => -5

Мы используем == для оценки операции равенства, мы видим, что True==1, False == 0.

# Comparison operators look at the numerical value of True and False
0 == False  # => True
1 == True   # => True
2 == True   # => False
-5 != False # => True

Мы должны быть осторожны с функцией bool() в Python, она не означает преобразование в тип bool. Если мы выполним эту функцию, тоТолько 0 считается False, все остальные значения True:

bool(0)     # => False
bool(4)     # => True
bool(-6)    # => True
0 and 2     # => 0
-5 or 0     # => -5

В Python == используется для определения равенства, > означает больше, >= означает больше или равно,

# Equality is ==
1 == 1  # => True
2 == 1  # => False

# Inequality is !=
1 != 1  # => False
2 != 1  # => True

# More comparisons
1 < 10  # => True
1 > 10  # => False
2 <= 2  # => True
2 >= 2  # => True

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

# Seeing whether a value is in a range
1 < 2 and 2 < 3  # => True
2 < 3 and 3 < 2  # => False
# Chaining makes this look nicer
1 < 2 < 3  # => True
2 < 3 < 2  # => False

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

списки и строки

Что касается суждения о списке, мы обычно используем два суждения: одно — только что введенное ==, а другое — is. Мы иногда используем is, чтобы судить просто и практично, так в чем же разница между ними? Давайте посмотрим на следующий пример:

a = [1, 2, 3, 4]  # Point a at a new list, [1, 2, 3, 4]
b = a             # Point b at what a is pointing to
b is a            # => True, a and b refer to the same object
b == a            # => True, a's and b's objects are equal
b = [1, 2, 3, 4]  # Point b at a new list, [1, 2, 3, 4]
b is a            # => False, a and b do not refer to the same object
b == a            # => True, a's and b's objects are equal

Python — это полностью ссылочный язык, в котором объекты представлены с помощью ссылок. судятуказывают ли две ссылки на один и тот же объект, и == должны определить, равно ли конкретное содержимое, на которое указывают две ссылки. Например, если мы сравниваем ссылки с адресами, мы должны определить, указывают ли две переменные на один и тот же адрес, например, № XX вдоль Hedong Road. И == должен определить, являются ли оба получателя этих двух адресов именем Чжан Сан.

Очевидно, что всех людей, живущих по одному и тому же адресу, нужно звать Чжан Сан, но двух людей, живущих по разным адресам, можно обоих звать Чжан Сан, или они могут называться разными именами. Итак, если a равно b, то должно выполняться a == b, и наоборот.

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

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

# Strings are created with " or '
"This is a string."
'This is also a string.'

# Strings can be added too! But try not to do this.
"Hello " + "world!"  # => "Hello world!"
# String literals (but not variables) can be concatenated without using '+'
"Hello " "world!"    # => "Hello world!"

Мы можем использовать [] для поиска символа в определенной позиции в строке, используяlenдля вычисления длины строки.

# A string can be treated like a list of characters
"This is a string"[0]  # => 'T'

# You can find the length of a string
len("This is a string")  # => 16

мы можем добавить строкуПлюс f для операции формата, а также поддерживает операции в операциях форматирования, например, функция len может быть вложенной. Однако следует отметить, что только версии Python выше 3.6 поддерживают операцию f.

# You can also format using f-strings or formatted string literals (in Python 3.6+)
name = "Reiko"
f"She said her name is {name}." # => "She said her name is Reiko"
# You can basically put any Python statement inside the braces and it will be output in the string.
f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."

Последним является суждение None В Python None также является объектом.Все переменные со значением None будут указывать на этот объект.. Согласно тому, что мы сказали ранее, поскольку все None указывают на один и тот же адрес, когда нам нужно определить, является ли переменная None, мы можем использовать is для оценки.Конечно, также можно использовать ==, но мы обычно используем является.

# None is an object
None  # => None

# Don't use the equality "==" symbol to compare objects to None
# Use "is" instead. This checks for equality of object identity.
"etc" is None  # => False
None is None   # => True

Разобравшись с None, давайте вернемся к функции bool(), представленной ранее, ее цель — определить, является ли значение пустым. все типыБудет возвращено нулевое значение по умолчанию False, в противном случае оба значения True. Например, 0, "", [], {}, () и т. д.

# None, 0, and empty strings/lists/dicts/tuples all evaluate to False.
# All other values are True
bool(None)# => False
bool(0)   # => False
bool("")  # => False
bool([])  # => False
bool({})  # => False
bool(())  # => False

Все переданные значения, кроме указанных выше, получат значение True.

Переменные и коллекции

ввод, вывод

Стандартный ввод и вывод в Python:ввод и печать.

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

# Python has a print function
print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!

# By default the print function also prints out a newline at the end.
# Use the optional argument end to change the end string.
print("Hello, World", end="!")  # => Hello, World!

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

# Simple way to get input data from console
input_string_var = input("Enter some data: ") # Returns the data as a string
# Note: In earlier versions of Python, input() method was named as raw_input()

Переменная

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

# There are no declarations, only assignments.
# Convention is to use lower_case_with_underscores
some_var = 5
some_var  # => 5

# Accessing a previously unassigned variable is an exception.
# See Control Flow to learn more about exception handling.
some_unknown_var  # Raises a NameError

Поддержка PythonТернарное выражение, но синтаксис отличается от C++, используя структуру if else, записанную как:

# if can be used as an expression
# Equivalent of C's '?:' ternary operator
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

Приведенный выше код эквивалентен:

if 3 > 2:
    return 'yahoo'
else:
    return 2

list

В Python [] используется для представления пустого списка, и мы также можем напрямую заполнять элементы для инициализации:

# Lists store sequences
li = []
# You can start with a prefilled list
other_li = [4, 5, 6]

Используйте append и pop для вставки или удаления элементов из конца списка:

# Add stuff to the end of a list with append
li.append(1)    # li is now [1]
li.append(2)    # li is now [1, 2]
li.append(4)    # li is now [1, 2, 4]
li.append(3)    # li is now [1, 2, 4, 3]
# Remove from the end with pop
li.pop()        # => 3 and li is now [1, 2, 4]
# Let's put it back
li.append(3)    # li is now [1, 2, 4, 3] again.

Список может получить доступ к элементу в указанной позиции, добавив индекс [], если это отрицательное число, это означаетДоступ в обратном порядке. -1 означает последний элемент, -2 означает предпоследний и так далее. Если доступный элемент превышает длину массива, он сработаетIndexErrorошибка.

# Access a list like you would any array
li[0]   # => 1
# Look at the last element
li[-1]  # => 3

# Looking out of bounds is an IndexError
li[4]  # Raises an IndexError

Список поддерживает операцию среза, так называемый срез из исходного списка.копироватьвне указанного раздела. Мы используем формат начало: конец, чтобы получить срез, обратите внимание, что этоЛевый закрытый правый открытый интервал. Если оставить его пустым для указания всех сборов, мы также можем добавить дополнительный параметр для указания размера шага, например, [1:5:2] означает, что нужно начинать с позиции 1, а размер шага равен 2 для получения элементов. Получен результат [1, 3]. Если размер шага установлен равным -1, это означает обратный обход.

# You can look at ranges with slice syntax.
# The start index is included, the end index is not
# (It's a closed/open range for you mathy types.)
li[1:3]   # Return list from index 1 to 3 => [2, 4]
li[2:]    # Return list starting from index 2 => [4, 3]
li[:3]    # Return list from beginning until index 3  => [1, 2, 4]
li[::2]   # Return list selecting every second entry => [1, 4]
li[::-1]  # Return list in reverse order => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# li[start:end:step]

Если мы хотим указать обратный порядок интервала, предыдущее начало и конец также необходимо поменять местами.Например, если я хочу получить обратный порядок интервала [3: 6], это должно быть записано как [6 :3:-1].

Напишите только одно:, что означает все копии.Если вы используете is для оценки списка до и после копии, вы получите False. Вы можете использовать del, чтобы удалить элемент в указанной позиции, или вы можете использовать метод удаления.

# Make a one layer deep copy using slices
li2 = li[:]  # => li2 = [1, 2, 4, 3] but (li2 is li) will result in false.

# Remove arbitrary elements from a list with "del"
del li[2]  # li is now [1, 2, 3]

# Remove first occurrence of a value
li.remove(2)  # li is now [1, 3]
li.remove(2)  # Raises a ValueError as 2 is not in the list

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

# Insert an element at a specific index
li.insert(1, 2)  # li is now [1, 2, 3] again

# Get the index of the first item found matching the argument
li.index(2)  # => 1
li.index(4)  # Raises a ValueError as 4 is not in the list

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

# You can add lists
# Note: values for li and for other_li are not modified.
li + other_li  # => [1, 2, 3, 4, 5, 6]

# Concatenate lists with "extend()"
li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]

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

# Check for existence in a list with "in"
1 in li  # => True

# Examine the length with "len()"
len(li)  # => 6

tuple

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

# Tuples are like lists but are immutable.
tup = (1, 2, 3)
tup[0]      # => 1
tup[0] = 3  # Raises a TypeError

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

# Note that a tuple of length one has to have a comma after the last element but
# tuples of other lengths, even zero, do not.
type((1))   # => <class 'int'>
type((1,))  # => <class 'tuple'>
type(())    # => <class 'tuple'>

Tuple поддерживает большинство операций из списка:

# You can do most of the list operations on tuples too
len(tup)         # => 3
tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
tup[:2]          # => (1, 2)
2 in tup         # => True

Мы можем распаковать кортеж с несколькими переменными:

# You can unpack tuples (or lists) into variables
a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
# You can also do extended unpacking
a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4
# Tuples are created by default if you leave out the parentheses
d, e, f = 4, 5, 6  # tuple 4, 5, 6 is unpacked into variables d, e and f
# respectively such that d = 4, e = 5 and f = 6
# Now look how easy it is to swap two values
e, d = d, e  # d is now 5 and e is now 4

Объясните эту строку кода:

a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4

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

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

a = (3, [4])

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

a[1].append(0) # 这是合法的

dict

Dict также является контейнером, часто используемым в Python, что эквивалентно карте в C++, т.е.Пара ключ-значение, в которой хранятся ключ и значение. Мы обозначаем dict с помощью {} и разделяем ключ и значение с помощью : .

# Dictionaries store mappings from keys to values
empty_dict = {}
# Here is a prefilled dictionary
filled_dict = {"one": 1, "two": 2, "three": 3}

Ключ dict должен быть неизменяемым объектом, поэтомуlist, set и dict нельзя использовать в качестве ключа другого dict, иначе будет выброшено исключение:

# Note keys for dictionaries have to be immutable types. This is to ensure that
# the key can be converted to a constant hash value for quick look-ups.
# Immutable types include ints, floats, strings, tuples.
invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.

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

# Look up values with []
filled_dict["one"]  # => 1
filled_dict.get('one') #=> 1

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

# Get all keys as an iterable with "keys()". We need to wrap the call in list()
# to turn it into a list. We'll talk about those later.  Note - for Python
# versions <3.7, dictionary key ordering is not guaranteed. Your results might
# not match the example below exactly. However, as of Python 3.7, dictionary
# items maintain the order at which they are inserted into the dictionary.
list(filled_dict.keys())  # => ["three", "two", "one"] in Python <3.7
list(filled_dict.keys())  # => ["one", "two", "three"] in Python 3.7+

# Get all values as an iterable with "values()". Once again we need to wrap it
# in list() to get it out of the iterable. Note - Same as above regarding key
# ordering.
list(filled_dict.values())  # => [3, 2, 1]  in Python <3.7
list(filled_dict.values())  # => [1, 2, 3] in Python 3.7+

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

# Check for existence of keys in a dictionary with "in"
"one" in filled_dict  # => True
1 in filled_dict      # => False

Если вы используете [] для поиска несуществующего ключа, будет возбуждено исключение KeyError. При использованииМетод get не вызовет исключения, он получит только None:

# Looking up a non-existing key is a KeyError
filled_dict["four"]  # KeyError

# Use "get()" method to avoid the KeyError
filled_dict.get("one")      # => 1
filled_dict.get("four")     # => None
# The get method supports a default argument when the value is missing
filled_dict.get("one", 4)   # => 1
filled_dict.get("four", 4)  # => 4

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

# "setdefault()" inserts into a dictionary only if the given key isn't present
filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

Мы можем использовать метод обновления, чтобы обновить текущий словарь другим словарем, например, a.update(b). Ключ пересечения a и b будет перезаписан на b, а ключ, не существующий в a, будет вставлен:

# Adding to a dictionary
filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] = 4         # another way to add to dict

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

Python 3.5 и выше поддерживает использование ** для распаковки dict:

{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

set

комплект используется для храненияНе повторяйте элементыКонтейнер, в котором все элементы разные, одинаковые элементы будут удалены. Мы можем инициализировать его через set() или через {}. Обратите внимание, что когда мы используем {}, мы должны передавать данные, иначе Python спутает их с dict.

# Sets store ... well sets
empty_set = set()
# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}

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

# Similar to keys of a dictionary, elements of a set have to be immutable.
invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

Вы можете вызвать метод add для вставки элементов в набор:

# Add one more item to the set
filled_set = some_set
filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
# Sets do not have duplicate elements
filled_set.add(5)  # it remains as before {1, 2, 3, 4, 5}

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

# Do set intersection with &
# 计算交集
other_set = {3, 4, 5, 6}
filled_set & other_set  # => {3, 4, 5}

# Do set union with |
# 计算并集
filled_set | other_set  # => {1, 2, 3, 4, 5, 6}

# Do set difference with -
# 计算差集
{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}

# Do set symmetric difference with ^
# 这个有点特殊，计算对称集，也就是去掉重复元素剩下的内容
{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}

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

# Check if set on the left is a superset of set on the right
{1, 2} >= {1, 2, 3} # => False

# Check if set on the left is a subset of set on the right
{1, 2} <= {1, 2, 3} # => True

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

# Check for existence in a set with in
2 in filled_set   # => True
10 in filled_set  # => False

# Make a one layer deep copy
filled_set = some_set.copy()  # filled_set is {1, 2, 3, 4, 5}
filled_set is some_set        # => False

Поток управления и итерация

Судить приговоры

Оператор суждения в Python очень прост, и Python не поддерживает переключатель, поэтому даже при наличии нескольких условий мы можем толькоСписок если-иначе.

# Let's just make a variable
some_var = 5

# Here is an if statement. Indentation is significant in Python!
# Convention is to use four spaces, not tabs.
# This prints "some_var is smaller than 10"
if some_var > 10:
    print("some_var is totally bigger than 10.")
elif some_var < 10:    # This elif clause is optional.
    print("some_var is smaller than 10.")
else:                  # This is optional too.
    print("some_var is indeed 10.")

цикл

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

"""
For loops iterate over lists
prints:
    dog is a mammal
    cat is a mammal
    mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
    # You can use format() to interpolate formatted strings
    print("{} is a mammal".format(animal))

Если мы хотим зациклиться на диапазоне, мы можем использовать диапазон. Диапазон плюс параметр представляет собой последовательность, начинающуюся с 0, например диапазон (10), который представляет все целые числа в интервале [0, 10):

"""
"range(number)" returns an iterable of numbers
from zero to the given number
prints:
    0
    1
    2
    3
"""
for i in range(4):
    print(i)

Если мы передадим два параметра, тоПредставляет начало и конец интервала итерации.

"""
"range(lower, upper)" returns an iterable of numbers
from the lower number to the upper number
prints:
    4
    5
    6
    7
"""
for i in range(4, 8):
    print(i)

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

"""
"range(lower, upper, step)" returns an iterable of numbers
from the lower number to the upper number, while incrementing
by step. If step is not indicated, the default value is 1.
prints:
    4
    6
"""
for i in range(4, 8, 2):
    print(i)

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

"""
To loop over a list, and retrieve both the index and the value of each item in the list
prints:
    0 dog
    1 cat
    2 mouse
"""
animals = ["dog", "cat", "mouse"]
for i, value in enumerate(animals):
    print(i, value)

Цикл while похож на C++, он выполняется, когда условие истинно, и завершается, когда оно ложно. И условие суждения не нуждается в скобках:

"""
While loops go until a condition is no longer met.
prints:
    0
    1
    2
    3
"""
x = 0
while x < 4:
    print(x)
    x += 1  # Shorthand for x = x + 1

поймать исключение

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

# Handle exceptions with a try/except block
try:
    # Use "raise" to raise an error
    raise IndexError("This is an index error")
except IndexError as e:
    pass                 # Pass is just a no-op. Usually you would do recovery here.
except (TypeError, NameError):
    pass                 # Multiple exceptions can be handled together, if required.
else:                    # Optional clause to the try/except block. Must follow all except blocks
    print("All good!")   # Runs only if the code in try raises no exceptions
finally:                 #  Execute under all circumstances
    print("We can clean up resources here")

с операцией

В Python мы часто используем ресурсы, наиболее распространенными из которых являются open для открытия файла. мыДескрипторы открытых файлов должны быть закрыты, но если мы пишем вручную, то часто забываем выполнить операцию закрытия. И если файл ненормальный, он также вызовет исключение. В настоящее время мы можем использовать оператор with, чтобы заменить эту часть обработки, используя with willАвтоматически закрывать открытые ресурсы в конце выполнения блока with или при возникновении исключения.

Ниже приведены несколько вариантов использования и функций with:

# Instead of try/finally to cleanup resources you can use a with statement
# 代替使用try/finally语句来关闭资源
with open("myfile.txt") as f:
    for line in f:
        print(line)

# Writing to a file
# 使用with写入文件
contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w+") as file:
    file.write(str(contents))        # writes a string to a file

with open("myfile2.txt", "w+") as file:
    file.write(json.dumps(contents)) # writes an object to a file

# Reading from a file
# 使用with读取文件
with open('myfile1.txt', "r+") as file:
    contents = file.read()           # reads a string from a file
print(contents)
# print: {"aa": 12, "bb": 21}

with open('myfile2.txt', "r+") as file:
    contents = json.load(file)       # reads a json object from a file
print(contents)     
# print: {"aa": 12, "bb": 21}

повторяемый объект

Любой объект, который можно повторить с помощью оператора in, называетсяповторяемый объект, что не то же самое, что итератор. Есть только введение в итерируемые объекты.Чтобы понять конкретное содержание итераторов, перейдите на портал:

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

Когда мы вызываем метод keys в dict, возвращаемый результат представляет собой итерируемый объект.

# Python offers a fundamental abstraction called the Iterable.
# An iterable is an object that can be treated as a sequence.
# The object returned by the range function, is an iterable.

filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable)  # => dict_keys(['one', 'two', 'three']). This is an object that implements our Iterable interface.

# We can loop over it.
for i in our_iterable:
    print(i)  # Prints one, two, three

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

# However we cannot address elements by index.
our_iterable[1]  # Raises a TypeError

# An iterable is an object that knows how to create an iterator.
our_iterator = iter(our_iterable)

# Our iterator is an object that can remember the state as we traverse through it.
# We get the next object with "next()".
next(our_iterator)  # => "one"

# It maintains state as we iterate.
next(our_iterator)  # => "two"
next(our_iterator)  # => "three"

# After the iterator has returned all of its data, it raises a StopIteration exception
next(our_iterator)  # Raises StopIteration

# We can also loop over it, in fact, "for" does this implicitly!
our_iterator = iter(our_iterable)
for i in our_iterator:
    print(i)  # Prints one, two, three

# You can grab all the elements of an iterable or iterator by calling list() on it.
list(our_iterable)  # => Returns ["one", "two", "three"]
list(our_iterator)  # => Returns [] because state is saved

функция

Используйте ключевое слово def для определения функции.Когда мы передаем параметры, если мы указываем имя параметра в функции,может не следовать порядку определения функцийПараметры передачи:

# Use "def" to create new functions
def add(x, y):
    print("x is {} and y is {}".format(x, y))
    return x + y  # Return values with a return statement

# Calling functions with parameters
add(5, 6)  # => prints out "x is 5 and y is 6" and returns 11

# Another way to call functions is with keyword arguments
add(y=6, x=5)  # Keyword arguments can arrive in any order.

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

# You can define functions that take a variable number of
# positional arguments
def varargs(*args):
    return args

varargs(1, 2, 3)  # => (1, 2, 3)

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

# You can define functions that take a variable number of
# keyword arguments, as well
def keyword_args(**kwargs):
    return kwargs

# Let's call it to see what happens
keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}

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

# You can do both at once, if you like
def all_the_args(*args, **kwargs):
    print(args)
    print(kwargs)
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

При передаче параметров мы также можем использовать * и ** для распаковки list или dict:

# When calling functions, you can do the opposite of args/kwargs!
# Use * to expand tuples and use ** to expand kwargs.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)            # equivalent to all_the_args(1, 2, 3, 4)
all_the_args(**kwargs)         # equivalent to all_the_args(a=3, b=4)
all_the_args(*args, **kwargs)  # equivalent to all_the_args(1, 2, 3, 4, a=3, b=4)

Параметры в Pythonможет возвращать несколько значений:

# Returning multiple values (with tuple assignments)
def swap(x, y):
    return y, x  # Return multiple values as a tuple without the parenthesis.
                 # (Note: parenthesis have been excluded but can be included)

x = 1
y = 2
x, y = swap(x, y)     # => x = 2, y = 1
# (x, y) = swap(x,y)  # Again parenthesis have been excluded but can be included.

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

# Function Scope
x = 5

def set_x(num):
    # Local var x not the same as global variable x
    x = num    # => 43
    print(x)   # => 43

def set_global_x(num):
    global x
    print(x)   # => 5
    x = num    # global var x is now set to 6
    print(x)   # => 6

set_x(43)
set_global_x(6)

Поддержка Pythonфункциональное программирование, мы можем вернуть функцию внутри функции:

# Python has first class functions
def create_adder(x):
    def adder(y):
        return x + y
    return adder

add_10 = create_adder(10)
add_10(3)   # => 13

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

# There are also anonymous functions
(lambda x: x > 2)(3)                  # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5

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

Пять минут, чтобы понять карту, уменьшить и отфильтровать

# There are built-in higher order functions
list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]

list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]

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

# We can use list comprehensions for nice maps and filters
# List comprehension stores the output as a list which can itself be a nested list
[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]

# You can construct set and dict comprehensions as well.
{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

модуль

использоватьОператор import вводит модуль Python, мы можем использовать . для доступа к функциям или классам в модулях.

# You can import modules
import math
print(math.sqrt(16))  # => 4.0

Мы также можем использовать оператор импорта from, чтобы отдельно вводить функции или классы в модуль, не записывая полный путь. Используйте from import * для импорта всего в модуль (не рекомендуется)

# You can get specific functions from a module
from math import ceil, floor
print(ceil(3.7))   # => 4.0
print(floor(3.7))  # => 3.0

# You can import all functions from a module.
# Warning: this is not recommended
from math import *

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

# You can shorten module names
import math as m
math.sqrt(16) == m.sqrt(16)  # => True

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

# You can find out which functions and attributes
# are defined in a module.
import math
dir(math)

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

своего рода

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

# We use the "class" statement to create a class
class Human:

    # A class attribute. It is shared by all instances of this class
    # 类属性，可以直接通过Human.species调用，而不需要通过实例
    species = "H. sapiens"

    # Basic initializer, this is called when this class is instantiated.
    # Note that the double leading and trailing underscores denote objects
    # or attributes that are used by Python but that live in user-controlled
    # namespaces. Methods(or objects or attributes) like: __init__, __str__,
    # __repr__ etc. are called special methods (or sometimes called dunder methods)
    # You should not invent such names on your own.
    # 最基础的构造函数
    # 加了下划线的函数和变量表示不应该被用户使用，其中双下划线的函数或者是变量将不会被子类覆盖
    # 前后都有双下划线的函数和属性是类当中的特殊属性
    def __init__(self, name):
        # Assign the argument to the instance's name attribute
        self.name = name

        # Initialize property
        self._age = 0

    # An instance method. All methods take "self" as the first argument
    # 类中的函数，所有实例可以调用，第一个参数必须是self
    # self表示实例的引用
    def say(self, msg):
        print("{name}: {message}".format(name=self.name, message=msg))

    # Another instance method
    def sing(self):
        return 'yo... yo... microphone check... one two... one two...'

    # A class method is shared among all instances
    # They are called with the calling class as the first argument
    @classmethod
    # 加上了注解，表示是类函数
    # 通过Human.get_species来调用，所有实例共享
    def get_species(cls):
        return cls.species

    # A static method is called without a class or instance reference
    @staticmethod
    # 静态函数，通过类名或者是实例都可以调用
    def grunt():
        return "*grunt*"

    # A property is just like a getter.
    # It turns the method age() into an read-only attribute of the same name.
    # There's no need to write trivial getters and setters in Python, though.
    @property
    # property注解，类似于get，set方法
    # 效率很低，除非必要，不要使用
    def age(self):
        return self._age

    # This allows the property to be set
    @age.setter
    def age(self, age):
        self._age = age

    # This allows the property to be deleted
    @age.deleter
    def age(self):
        del self._age

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

Питон——slots, соглашения об именах свойств и объектов

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

# When a Python interpreter reads a source file it executes all its code.
# This __name__ check makes sure this code block is only executed when this
# module is the main program.
# 这个是main函数也是整个程序入口的惯用写法
if __name__ == '__main__':
    # Instantiate a class
    # 实例化一个类，获取类的对象
    i = Human(name="Ian")
    # 执行say方法
    i.say("hi")                     # "Ian: hi"
    j = Human("Joel")
    j.say("hello")                  # "Joel: hello"
    # i和j都是Human的实例，都称作是Human类的对象
    # i and j are instances of type Human, or in other words: they are Human objects

    # Call our class method
    # 类属性被所有实例共享，一旦修改全部生效
    i.say(i.get_species())          # "Ian: H. sapiens"
    # Change the shared attribute
    Human.species = "H. neanderthalensis"
    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
    j.say(j.get_species())          # => "Joel: H. neanderthalensis"

    # 通过类名调用静态方法
    # Call the static method
    print(Human.grunt())            # => "*grunt*"

    # Cannot call static method with instance of object 
    # because i.grunt() will automatically put "self" (the object i) as an argument
    # 不能通过对象调用静态方法，因为对象会传入self实例，会导致不匹配
    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given

    # Update the property for this instance
    # 实例级别的属性是独立的，各个对象各自拥有，修改不会影响其他对象内的值
    i.age = 42
    # Get the property
    i.say(i.age)                    # => "Ian: 42"
    j.say(j.age)                    # => "Joel: 0"
    # Delete the property
    del i.age
    # i.age                         # => this would raise an AttributeError

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

наследовать

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

from human import Human

# Specify the parent class(es) as parameters to the class definition
class Superhero(Human):

    # If the child class should inherit all of the parent's definitions without
    # any modifications, you can just use the "pass" keyword (and nothing else)
    # but in this case it is commented out to allow for a unique child class:
    # pass
    # 如果要完全继承父类的所有的实现，我们可以使用关键字pass，表示跳过。这样不会修改父类当中的实现

    # Child classes can override their parents' attributes
    species = 'Superhuman'

    # Children automatically inherit their parent class's constructor including
    # its arguments, but can also define additional arguments or definitions
    # and override its methods such as the class constructor.
    # This constructor inherits the "name" argument from the "Human" class and
    # adds the "superpower" and "movie" arguments:
    # 子类会完全继承父类的构造方法，我们也可以进行改造，比如额外增加一些参数
    def __init__(self, name, movie=False,
                 superpowers=["super strength", "bulletproofing"]):

        # add additional class attributes:
        # 额外新增的参数
        self.fictional = True
        self.movie = movie
        # be aware of mutable default values, since defaults are shared
        self.superpowers = superpowers

        # The "super" function lets you access the parent class's methods
        # that are overridden by the child, in this case, the __init__ method.
        # This calls the parent class constructor:
        # 子类可以通过super关键字调用父类的方法
        super().__init__(name)

    # override the sing method
    # 重写父类的sing方法
    def sing(self):
        return 'Dun, dun, DUN!'

    # add an additional instance method
    # 新增方法，只属于子类
    def boast(self):
        for power in self.superpowers:
            print("I wield the power of {pow}!".format(pow=power))

if __name__ == '__main__':
    sup = Superhero(name="Tick")

    # Instance type checks
    # 检查继承关系
    if isinstance(sup, Human):
        print('I am human')
    # 检查类型
    if type(sup) is Superhero:
        print('I am a superhero')

    # Get the Method Resolution search Order used by both getattr() and super()
    # This attribute is dynamic and can be updated
    # 查看方法查询的顺序
    # 先是自身，然后沿着继承顺序往上，最后到object
    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
                                # => <class 'human.Human'>, <class 'object'>)

    # 相同的属性子类覆盖了父类
    # Calls parent method but uses its own class attribute
    print(sup.get_species())    # => Superhuman

    # Calls overridden method
    # 相同的方法也覆盖了父类
    print(sup.sing())           # => Dun, dun, DUN!

    # Calls method from Human
    # 继承了父类的方法
    sup.say('Spoon')            # => Tick: Spoon

    # Call method that exists only in Superhero
    # 子类特有的方法
    sup.boast()                 # => I wield the power of super strength!
                                # => I wield the power of bulletproofing!

    # Inherited class attribute
    sup.age = 31
    print(sup.age)              # => 31

    # Attribute that only exists within Superhero
    print('Am I Oscar eligible? ' + str(sup.movie))

множественное наследование

Создаем класс летучей мыши:

# Another class definition
# bat.py
class Bat:

    species = 'Baty'

    def __init__(self, can_fly=True):
        self.fly = can_fly

    # This class also has a say method
    def say(self, msg):
        msg = '... ... ...'
        return msg

    # And its own method as well
    # 蝙蝠独有的声呐方法
    def sonar(self):
        return '))) ... ((('

if __name__ == '__main__':
    b = Bat()
    print(b.say('hello'))
    print(b.fly)

Давайте создадим еще один класс Бэтмена, который наследует как Superhero, так и Bat:

# And yet another class definition that inherits from Superhero and Bat
# superhero.py
from superhero import Superhero
from bat import Bat

# Define Batman as a child that inherits from both Superhero and Bat
class Batman(Superhero, Bat):

    def __init__(self, *args, **kwargs):
        # Typically to inherit attributes you have to call super:
        # super(Batman, self).__init__(*args, **kwargs)      
        # However we are dealing with multiple inheritance here, and super()
        # only works with the next base class in the MRO list.
        # So instead we explicitly call __init__ for all ancestors.
        # The use of *args and **kwargs allows for a clean way to pass arguments,
        # with each parent "peeling a layer of the onion".
        # 通过类名调用两个父类各自的构造方法
        Superhero.__init__(self, 'anonymous', movie=True, 
                           superpowers=['Wealthy'], *args, **kwargs)
        Bat.__init__(self, *args, can_fly=False, **kwargs)
        # override the value for the name attribute
        self.name = 'Sad Affleck'

    # 重写父类的sing方法
    def sing(self):
        return 'nan nan nan nan nan batman!'

Выполните этот класс:

if __name__ == '__main__':
    sup = Batman()

    # Get the Method Resolution search Order used by both getattr() and super().
    # This attribute is dynamic and can be updated
    # 可以看到方法查询的顺序是先沿着superhero这条线到human，然后才是bat
    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
                                # => <class 'superhero.Superhero'>, 
                                # => <class 'human.Human'>, 
                                # => <class 'bat.Bat'>, <class 'object'>)

    # Calls parent method but uses its own class attribute
    # 只有superhero有get_species方法
    print(sup.get_species())    # => Superhuman

    # Calls overridden method
    print(sup.sing())           # => nan nan nan nan nan batman!

    # Calls method from Human, because inheritance order matters
    sup.say('I agree')          # => Sad Affleck: I agree

    # Call method that exists only in 2nd ancestor
    # 调用蝙蝠类的声呐方法
    print(sup.sonar())          # => ))) ... (((

    # Inherited class attribute
    sup.age = 100
    print(sup.age)              # => 100

    # Inherited attribute from 2nd ancestor whose default value was overridden.
    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False

Передовой

Строитель

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

# Generators help you make lazy code.
def double_numbers(iterable):
    for i in iterable:
        yield i + i

# Generators are memory-efficient because they only load the data needed to
# process the next value in the iterable. This allows them to perform
# operations on otherwise prohibitively large value ranges.
# NOTE: `range` replaces `xrange` in Python 3.
for i in double_numbers(range(1, 900000000)):  # `range` is a generator.
    print(i)
    if i >= 30:
        break

В дополнение к yield мы также можем использовать круглые скобки () для создания генератора:

# Just as you can create a list comprehension, you can create generator
# comprehensions as well.
values = (-x for x in [1,2,3,4,5])
for x in values:
    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal

# You can also cast a generator comprehension directly to a list.
values = (-x for x in [1,2,3,4,5])
gen_to_list = list(values)
print(gen_to_list)  # => [-1, -2, -3, -4, -5]

Дополнительные сведения о генераторах и итераторах см. в следующей статье:

За пять минут вы разберетесь с итераторами и генераторами и закрепите свои навыки программирования.

декоратор

После того, как мы введем обертки в functools, мы можем создать декоратор. Декораторы могут обернуть слой другой логики снаружи, не изменяя код внутри функции:

# Decorators
# In this example `beg` wraps `say`. If say_please is True then it
# will change the returned message.
from functools import wraps

def beg(target_function):
    @wraps(target_function)
    # 如果please为True，额外输出一句Please! I am poor :(
    def wrapper(*args, **kwargs):
        msg, say_please = target_function(*args, **kwargs)
        if say_please:
            return "{} {}".format(msg, "Please! I am poor :(")
        return msg

    return wrapper

@beg
def say(say_please=False):
    msg = "Can you buy me a beer?"
    return msg, say_please

print(say())                 # Can you buy me a beer?
print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(

Также перед декоратором есть специальная статья, которую можно переместить на следующий портал:

Получите декоратор Python в одной статье, больше не паникуйте после прочтения интервью

конец

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

Первоначальный автор написалФайл Python, все в комментариях Python. Я построил его с переделками и дополнительными описаниями. Если вы хотите получить исходный текст, вы можете нажать, чтобы просмотреть исходный текст, или ответить в официальном аккаунте.learnpythonПолучать.

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

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

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