算法乐园 主页 笔记 刷题

python笔记

pycharm常用快捷键

1print语句

print()默认结尾换行,如果不需要换行可以添加end=''

1
print("hello", end='')
2
print("world")

xxxxxxxxxx
1
1
helloworld

xxxxxxxxxx
2
1
print("hello\tworld")
2
print("hello\nworld")

xxxxxxxxxx
3
1
hello   world
2
hello
3
world

2.1字面量python六种数据类型

xxxxxxxxxx
3
1
print(999)
2
print(114.514)
3
print("hello world")

2.2注释

xxxxxxxxxx
7
1
"""
2
这个是多行注释
3
"""
4
# 这个是单行注释（#号和注释内容一般建议一个空格隔开）
5
'''
6
这个也是多行注释
7
'''

2.3变量

xxxxxxxxxx
3
1
money = 10
2
money = money - 5
3
print("余额为", money, "元")

xxxxxxxxxx
1
1
余额为 5 元

2.4数据类型

xxxxxxxxxx
4
1
string_type = type("hello world")
2
int_type = type(666)
3
float_type = type(114.514)
4
print(string_type, int_type, float_type)

xxxxxxxxxx
1
1
<class 'str'> <class 'int'> <class 'float'>

2.5数据类型转换

万物皆可转字符串,只有字符串是数字时才能将字符串转数字

xxxxxxxxxx
10
1
float_str = str(114.514)
2
print(type(float_str), float_str)
3
num = int("11")
4
print(type(num), num)
5
num2 = float("1919.810")
6
print(type(num2), num2)
7
fnum = float(11)
8
print(type(fnum), fnum)
9
inum = int(114.514)  # 不会四舍五入，直接取整
10
print(type(inum), inum)

xxxxxxxxxx
5
1
<class 'str'> 114.514
2
<class 'int'> 11
3
<class 'float'> 1919.81
4
<class 'float'> 11.0
5
<class 'int'> 114

2.6标识符

标识符命名只允许出现:

• 英文字母
• 中文(不推荐)
• 数字(不可以开头)
• 下划线_

2.7运算符

