容器

字符串

  • 回顾字符串的定义方式
  • 了解转义字符
  • 字符串相关的运算
  • 字符串相关函数
  • 字符串格式化的方法

详解字符串-转义字符

字符串的定义方式

  1. 单引号’’
  2. 双引号定义字符串””
  3. 三引号定义字符串’’’’’’或者””””””
  4. 字符串定义时，引号可以互相嵌套

转义字符

一个普通的字符出现在转义符\后面时候，实现了另一种意义

  • \ 转义符，续行符。
    • 作为转义符时，在\后面出现的字符可能会实现另外一种意义
    • 作为续行符时，在行尾使用了\后，可以继续换行书写内容
  • \n 代表换行
  • \r \r 代表光标的位置，从\r 出现的位置作为光标的起点
  • \t 水平制表符
  • \b 退格符
  • \ 就是打出一个单独的\
  • r 在字符串前＋ r 可以取消转义符的效果，原文字输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# \ 作为续行符
var = "123" \
      "456" \
      "789"
print(var)  # 123456789  打印结果仍旧是一行

# \ 作为转义符
var = "你要多耐心一点，美好的事物通常来的都慢一些"
print(var)  # 你要多耐心一点，美好的事物通常来的都慢一些

var = "你要多耐心一点，\n美好的事物通常来的都慢一些"
print(var)
# 你要多耐心一点，
# 美好的事物通常来的都慢一些


var = "你要多耐心一点，\r美好的事物通常来的都慢一些"
print(var)  # 美好的事物通常来的都慢一些

var = "你要多耐心一点，\t美好的事物通常来的都慢一些"
print(var)  # 你要多耐心一点，  美好的事物通常来的都慢一些

var = "你要多耐心一点，\b美好的事物通常来的都慢一些"
print(var)  # 你要多耐心一点美好的事物通常来的都慢一些

var = "abcde\\nabcde"
print(var)  # abcde\nabcde

var = r"abcde\nabcde"
print(var)  # abcde\nabcde

字符串相关操作

  • 字符串 +操作： 加法在字符串之间起到拼接作用
  • 字符串 *操作：乘法与字符串使用，会重复指定倍数的字符串
  • 字符串 []切片操作：只能使用[]下标的方式访问，但是不能修改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 加法在字符串之间起到拼接作用
vara = "你要稍微等一等,"
varb = "美好的事物都来得慢一些"
res = vara + varb
print(res)  # 你要稍微等一等,美好的事物都来得慢一些

# 乘法操作
var = "虎年大吉，" * 3
print(var)  # 虎年大吉，虎年大吉，虎年大吉，

# 切片操作
print(res[4:7])  # 等一等
print(res[8:10])  # 美好
print(res[::2])  # 你稍等等美的物来慢些
print(res[::-1])  # 些一慢得来都物事的好美,等一等微稍要你

字符串格式化

format() 格式化字符串 f 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 普通方式
name = "duanduan"
money = 10
sen = "今天{}花了{}块钱💰".format(name, money)
print(sen)  # 今天duanduan花了10块钱💰

# 通过索引的方法
sen = "今天{1}花了{2}块钱💰".format(None, name, money)
print(sen)

# 关键字传参
sen = "今天{who}花了{how}块钱💰".format(who=name, how=money)
print(sen)

# 容器类型数据传参
d = "duanduan:{},huanghuang:{},tutu:{}".format("小猪", "大猪", "小懒猪")
print(d)  # duanduan:小猪,huanghuang:大猪,tutu:小懒猪

d = "duanduan:{},huanghuang:{},tutu:{}".format(["小猪"], ["大猪"], ["小懒猪"])
print(d)  # duanduan:['小猪'],huanghuang:['大猪'],tutu:['小懒猪']

d = "duanduan:{0[0]},huanghuang:{0[1]},tutu:{0[2]}".format(["小猪", "大猪", "小懒猪"])
print(d)  # duanduan:小猪,huanghuang:大猪,tutu:小懒猪

data = {"who": "duanduan", "how": "10"}
sen = "今天{who}花了{how}块钱💰".format(**data)
print(sen)  # 今天duanduan花了10块钱💰

# 新增的格式化方法 f 方法
sen = f"今天{name}花了{money}块钱💰"
print(sen)  # 今天duanduan花了10块钱💰

sen = f'今天{data["who"]}花了{data["how"]}块钱💰'
print(sen)  # 今天duanduan花了10块钱💰

# 限定小数位数
pi = 3.1415926
var = f"圆周率是多少：{pi:.5f}"
print(var) # 圆周率是多少：3.14159

