python的基本知识点（Python0-3Python基本概念和基本类型）

警：人生苦短，我用Python

本章内容将讲述Python学习中的基本概念和基本类型，部分具体知识需要Python解释器辅助理解，在开始学习前请打开Python解释器，如果未曾安装请看前文“Python入门（学习笔记）”，里面有Windows操作系统Python解释器安装的教程。

Linux操作系统安装教程：http://c.biancheng.net/view/4162.html

mac操作系统安装教程：http://c.biancheng.net/view/4164.html

一、编程语言的分类

我们编写的源代码是人类语言，我们自己能够轻松理解；但是对于计算机硬件（CPU），源代码就是天书，根本无法执行，计算机只能识别某些特定的二进制指令，在程序真正运行之前必须将源代码转换成二进制指令。所谓的二进制指令，也就是机器码，是指 CPU 能够识别的硬件层面的“代码”，简陋的硬件（比如古老的单片机）只能使用几十个指令，强大的硬件（PC 和智能手机）能使用成百上千个指令。

然而，究竟在什么时候将源代码转换成二进制指令呢？不同的编程语言有不同的规定：

1.编译型语言

• 有的编程语言要求必须提前将所有源代码一次性转换成二进制指令，也就是生成一个可执行程序（Windows 下的 .exe），比如C语言、C 、Golang、Pascal（Delphi）、汇编等，这种编程语言称为编译型语言，使用的转换工具称为编译器。
• 总结：①编译型语言运行后会生成一个额外的可执行程序，是电脑能够直接识别并执行的；
• ②编译型语言的源代码和可执行程序不能跨平台使用。

2.解释型语言（Python就是解释型）

• 有的编程语言可以一边执行一边转换，需要哪些源代码就转换哪些源代码，不会生成可执行程序，比如 Python、JavaScript、PHP、Shell、MATLAB 等，这种编程语言称为解释型语言，使用的转换工具称为解释器。
• 总结：①解释型语言运行不会产生额外的文件；
• ②解释型语言在运行时翻译，运行一个代码功能就翻译一个代码功能。

二、变量（变量是Python标识符的一种）

任何编程语言都需要处理数据，比如数字、字符串、字符等，我们可以直接使用数据，也可以将数据保存到变量中，方便以后使用。

变量（Variable）可以看成一个小箱子，专门用来“盛装”程序中的数据。每个变量都拥有独一无二的名字，通过变量的名字就能找到变量之中的数据。

从底层看，程序中的数据最终都要存放到内存条中，在编程语言中，最终需要存放的数据都要存放到“内存条”中，而变量就是这块“内存条”的名字。

和变量相对应的是常量（Constant），它们都是用来“盛装”数据的小箱子，不同的是：变量保存的数据可以被多次修改，而常量一旦保存某个数据之后就不能修改了。

在编程语言中，将数据放入变量的过程叫做赋值（Assignment）。Python 使用等号=作为赋值运算符，具体格式为：

name = value

name 表示变量名；value 表示值，也就是要存储的数据。

在python中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

赋值的例子

变量的值不是一成不变的，它可以随时被修改，只要重新赋值即可；另外你也不用关心数据的类型，可以将不同类型的数据赋值给同一个变量。如下图所示：

变量的值的修改

注意，变量的值一旦被修改，之前的值就被覆盖了，不复存在了，再也找不回了。换句话说，变量只能容纳一个值。

除了赋值单个数据，你也可以将表达式的运行结果赋值给变量，例如：

赋值多个数据

注意，变量是标识符的一种，它的名字不能随便起，要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 关键字重名。

3.变量的使用

在使用Python变量时，只需要知道变量的名字即可，几乎在Python代码的任何地方都可使用变量，详情请看下面的演示：

变量的使用

除此之外，Python变量的使用还有单个定义和多个定义之分：

（1）单个定义——变量名=值（也是要保存的数据）——即a=10

（2）多个定义——变量名，变量名，......=值1，值2，......——即a，b，c，......=10,20,30，......

（3）变量使用单个定义或多个定义没有必要的区别，靠个人习惯选择。同时在编写代码过程中可以通过变量名得到保存值。

4.Python是一门弱类型的语言（补充内容）

在编程语言内部，有强类型和弱类型之分。

在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，C语言、C 、Java 是强类型语言的代表。

