[toc]

容器类型

通用操作

数学运算符

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

成员运算符

1. 语法：
   • 数据 in 序列
   • 数据 not in 序列
2. 作用：如果在指定的序列中找到值，返回bool类型。

str03 = "猥琐发育,别浪!"
print("猥琐" in str03)

str04 = "abcde"
print(str04[0])
print(str04[len(str04) - 1])
print(str04[-1])

# 索引不能越界
# print(str04[5])  # IndexError

# 切片
print(str04[0:3])# abc
print(str04[0:3:2]) # ac
print(str04[::]) # abcde
print(str04[::-1]) # edcba
print(str04[-2:-5:-1])# bcd
print(str04[1:1]) # 空
print(str04[1:10]) #bcde  切片即使越界,也不会错误.
print(str04[3:1]) # 空
print(str04[3:1:-1])# dc
print(str04[-2:])# de
print(str04[-2:1])# 空

索引index

1. 作用：访问容器元素
2. 语法：容器[整数]
3. 说明：
   正向索引从0开始，第二个索引为1，最后一个为len(s)-1
   反向索引是从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推。第一个是-len(s)

切片slice

1. 作用：从容器中取出相应的元素重新组成一个容器。
2. 语法：容器[(开始索引):(结束索引)(:(步长))] > 小括号()括起的部分代表可省略
3. 说明：
   结束索引不包含该位置元素
   步长是切片每次获取完当前元素后移动的偏移量

字符串str

定义：由一系列字符组成不可更改的序列容器，存储的是字符的编码值

name = "悟空"
name  = "孙悟空" 

不是替换了字符串的值，而是创建的新的内存地址其中的值为“孙悟空”赋值给了name

编码：

1. 字节byte：计算机最小存储单位，等于8位bit
2. 字符：单个的数字，文字与符号
3. 字符集（码表）：存储字符与二进制的序列的对应关系
4. 编码：将字符转换为对应的二进制序列的过程
5. 解码：将二进制序列转换为对应字符的过程
6. 编码方式：ASCII、GBK、Unicode、UTF-8

相关函数

1. bin(整数)：将整数转换为二进制
2. ord(字符)：将字符转换为编码值
3. chr(编码值)：将编码值转换为字符

转义字符

1. 改变字符的原始含义
   \’ \” \””” \n \\ \t \0 空字符
2. 原始字符串：取消转义。
   a = r”C:\newfile\test.py”

字符串格式化

1. 定义：生成一定格式的字符串。
2. 语法：字符串%(变量)
   > "我的名字是%s,年龄是%s" % (name, age)
3. 类型码：%s 字符串 %d整数 %f 浮点数
4. 格式：%[- + 0 宽度.精度]类型码
5. -: 左对齐(默认是右对齐)
6. + : 显示正号
7. 0 : 左侧空白位置补零
8. 宽度 : 整个数据输出的宽度
9. 精度 : 保留小数点后多少位
   > 这个精度只是显示出来的四舍五入，但是不会改变原来的值。但是round()函数会直接改变数值。
   练习：在控制台中显示120秒倒计时

# 在控制台中显示120秒倒计时
for i in range(120, -1, -1):
    minute = i // 60
    second = i % 60
    print("%02d:%02d" % (minute, second))

列表list

定义

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

基础操作

1. 创建列表：[] list(可迭代对象)

# 创建空列表
list01 = []
list01 = list()

2. 添加元素：insert/append

#  添加元素
# append 在末尾追加
list02.append("q")
list02.append("t")
# insert 插入(索引,元素)
list02.insert(1,"x")

3. 获取元素：索引/切片

# 定位元素(索引  切片)
# 获取前三个元素
print(list02[:3])
print(list02)

4. 删除元素：remove/del

# 删除元素
# 移除指定的元素
list02.remove(2)
# 删除指定索引的元素
del list02[1]

5. 遍历元素：

– 正序

# 正着
for i in range(len(list02)):# 0  1  2
    print(list02[i])

• 跳跃

# 跳着
for i in range(0,len(list02),2):
    print(list02[i])

• 倒序

for i in range(len(list02) - 1,-1,-1):
    print(list02[i])

深拷贝和浅拷贝

• 浅拷贝：是在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
  
  
• 深拷贝：复制整个依懒的变量。
  
  

列表VS字符串

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

+ 将多个字符串拼接为一个。
result = "连接符".join(列表)

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

# 根据某些逻辑，拼接一个字符串．
# result01 = ""
# for item in range(10):
#     result01 += str(item)
# print(result01)

# 每次拼接，创建一个新对象，替换变量地址．
# 变量　=　"0" + "1"
# 变量 = 变量 + "2"

list_result = []
for item in range(10):
    # 没用每次拼接，都生成一个列表．
    list_result.append(str(item))