英文字符与字符检测相关函数

  • 大小写转换
    • str.capitalize() 返回原字符串的副本，首个字符大写，其余为小写
    • str.title() 返回原字符串的副本，每一个英文单词的首个字符大写，其余为小写
    • str.upper() 将字符串中的英文全部转化为大写
    • str.lower() 将字符串中的英文全部转化为小写
    • str.swapcase() 将字符串中的英文大小写互换
  • 字符检测
    • str.isupper() 检查字符串是否都是大写
    • str.islower() 检查字符串是否都是小写
    • str.istitle() 检查字符串是否符合 title
    • str.isalnum() 检测当前字符串是否由字符(中文、英文、数字)组成。
    • str.isalpha() 检测当前字符串是否由字符(中文、英文)组成，不包含数字。
    • str.isdigit() 检测当前字符串是否纯数字
    • str.isspace() 检测当前字符串是否纯空格
    • str.startswith() 检测当前字符串是否由指定字符开头，可以指定开始和结束的位置
    • str.endswith() 检测当前字符串是否由指定字符结尾，可以指定开始和结束的位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# 大小写转换
sen = "duanDuan is a liTTle pig"
print(sen.capitalize())  # Duanduan is a little pig
print(sen.title())  # Duanduan Is A Little Pig
print(sen.upper())  # DUANDUAN IS A LITTLE PIG
print(sen.lower())  # duanduan is a little pig
print(sen.swapcase())  # DUANdUAN IS A LIttLE PIG

# 字符检测
up = "DUANDUAN"
lo = "duanduan"
nu = "123"
mix = "word123"
print(sen.isupper())  # False
print(up.isupper())  # True

print(sen.islower())  # False
print(lo.islower())  # True

print(sen.istitle())  # False

print(sen.isalnum())  # False
print(up.isalnum())  # True
print(lo.isalnum())  # True
print(nu.isalnum())  # True
print(mix.isalnum())  # True

print(sen.isalpha())  # False
print(up.isalpha())  # True
print(lo.isalpha())  # True
print(nu.isalpha())  # False
print(mix.isalpha())  # False

print(sen.isdigit())  # False
print(up.isdigit())  # False
print(lo.isdigit())  # False
print(nu.isdigit())  # True
print(mix.isdigit())  # False

print(sen.isspace())  # False
print(" ".isspace())  # True

print(sen.startswith("d"))  # True
print(sen.startswith("D"))  # False
print(sen.startswith("n", 3))  # True
print(sen.startswith("n", 3, 8))  # True

print(sen.endswith("u"))  # False
print(sen.endswith("g"))  # True
print(sen.endswith("pig"))  # True
print(sen.endswith("pig", 3, 24))  # True

字符串查找相关函数

  • str.find(sub[,start[,end]]) 从左向右获取指定字符在字符串中的索引位置，未找到则返回-1
  • str.rfind(sub[,start[,end]]) 从右向左获取指定字符在字符串中的索引位置，未找到则返回-1
  • str.index() 和 find 方法一样，只不过如果没有找到则报错
  • str.rindex() 从右往左找，如果没有找到则报错
  • str.count() 计算一个字符串出现的次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
sen = "duanduanispig,littlepig"

print(sen.find("pig"))  # 10
print(sen.find("pig", 14, 23))  # 20

print(sen.rfind("pig"))  # 20
print(sen.rfind("pig", 0, 14))  # 10

print(sen.index("pig"))  # 10
try:
    print(sen.index("help"))  # ValueError: substring not found
except:
    print("ValueError: substring not found")

print(sen.rindex("pig"))  # 20
try:
    print(sen.rindex("help"))  # ValueError: substring not found
except:
    print("ValueError: substring not found")

print(sen.count("duan"))  # 2
print(sen.count("u"))  # 2
print(sen.count("i"))  # 4

字符串操作相关函数

  • str.split() 按照指定的字符进行分隔，把一个字符串分隔成一个列表，可以指定分隔的次数
  • str.rsplit() 按照指定的字符进行分隔，把一个字符串分隔成一个列表，同样可以指定分割的次数
  • str.join() 按照指定的字符 str，把容器类型中的数据连接成一个字符串
  • str.strip() 去除字符串左右两侧的指定字符
  • str.lstrip() 去除字符串左侧的指定字符
  • str.rstrip() 去除字符串右侧的指定字符
  • str.replace(new,old) 用 new 替换掉 str 中的 old,可以指定替换的次数
  • str.center() 给 str 的左右增加指定字符
  • str.ljust() 字符串按照指定位数向左对齐，右侧不够的补充指定字符
  • str.rjust() 同上，向右对齐
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
sen = "duanduanisalittlepig"
print(sen.split("i"))  # ['duanduan', 'sal', 'ttlep', 'g']

