devbox
数据挖掘灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python快速入门，看这一篇就够了！_livecode for python

作者：数据挖掘灵魂 | 2024-01-31 21:33:40

赞

踩

livecode for python

大家好，我是蛋糕，我最近在看一些人工智能相关的东西，大部分相关的框架，都是用Python写的。

蛋糕会用Python，但谈不上多熟练，最近准备拿Python作为自己的第二语言，那么这期我们来一起快速梳理一下Python基础。

Python简介

Python是一门解释性编程语言，既年长又年轻的语言，它诞生于1989年，近些年，人工智能的复兴，给它注入了新的活力。

Python之父

“Python”的中文翻译“蟒蛇”，因为Python之父Guido van Rossum，就是这位头发浓密的大叔，喜欢蟒蛇。

Python的主流版本又分为2.X和3.X，2.X已经停止维护，目前Python已经发布到了3.11.2版本。

环境准备

我们来看一下在Windows环境下Python的安装。

  • 从官网下载Python，版本我们选择3.9.6：https://www.python.org/ftp/python/3.9.6/python-3.9.6-amd64.exe

Python下载

  • 下载完成之后就可以安装了，安装过程选择Add Pytyon 3.9 to PATH,这样就可以在任意路径使用Python了，同时也可以自定义一下Python的安装路径，我一般都是安装在D盘。

Python安装
  • Win+R打开命令行界面，输入Python，会显示Python的版本号，至此Pytyon安装就已经完成，并且打开了Python Shell。

Python版本

  • 我们还默认安装了一个重要的工具——pip，它是Python的包管理工具，类似Java的Maven、Node的npm，在命令行界面输入pip -V，可以看到pid的版本：

pip

编辑器准备

Python提供了交互式运行工具Python Shell，直接输入一行代码：

 print('Hello World.')

  • 1

万物之始：Hello World.

打印输出

当然，日常开发肯定不会使用这种交互式的方式，而是使用文件的方式，那么Python文件的编辑器一般使用什么呢？

Python因为是解释性语言，可选的编辑器有很多：Pycharm、Jupyter、Sbulime Text、VSCode……

功能最强大的肯定是Pycharm，但是因为占内存，最重要的是得花钱，所以我一般用VSCode。

  • VSCode的安装就不多说，直接下载安装就可以了

  • 为了更好地利用VSCode开发Python，推荐安装一些插件：

Python Snippets

  1. Python：VS Code官方自带插件

Python extension for Visual Studio Code

  1. LiveCode for python：可以实时显示每一个变量值

LiveCode for python

  1. Sourcery：可以自动审查和改进代码

Sourcery

  1. IntelliCode：官方提供的AI辅助开发插件，提供比较充分的代码提示

IntelliCode

  1. Python Indent：更好地进行Python代码的缩进

Python Indent

  1. Python Test Explorer：可视化代码测试

Python Test Explorer
  1. Python Snippets：自动补全代码片段

还有其它的一些好用的插件，大家可以自行探索—— 如果有的选，建议Pycharm。

我们来简单体验一下VSCode编写Python代码：

  • 创建文件夹python-demo

创建文件夹
  • 使用VSCode打开文件夹，新建文件hello.py

hello.py
  • 编写代码
print('Hello World.')  

  • 1
  • 可以直接在右上角点击运行

运行

至此，Python开发环境就已经准备好了，那么我们开始学习Python基础语法。

入门

基本命令

Python是一门非常简单的语言，我们前面的print就是非常简单的打印操作。

Python是一门解释性语言，有点类似shell，对缩进要求比较严格，以Tab键或者4个空格进行缩进。

例如，这一段代码就有语法错误：

语法错误

需要改成：

正确缩进

Python的注释，使用#：

注释

在VSCode里可以使用快捷键Ctrl+/快速注释：

快速注释

数据类型

Python是一种面向对象的编程语言，所有的数据类型都是类，每个数据值都是类的“实例”，并且不需要显式声明变量的类型。

在Python中有6种主要的内置数据类型：数字（Number）、字符串（string）、列表（list）、元组（tuple）、集合（set）和字典（dict）。

数字（Number）

Python中常用的数字类型有两种：整数(int)、浮点(float)。

我们在Python Shell里进行一些数字的操作：

  • 定义和输出
\>>> num=1  
\>>> print(num)  
1  

  • 1
  • 2
  • 3
  • +,-,*,/,%,//,
\>\>> 2+2  
4  
\>\>> 60+3\*2  
66  
\>\>> 36/2  
18.0  
\>\>> 33%10  
3     
\>\>> (66-30)\*2/4  
18.0  
\>\>> 19//3  
6  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

