• 后端Web服务器
• DevOps和Cloud Engineering
• 机器学习
• 脚本和自动化
• 等...

另一方面，这并不是在前端工作中特别闻名的。虽然可以这样做是可能的，但python通常不用于构建视觉用户界面。

设置当地开发环境

要开始使用Python，您需要在计算机上安装python命令，然后安装文本编辑器或IDE。如果您还不熟悉如何做到这一点，那么我可以遵循一个完整的分步project guide here。

如果您能够在计算机上编辑和运行Python代码，则可以继续！

什么是“代码”？

代码只是计算机可以遵循的一系列说明。计算机遵守每个指令，一个接一个地。

speed = 5
speed_description = "five"

如果没有动态键入该怎么办？

像GO这样的静态键入语言（在以后的课程中您会学到的）是静态键入的，而不是动态键入的。在静态键入的语言中，如果您尝试将值分配给错误类型的变量，则错误将崩溃。

如果Python静态型，则第一个示例将在第二行崩溃，speed = "five"。计算机会沿着you can't assign a string value ("five") to a number variable (speed)

用字符串数学

除了+加法运营商外，我们早些时候曾经过的大多数数学运算符都不使用字符串。使用字符串时，+操作员执行“串联”。

“串联”是一个花哨的词，意味着两个字符串的连接。

first_name = "Lane "
last_name = "Wagner"
full_name = first_name + last_name

full_name现在拥有“车道瓦格纳”的值。

请注意first_name变量中"Lane "末端的额外空间。在最终结果中，还有额外的空间将单词分开："Lane Wagner"。

多变量声明

通过在同一行上声明它们来创建许多新变量时，我们可以节省空间：

sword_name, sword_damage, sword_length = "Excalibur", 10, 200

与：
相同

sword_name = "Excalibur"
sword_damage = 10
sword_length = 200

可以在同一行上声明任何数量的变量，并且在同一行上声明的变量应以某种方式相互关联，以便代码仍然易于理解。

我们调用易于理解“干净代码”的代码。

第2章：计算基础知识

python数字

在Python中，没有小数零件的数字称为Integers-就像它们在数学中一样。

整数只是全数字，正数或负数。例如，3和-3都是整数的示例。

算术可以按照您的期望进行：

添加

2 + 1
# 3

减法

2 - 1
# 1

乘法

2 * 2
# 4

分配

3 / 2
# 1.5 (a float)

这个实际上有些不同 - 两个整数上的除法实际上会产生一个float。正如您可能猜到的那样，浮子是允许小数值的数字类型。

整数

在Python中，没有小数零件的数字称为Integers。将其与JavaScript进行对比，所有数字只是Number类型。

整数只是全数字，正数或负数。例如，3和-3都是整数的示例。

浮子

您可能已经猜到的是允许小数值的数字类型。

my_int = 5
my_float = 5.5

地板师

Python对数学操作有很好的开箱即用支持。除其他原因外，为什么它在人工智能，机器学习和数据科学应用中取得了如此成功的原因。

地板分裂就像正常的划分，但结果是floored之后，这意味着剩余的已删除。如您所料，这意味着结果是integer而不是float。

7 // 3
# 2 (an integer)

指数

python对指数有内置的支持 - 大多数语言都需要math库。

# reads as "three squared" or
# "three raised to the second power"
3 ** 2
# 9

在适当的位置

想要根据其当前值更改变量的值是很常见的。

player_score = 4
player_score = player_score + 1
# player_score now equals 5

player_score = 4
player_score = player_score - 1
# player_score now equals 3

不要让表达式player_score = player_score - 1不是有效的数学表达的事实令人困惑。 这没关系，是有效的代码。这是有效的，因为应该用英语读取表达方式是：

分配给player_score player_score减去1

的旧值

加上平等

python在进行数学时使重新分配变得容易。在JavaScript或Go中，您可能熟悉++语法，以增加数字变量。在Python中，我们使用+=操作员。

