Python之容器

通用操作

    数学运算符

            +：用于拼接两个容器

            +=：用原容器与右侧容器拼接，并重新绑定变量

             *：重复生成容器元素

             *=：用原容器生成重复元素，并重新绑定变量

             < <= > >= == !=：依次比较两个容器中元素，一旦不同则返回比较结果

    成员运算符

              语法：

                        数据 in 序列

                        数据 not in 序列

              作用：如果在指定的序列中找到值，返回bool类型

    索引 index

              作用：访问容器元素

              语法：容器[整数]

              说明：

                      正向索引从0开始，第二个索引为1，最后一个为len() - 1

                      反向索引是从 -1 开始， -1 代表最后一个， -2 代表倒数第二个，最后一个是 -len()

    切片 slice

               作用：从容器中取出相应的元素重新组成一个容器

               语法：容器[开始索引：结束索引：步长]

               说明：

                      结束索引不包含该位置元素

                      步长是切片每次获取完当前元素后移动的偏移量

    内建函数

               len()  获取容器长度

               max() 获取容器中的最大元素

               min() 获取容器中的最小元素

               abs() 获取绝对值

               pow() 计算一个数值的N次方

               round() 对一个数值进行四舍五入操作

               ord() 将字符转换为其对应的ascii码

               chr() 将ascii编码转换为字符

字符串 str

    定义

            由一系列字符组成的不可变序列容器，存储的是字符的编码值

    编码

            字节byte：计算机最小存储单位，等于8位bit

            字符：单个的数字，文字与符号。

            字符集(码表)：存储字符与二进制序列的对应关系。

            编码：将字符转换为对应的二进制序列的过程。

            解码：将二进制序列转换为对应的字符的过程。

            解码方式：

                   1、ASCII编码：包含英文、数字等字符，每个字符1个字节

                   2、GBK编码：兼容ASCII编码，包含21003个中文，英文1个字节，汉字2个字节

                   3、Unicode 字符集：国际统一编码，旧字符集每个字符2字节，新字符集每个字符4个字节

                   4、UTF-8 编码：Unicode 的存储与传输方式，英文1字节，中文3个字节

        相关函数

                    bin（整数）：将整数转换为二进制字符串

                    ord（字符串）：返回该字符串的Unicode码

                    chr（整数）：返回该整数对应的字符串

    字面值

        单引号和双引号的区别

                      单引号内的双引号不算结束符

                      双引号内的单引号不算结束符

        三引号作用

                     换行会自动转换为换行符 \n

        转义字符

                    改变字符的原始含义。

                    \'  \"  \"""   \n   \\   \t   \0  空字符

        字符串格式化

                    1、定义：生成一定格式的字符串

                    2、语法：字符串%（变量）-- “我的名字是%s，年龄是%d” % (name, age)

                    3、类型码：%s 字符串    %d 整数     %f 浮点数

                    4、格式：%[ - + 0 宽度.精度]类型码

                                    -：左对齐(默认是右对齐)

                                    +：显示正号

                                    0：左侧空白位置补零

                                    宽度：整个数据输出的宽度

                                    精度：保留小数点后多少位

 

列表 list

    定义

              由一系列变量组成的可变序列容器

    基础操作

              创建列表：[] 

              插入元素：insert

              追加元素：append

              获取元素：索引 [0]

              删除元素：remove

    深拷贝和浅拷贝

              浅拷贝：在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程

              深拷贝：复制整个依赖的变量

    列表 VS 字符串

              1、列表和字符串都是序列，元素之间有先后顺序关系

              2、字符串是不可变的序列，列表是可变的序列

              3、字符串中每个元素只能存储字符，而列表可以存储任意类型

              4、列表和字符串都是可迭代对象

              5、函数：

                          将多个字符串拼成一个：result = "连接符".join(列表)

                          将一个字符串拆分成多个：列表 = “a-b-c-d”.split("分隔符")

    列表推导式

              定义：使用简易方法，将可迭代对象转换为列表

              语法：

                       变量 = [表达式 for 变量 in 可迭代对象] data = [i for i in range(10)]

                       变量 = [表达式 for 变量 in 可迭代对象 if 条件] data = [i for i in range(10) if i %2 ==0]

    列表推导式嵌套

                 传统写法：

result = []

for r in ['a', 'b', 'c']:
    for c in ['A', 'B', 'C']:
        result.append(r + c)

                推导式写法：

result = [r + c for r in ['a', 'b', 'c'] for c in ['A', 'B', 'C']]

                语法：[ 表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2 ]

 

元组 tuple

    定义

                  有一系列变量组成的不可变序列容器，不可变是值一旦被创建，不可以再添加修改

    基础操作

                  创建空元组：（）      tuple（） 

                  创建非空元组： t = (20,)     t = (1,2,3)     t = 100,200,300    tuple(可迭代对象)

                  获取元素：索引

    作用

                  元组与列表都可以存储一系列变量，由于列表会预留内存空间，元组会按需分配内存，所以如果变量数量固定，

                  建议使用元组

    应用场景

                  变量交换的本质就是创建元组：x,y = y,x

                  格式化字符串的本质就是创建元组：“姓名%s，年龄%d” % (name， age)

字典 dict

    定义

                 由一系列键值对组成的可变映射容器。

                 映射：通过键获取值(字符串 / 列表 / 元组通过索引)

                 键必须唯一且不可变(字符串 / 数字 / 元组)，值没有限制

    基础操作

                 创建字典：{键1：值1，键2：值2}        dict也是可迭代对象

                 添加/修改元素：

                           语法：字典[键] = 数据

                           说明：键不存在，创建键，并绑定键对应的值。键存在，修改绑定的值

                 获取元素：v = 字典[键]       没有键则报错

                 删除元素：del 字典[键]

    字典推导式

                  {i:str(i) for i in range(1, 5)}

集合 set

    定义

                   由一系列不重复的不可变类型组成的可变映射容器，相当于只有键没有值的字典，键是集合的数据

    基础操作

                   创建空集合：set()       set(可迭代对象)

                   创建具有默认值的集合：{1，2，3}   set(可迭代对象)

                   添加元素：add

                   删除元素：discard

    运算

                  交集&，并集|，补集，对称补集^，子集< ，超集>

                  & 生成两个集合的交集，即返回共同元素

s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2  # s3 = {2,3}

                  | 生成两个集合的并集，返回所有不重复元素

s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2  # s3 = {1,2,3,4} 

                  - 生成两个集合的补集  返回只属于前者的元素

s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 - s2  # s3 = {1}
s3 = s2 - s1  # s3 = {4}

                 ^ 生成两个集合的对称补集，返回两者不同的元素

s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2  # s3 = {1,4} 等同于 (s1 - s2 | s2 -s1)

                 < 判断一个集合是不是另一个集合的子集

                 > 判断一个集合是不是另一个集合的超集

s1 = {1,2,3}
s2 = {2,3}
s1 > s2  # True
s2 < s1  # True
s1 < s2  # False

                 ==  != 判断两个集合是否相同

s1 = {1,2,3}
s2 = {3,2,1}
s1 == s2  # True
s1 != s2  # False

                <= >= 判断两个集合是不是子集或相同，超集或相同

    集合推导式

                定义：使用简易方法，将可迭代对象转换为集合。

                语法：

                         {表达式 for 变量 in 可迭代对象}

                         {表达式 for 变量 in 可迭代对象 if 条件}

固定集合 frozenset

    定义

               不可变的集合

    作用

               固定集合可以作为字典的键，还可以作为集合的值

    基础操作

               创建固定集合：frozenset(可迭代对象)

    运算

               等同于set