# join:将列表使用连接符，合成一个字符串
str_result = "+".join(list_result)
print(str_result)

# split:根据分割符拆分字符串
list01 = str_result.split("+")
print(list01)

列表的扩容

1. 原理
   • 创建新列表（更大的列表）
   • 拷贝原有元素
   • 替换列表地址
     
     

列表推导式

1. 定义：使用简易的方法，将可迭代对象转换为列表。
2. 语法：
   • 变量 = [表达式 for 变量 in 可迭代对象]
   • 变量 = [表达式 for 变量 in 可迭代对象 if 条件]
3. 说明：如果if真值表达式的布尔值为False，则可迭代对象生成的数据将被丢弃。

元组tuple

定义：由一系列变量组成的不可变序列容器。不可变是指一旦创建，不可以再添加/删除/修改元素

基础操作：

1. 创建空元组

t01 = ()
t02 = tuple()

2. 创建具有默认值的元组

t01 = (1,2,3)
t02 = tuple("abcd")
t03 = (1,2,[4,5])

运行结果:

3. 获取元素（索引、切片）同列表
4. 获取元组所有元素

for item in t01:
    print(item)

5. 倒叙获取元组所有元素

for i in range(len(t01)-1,-1,-1):
    print(t01[i])

列表与元组的内存图比较

作用

• 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素，但是会出现浪费的现象
• 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为通常占用空间更小
• 应用：
  • 变量交换的本质就是创建元组：x,y=y,x
  • 格式化字符串的本质就是创建元组："姓名:%s，年龄：%d" % ("tarena",15)

字典dict

定义：

• 有一系列键值对组成的可变映射容器。
• 映射：通过键获取值（字符串、列表、元组通过索引），每条记录无序
• 键必须唯一且不可变（字符串、数字、元组），值没有限制

基本操作

1. 创建空字典

d01 = {}
d02 = dict()

d01 = {"a":"A","b":"B"}
# d01 = dict("ab") # 分不清key  value
d01 = dict([(1,2),(3,4)]) # {1: 2, 3: 4}

2. 增加、修改

#　第一次增加
d01["c"] = "C"
#　第二次修改
d01["c"] = "CC"

3. 读取元素(如果不存在则异常)
   >建议：在字典中读取元素，先判断存在，在进行读取．

if "d" in d01:
    print(d01["d"])

print(d01)

4. 删除

del d01["c"]
print(d01)

5. 获取字典中所有元素：

for key in d01:
    print(key)
    print(d01[key])

6. 获取字典中所有记录(元组)

for item in d01.items():
    print(item[0]) # ｋｅｙ
    print(item[1]) # value

for k,v in d01.items():
    print(k) # ｋｅｙ
    print(v) # value

一个内存图的练习

集合set

定义

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

集合的内存图

基础操作

1. 创建空集合：set() set(可迭代对象)
2. 创建具有默认值集合：

s01 = set(1,2)
s02 = {1, 2, 3}  

运行结果：

3. 其他容器转换为集合

s01 = set("abcdace")
s02 = set([1,7,56,8,7,8])

运行结果：

注意：集合不能出现重复的键

3. 添加元素：add

s02.add("a")
s02.add("b")
s02.add("c")

4. 删除元素：discard
   

   如果使用remove，在这个键不存在的情况下会报错
   s02.discard("a")

5. 获取集合的所有元素

for item in s02:
    print(item)

运算(交集&, 并集|, 补集-, 对称补集^, 子集< 超集>)

运算图

1. & 生成两个集合的交集 返回共同元素

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

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

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

3. - 生成两个集合的补集 返回只属于其中之一的元素

s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 - s2  # {1}, 生成属于s1,但不属于s2的所有元素的集合

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

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

5. < 判断一个集合是另一个集合的子集

6. > 判断一个集合是另一个集合的超集

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

7. == != 集合相同或不同

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

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

固定集合

1. 定义:不可变的集合。
2. 作用:
   固定集合可以作为字典的键,还可以作为集合的值。
3. 基础操作
   创建固定集合：frozenset(可迭代对象)
4. 运算
   等同于set

python中被当成False的对象

在Python中，None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了 　__ nonzero __ ()　或　__ len __ () 方法且方法返回 0 或False，则其实例也被当作False，其他对象均为True。

下面是最简单的逻辑运算： 这里 1,2 都是Ture; 0，‘’都是False

    1  and  2    ==> 2                1  or  2    ==>  1
    1  and  0    ==> 0                1  or  0    ==>  1
    0  and  1    ==> 0                0  or  1    ==>  1
    0  and  ''   ==> 0                0  or  ''   ==>  ''

　　总结： 前提一个运算符的情况

• or 从左到右，返回第一个为真的值，都为假返回后一个值
• and 从左到右，若所有值均为真，则返回后一个值，有一个假的值，则返回第一个假的值