Python 笔记04

Python 笔记04

数据结构

Python 有四种数据结构，分别是：列表、字典、元组、集合。我们先从整体上认识一下这四种数据结构：

list = [value1,value2,value3,value4] #列表
dict = {key1:value1,key2:value2} #字典
tuple = (value1,value2,value3,value4) #元组
set = {value1,value2,value3,value4} #集合

1.1列表(List)

1. 列表中的每个元素都是可变的；
2. 列表中的元素是有序的，也就是说每个元素都有一个位置；
3. 列表中可以容纳 Python 中的任何对象。如下：

all_in_list = [
   1, #整数
   1.0, #浮点数
   'a word', #字符串
   print(1), #函数
   True, #布尔值
   [1,2], #列表中套列表
   (1,2), #元祖
   {'key':'value'} #字典
] 

1.1.1列表的操作—添加元素

 1. 在末尾追加元素 
 语法:列表.append(元素)
 2. 在指定索引位置插入数据
 语法:列表.insert(索引,元素)
 3. 将新列表追加到列表中
 语法:列表.extend(新列表)

1.1.2列表的操作—删除

 1. 指定删除对应索引的元素 
  语法:del 列表[索引] 
 2. 删除最后一个元素,并返回删除的值  
 语法:列表.pop()
 3. 根据索引删除对应元素,并返回删除元素值 
 语法:列表.pop(索引)
 4. 删除第一个出现的指定数据  
语法:列表.remove(数据)
 6. 清空列表 
 语法:列表.clear()

1.1.3列表的操作—查询

1.列表[索引]
2.切片查询
语法:列表[起始:终止:步长]      包头不包尾,步长决定查询元素的方向
列表[::-1]   ====>   倒序获取列表数据
3.获取列表长度
语法:len(列表)
4.获取指定元素的第一个位置的索引
语法:列表.index(元素)
5.获取指定元素出现的次数
语法:列表.count(元素) 

1.1.4列表的操作—修改

列表[索引]=新的值 

1.1.5列表的排序

 1. 升序 	
	语法:列表.sort()
 2. 降序	 
	语法:sort(reverse=True)
 3. 逆转,翻转 
 	列表.reverse()

1.1.6列表的遍历

for  i  in   列表:
 #将列表中的每个元素一次取出赋值给i临时变量
  print(i) 

1.2 字典（Dict）

• 字典中数据必须是以键值对的形式出现的；
• 字典特征：无序、键名是唯一的， 字典属于可变数据类型。
• 字典中的键（key）是不可变的，也就是无法修改的，而值（value）是可变的，可修改的，可以是任何对象。
• 定义一个空字典：

dic = {}

1.2.1字典的操作—添加

• dic[key] = value 有则修改value 值，无则添加

1.增加多个k,v
dic = {"name":"张三", "age": "20"}
2.增加一个 item
dic["sex"] = "男"
print(dic)

1.2.2字典的操作—删除

• 删除指定键所对应的值： del dic(key) 或 dic.pop(key)

del dic["name"]
print(dic)

• 随机删除一对键和值：popitem ( )
• 字典popitem()方法作用是：随机返回并删除字典中的一对键和值（项）。为什么是随机删除呢？因为字典是无序的，没有所谓的“最后一项”或是其它顺序。

1.2.3字典的操作—修改

“有则修改，无则添加“”
dic["name"] = "张三"
print(dic)

1.2.4字典的操作—查询

 - 直接根据键名查询
    dic[name]
    print(dic[name])

 - dic.keys：查询所有的键名
   print(dic.keys())

 - dic.values：查询所有的键的值
   print(dic.values()) 

• item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回。

• 查询是否有此键： get

1.2.5字典的遍历

1. 遍历字典

for item in dic:
    print("打印字典key和value:", item, dic[item]) 

2. 遍历字典元组items

for key, value in dic.items():
    print(key, value)

# key 接收了字典的key值，value 接收了字典的value 

3. 遍历所有键

for item in dic.keys():
    print("键名：", item, "键值:", dic[item])   #根据key取对应的value 

1.3 元组（Tuple）

元组可以理解为一个稳固版的列表，因为元组是不可以修改的，因此在列表中的存在的方法均不可以使用在元组上，但是元组是可以被查看索引的，方式和列表一样。

1.3.1创建元组

创建元组时大部分使用的是小括号，具体操作如下：

>>> tuple = (1,2,3,4)
>>> tuple
(1, 2, 3, 4)

和列表一样，元组中可以包含整形、字符串、浮点型数据，还可以包含另一个元组。

1.3.2从元组中获取元素

由于元组中的元素不能随意插入或更改，所以插入或更改的方法在后文中讲解，我们先来讲解简单一点的元素获取方法（其方法与列表中获取元素方法相同）。

1. 从元组中获取元素可以一次获取一个或多个，获取一个的操作如下：

>>> tuple = (1,2,3,4)
>>> tuple[0]
1

2. 获取多个的方法如下：

>>> tuple = (1,2,3,4)
>>> tuple[0:3]
(1, 2, 3)