word = "duanduan_is_a_little_piggy"
print(word.split("_"))  # ['duanduan', 'is', 'a', 'little', 'piggy']
print(word.split("_", 2))  # ['duanduan', 'is', 'a_little_piggy']
print(word.rsplit("_"))  # ['duanduan', 'is', 'a', 'little', 'piggy']
print(word.rsplit("_", 2))  # ['duanduan_is_a', 'little', 'piggy']

li = ['user', 'duan', 'pet', 'tu']
print("_".join(li))  # user_duan_pet_tu

word = "      Hello piggy this is tutu     "
print(word.strip())  # Hello piggy this is tutu

old = "新年快乐"
new = old.replace("快乐", "大吉")
print(new)  # 新年大吉

word = "piggy"
print(word.center(10))  #   piggy
print(word.center(10, "*"))  # **piggy***

print(word.ljust(10, '*'))  # piggy*****
print(word.rjust(10, '*'))  # *****piggy

列表详解

列表就是一组有序的数据组合，列表中的数据可以被修改

列表定义与基本操作

列表的定义

  • 可以使用中括号定义 []
  • 可以使用 list 函数定义
  • 在定义列表中的元素时，需要在每个元素之间使用逗号，进行分割。
  • 列表中的元素可以是任意类型，通常存放同类型的

列表的基本操作

  • 使用+可以对两个列表进行拼接
  • 使用*实现列表元素的重复
  • 使用 in 判断列表中是否存在某元素
  • 列表的索引操作
    • 通过下标获取指定的元素
    • 通过下标修改元素
    • 不能通过下标添加元素
  • append()：可以用于向列表中追加元素
  • len()：获取列表的长度
  • 列表元素的删除
    • del 可以用于通过指定下标删除元素
    • pop()：可以使用 pop 方法出栈来删除最后一个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
varlist1 = [1, 2, 3, 4]
varlist2 = ['a', 'b', 'c', 'd']

res = varlist1 + varlist2
print(res)  # [1, 2, 3, 4, 'a', 'b', 'c', 'd']

res = varlist1 * 3
print(res)  # [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

res = 1 in varlist1
print(res)  # True

varlist1.append(5)
print(varlist1)  # [1, 2, 3, 4, 5]

print(varlist1)  # [1, 2, 3, 4, 5]
del varlist1[3]
print(varlist1)  # [1, 2, 3, 5]
res = varlist1.pop()
print(res)  # 5
print(varlist1)  # [1, 2, 3]

列表切片操作

列表[开始索引:结束索引:步进值]

  • 列表[开始索引:] 从开始索引到列表的最后
  • 列表[:结束索引] 从开始到结束索引的前一个
  • 列表[开始索引:结束索引] 从开始索引到结束索引的前一个
  • 列表[开始索引:结束索引:步进值] 带有步进值的从开始到结束前一个
  • 列表[:] 列表全部数据
  • 列表[::] 列表全部数据
  • 列表[::-1] 列表逆序输出

使用切片的方法进行列表的数据更新和删除

  • 从指定下标开始到指定下标结束前，替换为想要的对应的容器类型
  • 使用 del 进行切片删除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
varlist = ['Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden']

res = varlist[2:]
print(res)  # ['Curry', 'Tony', 'Irving', 'Thompson', 'Harden']

res = varlist[:2]
print(res)  # ['Kobe', 'James']

res = varlist[2:6]
print(res)  # ['Curry', 'Tony', 'Irving', 'Thompson']

res = varlist[2:6:2]
print(res)  # ['Curry', 'Irving']

varlist[3:6] = ['All star']
print(varlist)  # ['Kobe', 'James', 'Curry', 'All star', 'Harden']

列表的相关函数

  • len() ：使用 len 方法可以计算出列表的长度
  • count() ：count 方法可以检测具体某个元素出现了多少次
  • append() ：append 方法可以在列表尾部追加元素
  • insert(i,x) ：在 i 索引位置，插入 x
  • pop() ：默认出栈一个最末尾的元素,也可以指定索引进行出栈
  • remove() ：可以指定列表中的元素进行删除，如果元素不存在会报错
  • index() ：可以查找列表中元素第一次出现的索引
  • extend() ：可以将另一个列表扩展到原来的列表上，类似于+
  • clear() ：清空列表中的元素
  • reverse() ：逆序列表
  • sort() ：对列表排序，默认由小到大排序
    • 若 reverse=True，则按照由大到小排序
    • 若 key=func，则按照函数处理结果进行排序
  • copy() ：可以拷贝一个列表,但是如果执行修改操作，del 会对多维列表同时修改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
varlist = ['Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden']

print(len(varlist))  # 7

print(varlist.count('Curry'))  # 1

