python基础之数据结构

1.python中的序列通用操作

在python中有六中内置序列，其中有三种常见的序列类型：列表、元组和字符串。在python中大部分的序列都可以进行通用的操作，包括索引、切片、相同类型序列相加、乘法、成员资格（in）、长度、最大值和最小值，本文不展开通用操作进行讲解。

2.列表（list）

列表的作用相当于其他高级语言中的数组，是python重要的数据结构之一，本节将会讲解和列表相关的操作

• 列表新增元素

1. append(value)：在列表最后添加单个值
2. extends(list)：把新列表拆分添加到原来列表中
3. insert(index, value)：在指定索引的位置添加元素

list1 = [1, 2, 3]
#append
list1.append(4)
print(list1) # [1, 2, 3, 4]
#extend
list1.extend([5, 6, 7])
print(list1) # [1, 2, 3, 4, 5, 6, 7]
#insert
list1.insert(2, 10)
print(list1) # [1, 2, 10, 3, 4, 5, 6, 7]

• 删除列表

1. pop(index)：删除指定索引的元素并返回删除的元素，如果不指定索引则默认删除最后一个
2. remove(value)：删除查找的第一个元素
3. del list[index]：删除指定位置的元素

list1 = [1, 2, 3, 4, 5, 6, 7]
#pop
print(list1.pop(0)) #1
print(list1.pop()) #7
print(list1) # [2, 3, 4, 5, 6]
#remove
list1.remove(4)
print(list1) # [2, 3, 5, 6]
#del
del list1[0]
print(list1) # [3, 5, 6]

• 查找元素（通用序列的操作）

1. index(value)：返回查找元素的索引值，如果没有查找到则报错
2. count(value)：查找该元素在列表中出现过几次
3. value in list|string|tuple：查找该元素是否位于列表中

list1 = [1, 1, 1, 2, 4, 5, 7]
#index
print(list1.index(1)) #0
print(list1.index(6)) #报错
#count
print(list1.count(1)) #3
#in
print(2 in list1) #True

• 排序（通用序列操作）

1. list|string|tuple.reverse()：反转队列
2. list|string|tuple.sort(reverse=Ture|False)：队列排序（逆排序）

list1 = [1, 3, 2, 0, 4, 5, 7]
#reverse
list1.reverse()
print(list1) #[7, 5, 4, 0, 2, 3, 1]
#sort
list1.sort()
print(list1) #[0, 1, 2, 3, 4, 5, 7]
list1.sort(reverse=True)
print(list1) #[7, 5, 4, 3, 2, 1, 0]

3.字符串（string）

• 字符串常见操作（以下操作均不会改变原字符串）

1. replace(oldstr, newstr, count)：替换字符并返回新字符串，count：替换多少次
2. split(char)：分割字符串，以列表形式返回
3. join(sep)：用字符串合并序列，并返回新字符串

str = 'hello world hello world'
#replace
str1 = str.replace('hello', 'hi')
print(str1) #hi world hi world
str2 = str.replace('world', 'python', 1)
print(str2) #hello python hello world
#split
list1 = str.split('world')
print(list1) #['hello ', ' hello ', '']
#join
str3 = '-'
str4 = str3.join(['1', '2', '3'])
print(str4) # 1-2-3

4.元组（tuple）

元组和列表十分相似，大部分方法都通用，但是元组与序列最大的区别就是列表可以修改，而元组创建之后这不能被修改，不能删除单个元素，但能删除整个元组。定义元组的时候只需要用"(" 和")"把元素括起来，并用","把元素隔开。注意：如果元组内只有一个元素，也要在元素后加上","，否则元素还是其原来的类型。

• 删除整个元组：del 元组名字
• 其他操作：count()/index()与列表相同

5.集合（set）

python中有一种内置类型叫做集合（set），它与列表（list）的行为相似，区别就是结合它是无序的并且不包含重复值的数据结构

• 集合的定义：

1. s = set([元素1,,元素2...])：通过构造函数，定义集合
2. s = {元素1,,元素2...}：使用结构定义并赋值

• 往集合中添加元素：add(value)
• 删除集合中的元素：remove(value)：

set1 = {1, 2, 3}
set2 = set()
# add
set2.add(1)
set2.add(2)
set2.add(3)
print(set2) #{1, 2, 3}
#remove
set1.remove(1)
print(set1) #{2, 3}

• 集合中的数学操作

1. 交集：&
2. 并集：|
3. 差集：-
4. 对称差集：^

