Byte of Python-----Data Structure

##Data Structure##
##2018/4/8##


#数据结构（Data Structures）基本上人如其名——它们只是一种结构，能够将一些数据聚合
#在一起。换句话说，它们是用来存储一系列相关数据的集合。
#Python 中有四种内置的数据结构——列表（List）、元组（Tuple）、字典（Dictionary）和集
#合（Set）。我们将了解如何使用它们，并利用它们将我们的编程之路变得更加简单。

##Point1##
##列表----List##
##一种用于保存一系列有序项目的集合，也就是说，你可以利用列表保存一串项目的序列
#项目的列表应该用方括号括起来，这样 Python 才能理解到你正在指定一张列表。一旦你创建
#了一张列表，你可以添加、移除或搜索列表中的项目。既然我们可以添加或删除项目，我们
#会说列表是一种可变的（Mutable）数据类型，意即，这种类型是可以被改变的。

##e.g.1
print('e.g.1')
shopping_list = ['meat','egg','milk','tomato']

print('I hava',len(shopping_list),'items to purchase')

print('These items are ',end = ' ')
for item in shopping_list:
    print(item,end = ' ')

print('\nI also have to buy rice.')
shopping_list.append('rice')
print('Now my shoplist is ',shopping_list)

print('I will sort my list now')
shopping_list.sort()
print('Sorted shopping list is',shopping_list)

print('The first item I will buy is',shopping_list[0])
olditem = shopping_list[0]
del shopping_list[0]
print('I bought the ',olditem)
print('My shopping list is now',shopping_list)
print('----------------------------------------------------------------')


##Point2##
##元组----Tuple##
#元组（Tuple）用于将多个对象保存到一起。你可以将它们近似地看作列表，但是元组不能提
#供列表类能够提供给你的广泛的功能。元组的一大特征类似于字符串，它们是不可变的，也
#就是说，你不能编辑或更改元组。
#元组是通过特别指定项目来定义的，在指定项目时，你可以给它们加上括号，并在括号内部
#用逗号进行分隔。
#元组通常用于保证某一语句或某一用户定义的函数可以安全地采用一组数值，意即元组内的
#数值不会改变。

##e.g.2
print('e.g.2')
zoo = ('python','elephant','penguin')   #显式元组
print('Number of animals in the zoo is ',len(zoo))
 
new_zoo = 'monkey','camel',zoo          #隐式元组
print('Number of cages in the new zoo is',len(new_zoo))
print('All animals in new zoo are',new_zoo)
print('Animals brought from old zoo are',new_zoo[2])
print('Last animal brought from old zoo is',new_zoo[2][2])
print('Number of animals in the new zoo is',
      len(new_zoo)-1+len(new_zoo[2]))
print('----------------------------------------------------------------')

##ps
#包含 0 或 1 个项目的元组
#一个空的元组由一对圆括号构成，就像 myempty = () 这样。然而，一个只拥有一个项
#目的元组并不像这样简单。你必须在第一个（也是唯一一个）项目的后面加上一个逗号
#来指定它，如此一来 Python 才可以识别出在这个表达式想表达的究竟是一个元组还是只
#是一个被括号所环绕的对象，也就是说，如果你想指定一个包含项目 2 的元组，你必
#须指定 singleton = (2, ) 。



##Point3##
##字典----Dictionary##
#字典就像一本地址簿，如果你知道了他或她的姓名，你就可以在这里找到其地址或是能够联
#系上对方的更多详细信息，换言之，我们将键值（Keys）（即姓名）与值（Values）（即地
#址等详细信息）联立到一起。在这里要注意到键值必须是唯一的，正如在现实中面对两个完
#全同名的人你没办法找出有关他们的正确信息。
#另外要注意的是你只能使用不可变的对象（如字符串）作为字典的键值，但是你可以使用可
#变或不可变的对象作为字典中的值。基本上这段话也可以翻译为你只能使用简单对象作为键
#值。
#在字典中，你可以通过使用符号构成 d = {key : value1 , key2 : value2} 这样的形式，来成
#对地指定键值与值。在这里要注意到成对的键值与值之间使用冒号分隔，而每一对键值与值
#则使用逗号进行区分，它们全都由一对花括号括起。
#另外需要记住，字典中的成对的键值—值配对不会以任何方式进行排序。如果你希望为它们
#安排一个特别的次序，只能在使用它们之前自行进行排序。

