前言

学无止境，无止境学。大家好，我是张大鹏，之前在抖音有5万多粉丝，不过现在不拍视频，专心写公众号了。笔者目前是高级Python工程师，之前是全栈工程师，主要擅长Golang和Python开发，对于Java，Vue，React也有一些研究。工作之余，喜欢学习和分享，希望能够通过此公众号”张大鹏520″，将自己学到的东西分享给大家，和大家一起交流，一起成长，一起进步。

今天要给大家分享的是《Python零基础入门教程01 快速入门》，这是一个系列的教程，从零基础到项目实战。在本教程中，我会给大家介绍Python入门的一些基础知识。比如注释，变量，数据类型，输入输出等。还会配套相关的练习，大家学完以后可以自行通过练习题巩固和加深对知识点的理解。

如果大家需要本教程的PDF电子书或者完整的源码，可以在文末找到获取方式哈。

01 Python简介

Python介绍

Python是时下最流行,最火爆的编程语言之一,具体原因如下:

简单,易学,适应人群广泛
免费,开源
应用领域广泛

Python的适用人群:

Python的应用领域:

Python解释器

解释器用于运行Python文件,如果没有解释器,我们编写的代码就无法运行.常见的Python解释器如下:

CPython,C语言开发的官方解释器,也是我们学习使用的解释器
IPython,基于CPython的一种交互式解释器
PyPy,基于Python的解释器,比官方解释器要快很多

Python解释器下载地址: https://www.python.org/downloads/release/python-372/

Pycharm

Pycharm是一种Python集成开发环境,能够提高Python的开发效率,具备以下功能:

项目管理
智能提示
语法管理
代码调试
代码运行
其他

pycharm分为专业版和社区版，社区版免费使用，专业版需要收费。

pycharm下载地址: https://www.jetbrains.com/pycharm/download/#section=windows

02 注释

注释是给程序员看的, 不会被程序执行.

Python中的注释可以分为:

单行注释: 以#号开头的一行字符串
多行注释: 包裹在三个单引号‘’‘或者三个双引号“""中间的字符串

示例代码:

# 单行：输出hello world
print('hello world')

print('hello Python')  # 简单注释内容

# 单行注释

"""
第一行注释
第二行注释
第三行注释
"""

'''
注释1
注释2
注释3
'''

多写注释是一个良好的习惯, 优秀的人对自己的代码负责, 也对阅读代码的人负责.

03 变量

什么是变量

变量是程序运行过程中，用来存在在内存中计算需要用到的数据的标识符。

变量非常的重要，程序中充斥着各种各样的变量，几乎只要有程序的地方，就需要用到变量。

变量是一个标识符，记录一个内存地址，是这个内存地址的名字。真实的数据是存储在内存中的，变量是对这个内存地址的引用。

如何定义变量

Python中定义变量非常的简单，不需要声明变量的类型。语法如下：

变量名 = 值

如何使用变量

变量可以用来参与运算，比如：

num = 33
result = num * 33

变量可以直接用print打印，比如：

name = '张大鹏'
print(f"我的名字是：{name}")

如何修改变量

变量最大的特点就是可以修改，其值随时会可能发生变化。

那么如何修改变量呢？

# 先定义变量
num = 33
print(num)

# 程序运行过程中动态修改变量
print("执行了某段逻辑代码")
num = 333
print("num的值被修改了：", num)

访问没有事先定义的变量会报错

在大部分语言中都会有这个特点，访问不存在的变量会报错。不过少部分语言中，访问不存在的变量会打印一个空值。

Python属于前者。比如，我们访问一个不存在的变量age，程序会报错：

name = '张大鹏'
print(f"我的名字是{name}, 我{age}岁了。")

错误信息如下：

NameError                                 Traceback (most recent call last)
Input In [2], in <cell line: 1>()
----> 1 print(f"我的名字是{name}, 我{age}岁了。")

NameError: name 'age' is not defined

核心的错误信息是：

NameError: name 'age' is not defined

可以稍微留意一下这个错误类型，叫做NameError，随着深入的学习，还会有很多其他的错误类型。关于异常的处理，也是Python基础知识中非常重要的一个点。

变量名的规范

在编写程序的时候，我们通常需要定义变量，关于变量名，是不能随心所欲的，尽量遵循以下规范：

变量名不能以数字开头
变量名不能是系统关键字，比如def，if，for，while等
变量名最好见名知意，由有意义的英文单词组成，多个单词之间用下划线分割，比如：student_name
常量名建议全大写，由下划线分割多个单词，比如：PI，THREAD_NUM