varlist.append('new star')
print(varlist)  # ['Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'new star']

varlist.insert(1, 'Pony')
print(varlist)  # ['Kobe', 'Pony', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'new star']

res = varlist.pop()
print(res)  # new star
print(varlist)  # ['Kobe', 'Pony', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden']

varlist.remove('Tony')
print(varlist)  # ['Kobe', 'Pony', 'James', 'Curry', 'Irving', 'Thompson', 'Harden']

print(varlist.index('Curry'))  # 3

temp = ['nobody', 'somebody']
varlist.extend(temp)
print(varlist)  # ['Kobe', 'Pony', 'James', 'Curry', 'Irving', 'Thompson', 'Harden', 'nobody', 'somebody']

varlist.clear()
print(varlist)  # []

varlist = ['Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden']
varlist.reverse()
print(varlist)  # ['Harden', 'Thompson', 'Irving', 'Tony', 'Curry', 'James', 'Kobe']

varlist.sort()
print(varlist)  # ['Curry', 'Harden', 'Irving', 'James', 'Kobe', 'Thompson', 'Tony']\
var = [6, 8, 3, 5, 9, 0, 2, 1, 4, 7]
var.sort()
print(var)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

var = [1, 2, 3, 4, 5]
var_val = var.copy()
print(id(var), id(var_val))  # 4494320416 4493079008
del var[4]
print(var)  # [1, 2, 3, 4]
print(var_val)  # [1, 2, 3, 4, 5]

var = [1, 2, 3, [4, 5]]
var_val = var.copy()
print(id(var), id(var_val))  # 4559934480 4558631712
del var[3][1]
print(var)  # [1, 2, 3, [4]]
print(var_val)  # [1, 2, 3, [4]]

深拷贝与浅拷贝

  • 浅拷贝
    • 使用的是 copy()方法
    • 对一维列表拷贝后，与原来的列表是不同的，单独做出修改不会影响另一列表
    • 但是如果是多维列表，使用浅拷贝之后，对多维部分进行修改，所有的都会改变
  • 深拷贝
    • 使用的是 copy 模块下的 deepcopy()
    • 深拷贝下的拷贝列表，是完全独立的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import copy

varlist = [1, 2, [3, 4, 5]]
newlist = varlist.copy()

print(varlist)  # [1, 2, [3, 4, 5]]
print(newlist)  # [1, 2, [3, 4, 5]]
print(id(varlist) == id(newlist))  # False
print(id(varlist[2]) == id(newlist[2]))  # True
del varlist[2][0]
print(varlist)  # [1, 2, [4, 5]]
print(newlist)  # [1, 2, [4, 5]]

varlist = [1, 2, [3, 4, 5]]
newlist = copy.deepcopy(varlist)
print(varlist)  # [1, 2, [3, 4, 5]]
print(newlist)  # [1, 2, [3, 4, 5]]
print(id(varlist) == id(newlist))  # False
print(id(varlist[2]) == id(newlist[2]))  # False
del varlist[2][0]
print(varlist)  # [1, 2, [4, 5]]
print(newlist)  # [1, 2, [3, 4, 5]]

列表推导式

列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或者可迭代对象的每个元素上，然后使用其结果来创建列表，或者通过满足某些特定条件元素来创造子序列

  • 常用方法
  • list = [想要的处理方式 for i in 容器类型数据 条件表达式]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
# 创建0-9的平方列表

# 普通方法
varlist = []
for i in range(10):
    varlist.append(i ** 2)

print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# lambda表达式+map
varlist = list(map(lambda x: x ** 2, range(10)))
print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 列表推导式
varlist = [i ** 2 for i in range(10)]
print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 2 实现一个字符串'1234' ===> [2，4，6，8]

# 普通方法
varstr = '1234'
varlist = []
for i in varstr:
    varlist.append(int(i) * 2)
print(varlist)  # [2, 4, 6, 8]

# lambda+map
varlist = list(map(lambda x: int(x) * 2, varstr))
print(varlist)  # [2, 4, 6, 8]

# 列表推导式
varlist = [int(i) * 2 for i in varstr]
print(varlist)  # [2, 4, 6, 8]

# 3 实现0-9的偶数列表 ===> [0,2,4,6,8]

# 普通方法
varlist = []
for i in range(10):
    if i % 2 == 0:
        varlist.append(i)
print(varlist)  # [0, 2, 4, 6, 8]

# lambda+fliter
varlist = list(filter(lambda x: True if x % 2 == 0 else False, range(10)))
print(varlist)  # [0, 2, 4, 6, 8]

# 列表推导式
varlist = [i for i in range(10) if i % 2 == 0]
print(varlist)  # [0, 2, 4, 6, 8]

