Python 数据结构

'''                    Pythone 数据结构 学习笔记                 '''
'''
python中的数据容器主要有：列表，元组，集合和字典

序列：是一种可以迭代，元素有序，可重复出现的数据结构，可通过索引访问
序列包括：列表，字符串，元组，范围，字节序列，可进行索引，分片，加和乘

'''

'''
                    1、列表

可以追加、插入、删除和替换列表中的元素
创建列表可以使用list(iterable)函数，或者用中括号[]将元素包裹起来，元素之间用逗号隔开
'''

a = list([])#创建一个新列表
print(type(a))
print(a);

b = []#创建一个新列表
print(type(b))
print(b)

'''报错，0是列表第一个元素'''
#print(b[0])

print(b[:])#打印空列表[]

c = [10]#创建一个新列表,带有一个元素
print(type(c))
print(c)

j = ['x'] *10 #初始化默认值为x，大小为10
print(j)

n_list = [10,]#创建一个新列表,带有一个元素
print(type(n_list))
print(n_list)

n_list.append("周松松")#追加一个元素
print(n_list)

n_list.extend([1,2,3,4,5,6,])#追加多个元素
print(n_list)

del n_list[2] #删除第3个元素
print(n_list)

n_list.insert(0,"谢杰")#在指定位置插入元素
print(n_list)

n_list[0] = "张三"#修改元素
print(n_list)

'''
remove方法是从左到右查找元素，如果找到就删除，如果多个，删除第一个，没找到抛错误
'''
n_list.remove("周松松")#删除元素
print(n_list)

'''
pop方法删除列表元素并返回
'''
print(n_list.pop())#返回最后一个元素
print(n_list.pop(0))#返回第一个元素
print(n_list)

'''
reverse方法列表倒置
sort方法对列表排序
copy方法列表复制
clear方法列表清除
index方法返回查找元素的索引，可设置起始位置和结束位置
count方法查找元素在列表中出现的次数

list方法把元组转化为列表
'''

'''
遍历 [start,end)，间隔为 span，当 span>0 时顺序遍历, 当 span<0 时，逆着遍历。
start 不输入则默认为 0，end 不输入默认为长度
'''
lx = [i for i in range(len(n_list))]
print(lx)

l = [i for i in range(0,15)]
print(l[::2])

'''列表复制'''
f = [1,2,3]
e = f
print(id(f),id(e))#同一个地址空间，说明，这种复制只是对[1,2,3]对象取了另外一个名字,改变列表，f,e都会跟着改变
h = f[:]
print(id(f),id(h))#不通地址，说明，h新开辟了空间

import  copy #用copy模块里 copy()函数完成复制
i = copy.copy(f)#产生新的地址
print(i)
print(id(f),id(i))

'''
列表推导式
将一种数据结构作为输入，经过过滤、计算等处理，最后输出另一种数据结构
'''

'''
#range(10) 生成0-9的列表
#解释为 循环取0-9，是否满足整除2，满足后2次方，生成的序列
range(10)为输入参数
x为元素变量
if % 2 == 0为条件
x ** 2 为输出表达式
'''
m_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(m_list)

x_list = [x ** 2 for x in range(100) if x % 2 == 0 if x % 5 == 0]
print(x_list)


'''
                        2、元组

元组是一种不可变序列 ，一旦创建就不能修改，创建元组可以使用tuple([iterable])函数或者直接用(,)将元素分割    
iterable 是任何可迭代对象                   
'''

aa = tuple([])# 创建一个空元组
print(aa)
print(type(aa))

aa = ()# 创建一个空元组
print(type(aa))

'''注意：这不是元组对象，是一个整型对象'''
cc = (21)#
print(type(cc)) #<class 'int'>

ee = (21,)#创建一个元素的元组
print(type(ee))

bb = tuple((21,32,43,45))# 创建一个元组 ,iterable 是任何可迭代对象，元组迭代
print(bb)
print(type(bb))

dd = (21,32,43,45)# 创建一个元组
print(dd)
print(type(dd))

n_tuple = tuple([21,32,43,45]) # 创建一个元组,iterable 是任何可迭代对象 列表迭代
print(n_tuple)

print(n_tuple[0:3])#访问元组，索引，截取

print(dd + n_tuple) # 元组连接

print(32 in dd)# 元组元素是否存在

for x in dd :print(x,) # 元组迭代，属于拆包

xx = dd * 2
print(xx) # 元组复制

del dd #由于元组对象不应许修改，只能删除整个元组，不能删除元素，

'''元组拆包,接收参数与元组元素相等'''
n1, n2, n3, n4 = n_tuple
print(n1,n2,n3,n4)

'''元组拆包,接收参数与元组元素相等,用下划线忽略取值'''
nx, _, _, _ = n_tuple
print(nx)

'''元组拆包，接收参数与元组元素不等，最后一个加*表示以列表形式接收后面所有元素'''
nn, *n = n_tuple
print(nn,n)

'''遍历元组 enumerate获取元组对象，包含元素和值'''
for i , item in enumerate(n_tuple):
    print('{0} - {1}'.format(i,item))

