这里查看效果更好哪里

3.1数据结构和序列

python数据结构简单强大，主要有元组、列表、字典、集合

元祖

长度固定、不可变。
有两种方式创建：1、使用圆括号将元素括起来；2、直接使用逗号将元素分隔

tul1 = 1,2,3
tul2 = (4,5,6)

tul1

(1, 2, 3)

type(tul1)

tuple

使用tuple()函数可以将任何序列或者迭代器转换成元祖

tuple([1,2,3])

(1, 2, 3)

tuple(range(4))

(0, 1, 2, 3)

t3 = tuple('hello')
t3

('h', 'e', 'l', 'l', 'o')

可以使用方括号索引访问元素，从0开始

t3[4]

'o'

元组是不可变的，但是这种不可变是相对性的。仔细体会下面的实验

t = ('hello', 100, [1, 2],'world')
t[1]= 200

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-12-333a20f7f865> in <module>()1 t = ('hello', 100, [1, 2],'world')
----> 2 t[1]= 200TypeError: 'tuple' object does not support item assignment

t[2] = 1

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-13-45549d36daea> in <module>()
----> 1 t[2] = 1TypeError: 'tuple' object does not support item assignment

t[2][1] = 100

('hello', 100, [1, 100], 'world')

可以使用加号+运算符将元祖串联起来

(1,2,3) + ('hello', 100)

(1, 2, 3, 'hello', 100)

元祖乘以一个整数，会将元祖重复整数遍

(1,2,'hell') * 3

(1, 2, 'hell', 1, 2, 'hell', 1, 2, 'hell')

拆分元祖（解包）

tul = (1,2,'hell')
a,b,c = tul
a

'hell'

#即使含有元祖的元祖也可以拆分
tul = (1,2,('hell','jack'))
a,b,c = tul
c

('hell', 'jack')

a,b,c,d = tul   #注意此种解包会报错
c

---------------------------------------------------------------------------ValueError                                Traceback (most recent call last)<ipython-input-37-2a1bba36f192> in <module>()
----> 1 a,b,c,d = tul   #注意此种解包会报错2 cValueError: not enough values to unpack (expected 4, got 3)

a,b,(c,d) = tul
d

'jack'

#交换两个数的值，可以很方便
a, b = 10,20
a

a, b = b, a
a

变量的拆分常用来迭代元祖或者列表

seq = [(1,2,3),(4,5,6),(7,8,9)]
for a, b, c in seq:print('{}: {}: {}'.format(a,b,c))

1: 2: 3
4: 5: 6
7: 8: 9

解包时当变量数少于元素数时，可以从元祖中任意位置抓取几个元素

tul = (1,2,3,4,5)
# 开头抓取几个元素
*args, a, b = tul
print('args = {},  a = {},  b = {}'.format(args,a,b))

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

type(args)

list

type(a)

int

# 从中间位置抓取多个元素
a,*args,b = tul
print('a={},  args={},  b={}'.format(a,args,b))

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

# 从末尾抓取多个元素
a, b, *args = tul
print('a={},  b={},  args={}'.format(a,b,args))

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

tuple的方法

count()方法可以统计某个值出现的频率。也适用于列表

a = (1,2,3,4,1,1,4,4,2,2,4)
a.count(2)

列表list

列表可变、内容可以被修改
可以用方括号创建或者list()

L1 = [1,2,3,'hello']  #创建方式1
#创建方式2
t = (1,2,3,'hello')
L2 = list(t)

#访问
L1[1]

L1[3]

'hello'

#修改
L1[3] = 'world'
L1

[1, 2, 3, 'world']

list()函数常用来实体化迭代器或者生成器

gen = range(4)
gen

range(0, 4)

list(gen)

[0, 1, 2, 3]

列表的常用方法

append()、insert()、pop()、remove()、len()、sort()、in等
append()在列表末尾添加元素

name = ['Jack','Killy','Tom']
name.append('Jimmy')
name

['Jack', 'Killy', 'Tom', 'Jimmy']

insert(pos,val)在指定位置pos处添加元素val。该方法耗费的时间会比较大，因为它要将移动位置之后的元素往后移。
如果要在开头或者末尾插入数据，可以使用双端队列collections.deque

name.insert(2,'Lily')
name

['Jack', 'Killy', 'Lily', 'Tom', 'Jimmy']

pop(pos)是insert()的逆运算，注意不是append()的逆运算。用于删除指定位置的元素

name.pop(2)
name

['Jack', 'Killy', 'Tom', 'Jimmy']

remove(val)会删除最先找到的元素