tuple[0:3]中0为开始位置，3为结束位置；

3. 访问元组中元组的方法如下：

>>> tuple = (1,2,(3,4))
>>> tuple[2][1]
4

tuple[2][1]2指第一层元组的元素，1指第二层元组中的元素。

1.3.3元组反转

其反转方法和列表的第一种方法一样，通过分片操作即可，分片操作中当步长为-1就可以实现列表反转，操作如下：

>>> tuple = (1,2,3,4)
>>> tuple[::-1]
(4, 3, 2, 1)

1.3.4元组的重复

元组重复的操作与列表类似，具体如下：

>>> tuple = (123,)
>>> tuple*3
(123, 123, 123)
>>> tuple *= 3
>>> tuple
(123, 123, 123)

需要注意的是当创建的元组只包含一个元素时，里面的逗号是必不可少的，有逗号才可以证明我们创建的是元组，证明如下（我们使用type方法查看类型）：

>>> temp = (123)
>>> type(temp)
<class 'int'>
>>> temp = (123,)
>>> type(temp)
<class 'tuple'>

当没有逗号时我们创建的是int型，而有逗号时我们创建的才是元组，由此可见逗号才是元组的关键！

1.3.5向元组中添加元素

既然不可以在元组中随意插入元素，那么我们就使用构造新元组的方法来解决这个问题，操作如下：

>>> tuple = ('z','x','c')
>>> tuple = tuple[0:2]+('zxc',)+tuple[2:]
>>> tuple
('z', 'x', 'zxc', 'c') 

这样我们就可以向元组中添加一个元素，并且添加的位置还可以自己来定，其实原理是使用分片的方法将元组拆分为两部分，再使用连接操作符+合并为一个新元组，最后将tuple名指向新元组，需要注意的是被添加元素(‘zxc’,)的逗号不可缺少！！

1.3.6从元组中删除元素

1. 删除的原理和插入原理类似，都需要采用列表分片的方法，然后使用连接操作符+合并一个新元组，操作如下：

>>> tuple = ('删','除','元','组')
>>> tuple = tuple[:1] + tuple[2:]
>>> tuple
('删','元','组') 

2. 如果需要删除整个元组，我们可以使用del语句，操作如下：

>>> tuple1 = (1,2,3,4)
>>> del tuple1
>>> tuple1
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    tuple1
NameError: name 'tuple1' is not defined 

1.4 集合（Set）

集合是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合的唯一性，无序性和确定性

1.4.1创建集合

用法：

# 创建保存多个元素的集合
parame = {value01, value02, ...}
# 创建一个空集合
set(value) 

示例：

sets = {1, 2, 3, 4, 5}

1.4.2操作集合

1. 添加单个元素

sets.add(6)
print(sets)

{1, 2, 3, 4, 5, 6}

add()将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

2. 添加多个元素

sets.update([7, 8])
print(sets)

{1, 2, 3, 4, 5, 6, 7, 8}

update()可以添加元素，且参数可以是列表，元组，字典等。x 可以有多个，用逗号分开。

3. 移除元素

# 移除存在的元素
sets.remove(2)
# 移除不存在的元素
sets.remove(9)
# KeyError: 9
print(sets)

{1, 3, 4, 5, 6, 7, 8}

remove()将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

# 移除存在的元素
sets.discard(1)
# 移除不存在的元素
sets.discard(10)

{3, 4, 5, 6, 7, 8}

discard()也是移除集合中的元素，且如果元素不存在，不会发生错误。

sets.pop()
print(sets)

{4, 5, 6, 7, 8}

pop()随机删除集合中的一个元素。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

4. 计算集合元素个数

print(len(sets))

5

len()计算集合中某个元素的个数。

5. 清空集合

sets.clear()
print(sets)

set()

clear()清空指定的集合。

6. 判断元素是否在集合中存在

x in sets

1

in判断元素 x 是否在集合 sets 中，存在返回 True，不存在返回 False。

1.4.3集合内置方法

• add()：为集合添加元素。
• clear()：移除集合中的所有元素。
• copy()：拷贝一个集合。
• difference()：返回多个集合的差集。
• discard()：删除集合中指定的元素。
• intersection()：返回集合的交集。
• isdisjoint()：判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
• issubset()：判断指定集合是否为该方法参数集合的子集。
• issuperset()：判断该方法的参数集合是否为指定集合的子集。
• pop()：随机移除元素。
• remove()：移除指定元素。
• symmetric_difference()：返回两个集合中不重复的元素集合。
• union()：返回两个集合的并集。
• update()：给集合添加元素。

1.5 数据结构的一些技巧

1.5.1 多重循环

如下：
代码演示：

for a, b in zip(num, str):
    print(b, 'is', a)

1.5.2 推导式

列表推导式的用法很好理解，可以简单地看成两部分。如下：

红色虚线后面的是我们熟悉的 for 循环的表达式，而虚线前面的可以认为是我们想要放在列表中的元素。

代码演示

a = []
for i in range(1, 11):
    a.append(i)

可以换成列表解析的方式来写：

b = [i for in i range(1, 11)]