和强类型语言相对应的是弱类型语言，Python、JavaScript、PHP 等脚本语言一般都是弱类型的。弱类型语言有两个特点：

• 变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
• 变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。

注意，弱类型并不等于没有类型区分！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型，例如：

Python变量的数据类型

三、Python标识符命名规范

Python 语言的标识符必须以字母、下划线（_）开头，后面可以跟任意数目的字母、数字和下画线（_）。此处的字母并不局限于 26 个英文字母，可以包含中文字符、日文字符等。

1.命名规范的作用

使你的变量名符合Python程序的底层规则与逻辑，如果不符合，则程序报错，无法运行。同时方便自我对已写代码的记忆，不至于产生忘记某些代码所属含义的可能。

2.如何进行规范的命名

（1）规则（不能违反，否则会出问题，不可选）：

1. 标识符可以由字母、数字、下划线（_）组成，其中数字不能作为开头使用。
2. 标识符不能是 Python 关键字，但可以包含几个关键字。
3. 标识符不能包含空格。

如果违反规则，则代码运行时会报错

正确以及错误的标识符命名示范

举例，例如下面变量，有些是合法的，有些是不合法的：

• abc_xyz：合法。
• HelloWorld：合法。
• abc：合法。
• xyz#abc：不合法，标识符中不允许出现“#”号。
• abc1：合法。
• 1abc：不合法，标识符不允许数字开头。

（2）规范（违反可能会产生隐性问题，但不会立即表现出来，是可选的）：

①一般使用英文字母、下划线和数字组成。可以随意组合，但不能违反规则

②见名知意，最好使用英文单词命名

如果不符合规范，代码运行时不会报错，但可能有隐性问题，而隐性问题具体可表现为，遗忘所写代码里部分变量名的含义，同时在工作中与同事的对接，会让对接的工作量增加。

3.总结：

（1）最好是符合规则且见名知意的规范命名

（2）标识符命名只能是黑色，如果不是黑色，则命名违反了规则，需要立马更换命名

补充：在Python中，不同的代码会有不同的颜色，而变量名只能是黑色，如果你所书写的变量名不是黑色，则不是变量名。

四、变量和引用（逻辑内容）

1.保存值：意指变量保存的是其地址值

在Python中，可以通过地址值找到对应的变量

2.内置函数id（值）：其作用为获取指定的数据的地址值

3.总结：变量保存的是地址值，通过地址值找到对应的数据，进行使用。

五、关键字

关键字是预先保留的标识符，每个关键字都有特殊的含义。编程语言众多，但每种语言都有相应的关键字，Python 也不例外，它自带了一个‘keyword’ 模块，用于检测关键字。

在Python解释器中，要获取关键字列表可以使用内置函数help()

help('keyword')获取关键字列表

或者通过keyword模块导入关键字列表：import keyword

keyword模块导入关键字列表

注意：①关键字中，除False、None和True之外，其余关键字首字母均为小写。且在Python语言中是区分大小写的，比如False是一个关键字，而false则是一个变量名。

②Python是一门动态语言，根据时间在不断变化，关键字列表并非一成不变，在将来可能会发生改变。

除此之外，keyword模块还提供了关键字的判断方法

关键字的判断

如果是关键字，则返回True；不是关键字，则返回False。

Python关键字及其含义

总结：

1.关键字是指在Python中具有特殊含义和功能的单词，不能作为变量名使用。

2.关键字本身已经被Python解释器给占用了，在敲写代码的过程中，不能赋予关键字其他的含义。

3.关键字的特殊含义以及功能是由Python这门编程语言本身定义的。

六、内置函数

Python 解释器自带的函数叫做内置函数，这些函数可以直接使用，不需要导入某个模块。

（一）函数的概念：函数就是一段封装好的、可以重复使用的代码，它使得我们的程序更加模块化，不需要编写大量重复的代码。

在Python中，函数不仅有内置函数，也有标准库函数。而内置函数和标准库函数是不一样的。在Python解释器中，它给用户提供了一些常用功能，并给它们起了独一无二的名字，这些常用功能就是内置函数。Python 解释器启动以后，内置函数也生效了，可以直接拿来使用。

Python 标准库相当于解释器的外部扩展，它并不会随着解释器的启动而启动，要想使用这些外部扩展，必须提前导入。Python 标准库非常庞大，包含了很多模块，要想使用某个函数，必须提前导入对应的模块，否则函数是无效的。

