第三章 序列类型的方法

# 第三章 序列的方法

## 一、取值、切片、重新赋值

### 1、取值

    

  首先，我们需要学习Python中的索引(index)是什么呢？

  

  每个元素都有自己的位置，称之为索引。生活中我们要排列顺序是从1,2,3·····n对吧，Python中排列顺序是从0,1,2,3·····n的顺序开始的。

  - 字符串取值

```python

>>> st1='thisisapple'

>>> st1[2]    #字符串+[]:表示对字符串索引取值，2代表索引为2的值。

'i'

>>> st1[6]    #如果要取'a',通过索引可以定位是6这个位置就是代表a值

'a'

```

  - 列表取值

```python

>>> li=['tom','Jon','Merry','Lili']

>>> li[2]

'Merry'

```

  - 元组取值

```python

>>> tu=(123,'abcd',456,'tuple')

>>> tu[2]

456  

```

  

### 2、切片

  Python序列的切片很基础同时也很重要。先看下切片的基本语法，一般认为切片语法是[N:M]，是个半闭合区间，等效于数学上[N,M)取值范围，取N不取M, M>N,否则取不到值。

  

  [::-1]这个也是正确的切片语法，重新审视切片语法，原来完整的切片语法是[N:M:S]，其中的S代表step，s可以为负数，并且s的正负对取切片的行为有影响，什么影响？2个方面：

  

  1.影响N,M的缺省值

  

  2.影响切片取值方向

  

  s缺省为1，如果>0,取切片从左向右取，缺省N=0

```python

>>>s=[1,2,3,4,5,6,7,8]

>>> s[0:6]    #从下标为0位置到下标为5的位置切片

[1, 2, 3, 4, 5, 6]

```

  因为是从左往右取，所以要求N<M,否则取不到，这个规则同样适用于N,M为负数的情况,看下面的例子,第一个N=-1,M=-2,N>M,从左往右取，-2位置上在-1的左边，所以取不到，第二个N=-2,M=-1,从-2向右-1取，得7，符合上述规则！

```python

>>>s=[1,2,3,4,5,6,7,8]

>>> s[-1:-2]

[]

>>> s[-2:-1]

[7]

```

  如果s<0，会如何缺省值：N= -1,M = -len(s)-1方向：从右向左取这就解释了[::-1]的结果，[::]代表取全序列，-1代表从右向左取步长为1

```python          

>>> s[::-1]

[8, 7, 6, 5, 4, 3, 2, 1]

```

  理解了以上原则，就容易理解以下切片的结果了，可以看到此时，如，N>M,但可以取到值，如,N<M取不到值，原因是s=-1,从右向左取值的缘故. 总之s的正负会影响切片取值方向，使用中需要特别注意。

```python

>>> s[-1:-2:-1]

[8]

>>> s[-2:-1:-1]

[]

```

  

下面对3种序列类型的切片简单举例说明，加强理解。

- 字符串切片

```python

>>> st1='thisisapple'

>>> st1[1:4]    

'his'

>>> st1[1:6:2]    #这个s为+2,由左向右隔2个步长取值，下标1到下标6方向也是由左向右，按照步长的方向隔2个步长在'hisis'取值.    

'hss'

```

- 列表切片

```python

>>> li=['tom','Jon','Merry','Lili']

>>> li[1:3]    #结果元素里包含下标 1，不含下标 3

['Jon', 'Merry']

>>> li[2:]    #从下标为2开始，取出后面所有的元素（没有结束位）

['Merry', 'Lili']

>>> li[:2]    #从起始位置开始，取到下标为2的前一个元素（不包括结束位本身）

['tom', 'Jon']

>>> li[:-1]    #从起始位置开始，取到倒数第一个元素（不包括结束位本身）

['tom', 'Jon', 'Merry']

```

  - 元组切片

```python

>>> tu=(123,'abcd',456,'tuple')

>>> tu[:3]

(123, 'abcd', 456)

```

 

### 3、重新赋值

  什么是不可变类型？

    

  变量对应的值中的数据是不能被修改，如果修改就会生成一个新的值从而分配新的内存空间，不同的内存空间就代表不同的变量。

    

   什么是可变类型？

     

  变量对应的值中的数据可以被修改，但内存地址保持不变。

  

  - 字符串(不可变对象)

 请问，a='IAmTom'改为a='IAmJon'需要重新赋值吗？

```python

>>>> a='IAmTom'

>>> a[3:6]

'Tom'

>>> a[3:6]='Jon'    #通过切片取出'Tom',直接改为'Jon',很明显是不可以的，不能通过索引改变字符串的某个元素。

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

>>> a='IAmJon'

```

