小甲鱼——序列

 一，序列

*  元组，列表，字符串的共同点：

1.都可以通过索引获取每一个元素

2.第一个元素的索引值都是0

3.都可以通过切片的方法获取一个范围（一个集合）

4.都有很多共同的运算符

   * 那么在python当中，我们把元组，列表，字符串统称为“序列”

根据能否被修改这一特征，可以将序列分为可变序列和不可变序列

eg:列表是可变序列，元组和字符串就是不可变序列

      *能够作用与序列的一些运算符和函数

运算符：+    *

+：表示将字符串进行拼接

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


#这段代码的返回值就是：[1,2,3,4,5,6]
对于元组和字符串而言也是一样的

*：表示将字符串进行重复

[1,2,3] *3


#这段代码的返回值就是：[1,2,3,1,2,3,1,2,3]
这对于元组和字符串也是一样的道理

二，增量赋值

增量复制就是在赋值的过程中同时进行运算

直接举例说明：

s = [1,2,3]
id[s]


#这段代码的返回值就是：2063833296576

s *= 2
print(s)

#这段代码的返回值就是[1,2,3,1,2,3]
id(s)


#它的返回值就是2063833296576

 在上面id（s）它的返回值两次都是一样的

其实在python当中，每一个对象都有三个基本特征

分别是：唯一标志，类型，值

唯一标志：他是随着对象创建的时候就存在的，它不可以被修改，也不会有重复的值，只要对像在这个内存当中，这个值就不会重复。这大概就是对象的一张身份证

id是一个内置函数，它的作用：返回一个代表指定对象的唯一标识的整数值

但是在元组身上，这个就不是这样的，例如：

t = (1,2,3)
id(t)

#它的返回值就是：20638333359552

t *= 2
print(t)

#它的返回值就是：（1，2，3，1，2，3）
id(t)


#它的返回值就是：2063832613504

那么这两次调用函数就会得到不同的值，所以元组和列表面对 id（）内置函数，他们的结果是不一样的

三，运算符

1.is 和 is not

用于检测对象的id值是否相等，从而判断是否是同一个对象，他也被称为同一性运算符，

在之前我们学过这样的例子：

x = "FishC"
y = "FishC"
x is y


#它的返回值就是：True

那么今天我们看看如果是列表，会有怎么样的结果：

x = [1,2,3]
y = [1,2,3]
x is y


#他的返回值就是：False

虽然他们的值都是列表123，但是他们并不是同一对象

2.in 和 not in

in 和 not in主要判断的是包含问题

in主要是判断某个元素是否包含在序列当中，而not in则恰恰相反

"鱼" in "鱼C"


#它的返回值就是：True

"C" not in "FishC"

#这段代码的返回值就是：False

四，del语句

1.用于删除一个或多个指定对象

x = "FishC"
y = [1,2,3]

del x,y 
print(x)


#python1会报错


print(y)


#python也会报错

上面这段代码就说明，我们已经用del将x y都删除了，所以你再去打印的话，python就会报错

2.del语句还可以用于删除可变序列中的指定元素

x = [1,2,3,4,5]
delx[1:4]

print(x)


#这段代码的返回值就是[1,5]

这就是将指定元素删除的操作

而同样可以将指定元素删除的方法还有——切片

复习一下：

y = [1,2,3,4,5]
y[1:4] = []
print(y)

#这段代码的返回值就是：[1,5]

这就是将一个空列表赋值给一个切片区域，想当于执行了两个步骤的操作，第一步就是将赋值号左边指定的这个切片区的内容清除，第二个步骤就是将赋值号右侧的可迭代对象的内容插入到左侧刚刚被清空的列表里面。

del可以完成切片大法也无法做到的事情

x = [1,2,3,4,5]
del x[::2]
print(x)

#这段代码的返回值就是：[2,4]

五.跟序列相关的一些函数

1.列表，元组，字符串相互转换的函数

list()   tuple()   str()

A.要将一个可迭代对象转换成列表，直接调用list函数即可

list("Fishc")

#这段代码的返回值就是['F','i','s','h','C']

上面这段代码就实现了将字符串转换成列表

这个list()内置函数，面对元组也是一样的道理

list((1,2,3,4,5))


#这段代码的返回值就是：[1,2,3,4,5]

B.将一个可迭代对象转换成元组，我们使用的是tuple（）函数

tuple("FishC")

#这段代码的返回值就是：('F','i','s','h','C')

这就将可迭代对象转换成了元组，那么对于列表也是一样的道理

tuple([1,2,3,4,5])


#这段代码的返回值就是：(1,2,3,4,,5)

C.将一个可迭代对象，转换成字符串

str([1,2,3,4,5])


#这段代码的返回值就是‘[1,2,3,4,5]’

元组作为参数也是一样的道理：

str((1,2,3,4,5))

 
#这段代码的返回值就是'(1,2,3,4,5)'

 六，min() & max () 函数

对比传入的参数，并且返回最小值和最大值，他们都有两种函数类型，第一种传入的是可迭代对象，而我们所说的序列就是可迭代对象，

s = [1,1,2,3,5]
min(s)


#这段代码的返回值就是1

将s传入min()函数的时候min函数会从s这个列表当中选出一个最小的数字，并返回出来

t = "FishC"
max(t)


#这段代码的返回值就是："s"

#注意#：我们传入的如果是字符串的话，则min（）和max()这两个函数，比较的是字符串当中每个字符串的这个编码值，具体的编码值不需要记，只需了解26个字母的顺序即可，另外，大写字母的编码值是在小写字母之前的，并且，当我们传入的是一个空的可迭代对象的时候，那么python就会报错。

