python入门基础（完整）_python完整

x = 106
degree = 90

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 6
画一个长宽分别为 68, 59 像素的矩形

w = 68
h = 59
degree = 90

forward(w)
right(degree)
forward(h)
right(degree)
forward(w)
right(degree)
forward(h)
right(degree)

作业 7
画一个边长为 79 的正五边形
提示, 往右旋转 72 度

x = 79
degree = 72

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 8
画一个边长为 63 的正六边形
提示, 往右旋转 60 度
正 n 边形的内角和： (n - 2) * 180

x = 63
n = 6
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 9
画一个边长为 159 的正七边形
提示, 往右旋转 52 度

x = 159
n = 7
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 10
画一个边长为 93 的正十边形
提示, 往右旋转 36

x = 93
n = 10
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

# 循环
# 首先定义一个变量，用于计算循环的次数，一般是 i j k a b c
i = 0
# while 后面的语句是条件
# 当条件成立的时候，执行代码块内的语句
# 否则，结束循环
while i < n:
    forward(x)
    right(degree)
    # 注意，在 while 循环里，一定改变 i 的值
    # 否则循环永远不会结束
    i = i + 1

4）Python 中的四则运算

* 代表乘号
/ 代表除号
四则运算是有优先级的 + - 低于 * /

5）循环while

# 循环
# 首先定义一个变量，用于计算循环的次数，一般是 i j k a b c
i = 0
# while 后面的语句是条件
# 当条件成立的时候，执行代码块内的语句
# 否则，结束循环
while i < n:
    forward(x)
    right(degree)
    # 注意，在 while 循环里，一定改变 i 的值
    # 否则循环永远不会结束
    i = i + 1

6）函数

函数是用来消除大段重复代码的功能
主流的语言都有函数这个特性
函数是一段代码的疾患，用于重复使用一段代码

定义一个函数，画一个边长 100 像素的正三角形

def sjjcxy():
    n = 3
    x = 100
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        forward(x)
        right(degree)
        i = i + 1


sjjcxy()

以上是定义函数的方式，下面就可以使用了
注意，程序是按顺序执行的，所以定义要在使用前面
函数名 加上一对括号，表示调用函数（调用即为使用）

sjjcxy()
forward(50)
sjjcxy()

函数和其他变量一样，是可以赋值给另一个变量的

sjjc = sjjcxy
sjjc()

7）函数的参数可以增加灵活性

def sjjcxy(x):
    n = 3
    # x = 100
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        forward(x)
        right(degree)
        i = i + 1

sjjcxy(10)
sjjcxy(50)
sjjcxy(100)

def polygon(bmih, bmuu=3):
    # n = 3
    # x = 100
    n = bmuu
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        forward(bmih)
        right(degree)
        i = i + 1


polygon(100)
polygon(80, 5)
polygon(50, 6)

8）变量名命名规则

只能包括字母，下划线，美元符号，数字
不能以数字开头
变量名是大小写敏感的
只有在现代的 Python 里，才能用中文作为合法的变量名
变量名不能是 Python 的保留字（while def 等等）

9）代码格式化自检条目

​​​​1. 每行只写一条语句
2. 函数之间空两行
3. 运算符左右各加一个空格
4. 逗号前无空格，后面加 1 个空格
5. 冒号前无空格，字典中的冒号后面有一个空格
6. 参数默认值的等号两边没有空格
7. 函数、列表左括号前没有空格，所有右括号前无空格

二、第二课

1.作业1解答

1
实现函数, 用于画一个正方形, 边长由参数提供
参数 x, y 是正方形左上角坐标
参数 l(注意，这里是字母 l，不是数字 1) 是正方行边长

def square(x, y, l):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 4:
        forward(l)
        right(90)
        i = i + 1


square(5, 5, 10)

2
实现函数, 用于画一个矩形, 长宽由参数提供
参数 x, y 是左上角坐标
参数 w, h 是长宽

def rect(x, y, w, h):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 2:
        forward(w)
        right(90)
        forward(h)
        right(90)
        i = i + 1


rect(2, 20, 30, 10)

3
画一排正方形, 一共 5 个
从 0 0 点开始, 边长为 30, 正方形之间间隔为 0

def square(x, y, l):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 4:
        forward(l)
        right(90)
        i = i + 1


def square5():
    n = 5
    bmih = 30
    #  x 坐标
    # 0  30  60  90  120
    # 0  1   2   3   4
    i = 0
    while i < n:
        x1 = i * bmih
        y1 = 0
        square(x1, y1, bmih)
        i = i + 1


square5()