上一节学的序列转换，可以用在字符串重新赋值上。把字符串转换为列表再修改最后转换为字符串。下面我们复习一下序列转换和序列取值。

```python

>>> a='IAmTom'

>>> id(a)

2358828141296

>>> la=list(a)    #转换为列表序列，对象命名为la

>>> la

['I', 'A', 'm', 'T', 'o', 'm']

>>> la[3:6]='Jon'    #通过切片取出'Tom'值,改为'Jon'值

>>> la

['I', 'A', 'm', 'J', 'o', 'n']

>>> a=''.join(la)    #通过.join方法，将列表转为字符串

>>> a

'IAmJon'

>>> id(a)    #观察两个a对象(虽然命名一样)的id(内存空间位置)，是不一样的，说明字符串序列是不可变对象。

2358828142128

```

  - 元组(不可变对象)

    

元组和字符串一样，也是不可变对象，可动手写个元组举证下。

    

拓展一个元组知识：拆包

```python

>>> tu=('a','b','c')

>>> x,y,z=tu    #拆包:将元组每一个元素分别赋给对应的对象

>>> x

'a'

>>> y

'b'

>>> z

'c'

>>> x,*y=tu    #*y:表示除元组第一个元素外，后面所有元素都包含。

>>> x

'a'

>>> y

['b', 'c']    

```

   

  - 列表(可变对象)

```python

>>> li=[1,2,3]

>>> id(li)

2358825763976

>>> li[2]=4    #li对象对应的值中的数据可以被修改，但内存地址保持不变。

>>> li

[1, 2, 4]

>>> id(li)

2358825763976

```

    

## 二、数列类型的方法

### 1、字符串方法

  1)查

  -  .index('值'，索引起点) # 返回值第一次出现的索引，从索引起点开始查询（默认为0），若不存在则报错

  -  .count('值')    ##返回值出现次数　

  -  .find('值'） # 查找第一个出现该字符或字符串的索引号 没有找到字符时返还-1

  -  .find('值',索引起点) # 查找相应位置上的字符

  -  .rfind('值') # 从右向左查找 .find()默认的是从左到右查找

  -  .isdigit() # 判断字符串是否是数字，返还值为布尔型

  -  .isalpha() # 判断是否是纯字母，返还值为布尔型 字符串中不能有特殊符号，否则报错

  -  .startswith('值') # 判断是否以某字符或字符串开头

  -  .endswith('值') # 判断是否以某字符或字符串结尾

  -  .islower() # 判断字符串中字母是否都是小写

  -  .isupper() # 判断字符串中字母是否都是大写

```python

>>> one='我我是祖国的花朵儿'

>>> one.index('我')    #找到一个'我'的值就会返回这个对应的索引

0

>>> one.count('我')    #查找出现'我'在字符串的次数

2

>>> one.find('我')

0

#这里列举一部分方法，其他的可以亲自动手操作，去理解这些方法。

```

  2)改

  -  .upper() # 将字符串的小写字母全部大写

  -  .lower() # 将字符串的大写字母全部小写

  -  .strip() # 去两边的空格

  -  .rstrip() # 去右边的空格

  -  .capitalize() # 将第一个位置大写 （Xshell中，按Tab键补全方法的关键字）

  -  .title() # 将字符串中单词的首字母大写

  -  .split('内容',次数) # 切割 以传的内容按次数切割字符串，切割后返还的是一个列表（原字符串中的内容就没了，变成了逗号）

```python

>>> two='IAmTom'

>>> two.upper()

'IAMTOM'

>>> two.lower()

'iamtom'

>>> three='  you are welcome  '

>>> three.strip()

'you are welcome'

#这里列举一部分方法，其他的可以亲自动手操作，去理解这些方法。

```

  3)删

  -  .replace('原字符','替换后的字符'，替换次数) # 替换 可以用空字符串的替换，来实现删除。

```python

>>> st='我说最帅的吧吧吧吧'

>>> st.replace('吧','啊',2)

'我说最帅的啊啊吧吧'

```

  4)增

  

  通过字符串拼接可以实现。拼接方法有：

  -  str1+str2+str3

```python

>>> st1='hello'

>>> st2='world'

>>> st1+' '+st2

'hello world'    

```

  -  通过%s和%拼接

    

  一个%s,表示拼接一个字符串，两个%s表示拼接两个字符串，三个%s表示拼接三个字符串。

```python

>>> 'hello %s ,%s,%s'%('tom','jon','merry')

'hello tom ,jon,merry'  

```  

  -  通过.join

```python

>>> a='晚上好'

>>> '...'.join(a)

'晚...上...好'

```  

  -  通过.format和{}的使用，{索引}，加上指定的索引可以放置到指定的索引位置。