xxxxxxxxxx
4
1
print(1/3)
2
print(-17/4)
3
print(-17//4)
4
print(10//4)

xxxxxxxxxx
4
1
0.3333333333333333
2
-4.25
3
-5
4
2

整除取整方向默认为$-\mathrm{\infty }$$-\infin$

Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示。如下所示：

xxxxxxxxxx
6
1
a = 128
2
b = 1024
3
c = 512
4
d = a + \
5
    b - \
6
    c

如果包含在 []、{}、() 括号中，则不需要使用 \。如下所示：

xxxxxxxxxx
5
1
arr = {
2
    a,
3
    b,
4
    c
5
}

2.8字符串的三种定义方式

xxxxxxxxxx
10
1
# 单引号定义法
2
name1='hello'
3
# 双引号定义法
4
name2="hello"
5
#三引号定义法
6
name3="""
7
hello
8
world
9
"""
10
print(name3)

xxxxxxxxxx
3
1

2
hello
3
world

单引号定义法,可以内含双引号

双引号定义法,可以内含单引号

可以用转义字符\解除引号的效用

2.9字符串拼接

xxxxxxxxxx
4
1
s1 = "abcd"
2
s2 = "defg"
3
s3 = s1 + s2
4
print(s3)

xxxxxxxxxx
1
1
abcddefg

2.10字符串格式化

xxxxxxxxxx
6
1
num = 114514
2
s = "abcde"
3
message1 = "%s你好世界" % s
4
print(message1)
5
message1 = "%s你好世界%s" % (s, num)
6
print(message1)

xxxxxxxxxx
2
1
abcde你好世界
2
abcde你好世界114514

xxxxxxxxxx
5
1
s = "绩点"
2
gpa = 0.1
3
num = 666
4
message = "%s高达%f,老铁%d" % (s, gpa, num)
5
print(message)

xxxxxxxxxx
1
1
绩点高达0.100000,老铁666

字符转ASCII和ASCII转字符串

xxxxxxxxxx
2
1
print(ord("a"))
2
print(chr(97))

xxxxxxxxxx
2
1
97
2
a

字符串的大小写转化

xxxxxxxxxx
9
1
# title将首字母变成大写,其余小写
2
str = "wHat a beaUTIFul GIrl!!"
3
print(str.title())
4
# upper将所有字母变成大写
5
str = "Cpp Is The Best Programing Language"
6
print(str.upper())
7
# lower将所有字母变成小写
8
str = "I HATE PYTHOn"
9
print(str.lower())

xxxxxxxxxx
3
1
What A Beautiful Girl!!
2
CPP IS THE BEST PROGRAMING LANGUAGE
3
i hate python

2.11数字精度控制

2.12字符串格式化的一种快速写法

格式:f”内容{变量}”(不关心精度控制)

xxxxxxxxxx
5
1
s = "绩点"
2
gpa = 0.1
3
num = 666
4
message = f"{s}高达{gpa},大佬{num}"
5
print(message)

xxxxxxxxxx
1
1
绩点高达0.1,大佬666

2.15input语句

xxxxxxxxxx
2
1
name = input("你是谁？")
2
print("ohhhhhhh!您就是那位著名的%s" % name)

xxxxxxxxxx
2
1
你是谁？练习时长两年半的个人练习生
2
ohhhhhhh!您就是那位著名的练习时长两年半的个人练习生

input默认接受类型为string字符串

3条件语句

bool类型表示逻辑,True记作1,False记作0

python中的与或非: and or not

参考链接

xxxxxxxxxx
3
1
num1 = 11
2
num2 = 20
3
print(f"11>20结果是{11 > 20},类型为{type(11 > 20)}")

xxxxxxxxxx
1
1
11>20结果是False,类型为<class 'bool'>

xxxxxxxxxx
7
1
num = int(input())
2
if num < 10:
3
    print(f"{num}<10")
4
elif num <= 100:
5
    print(f"{num}<=100")
6
else:
7
    print(num)

xxxxxxxxxx
2
1
20
2
20<=100

xxxxxxxxxx
6
1
num = int(input())
2
if num <= 100:
3
    pass  # pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。
4
else:
5
    print(num)
6

4.1循环语句while

xxxxxxxxxx
6
1
x = 1
2
add = 0
3
while x <= 100:
4
    add += x
5
    x += 1
6
print(add)

xxxxxxxxxx
1
1
5050

4.2循环语句for

for 临时变量 in 序列类型:

字符串和range语句生成的都是序列类型

xxxxxxxxxx
7
1
s = "abcdef"
2
for ch in s:
3
    if ch == "a":
4
        continue
5
    if (ch == "e"):
6
        break
7
    print(ch)

xxxxxxxxxx
3
1
b
2
c
3
d

range(num)

获得一个从0开始,到num结束的数字序列

range(5)取得的数据是[0,1,2,3,4]

range(num1,num2)

获得从num1开始,到num2结束的数字序列(不含num2本身)

range(5,10)取得的数据是[5,6,7,8,9]

range(num1,num2,step)

获得从num1开始,到num2结束的数字序列(不含num2本身)

数字间的步长,以step为准(默认为1)

例如,range(5,10,2)取得的数据为[5,7,9]

xxxxxxxxxx
2
1
for x in range(5, 11, 2):
2
    print(x, end=' ')

xxxxxxxxxx
1
1
5 7 9

xxxxxxxxxx
3
1
for i in range(10, 0, -1):
2
    print(i, end=' ')
3
print()

xxxxxxxxxx
1
1
10 9 8 7 6 5 4 3 2 1 

reduce代替for循环

reduce函数在python2中是个内置函数，在python3中被移到functools模块中。

xxxxxxxxxx
6
1
from functools import reduce
2
def add(x,y):
3
    return x+y
4
ar=[1,2,3,4,5]
5
accumulate=reduce(add,ar)
6
print(accumulate)

xxxxxxxxxx
1
1
15

解释: 1+2+3+4+5=15

作用:它用于对一个可迭代对象进行累积操作，将一个二元函数应用于序列的前两个元素，然后将结果与下一个元素继续应用该函数，直到序列中的所有元素都被处理完毕。

5函数

xxxxxxxxxx
9
1
def strlen(s):
2
    a = 0
3
    for i in s:
4
        a += 1
5
    return a
6

7

8
s1 = "hello world"
9
print(strlen(s1))

xxxxxxxxxx
1
1
11

对于没有返回值的函数,返回值为None类型(也可以return None或return)

xxxxxxxxxx
5
1
def nofunc():
2
    print("nofunc")
3

4

5
print(nofunc(), type(nofunc()))

xxxxxxxxxx
3
1
nofunc
2
nofunc
3
None <class 'NoneType'>

在if判断中None等同于False

None也可用于声明无初始内容的变量

xxxxxxxxxx
4
1
a = None
2
print(a, type(a))
3
a = 1
4
print(a, type(a))

xxxxxxxxxx
2
1
None <class 'NoneType'>
2
1 <class 'int'>

函数说明文档:

xxxxxxxxxx
12
1
def add(x, y):
2
    """
3
    add函数可以接受2个参数，进行两数相加
4
    :param x:第一个数字
5
    :param y:第二个数字
6
    :return:两数之和
7
    """
8
    result = x + y
9
    return result
10

11

12
print("1+2=", add(1, 2))

注:函数内定义的变量在函数外是完全不可访问的

函数外定义的全局变量函数内可以访问

xxxxxxxxxx
15
1
num = 200
2

3

4
def test_a():
5
    print(f"test_a{num}")
6

7

8
def test_b():
9
    num = 500  # 局部变量
10
    print(f"test_b{num}")
11

12

13
test_a()
14
test_b()
15
print(num)

xxxxxxxxxx
3
1
test_a200
2
test_b500
3
200

xxxxxxxxxx
16
1
num = 200
2

3

4
def test_a():
5
    print(f"test_a{num}")
6

7

8
def test_b():
9
    global num
10
    num = 500  # 全局变量
11
    print(f"test_b{num}")
12

13

14
test_a()
15
test_b()
16
print(num)

xxxxxxxxxx
3
1
test_a200
2
test_b500
3
500

6.1 list数据容器-列表

定义列表

xxxxxxxxxx
11
1
name_list = ["abc", "def", "ghi"]
2
print(name_list)
3
print(type(name_list))
4
# 列表可以存储多种不同元素
5
my_list = ["abc", 666, True]
6
print(my_list)
7
print(type(my_list))
8
# 列表支持嵌套
9
two_dimension = [[1, 2, 3], [4, 5, 6]]
10
print(two_dimension)
11
print((type(two_dimension)))

xxxxxxxxxx
6
1
['abc', 'def', 'ghi']
2
<class 'list'>
3
['abc', 666, True]
4
<class 'list'>
5
[[1, 2, 3], [4, 5, 6]]
6
<class 'list'>

下标索引

.index方法(由元素找到第一次出现的下标)

列表.index(元素)

Return first index of value. Raises ValueError if the value is not present.(报错)

xxxxxxxxxx
3
1
mylist = ["abc", "def", "ghi"]
2
idx=mylist.index("abc")
3
print(f'"abc"的下标位置为{idx}')

xxxxxxxxxx
1
1
"abc"的下标位置为0

修改元素[]

xxxxxxxxxx
3
1
mylist = ["abc", "def", "ghi"]
2
mylist[1]="bcd"
3
print(mylist)

xxxxxxxxxx
1
1
['abc', 'bcd', 'ghi']

插入元素.insert()

xxxxxxxxxx
3
1
mylist = ["abc", "def", "ghi", "jkl", "mno"]
2
mylist.insert(2, "666")
3
print(f"在下标2处插入元素后，mylist变成{mylist}")

xxxxxxxxxx
1
1
在下标2处插入元素后，mylist变成['abc', 'def', '666', 'ghi', 'jkl', 'mno']

追加元素.append()

xxxxxxxxxx
3
1
mylist = ["abc", "def", "ghi", "jkl", "mno"]
2
mylist.append("pqr")
3
print(f"在尾插元素后，mylist变成{mylist}")

xxxxxxxxxx
1
1
在尾插元素后，mylist变成['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr']

追加其他容器.extend()

xxxxxxxxxx
3
1
mylist = ["abc", "def", "ghi", "jkl", "mno"]
2
mylist.extend(["pqr", "stu", "vwx"])
3
print(f"在追加列表后，mylist变成{mylist}")

xxxxxxxxxx
1
1
在追加列表后，mylist变成['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stu', 'vwx']

删除指定下标处元素

del 列表名[下标]或列表名.pop(下标)

xxxxxxxxxx
5
1
mylist = ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx"]
2
del mylist[2]
3
print(f"删除元素后，mylist变成{mylist}")
4
element = mylist.pop(2)
5
print(f"取出{element}后，列表变成{mylist}")

xxxxxxxxxx
2
1
删除元素后，mylist变成['abc', 'def', 'jkl', 'mno', 'pqr', 'stu', 'vwx']
2
取出jkl后，列表变成['abc', 'def', 'mno', 'pqr', 'stu', 'vwx']

找到并删除元素remove

xxxxxxxxxx
3
1
mylist = [1, 2, 3, 2, 3]
2
mylist.remove(2)
3
print(mylist)

xxxxxxxxxx
1
1
[1, 3, 2, 3]

只删除从左到右的第一个

清空列表.clear()

xxxxxxxxxx
3
1
mylist = [1, 2, 3, 2, 3]
2
mylist.clear()
3
print(mylist)

xxxxxxxxxx
1
1
[]

统计元素数量.count()

xxxxxxxxxx
2
1
my_list = [1, 1, 1, 2, 3]
2
print(my_list.count(1))

xxxxxxxxxx
1
1
3

列表长度

xxxxxxxxxx
2
1
my_list = [1, 1, 1, 2, 3]
2
print(len(my_list))

xxxxxxxxxx
1
1
5

列表长度上限为$2^{63}-1=9223372036854775807$$2^{63}-1=9223372036854775807$

遍历容器

xxxxxxxxxx
3
1
my_list = [1, 2, 3, 4, 5, 6, 7, 8]
2
for ele in my_list:
3
    print(ele, end=" ")

xxxxxxxxxx
1
1
1 2 3 4 5 6 7 8 

xxxxxxxxxx
3
1
list1 = ["这", "是", "一个", "测试"]
2
for index, item in enumerate(list1):
3
    print(index, item)

xxxxxxxxxx
4
1
0 这
2
1 是
3
2 一个
4
3 测试

可以设置下标从哪个数开始

xxxxxxxxxx
3
1
list1 = ["这", "是", "一个", "测试"]
2
for index, item in enumerate(list1, 1):
3
    print(index, item)

xxxxxxxxxx
4
1
1 这
2
2 是
3
3 一个
4
4 测试

拷贝容器.copy

l1=l2是深拷贝,修改l2,l1会跟着改变

l1-l2.copy()是浅拷贝,修改l2,l1不会跟着改变

6.7 tuple数据容器-元组

和list的区别是不可修改

定义:

(元素,元素,元素,......)

空元组:变量名称=()

变量名称=tuple()

xxxxxxxxxx
3
1
# 定义单个元素的元组
2
t = ("hello")
3
print(f"类型是{type(t)},内容是{t}")

xxxxxxxxxx
1
1
类型是<class 'str'>,内容是hello

xxxxxxxxxx
4
1
# 定义单个元素的元组需要加一个逗号,以便和数学公式区分
2
t = ("hello",)
3
print(f"类型是{type(t)},内容是{t}")
4
print(len(t))

xxxxxxxxxx
2
1
类型是<class 'tuple'>,内容是('hello',)
2
1

元组不可修改,但元组中的列表可以修改

xxxxxxxxxx
3
1
t = (1, 2, 3, 4, [1, 2, 3, 4], 5)
2
t[4][1] = -1
3
print(t)

xxxxxxxxxx
1
1
(1, 2, 3, 4, [1, -1, 3, 4], 5)

6.8string数据容器-字符串

字符串可以通过下标进行访问

• 从前往后,下标从0开始递增
• 从后往前,下标从-1开始递减

同元组一样,字符串是一个无法修改的数据容器

index方法

xxxxxxxxxx
2
1
s = "you are a handsome boy"
2
print(s.index("hand"))  # 返回hand第一次出现时h的下标

xxxxxxxxxx
1
1
10

.replace方法(替换)

语法:字符串.replace(字符串1,字符串2)

功能:将字符串内的全部: 字符串1,替换为字符串2

注意:不是修改字符串本身,而是得到了一个新字符串

xxxxxxxxxx
4
1
s = "cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do"
2
s1 = s.replace("cat", "tiger")
3
print(f"s={s}")
4
print(f"s1={s1}")

xxxxxxxxxx
2
1
s=cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do
2
s1=tigers and dogs are good tigers and dogs and tigers and dogs do things tigers and dogs like do

.split方法(分割)

语法:字符串.split(分隔符字符串)

功能:按照指定的分隔符字符串,将字符串划分成多个字符串,并存入列表对象中

注意:字符串本身不变,而是得到了一个列表对象

xxxxxxxxxx
4
1
s = "cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do"
2
l = s.split(" ")
3
print(f"s={s}")
4
print(f"s1={l},type(l)={type(l)}")

xxxxxxxxxx
2
1
s=cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do
2
s1=['cats', 'and', 'dogs', 'are', 'good', 'cats', 'and', 'dogs', 'and', 'cats', 'and', 'dogs', 'do', 'things', 'cats', 'and', 'dogs', 'like', 'do'],type(l)=<class 'list'>

.strip方法(规整字符串)

xxxxxxxxxx
2
1
s = "12abcde1"
2
print(s.strip("12"))

xxxxxxxxxx
1
1
abcde

.count方法统计字符串中某字符串出现的次数

xxxxxxxxxx
2
1
s = "114514514114514514114114"
2
print(s.count("114"))

xxxxxxxxxx
1
1
4

len统计字符串长度

xxxxxxxxxx
2
1
s = "114514514114514514114114"
2
print(len(s))

xxxxxxxxxx
1
1
24

汇总

Python 中常用处理字符串的相关函数

原文链接

string.capitalize() 把字符串的第一个字符大写 string.count(str, beg=0, end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. string.find(str, beg=0, end=len(string))检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 string.index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在 string中会报一个异常. string.isalnum()如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False string.isdecimal()如果 string 只包含十进制数字则返回 True 否则返回 False. string.isdigit()如果 string 只包含数字则返回 True 否则返回 False. string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False string.isnumeric()如果 string 中只包含数字字符，则返回 True，否则返回 False string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. string.istitle()如果 string 是标题化的(见 title())则返回 True，否则返回 False string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False string.join(seq)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 string.lower() 转换 string 中所有大写字符为小写. string.lstrip()截掉 string 左边的空格 max(str)返回字符串 str 中最大的字母。 min(str) 返回字符串 str 中最小的字母。 string.replace(str1, str2, num=string.count(str1))把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. string.split(str="", num=string.count(str))以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串 string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. string.strip([obj])在 string 上执行 lstrip()和 rstrip() string.swapcase()翻转 string 中的大小写 string.title()返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) string.translate(str, del="")根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 string.upper() 转换 string 中的小写字母为大写

6.10(取子序列)序列的切片

序列:内容连续,有序,可使用下标索引的一类数据容器

列表、元组、字符串均可以视为序列

注意:此操作不会影响序列本身,而是会得到一个新的序列

xxxxxxxxxx
5
1
mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2
result1 = mylist[1:4]
3
result2 = mylist[2:9:2]
4
print(result1)
5
print(result2)

xxxxxxxxxx
2
1
[1, 2, 3]
2
[2, 4, 6, 8]

xxxxxxxxxx
5
1
mytuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
2
r1 = mytuple[:]  # 都不写表示从头到尾
3
r2 = mytuple[::-1]
4
print(f"r1={r1}")
5
print(f"r2={r2}")

xxxxxxxxxx
2
1
r1=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
2
r2=(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

6.12set集合

xxxxxxxxxx
5
1
a = {1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 1, 1, 11}
2
b = {}  # 注意:这里的b是字典而不是集合 
3
c = set()
4
print(a, b, c)
5
print(type(b))

xxxxxxxxxx
2
1
{1, 2, 3, 4, 5, 6, 11} {} set()
2
<class 'dict'>

因为集合是无序的,所以不支持下标索引访问

但是集合和列表一样,是允许修改的

.add添加元素

xxxxxxxxxx
4
1
a = {11, 2, 3, 4, 5, 6, 7}
2
a.add(1)
3
a.add(5)
4
print(a)

xxxxxxxxxx
1
1
{1, 2, 3, 4, 5, 6, 7, 11}

.remove移除元素

xxxxxxxxxx
3
1
a = {11, 2, 3, 4, 5, 6, 7}
2
a.remove(3)
3
print(a)

xxxxxxxxxx
1
1
{2, 4, 5, 6, 7, 11}

.pop取出元素

xxxxxxxxxx
6
1
a = {11, 2, 3, 4, 5, 6, 7}
2
while len(a) > 0:
3
    print(a.pop())
4
a = {"ab", "idq", "sq", "kq", "yc", "mw"}
5
while len(a) > 0:
6
    print(a.pop())

xxxxxxxxxx
13
1
2
2
3
3
4
4
5
5
6
6
7
7
11
8
sq
9
yc
10
kq
11
mw
12
idq
13
ab

取出的过程对于字符串是随机的,即每次运行结果都不同

.difference集合差集

.difference_update集合的差集并更新左集合

.union集合合并

集合长度

xxxxxxxxxx
2
1
a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}
2
print(len(a))

xxxxxxxxxx
1
1
9

集合遍历

集合不支持下标索引,所以不能用while循环遍历集合

xxxxxxxxxx
3
1
set1 = {1, 2, 3, 4, 5}
2
for ele in set1:
3
    print(ele, end=" ")

xxxxxxxxxx
1
1
1 2 3 4 5 

总结

6.14 dict字典

xxxxxxxxxx
6
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100}
2
print(f"d1={d1} with type{type(d1)}")
3
d2 = {}
4
print(f"d2={d2} with type{type(d2)}")
5
d3 = dict()
6
print(f"d3={d3} with type{type(d3)}")

xxxxxxxxxx
3
1
d1={'a': 97, 'b': 98, 'c': 99, 'd': 100} with type<class 'dict'>
2
d2={} with type<class 'dict'>
3
d3={} with type<class 'dict'>

字典不允许键值重复

key和value可以是任意数据类型,但key不能为字典(必须可哈希)

[]访问元素

不可以使用下标索引,但可以根据key找到value

xxxxxxxxxx
2
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100}
2
print(d1["b"])