4
画一排正方形, 一共 5 个
从 0 0 点开始, 边长为 30, 正方形之间间隔为 10 像素

def square(x, y, l):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 4:
        forward(l)
        right(90)
        i = i + 1


def square5_10():
    n = 5
    bmih = 30
    space = 10
    #  x 坐标
    # 0  40  80  120  160
    # 0  1   2   3   4
    i = 0
    while i < n:
        x1 = i * (bmih + space)
        y1 = 0
        square(x1, y1, bmih)
        i = i + 1


square5_10()

5
实现函数, 画一排正方形, 有如下参数
x, y 是第一个正方形左上角坐标
n 是正方形的个数
space 是两个正方形之间的间距
len 是正方形的边长

def square(x, y, l):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 4:
        forward(l)
        right(90)
        i = i + 1


def square_line(x, y, n, space, len):
    # n = 5
    bmih = len
    # space = 10
    #  x 坐标
    # 0  40  80  120  160
    # 0  1   2   3   4
    i = 0
    while i < n:
        x1 = x + i * (bmih + space)
        y1 = y
        square(x1, y1, bmih)
        i = i + 1


square_line(5, 8, 7, 10, 30)

6
实现函数, 用上题的函数来画一个正方形方阵, 参数如下
x, y 是第一个正方形左上角坐标
space 是两个正方形之间的间距
len 是正方形的边长
n 是横向正方形的个数
m 是纵向正方形的个数

def square(x, y, l):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 4:
        forward(l)
        right(90)
        i = i + 1


def square_line(x, y, n, space, len):
    # n = 5
    bmih = len
    # space = 10
    #  x 坐标
    # 0  40  80  120  160
    # 0  1   2   3   4
    i = 0
    while i < n:
        x1 = x + i * (bmih + space)
        y1 = y
        square(x1, y1, bmih)
        i = i + 1


def square_square(x, y, space, len, n, m):
    i = 0
    while i < m:
        x1 = x
        y1 = y + i * (len + space)
        square_line(x1, y1, n, space, len)
        i = i + 1


square_square(-100, 50, 10, 50, 3, 2)

7
实现函数, 画一排矩形, 有如下参数
x, y 是第一个矩形左上角坐标
w, h 是矩形长宽
n 是矩形的个数
space 是两个矩形之间的间距

def rect(x, y, w, h):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 2:
        forward(w)
        right(90)
        forward(h)
        right(90)
        i = i + 1


def rect_line(x, y, w, h, n, space):
    i = 0
    while i < n:
        x1 = x + i * (w + space)
        y1 = y
        rect(x1, y1, w, h)
        i = i + 1


rect_line(40, 40, 40, 10, 3, 10)

8
实现函数, 画一个矩形方阵, 参数如下
x, y 是第一个矩形左上角坐标
space 是两个矩形之间的间距(横向和纵向)
w, h 是矩形的长宽
n 是横向矩形的个数
m 是纵向矩形的个数

def rect(x, y, w, h):
    jump(x, y)
    # 循环画正方形
    # 当然, 你可以用 goto 来画
    # 只需要计算一下四个顶点的坐标 (这很简单)
    i = 0
    while i < 2:
        forward(w)
        right(90)
        forward(h)
        right(90)
        i = i + 1


def rect_line(x, y, w, h, n, space):
    i = 0
    while i < n:
        x1 = x + i * (w + space)
        y1 = y
        rect(x1, y1, w, h)
        i = i + 1


def rect_square(x, y, space, w, h, n, m):
    i = 0
    while i < m:
        x1 = x
        y1 = y + i * (h + space)
        rect_line(x1, y1, w, h, n, space)
        i = i + 1


rect_square(50, 50, 10, 40, 10, 3, 4)

9
实现函数, 画一个正多边形, 参数如下
x y 是起点, 设起点为多边形的顶部边的左顶点
n 是多边形的边数
l 是边长

def polygon(x, y, n, l):
    jump(x, y)
    i = 0
    jcdu = 180 - (180 * (n - 2) / n)
    while i < n:
        forward(l)
        right(jcdu)
        i = i + 1


polygon(40, 10, 36, 10)

2.调试代码

解决语法错误和逻辑错误

3.数据类型

1）整型就是整数

x = 10

2）浮点型就是小数

y = 10.1
a = 12.0
b = 0.21

下面的 c 和 d 两个变量是合法的
因为当你小数点左右只有 0 的时候
Python 规定可以省略 0
但一定不要这样写

c = 12.
d = .21

3）字符串类型的变量

name = 'gua'
gender = "male"

4）print函数