```python

>>> 'hello {},{},{}'.format('tom','jon','merry')

'hello tom,jon,merry'

>>> 'hello {1},{2},{0}'.format('tom','jon','merry')

'hello jon,merry,tom'

```    

 

  5)字符串的转义

  -  \n # 换行

  -  \t # 水平制表符   一般情况下是一个Tab键的空间

  -  \b # 退格

  -  \r # 回车，把\r后面的字符，移到到行首，行首的相对应位置的字符被替换掉

  -  \\ # 代表反斜杠

  -  \' # 在字符串中打印出单引号（否则字符串中的'会报错）

  -  \0 # 空字符串      \012 # 换行效果,相当于\n

  -  \a # 声音

  -  r'字符串' # 将字符串中的转义全部失效

```python

>>> print('abcdef')

abcdef

>>> print('abc\ndef')    #\n换行

abc

def

>>> print('abc\bdef')    #相当于按了一下删除键

abdef

#这里列举一部分方法，其他的可以亲自动手操作，去理解这些方法。

```

### 2、列表方法

  1)增

  -  .append(值) # 把值添加到最后

  -  .extend([参数1，参数2]) # 添加多个值，但不能是数值类型的参数，要是序列类型的参数，比如元组，字符串，结果是把元组，字符串拆开。

  -  .insert(索引号,值) # 任意插入

```python

>>> li=[1,2,3]

>>> li.append('hello')

>>> li

[1, 2, 3, 'hello']

>>> li.insert(1,'tom')

>>> li

[1, 'tom', 2, 3, 'hello']

>>> li.extend((111,222))

>>> li

[1, 'tom', 2, 3, 'hello', 111, 222]

```  

  2)删

  -  .remove(值) # 删除值  一次只能删一个值

  -  .pop(索引号) # 删除索引（下标）处的值 索引号为空的话，默认删除最后的值  一次只能删一个

  -  .clear() # 清空

```python

>>> a=[1,2,3,4,5]

>>> a.pop(1)

2

>>> a

[1, 3, 4, 5]

>>> a.pop()

5

>>> a

[1, 3, 4]

>>> a.remove(4)

>>> a

[1, 3]

>>> a.clear()

>>> a

[]  

```  

  3)改

  - 索引赋值 [索引号] = 值

```python

>>> li=[2,4,6,8]

>>> li[2]=10

>>> li

[2, 4, 10, 8]  

```

  4)查

  -  .index(值) # 返还的是（第一个出现该值的）索引号（下标）

  - .count(值) # 查找该值在列表中出现的次数

  -其他方法

  - .sort() # 排序 默认从小到达（默认值是reverse=False）

  - .sort(reverse=True) # 排序 从小到大

  - .reverse() # 反向 掉头 不排序 和[::-1]的功能相似

  - .copy() # 复制一份

```python

>>> li=[1,4,2,6,-1]

>>> li.sort()

>>> li

[-1, 1, 2, 4, 6]

>>> li.sort(reverse=True)

>>> li

[6, 4, 2, 1, -1]

#其他一些方法可亲自动手操作，去理解这些方法

```

### 3、元组方法

  元组是不可变对象，只有两个方法，方便查找元组中的数据

    

  1)-查

  

  元组查方法和其他序列，如列表、字符串一样使用方式。

  - .index(值)

  - .count(值)

```python

>>> tu=('a','b','a','c')

>>> tu.index('a',1)

2

>>> tu.count('a')

2  

```

## 三、课堂练习

  - 1、创建一个变量，并赋给它一个列表(含数值，文本)，进行切片取值，并进行增删改查的操作。

  - 2、创建三个字符串对象，值分别是'Hello'、'My name'和'is tom',用学过的拼接方法去完成拼接结果为'Hello,My name is tom'

    

## 四、上一节课堂练习答案

### 1、创建一个变量，并给它赋一个数值(任何数值都行)，然后使用print显示这个变量。

```python

>>> one=(123)    #变量=(数值)，复习变量的命名，数列定义

>>> print(one)

123  

```

### 2、改变这个变量，可以用一个新值替换原来的值，或者将原来的值增加某个量，使用print显示这个新值。

```python

>>> one=(234)    #用新值替换原来的值

>>> print(one)

234

    

>>> one=(123)

>>> one+=10    #将原来的值增加某个量

>>> print(one)

133    

```

### 3、创建另一个变量，并赋给它一个字符串('某个文本')，然后使用print显示这个变量。

```python    

>>> st='我是一串字符串'

>>> print(st)

我是一串字符串

```     

### 4、将第三题的变量转换为列表形式和元组形式。

```python    

>>> lst=st.split()    

>>> print(lst)

['我是一串字符串']

>>> tst=tuple(st)

>>> print(tst)

('我', '是', '一', '串', '字', '符', '串')

```