python内置数据结构 - list

目录：

分类
数字的处理函数
类型判断
list
练习题

一. 分类

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)