04 数据类型

常见的数据类型

Python中有非常多的数据类型，常用的如下：

整数类型：int
浮点数类型：float
字符串类型：str
布尔类型：bool
列表类型：list
元组类型：tuple
字典类型：dict
集合类型：set

整数类型

整数类型包括负整数，0和正整数，这个和数学上的定义差不多。

Python中定义一个变量是不需要指定数据类型的，Python的解释器会自动帮我们根据变量的值推断变量的类型。

所以，要定义整数类型就比较简单了，如下：

num1 = -1 # 负整数
num2 = 0 # 0
num3 = 1 # 正整数

变量定义以后，我们可以通过type函数来查看变量的数据类型，确认其符合我们的预期。

比如：

print(type(num1))
print(type(num2))
print(type(num3))

在ipython中，可以不使用print函数，直接调用type就能够查看到数据的类型：

type(num1)
type(num2)
type(num2)

输出结果如下：

In [4]: type(num1)
Out[4]: int

In [5]: type(num2)
Out[5]: int

In [6]: type(num3)
Out[6]: int

浮点数类型

浮点数类型就是数学中的小数类型。浮点数包括负小数，0和正小数。

需要注意的是，0在大部分情况下，都属于整数，只有在和浮点数参与运算的时候，才转换为浮点数。

所以，0可以归纳为整数，但是也可以在绝大部分情况下作为浮点数使用。

如果要显示的声明0为浮点数，则使用0.0，0.，.0来赋值。

定义三个浮点数：

num1 = -1.0 # 负小数
num2 = 0.0 # 0
num3 = 1.0 # 正小数

查看三个浮点数的类型：

print(type(num1))
print(type(num2))
print(type(num3))

在ipython中，可以省略print：

type(num1)
type(num2)
type(num2)

输出结果如下：

In [7]: num1 = -1.0 # 负小数
   ...: num2 = 0.0 # 0
   ...: num3 = 1.0 # 正小数

In [8]: type(num1)
Out[8]: float

In [9]: type(num2)
Out[9]: float

In [10]: type(num3)
Out[10]: float

字符串类型

字符串是几乎所有编程语言中最常见的一种数据类型。

在Python中，要定义一个字符串，有很多种方式，比较特殊。

常见的定义字符串类型的方式如下：

name1 = '张大鹏'
name2 = "张大鹏"
name3 = """张大鹏"""
name4 = '''张大鹏'''

同样地，我们可以用type查看变量的类型：

print(type(name1))
print(type(name2))
print(type(name3))
print(type(name4))

完整代码如下：

name1 = '张大鹏'
name2 = "张大鹏"
name3 = """张大鹏"""
name4 = '''张大鹏'''

print(name1, "name1的类型是：", type(name1))
print(name2, "name2的类型是：", type(name2))
print(name3, "name3的类型是：", type(name3))
print(name4, "name4的类型是：", type(name4))

输出结果如下：

张大鹏 name1的类型是： <class 'str'>
张大鹏 name2的类型是： <class 'str'>
张大鹏 name3的类型是： <class 'str'>
张大鹏 name4的类型是： <class 'str'>

布尔类型

布尔类型是一种非常特殊的类型，它只有两个值，True和False。

这里需要注意一下，其他大部分语言中，True和False都是全小写的，只有Python是首字母大写的。

定义布尔类型的变量：

flag1 = True
flag2 = False

查看变量的类型：

print(type(flag1))
print(type(flag2))

完整代码如下：

flag1 = True
flag2 = False


t1 = type(flag1)
t2 = type(flag2)

print(f"flag1的值是:{flag1}，flag1的类型是：{t1}")
print(f"flag2的值是:{flag2}，flag2的类型是：{t2}")

输出结果如下：

flag1的值是:True，flag1的类型是：<class 'bool'>
flag2的值是:False，flag2的类型是：<class 'bool'>

list列表类型

列表类型类似于C和Java中的数组类型，都是用来存储一段有序且连续的数据的。

不同的是，Python的列表可以存储不同类型的数据，支持通过切片的方式获取数据，也没有固定长度的约束。

简单的说，Python的列表更加的灵活和强大，更像是其他语言中”动态数组”的类型。

定义列表：

# 空列表
num1 = []
num2 = list()

# 有数据的列表
num3 = [1, 2, 3]
num4 = list(range(1,4))

查看列表的数据类型：

print(type(num1))
print(type(num2))
print(type(num3))
print(type(num4))

完整代码如下：