star_rating = 4
star_rating += 1
# star_rating is now 5

科学计数法

正如我们之前涵盖的那样，float是一个正数或负数，分数部分。

您可以添加字母e或E，然后是一个正或负整数来指定您使用的是scientific notation。

print(16e3)
# Prints 16000.0

print(7.1e-2)
# Prints 0.071

如果您不熟悉科学符号，这是一种表达数字太大或太小而无法正常写入的数字的方式。

强调可读性

python还允许您使用下划线而不是逗号以更易于阅读的逗号表示大量数字。

num = 16_000
print(num)
# Prints 16000

num = 16_000_000
print(num)
# Prints 16000000

逻辑操作员

您可能熟悉逻辑运营商AND和OR。

逻辑运营商处理boolean values，True和False。

逻辑AND运算符要求 输入都是True才能返回True。逻辑OR操作员只要求至少一个输入是True才能返回True。

例如：

True AND True = True
True AND False = False
False AND False = False

True OR True = True
True OR False = True
False OR False = False

Python语法

print(True and True)
# prints True

print(True or False)
# prints True

用括号嵌套

我们可以使用括号嵌套逻辑表达式。

print((True or False) and False)

首先，我们评估了括号中的表达，(True or False)。它评估为True：

print(True and False)

True and False评估对False：

print(False)

所以，print((True or False) and False)向控制台打印“ false”。

二进制数

二进制数字只是“基本2”数字。它们的工作方式与“普通”基础10个数字相同，但是有2个符号而不是10个符号。

二进制数中的每个1代表2个较大的倍数。在4位数字中，这意味着您拥有八个位置，四个位置，四个位置，两人的位置和一个位置。类似于您在十进制中如何拥有千分之一的位置，一百个位置，十个位置和一个地方。

• 0001 = 1
• 0010 = 2
• 0011 = 3
• 0100 = 4
• 0101 = 5
• 0110 = 6
• 0111 = 7
• 1000 = 8

钻头”＆”操作员

位运算符与逻辑运算符相似，但是它们不用在布尔值上操作，而是将相同的逻辑应用于值中的所有位。例如，假设您的数字5和7在binary中代表。您可以执行Bitwise AND操作，结果将是5。

0101 = 5
&
0111 = 7
=
0101 = 5

二进制中的1与True相同，而0是False。因此，实际上是一个位于串联完成的逻辑操作。

&是Python中的Bitwise AND操作员。 5 & 7 = 5，而5 & 2 = 0。

0101 = 5
&
0010 = 2
=
0000 = 0

二进制符号

在二进制中编写一个数字时，前缀0b用于指示下面的是二进制号码。

• 0b0101是5
• 0b0111是7

示例：公会许可

在后端开发中，将用户权限存储为二进制值是常见的做法。考虑一下，如果我拥有用户可以拥有的4不同的权限，那么我可以将其存储为4位二进制号码，如果存在某个位置，我知道已启用了权限。

让我们假装我们有4个权限：

• can_create_guild-最左边的位
• can_review_guild-第二到左
• can_delete_guild-第二到右
• can_edit_guild-最右边的位

由0b0000代表。例如，如果用户仅拥有can_create_guild许可，则其二进制权限为0b1000。拥有can_review_guild和can_edit_guild的用户将是0b0101。

要检查can_review_guild许可，我们可以对用户的权限和启用的can_review_guild bit（0b0100）执行Bitwise AND操作。如果结果再次为0b0100，我们知道他们已有特定的许可！

钻头“ |”操作员

您可能已经猜到的是，位“或“操作员”类似于位”和“运算符，因为它在二进制而非布尔值上都起作用。但是，将位的位“或“操作员”）一起。这是一个例子：

• 0101是5
• 0111是7

0101
|     
0111
=
0111

