入门第三课 Python中的变量，及数字、字符串详解

一、我们先以一道常见的小学数学题作为例子：

3x=6，那么x等于多少？

这里的x就成为“变量”。说白了就是一个“可变的”这么一个代号，只不过在编程语言中，习惯地称之为“变量”。相对应的一个数字10，就是一个常量，因为10这个数本身，是不变的。

二、在Python中，可以修改的值，我们统称为“变量”。与其他大多数编程语言相比，Python这里有所不同，那就是Python的变量不需要事先声明其类型。举个栗子-_-！

我们在IDLE界面中输入：x="I wanna learn Python!!!"

回车后，就意味着我们创建了一个变量x，他的值是一个字符串（字符串需要使用一对单引号或者一对双引号括起来），字符串的值是：I wanna learn Python!!!

>>> x="I wanna learn Python!"
>>> x
'I wanna learn Python!'

变量的值有很多种类，可以给变量赋值一个数字，一串由数字、字母和符号混合体（称之为“字符串”），还可以是其他的很多东西（类型）。

分析一下：

1、只有一行代码；

2、功能一：创建变量x，该变量的名就是：x

     功能二：对其赋值，x的值是：I wanna learnPython

     功能三：设定了该变量的类型，x的类型是字符串类型

三、Pyhong中数据类型

        介绍数据类型之前，强调一下。对于首次看到的概念无法理解的，不用非得看懂，“记住”概念，一定要记住。之后的教程中会展开讲解，届时就能明白。这一点很重要，对于“为什么这么说”和“为什么这么设置”之类的问题，无需耗费时间思考。因为有的专有名词翻译其实没有什么实际的含义，而有的结果完全是Python故意设置成这样的。

我们的世界，有多重多样的信息：图书、音乐、影视剧、画。。。。在计算机看来都是一串数据。我们之前说过，要想让计算机为你服务，就要使用计算机能够读懂的语句与其交流。Python使用的数据可以大体分以下几种：

1、数字

2、字符串

3、列表

4、元组

5、字典

6、集合（目前我还没有用到，今后会补充）

 -------------------------------------------------------------------------------------------------------------------------------------------

1、数字：我们先看“数字”这个数据类型。这是与我们在数学中最为接近的概念。Python中的数字有：23、15.1432

比如：a=100，就意味着创建了一个变量a，a的值是100，因为100是整数，那么a是一个“整型”，在Python中称之为：int

           b=13.24，就意味着创建了一个变量b，b的值是13.24，因为13.24是整数+小数，那么b是一个“浮点型”，在Python中称之为：float  

           还有其他类型稍后做介绍

>>> a=10
>>> type(a)
<class 'int'>
>>> b=23.50
>>> type(b)
<class 'float'>

给变量a赋值10，是一个整数；创建后使用type()命令来显示变量的类型，这里显示为‘int’也就是整型。

给变量b赋值23.50，是一个浮点数；创建后使用type()命令来显示变量的类型，这里显示为‘float’也就是浮点型。

共数字使用的运算符号。数学中我们熟悉加减乘除，Python也有对应的运算方法和运算符号：

1.1 算术运算符

若a=10,b=21

+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

1.2 比较运算符

若a=10,b=20

==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

1.3 赋值运算符

若a=10,b=20

=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

1.4 位运算符

        若a=60,b=13。这些数字是我们熟悉的，生活中我们都知道逢10进1，故而这些都是10进制数。计算机由于其固有的特性，计算机能读懂2进制、8进制和16进制等等的数字；只是这些数字的书写格式与我们熟悉的10进制完全不同。

a的值是60，二进制的a=00111100，b=00001101

&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

1.5 逻辑运算符

若a=10，b=20

and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

1.6 成员运算符

in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

1.7 身份运算符

身份运算符用于比较两个对象的存储单元

is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

1.8 运算符的优先级

所谓优先级，就是指谁的优先级高，就先做谁的运算，反之亦然。以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

 

 

2、字符串：所谓字符串，就是用一对儿单引号‘’或者一对儿双引号“”括起来的字符，在Python中称之为str。这些字符可以是一串字母“werGHJKemn”，可是一串数字“12649”或者一串标点符号“！@#￥%……”或者上述的混合体“qw567%%cx”。

这里有一个问题：

a=10

b=“10”

a与b相等吗？

答案：不相等。因为a是整型，b是字符串型。在python（以及计算机系统中），a和b是两个完全不同的变量。

另外，字符串可以收尾相连：

>>> a="What're you doing?"
>>> b="Leave me alone."
>>> c=a+b
>>> print(c)
What're you doing?Leave me alone.

数字可以加减乘除，字符串也有类似的多种操作，上面的示例就是两个字符串“相加”。下面详细说明：