name = ['Jack','Killy','Tom','Jack','Tom','Jack']
name

['Jack', 'Killy', 'Tom', 'Jack', 'Tom', 'Jack']

name.remove('Jack')
name

['Killy', 'Tom', 'Jack', 'Tom', 'Jack']

name.remove('Tom')
name

['Killy', 'Jack', 'Tom', 'Jack']

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

[1, 3, 2, 2, 2, 3, 4, 3]

使用in检查某个元素是否位于列表中，返回布尔值
在列表中检查是否存在某个值远比字典和集合速度慢，因为Python是线性搜索列表中的值，但在字典和集合中，在同样的时间内还可以检查其它项（基于哈希表）

'Killy' in name

True

'John' not in name

True

串联和组合列表

可以使用+组合两个列表

[1,2,3] + ['hello', 100]

[1, 2, 3, 'hello', 100]

extend()方法也可以添加。与 + 不同的是，+ 串联列表计算量更大，要创建新的list，并且要复制对象

L = [1,2,3]
L.extend([4,5,(10,100)])
L

[1, 2, 3, 4, 5, (10, 100)]

注意extend()和append()的区别

L1 = [1,2,3]
L2 = [1,2,3]
a = [4,5]
b = [4,5,(10,100)]
#注意区别
L1.append(a)
L1

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

L2.extend(a)
L2

[1, 2, 3, 4, 5]

len(L1)

len(L2)

L1.append(b)
L1

[1, 2, 3, [4, 5], [4, 5, (10, 100)]]

L2.extend(b)
L2

[1, 2, 3, 4, 5, 4, 5, (10, 100)]

排序

可以使用sort()进行原地排序，即不创建新的对象

a = [1,7,43,4,2,13,45]
a.sort()
a

[1, 2, 4, 7, 13, 43, 45]

sort()有一个选项key,可以指定按key进行排序

names  =['jack','hello','world','hi','forever']
names.sort(key=len)
names

['hi', 'jack', 'hello', 'world', 'forever']

二分搜索和维护已经排序的列表

bisect模块支持二分查找，和向已经排序的列表插入值。bisect.bisect可以找到插入值后仍保持排序的位置，bisect.insort是向这个位置插入值
注意：bisect模块不会检查列表是否已经排序

import bisect
c = [1,2,2,2,3,4,7]
bisect.bisect(c,2)

bisect.bisect(c,5)

[1, 2, 2, 2, 3, 4, 7]

bisect.insort(c,6)

[1, 2, 2, 2, 3, 4, 6, 7]

切片

seq = [1,3,4,5,3,5,7,10]
seq[:]#获取所有的元素

[1, 3, 4, 5, 3, 5, 7, 10]

seq[:3]#获取从头开始的三个元素

[1, 3, 4]

seq[-4:-1]

[3, 5, 7]

指定切片的步长

seq[0:6:2]

[1, 4, 3]

#将一个list反转过来的聪明做法是设置步长为1
seq[::-1]

[10, 7, 5, 3, 5, 4, 3, 1]

序列函数

enumerate()

names = ['foo', 'bar', 'baz']
mapping = {}
for i,val in enumerate(names):mapping[i] = val

mapping

{0: 'foo', 1: 'bar', 2: 'baz'}

# 可以指定一个起始值
mapping = {}
for i,val in enumerate(names,100):mapping[i] = val
mapping

{100: 'foo', 101: 'bar', 102: 'baz'}

sorted(),返回一个新的已经排序好的列表.
sort()函数直接对对象进行原地排序，并不生成新的对象。sorted()与此相反

a = [1,4,7,3,9,10,0]
sorted(a)

[0, 1, 3, 4, 7, 9, 10]

[1, 4, 7, 3, 9, 10, 0]

a.sort()
a

[0, 1, 3, 4, 7, 9, 10]

zip()函数将多个列表或者其它序列组合成一个新的元祖列表

seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zipped = zip(seq1,seq2)
list(zipped)