# 空列表
num1 = []
num2 = list()

# 有数据的列表
num3 = [1, 2, 3]
num4 = list(range(1, 4))


print(type(num1))
print(type(num2))
print(type(num3))
print(type(num4))

输出结果如下：

<class 'list'>
<class 'list'>
<class 'list'>
<class 'list'>

tuple元组类型

元组也是有序的容器，和list不同的是，元组的长度是固定的，且元组的元素是不可以增删改的。

元组近似的认为，是一旦定义，就不能再修改的list列表。适合用来传递数据，定义函数的参数，函数的返回值等。

定义元组：

# 空元组
t1 = ()
t2 = tuple()

# 1个元素的元组
t3 = (1,)
t4 = tuple([1])

# 多个元素的元组
t5 = (1, 2, 3)
t6 = tuple(range(1, 4))

# 查看元组的类型
print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))
print(type(t5)

完整代码：

# 空元组
t1 = ()
t2 = tuple()

# 1个元素的元组
t3 = (1,)
t4 = tuple([1])

# 多个元素的元组
t5 = (1, 2, 3)
t6 = tuple(range(1, 4))

# 查看类型
print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))
print(type(t5))
print(type(t6))

输出结果如下：

<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>

set集合类型

集合类型是Python中不怎么常用但是效率极其高效的一种数据类型，特别适合需要去重处理的场景，因为集合具备自动去重的功能。

集合是无序的，适合存储一组相同类型且不重复的元素。

定义集合：

# 空集合
s2 = set()

# 有元素的集合
s3 = {1, 2, 3}
s4 = set(range(1, 4))

查看集合类型：

# 查看类型
print(type(s2))
print(type(s3))
print(type(s4))

完整代码如下：

# 空集合
s2 = set()

# 有元素的集合
s3 = {1, 2, 3}
s4 = set(range(1, 4))

# 查看类型
print(type(s2))
print(type(s3))
print(type(s4))

输出结果如下：

<class 'set'>
<class 'set'>
<class 'set'>

dict字典类型

字典类型也是Python中经常用到的类型，经常和list组合使用。

字典也是无序的，是一种key-value键值对类型。

字典的查询效率非常高，通过key去找value，效率能够达到O(1)，非常的高效。

定义字典：

# 空字典
d1 = {}
d2 = dict()

# 带数据的字典
d3 = {"k1": "v1", "k2": "v2"}
d4 = dict((("k1", "v1"), ("k2", "v2")))

查看类型：

print(type(d1))
print(type(d2))
print(type(d3))
print(type(d4))

完整代码：

# 空字典
d1 = {}
d2 = dict()

# 带数据的字典
d3 = {"k1": "v1", "k2": "v2"}
d4 = dict((("k1", "v1"), ("k2", "v2")))

# 查看类型
print(type(d1))
print(type(d2))
print(type(d3))
print(type(d4))

输出结果：

<class 'dict'>
<class 'dict'>
<class 'dict'>
<class 'dict'>

综合案例

# int -- 整型
num1 = 1

# float -- 浮点型，就是小数
num2 = 1.1
print(type(num1))
print(type(num2))

# str -- 字符串，特点：数据都要带引号
a = 'hello world'
print(type(a))

# bool -- 布尔型，通常判断使用，布尔型有两个取值 True 和 False
b = True
print(type(b))


# list -- 列表
c = [10, 20, 30]
print(type(c))

# tuple -- 元组
d = (10, 20, 30)
print(type(d))

# set -- 集合
e = {10, 20, 30}
print(type(e))


# dict -- 字典 -- 键值对
f = {'name': 'TOM', 'age': 18}
print(type(f))

输出结果：

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

05 格式化输出

格式化输出整数

格式化输出整数用%d，一个%d表示一个整数。

示例：

age = 33
print("年龄是：%d岁" % age)

如果要在整数的前面填充字符，比如有时候对于员工编号，想要使用0填充。假设员工1的变化为1，但是员工999的编号为999，直接打印会不好看，这个时候就需要在前面填充0，统一为000001和000999，这种时候可以使用%06d来格式化。这里的6表示总共6位数，不足6位用0填充。

示例：

no1 = 1
no999 = 999

print("员工1的编号是：%06d" % no1)
print("员工999的编号是：%06d" % no999)

格式化输出字符串

格式化输出字符串使用%s，一个%s表示一个字符串。

示例：

name = "张大鹏"
print("我的名字是：%s" % name)

格式化输出小数

