# 2018.05.09
# by pengxw


# Python3 列表
# 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
# Python有6个序列的内置类型，但最常见的是列表和元组。
# 序列都可以进行的操作包括索引，切片，加，乘，检查成员。
# 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
# 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
# 列表的数据项不需要具有相同的类型
# 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

# 更新列表
list1=[1,2,3,'shawn','pengxw']
# 列表可直接通过索引位置更新成员,还有 append 函数
list1[2]
list1[2] = 'pxw'
list1[2]
list1.append('!')

# 删除列表元素
# 可用 del 语句删除元素， 还有 remove 函数
del list1[2]

# 列表脚本操作符
# 列表长度
len([1,2,3])
# Out[10]: 4
# 组合
# 但不能使用减号 -
[1,2,3,4,5] + [6,7,8,9,10]
# Out[12]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 重复
['shawn','*']*4
# Out[13]: ['shawn', '*', 'shawn', '*', 'shawn', '*', 'shawn', '*']
# 元素是否存在列表
3 in [1,2,3,4]
# Out[14]: True
# 循环迭代
for x in [1,2,3]:print(x,end='/')
# 1/2/3/


# 列表截取索引
list1=[1,2,3,'shawn','pengxw']
list1[3]
# Out[25]: 'shawn'
list1[-3]
# Out[26]: 3
list1[1:]
# Out[27]: [2, 3, 'shawn', 'pengxw']


# Python列表函数&方法
# Python包含以下函数:

# 序号        函数
# 1        len(list)
# 列表元素个数
# 2        max(list)
# 返回列表元素最大值
# 3        min(list)
# 返回列表元素最小值
# 4        list(seq)
# 将元组转换为列表
atuple = (1,2,3)
list(atuple)
# Out[31]: [1, 2, 3]
str="Hello World"
list2=list(str)
# Out[33]: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

# Python包含以下方法:

# 序号        方法
# 1        list.append(obj)
# 在列表末尾添加新的对象

# 2        list.count(obj)
# 统计某个元素在列表中出现的次数
list1=[1,2,3,'shawn','pengxw']
list1.count('shawn')
[1,2,3,'shawn','pengxw'].count(1)

# 3        list.extend(seq)
# 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list1.extend([1,2,3])

# 4        list.index(obj)
# 从列表中找出某个值第一个匹配项的索引位置
list1.index(1)
# 5        list.insert(index, obj)
# 将对象插入列表
list1.insert(9,'!')
# 6        list.pop(obj=list[-1])
# 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
# 7        list.remove(obj)
# 移除列表中某个值的第一个匹配项
list1.remove(1)
# 8        list.reverse()
# 反向列表中元素
# 9        list.sort([func])
# 对原列表进行排序，只能比较同类型元素，当列表中同时包含字符和数字时会报错
list3 = [3,6,7,1,2,5]
list3.sort()
# 10        list.clear()
# 清空列表
# 11        list.copy()
# 复制列表


# Python3 元组
# Python 的元组与列表类似，不同之处在于元组的元素不能修改，它也没有append()，insert()这样的方法，但是能拼接
# 元组使用小括号，列表使用方括号。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。也可以不使用括号
tup1 = (1,2,3)
tup2 = 'x','y','z'
tup3 = tup1 + tup2
# 删除元组
# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

# 元组运算符
# 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
# 但不能使用减号 -

# 元组索引，截取
# 因为元组也是一个序列，所以我们可以类似列表访问元组中的指定位置的元素，也可以截取索引中的一段元素

# 不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

# 如果要定义一个空的tuple，可以写成()
t = ()

# 但是，要定义一个只有1个元素的tuple，如果这么定义:
t1 = (1)
type(t1)
# Out[64]: int
# 定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，
# 因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
# 所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
t2 = (1,)
type(t2)
# Out[66]: tuple