二进制中的1与True相同，而0是False。因此，位操作只是一堆逻辑操作，这些操作是同时完成的。当两个二进制编号一起“ or”在一起时，结果在输入数字的任何位置都具有1。

|是Python的Bitwise OR操作员。 5 | 7 = 7和5 | 2 = 7！

0101 = 5
|
0010 = 2
=
0111 = 7

不是

我们跳过了一个非常重要的逻辑操作员-not。 not操作员逆转了结果。如果输入为True，则返回False，反之亦然。

print(not True)
# Prints: False

print(not False)
# Prints: True

第3章：比较

比较操作员

编码时，有必要比较两个值。 Boolean logic是这些比较操作的名称，这些操作总是导致True或False。

操作员：

• <“小于”
• >“大于”
• <=“小于或等于”
• >=“大于或等于”
• ==“等于”
• !=“不等于”

例如：

5 < 6 # evaluates to True
5 > 6 # evaluates to False
5 >= 6 # evaluates to False
5 <= 6 # evaluates to True
5 == 6 # evaluates to False
5 != 6 # evaluates to True

评估

发生比较时，比较的结果只是一个布尔值，它是True或False。

以以下两个示例：

is_bigger = 5 > 4

is_bigger = True

在上述两种情况下，我们正在创建一个称为is_bigger的Boolean变量，值为True。

自5 > 4以来，is_bigger总是分配了True的值。

如果可以将其设置为“ True”，为什么要使用比较？

您不会在 案例中。但是，让我们想象，我们没有一些 dynamic 变量，而不是用硬编码数字5和4。例如，也许您正在制作视频游戏，需要跟踪玩家分数。

要计算谁获胜，您需要写类似的东西：

# player_one_points and player_two_points are defined and change somewhere else in the game's code
player_one_wins = player_one_points > player_two_points
print(player_one_wins)

# prints "True" when player one is winning, otherwise prints "False"

增量 /减少

如果我们要更改一个数字，并且只想增加（添加到）或减少（从中减去），则有特殊操作员。

shield_armor = 4
shield_armor += 1
# shield_armor now equals 5
shield_armor += 2
# shield_armor now equals 7

shield_armor = 4
shield_armor -= 1
# shield_armor now equals 3
shield_armor -= 2
# shield_armor now equals 1

请注意，shield_armor+=1只是shield_armor = shield_armor + 1

如果语句

在满足特定条件时仅执行代码通常很有用：

if CONDITION:
  # do some stuff here

例如：

if bob_score > bill_score:
  print("Bob Wins!")

如果别的

if语句之后可以零或更多的elif（代表“ else if”）语句，可以随后进行零或一个else语句。例如：

if score > high_Score:
    print('High score beat!')
elif score > second_highest_score:
    print('You got second place!')
elif score > third_highest_score:
    print('You got third place!')
else:
    print('Better luck next time')

首先评估了if语句。如果是True，则执行IF语句的主体，并且所有其他else被忽略。

如果第一个if是错误的，则评估下一个elif。同样，如果是True，则执行其身体，其余的忽略。

如果if没有对True进行评估，则最终的else语句将是唯一执行的机构。

如果else规则

• 没有if的elif或else
• you can 有一个没有elif的else

第5章：循环

循环是程序员的最好朋友。循环允许我们多次进行相同的操作，而无需每次明确编写。

例如，让我们假装我想打印数字0-9。

我可以这样做：

print(0)
print(1)
print(2)
print(3)
print(4)
print(5)
print(6)
print(7)
print(8)
print(9)

即使这样，它也可以节省很多时间来使用 loop 。特别是如果我想做同样的事情 或一百万次。

for i in range(0, 10):
    print(i)

for i in range(0, 10):
    print(i)

for i in range(0, 10, 2):
    print(i)
# prints:
# 0
# 2
# 4
# 6
# 8

for i in range(3, 0, -1):
    print(i)
# prints:
# 3
# 2
# 1

