python语法 数据结构-列表和元组

文章目录

  • 1. 列表
    • 1. 1. 列表特征
    • 1. 2. 创建列表
    • 1. 3. 列表常用方法
      • 1. 3.1 `lst.append(x)`
      • 1. 3.2 `lst.extend(L)`
      • 1. 3.3 ` lst. inser(index, x)`
      • 1. 3.4 `lst.pop([index])`
      • 1. 3.5 `Ist.remove(x)`
      • 1. 3.6 `lst.coun(x)`
      • 1. 3.7 `lst.sort(key=None, reverse=False)`
      • 1. 3.8 `lst.sort(key=None, reverse=False)`
      • 1. 3.9 `lst.clear()`
      • 1. 3.10 ` lst.copy()`
    • 1. 4. 获取列表值
      • 1. 4.1 通过索引
      • 1. 4.2 通过迭代
      • 1. 4.3 通过列表切片
    • 1. 5. 列表与运算符
    • 1.6. 列表表达式
  • 2. 元组
    • 2. 1. 元组特征
    • 2. 2. 创建空元组
    • 2. 3. 更新元组

1. 列表

列表类型list

1. 1. 列表特征

  • 列表中的每一个元素都是可变的
  • 列表中的元素是有序的,也就是说每一个元素都有一个位置
  • 列表可以容纳 Python 中的任何对象

1. 2. 创建列表

创建列表和创建普通变量一样, 用中括号括起一堆数据就可以了, 数据之间用逗号隔开

创建空列表

a = []

1. 3. 列表常用方法

1. 3.1 lst.append(x)

x 追加至列表 lst 的尾部,不影响列表中已有元素的位置,也不影响列表在内存中的起始地址。

a = [1, 2, 3, 4]
a.append(5)
print(a)

输出:
[1, 2, 3, 4, 5]

1. 3.2 lst.extend(L)

将列表 L 中所有元素追加至列表 lst 的尾部,不影响 lst 列表中已有元素的位置,也不影响 lst 列表在内存中的起始地址。

a = [1, 2, 3, 4]
b = [5, 6, 7]
a.append(b)
print(a)

输出:
[1, 2, 3, 4, 5, 6, 7]

1. 3.3 lst. inser(index, x)

在列表 lstindex 位置处插入 x ,该位置之后的所有元素自动向后移动,索引加1。

a = [1, 2, 3, 4]
a.insert(0, 0)
print(a)

输出:
[0, 1, 2, 3, 4]

1. 3.4 lst.pop([index])

删除并返回列表 lst 中下标为 index 的元素,该位置后面的所有元素自动向前移动,索引减1。index 默认为-1,表示删除并返回列表中最后一个元素。

a = [1, 2, 3, 4]
a.pop(0)
print(a)

输出:
[2, 3, 4]

1. 3.5 Ist.remove(x)

在列表 lst 中删除第一个值为 x 的元素,被删除元素位置之后的所有元素自动向前 移动,索引减1;如果列表中不存在 x 则抛出异常。

a = [1, 2, 3, 4]
a.remove(3)
print(a)

输出:
[1, 2, 4]

1. 3.6 lst.coun(x)

返回 x 在列表 lst 中的出现次数。

a = [1, 2, 3, 3]
b = a.count(3)
print(b)

输出:
2

1. 3.7 lst.sort(key=None, reverse=False)

对列表 lst 中的元素进行原地排序,key 用来指定排序规则,reverseFalse 表示升序,为 True 表示降序。默认不需要参数, 从小到大排队

a = [5, 3, 1, 4, 2]
a.sort()
print(a)

输出:
[1, 2, 3, 4, 5]

1. 3.8 lst.sort(key=None, reverse=False)

对列表 lst 的所有元素进行原地逆序,首尾交换。

a = [1, 2, 3, 4, 5]
a.sort()
print(a)

输出:
[5, 4, 3, 2, 1]

1. 3.9 lst.clear()

清空列表 lst 所有元素。

1. 3.10 lst.copy()

生成列表 lst 的副本,可以通过赋值传递给别一个变量。

a = [1, 2, 3, 4, 5]
b = a.copy()
a[0] = 0;
print(a)
print(b)

输出:
[0, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

1. 4. 获取列表值

1. 4.1 通过索引

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

输出:
1

1. 4.2 通过迭代

a = [1, 2, 3, 4, 5]
for index in a:
	print(index)

输出:
1 2 3 4 5

1. 4.3 通过列表切片

用一个冒号隔开两个索引值, 左边是开始位置, 右边是结束位置。 这里要注意的一点是, 结束位置上的元素是不包含的。
利用列表分片,得到一个原来列表的拷贝, 原来列表并没有发生改变。

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

a[1:]
a[:2]
a[::2]

输出:

1. 5. 列表与运算符

  • + 连接符
  • * 重复运算符
  • in
  • not in

1.6. 列表表达式

[ 表达式 for 迭代变量 in 可迭代对象 if 条件表达式 ]

arr = [i for i in range(5)]
print(arr)

输出: 0 1 2 3 4

arr = [i * i for i in range(6) if i*i <= 9 ]
print(arr)

输出: 0 1 4 9 

2. 元组

元组类型tuple

2. 1. 元组特征

元组其实可以理解为一个稳固版的列表,因为元组是不可以被修改的,因此在列表中的存在的方法均不可以使用在元组上,但是元组是可以被查看=索引的,方式就和列表一样

2. 2. 创建空元组

a = () # 创建空元组
a = (1, ) # 元组只有一个元素

2. 3. 更新元组

可以通过切片的方式更新元组

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

输出:
(1, 2, 4, 3)

你可能感兴趣的:(Python,python)