python

数据结构（Data Structures）人如其名，只是一种结构，能够将一些数据聚合在一起。换句话说，它们是用来存储一系列相关数据的集合。python中有四种内置的数据结构：

• 列表（list）
• 元组（tuple）
• 字典（dictionary）
• 集合（set）

另外，讲解以下三部分内容：

• 序列
• 引用
• 字符串的常用方法

1. 列表

列表：用于保存一系列有序项目的集合。语法：用方括号括起来，中间用逗号隔开。如：

shoppinglist = ['apple', 'orange', 'banana']

可以向列表中添加任何类型的对象，包括字符串、数字，甚至可以是其他列表

列表也是一个序列 

可对列表中的项目进行增删改查，所以说列表是一种可变的数据类型

shoppinglist = ['apple', 'orange', 'banana']

print(shoppinglist)  # 打印整个列表，['apple','orange','banana']

for list1 in shoppinglist:  # 打印列表中的元素，分三行，分别打印apple  orange  banana
    print(list1)

shoppinglist[0]     # 列表的第一个元素
shoppinglist[-1]    # 列表的最后一个元素

shoppinglist.append('pear')  # 向列表后追加元素
shoppinglist[0] = 'aaa'      # 修改列表中的第一个元素的值为aaa
shoppinglist.remove(shoppinglist[0])   # 删除列表中的第一个元素（方法一）
del shoppinglist[0]                    # 删除列表中的第一个元素（方法二）
shoppinglist.pop(0)                    # 删除列表中的第一个元素（方法三）（优）

len(shoppinglist)    # 列表的长度（列表中元素的个数）
shoppinglist.sort()  # 排序，影响的是列表本身（与修改字符串的方式不同）（列表是可变的，字符串是不可变的，字符串没有sort()方法，会报错：AttributeError: 'str' object has no attribute 'sort'）

资格测试
1 mylist = ['apple', 'orange', 'banana']

if 'apple' in mylist:   # 判断apple是否在mylist中
    print('yes')
else:
    print('no')

2. 元组

用于将多个对象保存在一起。语法：用圆括号括起来，中间用逗号隔开。如：

zoo = ('apple', 'orange', 'banana')

元组也是一个序列

 元组可以近似的看做一个列表，但元组不可改变。
1 zoo = ('apple', 'orange', 'banana')

print(zoo)       # 打印元组('apple', 'orange', 'banana')

for i in zoo:    # 打印元组中的元素 apple  orange  banana
    print(i)

print(len(zoo))  # 打印元组的长度 3

new_zoo = ('pear', 'mongo', zoo)

# 元组中所包含的元组，不会失去其所拥有的身份
print(new_zoo)        # 打印新的元组 ('pear', 'mongo', ('apple', 'orange', 'banana'))
print(new_zoo[1])     # 方括号[]，索引运算符  mongo
print(new_zoo[2])     # ('apple', 'orange', 'banana')
print(new_zoo[2][2])  # banana
print(len(new_zoo))   # 3

# 空元组
myempty = ()
print(myempty)  # ()

# 包含一个元素的元组
single = (2,)   # 必须在项目后面加上一个逗号来指定它，这样python才可以识别出这个表达式想表达的是元组还是对象
print(single)   # (2,)

my_yuanzu = ('apple',)
print(my_yuanzu)       # 打印元组 ('apple',)

my_yuanzu = ('apple')
print(my_yuanzu)       # 打印对象 apple

3. 字典

键值对（key-value）结构。语法：用一对大括号括起来，每一个键值对之间用逗号分隔，键与值之间用冒号分隔。如：

ab = {'zhangsan':'zhangsan@126.coom',
      'lisi':'lisi@126.com',
      'wangmazi':'wangmazi@qq.com'}

键必须唯一，且不可变。值可以变。字典不能排序。

ab = {'zhangsan':'zhangsan@126.coom',
      'lisi':'lisi@126.com',
      'wangmazi':'wangmazi@qq.com'}

print(ab)   # 打印整个字典：{'zhangsan': 'zhangsan@126.coom', 'lisi': 'lisi@126.com', 'wangmazi': 'wangmazi@qq.com'}

for key, value in ab.items():    # 打印字典中的所有键和值
    print(key, value)

print(ab['zhangsan'])            # 打印字典中某个键的值（用索引运算符）：zhangsan@126.coom

print(ab.keys())     # 打印字典中的所有键：dict_keys(['zhangsan', 'lisi', 'wangmazi'])
print(ab.values())   # 打印字典中所有键的值：dict_values(['zhangsan@126.coom', 'lisi@126.com', 'wangmazi@qq.com'])

ab['wangmazi'] = 'wangmazi@126.com'  # 修改键名为wangmazi的值
ab['wangwu'] = 'wangwu.126.com'      # 添加一个键值对
del ab['wangwu']                     # 删除字典中键为wangwu的键值对（方法一）
ab.pop('wangwu')                     # 删除字典中键为wangwu的键值对（方法二）（优）

print(len(ab))                       # 打印字典的长度（键值对的数量）
if 'wangmazi' in ab:                 # 若字典中存在键名为wangmazi的键，则打印出它的值
    print(ab['wangmazi'])

ps：

print(ab.items())  # dict_items([('zhangsan', 'zhangsan@126.coom'), ('lisi', 'lisi@126.com'), ('wangmazi', 'wangmazi@qq.com')])

ab.items()返回一个包含元组的列表。每一个元组中包含一个键值对。用for循环打印时，将每一个配对信息分配给key和value变量　