num_bananas = 10
print(f"You have {num_bananas} bananas")
# You have 10 bananas

inventory = ["Iron Breastplate", "Healing Potion", "Leather Scraps"]

flower_types = [
    "daffodil",
    "rose",
    "chrysanthemum"
]

names = ["Bob", "Lane", "Alice", "Breanna"]

best_languages = ["JavaScript", "Go", "Rust", "Python", "C"]
print(best_languages[1])
# prints "Go", because index 1 was provided

fruits = ["apple", "banana", "pear"]
length = len(fruits)
# Prints: 3

inventory = ["Leather", "Healing Potion", "Iron Ore"]
inventory[0] = "Leather Armor"
# inventory: ['Leather Armor', 'Healing Potion', 'Iron Ore']

cards = []
cards.append("nvidia")
cards.append("amd")
# the cards list is now ['nvidia', 'amd']

vegetables = ["broccoli", "cabbage", "kale", "tomato"];
last_vegetable = vegetables.pop()
# vegetables = ['broccoli', 'cabbage', 'kale']
# last_vegetable = 'tomato'

for i in range(0, len(sports)):
    print(sports[i])

trees = ['oak', 'pine', 'maple']
for tree in trees:
  print(tree)
# Prints:
# oak
# pine
# maple

for fruit in fruits:
    print(fruit)

remainder = 8 % 3
# remainder = 2

Lst[ Initial : End : IndexJump ]

scores = [50, 70, 30, 20, 90, 10, 50]
# Display list
print(scores[1:5:2])
# Prints [70, 20]

scores = [50, 70, 30, 20, 90, 10, 50]
# Display list
print(scores[1:5])
# Prints [70, 30, 20, 90]

scores = [50, 70, 30, 20, 90, 10, 50]
# Display list
print(scores[1:])
# Prints [70, 30, 20, 90, 10, 50]

all = [1, 2, 3] + [4, 5, 6]
print(all)
# Prints: [1, 2, 3, 4, 5, 6]

fruits = ["apple", "orange", "banana"]
print("banana" in fruits)
# Prints: True

f"banana is in fruits list: {'banana' in fruits}"

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# delete the fourth item
del nums[3]
print(nums)
# Output: [1, 2, 3, 5, 6, 7, 8, 9]

# delete items from 2nd to 3rd
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
del nums[1:3]
print(nums)
# Output: [1, 4, 5, 6, 7, 8, 9]

# delete all elements
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
del nums[:]
print(nums)
# Output: []

my_tuple = ("this is a tuple", 45, True)
print(my_tuple[0])
# this is a tuple
print(my_tuple[1])
# 45
print(my_tuple[2])
# True

dog = ("Fido", 4)

my_tuples = [("this is the first tuple in the list", 45, True),("this is the second tuple in the list", 21, False)]
print(my_tuples[0][0])
# this is the first tuple in the list

r = 5
area = 3.14 * r * r

r = 5
area1 = 3.14 * r * r

r2 = 7
area2 = 3.14 * r2 * r2

r3 = 11
area3 = 3.14 * r3 * r3

def area_of_circle(r):
    return 3.14 * r * r

radius = 5
area = area_of_circle(radius)

def subtract(a, b):
    return a - b

print(my_name)
my_name = 'Lane Wagner'

my_name = 'Lane Wagner'
print(my_name)

def main():
    func2()

def func2():
    func3()

def func3():
    print("I'm function 3")

main() # entrypoint

def subtract(x, y)
    return x - y
result = subtract(5, 3)
print(x)
# ERROR! "name 'x' is not defined"

pi = 3.14

def get_area_of_circle(radius):
    return pi * radius * radius

negative_infinity = float('-inf')
positive_infinity = float('inf')

def my_func():
    print("I do nothing")
    return None

def my_func():
    print("I do nothing")
    return

def my_func():
    print("I do nothing")

# a and b are parameters
def add(a, b)
    return a + b