但是当我们将这段程序用于现实的时候一定会有用户有这种情况的发生，那么我们此时可以这样子：就是利用default()函数

s = []
min(s,default = "啥都没有，怎么找到最小")
print(s)


#这段代码的返回值就是："啥都没有，怎么找到最小的?"

这样子就不会报错，那么max也会是一样的操作

min和max的第二种用法：

传入多个参数，这样的话就会自动找出其中的最大值和最小值

min(1,2,3,0,6)

#这段代码的返回值就是0

max(1,2,3,0,6)

#这段代码的返回值就是:6

七.len() 和sum()函数

len函数的最大可承受范围

len(range(2**100))

# 这样的话python就会直接报错，因为len()函数的参数太大导致

python为了内部执行效率，一般使用效率更高的C语言来实现，而len函数为例让python自带的数据结构可以走后门，不会直接计算，而是直接读取C语言结构体里面对象的长度，所以，如果检测的对象超过了某个数值，就会报错。通常对于32位平台来说，最大的值是2的31次方减1，而对于64位平台来说，这个最大的数值就是2的63次方减1.

sum函数，求和

s = [1,0,0,8,6]
sum(s)#传入一个可迭代对象


#这段代码的返回值就是15

它还有一个start参数，这个参数用于  指定求和计算的起始值

s = [1,0,0,8,6]
sum = (s,start=100)



#那么这段代码就是要从100+1+0+0+8+6
所以它的返回值就是115

八，sorted（）&  reversed（）函数

s = [1,2,3,0,6]

sorted(s)



#那么这段你代码的返回值就是[0,1,2,3,6]

注意区别：sorted函数返回的是一个全新的列表，而原来的列表不会收到影响，现在去返回s列表，依旧是[1，2，3，0，6]

但是!如果你调用的是s的sort方法，列表就会被改变

s = [1,2,3,0,6]
s.sort()
print(s)


#这段代码的返回值就是[0,1,2,3,6]

sorted函数也支持key 和reverse两个参数，用法如下

sorted(s,reverse = True)

#这段代码的返回值就是[6,3,2,1,0]

key参数的用法：

t = ["FishC","Apple","Book","Banana","Pen"]
sorted(t)
#上面这部分代码的返回值就是：
["Apple","Banana","Book","Fishc","Pen"]
storted(t,key=len)

那么这段代码的返回值就是["Pen","Book","Fishc","Apple","Banana"]

当我们传入t的时候，它对比的是列表当中的每一个元素，那这里的每一个元素，他又是字符串，

所以它对比的是字符串的每一个字符的编码值，但是这里面的"Banana","Book"当中为什么Banana在book的前面，因为，当我们字符串的第一个字符一样的话，他就会去找第二个元素，第二个一样找第三个，以此类推。

那么在后面的这个，sorted（t，key=len）key它指定的是一个干预排序算法的函数，比如说，我们在这里指定为len函数，没有括号，只写了他的名字，python会在排序的过程当中，先将列表当中的每一个元素去自动调用一次这个len函数，比较的是len函数的返回结果，所以这个sorted（t,key = len）这个呢比较的是每个元素的长度，因此呢，“pen”是在“Book”的前面，而book又是在“FishC”前面的，

列表的sort函数，也可以这么写

t = ["FishC","Apple","Book","Banana","Pen"]
t.sort(key=len)

#这段代码的返回值就是["Pen","Book","Fishc","Apple","Banana"]

这里有一个区别就是：

sort他只能作用于列表，不能作用于元组和字符串，但是sorted它可以作用于列表，元组，字符串。

sorted("FishC")
这段代码的返回值就是：['C','F','h','i','s']

sorted((1,0,,0,8,6))

#这段代码的返回值就是[0,0,1,6,8]

reverse函数

 reversed（）函数返回的，是一个参数的反向迭代器，

迭代器：暂时当作可迭代对象理解即可

s = [1,2,5,8,0]
reversed(s)

#这段代码的返回值就是：一串奇奇怪怪的英文

其实它的返回结果就是迭代器，我们把它理解成可迭代对象就可以了。

s = [1,2,5,8,0]
list(reversed(s))


#这段代码的返回值就是[0,8,5,2,1]

就是倒序

除了列表，reversed()函数也可以支持任何形式的可迭代对象。

list(reversed("FishC"))

#这段代码的返回值就是：
['C','h','s','i','F']

list(reversed((1,2,5,9,3)))
#返回值就是:[3,9,5,2,1]

#也可以这么写：
list(reversed((0，10)))

#这段代码的返回值就是：
[9,8,7,6,5,4,3,2,1,0]

又倒过来了

九，all()  &   any()函数

all()函数，是判断可迭代对象中是否所有元素的值都为真。

any函数，是判断可迭代对象中某个元素的值为真。

x = [1,1,0]
y = [1,1,9]


all(x)

#返回值是：False#因为他并非每个元素都为真

all(y)
#返回值就是 True

那么对于any（）函数
any(x)
any(y)
它的返回值就是：True

十，enumerate()

这个函数是用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表

seasons = ["spring","summer","fall","winter"]
enumerate(seasons)
<enumerate object at 0x000002627A73D500>

print(list(enumerate(seasons)))

#这段代码的返回值就是
[(0,'Spring'),(1,'Summer'),(2,'Fall'),(3,'Winter')]

事实上就是将seasons这个列表的每个元素抽取出来，然后呢，跟一个从0开始的索引去构成一个元组，那么事实上还有start参数，