其中/会永远返回浮点数float，Python只支持双精度的浮点数float，返回int需要用//

  • int和float转换
\>\>> int\_num=int(8.8)  
\>\>> print(int\_num)  
8  

  • 1
  • 2
  • 3

Python 支持其他类型的数字，例如Decimal and Fraction。Python 还内置了对复数（complex）的支持，当然，用的也不多。

字符串（string）

字符串是最常用的数据类型，它可以放在单引号''里，也可以放在双引号“”里。

\>\>> 'Good man'  
'Good man'  
\>\>> "Good man"  
'Good man'  

  • 1
  • 2
  • 3
  • 4
  • 字符串连接可以直接使用+
\>\>> "Python is"+"good"  
'Python isgood'  

  • 1
  • 2
  • 如果字符串本身包含单引号''或者双引号“”，可以使用转义符\
\>\>> "I say:\\"Python is good\\"."  
'I say:"Python is good".'  

  • 1
  • 2
  • 字符串可以和数字相互转化，字符串转数字可以用int()或float()，数字转字符串可以用str()
\>\>> int("666")  
666  
\>\>> float("66.6")  
66.6  
\>\>> str(888)  
'888'  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 字符串支持下标访问，包括正向索引（正数），和反向索引（负数）
\>\>> str="The world is so greate."  
\>\>> str\[5\]  
'o'  
\>\>> str\[-2\]  
'e'  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 字符串使用find()查找，replace()替换，split()切割
\>\>> str="There is a hard people."  
\>\>> str.find('hard')  
11  
\>\>> str.replace(' ','|')     
'There|is|a|hard|people.'  
\>\>> str.split('|')  
\['There is a hard people.'\]  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

列表（list）

线性表这种数据结构我们都比较熟悉，Python中的实现是list，类似于Java中的ArrayList，list中可以放入任意类型的变量：

\>\>> list1=\["Python","Good","Study"\]  
\>\>> list2=\[1,2,3,4,5\]  
\>\>> list3=\["Python",4,"is",12.3,"Good"\]  

  • 1
  • 2
  • 3
  • 元素可以直接通过下标访问：
\>\>> list1\[2\]   
'Study'  

  • 1
  • 2
  • 通过append()方法添加元素
\>\>> list1.append("World")  
\>\>> print(list1)  
\['Python', 'Good', 'Study', 'World'\]  

  • 1
  • 2
  • 3
  • 通过insert(i，x)方法在指定位置 插入元素
\>\>> list1.insert(1,"Should")  
\>\>> print(list1)  
\['Python', 'Should', 'Good', 'Study'\]  

  • 1
  • 2
  • 3
  • 替换元素，可以直接list[i]=x
\>>> list=\[60,80,30,70\]   
\>>> list\[2\]=90  
\>>> print(list)  
\[60, 80, 90, 70\]  

  • 1
  • 2
  • 3
  • 4
  • 删除元素，使用remove(x)方法
\>\>> list.remove(60)  
\>\>> print(list)  
\[80, 90, 70\]  

  • 1
  • 2
  • 3

元组（tuple）

列表（list）是一种可变的序列类型，元组（tuple）是一种不可变的序列类型，由多个用逗号隔开的值组成：

\>\>> t=1314,"love",3,666  
\>\>> t\[0\]  
1314  
\>\>> t  
(1314, 'love', 3, 666)  

  • 1
  • 2
  • 3
  • 4
  • 5

集合（set）

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据，类似于Java中的Set。

\>\>> set\={50,50,60,90,70,60}  
\>\>> print(set)  
{50, 60, 90, 70}  

  • 1
  • 2
  • 3
  • 集合的添加用add()，删除用remove()
\>\>> set.add(100)  
\>\>> set.remove(50)  
\>\>> print(set)  
{100, 70, 90, 60}  

  • 1
  • 2
  • 3
  • 4

字典（dict）

字典（dict）是一种key，value类型的数据结构，类似于Java中的Map。

\>\>> tel = {'jack': 4098, 'sape': 4139}  
\>\>> print(tel)  
{'jack': 4098, 'sape': 4139}  

  • 1
  • 2
  • 3
  • 可以直接根据key找到value
\>\>> tel\['jack'\]  
4098  

  • 1
  • 2
  • 添加和更新元素都可以直接通过key
