一、我们先以一道常见的小学数学题作为例子：
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'\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 "<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', '\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 对儿与对儿之间使用逗号隔开。