my_dict = {'zhangsan':'18100000001',
           'lisi':'18100000001',
           'wangmazi':'18100000002'}

print(my_dict)
# {'zhangsan': '18100000001', 'lisi': '18100000001', 'wangmazi': '18100000002'}

print(my_dict.items())    # items()返回包含元组的列表
# dict_items([('zhangsan', '18100000001'), ('lisi', '18100000001'), ('wangmazi', '18100000002')])

for i in my_dict.items():
    print(i)
# ('zhangsan', '18100000001')   i 是元组
# ('lisi', '18100000001')
# ('wangmazi', '18100000002')

for i, j in my_dict.items():
    print(i, j)
# zhangsan 18100000001
# lisi 18100000001
# wangmazi 18100000002

4. 集合

 简单对象的无序集合。语法：set([列表])。如：

bri = set(['apple', 'orange', 'banana'])

当集合中的元素存在与否，比次序或出现次数更加重要时，使用集合。集合的作用：

• 测试某些元素的资格
• 检查是否是其他集合的子集
• 找到两个集合的交集等

bri = set(['apple', 'orange', 'banana'])

print('apple' in bri)   # True
print('mongo' in bri)   # False

bric = bri.copy()       # 复制一个集合

bric.add('pear')        # 添加一个元素
bric.remove('banana')   # 删除一个元素

print(bric.issuperset(bri))   # bric是否是bri的父集ic
print(bric.issubset(bri))     # bric是否是bri的子集
print(bric & bri)             # 求交集
print(bric | bri)             # 求并集（无序）

关于序列、引用、字符串的常用方法：

1. 序列

序列的三种形态：列表、元组、字符串

序列的主要功能：

• 资格测试（也就是in与not in表达式）
• 索引操作

 下面主要讲解切片操作：

可以使用同样的的方式，访问列表、元组、字符串
 1 shoppinglist = ['apple', 'orange', 'banana', 'pear']
name = 'abcdefg'

# 索引或下标操作
print(shoppinglist[0])   # apple
print(shoppinglist[1])   # orange
print(shoppinglist[2])   # banana
print(shoppinglist[3])   # pear
print(name[0])      # a

print(shoppinglist[-1])  # pear  索引也可以使用负数，位置计数从末尾开始
print(shoppinglist[-2])  # banana
print(shoppinglist[-4])  # apple
print(name[-1])    # g

# 切片操作
print(shoppinglist[1:3])    # ['orange', 'banana']   序列切片包括起始位置，不包括结束位置
print(shoppinglist[2:])     # ['banana', 'pear']
print(shoppinglist[:3])     # ['apple', 'orange', 'banana']
print(shoppinglist[1:-1])   # ['orange', 'banana']
print(shoppinglist[:])      # ['apple', 'orange', 'banana', 'pear']
print(name[1:3])    # bc

# 切片步长（默认为1）
print(shoppinglist[::1])    # ['apple', 'orange', 'banana', 'pear']
print(shoppinglist[::2])    # ['apple', 'banana']  步长为2时，得到0，2，4元素
print(shoppinglist[::3])    # ['apple', 'pear']    步长为3时，得到0,3元素
print(shoppinglist[::-1])   # ['pear', 'banana', 'orange', 'apple']
print(shoppinglist[::-2])   # ['pear', 'orange']
print(shoppinglist[0:3:2])  # ['apple', 'banana']

2. 引用

 如果你希望创建一个复杂对象（如：序列）的副本，必须使用切片操作。

直接赋值，指同一个对象
 1 shoppinglist = ['apple', 'orange', 'banana']

mylist = shoppinglist   # mylist只是shoppinglist的别名，它们指的是同一个对象

print(shoppinglist)          # ['apple', 'orange', 'banana']
print(mylist)                # ['apple', 'orange', 'banana']

mylist.remove(mylist[0])     # 移除mylist中的第一个元素

print(shoppinglist)          # ['orange', 'banana']   （shoppinglist同时也少一个元素）  
print(mylist)                # ['orange', 'banana']

切片赋值，指向不同对象
1 shoppinglist = ['apple', 'orange', 'banana']

mylist = shoppinglist[:]   # 通过生成一份完整的切片，制作一份列表的副本，它们指的不是同一个对象

print(shoppinglist)          # ['apple', 'orange', 'banana']
print(mylist)                # ['apple', 'orange', 'banana']

mylist.remove(mylist[0])     # 移除mylist中的第一个元素

print(shoppinglist)          # ['apple', 'orange', 'banana']  （shoppinglist并无变化）
print(mylist)                # ['orange', 'banana']

简单对象可以直接赋值，指向不同对象
 1 a = 5
b = a      # 指向不同对象

print(a)   # 5
print(b)   # 5

b = 3

print(a)   # 5
print(b)   # 3

3. 字符串的常用方法

 字符串都是str类下的对象，有自己的方法，可以检查字符串中的一部分或是去掉空格等很多事情

mystring = 'method'

if mystring.startswith('me'):   # start()方法，查找字符串是否以指定内容开头
    print('ok')

if mystring.find('th') != -1:   # find()方法，查找子字符串。找到返回2，找不到返回-1
    print('ok')

if 't' in mystring:             # in 运算符，检查给定的字符串是否是查询字符串中的一部分
    print('ok')

delimeter = '_'
mylist = ['apple', 'orange', 'banana']
print(delimeter.join(mylist))     # join() 方法，连接序列中的元素 apple_orange_banana
print(delimeter.join(mystring))   # m_e_t_h_o_d