2019-02-13

python内置数据结构

内置数据结构

list

创建列表

一般方式创建列表

1. 直接赋值
a = []
2. 指定类型，转换数据类型
a = list((2,3,4))
3. 通过列表内涵，创建新列表
a = [1,2,3,5]
# 对于a中元素， 逐个放入b中
b = [i for i in a]
4. 使用分片操作
a = [1,2,3,4,5]
b = [:]

for 循环创建列表

# 对于a中元素， 逐个放入b中
b = [i for i in a]
# 每个数据乘以10 得到 [10, 20, 30, 50]
c = [i*10 for i in a]
# 过滤出偶数 得到 [0,2,4,6,8]
d = [i for i in range(0,10) if i%2 == 0]

for 循环嵌套创建列表

列表生成可以嵌套,等于两个for循环嵌套

# [11, 21, 31, 51, 12, 22, 32, 52, 13, 23, 33, 53, 15, 25, 35, 55]
l = [m+n for m in a for n in c]
# 等价于
for m in a:
    for n in c:
        # m+n

for循环嵌套读取数据

a = [[1,2], [3,4], [5,6]]
k, v的个数应该跟解包出来的变量个数一致， 否则会报错
for k, v in a:
    print(k, '---', v)

分片操作

包含中括号左边，不包含右边的值，默认步长为1
分片操作是生成一个新的list

分片下标超标不会报错

自然数下标

l = [1, 3, 5, 7, 9] 
# [1, 3, 5, 7, 9], 全部, 下标可以超出范围, 超出后不考虑多余的内容
l1 = l[:] 
# [3, 5, 7, 9], 从下标1开始到结束     
l2 = l[1:]
# [1, 3, 5, 7, 9], 从下标0开始到下标4结束
l3 = l[:4]
# [3, 5, 7], 默认步长为1, 包含左边的值, 不包含右边的值
l4 = l[1:4]
# [3, 7], 步长为2,步长可以为负数
l5 = l[1:4:2]

负数下标

l = [1, 3, 5, 7, 9]
下标：-5 -4 -3 -2 -1
l1 = l[-4:-2]  # [3, 5]
l1 = l[-2:-4]  # [] 分片默认从左往右截取，即正常情况下，左边的值小于右边的值
l1 = l[::-1]   # [9, 7, 5, 3, 1] 步长为负数,从右往左走,直接正反颠倒

list常用函数

方法	功能	使用
extend()	扩展列表, b直接拼接到a上	a.extend(b)
reverse	翻转a,原地翻转	a.reverse()
copy	浅拷贝,copy可以复制出一份,不改变之前的值(一层有效)	b=a.copy()
len()	返回列表长度	len(a)
	+	合并（连接）两个列表	a + b
*	重复列表内容	a = [1]*3 -> [1,1,1]
in	检查元素是否在列表中	x in a
not in	不在列表中	x not in a
append()	添加到列表末尾	a.append(x)
sort()	对列表排序	a.sort()
index()	返回第一个出现元素x的的索引值	a.index(x)
insert()	在i位置处插入新元素x	a.insert(i, x)
count()	返回元素x在列表中的数量	a.count(x)
remove()	删除列表中第一次出现的元素x	a.remove(x)
pop()	取出列表中i位置的元素,并将其删除	a.pop(i)
del	删除变量	del x
range()	生成可迭代数据 type：range	range(1,10)
max()	列表中的最大值	max(a)
min()	最小值	min(a)
list()	将其他格式的数据转换成list	list(a)

深拷贝与浅拷贝的区别

l = [1,2,3,['a','b','c']]
l1 = l.copy()
print(l1)
# [1, 2, 3, ['a', 'b', 'c']]
print(id(l))
print(id(l1))
# 84748296
# 58353288
# l和l1 id不一样，说明第一层指向不同的地址

print(id(l[3]))
print(id(l1[3]))
# 84748680
# 84748680
# l[3]和l1[3] id一样，说明第二层指向相同的地址

元祖

元祖可以看成是不可更改的list
是特殊的有序列表，可以通过索引访问

元祖的值可以访问，但是不能修改，使得代码更加安全

元祖的值可以是任意数据类型

list的特性，除了不能修改之外，元祖都具有（索引，分片，相乘，相加，成员资格操作等等）

元祖的不可修改指的是内容的不可修改，元祖变量重新赋值不会报错，修改内容会报错
一般用于表达固定数据项，函数多返回值等情况
元祖创建
1. 创建空元祖
t = ()
2. 创建只有一个值的元祖, 一定要有逗号， (1)为int型，代表一个数
t = (1,)
t = 1,
3. 创建多个值的元祖
t = (1,2,3,4,5)
t = 1,2,3,4,5
4. 使用其他结构转换成元祖
l = [1,2,3,4,5]
t = tuple(l)

元祖遍历

1. 单层元祖遍历
t = (1,2,3, 'ha','xi','he')
for i in t:
    print(i, end=" ")

2. 双层元祖遍历
t = ((1,2,3), ('ha','xi','he'))
# (1,2,3)  ('ha','xi','he')
for i in t:
    print(i)
# k m n 和最内层的个数对应
for k,m,n in t:
    print(k, '--', m, '--', n)

集合set

同数学中额集合概念一致，即包含0或多个数据项的无序组合
集合中的元素不可重复
集合是无序组合，没有索引和位置的概念
集合通常用于表示成员间的关系，元素去重等

集合创建

# set()函数用于集合的生成， 返回结果是一个无重复且排序任意的集合
a = set([1,1,1,2,3,4])

集合操作

集合操作	含义
s-t s.difference(t)	返回在集合s中但不在t中的元素
s&t s.intersection(t)	返回同时在集合s和t中的元素
s	t s.union(t)	返回集合s和t中的所有元素
s^t s.symmetric_difference(t)	返回集合s和t中的元素，但不包括同时在其中的元素

字典

本文标题:python内置数据结构

文章作者:yimi

发布时间:2019-02-13, 22:46:08

最后更新:2019-02-19, 23:31:28

原始链接:http://wttwhite.github.io/2019/02/13/python/data_type/

许可协议: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。