内置函数是解释器的一部分，它随着解释器的启动而生效；标准库函数是解释器的外部扩展，导入模块以后才能生效。一般来说，内置函数的执行效率要高于标准库函数。

Python 解释器一旦启动，所有的内置函数都生效了；而导入标准库的某个模块，只是该模块下的函数生效，并不是所有的标准库函数都生效。

（二）举例：打包代码（也叫输出代码）——print()

内置函数的数量必须被严格控制，否则 Python 解释器会变得庞大和臃肿。一般来说，只有那些使用频繁或者和语言本身绑定比较紧密的函数，才会被提升为内置函数。例如，在屏幕上输出文本就是使用最频繁的功能之一，所以 print() 是 Python 的内置函数。

在 Python 2.x 中，print 是一个关键字；到了 Python 3.x 中，print 变成了内置函数。

因为一个功能不是一两行就能完成的，可能有几十上百行，为了使几十上百行的代码只实现我们指定的一个或者多个功能，于是Python就帮我们定义好了能实现这个的功能函数print()。

除了 print() 函数，Python 解释器还提供了更多内置函数，下表列出了 Python 3.x 中的所有内置函数。

Python 3.x内置函数

如果要了解内置函数的具体功能和用法，可以通过下面的网址去详细了解：

https://docs.python.org/zh-cn/3/library/functions.html

七、输入输出

（一）初步理解：

1.输入（input）

（1）输入的含义：人输入数据到电脑

（2）输入的作用：①接收用户输入的数据；

②搭配变量保存用户输入的数据。

（3）输入的使用：①输入是内置函数

②内置函数使用规则是“内置函数名 （‘’）”，而输入的使用规则是“input （‘’）”

（4）注意：input接收到的所有数据类型都是字符串类型

2.输出（print）

（1）输出的含义：电脑输出数据（电脑显示数据）

（2）输出的作用：把你想要展示出来的内容显示在屏幕上

（3）输出的使用：①输出是print，使用规则“print （‘输出的内容’）”

（4）输出语法的进阶：①在使用完输出语法print后，系统会默认换行，我们可以通过修改print后的end参数让其不换行。

②print（要展示的内容，end=‘/n’）

③打印多个参数要用逗号隔开，展示的效果会用空格隔开

（二）进阶理解：

1.输出

①print（）函数语法格式：print（self, *args, sep=’ ‘, end=’\n’, file=None）*args：位置参数sep：分隔

位置参数和分隔的用法

end：print函数最后默认打印的内容

end参数用法

file：结果打印的地方，默认在控制台输出

②格式化输出

常用的格式化符号

③换行输出\n ：将后面的内容换行输出

2.输入

1.input函数语法格式：x = input（‘ ’）小括号里放入提示信息从键盘获取的数据会给到左边的变量xinput会将用户的值都当作字符串来对待

八、数据类型

(一)数值，数字（Number）

在Python中，数值用Number表示，通常分为：

1.Int（整数）,比如1

（1）初步内容：

整数就是没有小数部分的数字，Python中的整数包括正整数、0和负整数。

（2）进阶内容（整数的不同进制）：

在 Python 中，可以使用多种进制来表示整数：

1) 十进制形式

我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

2) 二进制形式

由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。

3) 八进制形式

八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。

4) 十六进制形式

由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，

补充：如果你对不同进制以及它们之间的转换方法不了解，请查看下面的链接：

1.进制详解：http://c.biancheng.net/view/1724.html

2.进制之间的转换：http://c.biancheng.net/view/1725.html

2.float（小数）

（1）初步内容：float例子，比如1.1,1.2

（2）进阶内容：

Python中关于float小数有两种书写形式

①十进制形式：十进制形式就是上述的初步内容，也是我们日常所看到的小数的形式34.6,34.5,35.7等等，注意必须要有小数点，否则会被Python当做整数处理。

②指数形式：Python中小数的指数形式的写法为

aEn或aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。

指数形式的小数举例：

• 2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。
• 3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。
• 0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。

注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。

小数在Python中的使用

