一、我们先以一道常见的小学数学题作为例子：
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)
>>> b=23.50
>>>type(b)
给变量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， 在一个有符号二进制数的补码形式。
<<
左移动运算符：运算数的各二进位全部左移若干位，由”<
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 ind:print(‘yes’)
yes>>> if a not inb: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
用十六进制数格式化变量的地址
格式化辅助指令
*
定义宽度或者小数点精度
–
用做左对齐
+
在正数前面显示加号( + )
在正数前面显示空格
#
在八进制数前面显示零(‘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’\xe6\x88\x91\xe8\xa6\x81\xe5\xad\xa6Python’
>>> a_gbk=a.encode(“GBK”)>>>a_gbk
b’\xce\xd2\xd2\xaa\xd1\xa7Python’
>>> 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 tab\t here.’
>>>a’There is a tab\t 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””, line 1, in a.index(c)
ValueError: substringnotfound>>> a.index(b,0,5)
Traceback (most recent call last):
File””, line 1, in a.index(b,0,5)
ValueError: substringnot 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’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 b 为 False，不包含换行符，如果为 True，则保留换行符。
>>> a=’abc\nde\n\n fg\r\nhi\r’
>>>a.splitlines()
[‘abc’, ‘de’, ”, ‘fg’, ‘hi’]>>>a.splitlines(True)
[‘abc\n’, ‘de\n’, ‘\n’, ‘fg\r\n’, ‘hi\r’]
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 wanna\nlearn Python!’)
I wanna
learn Python!
你可能会说：不是说print(‘xxxx’)，python会打印xxxx吗？怎么到你这里不仅没有打印中间的\n，还换了行？
这里就涉及到“转义字符”这个概念。所谓转义字符，就是指在python中，有特殊含义的字符或字符串(多个字符连在一起)。都有哪些呢？一起看一下：
\(在行尾时)
续行符
\\
反斜杠符号
\’
单引号
\”
双引号
\a
响铃
\b
退格(Backspace)
\e
转义
\000
空
\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 对儿与对儿之间使用逗号隔开。