'''
#tuple所谓的"不变"是说，tuple的每个元素，指向永远不变
tuple元素不可变有一种特殊情况，当元素是可变对象时。对象内部属性是可以修改的
tuple的元素所保存的内容（数值或内存地址）是不允许修改的，但地址映射的对象自身是可以修改的
'''
t = ('a',['A','B'])#定义一个元组，包含列表，元组不能修改，但列表可以
print(t)
t[1][0] = 'a' #修改列表的值
print(t)
t[1].append("c")
print(t)

'''注：字符串是一种特殊的元组，支持元组的元算符，'''

'''
元组升级版本：namedtuple(具名元组)
因为元组的局限性：不能为元组内部的数据进行命名，
所以往往我们并不知道一个元组所要表达的意义，所以在这里引入了
 collections.namedtuple 这个工厂函数，来构造一个带字段名的元组
'''
import collections
User = collections.namedtuple('User', 'name age id')
user = User('tester', '22', '464643123')
print(user) #User(name='tester', age='22', id='464643123')


'''
                     3、集合

集合：是一种可迭代的，无序的（无索引），不能包含重复元素的数据结构
集合分为可变集合(set)和不可变集合(frozenset）
'''

'''可变集合操作'''

k_set = {'张三','李四','王五'}#创建3个元素的集合
print(k_set)

j = set()#创建一个空的集合，如果去掉set，就表示创建空的元组
print(type(j))

j_set = set((20,39))#创建2个元素的集合
print(j_set)

k_set.add('周松松')#集合无序，添加后每次的位置都可能不同，如果元素存在，不能添加，不抛错
print(k_set)

k_set.remove('周松松')#删除元素，不存在，抛出错误
print(k_set)

k_set.discard('123')#删除元素，不存在，不抛错
print(k_set)

'''
pop方法删除返回集合中任意一个元素
clear方法清除集合
'''

'''遍历集合'''
for i, item in enumerate(k_set):
    print('{0} - {1}'.format(i,item))# i 不是索引，是遍历集合的次数

'''
不可变集合
不可变集合使用frozenset([iterable])函数，不能使用大括号
'''
frozenset_set0 = frozenset(())#创建空的不可变集合
print(type(frozenset_set0))
print(frozenset_set0)

frozenset_set = frozenset({'张三','李四','王五'})
print(type(frozenset_set))
print(frozenset_set)

frozenset_set1 = frozenset(('张三','李四','王五'))#将元组转化为不可变集合
print(frozenset_set1)


'''
集合推导式
'''

frozenset_set3 = {x for x in range(100) if x % 2 == 0 if x % 5 == 0}
print(frozenset_set3)

'''

                    4、字典
字典：是可迭代的，可变的数据结构，通过键来访问元素的数据结构
键视图不能包含重复的元素，值集合可以重复，键值成对出现
字典类型dict ,创建字典可以用dict函数，或者使用大括号{}将键值对包裹起来
'''

dict1 = {102:102,103:103,104:104}#创建3个元素字典
print(type(dict1))
print(dict1)

dict2 = {}#创建空字典
print(type(dict2))
print(dict2)

dict3 = dict(dict1)#创建新地址，完成复制
print(dict3)
print(id(dict1),id(dict3))#地址不一样

dict4 = dict(((111,111),(222,222)))#将成对元组转化为字典，元组中含有两个元素的元组
print(dict4)

dict5 = dict([(333,333),(444,444)])#与上面表达式比，列表中含有连个元素的元组
print(dict5)

'''zip函数将两个可迭代对象打包成元组，在创建字典时，需要另个可迭代对象'''
dict6 = dict(zip([102,105,109],['张三','李四','王五']))
print(dict6)

'''key - value 形式只能创建键是字符串类型的字典'''
#dict7 = dict(102 = '张三') #错误，写法就错误了，键不能是数字
#dict7 = dict(102' = '张三') #错误，写法就错误了，字符串表达方式错误
dict7 = dict(S102 = '张三',S103 = 'lishi')
print(dict7)

print(dict6[102]) #查看键对应的值
dict6[103] = "董卓" #修改键对应值，如果键存在，就修改，不存在，就添加
print(dict6)
del dict6[102] #删除键值对，如果键不存在，抛错误
print(dict6)

#print(dict6.pop(103)) # 删除返回，如果存在，返回值，不存在，无返回
#print(dict6)

#print(dict6.pop(106,'东流')) # 删除返回，如果存在，返回值，不存在，返回默认 东流

#print(dict6.popitem())# 删除返回，popitem方法双层任意键值对，返回该键值对构成的元组

''' get[key[,default])通过键返回值，如果不存在返回默认'''
print(dict6.get(105))#返回105的值，没找到返回None
print(dict6.get(107,'1234'))#返回107的值，没找到返回1234

'''items方法返回字典所有键值对'''
print(dict6.items())

'''keys方法返回字典键视图'''
print(dict6.keys())

'''values方法返回字典值视图'''
print(dict6.values())

''' in ,not in 运算符，只是测试键视图'''
booll = 105 in dict6
print(booll) #Ture 表示键在字典中

'''遍历字典'''

for id,name in dict6.items():#keys推导键视图，values推导值视图，items推导键值对视图
    print('学号： {0} - 学生： {1}'.format(id,name))

input_dict = {'one' : 1, 'two' : 2, 'three' : 3, 'four' : 4}

output_dict = {k : v for k,v, in input_dict.items() if v % 2 == 0}

print(output_dict)

keys_dict = [v for k,v in input_dict.items() if v % 2 == 0]
print(keys_dict)