从运行结果可以看出，Python 能容纳极小和极大的浮点数。print 在输出浮点数时，会根据浮点数的长度和大小适当地舍去一部分数字，或者采用科学计数法。f5 的值是 120000，但是它依然是小数类型，而不是整数类型。让人奇怪的是 f6，12.3*0.1的计算结果很明显是 1.23，但是 print 输出却不精确。这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。

3.bool（布尔型），只有两个值——①True（真，1），②False（假，0）

Python 提供了 bool 类型来表示真（对）或假（错），比如常见的5 > 3比较算式，这个是正确的，在程序世界里称之为真（对），Python 使用 True 来代表；再比如4 > 20比较算式，这个是错误的，在程序世界里称之为假（错），Python 使用 False 来代表。

True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错。

值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。因此，下边这些运算都是可以的：

>>> False 1 1 >>> True 1 2

注意，这里只是为了说明 True 和 Flase 对应的整型值，在实际应用中是不妥的，不要这么用。总的来说，bool 类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。

4.complex（复数）

复数（Complex）是 Python 的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a bj

a 表示实部，b 表示虚部。

实例：Python复数的使用

运行结果

通过运行结果可以发现，复数在 Python 内部的类型是 complex，Python 默认支持对复数的简单计算。

（二）String（字符串）

（三）List（列表）——列表至字典等内容置于之后讲，此处不在一一详解

（四）Tuple（元组）

（五）Dictionary（字典）

注意：在编辑器中可使用内置函数type()查看各项数据的类型。

九、数值类型计算

（一）数值类型计算含义：

1.在Python中数值类型计算又称运算符计算，主要是进行运算符之间的数学计算。

2.数值类型计算的作用：可以通过运算得出结果

3.运算符类型：①算术运算符；②赋值运算符；③位运算符；④比较运算符；⑤逻辑运算符；⑥三目运算符。

（二）算术运算符（重点）：

算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。

Python常用算术运算符

1.加法运算符“ ”：

加法的运算符运算很简单，和数学中的规则一样，请看下面代码

加法运算代码

运算结果

2.减法运算符“ - ”：

①减法运算也和数学中的规则相同，请看下面代码：

减法运算代码

运算结果

②求负：

‘-’除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数），请看下面的代码：

求负运算代码

运算结果

3.乘法运算符“ * ”：

①乘法运算也和数学中的规则相同，请看代码：

乘法运算代码

运算结果

②重复字符串：

乘法运算符除了可以用作乘法运算，还可以用来重复字符串，也可以将n个同样的字符串连接起来，请看代码：

重复字符串代码

运算结果

4./ 和 // 除法运算符：

Python 支持/和//两个除法运算符，但它们之间是有区别的：

• /表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
• //表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。

请看下面的代码：

除法运算符代码

运算结果

从运算结果可以发现：

• /的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
• 当有小数参与运算时，//结果才是小数，否则就是整数。

需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致 ZeroDivisionError 错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。

5.求余运算符“ % ”：

Python % 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。注意，求余运算的本质是除法运算，所以第二个数字也不能是 0，否则会导致“ ZeroDivisionError” 错误。Python % 使用示例：

print("-----整数求余-----") print("15%6 =", 15%6) print("-15%6 =", -15%6) print("15%-6 =", 15%-6) print("-15%-6 =", -15%-6) print("-----小数求余-----") print("7.7%2.2 =", 7.7%2.2) print("-7.7%2.2 =", -7.7%2.2) print("7.7%-2.2 =", 7.7%-2.2) print("-7.7%-2.2 =", -7.7%-2.2) print("---整数和小数运算---") print("23.5%6 =", 23.5%6) print("23%6.5 =", 23%6.5) print("23.5%-6 =", 23.5%-6) print("-23%6.5 =", -23%6.5) print("-23%-6.5 =", -23%-6.5)

运行结果：

-----整数求余----- 15%6 = 3 -15%6 = 3 15%-6 = -3 -15%-6 = -3 -----小数求余----- 7.7%2.2 = 1.0999999999999996 -7.7%2.2 = 1.1000000000000005 7.7%-2.2 = -1.1000000000000005 -7.7%-2.2 = -1.0999999999999996 ---整数和小数运算--- 23.5%6 = 5.5 23%6.5 = 3.5 23.5%-6 = -0.5 -23%6.5 = 3.0 -23%-6.5 = -3.5

从运行结果可以发现两点：

• 只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
• %两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。