[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

#zip()可以处理任意多个序列，元素的个数取决于最短的序列
seq3 = [1,2]
list(zip(seq1, seq2, seq3))

[('foo', 'one', 1), ('bar', 'two', 2)]

#zip()最常用的用法是同时迭代多个序列，结合enumerate的使用
for i,(a,b) in enumerate(zip(seq1,seq2), start=1):print('{}:{},{}'.format(i,a,b))

1:foo,one
2:bar,two
3:baz,three

# zip()也可以解压序列，结合*
seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zipped = list(zip(seq1,seq2))
z1,z2 = zip(*zipped)
z1

('foo', 'bar', 'baz')

reversed()可以从后向前迭代一个序列
要记住reversed是一个生成器（后面详细介绍），只有实体化（即列表或for循环）之后才能创建翻转的序列。

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(reversed(range(10)))

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

字典

字典可能是Python最为重要的数据结构。它更为常见的名字是哈希映射或关联数组。它是键值对的大小可变集合，键和值都是Python对象。创建字典的方法之一是使用尖括号，用冒号分隔键和值：

empty_dict = {}
type(empty_dict)

dict

len(empty_dict)

d1 = {'a':1, 'b':[1,2,3]}
d1

{'a': 1, 'b': [1, 2, 3]}

# 访问
d1['b']

[1, 2, 3]

#插入
d1['c'] = 'hello'
d1

{'a': 1, 'b': [1, 2, 3], 'c': 'hello'}

#检查字典是否包含某个键值
'a' in d1

True

# 使用del关键字或者pop()方法删除值，删除键的同时返回值
d1[5] = '500'
d1[10] = 1000
d1

{'a': 1, 'b': [1, 2, 3], 'c': 'hello', 5: '500', 10: 1000}

del d1['b']

d1

{'a': 1, 'c': 'hello', 5: '500', 10: 1000}

d1.pop('c')

'hello'

d1

{'a': 1, 5: '500', 10: 1000}

#keys和values是字典的键和值的迭代器方法。
#虽然键值对没有顺序，这两个方法可以用相同的顺序输出键和值：
list(d1.keys())

['a', 5, 10]

list(d1.values())

[1, '500', 1000]

使用update()可以将一个字典和另一个字典融合.原地更新

d2 = {'b':'foo', 'c':12}
d1.update(d2)
d1

{'a': 1, 5: '500', 10: 1000, 'b': 'foo', 'c': 12}

3_1 Python的数据结构、函数和文件相关推荐

python open 打开是什么类型的文件-详解Python中open()函数指定文件打开方式的用法...
文件打开方式当我们用open()函数去打开文件的时候,有好几种打开的模式. 'r'->只读 'w'->只写,文件已存在则清空,不存在则创建. 'a'->追加,写到文件末尾 'b'- ...
【“笨办法”学Python】20.函数和文件
20.函数和文件文章目录前言一.Atom文本编辑器二.运行Python程序总结前言函数和文件在一起是如何一起协助发挥作用. 一.Atom文本编辑器 from sys import a ...
python 集合、函数、文件操作
集合一.集合的特性无序,不重复二.集合的创建方法 1. 大括号 >>> s = {11, 22, 33, 11} >>> s {33, 11, 22} 2.初 ...
python中write函数_第9.7节 Python使用write函数写入文件内容
一.语法 write(data) data为要写入的数据,可以为字符串str类型,也可以是bytes类型. 返回值为实际写入的数据数,在写入数据为str类型时,该数据为实际写入的UNIOCODE字符数 ...
第9.7节 Python使用write函数写入文件内容
一. 语法 write(data) data为要写入的数据,可以为字符串str类型,也可以是bytes类型. 返回值为实际写入的数据数,在写入数据为str类型时,该数据为实际写入的UNIOCODE字符 ...
python中open函数打开文件_Python open函数详解：打开指定文件
掌握了各种操作目录字符串或目录的函数之后,接下来可以准备读写文件了.在进行文件读写之前,首先要打开文件. Python 提供了一个内置的 open() 函数,该函数用于打开指定文件. open() 函 ...
python第三节函数，文件操作
文件操作#以读的方式打开文件# f=open('c.txt',encoding='utf-8')# print(f)# data = f.read() #以读的方式打开# print(data)# p ...
python中image.open函数怎么用_详解Python中open()函数指定文件打开方式的用法
文件打开方式当我们用open()函数去打开文件的时候,有好几种打开的模式. 'r'->只读 'w'->只写,文件已存在则清空,不存在则创建. 'a'->追加,写到文件末尾 'b'- ...
第9.8节 Python使用writelines函数写入文件内容
一. 语法 writelines(lines) 参数lines为一个列表,写入时列表中的每个元素不会自动添加换行符,因此通常需要在列表的每个元素后面添加换行符以确保写入的文件会分行. 注意:Pytho ...

3_1 Python的数据结构、函数和文件

这里查看效果更好哪里

3.1数据结构和序列

元祖

拆分元祖（解包）

tuple的方法

列表list

列表的常用方法

串联和组合列表

排序

二分搜索和维护已经排序的列表

切片

序列函数

字典

3_1 Python的数据结构、函数和文件相关推荐

最新文章

热门文章