# ‘可变的’元组
t = ('a','b',[1,2])
t[2][0] = 'x'
t[2][1] = 'y'
t[2].append(1)
print(t)

# 这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
# 别急，我们先看看定义的时候tuple包含的3个元素：当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：表面上看，
# tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，
# tuple所谓的"不变"是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，
# 但指向的这个list本身是可变的！理解了"指向不变"后，要创建一个内容也不变的tuple怎么做？
# 那就必须保证tuple的每一个元素本身也不能变。


# 字符串是一种特殊的tuple,支持部分tuple的运算符
a = '12345'
a[1]

# Python元组的升级版本 -- namedtuple(具名元组)

# 因为元组的局限性：不能为元组内部的数据进行命名，所以往往我们并不知道一个元组所要表达的意义，
# 所以在这里引入了 collections.namedtuple 这个工厂函数，来构造一个带字段名的元组。
# 具名元组的实例和普通元组消耗的内存一样多，因为字段名都被存在对应的类里面。
# 这个类跟普通的对象实例比起来也要小一些，因为 Python 不会用 __dict__ 来存放这些实例的属性。

import collections
Username = collections.namedtuple('User', 'name age id')
user = Username('tester', '22', '464643123')
print(user)
# Out[85]: User(name='tester', age='22', id='464643123')



# Python3 字典
# 字典是另一种可变容器模型，且可存储任意类型对象。

# 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
# d = {key1 : value1, key2 : value2 }
# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
dict1 = {('id1','id2'):('12345','12346'),'name':'shawn','age':27}


# 访问字典里的值
# 把相应的键放入到方括号中,如果用字典里没有的键访问数据，会输出错误
dict1['name']
# Out[90]: 'shawn'

# 修改字典
# 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值
dict1['name'] = 'pengxw'
dict1['gender'] = 'male'

# 删除字典元素
# 能删单一的元素也能清空字典，清空只需一项操作。
# 显示删除一个字典用del命令
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

# 字典键的特性
# 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
# 两个重要的点需要记住：
# 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被保留
# 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行


# 字典内置函数&方法
# Python字典包含了以下内置函数：

# 序号        函数及描述        实例
# 1        len(dict)
# 计算字典元素个数，即键的总数。       
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
len(dict)

# 2        dict1.__str__()
# 输出字典，以可打印的字符串表示。       
dict1.__str__()
# "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

# 3        type(variable)
# 返回输入的变量类型，如果变量是字典就返回字典类型。
type(dict)
# <class 'dict'>


# 字典的键、值是"只读"的，所以不能对键和值分别进行初始化
# 字典是支持无限极嵌套的

cities={
    '北京':{
        '朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
        '海淀':['圆明园','苏州街','中关村','北京大学'],
        '昌平':['沙河','南口','小汤山',],
        '怀柔':['桃花','梅花','大山'],
        '密云':['密云A','密云B','密云C']
    },
    '河北':{
        '石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
        '张家口':['张家口A','张家口B','张家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}

for i in cities['北京']:
    print(i)

       
       
# Python字典包含了以下内置方法：

# 序号        函数及描述
# 1        dict.clear()
# 删除字典内所有元素
# 2        dict.copy()
# 返回一个字典的浅复制
# 3        dict.fromkeys()
# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
# 4        dict.get(key, default=None)
# 返回指定键的值，如果值不在字典中返回default值
# 5        key in dict
# 如果键在字典dict里返回true，否则返回false
# 6        dict.items()
# 以列表返回可遍历的(键, 值) 元组数组
# 7        dict.keys()
# 以列表返回一个字典所有的键
# 8        dict.setdefault(key, default=None)
# 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
# 9        dict.update(dict2)
# 把字典dict2的键/值对更新到dict里
# 10        dict.values()
# 以列表返回字典中的所有值
# 11        pop(key[,default])
# 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
# 12        popitem()
# 随机返回并删除字典中的一对键和值(一般删除末尾对)。