python基础——容器

通用操作

数学运算符

1. +：用于拼接两个容器
2. +=：用原容器与右侧容器拼接,并重新绑定变量
3. *：重复生成容器元素
4. *=：用原容器生成重复元素, 并重新绑定变量
5. < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。

成员运算符

语法：

        数据 in 序列

        数据 not in 序列

作用：

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

索引index

1. 作用：定位单个容器元素
2. 语法：容器[整数]
3. 说明：

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

反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

例子：

反向索引	-8	-7	-6	-5	-4	-3	-2	-1
	我	是	计	算	机	爱	好	者
正向索引	0	1	2	3	4	5	6	7

切片slice

作用：

        定位多个容器元素。

语法：

        容器[(开始索引):(结束索引)(:(步长))]

说明：

        红色部分小括号()括起的部分代表可省略

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

        开始索引省略，默认为0

        结束索引省略，默认末尾（包含末尾）

        步长省略，默认为1

        特殊情况    [::-1]全部倒过来

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

        [m:n]

        m<=n时候为空

索引不能越界，切片可以越界

内建函数

1. len(x)     返回序列的长度
2. max(x)   返回序列的最大值元素
3. min(x)   返回序列的最小值元素
4. sum(x)   返回序列中所有元素的和(元素必须是数值类型)

字符串 str

定义

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

编码

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

   

2. 字符：单个的数字，文字与符号。
3. 字符集(码表)：存储字符与二进制序列的对应关系。
4. 编码：将字符转换为对应的二进制序列的过程。
5. 解码：将二进制序列转换为对应的字符的过程。
6. 编码方式：

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

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

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

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

相关函数

ord(字符串):返回该字符串的Unicode码。

chr(整数):返回该整数对应的字符串。   

    字--->编码
    ord( )
    
    字--->编码
    chr( )

  

字面值

单引和双引号的区别

1. 单引号内的双引号不算结束符
2. 双引号内的单引号不算结束符

三引号作用

1. 换行会自动转换为换行符\n
2. 三引号内可以包含单引号和双引号
3. 作为文档字符串

转义字符

1. 改变字符的原始含义。

                \’  \”  \”””  \n  \\  \t  \0 空字符 

     2.原始字符串：取消转义。

            a = r”C:\newfile\test.py”

字符串格式化

定义：

        生成一定格式的字符串。

语法：

        字符串%(变量)

        "我的名字是%s,年龄是%s" % (name, age)

        %.nf(n取多少就会保留几位小数,四舍五入)

类型码：

        %s 字符串     %d整数     %f 浮点数

列表 list

定义

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

基础操作

创建列表：

        列表名 = []   

        列表名 = list(可迭代对象)

获取元素：

        方法一：索引

        方法二：切片

添加元素：

        列表名.append(元素)

        列表.insert(索引，元素)

定位元素：

        列表名[索引] = 元素

        变量 = 列表名[索引]

        变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表

        列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：

       正向：

       for 变量名 in 列表名:

              变量名就是元素

      反向：

       for 索引名 in range(len(列表名)-1,-1,-1):

              列表名[索引名]就是元素

删除元素：

        列表名.remove(元素)

      del 列表名[索引或切片]

例：

深拷贝和浅拷贝

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

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

列表VS字符串

1. 列表和字符串都是序列,元素之间有先后顺序关系。
2. 字符串是不可变的序列,列表是可变的序列。
3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。
4. 列表和字符串都是可迭代对象。
5. 函数：

将多个字符串拼接为一个。

result = "连接符".join(列表)

将一个字符串拆分为多个。

列表 = “a-b-c-d”.split(“分隔符”)

列表推导式

定义：

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

语法：

        变量 = [表达式 for 变量 in 可迭代对象]

        变量 = [表达式 for 变量 in 可迭代对象 if 条件]

说明:

        如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

列表推导式嵌套

语法：

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

传统写法：

result = []

for r in  ["a", "b", "c"]:

    for c in ["A", "B", "C"]:

        result.append(r + c)

推导式写法：

result = [r + c for r in list01 for c in list02]

 

列表扩容

1、列表都会预留空间

2、预留空间不足时，会再开辟更大的空间（创建新列表）

3、将原有列表数据拷贝到新列表中

4、替换引用

元组 tuple

定义

1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。   

基础操作

创建空元组：

元组名 = ()

元组名 = tuple()

创建非空元组：

元组名 = (20,)

    元组名 = (1, 2, 3)

元组名 = 100,200,300

元组名 = tuple(可迭代对象)

获取元素： 

变量 = 元组名[索引]

变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表 

遍历元组：

       正向：

       for 变量名 in 列表名:

              变量名就是元素

              反向：

       for 索引名 in range(len(列表名)-1,-1,-1):

              元组名[索引名]就是元素

作用

1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
3. 应用：

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

格式化字符串的本质就是创建元祖："姓名:%s, 年龄:%d"  % ("tarena", 15)

列表：

元组：

字典 dict

定义

1. 由一系列键值对组成的可变散列容器。
2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

创建字典：

字典名 = {键1：值1，键2：值2}

字典名 = dict (可迭代对象)

添加/修改元素：

语法:

    字典名[键] = 数据

说明:

    键不存在，创建记录。

    键存在，修改值。

获取元素：

变量 = 字典名[键]  # 没有键则错误

遍历字典：

       for 键名 in 字典名:

              字典名[键名]

for 键名,值名 in 字典名.items():

语句

删除元素：

del 字典名[键]

字典推导式

定义：

使用简易方法，将可迭代对象转换为字典。

语法:

{键:值 for 变量 in 可迭代对象}

    {键:值 for 变量 in 可迭代对象 if 条件}

练习：

字典 VS 列表

1. 都是可变容器。
2. 获取元素方式不同,列表用索引,字典用键。
3. 字典的插入,删除,修改的速度快于列表。
4. 列表的存储是有序的,字典的存储是无序的。
5. 

集合 set

定义

1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。

基础操作

创建空集合：

集合名 = set() 

集合名 = set(可迭代对象)

创建具有默认值集合：

集合名 = {1, 2, 3}

集合名 = set(可迭代对象)

添加元素：

集合名.add(元素)

删除元素：

集合名.discard(元素)

运算

交集&：返回共同元素。

s1 = {1, 2, 3}

s2 = {2, 3, 4}

      s3 = s1 & s2  # {2, 3}

并集：返回不重复元素

s1 = {1, 2, 3}

     s2 = {2, 3, 4}

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

差集-：返回只属于其中之一的元素

     s1 = {1, 2, 3}

     s2 = {2, 3, 4}

      s1 - s2  # {1} 属于s1但不属于s2

补集^：返回不同的的元素

     s1 = {1, 2, 3}

     s2 = {2, 3, 4}

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

1. 子集<：判断一个集合的所有元素是否完全在另一个集合中
2. 超集>：判断一个集合是否具有另一个集合的所有元素

     s1 = {1, 2, 3}

     s2 = {2, 3}

       s2 < s1  # True

     s1 > s2  # True

1. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。

      s1 = {1, 2, 3}

     s2 = {3, 2, 1}

     s1 == s2  # True

     s1 != s2  # False

子集或相同,超集或相同 <=  >=

集合推导式

1. 定义：

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

1. 语法:

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

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