python数据容器专题

# 列表的创建
[]                            # 创建空列表，其结果为[] 
[1,2,3,4,5,'6',{7}]           # 创建拥有不同数据类型成员的列表，其结果为[1, 2, 3, 4, 5, '6', {7}] 
list((0,1))                   # 通过强制类型转换创建列表，其结果为[0, 1] 
[1,2] * 2                                  # 简写重复的元素建立一维列表，其结果为 [1, 2, 1, 2]
[i for i in range(1,16,2)]                 # 使用嵌套的表达式建立列表，用到了列表推导式的写法，其结果为[1, 3, 5, 7, 9, 11, 13, 15] 
list(map(lambda x: x, range(1,16,2)))      # 效果上与e相同，其结果为[1, 3, 5, 7, 9, 11, 13, 15] 
[[1,2,3,4,5],[5,4,3,2,1]]                  # 创建二维列表，其结果为[[1,2,3,4,5],[5,4,3,2,1]]
[[1,2] * 2] * 3                            # 简写重复的元素建立二维列表，
                                           # 其结果为 [[1, 2, 1, 2], [1, 2, 1, 2], [1, 2, 1, 2]]

# 尾插入法
a = ["你","好"]
a.append("啊")    # 在原列表的最后一个位置插入元素
print(a)          # 结果为 ["你", "好", "啊"]
# 指定位置插入
a = ["你","好"]
a.insert(1,"真")  # 在原索引号为 1 的位置处插入元素"真"
print(a)          # 结果为 ["你", "真", "好"]

# 列表元素的索引
[1, 2, 3, 4][-1]                           # 其结果为 4
['零','一','二','三','四','五','六'][1:5]   # 通过列表的切片创建子列表，其结果为 ['一', '二', '三', '四'] 
# 元素反查列表索引
a = [i for i in 'ABCDEFGHIJKABCDEFGHIJK']
a.index('G')                               # 使用列表的index()方法查询'G'的索引

# 列表的合并
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a+b                                        # 其结果为 [1, 2, 3, 4, 5, 6, 7, 8]
a.extend(b)                                # 其结果为 [1, 2, 3, 4, 5, 6, 7, 8]
# 列表合并字典键
a = [0, 1, 2, 3, 4]
b = {'5':'五','6':'六','7':'气'}
a.extend(b)                                # 其结果为 [0, 1, 2, 3, 4, '5', '6', '7']

a = ["老虎","狮子","豹子","袍子","猴子","猩猩","狗熊"]
"北极熊" in a               # 判断某元素是否在列表a中，结果为 False
“"猴子" in a                # 结果为 True
"袍子" not in a             # 结果为 False

# 获取列表的一个浅拷贝
a = [0, 1, 2, 3, 4, 3, 2, 1]
a.copy()

# 列表元素的统计
a = [i for i in 'ABCDEFGHIJKABCDEFGHIJK']
a.count('A')             # 其结果为 2，表明该元素在列表中出现过2次
len(a)                   # 统计列表 a 中所有元素的个数，结果为22
max(a)                   # 最大值，对于字符比较的是字符的最后的字母。返回结果为'K'
min(a)                   # 最小值，对于字符比较的是字符的最前的字母。返回结果为'A'

# 反转
a = [1, 2, 3, 4, 5, 6, 7]
a.reverse()                               # 反转列表元素，[7, 6, 5, 4, 3, 2, 1]

# 排序
a = [ 'zl赵六', 'lh李华', 'lm李明', 'xh小红','zs张三', 'lh李华', 'ww王五', 'zl赵六', 'xh小红', 'lh李华']
print(a.sort())     # 对列表中的元素进行排序
                    # 结果为 [‘lh李华’, ‘lh李华’, ‘lh李华’, ‘lm李明’, ‘ww王五’, ‘xh小红’, ‘xh小红’, ‘zl赵六’, ‘zl赵六’, ‘zs张三’]
b = [9,7,8,5,2,4,5,4,5]
b.sort()
print(b)           # 结果为 [2, 4, 4, 5, 5, 5, 7, 8, 9]

a = [9,7,8,5,2,4,5,4,5]
print("a=",a)
sorted(a)

# 元组的创建
()                           # 直接创建一个空元组
(1, 2)                       # 通过列举成员直接创建一个一维元组
((1,2,3),(4,5,6),(7,8,9))    # 通过列举成员直接创建一个二维元组
1, 2, '3','4', 5             # 创建序列甚至可以不写小括号，且其成员支持任意类型

# 索引元组
tp = tuple(range(10))
tp[2]                        # tp的第3个元素，其结果为 2
a_tuple[2:6]                 # tp的第3个元素到第6个元素构成的子元组，其结果为 (2, 3, 4, 5)

# 将其它序列转换为元组
tuple([1,2,3])               # 将列表转换为元组，结果为(1,2,3)
tuple("写代码很快乐")         # 将字符串转换为元组，结果为 ("写","代","码","很","快","乐")
tuple((i for i in range(5))) # 有元组推导式生成元组，结果为(0,1,2,3,4)