##e.g.3
print('e.g.3')
AddressBook = {
    'xiaoming':'[e-mail]',
    'daming':'[e-mail]',
    'goudan':'[e-mail]'
    }

print("goudan's address is ",AddressBook['goudan'])
#delete
del AddressBook['xiaoming']

print('\nThere are {} contact in the address-book'.format(len(AddressBook)))

for name,address in AddressBook.items():
    print('Contact {} at {}'.format(name,address))
#添加键值配对
AddressBook['ergouzi'] = '[e-mail]'

if 'ergouzi' in AddressBook:
    print('\nergouzi address is',AddressBook['ergouzi'])
print('----------------------------------------------------------------')



##Point4##
##序列----Sequence##
#列表、元组和字符串可以看作序列（Sequence）的某种表现形式
#序列的主要功能是资格测试（Membership Test）（也就是 in 与 not in 表达式）和索引
#操作（Indexing Operations），它们能够允许我们直接获取序列中的特定项目

#e.g.4
print('#e.g.4')
if 'something' not in AddressBook:
    print('Membership Test')
print('----------------------------------------------------------------')

#上面所提到的序列的三种形态——列表、元组与字符串，同样拥有一种切片（Slicing）运算
#符，它能够允许我们序列中的某段切片——也就是序列之中的一部分

#e.g.5
print('#e.g.5')
shoplist = ['apple','mango','carrot','banana']
name = 'ysuzz'

##Index----索引
print('shoplist item 0 is ',shoplist[0])
print('shoplist item -1 is ',shoplist[-1])
print('name character 0 is ',name[0])

##Slicing----切片
print('shoplist 1 to 3 is ',shoplist[1:3])
print('shoplist 2 to end is ',shoplist[2:])
print('shoplist 1 to -1 is ',shoplist[1:-1])
print('shoplist start to end is ',shoplist[:])
print('----------------------------------------------------------------')
#。要注意的是切片操作会在开始处返回 start，并在 end 前面的位置结束工作。也就是说，序列切片将包括起始位
#置，但不包括结束位置。

#你同样可以在切片操作中提供第三个参数，这一参数将被视为切片的步长（Step）（在默认
#情况下，步长大小为 1）：
for item in shoplist[::-1]: #倒序！！
    print(item)
print('----------------------------------------------------------------')
#ps
#你要记住如果你希望创建一份诸如序列等复杂对象的副本（而非整数这种简单的对象
#（Object）），你必须使用切片操作来制作副本。如果你仅仅是将一个变量名赋予给另一个名
#称，那么它们都将“查阅”同一个对象，如果你对此不够小心，那么它将造成麻烦。



##Point5##
##集合----Set##
#集合（Set）是简单对象的无序集合（Collection）。当集合中的项目存在与否比起次序或其出
#现次数更加重要时，我们就会使用集合。
#通过使用集合，你可以测试某些对象的资格或情况，检查它们是否是其它集合的子集，找到
#两个集合的交集，等等

#e.g.6
print('e.g.6')
bri = set(['brazil','russia','india'])
#资格测试
print('india' in bri)
bric = bri.copy()
bric.add('china')
print(bric.issuperset(bric))
bri.remove('russia')
print(bri & bric)   #交集
print(bri | bric)   #并集
print(bri ^ bric)   #补集
print('----------------------------------------------------------------')



##字符串##
##strint##

#e.g.7
print('e.g.7')
name = 'Swaroop'

if name.startswith('Swa'):
    print('yes,the string starts with "Swa"')

if 'a' in name:
    print('yes,it contains the string "a"')

if name.find('war') != -1:
    print('Yes,it contains the string "war"')

delimiter = '_*_'
mylist = ['a','b','c','d']
print(delimiter.join(mylist))
print('----------------------------------------------------------------')