# 4 实现多循环的列表推导式
# 实现 [1,2,3],[3,1,4]  ===> 列表中的元素两两组合，要求组合元素不能重复

# 普通方法
varlist = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            varlist.append((x, y))
print(varlist)  # [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

# 列表推导式
varlist = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(varlist)  # [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

# 5 实现矩阵的转换

# 普通方法
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]
newlist = []
for i in range(len(matrix[0])):
    newlist.append([res[i] for res in matrix])
print(newlist)

# 列表推导式
newlist = [[res[i] for res in matrix] for i in range(4)]
print(newlist)

练习题

使用列表推导式实现乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 把字典中的键值对转换成 a=b的列表形式
# {'user':'admin','age':'20','phone':'130'} ===> ['user=admin','age=20','phone=133']

vardict = {'user': 'admin', 'age': '20', 'phone': '130'}

varlist = [i + '=' + vardict[i] for i in vardict]
print(varlist)  # ['user=admin', 'age=20', 'phone=130']
res = '&'.join(varlist)
print(res)  # user=admin&age=20&phone=130

# 把列表中的所有字符全部转为小写
# ['AAAAA','BbbBB','CCCcc'] ===> ['aaaaa','bbbbb','ccccc']
varlist = ['AAAAA', 'BbbBB', 'CCCcc']
newlist = [i.lower() for i in varlist]
print(newlist)  # ['aaaaa', 'bbbbb', 'ccccc']

# x是0-5之间的偶数，y是0-5之间的奇数，把x，y组成一个元组放进一个列表中

newlist = [(x, y) for x in range(6) for y in range(6) if x % 2 == 0 if y % 2 != 0]
print(newlist)

# 使用列表推导式完成乘法表

newlist = [f'{i}×{j}={i * j}' for i in range(1, 10) for j in range(1, i + 1)]
print(newlist)

# 使用列表推导式完成M与N的计算 ===> [2,4,6,12,15,18,28,32,36]

M = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

N = [
    [2, 2, 2],
    [3, 3, 3],
    [4, 4, 4],
]

newlist = [M[p][q] * N[p][q] for p in range(3) for q in range(3)]
print(newlist)  # [2, 4, 6, 12, 15, 18, 28, 32, 36]

元组详解

基本定义和切片操作

元组和列表一样都是一组有序的数据组合 元组中的元素一旦定义了就不能修改，因此元组是不可变数据类型

元组定义

  • 定义空元祖，变量名=() 或者 变量名=tuple()
  • 还可以使用 变量名=(1，2，3)的方式定义有数据的元组
  • 如果只有一个数据，数据后需要加,，如 变量名=(1,)
  • 特例，使用 变量=1,2,3 这样的方式也可以定义元组

元组的相关操作

由于元组是不可变的数据类型，因此只能使用索引进行访问，不能进行其他操作 元组可以和列表一样使用切片操作

  • tuple.count() 统计一个元素出现的次数
  • tuple.index() 查找一个元素的索引值
  • tuple[] 与列表一样的方式进行切片
  • 使用 +、* 运算，合并组成新的元组
  • in 方法检测一个元素是否在元组中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
vartuple = 1, 2, 3
print(vartuple)  # (1, 2, 3)

vartuple = (1,)
print(vartuple)  # (1,)

vartuple = (1, 2, 3, 4, 5)
print(len(vartuple))

print(vartuple[:])  # (1, 2, 3, 4, 5)
print(vartuple[::])  # (1, 2, 3, 4, 5)
print(vartuple[1:3])  # (2, 3)
print(vartuple[::-1])  # (5, 4, 3, 2, 1)