6.次方（乘方）运算符“ ** ”：

Python中，**运算符是用来求一个数x的y次方，也即次方（乘方）运算符。

由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算。

Python ** 运算符示例：

print('----次方运算----') print('3**4 =', 3**4) print('2**5 =', 2**5) print('----开方运算----') print('81**(1/4) =', 81**(1/4)) print('32**(1/5) =', 32**(1/5))

运行结果：

----次方运算---- 3**4 = 81 2**5 = 32 ----开方运算---- 81**(1/4) = 3.0 32**(1/5) = 2.0

（三）赋值运算符（重点）：

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。Python 中最基本的赋值运算符是等号=；结合其它运算符，=还能扩展出更强大的赋值运算符。

1.基本赋值运算符：

= 是Python中最常见、最基本的赋值运算符，用来将一个表达式的值赋给另一个变量，具体请看下面的例子：

#将字面量（直接量）赋值给变量 n1 = 100 f1 = 47.5 s1 = "http://c.biancheng.net/python/" #将一个变量的值赋给另一个变量 n2 = n1 f2 = f1 #将某些运算的值赋给变量 sum1 = 25 46 sum2 = n1 % 6 s2 = str(1234) #将数字转换成字符串 s3 = str(100) "abc"

连续赋值

Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：

a = b = c = 100

= 具有右结合性，我们从右到左分析这个表达式：

• c = 100 表示将 100 赋值给 c，所以 c 的值是 100；同时，c = 100 这个子表达式的值也是 100。
• b = c = 100 表示将 c = 100 的值赋给 b，因此 b 的值也是 100。
• 以此类推，a 的值也是 100。

最终结果就是，a、b、c 三个变量的值都是 100。

= 和 ==

= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。

扩展后的赋值运算符（进阶内容）

=还可与其他运算符（包括算术运算符、位运算符和逻辑运算符）相结合，扩展成为功能更加强大的赋值运算符，如下图所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。

Python扩展赋值运算符

举例： n1 = 100 f1 = 25.5 n1 -= 80 #等价于 n1=n1-80 f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 ) print("n1=%d" % n1) print("f1=%.2f" % f1) 运行结果为： n1=20 f1=255.00

通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。但是请注意，这种赋值运算符只能针对已经存在的变量赋值，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：

n = 10

该表达式等价于 n = n 10，n 没有提前定义，所以它不能参与加法运算。

十、字符串

简介：字符串的引号使用共分为3种，常用的为单引号' '和双引号" ",在字符串较长或特别长的情况下，使用三引号"' "'

（一）字符串的含义：

字符串的意思就是“一串字符”，比如“Hello,Charlie”是一个字符串，“How are you？”也是一个字符串。Python 要求字符串必须使用引号括起来，使用单引号也行，使用双引号也行，只要两边的引号能配对即可。

（二）字符串的使用：

字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行。

字符串既可用单引号括起来，也可用双引号括起来，它们没有任何区别。例如如下程序：

str_1='hello word python!' str_2="hello word python!" print(str_1) print(str_2)

但需要说明的是，Python 有时候没有我们期望的那么聪明。如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理：

方式1.使用不同的引号将字符串括起来。

方式2.对引号进行转义。

先看第一种处理方式。假如字符串内容中包含了单引号，则可以使用双引号将字符串括起来。例如：

str3 = 'I'm a coder'

由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把 'I' 当成字符串，而后面的 m a coder' 就变成了多余的内容，从而导致语法错误。

为了避免这种问题，可以将上面代码改为如下形式：

str3 = "I'm a coder"

上面代码使用双引号将字符串括起来，此时 Python 就会把字符串中的单引号当成字符串内容，而不是和字符串开始的引号配对。

假如字符串内容本身包含双引号，则可使用单引号将字符串括起来，例如如下代码：

str4 = '"Spring is here,let us jam!", said woodchuck.'

（三）转义字符：

接下来看第二种处理方式：使用转义字符。Python 允许使用反斜线（\）将字符串中的特殊字符进行转义。假如字符串既包含单引号，又包含双引号，此时必须使用转义字符，例如如下代码：

str5 = '"we are scared,Let\'s hide in the shade",says the bird'

（四）拼接字符串：

如果直接将两个字符串紧挨着写在一起，Python 就会自动拼接它们，例如如下代码：