x = 10
y = 10.1
name = 'gua'
print(x, y, name)

10 10.1 gua

4.选择控制

1）if else

grade = 3
# 如果 grade 小于 7
if grade < 7:
    # 这句 print 只在 grade 小于 7 这个条件满足的情况下会被执行
    print('小学生')

小学生

if 带 else
if else 必定会执行一个语句

if 1 > 2:
    print('条件成立')
else:
    print('条件不成立')

条件不成立

多个if else

grade = 8
if grade < 7:
    print('小学生')
elif grade < 10:
    print('初中生')
else:
    print('高中生')

初中生

2）绝对值

n = 111
if n < 0:
    n = -n

print('绝对值', n)

绝对值 111

3）判断奇数偶数

n = 1
if n % 2 == 0:
    print('偶数')
else:
    print('奇数')

奇数

5.比较运算和逻辑操作

1）比较运算

一共有 6 个常用比较运算
分别是：
相等, 不等, 小于, 大于, 小于等于, 大于等于

==
!=
<
>
<=
>=

print('布尔值', 1 == 1)

布尔值 True

2）逻辑操作

与, 或, 非

and
or
not

用到的地方很广, 比如登录网站的时候, 服务器做如下判断

if 用户名存在 and 密码验证成功:
    登录成功
else:
    登录失败

print('1 == 1 and 2 == 2', 1 == 1 and 2 == 2)

1 == 1 and 2 == 2 True

6.函数返回值

1）定义

函数不仅可以合并操作重复性的代码
还可以通过计算得到一个结果, 结果就是返回值
函数可以有「返回值」
返回值的意思是函数调用的结果是一个值, 可以被赋值给变量

2）add函数

例
定义一个函数 add
接受 a b 两个参数

def add(a, b):
    # 用 return 语句来得到一个返回值
    # 函数执行到 return 语句的时候就结束了
    return a + b

print('add 函数的返回值', add(1, 2))
number = add(2, 3)
print('add 函数的返回值 number', number)

add 函数的返回值 3
add 函数的返回值 number 5

3）绝对值函数

def abs(n):
    if n < 0:
        n = -n
    return n


print(abs(0))
print(abs(-8))
print(abs(3))

0
8
3

函数执行遇到 return 就结束

def minus(a, b):
    print('minus start')
    return a - b
    print('这一句是不会被执行的, 因为 return 的时候函数就结束了')


print(minus(1, 2))

minus start

4）一个数字是否是奇数

def is_odd(n):
    # 取余数的操作符是 %
    if n % 2 != 0:
        return True
    else:
        return False

以下是更好的写法

def is_odd(n):
    return n % 2 != 0

print(is_odd(1))
print(is_odd(2))
print(is_odd(3))
print(is_odd(4))

True
False
True
False

5）返回两个参数中较小的一个

def min(a, b):
    if a < b:
        return a
    else:
        return b


print(min(1, 2))
print(min(3, 2))

1
2

7.标准库

库 是一个编程术语, 意思是一系列函数的集合

标准库 也是一个术语, 指的是语言自带的库

Python 的**在线文档**有所有标准库的文档(当然, 不那么容易看懂)。我们可以用标准库实现很多功能

使用标准库就是直接使用即可(因为自带了)。标准库的用法上课会讲

1）math库-sin

print(math.pi)
print(math.sin(30))
print('0.5', math.sin(30 * math.pi / 180))

3.141592653589793
-0.9880316240928618
0.5 0.49999999999999994

def float_equal(a, b):
    delta = 0.0001
    return abs(a - b) < delta

radian = 30 * math.pi / 180
sin30 = math.sin(radian)
# print('0.5', sin30, sin30 == 0.5)
print('0.5', sin30, float_equal(sin30, 0.5))

0.5 0.49999999999999994 True

2）math-floor,ceil

print('floor', math.floor(3.9))
print('ceil', math.ceil(3.1))

三、第三课

1.作业2解答

// 注意, 作业中提到的国旗的颜色我们只画黑色线框不填色
// 所有国旗的矩形长宽分别为 300 * 200(包括瑞士国旗)

// 作业 1
// 实现一个圆形函数
// x y 是圆形的圆心
// r 是半径
// circle(x, y, r)

提示:
    我们在第一节课的最后有一个作业 polygon, 实际上电脑是通过模拟来实现画一个圆的
    也就是画一个正 n 变形, n 很大的时候, 这个图形就是一个圆
    有一个问题需要注意, 初始点在圆心处, 在画 polygon 的时候需要从左上角开始
    所以要先从圆心移动到左上角