set1 = {4, 5, 6, 7, 8, 9, 10}
set2 = {1, 2, 3, 7, 8, 11, 12}
#交集
print(set1 & set2) #{8, 7}
#并集
print(set1 | set2) #{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
#差集
print(set1 - set2) #{4, 5, 6, 9, 10}
print(set2 - set1) #{1, 2, 3, 11, 12}
#对称差集
print(set1 ^ set2) #{1, 2, 3, 4, 5, 6, 9, 10, 11, 12}

6.字典

在python中，字典是一组键值对，字典中的元组都是你成对出现的，每个元素必须要有键的对应值

• 定义字典

1. 通过构造函数定义：d = dict()
2. 结构定义：d = {k1:v1,k2:v2}

• 访问元素

1. d[key]：没有对应的key则报错
2. d.get(key)：没有对应的key则返回None

• 往字典中添加元素：d[key] = value，如果key存在，则是修改元素的值
• 删除字典的数据

1. del d[key]：没有返回值
2. pop(key)：删除并返回删除的元素
3. clear：清空字典

person1 = {
    "name": "孙悟空",
    "age": 1000,
    "gender": "女"
}
#获取元素
print(person1["name"]) #孙悟空
# print(person1["qq"]) #报错
print(person1.get("qq")) #None
#添加元素/修改
person1["name"] = "猪八戒" #修改name
person1["qq"] = "1234567" #添加qq
print(person1) #{'name': '猪八戒', 'age': 1000, 'gender': '女', 'qq': '1234567'}
#删除元素
del person1["qq"]
print(person1) #{'name': '猪八戒', 'age': 1000, 'gender': '女'}
person1.pop("gender")
print(person1) #{'name': '猪八戒', 'age': 1000}
person1.clear()
print(person1) #{}

• 遍历字典

1. d.keys()：返回字典的键
2. d.values()：返回字典的值
3. d.items()：返回字典的键和值

person1 = {
    "name": "孙悟空",
    "age": 1000,
    "gender": "女"
}
#keys
keys = person1.keys()
print(keys) #dict_keys(['name', 'age', 'gender'])
#values
values = person1.values()
print(values) #dict_values(['孙悟空', 1000, '女'])
# values
items = person1.items()
print(items) #dict_items([('name', '孙悟空'), ('age', 1000), ('gender', '女')])

• 字典的其他操作

1. copy()：复制字典，浅拷贝，虽然返回一份全新的副本，但是字典内含有字典或其他引用的话，操作会对原字典有影响
2. fromkeys(seq, value)：用序列中的元素作为字典的键，第二个参数作为字典所有参数的初始值

seq = ("name", "age", "class")
#fromkeys：类方法
student1 = dict.fromkeys(seq)
print(student1) #{'name': None, 'age': None, 'class': None}
student2 = dict.fromkeys(seq, 15)
print(student2) #{'name': 15, 'age': 15, 'class': 15}
#copy
student3 = student2.copy()
print(student3)
student3["name"] = "孙悟空"
print(student3) #{'name': '孙悟空', 'age': 15, 'class': 15}
print(student2) #{'name': 15, 'age': 15, 'class': 15}

7.拓展

• enumerate函数：python的内置函数、适用于python2.x和python3.x，在字典上是枚举，列举的意思，参数为可迭代/遍历的对象（字符串、字典、元组等），它返回一个enumerate对象。它包含了索引和具体的值

person1 = {
    "name": "孙悟空",
    "age": 1000,
    "gender": "女"
}

list1 = ['a', 'b', 'c', 'd']

tuple1 = enumerate(list1)
print(tuple1) #

for k, v in enumerate(person1):
    print(k ,v)
    '''
        0 name
        1 age
        2 gender
    '''

• 列表、字典、集合推导式

python支持三种推导式（或者称为解析式），分别对应列表、字典、集合，利用for循环能够非常自然、简单的方式构建列表、字典和集合。列表推导式的语法：

[表达式 for 表达式 in 序列对象 if xxx]
列表用[]括起来，字典和集合用{}括起来，
表达式和表达式之间要相关联

#列表推导式
list1 = [x for x in range(5) if x % 2 != 0]
print(list1) #[1, 3]
#字典推导式
d1 = {
    "name": "孙悟空",
    "age": 1000
}
person = {
    v: k for k,v in d1.items()
}

print(person) #{'孙悟空': 'name', 1000: 'age'}

numdict = {n: n**2 for n in range(5) if n % 2 !=0}
print(numdict) #{1: 1, 3: 9}
#集合推导式：和列表推导式差不多，但是会去除重复的元素
s = {i**2 for i in [-1, -2 ,0, 1, 2]}
print(s) #{0, 1, 4}