str='hello,'"word python" print(str)

上面的代码将会输出：

hello，word python

上面这种写法只是书写字符串的一种特殊方法，并不能真正用于拼接字符串。Python 使用加号（ ）作为字符串的拼接运算符，例如如下代码：

str_1= "Python " str_2= "iS Funny" #使用 拼接字符串 str_3 = str_1 str_2 print(str_3)

除此之外，字符串的拼接还可以使用替身，占位符以及利用join做拼接。

1.替身做拼接（也叫字符串的格式化）：

例：拼接不同的字符串以组成一句话（替身法） str1='hello' str2='word' str3='python' print('%s %s %s'%(str1,str2,str3)) 输出结果为———— hello word python

在print()中，'%s %s %s '%(str1,str2,str3)是替身做拼接法的格式，其中的“%s”是替身，而他的数量取决于所要拼接的字符串有几个，比如有三个，则在' '之中写三个替身，每个替身之间要留有空格。再用%号连接后面的字符串本身。注意后面的字符串本身用括号单独括起来，字符串之间用逗号隔开。

2.format格式化：

例：拼接不同的字符串以组成一句话（format格式化） str1='hello' str2='word' str3='python' print('{} {} {}'.format(str1,str2,str3)) #简化后 print(f'{str1} {str2} {str3}') 输出结果为———— hello word python

3.利用join做拼接：

例：拼接不同的字符串以组成一句话（利用join） str1='hello' str2='word' str3='python' print(','.join([str(str1) str(str2) str(str3)])) 输出结果为———— hello,word,python

（五）字符串的大小写转换函数以及用法：

Python中，为了方便对字符串中的大小写转换，字符串变量提供了三种方法。分别是 title()、lower() 和 upper()。

Python title()方法

title() 方法用于将字符串中每个单词的首字母转为大写，其他字母全部转为小写，转换完成后，此方法会返回转换得到的字符串。如果字符串中没有需要被转换的字符，此方法会将字符串原封不动地返回。

title() 方法的语法格式如下：

str.title()

其中，str 表示要进行转换的字符串。

例： >>> str = "c.biancheng.net" >>> str.title() 'C.Biancheng.Net' >>> str = "I LIKE C" >>> str.title() 'I Like C'

Python lower()方法

lower() 方法用于将字符串中的所有大写字母转换为小写字母，转换完成后，该方法会返回新得到的字符串。如果字符串中原本就都是小写字母，则该方法会返回原字符串。lower() 方法的语法格式如下：

str.lower()

其中，str 表示要进行转换的字符串。

例： >>> str = "I LIKE C" >>> str.lower() 'i like c'

Python upper()方法

upper() 的功能和 lower() 方法恰好相反，它用于将字符串中的所有小写字母转换为大写字母，和以上两种方法的返回方式相同，即如果转换成功，则返回新字符串；反之，则返回原字符串。upper() 方法的语法格式如下：

str.upper()

其中，str 表示要进行转换的字符串。

例： >>> str = "i like C" >>> str.upper() 'I LIKE C'

（六）长字符串：

前面简介有提到过字符串使用三引号"' "'的情况，在三引号的字符串中，通常能放置任何内容，包括放置单引号、双引号都可以，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了。实际上，使用三个引号括起来的长字符串完全可以赋值给变量，例如如下程序：

str = '''"Let's go fishing", said Mary. "OK, Let's go", said her brother. they walked to a lake''' printstr)

上面程序使用三个引号定义了长字符串，该长字符串中既可包含单引号，也可包含双引号。当程序中有大段文本内容要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以让字符串中包含任何内容，既可包含单引号，也可包含双引号。此外，Python 还允许使用转义字符（\）对换行符进行转义，转义之后的换行符不会“中断”字符串。例如如下代码：

str_2= 'The quick brown fox \ jumps over the lazy dog' print(str_2)

上面 str_2字符串的内容较长，故程序使用了转义字符（\）对内容进行了转义，这样就可以把一个字符串写成两行。需要说明的是，Python 不是格式自由的语言，因此 Python 程序的换行、缩进都有其规定的语法。所以，Python 的表达式不允许随便换行。如果程序需要对 Python 表达式换行，同样需要使用转义字符（\）进行转义，代码如下：

num = 20 3 / 4 \ 2 * 3 print(num)