a = (6,4,7,8,9,2,4)
len(a)                      # 获取元组a中的元素个数，结果为 7
max(a)                      # 求元组a中的最大值，结果为 9
min(a)                      # 求元组a中的最小值，结果为 2

a = ("老虎","狮子","豹子","袍子","猴子","猩猩","狗熊")
"北极熊" in a               # 判断某元素是否在元组a中，结果为 False
“"猴子" in a                # 结果为 True
"袍子" not in a             # 结果为 False

range(5)                   # 创建range序列，结果为 range(0,5)

range(0,5)[2:3]            # 索引range序列，结果为 range(2, 3)
range(0,10)[2:8:2]         # 索引range序列时也同样可以指定在最后步长，结果为 range(2, 8, 2)，包含元素2,4,6
range(10)[2]               # 结果为 2

range(10).index(5)         # 查元素5在该range序列中的索引号，结果为5

len(range(5))              # 求range序列中的元素个数，结果为 5
max(range(3,9))            # 求range序列中最大的元素，结果为8
min(range(3,9))            # 求range序列中最小的元素，结果为3

0 in range(5)              # 判断元素是否在range序列中，结果为 True
5 in range(5)              # 结果为 False

tuple(range(2,5))          # range序列转换为元组，结果为 (2, 3, 4)
list(range(2,5))           # range序列转换为列表，结果为 [2, 3, 4]
list(range(0, -10, -1))    # 结果为 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
list(range(1, 0))          # 结果为 []
list(range(0))             # 结果为 []

"abcd"                       # 既可以使用双引号创建字符串
'WIJDH'                      # 也可以使用单引号创建字符串
a = "Hello World!"           # 将字符串常量赋值给遍历`a`，那么变量`a`引用的是字符串类型对象
                             # 但注意Python是动态类型语言，当再次复制其它类型的时候a就会称为对其它对象的引用

a = "ie6DCEG5QSD4Rwjgc"
a[2:6]                       # 结果为'6DCE'

bytes(b"kajshd")                  # 直接由二进制数据创建不可变字节数组，只有是ASCII码中包含的字符才可以。结果为 b'kajshd'
bytes("我爱我的祖国", "utf-8")     # 指定编码为"utf-8"，将字符串转为不可变字节数组，b'\xe6\x88\x91\xe7\x88\xb1\xe4\xb8\xad\xe5\x9b\xbd'
bytes(6)                          # 结果为 b'\x00\x00\x00\x00\x00\x00'
bytes([1,2,3,4,5,6])              # 结果为 b'\x01\x02\x03\x04\x05\x06'
bytes((1,2,3,4,5,6))              # 结果为 b'\x01\x02\x03\x04\x05\x06'

bytearray()                  # 创建一个空字节数组，返回结果为 bytearray(b'')
bytearray(range(5))          # 由range序列创建字节数组，结果为 bytearray(b'\x00\x01\x02\x03\x04')
bytearray([1,2,3])           # 由列表创建字节数组，结果为 bytearray(b'\x01\x02\x03')
bytearray((1,2,3))           # 由元组创建字节数组，结果为 bytearray(b'\x01\x02\x03')
bytearray(b'1a63fb')         # 由二进制数组创建字节数组，结果为 bytearray(b'1a63fb')
bytearray(5)                 # 由整数创建二进制数组，其结果为 bytearray(b'\x00\x00\x00\x00\x00')
bytearray("我爱python", "utf-8")      # 指定字符串编码为"utf-8"，由字符串创建字节数组
                                      # 其结果为 bytearray(b'\xe6\x88\x91\xe7\x88\xb1python')
bytearray("我爱python", "gbk")        # 指定字符串编码为"gbk"，由字符串创建字节数组
                                      # 其结果为 bytearray(b'\xce\xd2\xb0\xaepython')

a = bytearray([6,4,5,7,8,9,4,5,6,4,6])
len(a)                     # 字节数组 a 的长度，结果为11
max(a)                     # 字节数组 a 元素最大值，结果为 9
min(a)                     # 字节数组 a 元素最大值，结果为 4
a.count(6)                 # 字节数组 a 中 6 对应字节数据出现次数，结果为 3

a = bytearray("快乐学习", "utf-8")
print(a)               # 结果为bytearray(b'\xe5\xbf\xab\xe4\xb9\x90\xe5\xad\xa6\xe4\xb9\xa0')，一个汉字有3个字节
a.pop()                # 出栈，返回 160 ，原字节数组变为 bytearray(b'\xe5\xbf\xab\xe4\xb9\x90\xe5\xad\xa6\xe4\xb9')
a.push(1)              # 尾插，a 变为 bytearray(b'\xe5\xbf\xab\xe4\xb9\x90\xe5\xad\xa6\xe4\xb9\x01')
a.insert(8，6)         # 在索引为 8 处插入，a 变为 bytearray(b'\xe5\xbf\xab\xe4\xb9\x90\xe5\xad\x06\xa6\xe4\xb9\x01')
a.index(6)             # 获取第一个6对应字节数据的索引，结果为 8