2.1 想提取一个字符串中的一部分。举个栗子-_-!!

>>> a='Hello World!I wanna learn Python!I love Python!'
>>> b=a[0]
>>> b
'H'
>>> c=a[1:4]
>>> c
'ell'

分析一下：a是一个字符串。b从a取值，a后面[]中如果只有一个数字，就代表只从a中取一个字符，这个数字就是制定的顺序号，从0开始计数，则a[0]就是a中第一个字符，即'H'。

                                             c从a取值，a后面[]中如果有两个数字，且中间使用冒号隔开，就代表起点和终点（取值时不包括终点对应的字符，即不包含a[4]），所以返回了a[1]、a[2]和a[3]对应的字符‘ell’。

实际上这里的提取一部分，在Python中称之为“切片”，下面的列表中还会做详细的介绍。

2.2 字符串的运算符号。

+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 1
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 1
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'n' ) print( R'n' )

>>> a='Hello'
>>> b='Python'
>>> c=a+b
>>> c
'HelloPython'
>>> d=a*2
>>> d
'HelloHello'
>>> if a in d:
print('yes')
yes
>>> if a not in b:
print('yes')
yes

2.3 输出字符串时，Python可以按照我们制定的格式输出：

>>> print('她是%s，今年%d岁'%('小霞',20))
她是小霞，今年20岁

格式是这样的：print('   '%())。

2.3.1 其中单引号中是要打印的内容。这里需要被后面一对儿单括号中内容做替代的，使用%和一个代码来制定，比如%s和%d

2.3.2 后面一对儿单括号中的内容，是用来替代前面单引号中标有%s或者%d，这里使用了‘小霞’和20。因为%s指定的是字符串，%d指定的是整数。必须按照前后顺序指定值。

%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化辅助指令

*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

2.4 针对字符串有很多函数：

1）capitalize()
将字符串的第一个字符转换为大写。

>>> a='tech'
>>> a.capitalize()
'Tech'

 2）center(width, fillchar)

返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

>>> a='abcd'
>>> a.center(20)
'
abcd
'
>>> b='abcd'
>>> b.center(20,'1')
'11111111abcd11111111'

3）count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定，则返回指定范围内 str 出现的次数。

>>> a='abc'
>>> b='abcabcabcdef'
>>> b.count(a)
3
>>> b.count(a,1,10)
2

4）encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'。

encode与下面一条的decode是互逆的操作。一起来看示例：

>>> a='我要学Python'
>>> a_utf8=a.encode("UTF-8")
>>> a_utf8
b'xe6x88x91xe8xa6x81xe5xadxa6Python'
>>> a_gbk=a.encode("GBK")
>>> a_gbk
b'xcexd2xd2xaaxd1xa7Python'
>>> a_utf8.decode('UTF-8','strict')
'我要学Python'
>>> a_gbk.decode('GBK','strict')
'我要学Python'

分析一下：a是一个字符串变量，值是：我要学Python。这个值是人类的语言，有中文，也有英文。计算机根据不同的编码规则，有不同的编码供计算机系统来识别。这里使用了两套编码规则：UTF-8和GBK。

encode就是把人类语言转换为计算机能识别的语言，decode反过来是把计算机可以识别的语言转换为人类能识别的语言。

格式：encode和decode都有两个参数，一个是编码规则，另一个是错误处理方案。

5）bytes.decode(encoding="utf-8", errors="strict")
Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

请见上一条。

6）endswith(b, beg=0, end=len(string))
检查字符串是否以b结束，如果beg 或者 end 指定则检查指定的范围内是否以b结束，如果是，返回 True,否则返回 False。

>>> a='123123123456'
>>> b='123'
>>> c='456'
>>> a.endswith(b)
False
>>> a.endswith(c)
True
>>> a.endswith(c,0,5)
False

7）expandtabs(tabsize=8)
把字符串 string 中的 tab 符号('t')转为空格，tab 符号默认的空格数是 8 。

>>> a='There is a tabt here.'
>>> a
'There is a tabt here.'
>>> a.expandtabs(0)
'There is a tab here.'
>>> a.expandtabs(20)
'There is a tab
here.'

8）find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1。

>>> a='abc'
>>> b='abcabcabcdef'
>>> b.find(a)
0
>>> b.find(a,1,10)
3
>>> c='xyz'
>>> b.find(c)
-1

9）index(b, beg=0, end=len(string))
跟find()方法一样，只不过如果b不在字符串中会报一个异常。

>>> a='123123123asd'
>>> b='123asd'
>>> c='789'
>>> a.index(b)
6
>>> a.index(c)
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
a.index(c)
ValueError: substring not found
>>> a.index(b,0,5)
Traceback (most recent call last):
File "<pyshell#30>", line 1, in <module>
a.index(b,0,5)
ValueError: substring not found

