python内置数据结构 - list

目录：

  1. 分类
  2. 数字的处理函数
  3. 类型判断
  4. list
  5. 练习题

一. 分类

1). 数值型：int（整型）, float（浮点型）, complex（复数）, bool （布尔型）

2). 序列对象：str （字符串）, tuple（元组）

3). 键值对：set（集合）, dict（字典）

二. 数字的处理函数

round(), 对浮点数取近似值

In [1]: round(2.675, 2)
Out[1]: 2.67

In [2]: round(2.676, 2)
Out[2]: 2.68

在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67。

floor(), 地板, 即总是向小的方向变换.

ceil(), 天花板, 即总是向大的方向变换.

注：floor()和ceil()使用前需先导入math模块.

In [3]: import math

In [4]: math.ceil(2.675)
Out[4]: 3

In [5]: math.floor(2.675)
Out[5]: 2

三. 类型判断

type(obj), 返回类型.

isinstance(obj, class_or_tuple), 返回布尔值.

In [1]: name = ‘ames‘

In [2]: type(name)
Out[2]: str

In [3]: isinstance(name, str)
Out[3]: True

In [4]: isinstance(name, list)
Out[4]: False

In [5]:

四. list 

1). 列表的特点 

1. 一个队列，一个排列整齐的队伍; 
2. 列表内的个体称作元素，由若干元素组成列表;
3. 元素可以是任意对象（数字，字符串，对象，列表，元组，字典等）;
4. 列表内元素有序，可以使用索引; 
5. 线性的数据结构; 
6. 使用[]表示;
7. 列表是可变的;

2). 列表定义, 初始化 

In [6]: lst = list()

In [7]: type(lst)
Out[7]: list

In [8]: lst
Out[8]: []

3). 列表索引访问 

列表可通过索引访问，索引也称作下标，索引分为正索引和负索引，索引超界会引发 IndexError.

4). 列表 - 增

创建列表 :

In [9]: fruits_list = [‘apple‘, ‘orange‘, ‘mango‘]

or

In [11]: fruits_list = list([‘apple‘, ‘orange‘, ‘mango‘])

增加元素 :   L.append(object)  -> None

In [12]: fruits_list
Out[12]: [‘apple‘, ‘orange‘, ‘mango‘]

In [13]: fruits_list.append(‘cherry‘)

In [14]: fruits_list
Out[14]: [‘apple‘, ‘orange‘, ‘mango‘, ‘cherry‘]

插入元素 :  L.insert(index, object)  -> None

In [17]: fruits_list.insert(1, ‘lime‘)

In [18]: fruits_list
Out[18]: [‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘, ‘cherry‘]

列表扩展 :   L.extend(iterable) -> None

In [22]: number = [‘first‘, ‘second‘, ‘third‘]

In [23]: fruits_list.extend(number)

In [24]: fruits_list
Out[24]: [‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘, ‘cherry‘, ‘first‘, ‘second‘, ‘third‘]

In [25]:

连接操作 : ‘+ -‘   -> list 

In [25]: fruits_list = [‘apple‘, ‘lime‘, ‘orange‘]

In [26]: number = [‘first‘, ‘second‘, ‘third‘]

In [27]: fruits_list + number
Out[27]: [‘apple‘, ‘lime‘, ‘orange‘, ‘first‘, ‘second‘, ‘third‘]

重复操作 :  ‘*‘  -> list 

In [28]: fruits_list = [‘apple‘, ‘lime‘, ‘orange‘]

In [29]: fruits_list * 2
Out[29]: [‘apple‘, ‘lime‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘]

5). 列表 - 删  

根据value删除元素 :  L.remove(value) -> None  