\>\>> tel\['Tommy'\]=9876  
\>\>> tel\['sape'\]=5925   
\>\>> print(tel)  
{'jack': 4098, 'sape': 5925, 'Tommy': 9876}  

  • 1
  • 2
  • 3
  • 4
  • 使用pop()删除元素
\>\>> tel.pop('Tommy')  
9876  
\>\>> print(tel)  
{'jack': 4098, 'sape': 5925}  

  • 1
  • 2
  • 3
  • 4

好了，基本的数据结构我们都盘点完了，还有一些api，这里没有给出，建议大家可以直接查看api doc。

doc

流程控制

每个语言里都有条件语句、循环语句等等流程控制语句，我们来看看Python中的条件语句和循环语句。

条件语句

if语句
# 从控制台获取输入  
score=int(input("请输入你的分数："))  
  
if score>=90:  
    print("优秀")    
if score>=80 and score<90:  
    print("良好")   
if score>=60 and score<80:  
    print("及格")        
if score<60:  
    print("不及格")  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果：

运行结果

在Python里，有三种逻辑运算符：

  • not：逻辑非

  • and：逻辑与

  • or：逻辑或

其中and和or都是短路运算。

if-else
# 从控制台获取输入  
score=int(input("请输入你的分数："))  
  
if score>=60:  
    print('及格')  
else:  
    print("不及格")  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
if-elif-else
# 从控制台获取输入  
score=int(input("请输入你的分数："))  
  
if score>=90:  
    print("优秀")    
elif score>=80:  
    print("良好")   
elif score>=60:  
    print("及格")        
else:  
    print("不及格") 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

循环语句

Python支持两种循环语句：while和for。

while
i=0  
sum=0  
  
# 0到100的总和  
while i<100:  
  sum+=i  
  i+=1  
     
print(sum) 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
for

Python中的for比较特殊，只能迭代列表、字符串等任意序列，不能迭代算数递增值，或者定义结束条件。

names=\['张三','李四','王五','赵六'\]  
  
for name in names:  
  print(name)  

  • 1
  • 2
  • 3
  • 4

运行结果：

for

如果想对数字序列进行迭代呢？那就得用到range()函数：

for i in range(6):  
  print(i)  

  • 1
  • 2

如果想要跳出循环，或者跳过本次循环呢？

break/continue

  • break：break用于跳出 for 或 while 循环

    for i in range(10):  
    if i>3:  
        #跳出循环  
        break  
    print(i)  

    • 1
    • 2
    • 3
    • 4
    • 5

  • continue：continue用于结束本次循环

    for i in range(10):  
    if i%2==0:  
        #跳出本次循环  
        continue  
    print(i)  

    • 1
    • 2
    • 3
    • 4
    • 5
容器类型循环

一些集合类型的循环，比如列表、字典，还是非常常用的。

列表循环

  • for循环列表

    nums=[1,3,5,7,9]  
  
for i in nums:  
    print(i)  

    • 1
    • 2
    • 3
    • 4

  • while循环，根据下标循环list，和string遍历基本一样

    nums=[1,3,5,7,9]  
  
len=len(nums)  
i=0  
  
while i<len:  
    print(nums[i])  
    i=i+1;  

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

  • 用enumerate() 函数可以同时取出位置索引和对应的值：

    persons=['张三','李四','王五']  
  
for i,v in enumerate(persons):  
    print(i,v)  

    • 1
    • 2
    • 3
    • 4
字典遍历

字典是<key,value>类型的结构，遍历和序列结构有一些不一样

  • items()遍历：可以同时取出键和对应的值

    person_dict={'张三':26,'李四':22,'王五':33}  
  
# 遍历字典中的元素  
for k,v in person_dict.items():  
    print(k,v)  

    • 1
    • 2
    • 3
    • 4
    • 5

  • 遍历keys：可以用keys()函数，当然不用也可以

    person_dict={'张三':26,'李四':22,'王五':33}  
  
# 遍历keys  
for k in person_dict.keys():  
   print(k,person_dict[k])   
  
# 不用keys()也可以     
for k in person_dict:  
   print(k,person_dict[k]) 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

  • 遍历values：用values()函数可以直接遍历values

    person_dict={'张三':26,'李四':22,'王五':33}  
  
# 遍历values  
for v in person_dict.values():  
   print(v)  


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

函数

我们在写代码的过程中，有很多重复的逻辑，这时候就应该考虑复用这些逻辑，那么就应该定义一些函数（Functions）。

比如下面一段代码，创建一个函数，计算长方形的面积：

# 定义函数，计算长方形面积  
def get\_area(height,width):  
    area=height\*width  
    return area  
  