上面程序中有一个表达式，为了对该表达式换行，程序需要使用转义字符。

（七）进阶内容_1 repr和字符串：

有时候，我们需要将字符串与数值进行拼接，而 Python 不允许直接拼接数值和字符串，程序必须先将数值转换成字符串。为了将数值转换成字符串，可以使用 str() 或 repr() 函数，例如如下代码：

str_1 = "这是数字: " p = 99.8 #字符串直接拼接数值，程序报错 print(str_1 p) #使用str()将数值转换成字符串 print(str_1 str(p)) #使用repr()将数值转换成字符串 print(str_1 repr(p))

上面程序中直接拼接字符串和数值，程序会报错。str() 和 repr() 函数都可以将数值转换成字符串，其中 str 本身是 Python 内置的类型（和 int、float 一样），而 repr() 则只是一个函数。此外，repr 还有一个功能，它会以 Python 表达式的形式来表示值。对比如下代码：

st = "I will play my fife" print (st) print(repr(st))

上面代码中 st 本身就是一个字符串，但程序依然使用了 repr() 对字符串进行转换。运行上面程序，可以看到如下输出结果：

I will play my fife 'I will play my fife'

通过上面的输出结果可以看出，如果直接使用 print() 函数输出字符串，将只能看到字符串的内容，没有引号；但如果先使用 repr() 函数对字符串进行处理，然后再使用 print() 执行输出，将可以看到带引号的字符串，这就是字符串的 Python 的表达式形式。在交互式解释器中输入一个主量或表达式时，Python 会自动使用 repr() 函数处理该变量或表达式。

（八）进阶内容_2 使用 input 获取用户输入:

input() 函数用于向用户生成一条提示，然后获取用户输入的内容。由于 input() 函数总会将用户输入的内容放入字符串中，因此用户可以输入任何内容，input() 函数总是返回一个字符串。

例如如下程序：

msg ＝ input("请输入你的值：") print (type(msg)) print(msg)

第一次运行该程序，我们输入一个整数，运行过程如下：

请输入你的值：2 <class 'str'> 2

第二次运行该程序，我们输入一个浮点数，运行过程如下：

请输入你的值： 1.2 <class 'str'> 1.2

第三次运行该程序，我们输入一个字符串，运行过程如下：

请输入你的值：Hello <class 'str'> Hello

从上面的运行过程可以看出，无论输入哪种内容，始终可以看到 input() 函数返回字符串，程序总会将用户输入的内容转换成字符串。

（九）进阶内容_3 Python原始字符串：

由于字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要对其进行转义。比如写一条 Windows 的路径 G:\publish\codes\02\2.4，如果在 Python 程序中直接这样写肯定是不行的，需要写成 G:\\publish\\codes\\02\\2.4，这很烦人，此时可借助于原始字符串来解决这个问题。原始字符串以“r”开头，原始字符串不会把反斜线当成特殊字符。因此，上面的 Windows 路径可直接写成 r'G:\publish\codes\02\2.4'。关于原始字符串的用法看如下程序：

s1 = r'G:\publish\codes\02\2.4' print(s1)

如果原始字符串中包含引号，程序同样需要对引号进行转义（否则 Python 同样无法对字符串的引号精确配对），但此时用于转义的反斜线会变成字符串的一部分。例如如下代码：

# 原始字符串包含的引号，同样需要转义 s2 = r'"Let\'s go", said Charlie' print(s2)

上面代码会生成如下输出结果：

"Let\'s go", said Charlie

由于原始字符串中的反斜线会对引号进行转义，因此原始字符串的结尾处不能是反斜线，否则字符串结尾处的引号就被转义了，这样就导致字符串不能正确结束。如果确实要在原始字符串的结尾处包含反斜线怎么办呢？一种方式是不要使用原始字符串，而是改为使用长字符串写法（三引号字符串）；另一种方式就是将反斜线单独写出来。例如如下代码：

s3 = r'Good Morning' '\\' print(s3)

上面代码开始写了一个原始字符串 r'Good Morning'，紧接着程序使用 '\\' 写了一个包含反斜线的字符串，Python 会自动将这两个字符串拼接在一起。运行上面的代码会生成如下输出结果：

Good Morning\

作者：WananJ

尾言：部分内容转载于网络，文章仅供学习交流，禁止用于商业用途！

,