格式化输出小数使用%f，如果要指定保留多少位，则使用%.整数f。比如想要保留小数点后的两位，则使用%.2f。

示例：

weight = 88.8
print("体重是：%.2fkg" % weight)

综合案例

age = 18
name = 'TOM'
weight = 75.5
stu_id = 1
stu_id2 = 1000

# 1. 今年我的年龄是x岁 -- 整数 %d
print('今年我的年龄是%d岁' % age)

# 2. 我的名字是x -- 字符串 %s
print('我的名字是%s' % name)


# 3. 我的体重是x公斤 -- 浮点数 %f
print('我的体重是%.3f公斤' % weight)

# 4. 我的学号是x -- %d
print('我的学号是%d' % stu_id)

# 4.1 我的学号是001
print('我的学号是%03d' % stu_id)
print('我的学号是%03d' % stu_id2)


# 5. 我的名字是x，今年x岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 5.1 我的名字是x，明年x岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))


# 6. 我的名字是x，今年x岁了，体重x公斤，学号是x
print('我的名字是%s，今年%d岁了，体重%.2f公斤，学号是%06d' % (name, age, weight, stu_id))

输出结果如下：

今年我的年龄是18岁
我的名字是TOM
我的体重是75.500公斤
我的学号是1
我的学号是001
我的学号是1000
我的名字是TOM，今年18岁了
我的名字是TOM，明年19岁了
我的名字是TOM，今年18岁了，体重75.50公斤，学号是000001

06 转义字符

name = '张大鹏'
age = 22
gender = '男'

# 制表符
print(f'{name}t{age}t{gender}')
print(f'{name}t{age}t{gender}')
print(f'{name}t{age}t{gender}')
print("==============")

# 换行符
print(f'{name}t{age}t{gender}n{name}t{age}t{gender}n{name}t{age}t{gender}')

07 print的结束符

以换行符结束

print函数默认就是以换行符结束，在打印数据以后自动换行。

示例：

a = 11
b = 22
c = 33

print(a)
print(b)
print(c)
print("==================")

# 以下和上面是等价的
print(a, end="n")
print(b, end="n")
print(c, end="n")

其他结束符示例:

print('hello', end="n")
print('world', end="t")
print('hello', end="...")
print('Python')

08 输入

内置函数input

在Python中, 要录入内容, 主要使用input方法. 示例代码如下:

password = input('请输入您的密码：')
print(f'您输入的密码是{password}')

print(type(password))

input函数的语法:

变量 = input('提示信息')

input函数的特点:

遇到input，等待用户输入
接收input存变量
input接收到的数据类型都是字符串

练习1: 输入两个数, 计算这两个数相加的和, 然后输出到控制台

# 输入数据
a = int(input("请输入第一个数: "))
b = int(input("请输入第二个数: "))

# 计算
c = a + b

# 输出
print(f"{a} + {b} = {c}")

09 数据类型转换

快速体验数据类型转换

使用内置函数int可以将其他数据类型转换为整数类型.

语法:

变量 = int(需要转换的变量或数据)

示例: 将字符串类型转换为整数类型

num = input('请输入数字：')
print(num)
print(type(num))  # str

# 查看转换后的类型
print(type(int(num)))  # int

数据类型转换函数

转换为float类型:

num1 = 1
str1 = '10'
print(type(float(num1)))  # float
print(float(num1))  # 1.0

print(float(str1))  # 10.0

转换为字符串类型:

print(type(str(num1)))  # str

转换为元组类型:

list1 = [10, 20, 30]
print(tuple(list1))

转换为列表类型:

t1 = (100, 200, 300)
print(list(t1))

万能的eval，慎用:

str2 = '1'
str3 = '1.1'
str4 = '(1000, 2000, 3000)'
str5 = '[1000, 2000, 3000]'
print(type(eval(str2)))
print(type(eval(str3)))
print(type(eval(str4)))
print(type(eval(str5)))

完整代码:

# 1. float() -- 将数据转换成浮点型
num1 = 1
str1 = '10'
print(type(float(num1)))  # float
print(float(num1))  # 1.0
print(float(str1))  # 10.0


# 2. str() -- 将数据转换成字符串型
print(type(str(num1)))  # str


# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))


# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))


# 5. eval() -- 计算在字符串中的有效Python表达式,并返回一个对象
str2 = '1'
str3 = '1.1'
str4 = '(1000, 2000, 3000)'
str5 = '[1000, 2000, 3000]'
print(type(eval(str2)))
print(type(eval(str3)))
print(type(eval(str4)))
print(type(eval(str5)))