【python基础】（二）：常用数据结构及其用法

顺序结构

列表（List）

创建列表

列表是一种可变的数据结构，可存储任意类型的元素。

a = ['q', 1, '111', 2222]
li = []  # 空列表
li = list()  # 空列表的另一种表示

拼接

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b  # 结果：[1, 2, 3, 4, 5, 6]

追加

使用 append() 方法在列表末尾添加元素。

a = [1, 2, 3]
a.append(4)  # 结果：[1, 2, 3, 4]

插入

使用 insert() 方法在指定位置添加元素。

a = [1, 2, 3]
a.insert(1, 'new')  # 结果：[1, 'new', 2, 3]

列表扩展

使用 extend() 方法合并另一个列表。

a = [1, 2, 3]
a.extend([4, 5])  # 结果：[1, 2, 3, 4, 5]

取出

使用 pop() 方法移除并返回指定位置的元素。

a = [1, 2, 3]
removed_element = a.pop(1)  # 结果：2, 列表变为[1, 3]

移除元素

使用 remove() 方法删除指定的元素。

a=[1,2,3]
a.remove(2)# 结果：[1, 3]
# 或者
del a[2]# 结果：[1, 3]

清空

使用 clear() 方法清空整个列表。

a = [1, 2, 3]
a.clear()  # 结果：[]

排序

sort(reverse):将列表进行排序，默认是从小到大，可以加参数reverse=True，来进行逆向排序

a = [3, 1, 2]
a.sort()  # 默认升序排序，结果：[1, 2, 3]
a.sort(reverse=True)  # 逆向排序，结果：[3, 2, 1]

数字列表

使用 range() 函数创建数字列表。

numbers = list(range(1, 6))  # 结果：[1, 2, 3, 4, 5]

简单统计函数

sum():求和。
min():最小值。
max():最大值。

列表转字符串

使用 join() 方法将列表转换为字符串。

a = ['hello', 'world']
result = ' '.join(a)  # 结果："hello world"

元组

元组是不可变的数据结构，一旦创建，其内容不能更改。

创建元组

a = (1, 2, 3, 4)

元组操作

a=(1,2,3,44,52,11,2,1,2,11,2,3)
a.count(1) # 统计指定元素出现的数量
a.index(44) # 找到第一次出现的指定元素的索引
del(a) # 删除元组

列表与元组的转换

# 列表转元组
my_list = ["a", "b"]
my_tuple = tuple(my_list)

# 元组转列表
my_tuple = ("a", "b")
my_list = list(my_tuple)

元组转列表

List =list(tuple)

字符串（String）

Python 字符串不能修改，是 immutable 的。因此，为字符串中某个索引位置赋值会报错,要生成不同的字符串，应新建一个字符串.

字符串有多种表现形式，用单引号（'……'）或双引号（"……"）标注的结果相同 。反斜杠 \ 用于转义；

可以实现跨行连续输入。实现方式是用三引号："""...""" 或 '''...'''，字符串行尾会自动加上回车换行，如果不需要回车换行，在行尾添加 \ 即可。示例如下：

print('''
	hello  
	world \
	python
	''')  

字符串前缀u r b f

• u：Unicode字符串。
• r：原始字符串，忽略转义字符。
• b：字节字符串。
  • f：格式化字符串。
    1.u前缀表示unicode，以Unicode字符来存储字符串。在python3中，字符串的存储方式中，不管前缀带不带u，默认方式都是unicode编码的字符串。

2.r前缀表示raw string，不识别转义，在引号前添加 r 即可：

print('Hello\n World')  
#Hello  
# World  
print(r'Hello\n World')  
#Hello\n World

3.b前缀表示bytearray，生成字节序列对象。比如在网络通信中，需要按字节序列发送数据时有用，如下

import socket  
s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  
message = b'hello'  
s.sendto(message,('127.0.0.1',3030))

4.f前缀表示format，用来格式化字符串。比format具有更好的可读性，如下

age = 38  
name = "Annie"  
print(f'his name is {name},{age} years old')  
#his name is Annie,38 years old

字符操作