# 5 and 6 are arguments
sum = add(5, 6)

# returns email, age, and status of the user
def get_user():
    return "name@domain.com", 21, "active"

email, age, status = get_user()
print(email, age, status)
# Prints: "name@domain.com 21 active"

def get_user():
    return "name@domain.com", 21, "active"

# this works, and by convention you should NOT use the underscore variable later
email, _, _ = get_user()
print(email)
# Prints: "name@domain.com"
print(_)
# Prints: "active"

def get_greeting(email, name="there"):
    return f"Hello {name}, welcome! You've registered your email: {email}"

msg = get_greeting("lane@example.com", "Lane")
# Hello Lane, welcome! You've registered your email: lane@example.com

msg = get_greeting("lane@example.com")
# Hello there, welcome! You've registered your email: lane@example.com

car = {
  "brand": "Tesla",
  "model": "3",
  "year": 2019
}

car = {
    'make': 'tesla',
    'model': '3'
}
print(car['make'])
# Prints: tesla

names = ["jack bronson", "jill mcarty", "john denver"]

names_dict = {}
for name in names:
    # .split() returns a list of strings
    # where each string is a single word from the original
    names_arr = name.split()

    # here we update the dictionary
    names_dict[names_arr[0]] = names_arr[1]

print(names_dict)
# Prints: {'jack': 'bronson', 'jill': 'mcarty', 'john': 'denver'}

names = ["jack bronson", "james mcarty", "john denver"]

names_dict = {}
for name in names:
    # .split() returns a list of strings
    # where each string is a single word from the original
    names_arr = name.split()

    # we're always setting the "jack" key
    names_dict["jack"] = names_arr[1]

print(names_dict)
# Prints: {'jack': 'denver'}

names_dict = {
    'jack': 'bronson',
    'jill': 'mcarty',
    'joe': 'denver'
}

del names_dict['joe']

print(names_dict)
# Prints: {'jack': 'bronson', 'jill': 'mcarty'}

names_dict = {
    'jack': 'bronson',
    'jill': 'mcarty',
    'joe': 'denver'
}

del names_dict['unknown']
# ERROR HERE, key doesn't exist

cars = {
    'ford': 'f150',
    'tesla': '3'
}

print('ford' in cars)
# Prints: True

print('gmc' in cars)
# Prints: False

fruit_sizes = {
    "apple": "small",
    "banana": "large",
    "grape": "tiny"
}

for name in fruit_sizes:
    size = fruit_sizes[name]
    print(f"name: {name}, size: {size}")

# name: apple, size: small
# name: banana, size: large
# name: grape, size: tiny

fruits = {'apple', 'banana', 'grape'}
print(type(fruits))
# Prints: <class 'set'>

print(fruits)
# Prints: {'banana', 'grape', 'apple'}

fruits = {'apple', 'banana', 'grape'}
fruits.add('pear')
print(fruits)
# Prints: {'banana', 'grape', 'pear', 'apple'}

fruits = set()
fruits.add('pear')
print(fruits)
# Prints: {'pear'}

fruits = {'apple', 'banana', 'grape'}
for fruit in fruits:
    print(fruit)
    # Prints:
    # banana
    # grape
    # apple

fruits = {'apple', 'banana', 'grape'}
fruits.remove('apple')
print(fruits)
# Prints: {'banana', 'grape'}

this is not valid code, so it will error

this is not valid code, so it will error
      ^
SyntaxError: invalid syntax

try:
  10 / 0
except Exception as e:
  print(e)

# prints "division by zero"

raise Exception("something bad happened")

raise Exception("something bad happened")

try:
    10/0
except ZeroDivisionError:
    print("0 division")
except Exception:
    print("unknown exception")

try:
    nums = [0, 1]
    print(nums[2])
except ZeroDivisionError:
    print("0 division")
except Exception:
    print("unknown exception")

0 division
unknown exception

print "hello world"

print("hello world")