10）isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。

>>> a='1234sdfgf'
>>> a.isalnum()
True
>>> b='234@#$%sdf'
>>> b.isalnum()
False

11）isalpha()
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。

>>> a='adsfb'
>>> a.isalpha()
True
>>> b='adf2'
>>> b.isalpha()
False

12）isdigit()
如果字符串只包含数字则返回 True 否则返回 False。

>>> a='1234'
>>> a.isdigit()
True
>>> b='e43'
>>> b.isdigit()
False

13）islower()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。

>>> a='adfga'
>>> a.islower()
True
>>> b='asdf23A'
>>> b.islower()
False

14）isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False。

>>> a='2345'
>>> a.isnumeric()
True
>>> b='234sdf'
>>> b.isnumeric()
False

15）isspace()
如果字符串中只包含空白，则返回 True，否则返回 False。

>>> a='
'
>>> a.isspace()
True
>>> b='
a12'
>>> b.isspace()
False

16）istitle()
检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。是则返回 True，否则返回 False。

>>> a='There is a bug!'
>>> b='There is A bug!'
>>> a.istitle()
False
>>> b.istitle()
False
>>> c='There Is A Bug!'
>>> c.istitle()
True

17）isupper()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False。

>>> a='123#_A$%'
>>> a.isupper()
True
>>> b='345a'
>>> b.isupper()
False

18）join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。

>>> a
'abc'
>>> b='xyz'
>>> a.join(b)
'xabcyabcz'

19）len(string)
返回字符串长度。

>>> a
'abcABC'
>>> len(a)
6

20）ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

>>> a='abc'
>>> a.ljust(20)
'abc
'
>>> b='xyz'
>>> b.ljust(20,'1')
'xyz11111111111111111'

21）lower()
转换字符串中所有大写字符为小写.

>>> a
'abcABC'
>>> a.lower()
'abcabc'

22）lstrip()
截掉字符串左边的空格或指定字符。

>>> a='
ad23'
>>> a.lstrip()
'ad23'

23）title()

返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写。

>>> a='I wanna learn Py.'
>>> a.title()
'I Wanna Learn Py.'

24）max(str)

返回字符串 str 中最大的字母。

>>> a
'abcABC'
>>> max(a)
'c'

25）min(str)
返回字符串 str 中最小的字母。

>>> a='abcABC'
>>> min(a)
'A'

26）replace(old, new [, max])
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

>>> a='abcabcabcabc'
>>> a.replace('abc','xyz',2)
'xyzxyzabcabc'

27）rfind(str, beg=0,end=len(string))
类似于 find()函数，不过是从右边开始查找。

>>> a='abc'
>>> b='abcabcxyzabc'
>>> b.rfind(a)
9
>>> b.rfind(a,0,11)
3
>>> b.rfind(a,0,9)
3
>>> b.rfind(a,0,8)
3
>>> b.rfind(a,0,7)
3
>>> b.rfind(a,0,5)
0

28）rindex( str, beg=0, end=len(string))
类似于 index()，不过是从右边开始。

>>> a='abc'
>>> b='abcabcxyzabc'
>>> b.rindex(a)
9
>>> b.rindex(a,0)
9
>>> b.rindex(a,0,5)
0
>>> b.rindex(a,0,7)
3

29）rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。

>>> a='abc'
>>> a.rjust(20)
'
abc'
>>> b='xyz'
>>> b.rjust(20,'1')
'11111111111111111xyz'

30）rstrip()
删除字符串字符串末尾的空格.

>>> a='tech
'
>>> a
'tech
'
>>> a.rstrip()
'tech'

31）split(b, num)
num=string.count(b)) 以b为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串。

b -- 分隔符，默认为所有的空字符，包括空格、换行(n)、制表符(t)等。

num -- 分割次数，默认全部分割。

>>> a='I wanna learn Python!'
>>> a.split()
['I', 'wanna', 'learn', 'Python!']
>>> a.split('a')
['I w', 'nn', ' le', 'rn Python!']
>>> a.split('a',1)
['I w', 'nna learn Python!']