# 连接
s = 'hello' + ' ' + 'world'  # "hello world"

# 重复
repeated = 'hi ' * 3  # "hi hi hi"

# 相邻的两个或多个字符串字面值（引号标注的字符）会自动合并，这项功能只能用于两个字面值，不能用于变量或表达式：
print('hello' ' world')  #hello world

# 字符串长度
length = len(s)  # 字符串长度

# 查找与替换
position = s.find('world')  # 返回'world'的开始索引
rep = s.replace('world','世界') # hello 世界

str.title():单词首字母大写，其余小写。

name ='hello world'  
print(name.title())  
#Hello World

str.lower():全部转小写。

name = 'HELLO WORLD'  
print(name.lower())  
#hello world

str.upper():全部转大写。

str.lstrip():清除字符串左侧的空格。

str.rstrip():清除字符串右侧的空格。

str.strip():清除字符串两侧的空格。

ord(str):字转数。

print(ord('d'))  #100

chr(num):数转字。

print(chr(100))  #d

操作

索引

索引 （下标访问），第一个字符的索引是 0。

a = 'world'
print(a[0])
#w
print(a[4])
#d

索引还支持负数，用负数索引时，从右边开始计数：

a = 'world'  
print(a[-0])  
#w
print(a[-1])  
#d
print(a[-4])  
#o

注意，-0 和 0 一样，因此，负数索引从 -1 开始。

切片

在[]中通过索引切割出指定范围的子集
语法：[开始索引:结束索引]，左开右闭
索引如果超出不会报错

a=[1,2,3,4,5,6,7,8,9]
a[:]
a[2:5]
a[:3]
a[3:]
a[-3:-1] #索引支持负数，也就是从末尾（-1）开始，但这种无法获取到列表最后一个，因为是闭区间
a[-6,6]

a = 'world'  
print(a[0:2])  
#wo  
print(a[2:5])  
#rld

切片索引的默认值很有用；省略开始索引时，默认值为 0，省略结束索引时，默认为到字符串的结尾：

print(a[:3])
#wor  
print(a[3:])  
#ld  
print(a[:-2])  
#wor

注意，输出结果包含切片开始，但不包含切片结束。因此，s[:i] + s[i:] 相同于 s：

还可以这样理解切片，第一个字符的左侧标为 0，最后一个字符的右侧标为 n ，n 是字符串长度。例如：

p	y	t	h	o	n
0	1	2	3	4	5	6
-6	-5	-4	-3	-2	-1

第一行数字是字符串中索引 0…6 的位置，第二行数字是对应的负数索引位置。i 到 j 的切片由 i 和 j 之间所有对应的字符组成。

对于使用非负索引的切片，如果两个索引都不越界，切片长度就是起止索引之差。例如， word[1:3] 的长度是 2。

原本索引越界会报错，但是，切片会自动处理越界索引：

print(a[3:598])  
#ld

字典

一种键值对存储的结构,
键是唯一的，不能修改，通常使用数字或字符串，也可以是元组

dictionary={'a'=2222}
a={'a':2}
a['key1']='value1'

常用函数

Dic.Get(key，default)：在找不到对应的值时，返回一个默认值，没填第二个参数，默认为none

dic.items():返回一个键值对序列

dic. keys()：返回一个键序列

操作

# 长度
a={'a':'a11','b':'aaass',1:222}
len(a)
# 根据键取值
a['a'] # 有值打印，无值报错
a.get('a') # 有值打印，无值不报错
ak = a.keys() # 获取键可迭代序列
av = a.values() # 获取值可迭代序列
ai = a.items() # 获取键值可迭代序列
a.clear() # 清空

删除

del(a['a']) # 如果使用get获取的是值，无法删除字典键值对

弹出

返回对应数据，并从数组中删除。

a.pop('a')

集合set

集合是一个无序且不包含重复元素的数据结构。

创建集合

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

集合操作

# 添加元素,无法添加重复元素
s.add(6)

# 删除元素
s.remove(2)

# 集合运算
another_set = {4, 5, 6, 7}
union_set = s.union(another_set)  # 并集
intersection_set = s.intersection(another_set)  # 交集