Python内置数据结构——列表list

内置数据结构分类:

数值型

int , float , complex , bool

序列对象

字符串 str

列表 list

tuple(元组)

键值对

集合 set

字典 dict

数字型

• int ,float , complex , bool都是class, 1,5.0 , 2+3j都是对象的实例

• int : python3的int就是长整型,没有大小限制,受限于内存大小

• float:有整数部分和小数部分组成,支持十进制和科学计数法表示,只有双精度型

• complex:有实数和虚部组成,实部和虚部都是浮点数,3+4j

• bool:int 的子类,仅有2个实例True和False 对应 1和0,可以和整数直接运算

  
  

列表 list()

       列表是可变的,连续的(sequence),可以进行索引的,线性数据结构,可迭代的数据结构

区分:

    list列表: 查找快...但是从修改(增/删)的时候,很麻烦很慢

    link链表: 查找慢...但是修改快,查找很慢

    queue(队列): 先进先出~

    stack(栈): 先进后出,后进先出(堆栈)

列表list定义:  初始化

    list() ->new empty list

    list(iterable) -> new list initialized from iterable's items

    list不能一开始就定义大小

lst = list()
lst = []
lst = [2,5,6,'ab']
lst = list(range(5))

索引 index: 也叫下标,从0️开始

• 正索引: 从左至右,从0开始,为列表中每个单元进行编号

• 负索引:从右至左,从-1开始

• 正负索引不可超界,否则发生一场:Index Error

• 列表通过索引访问:list[index],index就是索引,使用中包括访问

列表查询方法:

1.L.index(valve,[start,stop])

• 通过元素值,从指定区间查找列表内的元素是否匹配

• 匹配到第一就立刻返回索引

• 匹配不到,抛出异常valveError

2.count(valve)

• 返回列表中匹配到valve的次数

• 时间复杂度:

• index和count方法都是O(n)[遍历]

• 随着列表数据规模的增大,效率下降

len():输出列表的长度

列表元素修改

索引访问修改 ，索引不要超界

list[index] = valve

列表增加,插入列表

返回None意味着没有新的列表产生,就地修改

1.L.append(object) -> None

• 列表尾部追加元素,返回None

• 实际复杂度是O(1)

2.L.insert(index,object) -> None

• 在指定的索引 index处插入语元素

• 时间复杂度是O(n)

• 此处index可以超界:

• 超越上界,尾部追加;

• 超越下界,头部追加

3.L.extend(iterable) -> None

• 将可迭代对象的元素追加进来,返回None

返回 list ,意味着产生了新的list

1. + -> list

• 连接操作,将两个列表连接起来

• 产生新的列表,原列表不变

• 本质上调用的是__add___()方法

2. *  -> list

• 重复操作,将本列表元素重复n次,返回新的列表

• 列表 * 重复的坑:

x = [[1,2,3]] * 3
print(x)
x[0][1] = 20
print(x)

[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
[[1, 20, 3], [1, 20, 3], [1, 20, 3]]

y = [1] * 5
y[0] = 6
y[1] = 7
print(y)

[6, 7, 1, 1, 1]

列表删除元素

1. L.remove(valve) -> None

• 从左至右查找第一个匹配Valve的值,移除该元素,返回None

• 就地修改

• 效率:时间复杂度= O(n)

2. L.pop([index]) -> item

• 不指定索引 index,就从列表尾部弹出一个元素

• 指定索引 index,就从index处弹出一个元素,索引超界抛出IndexError错误

• 效率:不指定索引 Index时 时间复杂度= O(1) ,指定索引(从头,或中间), 时间复杂度=O(n)

3. L.clear() -> None

• 清除列表所有元素,剩下一个空列表

其它列表操作

1. L.reserve() -> None

• 将列表元素反转,返回None

• 就地修改

2. L.sort(key=None,reserve=Flase) -> None

• 对列表元素进行排序,就地修改,默认升序

• reserve为True,反转,降序

• key= 一个函数,按照key的内容进行排序

• lst.sort(key=functionname),exp: lst.sort(key = str) 按照字符串进行排序

3. in , not in

• [3,4] in [1,2,[3,4]]

• [5] not in [1,2,[3,4]]

• for x in [1,2,[3,4]]

列表复制

L.copy() -> List

• 返回一个新的列表

1.浅拷贝shadow copy:

        影子拷贝,也叫浅拷贝,遇到引用类型,只是复制了一个引用而已

lst0 = [1,[2,3,4],5]
lst5 = lst0.copy()
lst5[1][1] = 20
print(lst5)
print(lst0)

[1, [2, 20, 4], 5]
[1, [2, 20, 4], 5]

2.深拷贝deepcopy

        copy模块提供了deepcopy

import copy
lst0 = [1,[2,3,4],5]
lst5 = copy.deepcopy(lst0)
lst5[1][1] = 20
lst5 ! == lst0
print(lst5)
print(lst0)

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

随机数 random模块

1. random.randint(a,b)  -> item

• 返回[a,b]之间的随机数

2. random.randrange([start],stop,[step])  -> item

• 从指定范围内,按指定基数递增的集合中获取一个随机数, 基数缺省值为1. random.randrange(1,7,2)

3. random.choice()  -> item

• 从非空序列的元素中随机抽取一个元素,exp: random.choice(range(10)) 从0到9中随机挑选一个整数.random.choice([1,3,5,7])

4. random.shuffle(list) -> none

• 就地打乱列表元素

5. random.sample(population,k) -> list

• 从样本空间或总体(序列或者集合类型) 中随机取出 k个不同(索引位置)的元素,返回一个新的列表. exp:

random.sample(['a','b','c','d'],2)
random.sample(['a','b'] ,2

元组

一个有序的元素组成的集合

使用小括号()表示

元组是不可变对象

元组的定义 初始化

定义:

    tuple() -> empty tuple

    tuple(iterable) -> tuple initialized from iterable's items

t = tuple()

t = ()

t = tuple(range(1,7,2)) 可迭代对象

t = (1,) # 一个元素元组的定义,注意要有个逗号

t = (1,) * 5

t = (1,2,3) * 6

元组元素的访问

• 支持索引(下标)

• 元组通过索引访问

      tuple[index]: t[1]

• 正索引:从左至右,从0开始

• 负索引:从右至左,从-1开始

• 正负索引不可超界.否则引发一场Index Error

元组查询

1.t.index(valve,[start,stop])

• 通过值value,从指定区间查找元组内的元素是否匹配

• 匹配到第一就立刻返回索引

• 匹配不到,抛出异常valveError

2.count(valve)

• 返回元组中匹配到valve的次数

• 时间复杂度:

• index和count方法都是O(n)[遍历]

• 随着列表数据规模的增大,效率下降

• len():返回元素的个数

元组不可变,只读,所以没有增,删,改的方法

命名元组namedtuple

namedtuple(typename,field_names,verbose= False,rename=False)

• 命名元组,返回一个元组的子类,并定义了字段

• field_names可以是空白符或逗号分割的字段的字符串,可以是字段的列表

from collections import namedtuple
point = namedtuple("_point",["x", "y"]) # point为返回的类
p = point(11,22)

Exp:
fORM collections import namedtuple
Student = namedtuple("Student","name age")
tom = Student("tom",20)
jerry = Student("jerry,18")
tome.name