xxxxxxxxxx
1
1
98

[]新增元素,更新元素

dict不支持访问不存在的元素(以下是错误代码)

xxxxxxxxxx
2
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
print(f'd1["g"]={d1["g"]}')  # 代码编译错误

.pop删除元素

xxxxxxxxxx
3
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
d1.pop("d")
3
print(d1)

xxxxxxxxxx
1
1
{'a': 97, 'b': 98, 'c': 99, 'e': 101, 'f': 102}

.clear清空元素

xxxxxxxxxx
3
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
d1.clear()
3
print(d1)

xxxxxxxxxx
1
1
{}

.keys获取全部的key

xxxxxxxxxx
4
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
k = d1.keys()
3
print(k)
4
print(type(k))

xxxxxxxxxx
2
1
dict_keys(['a', 'b', 'c', 'd', 'e', 'f'])
2
<class 'dict_keys'>

遍历容器

方式1:通过key

xxxxxxxxxx
4
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
k = d1.keys()
3
for k1 in k:
4
    print(f"key={k1},value={d1[k1]}", end=" ")

xxxxxxxxxx
1
1
key=a,value=97 key=b,value=98 key=c,value=99 key=d,value=100 key=e,value=101 key=f,value=102 

方式2:直接for循环

xxxxxxxxxx
3
1
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
2
for k1 in d1:
3
    print(f"key={k1},value={d1[k1]}", end=" ")

xxxxxxxxxx
1
1
key=a,value=97 key=b,value=98 key=c,value=99 key=d,value=100 key=e,value=101 key=f,value=102