In [33]: fruits_list = [‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [34]: fruits_list.remove(‘lime‘)

In [35]: fruits_list
Out[35]: [‘apple‘, ‘orange‘, ‘mango‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

根据索引值删除元素 :   L.pop([index]) -> item

注：不指定索引值，就从列表尾部弹出一个元素, 索引超界会报错 IndexError

In [36]: fruits_list
Out[36]: [‘apple‘, ‘orange‘, ‘mango‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [37]: fruits_list.pop(2)
Out[37]: ‘mango‘

In [38]: fruits_list
Out[38]: [‘apple‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

清除列表所有元素 :  L.clear() -> None 

注：清除列表所有元素后，剩下一个空列表；

In [39]: fruits_list
Out[39]: [‘apple‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [40]: fruits_list.clear()

In [41]: fruits_list
Out[41]: []

6). 列表 - 改 

通过索引访问修改 :  list[index] = value

注：索引不要越界.

In [44]: fruits_list = [‘apple‘, ‘lime‘, ‘orange‘]

In [45]: fruits_list[1] = ‘mango‘

In [46]: fruits_list
Out[46]: [‘apple‘, ‘mango‘, ‘orange‘]

7). 列表 - 查

查找元素对应的索引值 :  L.index(value, [start, [stop]]) -> integer 

注：查找时，匹配到一个就立即返回，否则报错 ValueError   

In [48]: fruits_list = [‘apple‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [49]: fruits_list.index(‘apple‘, 1, 5)
Out[49]: 2

匹配列表中元素出现次数 :  L.count(value) -> integer  

In [50]: fruits_list = [‘apple‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [51]: fruits_list.count(‘apple‘)
Out[51]: 2

8). 列表其他操作： 

将列表元素反转 :   L.reverse() -> None 

In [52]: fruits_list
Out[52]: [‘apple‘, ‘orange‘, ‘apple‘, ‘lime‘, ‘orange‘, ‘mango‘]

In [53]: fruits_list.reverse()

In [54]: fruits_list
Out[54]: [‘mango‘, ‘orange‘, ‘lime‘, ‘apple‘, ‘orange‘, ‘apple‘]

对列表排序 :  L.sort(key=None, reverse=False) -> None

注：排序时默认升序，reverse为True，则反转降序排列；key指定一个函数，指定如何排序。

In [59]: fruits_list
Out[59]: [‘mango‘, ‘orange‘, ‘lime‘, ‘apple‘, ‘orange‘, ‘apple‘]

In [60]: fruits_list.sort()

In [61]: fruits_list
Out[61]: [‘apple‘, ‘apple‘, ‘lime‘, ‘mango‘, ‘orange‘, ‘orange‘]

In [62]: fruits_list.sort(key=len)

In [63]: fruits_list
Out[63]: [‘lime‘, ‘apple‘, ‘apple‘, ‘mango‘, ‘orange‘, ‘orange‘]

判断一个元素是否在列表中 :  in

注：返回结果为bool.

In [64]: ‘apple‘ in fruits_list
Out[64]: True

9). 列表复制  

列表复制 :  L.copy() -> list -- a shallow copy of L 

shadow copy : 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已. 

深拷贝 :  copy模块提供了 deepcopy

浅拷贝在内存中只额外创建第一层数据.

深拷贝在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

浅拷贝：

In [65]: lst0 = [1, 2, [3, 4, 5], 6]

In [66]: lst1 = lst0.copy()

In [67]: lst0 == lst1
Out[67]: True

In [68]: lst1[2][2] = 10

In [69]: lst1
Out[69]: [1, 2, [3, 4, 10], 6]

In [70]: lst1 == lst0
Out[70]: True

深拷贝：

In [71]: import copy

In [72]: lst2 = [1, 2, [3, 4, 5], 6]

In [73]: lst3 = copy.deepcopy(lst2)

In [74]: lst2 == lst3
Out[74]: True

In [75]: lst3[2][2] = 10

In [76]: lst3
Out[76]: [1, 2, [3, 4, 10], 6]

In [77]: lst2 == lst3
Out[77]: False

10). 随机数  

使用random模块

randint(a, b)返回[a, b]之间的整数;

choice(seq) 从非空序列的元素中随机挑选一个元素；

randrange([start], stop, [, step]) 从指定范围内按指定基数递增的集合中获取一个随机数，基数缺省值为1.

random.shuffle(list) -> None  就地打乱列表元素.

In [78]: import random

In [79]: random.randint(1, 10)
Out[79]: 3

In [80]: random.choice(range(10))
Out[80]: 9

In [81]: random.randrange(1, 10, 2)
Out[81]: 9

In [82]: lis = list(range(10))

In [83]: lis
Out[83]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [84]: random.shuffle(lis)

In [85]: lis
Out[85]: [6, 5, 3, 1, 7, 4, 9, 0, 8, 2]

In [86]:

五. 练习题

1. 求100以内的素数.

方法1：  合数一定可以分解为几个质数的乘积.

lis = []
for i in range(2, 100):
    for j in lis:
        if i % j == 0:
            break
    else:
        lis.append(i)
print(lis)

方法2： 合数就是能被从2开始到自己的平方根的正整数整除的数.

import math
lis = []
for i in range(2, 100):
    for j in range(2, math.ceil(math.sqrt(i))):
        if i % j == 0:
            break
    else:
        lis.append(i)
print(lis)

方法3：

import math
lis = []
flag = False
for i in range(2, 100):
    for j in lis:
        if i % j == 0:
            flag = True
            break
        elif j >= math.ceil(math.sqrt(i)):
            flag = False
            break
    if not flag:
        lis.append(i)
print(lis)

2. 计算杨辉三角前六行. 

方法1：下一行依赖上一行所有元素，是上一行所有元素的两两相加的和，再在两头各加1.

triangle = [[1], [1, 1]]
n = 6
for i in range(2, n):
    cur = [1]
    for j in range(i-1):
        cur.append(triangle[-1][j] + triangle[-1][j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

方法2：方法1的变体.

triangle = []
for i in range(6):
    row = [1]
    triangle.append(row)
    if i == 0:
        continue
    for j in range(i-1):   
        row.append(triangle[i-1][j] + triangle[i-1][j+1])
    row.append(1)
print(triangle)

方法3 - while

n = 6
oldline = []
newline = [1]
length = 0
print(newline)
for i in range(1, n):
    oldline = newline.copy()
    oldline.append(0)  # 尾部加0, 相当于两端加0.
    newline.clear()
    offset = 0
    while offset <= i:
        newline.append(oldline[offset-1] + oldline[offset])
        offset += 1
    print(newline)

方法3 - for

n = 6
oldline = []
newline = [1]
length = 0
print(newline)
for i in range(1, n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    offset = 0
    for j in range(i+1):
        newline.append(oldline[j-1] + oldline[j])
    print(newline)
时间： 2024-09-30 07:57:23

python内置数据结构 - list的相关文章

Python内置数据结构——列表list,元组tuple

内置数据结构分类: 数值型 int , float , complex , bool 序列对象 字符串 str 列表 list tuple(元组) 键值对 集合 set 字典 dict 数字型 int ,float , complex , bool都是class, 1,5.0 , 2+3j都是对象的实例 int : python3的int就是长整型,没有大小限制,受限于内存大小 float:有整数部分和小数部分组成,支持十进制和科学计数法表示,只有双精度型 complex:有实数和虚部组成,实部

Python内置数据结构

内置数据结构 可变 list 列表 byterray dict 字典 set 集合 不可变 tuple 元组 bytes 常量(int,str,bool 等) list 列表 (推荐使用索引)列表相当于一个排列整齐的队列,可以理解为在内存中是一片排列整齐的连续的空间,它是可索引,可变的,有序的,线性结构,可迭代.优点:通过索引(index)查找.替换元素 效率高 时间复杂度O(1).尾部追加(append)与 尾部移除(pop)元素快 效率高 时间复杂度O(1).缺点:从中间增加或移除元素会使列

Python内置数据结构操作VS sqlite3操作

1.摘要 在同一数据库中查询某值,内置数据结构的查询速度快还是数据库sqlite3的查询速度快?针对这一问题,通过构建一个包含2500个随机数的列表,并将其插入sqlite3数据库中,利用timeit模块,分别对内置数据结构list和sqlite3查询某一值在不在数据组中进行对比. 2.代码 >>> import numpy as np >>> import sqlite3 >>> test=np.random.randn(2500) >>

【Python】07、python内置数据结构之字符串及bytes

一.字符串 1.定义和初始化 In [4]: s = "hello python" In [4]: s = "hello python" In [5]: s Out[5]: 'hello python' In [6]: s = 'hello python' In [7]: s Out[7]: 'hello python' In [8]: s = '''hello python''' In [9]: s Out[9]: 'hello python' In [10]: 

Python内置数据结构3

解构 In [8]: lst = [1,2] In [9]: lst Out[9]: [1, 2] In [10]: first,second = lst  #解构 In [11]: print(first,second) 1 2 按照元素顺序,把线性结构的元素赋值给变量 解构的变化 In [21]: lst = list(range(10)) In [22]: lst Out[22]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] In [23]: head,*mid,tail

chapter . 2.2、Python内置数据结构：字符串、字节和字节数组

字符串 有序的序列,是字符的集合 使用单引号,双引号,三引号引注的字符序列 字符串是不可变对象,我们看到的合并字符串,其实是返回一个由原来两个值复制后返回的值,会占用新的空间. 从python3起,字符串是Unicode类型 s1 = 'string' s2 = '''this's a "string''' s3 = r"hello \n aasdasd"    :r和R表示忽略转义 s4 = R'windows \net' sql = """s

【Python】11、python内置数据结构之字典

一.字典 1.字典的初始化 字典是一种key-value结构 In [160]: d = {} In [161]: type(d) Out[161]: dict In [166]: d = {'a':1, 'b':2} In [167]: d Out[167]: {'a': 1, 'b': 2} In [180]: d = dict({"a":0, "b":1}) In [181]: d Out[181]: {'a': 0, 'b': 1} In [164]: d 

【Python】06、python内置数据结构1

一.数据结构与获取帮助信息 1.数据结构 通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数字或者字符,甚至可以是其它的数据结构. python的最基本数据结构是序列 序列中的每个元素被分配一个序号(即元素的位置),也称为索引:索引从0开始编号 2.python中如何获取命令帮助 获取对象支持使用的属性和方法:dir(), 某方法的具体使用帮助:help() 获取可调用对象的文档字串:print(obj.__doc__) In [15]: dir(list) Ou

python内置数据结构之list

列表简单总结 类和实例之间的理解         人类,哺乳类         实例是某一类中的真实个体 时间复杂度         O(1)         O(n)         O(n**2)         随着处理的数据逐渐增加,程序返回结果的时间变化的描述.             O(1)表示无论程序处理的数据如何增加,返回结果的时间是常数             O(n)随着处理数据的数量n的增加,返回结果的时间线性增长n             O(n)随着处理数据的数量n的