来源：三分恶

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

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

起步

Python简介

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

“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

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

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

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

编辑器准备

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

 print(Hello World.

)

万物之始：Hello World.

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

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

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

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

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

Python：VS Code官方自带插件

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

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

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

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

Python Test Explorer：可视化代码测试

Python Snippets：自动补全代码片段

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

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

创建文件夹python-demo使用VSCode打开文件夹，新建文件hello.py编写代码print(Hello World.

)

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

至此，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+,-,*,/,%,//,>>> 2+2

4

>>> 60+3*2

66

>>> 36/2

18.0

>>> 33%10

3   

>>> (66-30)*2/4

18.0

>>> 19//3

6

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

int和float转换>>> int_num=int(8.8)>>> print(int_num)

8

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

字符串（string）

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

>>> Good man

Good man

>>> "Good man"

Good man

字符串连接可以直接使用+>>> "Python is"+"good"

Python isgood

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

I say:"Python is good".

字符串可以和数字相互转化，字符串转数字可以用int()或float()，数字转字符串可以用str()>>> int("666")

666

>>> float("66.6")

66.6

>>> str(888)

888

字符串支持下标访问，包括正向索引（正数），和反向索引（负数）>>> str="The world is so greate.">>> str[5]

o

>>> str[-2]

e

字符串使用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.]

列表（list）

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

>>> list1=["Python","Good","Study"]>>> list2=[1,2,3,4,5]>>> list3=["Python",4,"is",12.3,"Good"]元素可以直接通过下标访问：>>> list1[2] 

Study

通过append()方法添加元素>>> list1.append("World")>>> print(list1)

[Python, Good, Study, World]

通过insert(i，x)方法在指定位置 插入元素>>> list1.insert(1,"Should")>>> print(list1)

[Python, Should, Good, Study]

替换元素，可以直接list[i]=x>>> list=[60,80,30,70

] 

>>> list[2]=90>>> 

print(list)

[60, 80, 90, 70

]

删除元素，使用remove(x)方法>>> list.remove(60)>>> print(list)

[80, 90, 70]

元组（tuple）

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

>>> t=1314,"love",3,666>>> t[0]

1314

>>> t

(1314, love, 3, 666)

集合（set）

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

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

{50, 60, 90, 70}

集合的添加用add()，删除用remove()>>> set.add(100)>>> set.remove(50)>>> print(set)

{100, 70, 90, 60}

字典（dict）

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

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

{jack: 4098, sape: 4139}

可以直接根据key找到value>>> tel[jack]

4098

添加和更新元素都可以直接通过key>>> tel[Tommy]=9876>>> tel[sape]=5925 >>> print(tel)

{jack: 4098, sape: 5925, Tommy: 9876}

使用pop()删除元素>>> tel.pop(Tommy)

9876

>>> print(tel)

{jack: 4098, sape: 5925}

好了，基本的数据结构我们都盘点完了，还有一些api，这里没有给出，建议大家可以直接查看api 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("不及格"

)  

运行结果：

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

not：逻辑非and：逻辑与or：逻辑或

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

if-else# 从控制台获取输入score=int(input("请输入你的分数："

))

if score>=60

:

    print(及格

)

else

:

    print("不及格"

)  

if-elif-else# 从控制台获取输入score=int(input("请输入你的分数："

))

if score>=90

:

    print("优秀"

)  

elif score>=80

:

    print("良好"

) 

elif score>=60

:

    print("及格"

)      

else

:

    print("不及格"

) 

循环语句

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

whilei=0sum=0# 0到100的总和while i<100

:

  sum+=i

  i+=1

print(sum) 

for

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

names=[张三,李四,王五,赵六

]

for name in

 names:

  print(name)

运行结果：

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

for i in range(6

):

  print(i)

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

break/continue

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

for i in range(10

):

    if i>3

:

        #跳出循环        break

    print(i)

continue：continue用于结束本次循环

for i in range(10

):

    if i%2==0

:

        #跳出本次循环        continue

    print(i)

容器类型循环

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

列表循环

for循环列表

nums=[1,3,5,7,9

]

for i in

 nums:

    print(i)

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

nums=[1,3,5,7,9

]

len=len(nums)

i=0while

 i

    print(nums[i])

    i=i+1

;

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

persons=[张三,李四,王五

]

for i,v in

 enumerate(persons):

    print(i,v)

字典遍历

字典是

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

person_dict={张三:26,李四:22,王五:33

}

# 遍历字典中的元素for k,v in

 person_dict.items():

    print(k,v)

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

person_dict={张三:26,李四:22,王五:33

}

# 遍历keysfor k in

 person_dict.keys():

   print(k,person_dict[k]) 

# 不用keys()也可以   for k in

 person_dict:

   print(k,person_dict[k]) 

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

person_dict={张三:26,李四:22,王五:33

}

# 遍历valuesfor v in

 person_dict.values():

   print(v)

函数

我们在写代码的过程中，有很多重复的逻辑，这时候就应该考虑复用这些逻辑，那么就应该定义一些函数（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)

在这个简单的函数里：

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;

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

# 导入模块import

 calculate

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

))

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

# 导入模块import calculate as

 cal

# 使用模块名调用函数print(cal.add(5,6

))

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

# 导入模块中的函数from calculate import

 add

#使用模块名调用函数print(add(5,6

))

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}

)

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

面向对象

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

类和对象

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

class Person:def say_hello(n):    print(你好

)

zhansan=Person()

zhansan.say_hello() 

这段代码里定义了一个类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() 

在类中：

成员变量也被称为数据成员，类变量属于类，实例变量属于实例。构造方法用于初始化类的成员变量。成员方法是在类中定义的函数，包含类方法和实例方法。

我们接下来，看看面向对象的三大特征在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()) 

继承

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

from Person import

 Person

# 继承Personclass 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() 

多态

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

from Person import

 Person

# 继承Personclass 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()  

异常处理

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

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

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

num=5/0

结果就发生了异常：

ZeroDivisionError: division by zero

我们可以捕获这个异常：

try

:

    num=5/0except Exception as

 e:

    print(e)    

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

try

:

    num=5/0except Exception as

 e:

    pass

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

try

:

    num=5/0except Exception as

 e:

    print(e)

finally

:

    print(end

)  

小结

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

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

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

参考：[1].  《Python网络爬虫从入门到实践》[2].https://docs.python.org/3/[3].https://www.jkxuexi.com/resources/191.html[4].《看漫画学Python》