需要注意的是，按照下面提示的写法，画出的圆会多处一条半径线，这一条线必须保留。


分步提示:
注意, 你需要 import math 后才能使用 math.pi
    1. 我们用正 36 边形来模拟圆形, 也就是说 n 取值 36
    2. 正多边形的周长是 n(边数) * l(边长), 而它的外接圆的周长是 2 * math.pi * r, 我们这里把这两个周长看做相等(因为我们只是用正多边形近似模拟, 不是精准画圆, 小小偏差可以接受)
       所以直接算出 l = (2 * math.pi * r) / n  这个公式中 l 是多边形边长, r 是圆半径, n 是边数
       具体请看下图(正多边形和外接圆)
    3. 初始情况下箭头是朝右的, 所以先往左转, 左转 90 度等于右转 270 度, 所以你需要自己实现一个 left 函数(或者直接 right(270) 或者 right(-90))
        这个角度的具体计算原理见下图
        这里直接把公式给出如下, 你可以直接使用
        jcdu = (90 + (360 / n) / 2)
        left(jcdu)
    4. 转完之后, 移动 r, 也就是半径的距离
    5. 这样就移动到了左上角的位置, 但此时角度并不是朝右的,
       刚刚往左转动了 jcdu, 现在往右转回来这个角度
       right(jcdu)
    6. 这时候你就在正多边形的顶部横边的左顶点并且方向朝右了, 以此为起点画一个正 36 边形即可


如果不能理解上面的提示，那么看下面的提示
程序初始的时候状态如下
1，箭头朝右
2，在原点处

你把你想像成箭头，你得先 jump 到圆心处，再：
1，先左转90度（或者右转 270 度）
2，左转 360/n/2 度
3，前进半径 r
4，转成朝右
5，开始画 36 边形

def left(jcdu):
    right(360 - jcdu)


def polygon(n, l):
    i = 0
    jcdu = 360 / n
    while i < n:
        forward(l)
        right(jcdu)
        i = i + 1


def circle(x, y, r):
    jump(x, y)

    n = 36
    jcdu = (90 + (360 / n) / 2)
    len = (2 * math.pi * r) / n
    left(jcdu)
    forward(r)
    right(jcdu)

    polygon(n, len)


circle(0, 0, 50)

// 作业 2
// 实现一个矩形函数
// x y 是矩形中心的坐标
// w h 是宽高
// center_rect(x, y, w, h)

提示:
在第一课的作业中已经实现了 rect 函数,
不过 rect 函数中的 x, y 是表示左上角坐标,
现在需要实现的 center_rect 函数的 x, y 是矩形中心的坐标,
所以应该先从矩形中心移动到矩形左上角, 然后调用 rect 函数

分步提示:

1. 根据矩形中心坐标 x, y 计算出左上角坐标 x1, y1
2. 调用 rect 函数, 传入的参数分别为左上角坐标, 宽和高

def rect(x, y, w, h):
    jump(x, y)
    i = 0
    while i < 2:
        forward(w)
        right(90)
        forward(h)
        right(90)
        i = i + 1


def center_rect(x, y, w, h):
    x1 = x - w / 2
    y1 = y + h / 2
    rect(x1, y1, w, h)

// 作业 3
// 实现一个正五角星(国旗大星星那种)函数
// x y 是五角星顶部横边的左边点坐标
// length 是一条线的长度
// 这是一个正五角星
// vgwujcxy(x, y, length)

分步提示:

1. 正五角星需要重复 5 次, 所以需要循环 5 次
2. 每次循环中前进 length 的长度, 右转 144 度
3. 别忘了循环的时候 i 增加 1

def vgwujcxy(x, y, length):
    jump(x, y)

    i = 0
    while i < 5:
        forward(length)
        right(144)
        i = i + 1


vgwujcxy(-100, 50, 50)

// 注意, 作业中提到的国旗的颜色我们只画黑色线框不填色

// 作业 4
// 实现一个函数画日本国旗
// 调用 2 个函数画日本国旗
// 一个画背景的白色矩形
// 一个画中间的圆，圆的直径必须为国旗高的 3/5
// x, y 是国旗左上角座标
// japan(x, y)

提示:
日本国旗由两部分组成, 矩形和圆形. 所以依次画出这两个图形

分步提示:

1. 调用 center_rect 函数画一个矩形
2. 调用 circle 函数画一个圆形

def japan(x, y):
    w = 300
    h = 200

    x1 = x + w / 2
    y1 = y - h / 2
    center_rect(x1, y1, w, h)

    r = h * (3 / 5) / 2
    circle(x1, y1, r)


