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

た入场券 2021-12-24 00:29 1034阅读 0赞

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

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

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

1.2 比较运算符

若a=10,b=20

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

1.3 赋值运算符

若a=10,b=20

<table> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>简单的赋值运算符</td> 
   <td>c = a + b 将 a + b 的运算结果赋值为 c</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 % 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> 
 </tbody> 
</table>

1.4 位运算符

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

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

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

1.5 逻辑运算符

若a=10，b=20

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

1.6 成员运算符

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

1.7 身份运算符

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

<table> 
 <tbody> 
  <tr> 
   <td>is</td> 
   <td>is 是判断两个标识符是不是引用自一个对象</td> 
   <td><strong>x is y</strong>, 类似&nbsp;<strong>id(x) == id(y)</strong>&nbsp;, 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>is not 是判断两个标识符是不是引用自不同对象</td> 
   <td><strong>x is not y</strong>&nbsp;， 类似&nbsp;<strong>id(a) != id(b)</strong>。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

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

1.8 运算符的优先级

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

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

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 字符串的运算符号。

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

>>> 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指定的是整数。必须按照前后顺序指定值。

<table> 
 <tbody> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp; &nbsp; &nbsp; &nbsp;%c</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化字符及其ASCII码</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %s</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化字符串</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %d</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化整数</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %u</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化无符号整型</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %o</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化无符号八进制数</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %x</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化无符号十六进制数</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %X</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化无符号十六进制数（大写）</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %f</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;格式化浮点数字，可指定小数点后的精度</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %e</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;用科学计数法格式化浮点数</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %E</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;作用同%e，用科学计数法格式化浮点数</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %g</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;%f和%e的简写</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %G</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;%f 和 %E 的简写</span></td> 
  </tr> 
  <tr> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %p</span></td> 
   <td><span style="font-family:'宋体';font-size:small;">&nbsp;用十六进制数格式化变量的地址</span></td> 
  </tr> 
 </tbody> 
</table>

格式化辅助指令

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

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在使用时，可以指定要删除的字符。

*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中，有特殊含义的字符或字符串（多个字符连在一起）。都有哪些呢？一起看一下：

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

表格中清楚地标明了在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。