vartuple = ('Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'Kobe')
print(vartuple.count('James'))  # 1
print(vartuple.index('Curry'))  # 2
print(vartuple.index('Kobe'))  # 0
print(vartuple.index('Kobe', 5, 8))  # 7

print(
    vartuple + vartuple)  # ('Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'Kobe', 'Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'Kobe')
print(
    vartuple * 2)  # ('Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'Kobe', 'Kobe', 'James', 'Curry', 'Tony', 'Irving', 'Thompson', 'Harden', 'Kobe')

res = 'Irving' in vartuple
print(res)  # True

元组推导式 generator

元组推导式 generator 也称为生成器，返回的是一个生成器 生成器是一个特殊的迭代器，生成器可以自定义，也可以使用元组推导式定义 生成器是按照某种算法去推算下一个数据或结果，只需要往内存中存储一个生成器，节约内存消耗，提升性能 语法： (1) 里面是推导式，外面是一个() 的结果就是一个生成器 (2) 自定义生成器，含有 yidle 关键字的函数就是生成器 含有 yield 关键字的函数，返回的结果就是一个迭代器(生成器函数就是一个返回迭代器的函数)

  • 如何使用生成器：生成器是迭代器的一种，所以可以使用操作迭代器的方法操作生成器
    • 使用 next()函数调用
    • 使用 list()函数或者 tuple()函数进行操作
    • 使用 for 语句进行遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
varlist = [1, 2, 3, 4, 5]
newtuple = (i ** 2 for i in varlist)
print(newtuple)  # <generator object <genexpr> at 0x101dd1f50>

# 1
print(next(newtuple))  # 1
print(next(newtuple))  # 4

# 2
newtuple = (i ** 2 for i in varlist)
print(list(newtuple))  # [1, 4, 9, 16, 25]

newtuple = (i ** 2 for i in varlist)
print(tuple(newtuple))  # (1, 4, 9, 16, 25)

# 3
newtuple = (i ** 2 for i in varlist)
for i in newtuple:
    print(i)  # 1 4 9 16 25

字典详解

定义和基本操作

字典也是一种数据的集合，由键值对组成的数据集合，字典中的键不能重复 字典中的键必须是不可变的数据类型，常用的键主要是：字符串，整型

字典的定义

  • 字典可以通过大括号括起来的 键:值对 进行创建
  • 也可以使用 dict 构造器来创建
  • 数据类型的转换：可以将其他的二级容器类型（列表、元组）转换为 dict
  • 可以使用 zip()函数，将两个 list 组合成一个 dict

字典的操作

  • 获取，通过索引键的方式可以获取到值
  • 修改，索引到的话可以修改值
  • 删除，使用 del 进行删除
  • 添加，使用一个新的键，进行赋值，若键存在，则会覆盖
  • 成员检测，可以使用 in 进行成员检测，但是只能检测键
  • 长度，可以用 len()，来检测有多少个键值对
  • dict.keys()：可以查询所有键
  • dict.values()：可以查询所有值
  • dict.items()：获取当前字典中所有的键值对
  • 字典的遍历：可以使用 for
  • 字典合并：new_dict = {**dict1, **dict2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
vardict = {'a': 1, 'b': 2, 'c': 3}
print(vardict, type(vardict))  # {'a': 1, 'b': 2, 'c': 3} <class 'dict'>

vardict = dict(a=1, b=2, c=3)
print(vardict)  # {'a': 1, 'b': 2, 'c': 3}

vardict = dict([['a', 1], ['b', 2], ['c', 3]])
print(vardict)  # {'a': 1, 'b': 2, 'c': 3}

var1 = ['a', 'b', 'c']
var2 = [1, 2, 3]
print(dict(zip(var1, var2)))  # {'a': 1, 'b': 2, 'c': 3}

res = vardict['a']
print(res)  # 1

vardict['a'] = 'A'
print(vardict)  # {'a': 'A', 'b': 2, 'c': 3}

del vardict['a']
print(vardict)  # {'b': 2, 'c': 3}

vardict['d'] = 4
print(vardict)  # {'b': 2, 'c': 3, 'd': 4}

res = 'd' in vardict
print(res)  # True
res = 'a' in vardict
print(res)  # False

res = len(vardict)
print(res)  # 3

res = vardict.keys()
print(res) #dict_keys(['b', 'c', 'd'])
res = vardict.values()
print(res) # dict_values([2, 3, 4])
res = vardict.items()
print(res) # dict_items([('b', 2), ('c', 3), ('d', 4)])

# 字典的遍历
for i in vardict:
    print(i,vardict[i])
    # b 2
    # c 3
    # d 4

for k,v in vardict.items():
    print(k,v)
    # b 2
    # c 3
    # d 4

相关函数

  • len(dict)，来检测有多少个键值对
  • dict.keys()：可以查询所有键
  • dict.values()：可以查询所有值
  • dict.items()：获取当前字典中所有的键值对
  • iter(dict)：返回以字典的键为元素的迭代器
  • pop(key)：通过键的方式弹出键值对
  • popitem()：按照 LIFO 的方式删除键值对
  • get()：通过 get 函数获得对应键的值，若键不存在返回 None
  • update()：更新字典，在原来的基础上更新
  • setdefault()：如果 字典的键存在 则返回对应值；如果键不存在，默认存入值为 None 的键值对，返回值为值，也可以指定传入的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
vardict = {'a': 1, 'b': 2, 'c': 3}

res = iter(vardict)
print(res)  # <dict_keyiterator object at 0x102977950>

for i in res:
    print(i)
    # a
    # b
    # c

vardict.pop('a')
print(vardict)  # # {'b': 2, 'c': 3}

vardict.popitem()
print(vardict)  # {'b': 2}

vardict = {'a': 1, 'b': 2, 'c': 3}
res = vardict.get('a')
print(res)  # 1
res = vardict.get('d')
print(res)  # None

vardict.update(a=11, b=22)
print(vardict)  # {'a': 11, 'b': 22, 'c': 3}

res = vardict.setdefault('d', 4)
print(res)  # 4
print(vardict)  # {'a': 11, 'b': 22, 'c': 3, 'd': 4}

字典推导式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
vardict = {'a': 1, 'b': 2, 'c': 3}

# 把字典中的键值对位置交换

# 普通方法
newdict = {}
for k, v in vardict.items():
    newdict[v] = k
print(newdict)  # {1: 'a', 2: 'b', 3: 'c'}

# 使用字典推导式
newdict = {v: k for k, v in vardict.items()}
print(newdict)  # {1: 'a', 2: 'b', 3: 'c'}


# 只保留值为偶数的键值对 并且键值互换
# 普通方法
vardict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
newdict = {}
for k,v in vardict.items():
    if v % 2 ==0:
        newdict[v] = k
print(newdict) # {2: 'b', 4: 'd'}

# 列表推导式方法
newdict = {v:k for k,v in vardict.items() if v % 2 == 0}
print(newdict) # {2: 'b', 4: 'd'}

集合详解

集合的基本操作和常规

确定的一组无序的数据的组合

  • 确定的：当前集合中元素的值不能重复
  • 由多个数据组合的复合型数据（容器类型数据）
  • 集合中的数据没有顺序
  • 功能：成员检测、从序列中去除重复项以及数学中的集合类计算，列如交集、并集、差集与对称差集等等

集合的定义

  • 可以直接使用{}来定义集合，定义空集合必须用 set()方法
  • 可以使用 set()进行集合的定义和转换
  • 使用集合推导式完成集合的定义 注意：集合中的元素不能重复，集合中存放的数据：Number、Strings、Tuple、冰冻集合

集合的基本操作和常规函数

  • 无序、False 和 0 只会出现一个、True 和 1 只会出现一个、元素值不会重复
  • 成员检测：使用 in 检测是都存在某个元素
  • 元素个数：len()检测集合元素个数
  • 集合遍历：使用 for 方法进行遍历
  • 追加元素：set.add()可以向集合中追加元素，（为什么不是 append，因为 append 有扩充的思想，从尾部插入，而 add 是没有顺序的）
  • 删除元素：
    • set.pop()可以删除集合中的元素，随机删除，并返回
    • set.remove()指定删除集合中的元素，无返回值,如果不存在则会报错
    • set.discard()指定删除集合中的元素，不存在也不会报错
  • 清空集合：set.clear()
  • 更新集合：set.update()
  • 集合的拷贝：set.copy()
  • 冰冻集合：frozenset()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
varset = {123, 'abc', True, (1, 2, 3), 0, False, 3.1415, 123}

print(varset)  # {0, True, 3.1415, 'abc', (1, 2, 3), 123}

res = 'abc' in varset
print(res)  # True

res = len(varset)
print(res)  # 6

for i in varset:
    print(i)
    # 0
    # True
    # 3.1415
    # (1, 2, 3)
    # abc
    # 123

varset.add('new')
print(varset)  # {0, True, 3.1415, 'new', (1, 2, 3), 'abc', 123}

# pop是随机的删除
r1 = varset.pop()
r2 = varset.pop()
r3 = varset.pop()
r4 = varset.pop()
print(r1, r2, r3, r4)  # 0 True 3.1415 new
print(varset)  # {(1, 2, 3), 'abc', 123}

varset = {123, 'abc', True, (1, 2, 3), 0, False, 3.1415, 123}
varset.remove('abc')
print(varset)  # {0, True, 3.1415, (1, 2, 3), 123}

varset.discard(123)
print(varset)  # {0, True, 3.1415, (1, 2, 3)}

varset.clear()
print(varset)  # set()

varset = {123, 'abc', True, (1, 2, 3), 0, False, 3.1415, 123}
varset.update({1, 2, 3, 4, 5})
print(varset)  # {0, True, 2, 3.1415, 3, 4, 5, (1, 2, 3), 123, 'abc'}

newset = varset.copy()
print(newset)  # {0, True, 2, 3.1415, 3, 4, 5, (1, 2, 3), 'abc', 123}

# 冰冻集合
v = frozenset({1, 2, 3})
print(v)  # frozenset({1, 2, 3})

冰冻集合

  • 定义冰冻集合 只能使用 frozenset()函数进行冰冻集合的定义
    • 冰冻集合一旦定义 就不能修改
    • 冰冻集合只能做集合相关的运算：求并交补差集
    • 本身就是一个强制类型转换的函数，可以把其他任何容器类型的数据转换为冰冻集合
  • 冰冻集合可以遍历：使用 for 进行遍历
  • 冰冻集合的推导式
1
2
3
4
5
6
7
8
9
10
11
12
13
vars = frozenset({1,2,3})
print(vars) # frozenset({1, 2, 3})

for i in vars:
    print(i)
    # 1
    # 2
    # 3


# 冰冻集合推导式
res = frozenset({i<<1 for i in range(6)})
print(res) # frozenset({0, 2, 4, 6, 8, 10})

集合推导式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 普通推导式
varset = {1, 2, 3, 4}

newset = {i << 1 for i in varset}
print(newset)  # {8, 2, 4, 6}

# 带有条件表达式的推导式
newset = {i << 1 for i in varset if i % 2 == 0}
print(newset)  # {8, 4}

# 多循环的集合推导式
# 普通方法
vars1 = {1, 2, 3}
vars2 = {4, 5, 6}
newset = set()
for i in vars1:
    for j in vars2:
        print(i, j)
        newset.add(i + j)
print(newset)  # {5, 6, 7, 8, 9}

# 列表推导式
newset = {i + j for i in vars1 for j in vars2}
print(newset)  # {5, 6, 7, 8, 9}

# 待条件表达式的多循环的集合推导式
newset = {i + j for i in vars1 for j in vars2 if (i + j) % 2 == 0}
print(newset)  # {8, 6}

集合运算

  • 集合的主要运算
    • 交集
      • &
      • set.intersection() 有返回值，不对原集合更新；还可以对可迭代对象进行合并
      • set.intersection_update() 无返回值，对原集合会更新
    • 并集
      • | 更推荐这种，对两种数据要求高 不能太灵活
      • set.union() 有返回值，不对原集合更新 ；还可以对可迭代对象进行合并
      • set.update() 无返回值，对调用的集合更新
    • 差集 (去掉集合中 另一集合有的部分)
      • set.difference() 有返回值，不对原集合更新
      • set.difference_update() 无返回值，对原集合更新
    • 对称差集 (去掉各自集合中 相同的部分)
      • ^
      • set.symmetric_difference() 有返回值，不对原集合更新
      • set.symmetric_difference_update() 无返回值，对原集合更新
  • 检测超集和子集
    • set1.issuperset(set2) 返回值为 True、False，意义为 set1 是否为 set2 的超集，也可以用 >=
    • set1.issubset(set2) 检测 set1 是否为 set2 的子集，也可以使用 <=
  • 检测是否不相交
    • set1.isdisjoint(set2) 有返回值，不相交返回 True、相交返回 False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
vars1 = {1, 2, 3, 4, 5, 6, 7}
vars2 = {4, 5, 6, 7, 8, 9, 10}

# 交集
print(vars1 & vars2)  # {4, 5, 6, 7}
res = vars1.intersection(vars2)
print(res)  # {4, 5, 6, 7}
print(vars1)  # {1, 2, 3, 4, 5, 6, 7}

res = vars1.intersection_update(vars2)
print(res)  # None
print(vars1)  # {4, 5, 6, 7}

# 并集
vars1 = {1, 2, 3, 4, 5, 6, 7}
vars2 = {4, 5, 6, 7, 8, 9, 10}
print(vars1 | vars2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
res = vars1.union(vars2)
print(res)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
vars1.update(vars2)
print(vars1)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

# 差集
vars1 = {1, 2, 3, 4, 5, 6, 7}
vars2 = {4, 5, 6, 7, 8, 9, 10}
print(vars1 - vars2)  # {1, 2, 3}
print(vars2 - vars1)  # {8, 9, 10}
res = vars1.difference(vars2)
print(res)  # {1, 2, 3}
vars1.difference_update(vars2)
print(vars1)  # {1, 2, 3}

# 对称差集
vars1 = {1, 2, 3, 4, 5, 6, 7}
vars2 = {4, 5, 6, 7, 8, 9, 10}
print(vars1 ^ vars2)  # {1, 2, 3, 8, 9, 10}
res = vars1.symmetric_difference(vars2)
print(res)  # {1, 2, 3, 8, 9, 10}
vars1.symmetric_difference_update(vars2)
print(vars1)  # {1, 2, 3, 8, 9, 10}

vars1 = {1,2,3}
vars2 = {1,2,3,4,5,6,7}
res = vars2.issuperset(vars1)
print(res) # True

res = vars1.issubset(vars2)
print(res) # True

res = vars1.isdisjoint(vars2)
print(res) # False

更新: 2024-01-10 22:17:18
原文: https://www.yuque.com/zacharyblock/cx2om6/an7fvuvt1unusq1w