32）splitlines([b])
按照行('r', 'rn', n')分隔，返回一个包含各行作为元素的列表，如果参数 b 为 False，不包含换行符，如果为 True，则保留换行符。

>>> a='abcndenn
fgrnhir'
>>> a.splitlines()
['abc', 'de', '', '
fg', 'hi']
>>> a.splitlines(True)
['abcn', 'den', 'n', '
fgrn', 'hir']

33）startswith(b, beg=0,end=len(string))
检查字符串是否是以b开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

>>> a='asdfasdfasdf'
>>> b='asdf'
>>> c='a123'
>>> a.startswith(b)
True
>>> a.startswith(c)
False
>>> d='as1'
>>> a.startswith(d,4,8)
False

34）strip([chars])
在字符串上执行 lstrip()和 rstrip()。

>>> a='
asdfer123
'
>>> a.strip()
'asdfer123'

35）swapcase()
将字符串中大写转换为小写，小写转换为大写。

>>> a='Tech'
>>> a.swapcase()
'tECH'

36）bytearray.maketrans()

 还不会用，以后补充。-_-!!

37）bytes.maketrans()

>>> tran=bytes.maketrans(b'abcde',b'12345')
>>> a='I wanna learn Py.'
>>> b'I wanna learn Py.'.translate(tran,b'n')
b'I w11 l51r Py.'
>>> b'I wanna learn Py.'.translate(tran)
b'I w1nn1 l51rn Py.'

38）str.maketrans(intab,outtab)

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一 一对应的关系。返回字符串转换后生成的新字符串。

intab -- 字符串中要替代的字符组成的字符串。

outtab -- 相应的映射字符的字符串。

>>> intab="abcde"
>>> outtab="12345"
>>> tran=str.maketrans(intab,outtab)
>>> a='I wanna learn Py.'
>>> a.translate(tran)
'I w1nn1 l51rn Py.'

分析一下：通过str.maketrans制定对应规则tran：a-1/b-2/c-3/d-4/e-5。

之后就可以通过translate应用对应规则tran来“翻译”啦。

39）translate(table, deletechars="")
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。

见38示例。

不同的是，由bytes.maketrans()和bytearray.maketrans()制定的对应规则，translate在使用时，可以指定要删除的字符。

>>> tran=bytes.maketrans(b'abcde',b'12345')
>>> a='I wanna learn Py.'
>>> b'I wanna learn Py.'.translate(tran,b'n')
b'I w11 l51r Py.'
>>> b'I wanna learn Py.'.translate(tran)
b'I w1nn1 l51rn Py.'

40）upper()
转换字符串中的小写字母为大写。

>>> a='tech'
>>> a.upper()
'TECH'

41）zfill (width)
返回长度为 width 的字符串，原字符串右对齐，前面填充0。

>>> a='asdf'
>>> a.zfill(20)
'0000000000000000asdf'

42）isdecimal()
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

>>> a='adsf'
>>> a.isdecimal()
False
>>> b='1233'
>>> b.isdecimal()
True

2.5 转义字符

这个怎么说呢？举个栗子-_-!!

我想打印两行字：大体的格式这样滴

I wanna

learn Python！

我可以这样编程：

>>> print('I wanna');print('learn Python!')
I wanna
learn Python!

还可以这样：

>>> print('I wannanlearn Python!')
I wanna
learn Python!

你可能会说：不是说print('xxxx')，python会打印xxxx吗？怎么到你这里不仅没有打印中间的n，还换了行？

这里就涉及到“转义字符”这个概念。所谓转义字符，就是指在python中，有特殊含义的字符或字符串（多个字符连在一起）。都有哪些呢？一起看一下：

(在行尾时)	续行符
\	反斜杠符号
'	单引号
"	双引号
a	响铃
b	退格(Backspace)
e	转义
00	空
n	换行
v	纵向制表符
t	横向制表符
r	回车
f	换页
oyy	八进制数，yy代表的字符，例如：o12代表换行
xyy	十六进制数，yy代表的字符，例如：x0a代表换行
other	其它的字符以普通格式输出

表格中清楚地标明了在python中特殊字符和字符串，代表着特殊的含义。比如刚才我们使用的n，就代表换行，也就是另起一行！！

3、列表

Python中列表十分常见，格式是一对方括号括起来的数据。在Python中称之为list。注意一点，列表可以修改。

3.1方括号中可以存放数字，比如：

[1,2,3,4,100]

3.2可以存放字符串，比如：

[“25”,"sdfer"]

3.3也可以存放列表，比如：

[[1,2,3,5],["sd","567"]]

3.4或者上述类型的混合体

4、元祖

格式与列表（list）相同，唯一不同的地方是，元祖不能修改。在Python中称之为tuple。

5、字典

在Python中称之为dict。

使用一对大括号{}括起来的数据。

我们都使用过字典。无论是中文字典还是英语字典，都有一个共同特性：那就是根据目录，找出对应的页数；再根据页码找到我们想看的内容。

Python中的字典也是这样的。无非就是叫法有所不同。

举个栗子-_-!!

{"name":"zhaoyun","age":35,"height":185,"weight":85,"addr":"beijing:}

分析一下：

5.1 数据成对儿出现"name":"zhaoyun"，中间用冒号隔开，意思是name是zhaoyun。

5.2 name称为“键”，zhaoyun称为“值”。

5.3 对儿与对儿之间使用逗号隔开。