【爆肝更新】第二章：Python基础语法——保姆级，超万字！

超、凢脫俗 2023-10-10 17:27 25阅读 0赞

这一章我们开始学习Python的基础语法，包含字面量，运算符，变量，字符串格式化，input函数等，这一章是为整个Python体系学习打好基础，所以一定要重视起来。

习惯看视频的同学可以看这个免费教程：

[https://www.bilibili.com/video/BV1ZK411Q7uX/?vd\_source=704fe2a34559a0ef859c3225a1fb1b42&wxfid=o7omF0RELrnx5\_fUSp6D59\_9ms3Y][https_www.bilibili.com_video_BV1ZK411Q7uX_vd_source_704fe2a34559a0ef859c3225a1fb1b42_wxfid_o7omF0RELrnx5_fUSp6D59_9ms3Y]

关于本教程的说明，可以看之前的文章：

[我打算写一套基础实用的Python图文教程——这是第一篇][Python]

好，接下来是本章节的内容。

####  ####

### 字面量 ###

学习目标：

*  掌握字面量的含义
 *  了解常见的字面量类型
 *  基于 print 语句完成各种字面量的输出

什么是字面量

在代码中，被写下来的的固定的值，称之为字面量。在Python中，哪些值是可以写出来的呢？字面量分为以下6种类型，见下表：

![a25b8edc46b51713912185aefc4bc54b.png][]

看到这么多类型，你也不要惊慌，在刚开始，我们先重点掌握数字类型。我们在入门阶段主要学习数字类型中的整数、浮点数，以及字符串这3种就可以了。

整数：整数其实和我们数学中的整数是一个意思，比如10或者-10。

浮点数：也就是数学中的小数，比如13.14，或者-13.14。

字符串：指任意数量的字符如中文，英文，数字，符号组成。例如：

*  "黑马程序员"
 *  "学Python来黑马"
 *  "!@\#$%^&"
 *  "传智教育的股票代码是：003032"

注意，我们在 Python 中，字符串需要用双引号包围起来，或者说凡是被双引号包围起来的，都称之为字符串。了解了整数、浮点数以及字符串的含义之后，我们再来看一下这些类型在代码中如何表示。整数、浮点数，程序中的写法和现实生活中的写法是完全一致的，不同的就是字符串了，在程序中写字符串要加上双引号。

####  ####

如何在代码中写字面量

我们目前要学习的这些类型，如何在代码中表达呢？

<table> 
 <tbody> 
 <tr> 
 <th> 类型 </th> 
 <th> 程序中的写法 </th> 
 <th> 说明 </th> 
 </tr> 
 <tr> 
 <td> 整数 </td> 
 <td> 666，-88 </td> 
 <td> 和现实中的写法一致 </td> 
 </tr> 
 <tr> 
 <td> 浮点数（小数） </td> 
 <td> 13.14，-5.21 </td> 
 <td> 和现实中的写法一致 </td> 
 </tr> 
 <tr> 
 <td> 字符串（文本） </td> 
 <td> "黑马程序员" </td> 
 <td> 程序中需要加上双引号来表示字符串 </td> 
 </tr> 
 </tbody> 
</table>

注意：字符串一定要用英文双引号。

现在我想让这3个字面量在屏幕上显示出来，应该如何去做呢？前面我们是不是在学Hello World的时候用过一个print语句呀，接下来用print输出这三种数据类型，打印字符串时，要加上一个英文双引号：

print(666)  
print(13.14)  
print("黑马程序员")

然后点击Pycharm右上角的绿色小箭头，运行一下结果就出来了：

666  
13.14  
黑马程序员

####  ####

### 注释 ###

####  ####

学习目标：

我们需要同学们能够了解注释的作用，以及能够使用单行注释和多行注释。

####  ####

#### 注释的作用 ####

首先我们先来看一下上一小节的代码：

666  
13.14  
"黑马程序员  
print(666)  
print(13.14)  
print("黑马程序员")

未使用注释的代码

"""  
演示：  
\- 各类字面量的写法  
\- 通过print语句输出各类字面量  
"""  
\# 写一个整数字面量  
666  
\# 写一个浮点数字面量  
13.14  
\# 写一个字符串字面量  
"黑马程序员"  
  
\# 通过orint语句输出各类字面量  
print(666)  
print(13.14)  
print("黑马程序员")

使用注释的代码

通过观察同学们应该能够发现，添加了注释的代码，好像看起来更容易理解了，那这也是注释的作用。那么什么是注释呢？

注释：在程序代码中对程序代码进行解释说明的文字。

作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。

####  ####

#### 注释的分类 ####

单行注释：以\#开头，\#右边的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用。

\# 我是单行注释  
print（"Hello World"）

注意，\# 号和注释内容一般建议以一个空格隔开。

规范是一种建议性的要求，而不是强制性的要求。虽然你不遵守也不会影响程序的运行，但我们建议同学们还是遵守一下 Python 的规范，毕竟官方和大厂的代码都在遵守规范，这样也会让我们的代码更高级。这是单行注释的使用方式。多行注释：以 一对三个双引号引起来 ( )来解释说明一段代码的作用使用方法。

"""  
我是多行注释  
诗名：悯农  
作者：李绅  
"""  
  
print（"锄禾日当午"）  
print（"汗滴禾下土"）  
print（"谁知盘中餐"）  
print（"粒粒皆辛苦"）

如上代码显示，我们发现它们还支持换行。这就是多行注释的使用方式。

####  ####

### 变量 ###

####  ####

学习目标：

*  理解变量的作用和特征
 *  并掌握变量的定义方式

变量：在程序运行时，能储存计算结果或能表示值的抽象概念。

简单地说，变量就是在程序运行时，记录数据用的。

我们可以将变量想象成一个盒子，用来记录数据，比如记录一个数字100，或者一个字符串“你好”。

那么变量怎么定义呢？格式 如下：

![c5e3190699d699a90873c7854b0a881b.png][]

简单来说，变量就是用于记录数据的“盒子”，可以存储整数100或字符串“你好”等数据。变量的定义格式很简单，只需要在代码中写上变量名称等于变量的值即可。在Python中，可以定义很多变量，每个变量都有自己的名称（即变量名）和存储的值（即变量值）。等号表示赋值的意思，将等号右侧的值赋给左侧的变量。

了解了变量及其定义格式之后呢，现在我们在Pycharm中操作一下，我们想通过一个变量记录钱包的余额，可以用变量来定义：

money = 50

这个变量是否真的能够存储 50这个数据，那怎么验证呢，我们可以通过 print 语句将它的内容输出出来，我们可以写上print()，并且加上一个逗号，前边或者后边就可以加一个字符串同时输出：

print('钱包:',money)

print语句它的用法是很多的，print语句可以输出非常多份的数据，那么每一份数据我们可以通过逗号隔开就可以了。比如我这个语句就可以输出“钱包”这一串字符串，同时还能将后面的变量它的内容也给我们输出来，所以说输出多份数据，你用逗号隔开就可以。运行结果是：

钱包: 50

除了记录数据这一个基本特征以外，变量还有没有其他的特征呢？答案当然是肯定的。

####  ####

#### 变量的特征 ####

变量的名字中有一个“变”字，但是不是说明这个量是可以发生变化的呀，那具体是什么意思呢？

举一个例子：假设我买了一个冰淇淋，然后花费10元，那是不是钱包的余额，就要减去10元呀？我们是不是可以通过数学计算，让50元减去10元就可以了。

那么数学计算在Python中如何写呢，其实很简单，直接用50-10就可以了。但是这样写一点都不高级，这跟我直接写一个40这个字面量并没有什么区别。因为我们本身是余额发生变化，减去了10，余额是不是记录到money这个变量中了呀，其实是可以写成money-10，这样一看是不是就更加的高级了。

我从钱包拿出来50块钱买个冰淇淋，给了老板，老板扣去10元之后，是不是应该将剩余的钱再找给我呀，那这个动作在我们代码中应该如何去做？

变量值有了是：money-10

变量名等于变量值，我们需要再定义第2个变量吗？不需要，我们是不是将新的内容，再放回money这个变量本身就可以了呀，你是不是发现我们变量所记录的内容，发生了改变呀？

那么，我们通过print语句来验证一下：

\# 买了一个冰淇淋，花费10元  
money = money - 10  
print("买了冰淇淋花费10元，还剩余：", money, "元")

这样我们的变量就定义好了。

\# 假设，每隔一小时，输出一下钱包的余额  
print("现在是下午1点，钱包余额剩余：", money)  
print("现在是下午2点，钱包余额剩余：", money)  
print("现在是下午3点，钱包余额剩余：", money)  
print("现在是下午4点，钱包余额剩余：", money)

这里有一个小技巧，光标定位到第一行的print语句时，直接ctrl+D可以直接复制多行。

####  ####

### 数据类型 ###

**学习目标：**

掌握使用type()语句查看数据的类型

理解变量无类型而数据有类型的概念

在学习字面量的时候，我们了解到：数据是有类型的。目前在入门阶段，我们主要接触如下三类数据类型：

<table> 
 <tbody> 
 <tr> 
 <th> 类型 </th> 
 <th> 描述 </th> 
 <th> 说明 </th> 
 </tr> 
 <tr> 
 <td> string </td> 
 <td> 字符串类型 </td> 
 <td> 用引号引起来的数据都是字符串 </td> 
 </tr> 
 <tr> 
 <td> int </td> 
 <td> 整型（有符号） </td> 
 <td> 数字类型，存放整数 如 -1,10,0 等 </td> 
 </tr> 
 <tr> 
 <td> float </td> 
 <td> 浮点型（有符号） </td> 
 <td> 数字类型，存放小数 如 -3.14,6.66 </td> 
 </tr> 
 </tbody> 
</table>

string、int、float这三个英文单词，就是类型的标准名称。

####  ####

#### type()语句 ####

那么，问题来了，如何验证数据的类型呢？我们可以通过type()语句来得到数据的类型，语法如下：

type(被查看类型的数据)

1.  1.在print语句中，直接输出类型信息：（str是string的缩写）
2.  
3.  如，在 type 里面写上一个字符串的字面量，或者写上一个整数字面量，或者写上浮点数字面量，然后通过 print的语句将它们整体输出来，你就可以得到类型信息的结果了。

string\_type=type("黑马程序员") 
int\_type = type(666) 
float\_type = type(11.345) 
print(string\_type) 
print(int\_type) 
print(float\_type) 
 
输出结果： 
<class 'str'> 
<class int> 
<class 'float'>

在这个结果里面，class 这个单词我们先暂时不用管它什么意思，我们只需要关心在单引号里面包围起来的就是类型信息。同样可能会想，这个 int 和 float 你刚刚说的我知道。那这个 str 它是什么东西？其实，str 它就是我们所说的 string字符串的一个缩写，这个要注意一下。

2.用变量存储type()的结果（返回值）：

除了这种方式以外，我们还可以使用变量去存储 type 语句的结果。type 语句它在执行完成之后会给我们提供一个返回值，其实也就是结果。对于这个结果，我们是可以用变量去存储起来的。

string\_type=type("黑马程序员") 
int\_type = type(666) 
float\_type = type(11.345) 
 
print(string\_type) 
print(int\_type) 
print(float\_type) 
 
 
输出结果： 
\# <class 'str'> 
\# <class int> 
\# <class 'float'>

我们这两种方式查看的都是<字面量>的类型，能查看变量中存储的数据类型吗？那当然：可以。

name="黑马程序员" 
name\_type = type(name) 
print(name\_type) 
 
\# <class str>

####  ####

#### 变量有类型吗？ ####

我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型？查看的是：变量存储的数据的类型。因为变量无类型，但是它存储的数据有。

好，那么为了理解这句话，我们来看一个例子：我们假设有个盒子，盒子里面放入足球，我们可以把它叫做足球盒子；盒子里面放入篮球，我们可以把它叫做篮球盒子。那么，我来问一下同学们，当盒子放入了足球以及篮球之后，盒子会变成足球或者篮球吗？显而易见的并不会，是吧？那么我们的变量也是一样的，我们的变量里面存储字符串数据，那么变量会变成字符串吗？肯定不会。

![e482249331110e85de0b498de528afc3.png][]

####  ####

#### 字符串类型的不同定义方式 ####

字符串有3种不同的定义方式：

*  双引号定义法 "字符串"
 *  单引号定义法 '字符串'
 *  三引号定义法 """字符串"""

三引号定义法，表示在一堆三个双引号的范围内，均是字符串，如下：

text = """  
在三个引号的包围圈内  
全部都是  
字符串哦  
写入完成  
"""

要注意的是，包含范围是：从三个引号开始，到下一个三个引号结束。

####  ####

### 数据类型转换 ###

学习目标：

*  掌握如何在字符串、整数、浮点数之间进行相互转换
 *  了解转换的注意事项

为什么要完成类型的转换？数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等。那么，我们为什么要转换它们呢？数据类型转换，将会是我们以后经常使用的功能。如：

*  从文件中读取的数字，默认是字符串，我们需要转换成数字类型
 *  后续学习的input()语句，默认结果是字符串，若需要数字也需要转换
 *  将数字转换成字符串用以写出到外部系统

用途很多，那么让我们来学习一下如何转换吧。

我们目前接触到了3类数据类型，那我们目前就，只讲解这3类类型之间如何转换。

<table> 
 <tbody> 
 <tr> 
 <th> 语句(函数) </th> 
 <th> 说明 </th> 
 </tr> 
 <tr> 
 <td> int(x) </td> 
 <td> 将x转换为一个整数 </td> 
 </tr> 
 <tr> 
 <td> float(x) </td> 
 <td> 将x转换为一个浮点数 </td> 
 </tr> 
 <tr> 
 <td> str(x) </td> 
 <td> 将对象 x 转换为字符串 </td> 
 </tr> 
 </tbody> 
</table>

这三句理解起来也比较简单，int(x) 那这句话的意思就是，你把x放进去，他就把x给你转换成一个整数。因为我们知道，int 代表的是整数类型嘛！那同样float里面放入一个x，就表明将 x 转换为一个浮点数，那同样下面的str,就表明将 x 转换成字符串。

只不过有一点我们需要注意，这3个语句，跟我们前面学习的type语句一样，它都是带有结果的，那对于这些带有结果的语句，我们可以直接用print()输出他的结果。

同学们可以拿下面的代码做一下练习

\# 将数字类型转换成字符串  
num\_str = str(11)  
print(type(num\_str), num\_str)  
  
float\_str = str(11.345)  
print(type(float\_str), float\_str)  
  
\# 将字符串转换成数字  
num = int("11")  
print(type(num), num)  
  
num2 = float("11.345")  
print(type(num2), num2)  
  
\# 整数转浮点数  
float\_num = float(11)  
print(type(float\_num), float\_num)  
  
\# 浮点数转整数  
int\_num = int(11.345)  
print(type(int\_num), int\_num)

#### 类型转换注意事项 ####

类型转换不是万能的，毕竟强扭的瓜不会甜，我们需要注意：

1.  任何类型，都可以通过str()，转换成字符串
2.  字符串内必须真的是数字，才可以将字符串转换为数字 如下：

v\_str = "我不是数字"  
num = int(v\_str)

就会出现报错。

Traceback (most recent call last): 
File "C:\\Users\\itcast\\PycharmProjects\\pythonProject1\\python图书练习\\2.3变量.py", line 24, in <module> 
num = int(v\_str) 
ValueError: invalid literal for int() with base 10: '我不是数字'

####  ####

### 标识符 ###

学习目标：

*  理解什么是标识符
 *  掌握标识符的命名规则
 *  掌握变量的命名规范

在Python程序中，我们可以给很多东西起名字，比如：

*  变量的名字
 *  方法的名字
 *  类的名字,等等

这些名字，我们把它统一的称之为标识符，用来做内容的标识。

所以，标识符是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。

既然要起名字，就会有对应的限制

####  ####

#### 标识符命名规则 ####

Python中，标识符命名的规则主要有3类：

*  内容限定
 *  大小写敏感
 *  不可使用关键字

接下来我们一个个来看下，首先来看，

####  ####

识符命名规则 - 内容限定

标识符命名中，只允许出现：

*  英文
 *  中文
 *  数字
 *  下划线（\_）

这四类元素。

其余任何内容都不被允许。

那除此以外还有一些注意的事项，比如第一我们不推荐使用中文，尽管Python支持以中文作为标识符的命名，但是目前支持的还不太完善，我们使用中文的话，可能会有一些隐藏的问题，其次在行业中，大多数的程序员都会使用英文来去做标识符的命名，而很少会使用中文，那么所以为了迎合行业的习惯，我们同样也不推荐使用中文。

还有一个需要注意的点，就是数字是不可以用在开头的，这是一个硬性的规定。

那我们来看一些例子

① abc、abc123、\_abc、hello（合理）

② 123abc、@abc、abc-123（不合理）

####  ####

标识符命名规则 - 大小写敏感

我们来看下面的代码：

Andy = '安迪1'  
andy = '安迪2'  
print(Andy)  
print(andy)

输出的结果为：

安迪1  
安迪2

字母a的大写和小写，是完全能够区分的。

####  ####

第三个规则：不可使用关键字

什么是关键字呢？

我们回想一下，在日常生活中，会不会有一些关键的电话号码呀，比如110120122119。我们的手机号，是不可以去占用这些关键的号码的，那同样在python中呢，也有一系列的单词称之为关键字。

关键字在Python中都有特定用途，我们不可以使用它们作为标识符。

下面是33个关键字：

False  
True  
None  
and  
as  
assert  
break  
class  
continue  
def  
del  
elif  
else  
except  
finally  
for  
from  
global  
if  
import  
in  
is  
lambda  
nonlocal  
not  
or  
pass  
raise  
return  
try  
while  
with  
yield

这么多的关键字肯定是不需要去背的，因为这些关键字我们说，都会有特定的用途，每一个用途都是一个功能。

我们在后续的代码中，会陆陆续续都接触到这些关键字，代码写多了，自然而然你就把它们都记住了，所以说不需要刻意去背。

还有一个关键的点，我们刚刚说过，标识符它是大小写敏感的，那么这个规则，同样适用于我们的关键字。

那可以看到我们关键字里面，有3个关键字，他都是首字母大写的，然后剩余的都是全小写的，那所以说对于这些关键字，我们如果大小写和他不一样的话，那么就不算占用关键字，但是如果你的大小写，和他完全一致的话，那么你就相当于占用关键字了，这一点我们要注意，关键字也同样大小写敏感。

通过以下的练习代码我们可以巩固一下刚才所学内容

\# 规则1：内容限定，限定只能使用：中文、英文、数字、下划线，注意：不能以数字开头  
\# 错误的代码示范：1\_name = "张三"  
\# 错误的代码示范：name\_! = "张三"  
name\_ = "张三"  
\_name = "张三"  
name\_1 = "张三"  
  
\# 规则2：大小写敏感  
Itheima = "黑马程序员"  
itheima = 666  
print(Itheima)  
print(itheima)  
  
\# 规则3：不可使用关键字  
\# 错误的示例，使用了关键字：class = 1  
\# 错误的示例，使用了关键字：def = 1  
Class = 1

####  ####

#### 变量命名规范 ####

刚刚我们学完了标识符的命名规则，再来学习一下标识符的命名规范。我们在前面说过，规范是建议型的要求，不是强制性的，但是如果你不遵守，规范会让我们的代码看起来不太高级，那么标识符有哪些规范呢？

我们标识符可以有变量名，类名和方法名，那么不同的标识符它有不同的规范，由于类和方法我们目前还没有学习，所以说，目前我们只学习变量的命名规范了。变量的命名规范呢有3个

*  第一个见名知意
 *  第二个下滑线命名法
 *  第三个叫做英文字母全小写

我们变量的命名要做到第一点，要做到明了，也就是看到名字就知道是什么意思。

定义两个变量：

a = "张三"  
b= 11

虽然程序可以正确运行，但是看起来不太高级，当我们把变量换成：

name= "张三"  
age = 11

就有见名起知意的效果了。

我们变量的命名第二点要做到简洁：尽量在确保“明了”的前提下，减少名字的长度

a\_person\_name = "张三"

太长了没必要，我们直接叫name就可以了。

name = "张三"

多个单词组合变量名，要使用下划线做分隔， 这样看起来就非常清爽了 。

firstnumber = 1  
studentnickname = "小明"  
  
first\_number = 1  
student\_nickname = "小明"

命名变量中的英文字母，应全部小写， 我们在命名的时候，凡是使用到英文字母，就不要去大写了，把变量中的英文字母全部小写就可以 。

name = "张三"  
age = 11

####  ####

### 运算符 ###

**学习目标：**

了解Python中常见

*  算术（数学）运算符

#### 赋值运算符 ####

那首先我们来看一下算数运算符是什么？那算数运算符其实简单来说就是用来做数学运算的，比如说加、减、乘、除、取整、除、取余以及求子数这常见的 7 种。那么这 7 个运算符其实和我们数学计算中的 7 种数学运算的概念是完全一样的

<table> 
 <tbody> 
 <tr> 
 <th> 运算符 </th> 
 <th> 描述 </th> 
 <th> 实例 </th> 
 </tr> 
 <tr> 
 <td> + </td> 
 <td> 加 </td> 
 <td> 两个对象相加 a + b 输出结果 30 </td> 
 </tr> 
 <tr> 
 <td> - </td> 
 <td> 减 </td> 
 <td> 得到负数或是一个数减去另一个数 a - b 输出结果 -10 </td> 
 </tr> 
 <tr> 
 <td> * </td> 
 <td> 乘 </td> 
 <td> 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200 </td> 
 </tr> 
 <tr> 
 <td> / </td> 
 <td> 除 </td> 
 <td> b / a 输出结果 2 </td> 
 </tr> 
 <tr> 
 <td> // </td> 
 <td> 取整除 </td> 
 <td> 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 </td> 
 </tr> 
 <tr> 
 <td> % </td> 
 <td> 取余 </td> 
 <td> 返回除法的余数 b % a 输出结果 0 </td> 
 </tr> 
 <tr> 
 <td> ** </td> 
 <td> 指数 </td> 
 <td> a**b 为10的20次方， 输出结果 100000000000000000000 </td> 
 </tr> 
 </tbody> 
</table>

####  ####

#### 算术运算符的演示 ####

加减乘除和求平方，我们在前面已经使用过啦。现在再带上：整除以及求余数，一起试一试吧。

print("1+1结果是：%d"%(1+1))  
print("2-1结果是：%d"%(2-1))  
print("1\*3结果是：%d"%(1\*3))  
print("9/3结果是：%d"%(9/3))  
print("9//2(9整除2)结果是：%d"%(9//2))  
print("9%%2(9余2的结果是)结果是：%d"%(9%2))  
print("2的6次方是：结果是：%d"%(2\*\*6))

输出结果

\# 1+1结果是：2  
\# 2-1结果是：1  
\# 1\*3结果是：3  
\# 9/3结果是：3  
\# 9//2(9整除2)结果是：4  
\# 9%2(9余2的结果是)结果是：1  
\# 2的6次方是：结果是：64

####  ####

#### 赋值运算符 ####

那么在 Python 中的运算符，除了算术运算符以外，还有赋值运算符。比如在 Python 中，赋值运算符可以分为两类：第一类是标准的赋值运算符，它是一个等号，它的含义是将等号右边的结果赋给左边的变量。在定义变量时，本质上已经使用了赋值运算符。

<table> 
 <tbody> 
 <tr> 
 <th> 运算符 </th> 
 <th> 描述 </th> 
 <th> 实例 </th> 
 </tr> 
 <tr> 
 <td> = </td> 
 <td> 赋值运算符 </td> 
 <td> 把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7 </td> 
 </tr> 
 </tbody> 
</table>

####  ####

#### 复合赋值运算符 ####

除了标准的赋值运算符外，我们还有复合赋值运算符，如加等、减等、乘等、除等、余等、平方等和整除等。这些运算符表示将变量本身进行运算，然后将结果赋值给变量本身。如下表：

<table> 
 <tbody> 
 <tr> 
 <th> 运算符 </th> 
 <th> 描述 </th> 
 <th> 实例 </th> 
 </tr> 
 <tr> 
 <td> += </td> 
 <td> 加法赋值运算符 </td> 
 <td> c += a 等效于 c = c + a </td> 
 </tr> 
 <tr> 
 <td> -= </td> 
 <td> 减法赋值运算符 </td> 
 <td> c -= a 等效于 c = c - a </td> 
 </tr> 
 <tr> 
 <td> *= </td> 
 <td> 乘法赋值运算符 </td> 
 <td> c *= a 等效于 c = c * a </td> 
 </tr> 
 <tr> 
 <td> /= </td> 
 <td> 除法赋值运算符 </td> 
 <td> c /= a 等效于 c = c / a </td> 
 </tr> 
 <tr> 
 <td> %= </td> 
 <td> 取模赋值运算符 </td> 
 <td> c %= a 等效于 c = c % a </td> 
 </tr> 
 <tr> 
 <td> **= </td> 
 <td> 幂赋值运算符 </td> 
 <td> c = a 等效于 c = c &nbsp;a </td> 
 </tr> 
 <tr> 
 <td> //= </td> 
 <td> 取整除赋值运算符 </td> 
 <td> c //= a 等效于 c = c // a </td> 
 </tr> 
 </tbody> 
</table>

####  ####

接下来通过代码来演示一下：

\# 赋值运算符  
num = 1 + 2 \* 3  
\# 复合赋值运算符  
\# +=  
num = 1  
num += 1 \# num = num + 1  
print("num += 1: ", num)  
num -= 1  
print("num -= 1: ", num)  
num \*= 4  
print("num \*= 4: ", num)  
num /= 2  
print("num /= 2: ", num)  
num = 3  
num %= 2  
print("num %= 2: ", num)  
  
num \*\*= 2  
print("num \*\*=2: ", num)  
  
num = 9  
num //= 2  
print("num //= 2:", num)

结果：

1 + 1 = 2  
2 - 1 = 1  
3 \* 3 = 9  
4 / 2 = 2.0  
11 // 2 = 5  
9 % 2 = 1  
2 \*\* 2 = 4

####  ####

### 字符串拓展 ###

####  ####

#### 字符串的三种定义方式 ####

我们学习过字符串的相关定义方法，但是我们当时定义的是被双引号包围的内容，我们把它叫做字符串。这种定义方式叫做双引号的定义法。严格来说，字符串在Python中有多种定义形式：

1.单引号定义法：name = "黑马程序员"

2.双引号定义法：name = "黑马程序员"

3.三引号定义法：name = """黑马程序员"""

三引号定义法，和多行注释的写法一样，同样支持换行操作。

*  使用变量接收它，它就是字符串
 *  不使用变量接收它，就可以作为多行注释使用

我们在代码中演示一下：

\# 单引号定义法，使用单引号进行包围  
name = '黑马程序员'  
print(type(name))  
  
\# 双引号定义法  
name = "黑马程序员"  
print(type(name))  
  
\# 三引号定义法，写法和多行注释是一样的  
name = """  
我是  
黑马  
程序员  
"""  
print(type(name))

结果：

思考：如果我想要定义的字符串本身，是包含：单引号、双引号自身呢？如何写？1234567890

*  单引号定义法，可以内含双引号
 *  双引号定义法，可以内含单引号
 *  可以使用转义字符（\\）来将引号解除效用，变成普通字符串
 *  转义字符是在计算机编程中使用的一种特殊字符，它可以改变后面字符的解释方式。

\# 在字符串内 包含双引号  
name = '"黑马程序员"'  
print(name)  
  
\# 在字符串内 包含单引号  
name = "'黑马程序员'"  
print(name)  
  
\# 使用转义字符 \\ 解除引号的效用  
name = "\\"黑马程序员\\""  
print(name)  
  
name = '\\'黑马程序员\\''  
print(name)

结果：

"黑马程序员"  
'黑马程序员'  
"黑马程序员"  
'黑马程序员'

####  ####

#### 字符串拼接 ####

如果我们有两个字符串（文本）字面量，可以将其拼接成一个字符串，通过+号即可完成，如：

print("学IT来黑马" + "月薪过万")

输出结果：

学IT来黑马月薪过万

不过一般情况下，单纯的2个字符串字面量进行拼接显得很呆，一般，字面量和变量或变量和变量之间会使用拼接，如：

name="黑马程序员"  
print("我的名字是："+name+",我可以教大家IT技能")

输出结果：

我的名字是：黑马程序员,我可以教大家IT技能

既然，字符串和变量进行拼接，我们来完成一个小需求：

定义2个变量：

*  name，内容是“黑马程序员”
 *  address，内容是“建材城东路9号”

要求写程序通过print语句以及字符串拼接的方式输出：

“我是：黑马程序员，我的地址是：建材城东路9号院“

name="黑马程序员"  
address="建材城东路9号院"  
print("我是："+name+",我的地址是："+address)

输出结果：

我是：黑马程序员,我的地址是：建材城东路9号院

既然可以和字符串变量完成拼接，那么，是否可以和其它变量类型如数字类型完成拼接呢？让我们试一试。

name="传智播客"  
set\_up\_year =2006  
print("我是："+name+",我成立于："+set\_up\_year)

可以看出，类型不同的变量，是不能进行拼接的，输出的结果是：

Traceback (most recent call last): 
File "C:\\Users\\itcast\\PycharmProjects\\pythonProject1\\python图书练习\\2.3变量.py", line 1512, in <module> 
print("我是："+name+",我成立于："+set\_up\_year) 
TypeError: can only concatenate str (not "int") to str

它这里提示了个叫 type error 类型错误，这是什么呢？这其实意思就是告诉我们，我们的字符串是没有办法通过加号和整数进行拼接的，其实不仅仅是整数，包括浮点数或者一些其他的类型，我们直接使用加号都是没有办法和字符串完成拼接，所以这一点需要我们注意一下。

####  ####

#### 字符串格式化 ####

学习目标：

*  掌握通过占位的形式拼接字符串（字符串格式化）

我们会发现，这个拼接字符串也不好用，原因如下：

1.变量过多，拼接起来实在是太麻烦了

2.字符串无法和数字或其它类型完成拼接。

print("我是"+name+",我的性别是："+sex+",我住在："+address+",我的爱好是："+hobby)

所以，有没有其它方式，即方便又支持拼接其它类型呢？这个方式，就是字符串的格式化。

我们可以通过如下语法，完成字符串和变量的快速拼接。其中的“%s ”

*  % 表示：我要占位
 *  s 表示：将变量变成字符串放入占位的地方

所以，综合起来的意思就是：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置：

name="黑马程序员"  
message="学IT就来%s"%name  
print(message)

输出结果：

学IT就来黑马程序员

那，数字类型呢？可以不可以占位？那必须可以，我们来尝试如下代码：

class\_num = 57  
avg\_salary = 16781  
message="Python大数据学科，北京%s期，毕业平均工资：%s"%(class\_num,avg\_salary)  
print(message)

输出结果：

Python大数据学科，北京57期，毕业平均工资：16781

这里我们会有一个疑问， 数字怎么也可以用%s 占位？%s 中的 s表示将变量变成字符串放入占位的地方，你怎么类型对不上？其实通过刚刚代码的演示，我们发现它真的是可以的。这里它是将数字转换成了字符串，也就是将数字 57 或者数字 16781 变成了字符串 57 或字符串 16781 放入了它应该占位的地方。

数字类型，也太没有地位了吧，竟然要被转成字符串拼接。有没有体面一点的方式，让数字以其原本的面貌拼接进去呢？Python中，其实支持非常多的数据类型占位，最常用的是如下三类：

<table> 
 <tbody> 
 <tr> 
 <th> 格式符号 </th> 
 <th> 转化 </th> 
 </tr> 
 <tr> 
 <td> %s </td> 
 <td> 将内容转换成字符串，放入占位位置 </td> 
 </tr> 
 <tr> 
 <td> %d </td> 
 <td> 将内容转换成整数，放入占位位置 </td> 
 </tr> 
 <tr> 
 <td> %f </td> 
 <td> 将内容转换成浮点型，放入占位位置 </td> 
 </tr> 
 </tbody> 
</table>

如下代码，完成字符串、整数、浮点数，三种不同类型变量的占位：

name="传智播客"  
set\_up\_year = 2006  
stock\_price = 19.99  
message="我是：%s,我成立于：%d,我今天的股价是：%f"%(name,set\_up\_year,stock\_price)  
print(message)

输出结果：

我是：传智播客,我成立于：2006,我今天的股价是：19.990000

####  ####

### 格式化的精度控制 ###

学习目标：

*  掌握格式化字符串的过程中做数字的精度控制

####  ####

#### 字符串格式化 ####

上一节的代码，完成字符串、整数、浮点数，三种不同类型变量的占位，细心的同学可能会发现：浮点数19.99，变成了19.990000输出，这里我们就要讲解一下，字符串格式化之“数字精度控制”。

####  ####

#### 字符串格式化 - 数字精度控制 ####

我们可以使用辅助符号"m.n"来控制数据的宽度和精度

*  m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
 *  .n，控制小数点精度，要求是数字，会进行小数的四舍五入

示例：

*  %5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：\[空格\]\[空格\]\[空格\]11，用三个空格补足宽度。
 *  %5.2f：表示将宽度控制为5，将小数点精度设置为2

小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：\[空格\]\[空格\]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35 •%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35 体验一下如下代码的快乐吧，输入：

num1 = 11  
num2 = 11.345  
print("数字11宽度限制5，结果：%5d"%num1)  
print("数字11宽度限制1，结果：%1d"%num1)  
print("数字11.345宽度限制7，小数精度2，结果：%7.2f"%num2)  
print("数字11.345不限制宽度，小数精度2，结果：%.2f"%num2)

输出结果：

数字11宽度限制5，结果：11 \# 宽度5，补了3个空格  
数字11宽度限制1，结果：11 \# 宽度小于数字本身，无影响  
数字11.345宽度限制7，小数精度2，结果：11.35 \# 宽度7，补了2个空格，小数精度2，四舍五入后为.35  
数字11.345不限制宽度，小数精度2，结果：11.35 \# 不限制宽度，小数点后四舍五入后为.35

####  ####

#### 字符串格式化方式2 ####

####  ####

字符串格式化 - 快速写法

目前通过%符号占位已经很方便了，还能进行精度控制。

可是追求效率和优雅的Python，是否有更加优雅的方式解决问题呢？

那当然：有。

通过语法：f"内容\{变量\}"的格式来快速格式化，看如下代码：

name="传智播客"  
set\_up\_year = 2006  
stock\_price = 19.99  
print(f"我是\{name\},我成立于：\{set\_up\_year\},我今天的股票价格是：\{stock\_price\}")

输出结果：

我是传智播客,我成立于：2006,我今天的股票价格是：19.99 \#不做精度控制，原样输出

注意：这种写法不做精度控制，也不理会类型，适用于快速格式化字符串。

####  ####

#### 对表达式进行格式化 ####

学习目标:

*  了解什么是表达式
 *  掌握对表达式进行字符串格式化

####  ####

字符串格式化 - 表达式的格式化

刚刚的演示，都是基于变量的。

可是，我想更加优雅些，少写点代码，直接对“表达式”进行格式化是否可行呢？

那么，我们先了解一下什么是表达式。

表达式：一条具有明确执行结果的代码语句

如：1 + 1、5 \* 2，就是表达式，因为有具体的结果，结果是一个数字

又或者，常见的变量定义：name = “张三” age = 11 + 11

等号右侧的都是表达式呢，因为它们有具体的结果，结果赋值给了等号左侧的变量。那么，对于字符串格式化，能否直接格式化一个表达式呢？可以，上代码：

print("1\*1的结果是：%d"%(1\*1))  
print(f"1\*1的结果是：\{1\*1\}")  
print("字符串在Python中的类型是：%s"%type('字符串'))

输出结果：

1\*1的结果是：1 
1\*1的结果是：1 
字符串在Python中的类型是：<class 'str'>

在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码哦。

####  ####

练习：

股价计算小程序 定义如下变量：

*  name，公司名
 *  stock\_price，当前股价
 *  stock\_code，股票代码
 *  stock\_price\_daily\_growth\_factor，股票每日增长系数，浮点数类型，比如1.2
 *  growth\_days，增长天数

计算，经过growth\_days天的增长后，股价达到了多少钱 使用字符串格式化进行输出，如果是浮点数，要求小数点精度2位数。示例输出：

![ee73b2a65bab5e7abe053df7598554fd.png][]

提示：

红色框框都是变量，要使用格式化的方式拼接进去 提示，可以使用：当前股价\*增长系数增长天数，用来计算最终股价哦 如，股价19.99 \* 系数1.2 7天 = 71.62778419199998，小数点现在精度2位后结果：71.63

参考代码：

\# 定义需要的变量  
name = "传智播客"  
stock\_price = 19.99  
stock\_code = "003032"  
\# 股票 价格 每日 增长 因子  
stock\_price\_daily\_growth\_factor = 1.2  
growth\_days = 7  
  
finally\_stock\_price = stock\_price \* stock\_price\_daily\_growth\_factor \*\* growth\_days  
  
print(f"公司：\{name\}，股票代码：\{stock\_code\}，当前股价：\{stock\_price\}")  
print("每日增长系数: %.1f，经过%d天的增长后，股价达到了：%.2f" % (stock\_price\_daily\_growth\_factor, growth\_days, finally\_stock\_price))

####  ####

### 掌握input语句（函数）的使用 ###

学习目标：

*  掌握input语句（函数）的使用

####  ####

#### 获取键盘输入 ####

试想一下，我们经常遇到过程序需要我们输入信息的场景。

比如：银行取钱的过程，是去银行，输入需要取款的钱数，然后银行给到你对应的钱。

如何在Python中做到读取键盘输入的内容呢？这里就要请出input语句了。

####  ####

#### input语句（函数） ####

我们前面学习过print语句（函数），可以完成将内容（字面量、变量等）输出到屏幕上。

在Python中，与之对应的还有一个input语句，用来获取键盘输入。

*  数据输出：print
 *  数据输入：input

使用上也非常简单：

*  使用input()语句可以从键盘获取输入
 *  使用一个变量接收（存储）input语句获取的键盘输入数据即可

print("请告诉我你是谁？")  
name = input()  
print("Get!!!你是：%s" % name)

需要键盘输入：

请告诉我你是谁？  
黑马程序员 \# 键盘输出内容并回车  
Get!!!你是：黑马程序员

在前面的代码中，输出”请告诉我你是谁？“的print语句其实是多余的。

input()语句其实是可以在要求使用者输入内容前，输出提示内容的哦，方式如下：

name = input("请告诉我你是谁？")  
print("Get!!!你是：%s" % name)

输出结果：

请告诉我你是谁？黑马程序员  
Get!!!你是：黑马程序员

如图，在input的括号内直接填入提示内容即可。

####  ####

#### input语句获取的数据类型 ####

我们刚刚试验的都是输入了字符串类型的数据。

那么如果我们输入数字类型或其它类型，结果会如何？

那么，让我们通过前面学习过的type()语句来验证一下输入内容的数据类型吧。

可以看到，无论键盘输入何种类型的数据

最终的结果都是：字符串类型的数据

![4369eec542a2b31104ab551d31eeefe5.png][]

自己去尝试一下吧！

[https_www.bilibili.com_video_BV1ZK411Q7uX_vd_source_704fe2a34559a0ef859c3225a1fb1b42_wxfid_o7omF0RELrnx5_fUSp6D59_9ms3Y]: https://www.bilibili.com/video/BV1ZK411Q7uX/?vd_source=704fe2a34559a0ef859c3225a1fb1b42&wxfid=o7omF0RELrnx5_fUSp6D59_9ms3Y
[Python]: http://mp.weixin.qq.com/s?__biz=Mzg5MzU3MDcyOQ==&mid=2247493319&idx=1&sn=7b5761b3aa029c7d24fde026c3b3110d&chksm=c02e7d01f759f417235dfc5db10e777f2aa0bf0aafe33b5b818e0cb9d04278dc2eb9ba87eaac&scene=21#wechat_redirect
[a25b8edc46b51713912185aefc4bc54b.png]: https://img-blog.csdnimg.cn/img_convert/a25b8edc46b51713912185aefc4bc54b.png
[c5e3190699d699a90873c7854b0a881b.png]: https://img-blog.csdnimg.cn/img_convert/c5e3190699d699a90873c7854b0a881b.png
[e482249331110e85de0b498de528afc3.png]: https://img-blog.csdnimg.cn/img_convert/e482249331110e85de0b498de528afc3.png
[ee73b2a65bab5e7abe053df7598554fd.png]: https://img-blog.csdnimg.cn/img_convert/ee73b2a65bab5e7abe053df7598554fd.png
[4369eec542a2b31104ab551d31eeefe5.png]: https://img-blog.csdnimg.cn/img_convert/4369eec542a2b31104ab551d31eeefe5.png