# 调用函数：实参顺序和形参一致  
area=get\_area(12,8)  
print(area)  
  
# 调用函数：直接指定形参，顺序无限制  
area=get\_area(width=9,height=15)  
print(area)  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在这个简单的函数里：

  • def: Python中用def关键字定义函数

  • get_area：函数名

  • height,width:函数的形参

  • area=height*width：函数体

  • return area：函数的返回值

在调用的时候，如果不直接指定形参，那么实参的顺序要和形参一致。

模块

上面我们学习了Python的函数，通过函数我们可以实现很多代码的复用，但是问题来了，所有的函数我们也不能都写在一个文件里，那到后面这个文件就膨胀地不像话了，必须拆分文件。

那么文件拆分后，里面的函数怎么调用呢？这就得用到Python的模块了。

  • 写一个calculate.py，很简单，里面定义一个简单的函数add，这时候calculate.py就可以理解为一个模块

    # 加法  
def add(a,b):  
    return a+b;  

    • 1
    • 2
    • 3

  • 再写一个main.py，导入模块，调用函数

    main.py

    # 导入模块  
import calculate  
  
# 使用模块名调用函数  
print(calculate.add(5,6))  

    • 1
    • 2
    • 3
    • 4
    • 5

    如果模块名太长了，也可以给模块设置别名：

    # 导入模块  
import calculate as cal  
  
# 使用模块名调用函数  
print(cal.add(5,6))  

    • 1
    • 2
    • 3
    • 4
    • 5

    假如模块里定义的函数太多了，而我们只需要用某一个函数，或者某几个函数，怎么办？可以只导入模块中的函数：

    # 导入模块中的函数  
from calculate import add  
  
#使用模块名调用函数  
print(add(5,6))  

    • 1
    • 2
    • 3
    • 4
    • 5

Python中也内置了很多模块，常用的有math、datetime、os等等。

例如，利用datetime获取当前年月：

#导入日期模块  
import datetime  
  
# 获取当前年、月  
def get\_year\_and\_month():  
    now = datetime.datetime.now()  
    year=now.year  
    month=now.month  
    return year,month  
  
year,month=get\_year\_and\_month();  
print(f'{year}:{month}')  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

更多的标准库，可以直接查看官方的api文档。

面向对象

Python是一门面向对象的语言，面向对象是为了更好地复用代码，接下里，我们看看面向对象的三大特征：封装、继承、多态在Python里是怎么实现的。

类和对象

所谓类就是某个类型，比如人类，所谓对象，就是类的实例，比如张三。

class Person:  
      
def say\_hello(n):  
    print('你好')  
  
zhansan=Person()  
zhansan.say\_hello() 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

这段代码里定义了一个类Person，类里定义了一个方法say_hello，实例化了一个对象zhangsan，调用了方法。

类里可以有这些成员：

类的成员 
class Person:  
    # 类变量  
    planet='地球'  
      
    # 构造方法，初始化成员变量  
    def \_\_init\_\_(self,name,sex,age):  
        # 成员变量：姓名，性别，年龄  
        self.name=name  
        self.sex=sex  
        self.age=age  
      
    # 实例方法，使用成员变量       
    def say\_hello(self):  
       print(f'{self.name}:你好')  
         
    #类方法  
    @classmethod  
    def breath(cls):  
        print('人需要呼吸')    
  
# 使用构造方法实例化对象并赋值          
zhansan=Person(name='张三',sex='男',age=22)  
# 调用实例方法  
zhansan.say\_hello()     
# 调用类方法  
Person.breath() 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

在类中：

  • 成员变量也被称为数据成员，类变量属于类，实例变量属于实例。

  • 构造方法用于初始化类的成员变量。

  • 成员方法是在类中定义的函数，包含类方法和实例方法。

我们接下来，看看面向对象的三大特征在Python里是怎么实现的。

封装/继承/多态

封装

封装就是隐藏对象的内部细节，外部只管调用就行了。

Python中的变量默认是公开的，可以在外部的类中访问它们，如果想让它们变为私有变量，在变量前加上双双下画线（__）就行了，变量的获取和设置可以通过get()、set()方法。

class Programer:  
      
    # 构造方法，初始化成员变量  
    def \_\_init\_\_(self,name):  
        # 创建初始化实例变量：姓名  
        self.name=name  
        # 创建和初始化私有实例变量：\_level  
        self.\_level=''  
      
    # 实例方法    
    def write\_bug(self):  
        print(self.\_level+self.name+'正在写bug中。。')  
          
    # get方法  
    def get\_level(self):  
        return self.\_level  
      
    # get方法  
    def set\_level(self,level):  
        self.\_level=level  
        