a = bytearray([6,4,5,7,8,9,4,5,6,4,6])
a[5]                   # 索引字节数组第 6 个元素，结果为整数 9 
a[4:8]                 # 索引第 5 到第 7 个字节元素，结果为字节数组 bytearray(b'\x08\t\x04\x05')

a = bytearray([6,4,5,7,8,9,4,5,6,4,6])
6 in a                # 判断 6 的字节数据是否在字节数组 a 中，结果为 True
7 not in a            # 判断 7 的字节数据是否在字节数组 a 中，结果为 False

a = bytearray("你好啊，世界！","utf-8")
path = r"D:\codes\bytearray_test.txt"
with open(path,"wb") as file:
    file.write(a)

path = r"D:\codes\bytearray_test.txt"
with open(path,'rb') as file:
    stream = file.read()
    print("输出字节流：", stream)
    print("转为字符串输出", str(straem, encoding="utf-8"))

from array import array           # 导入python数组对象

from collections import deque

deque([1,2,3,4,5,6,7]).append('1')      # 尾插法：结果为 deque([1, 2, 3, 4, 5, 6, 7, '1'])，时间复杂度为O(1)
deque('abcde').appendleft('A')          # 首查法：结果为 deque(['A', 'a', 'b', 'c', 'd', 'e'])，时间复杂度也为O(1)
deque('abcde').insert(2,'666')          # 在指定索引位置插入元素，结果为 deque(['a', 'b', '666', 'c', 'd', 'e'])

a = deque('abcde')
a.extend('ABC')                       # 在原队列右侧拓展，结果为 deque(['a', 'b', 'c', 'd', 'e', 'A', 'B', 'C'])

a = deque('abcde')
a.extend(['*',6,'&',9,'^'])             # 结果为 deque(['a', 'b', 'c', 'd', 'e', '*', 6, '&', 9, '^'])

import numpy as np
a = np.array([1,2,3,4,5,6])           # 通过将列表[1,2,3,4,5,6]类型转换创建数组a
b = np.array((1,2,3,4,5,6))           # 通过将元组(1,2,3,4,5,6)类型转换创建数组b
c = np.arange(0,1,7,dtype=int)        # 等间隔生成数组c，指定元素数据类型为整形。该方法类似于原生Python中用rang(i)生成range序列，但返回的是一个np.array对象
d = np.linspace(-2,2,5)               # 在(-2,2)上按照线性间隔创建数组
e = np.empty((2,3),int)               # 通np.empty()方法创建 2X3 空数组
f = np.random.random((2, 3))          # 生成2X3的随机浮点数数组
g = np.random.randint(1,10,(3,5))   # 随机生成区间[1:9]上的 3行5列数组
h = np.mgrid[-2:2:5j]                 # j代表虚数单位，此处与np.linspace(-2,2,5)等价
i = np.mgrid[0:2:4j,10:20:5j]         # 使用虚数单位j生成区间[0,2]X[10,20]上的4X5的二维数组
print('a=',a,'\nb=',b,'\nc=',c,'\nd=',d,'\ne=',e,'\nf=',f,'\ng=',g,'\nh=',h,'\ni=',i)

a= [1 2 3 4 5 6] 
b= [1 2 3 4 5 6] 
c= [0] 
d= [-2. -1.  0.  1.  2.] 
e= [[1 2 3]
 [4 5 6]] 
f= [[0.21883881 0.80893396 0.86216125]
 [0.47656256 0.05026984 0.92402366]] 
g= [[3 5 6 2 8]
 [9 5 4 3 3]
 [5 9 6 1 8]] 
h= [-2. -1.  0.  1.  2.] 
i= [
[[ 0.          0.          0.          0.          0.        ]
  [ 0.66666667  0.66666667  0.66666667  0.66666667  0.66666667]
  [ 1.33333333  1.33333333  1.33333333  1.33333333  1.33333333]
  [ 2.          2.          2.          2.          2.        ]]
 [[10.         12.5        15.         17.5        20.        ]
  [10.         12.5        15.         17.5        20.        ]
  [10.         12.5        15.         17.5        20.        ]
  [10.         12.5        15.         17.5        20.        ]]]

from pandas import Series      # 这样导入可以直接使用 Series
import pandas as pd               # 这样导入需要写成 pandas.pd

from pandas import Series
Series([1,2,3,4,5,6])

0    1
1    2
2    3
3    4
4    5
5    6
dtype: int64

import pandas as pd
a = {'a': 1, 'b': 2, 'c': 3}
pd.Series(data=a, index=['a', 'b', 'c'])

a   1
b   2
c   3
dtype: int64