Python-序列基本概念

序列

序列的概念

包含若干个元素, 元素有序排列, 可以通过下标访问到一个或者多个元素. 这样的对象, Python中统一称为序列(Sequence).

Python中的以下对象都属于序列

• 字符串
• 列表
• 元组

同是序列, 他们的使用方式有很多相通之处

注意:序列里面的元素的顺序很重要,因为比较是按顺序比

a = [1,2,3]
b = [3,2,1]
print(a ==b)    #False

标准类型操作符

下列标准类型操作符, 大多数情况下都是适用于序列对象的(少部分特例是, 序列中保存的元素不支持标准类型操作符).

序列类型操作符

• in/not in: 判定一个元素是否存在于序列中, 返回布尔值.

a = [1,2,3,4]
print(3 in a)    #True
print(3 not in a)    #False

• 连接操作符(+): 把两个相同类型的序列进行连接.

a = [1,2,3,4]
b = [5,6]
print(a+b)    #返回一个新列表,包含了a和b的所有元素[1, 2, 3, 4, 5, 6]

• 连接操作符往往并不高效(新创建对象, 把原有对象拷贝进去). 对于列表, 推荐使用extend来完成这样的操作; 对于字符串, 推荐使用join这样的方法.

a = [1,2,3,4]
b = [5,6]
a.extend(b)        #相当于把b的元素都插入到a的后面
print(a)    #[1, 2, 3, 4, 5, 6]

• 重复操作符(*): 让一个序列重复N次.

a  =[1,2,3]
print(a*3)    #[1, 2, 3, 1, 2, 3, 1, 2, 3]

序列的切片操作

• 切片操作符([ ], [A:B], [A:B:C]): 通过下标访问其中的某一个元素, 或者某个子序列

• 正数的索引以序列的起始位置作为起点, 负数的索引以序列的结束位置做为起点.
• 试图访问一个越界的索引, 会引发异常(可以简单理解成程序执行出错)

a  =[1,2,3]
print(a[100])
#执行结果：
IndexError: list index out of range

关于切片:左闭右开区间

方式1：[:] 左右两个端点都不写值,截取的是整个序列的元素,从头到尾

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

方式2：[A:B]

元素下标取值范围: [A,B)

a  =[1,2,3,4,5]
print(a[1:3])        #[2,3]         截取下标[1,3)的元素        
print(a[1:-1])        #[2,3,4]     截取下标[1,-1)的元素
print(a[:3])        #[1,2,3]     截取下标[0,3)的元素    
print(a[1:])        #[2,3,4,5]     截取下标[1,-1)的元素

如果左边端点不写,默认从0开始, 右边端点不写,默认截取到最后一个位置(即:-1位置)

方式3:[A:B:C] 第三个参数表示步长,即每隔多少个元素截取一个

• 扩展切片操作[::] 除了可以表示子序列的起始和结束位置, 还可以表示 "步长"

例子:

a = [1,2,3,4,5]
print(a[::2])   #每两个元素截取一个
#执行结果:
[1,3,5]

翻转字符串

字符串翻转, 这是一个非常基础, 也是笔试面试中会经常出现的一个题目. 我们学过C/C++, 有三种方法来解决这个问题.

方法1:首尾指针

char str[] = "abcdefg";
char* beg = str;
char* end = str + strlen(str);
while (beg < end) {
    swap(*beg++, *--end);
}

方法2:栈

char str[] = "abcdefg";
Stack stack;
char* p = str;
while(p) {
    stack.push(*p++);
}
int index = 0;
while(!stack.empty()){
    str[index++] = stack.top();
    stack.pop();
}

方法3:使用reverse + 迭代器翻转

#include <algorithm>
char str[] = "abcdefg";
std::reverse(str, str + strlen(str));    //指针就是天然的迭代器

python的做法:

a = "abcdefg"
print(a[::-1])

这个代码的含义:

a[::-1] -1表示往前走,从后往前拿元素

a = [1,2,3,4,5,6]
print(a[::-1])       #[6,5,4,3,2,1]
#含义
从-1位置往前走,先走到下标为-1位置，然后从6开始往前走

对于切片语法来说, 下标越界也没关系. 因为取的是前闭后开区间，区间里的元素, 能取到多少就取到
多少.

序列内建函数

len函数

len: 返回序列的长度.

a = [2,3,4,5]
print(len(a))    #4
b = "hello"
print(len(b))    #5

max函数 -O(N)

max: 返回序列中的最大值

a = [2,3,4,5]
print(max(a))    #5
b = "helloz"
print(max(b))    #z

min函数 -O(N)

min: 返回序列中的最小值

a = [2,3,4,5]
print(min(a))    #2
b = "helloz"
print(min(b))    #e

sorted函数

sorted: 排序. 这是一个非常有用的函数. 返回一个有序的序列(输入参数的副本).

a = ['abc','acb','a','b']    
print(sorted(a))    #['a', 'abc', 'acb', 'b']
a = [5,3,3,1,5]
print(sorted(a))    #[1, 3, 3, 5, 5]

sorted可以支持自定制排序规则

sum函数

sum: 序列中的元素求和( 要求序列中的元素都是数字)

a = [1,2,3,4,5]
print(sum(a))    #15
a= [1,'a']
print(sum(a))    #报错  unsupported operand type(s) for +: 'int' and 'str'

enumerate函数

enumerate: 同时枚举出序列的下标和值 可以避免很多丑陋的代码.

例如:找出元素在列表中的下标

a = [1,2,3,4,5]
def Find(input_list,x):
    for i in range(0,len(input_list)):
        if input_list[i] == x:
            return  i
    else:   #此处的else和for搭配
        return None

print(Find(a,2))    #1  下标为1

这里用for循环写的就不够优雅,使用enumerate函数就可以写的很优雅

a = [1,2,3,4,5]
def Find(input_list,x):
    for i ,item in enumerate(input_list):
        if item == x:
            return  i
    else:   #此处的else和for搭配
        return None

print(Find(a,2))    #1 下标为1

zip函数

zip: 这个函数的本意是 "拉链",

x = [1,2,3]
y = [4,5,6]
z = [7,8,9,10]    #多余的10不要，3行3列

print(zip(x,y,z))   #直接打印是对象的id    <zip object at 0x000001581CFE7748>
#把执行结果强转为list,列表
print(list(zip(x,y,z)))    #[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

#直观打印
for i in zip(x,y,z):
    print(i)
#执行结果：
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)

zip可以理解为行列互换

zip的一个比较常见的用法, 就是构造字典

key = ('name','id','score')
value =('Mango','2022','99')
d = dict(zip(key,value))    #执行结果转为一个字典
print(d)    #  {'name': 'Mango', 'id': '2022', 'score': '99'}