# 实例化  
programer =Programer('张三')   
# 设置私有变量  
programer.set\_level('高级工程师')   
# 调用成员方法    
programer.write\_bug()   
# 使用get方法获取私有变量    
print(programer.get\_level()) 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
继承

我们现在让Programer继承Person，继承语法很简单，在类后()里指定继承的类就行了，可以一个，也可以多个。

from Person import Person  
  
  
# 继承Person  
class Programer(Person):  
      
    # 构造方法，初始化成员变量  
    def \_\_init\_\_(self,name):  
        # 创建初始化实例变量：姓名  
        self.name=name  
        # 创建和初始化私有实例变量：\_level  
        self.\_level=''  
      
    # 实例方法    
    def write\_bug(self):  
        print(self.\_level+self.name+'正在写bug中。。')  
          
    # get方法  
    def get\_level(self):  
        return self.\_level  
      
    # get方法  
    def set\_level(self,level):  
        self.\_level=level  
        
# 实例化  
programer =Programer('张三')   
# 设置私有变量  
programer.set\_level('高级工程师')   
# 调用成员方法    
programer.write\_bug()   
# 使用get方法获取私有变量    
print(programer.get\_level())      
  
# 调用父类方法  
programer. say\_hello() 


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
多态

Python同样支持多态，对于继承，实现多态的方式，就是重写父类的方法：

from Person import Person  
  
  
# 继承Person  
class Programer(Person):  
      
    # 构造方法，初始化成员变量  
    def \_\_init\_\_(self,name):  
        # 创建初始化实例变量：姓名  
        self.name=name  
        # 创建和初始化私有实例变量：\_level  
        self.\_level=''  
      
    # 实例方法    
    def write\_bug(self):  
        print(self.\_level+self.name+'正在写bug中。。')  
          
    # get方法  
    def get\_level(self):  
        return self.\_level  
      
    # get方法  
    def set\_level(self,level):  
        self.\_level=level  
          
    # 重写父类方法  
    def say\_hello(self):  
        print(f"一介开发{self.name}向您问好！")     
  
        
# 实例化  
programer =Programer('张三')   
# 设置私有变量  
programer.set\_level('高级工程师')   
# 调用成员方法    
programer.write\_bug()   
# 使用get方法获取私有变量    
print(programer.get\_level())      
  
# 调用重写了的父类方法  
programer. say\_hello()  


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

异常处理

对于开发工程师而言，日常最苦恼的事情大概就是写bug和找bug了。

有些时候，我们不希望因为某些错误，导致整个程序停止，那么我们就可以利用try/except语句来捕获异常。

比如下面的代码，用5/0：

num=5/0  

  • 1

结果就发生了异常：

ZeroDivisionError: division by zero  

  • 1

我们可以捕获这个异常：

try:  
    num=5/0  
except Exception as e:  
    print(e)    

  • 1
  • 2
  • 3
  • 4

在这段代码里，我们捕获了异常，并把它打印了出来，我们也可以用pass空语句，不对异常做任何处理：

try:  
    num=5/0  
except Exception as e:  
    pass 

  • 1
  • 2
  • 3
  • 4

我们还可以使用finally子句，定义所有情况下都必须执行的操作：

try:  
    num=5/0  
except Exception as e:  
    print(e)  
finally:  
    print('end')  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

小结

这一篇几千字的小文章到此就结束了，在这篇文章里，我们快速过了一遍Python环境的搭建，以及各种基础语法，包括数据类型、流程控制语句、函数、模块、面向对象、异常处理。

大家可以看到，Python是一门相对比较好上手的语言，我有个同事这么说——“Python有什么好学的，看看不就会了”。虽然他有吹的成分，但也可以看到，如果有一些编程语言基础，Python上手还是比较简单的。

我们可以先掌握Python基础，把它用起来，用的过程中，再通过文档、搜索引擎、ChatGPT等等，不断加深对细节的掌握。

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。我收藏了很多技术干货，可以共享给喜欢我文章的朋友们，如果你肯花时间沉下心去学习，它们一定能帮到你，干货内容包括：

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

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

在这里插入图片描述

二、学习软件

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

在这里插入图片描述

三、入门学习视频

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

在这里插入图片描述

在这里插入图片描述

四、实战案例

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

在这里插入图片描述

五、100道Python练习题

检查学习结果。

在这里插入图片描述

六、面试资料

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


​​在这里插入图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/52250
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。