数据类型
https://www.liaoxuefeng.com/wiki/1016959663602400
列表和字典的区别
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
列表的用法
#list列表的用法
#list是一种有序的集合，可以随时添加和删除其中的元素
classmates = ['Michael', 'Bob', 'Tracy']
classmates
['Michael', 'Bob', 'Tracy']
classmates[0]
classmates[1]
classmates[2]
'Tracy'
#除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素，索引
classmates[-1]
'Tracy'
classmates[-2]
'Bob'
#list是一个可变的有序表，所以，可以往list中追加元素到末尾：追加
classmates.append('Adam')
classmates
['Michael', 'Bob', 'Tracy', 'Adam']
#也可以把元素插入到指定的位置，比如索引号为1的位置：
classmates.insert(1, 'Jack')
classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
#要删除list末尾的元素，用pop()方法：
classmates.pop()
classmates
['Michael', 'Jack', 'Bob', 'Tracy']
#要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
classmates.pop(1)
classmates
['Michael', 'Bob', 'Tracy']
#要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：替换
classmates[1] = 'Sarah'
classmates
['Michael', 'Sarah', 'Tracy']
#list里面的元素的数据类型也可以不同，比如：
L = ['Apple', 123, True]
#list元素也可以是另一个list，比如：
s = ['python', 'java', ['asp', 'php'], 'scheme']
#list里面的元素的数据类型也可以不同，比如：
L = ['Apple', 123, True]
#list元素也可以是另一个list，比如：
s = ['python', 'java', ['asp', 'php'], 'scheme']
List¶
# 与元组对⽐，列表的⻓度可变、内容可以被修改。
a_list = [2, 3, 7, None]
tup = ('foo', 'bar', 'baz')
# 转换为列表
b_list = list(tup)
b_list
['foo', 'bar', 'baz']
b_list[1] = 'peekaboo'
b_list
['foo', 'peekaboo', 'baz']
# list函数常⽤来在数据处理中实体化迭代器或⽣成器
gen = range(10)
gen
# 生成随机列表
list(gen)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Adding and removing elements
添加和删除元素
# 可以⽤append在列表末尾添加元素：
# 添加和删除元素
# 可以⽤append在列表末尾添加元素：
b_list.append('dwarf')
b_list
['foo', 'peekaboo', 'baz', 'dwarf']
# insert可以在特定的位置插⼊元素：
# 与append相⽐，insert耗费的计算量⼤，因为对后续
# 元素的引⽤必须在内部迁移，以便为新元素提供空间
b_list.insert(1, 'red')
b_list
['foo', 'red', 'red', 'peekaboo', 'baz', 'dwarf']
# insert的逆运算是pop，它移除并返回指定位置的元素：
b_list.pop(2)
b_list
['foo', 'red', 'baz', 'dwarf']
b_list.append('foo')
b_list
['foo', 'red', 'baz', 'dwarf', 'foo']
# 可以⽤remove去除某个值，remove会先寻找第⼀个值并除去：
# 如果不考虑性能，使⽤append和remove，可以把Python的列表
# 当做完美的“多重集”数据结构。
b_list.remove('foo')
b_list
['red', 'baz', 'dwarf']
Python是线性搜索列表中的值，但在字典和集合中，在同样的时
# 间内还可以检查其它项（基于哈希表）
# ⽤in可以检查列表是否包含某个值,是否在列表中
# Python是线性搜索列表中的值，但在字典和集合中，在同样的时
# 间内还可以检查其它项（基于哈希表）
'dwarf' in b_list
True
'dwarf' not in b_list
False
Concatenating and combining lists
# 串联和组合列表
# 与元组类似，可以⽤加号将两个列表串联起来： 合并列表
[4, None, 'foo'] + [7, 8, (2, 3)]
[4, None, 'foo', 7, 8, (2, 3)]
通过加法将列表串联的计算量较⼤，因为要新建⼀个列表，并且
# 要复制对象。⽤extend追加元素，尤其是到⼀个⼤列表中，更为
# 可取。
# 如果已经定义了⼀个列表，⽤extend⽅法可以追加多个元素：追加多个元素
x = [4, None, 'foo']
x.extend([7, 8, (2, 3)])
x
# 通过加法将列表串联的计算量较⼤，因为要新建⼀个列表，并且
# 要复制对象。⽤extend追加元素，尤其是到⼀个⼤列表中，更为
# 可取。
[4, None, 'foo', 7, 8, (2, 3)]
everything = [] for chunk in list_of_lists: everything.extend(chunk)
everything = [] for chunk in list_of_lists: everything = everything + chunk
Sorting
排序
# 排序 对列表排序
# 你可以⽤sort函数将⼀个列表原地排序（不创建新的对象）：
a = [7, 2, 5, 1, 3]
a.sort()
a
[1, 2, 3, 5, 7]
# 我们可以按⻓度对字符串进⾏排序：
b = ['saw', 'small', 'He', 'foxes', 'six']
b.sort(key=len)
b
['He', 'saw', 'six', 'small', 'foxes']
对列表进行排序，二分搜索
Sorting
# 排序 对列表排序
# 你可以⽤sort函数将⼀个列表原地排序（不创建新的对象）：
a = [7, 2, 5, 1, 3]
a.sort()
a
[1, 2, 3, 5, 7]
，寻找插入的位置
# ⼆分搜索和维护已排序的列表
# bisect模块⽀持⼆分查找，和向已排序的列表插⼊值。
# 向有序列表中插入值 ，寻找插入的位置
# bisect.bisect可以找到插⼊值后仍保证排序的位置，
# bisect.insort是向这个位置插⼊值：
import bisect
c = [1, 2, 2, 2, 3, 4, 7]
bisect.bisect(c, 2)
c
[1, 2, 2, 2, 3, 4, 7]
bisect.bisect(c, 5)
6
3
# 直接使用 insort 插入比先使用 bisect 再使用 insert 速度更快
bisect.insort(c, 3)
c
[1, 2, 2, 2, 3, 3, 4, 6, 7, 7, 8]
元组的用法
元组基础知识
#tuple
#另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
classmates = ('Michael', 'Bob', 'Tracy')
#tuple
#另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
classmates = ('Michael', 'Bob', 'Tracy')
#
#classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
#不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
#所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
t = (1,)
t
#Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号
(1,)
t
#列表与元组组合
#最后来看一个“可变的”tuple
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
t
('a', 'b', ['X', 'Y'])
Tuple
#元组是⼀个固定⻓度，不可改变的Python序列对象。创建元组的 最简单⽅式，是⽤逗号分隔⼀列值：
tup = 4, 5, 6
tup
(4, 5, 6)
nested_tup = (4, 5, 6), (7, 8)
nested_tup
((4, 5, 6), (7, 8))
tuple([4, 0, 2])
#⽤tuple可以将任意序列或迭代器转换成元组：
tup = tuple('string')
tup
('s', 't', 'r', 'i', 'n', 'g')
tup[0]
's'
#元组中存储的对象可能是可变对象。⼀旦创建了元组，元组中的对象就不能修改了
tup = tuple(['foo', [1, 2], True])
tup[2] = False
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-8-942119627f36> in <module>()
1 #元组中存储的对象可能是可变对象。⼀旦创建了元组，元组中的对象就不能修改了
2 tup = tuple(['foo', [1, 2], True])
----> 3 tup[2] = False
TypeError: 'tuple' object does not support item assignment
#列表，可以在原位进⾏修改：
tup[1].append(3)
tup
('foo', [1, 2, 3], True)
#⽤加号运算符将元组串联起来：
(4, None, 'foo') + (6, 0) + ('bar',)
(4, None, 'foo', 6, 0, 'bar')
#元组乘以⼀个整数，像列表⼀样，会将⼏个元组的复制串联起来
('foo', 'bar') * 4
Unpacking tuples
# 拆分元组
tup = (4, 5, 6)
a, b, c = tup
b
5
tup = 4, 5, (6, 7)
a, b, (c, d) = tup
d
7
tmp = a a = b b = tmp
a, b = 1, 2
a
b
b, a = a, b
a
b
# 变量拆分常⽤来迭代元组或列表序列，遍历元组
seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
for a, b, c in seq:
print('a={0}, b={1}, c={2}'.format(a, b, c))
a=1, b=2, c=3
a=4, b=5, c=6
a=7, b=8, c=9
# ⾼级的元组拆分功能，rest的部分是想要舍弃的部分
values = 1, 2, 3, 4, 5
a, b, *rest = values
a, b
rest
[3, 4, 5]
a, b, *_ = values
_
[3, 4, 5]
Tuple methods
统计某个值
# 得出现频率
a = (1, 2, 2, 2, 3, 4, 2)
a.count(2)
统计某个值
# 得出现频率
a = (1, 2, 2, 2, 3, 4, 2)
a.count(2)
#元组:以小括号形式的数据结合,(1,2,"abc",True)
#可以存储任意数据类型
#注意:元组可以根据下标获取数据,但是不能对元组进行数据修改
my_tuple = (1,4,"abc",True,1.2)
print(my_tuple,type(my_tuple))
#根据下标取值
value = my_tuple[-1]
print(value)
#元组不能根据下标删除数据
# del my_tuple[2]
# print(my_tuple)
#修改数据
# my_tuple[0] = 3
# print(my_tuple)
#注意不论元组里面装什么数据类型都不可以修改
my_tuple = (1,[2,3])
# my_tuple[1] = [2,3]
my_list = my_tuple[1]
print(my_list)
my_list = [1,2]
print(my_tuple)
#定义一个空的元组
#坑:如果定义的元组,只有一个元素,那么元组的类型为元素的类型
#如果指定只传一个元素,还想保证是元组类型,那么需要加上逗号
my_tuple = (1,)
print(my_tuple,type(my_tuple))
#判断数据是否正在元组里面
my_tuple = (10,5,10,10)
result = 5 in my_tuple
print(result)
result = 3 not in my_tuple
print(result)
#元组中元素的下标(字符串,列表,元组都是有下标的, 有序的)
result = my_tuple.index(5)
print(result)
#元组中元素的个数
result = my_tuple.count(10)
print(result)
# my_tuple = (10,20)
# my_tuple[0] = 100
# print(my_tuple)
my_tuple = (0,[10,20])
my_list = my_tuple[1]
print(my_list)
my_list[0] = 20
#硬修改元组里面的元素
print(my_list)
print(my_tuple)
序列函数
# 序列函数
# Python有⼀些有⽤的序列函数。
# enumerate
Built-in Sequence Functions
i = 0 for value in collection:
do something with value
i += 1
for i, value in enumerate(collection):
do something with value
# Python内建了⼀个enumerate函数，可以返
# 回(i, value)元组序列：
some_list = ['foo', 'bar', 'baz']
mapping = {}
for i, v in enumerate(some_list):
mapping[v] = i
mapping
{'foo': 0, 'bar': 1, 'baz': 2}
sorted
# sorted函数可以从任意序列的元素返回⼀个新的排好序的列表：
sorted([7, 1, 2, 6, 0, 3, 2])
sorted('horse race')
[' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']
zip
元组
# zip函数 拼接元组
# zip可以将多个列表、元组或其它序列成对组合成⼀个元组列表：
seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zipped = zip(seq1, seq2)
list(zipped)
[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]
# zip可以处理任意多的序列，元素的个数取决于最短的序列：
seq3 = [False, True]
list(zip(seq1, seq2, seq3))
[('foo', 'one', False), ('bar', 'two', True)]
for i, (a, b) in enumerate(zip(seq1, seq2)):
print('{0}: {1}, {2}'.format(i, a, b))
0: foo, one
1: bar, two
2: baz, three
# 给出⼀个“被压缩的”序列，zip可以被⽤来解压序列。也可以当
# 作把⾏的列表转换为列的列表。这个⽅法看起来有点神奇：
pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),
('Schilling', 'Curt')]
first_names, last_names = zip(*pitchers)
first_names
# last_names
('Nolan', 'Roger', 'Schilling')
reversed
reversed函数
#reversed函数
#reversed可以从后向前迭代⼀个序列：
集合 set
#集合 set
#set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
#要创建一个set，需要提供一个list作为输入集合：
#注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
s = set([1, 2, 3])
s
{1, 2, 3}
#添加元素，通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
s.add(4)
s
{1, 2, 3, 4}
s.add(4)
s
{1, 2, 3, 4}
#通过remove(key)方法可以删除元素：
s.remove(4)
s
{1, 2, 3}
#set交集、并集等操作：
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
{2, 3}
s1 | s2
{1, 2, 3, 4}