japan(100, 100)

// 作业 5
// 实现一个五角星函数
// x y 是五角星的中心点坐标
// r 是五角星外接圆的半径
// wujcxy(x, y, r)
// 为了实现这个函数, 你需要使用三角函数计算顶点在圆上的坐标
// 如果你不懂这个数学计算过程, 应该在群里提问
// 我帮你实现了正弦余弦函数如下
def sin(degree):
import math

如上课所述, 数学库里面的 sin 函数接受弧度作为参数

我们这个函数接受角度, 下面是弧度转角度的公式

radians = degree * math.pi / 180
return math.sin(radians)

def cos(degree):
import math
radians = degree * math.pi / 180
return math.cos(radians)

提示

1. 正五角星顶角的一半是 18 度, du = 18, 外接圆半径为 r
2. 五角星顶部横边 BE 的左边点 B 的 x 坐标为 x1 = x - cos(du) * r
3. 五角星顶部横边 BE 的左边点 B 的 y 坐标为 y1 = y + sin(du) * r
4. 五角星顶部横边的长度为 length = cos(du) * r * 2
5. 调用作业 3 的函数 vgwujcxy(x1, y1, length)

def sin(degree):
    import math
    # 如上课所述, 数学库里面的 sin 函数接受弧度作为参数
    # 我们这个函数接受角度, 下面是弧度转角度的公式
    radians = degree * math.pi / 180
    return math.sin(radians)

def cos(degree):
    import math
    radians = degree * math.pi / 180
    return math.cos(radians)

def wujcxy(x, y, r):
    du = 18
    x1 = x - cos(du) * r
    y1 = y + sin(du) * r
    length = cos(du) * r * 2

    vgwujcxy(x1, y1, length)


wujcxy(0, 0, 135)
circle(0, 0, 135)

作业 6
实现一个函数画中国国旗(以下国旗题目都是如此 不重复了)
五角星不要求角度朝向（统一用正五角星），但是要求尺寸必须符合下图中的比例
x, y 是国旗左上角座标（后面的题都是这个要求，不再重复说明）
china(x, y)

提示:
    中国国旗由两部分组成, 矩形和 5 个五角星, 计算好比例, 依次画完

分步提示:
    1. 使用 rect 函数画一个矩形
    2. 计算比例，画 5 个五角星(调用 5 次)

def china(x, y):
    w = 300
    h = 200

    rect(x, y, w, h)
    # 大五角星
    xw1 = x + w / 6
    yw1 = y - h / 4
    rw1 = h * 3 / 20
    wujcxy(xw1, yw1, rw1)
    #
    xw2 = x + w / 3
    xw3 = x + w * 12 / 30
    yw2 = y - h * 1 / 10
    yw3 = y - h * 1 / 5
    yw4 = y - h * 7 / 20
    yw5 = y - h * 9 / 20
    rw2 = h / 20

    wujcxy(xw2, yw2, rw2)
    wujcxy(xw3, yw3, rw2)
    wujcxy(xw3, yw4, rw2)
    wujcxy(xw2, yw5, rw2)


china(0, 0)

// 作业 7
// 实现一个函数画法国国旗
// france(x, y)

提示:
法国国旗由三个纵向矩形组成, 依次画出这三个矩形

分步提示:

1. 计算出三个矩形的宽, 均为 1/3 * w
2. 计算出三个矩形的左上角坐标, 分别为 x1, y1、x2, y2 和 x3, y3
3. 调用三次 rect 函数, 每次传入不一样的参数

def france(x, y):
    w = 300
    h = 200

    w1 = w / 3
    x1 = x
    x2 = x1 + w1
    x3 = x2 + w1

    rect(x1, y, w1, h)
    rect(x2, y, w1, h)
    rect(x3, y, w1, h)


france(0, 0)

// 作业 8
// 画德国国旗
// germany(x, y)

提示:
德国国旗由三个横向矩形组成, 依次画出这三个矩形

分步提示:

1. 计算出三个矩形的高, 均为 1/3 * h
2. 计算出三个矩形的左上角坐标, 分别为 x1, y1、x2, y2 和 x3, y3
3. 调用三次 rect 函数, 每次传入不一样的参数

def germany(x, y):
    w = 300
    h = 200

    h1 = h / 3
    y1 = y
    y2 = y1 - h1
    y3 = y2 - h1

    rect(x, y1, w, h1)
    rect(x, y2, w, h1)
    rect(x, y3, w, h1)


germany(0, 0)

// 作业 9
// 画 冈比亚国旗
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

五、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！