python 学习速查笔记（2）

Python 基本数据类型

与上一篇不同，从这篇开始我将详细的开始解释各个部分

  • 在Python 中的变量不需要声明。但是每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
  • 在 Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型。
  • 等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

1
2
3
4
5
6
7
#!/usr/bin/python3
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串
print (counter)
print (miles)
print (name)

若是执行以上程序会输出：

100
1000.0
runoob

多个变量赋值

在Python允许你同时为多个变量赋值。例如：

a = b = c = 1

这三个整型变量这时都被赋值为1，从后向前赋值，这三个变量都被赋予相同的值，当然，为多个对象指定多个变量也是可以的,例如：

a, b, c = 1, 2, “runoob”

以上a为1，b为2，c为runoob，注意赋值的时候会变更数据类型

标准数据类型

Python3 中常见的数据类型有：

  • Number（数字）
  • String（字符串）
  • bool（布尔类型）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

字典类型为python特有的数据类型，其中又有如下的分类

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

除此之外还有一些高级的数据类型，如字节数组类型(bytes)等等
接下来我将逐一分析学习

Number（数字）

在Python3中支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型即为 int，表示为长整型，没有Long和longlong。
内置的type()函数可以用来查询变量所指的对象类型。

1
2
3
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

你也可以使用isinstance 来判断所选数据类型是否正确,和type有点相似
1
2
3
4
>>> a = 111
>>> isinstance(a, int)
True
>>>

当你指定一个值时，Number 对象就会被创建：

var1 = 1
var2 = 10

也可以使用del语句删除一些对象引用,具体的使用方法为

1
del var1[,var2[,var3[....,varN]]]

如果要删除单个或多个对象。
1
2
del var
del var_a, var_b

isinstance() 和 type()关系分辨

type() 函数
这玩意返回对象的实际类型，属于精准判断类型

  • type() 不会考虑继承关系，它只返回对象的确切类型。
  • 如果对象是子类的实例，type() 只会返回子类类型，而不会认为它是父类类型。
    1
    2
    3
    4
    5
    6
    7
    8
    class Animal:
        pass
    class Dog(Animal):  # Dog 是 Animal 的子类
        pass
    dog = Dog()
    print(type(dog))  # 输出：<class '__main__.Dog'>
    print(type(dog) == Animal)  # 输出：False
    #这里 type(dog) 返回的是 Dog 类型，而不是 Animal 类型
    isinstance() 函数
    这玩意检查的对象式某个类或者子类的实例，是大类查找，范围广
  • isinstance() 会考虑继承关系，如果对象是子类的实例，它也会认为对象是父类的实例。
  • 可以同时检查多个类型（传入一个元组）。
    1
    2
    3
    4
    5
    6
    7
    8
    class Animal:
        pass
    class Dog(Animal):  # Dog 是 Animal 的子类
        pass
    dog = Dog()
    print(isinstance(dog, Dog))  # 输出：True
    print(isinstance(dog, Animal))  # 输出：True
    #这里 isinstance(dog, Animal) 返回 True，因为 Dog 是 Animal 的子类。
    打比方就是在车子中，type()找的是小米su7这一种车，但是isinstance()找的是汽车这一个种类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Animal:
        pass

    class Dog(Animal):
        pass

    dog = Dog()

    # 使用 type()
    print(type(dog) == Dog)    # True
    print(type(dog) == Animal) # False

    # 使用 isinstance()
    print(isinstance(dog, Dog))    # True
    print(isinstance(dog, Animal)) # True
    但是要注意一件事情：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False==0 会返回True，但可以通过is来判断类型。

    数值运算

    这玩意小学生都看得懂ok,我直接摆出来
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> 5 + 4  # 加法
    9
    >>> 4.3 - 2 # 减法
    2.3
    >>> 3 * 7  # 乘法
    21
    >>> 2 / 4  # 除法，得到一个浮点数
    0.5
    >>> 2 // 4 # 除法，得到一个整数
    0
    >>> 17 % 3 # 取余 
    2
    >>> 2 ** 5 # 乘方
    32
    注意事项：
  • Python可以同时为多个变量赋值，如a, b = 1, 2。
  • 一个变量可以通过赋值指向不同类型的对象。
  • 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  • 在混合计算时，Python会把整型转换成为浮点数。
    注意精度问题
    Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

    String（字符串）

    Python中的字符串用单引号'或双引号"括起来，同时使用反斜杠\转义特殊字符。
    字符串的截取的语法格式如下：

    变量[头下标:尾下标] 这个一般是单个字符访问

切片用于从字符串中提取子字符串，语法为：

1
字符串[start:end:step]

  • start：起始索引（包含）。
  • end：结束索引（不包含）。
  • step：步长（可选，默认为 1）。

切片规则

  • 如果省略 start，默认从字符串开头开始。
  • 如果省略 end，默认到字符串末尾。
  • 如果省略 step，默认为 1。
  • 步长可以为负数，表示从右向左切片。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    s = "Hello, World!"
    # 提取从索引 0 到 5 的子字符串（不包含索引 5）
    print(s[0:5])  # 输出：Hello
    # 省略 start，从开头到索引 5
    print(s[:5])  # 输出：Hello
    # 省略 end，从索引 7 到末尾
    print(s[7:])  # 输出：World!
    # 使用负索引
    print(s[-6:-1])  # 输出：World
    # 使用步长
    print(s[::2])  # 输出：Hlo ol!（每隔一个字符取一个）
    # 步长为负数，反转字符串
    print(s[::-1])  # 输出：!dlroW ,olleH

索引值以 0 为开始值，-1 为从末尾的开始位置。
在python中我们可以把字符串视为一个数组来理解，每个数字在自己的位置都有自己的编号，类似于门牌号一一对应，所以可以找到一个字符串的元素的具体位置

加号+是字符串的连接符， 星号*表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python3

str = 'Runoob'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

输出结果如下：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

这里可以看出来啦，字符串索引规则

  • 索引从 0 开始：字符串的第一个字符的索引是 0，第二个字符的索引是 1，依此类推。
  • 负索引：Python 支持负索引，从右向左计数，-1 表示最后一个字符，-2 表示倒数第二个字符，依此类推。
  • 索引范围：如果索引超出字符串的长度，会抛出 IndexError 异常。

Python 使用反斜杠\转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

1
2
3
4
5
6
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用"""..."""或者 '''...'''跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。 
1
2
3
4
5
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

注意啊，只是拿字符串和数组进行结构类似比较，没有实际关系，在python中字符串不能被改变，想你个索引的部分赋值会干报错的

注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。

果需要修改字符串，可以创建一个新的字符串

1
2
3
4
5
6
7
8
s = "Hello, World!"

# 尝试修改字符会报错
# s[0] = 'h'  # 报错：TypeError: 'str' object does not support item assignment

# 可以通过切片和拼接创建新字符串
new_s = 'h' + s[1:]
print(new_s)  # 输出：hello, World!

常用的字符串操作
使用len()函数获取字符串的长度。
1
2
s = "Hello, World!"
print(len(s))  # 输出：13

可以通过索引或直接遍历字符串中的字符。
1
2
3
4
5
6
7
8
9
s = "Hello"

# 通过索引遍历
for i in range(len(s)):
    print(s[i])

# 直接遍历字符
for char in s:
    print(char)

使用in关键字检查某个字符或子字符串是否存在于字符串中。
1
2
3
s = "Hello, World!"
print('o' in s)  # 输出：True
print('Python' in s)  # 输出：False

bool（布尔类型）

布尔类型即 True 或 False。
在 Python 中，True 和 False 都是关键字，表示布尔值。注意格式转换
布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。
布尔类型特点：

  • 布尔类型只有两个值：True 和 False。没多的了
  • bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。
  • 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
  • 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
  • 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
  • 可以使用 bool() 函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False：None、False、零 (0、0.0、0j)、空序列（如 ‘’、()、[]）和空映射（如 {}）。其他所有值转换为布尔值时均为 True。
    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
    # 布尔类型的值和类型
    a = True
    b = False
    print(type(a))  # <class 'bool'>
    print(type(b))  # <class 'bool'>
    # 布尔类型的整数表现
    print(int(True))   # 1
    print(int(False))  # 0
    # 使用 bool() 函数进行转换
    print(bool(0))         # False
    print(bool(42))        # True
    print(bool(''))        # False
    print(bool('Python'))  # True
    print(bool([]))        # False
    print(bool([1, 2, 3])) # True
    # 布尔逻辑运算
    print(True and False)  # False
    print(True or False)   # True
    print(not True)        # False
    # 布尔比较运算
    print(5 > 3)  # True
    print(2 == 2) # True
    print(7 < 4)  # False
    # 布尔值在控制流中的应用
    if True:
        print("This will always print")
    if not False:
        print("This will also always print")
    x = 10
    if x:
        print("x is non-zero and thus True in a boolean context")
    这里要注意数据类型的真假性，因为在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。

    List（列表）

    这玩意怕不是在python中用的最为频繁的数据类型之一
    列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。表中套表

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

变量[头下标:尾下标]

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

1
2
3
4
5
6
7
8
# 创建一个空列表
empty_list = []
# 创建一个包含整数的列表
numbers = [1, 2, 3, 4, 5]
# 创建一个包含不同类型元素的列表
mixed_list = [1, "Hello", 3.14, True]
# 创建一个嵌套列表（列表中的列表）
nested_list = [[1, 2], [3, 4], [5, 6]]

从排列逻辑上这个和字符串相当像，但是列表式可以修改的，如果你要修改，请见下
修改单个元素
1
2
3
fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"
print(fruits)  # 输出：['apple', 'blueberry', 'cherry']

修改多个元素（通过切片）
1
2
3
numbers = [0, 1, 2, 3, 4, 5]
numbers[1:4] = [10, 20, 30]
print(numbers)  # 输出：[0, 10, 20, 30, 4, 5]

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def reverseWords(input): 
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ") 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) 
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1] 
    # 重新组合字符串
    output = ' '.join(inputWords) 
    return output 
if __name__ == "__main__": 
    input = 'I like runoob'
    rw = reverseWords(input) 
    print(rw)

runoob like I

其他常用操作

添加元素

  • append()：在列表末尾添加一个元素。
  • extend()：在列表末尾添加多个元素（传入一个可迭代对象）。
  • insert()：在指定位置插入一个元素。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    fruits = ["apple", "banana"]
    # 添加单个元素
    fruits.append("cherry")
    print(fruits)  # 输出：['apple', 'banana', 'cherry']
    # 添加多个元素
    fruits.extend(["orange", "grape"])
    print(fruits)  # 输出：['apple', 'banana', 'cherry', 'orange', 'grape']
    # 在指定位置插入元素
    fruits.insert(1, "blueberry")
    print(fruits)  # 输出：['apple', 'blueberry', 'banana', 'cherry', 'orange', 'grape']
    有加就有减

    删除元素

    - remove()：删除第一个匹配的元素。
  • pop()：删除指定位置的元素（默认删除最后一个元素）。
  • del 语句：删除指定位置的元素或切片。
  • clear()：清空列表。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    fruits = ["apple", "banana", "cherry", "banana"]
    # 删除第一个匹配的元素
    fruits.remove("banana")
    print(fruits)  # 输出：['apple', 'cherry', 'banana']
    # 删除指定位置的元素
    fruits.pop(1)
    print(fruits)  # 输出：['apple', 'banana']
    # 删除最后一个元素
    fruits.pop()
    print(fruits)  # 输出：['apple']
    # 使用 del 语句删除元素
    del fruits[0]
    print(fruits)  # 输出：[]
    # 清空列表
    fruits.clear()
    print(fruits)  # 输出：[]

    查找元素

  • index()：返回第一个匹配元素的索引。
  • in 关键字：检查元素是否存在于列表中
    1
    2
    3
    4
    5
    6
    fruits = ["apple", "banana", "cherry"]
    # 查找元素的索引
    print(fruits.index("banana"))  # 输出：1
    # 检查元素是否存在
    print("cherry" in fruits)  # 输出：True
    print("orange" in fruits)  # 输出：False

    排序和反转

  • sort()：对列表进行排序（默认升序）。
  • reverse()：反转列表。
    1
    2
    3
    4
    5
    6
    7
    numbers = [3, 1, 4, 1, 5, 9, 2]
    # 排序
    numbers.sort()
    print(numbers)  # 输出：[1, 1, 2, 3, 4, 5, 9]
    # 反转
    numbers.reverse()
    print(numbers)  # 输出：[9, 5, 4, 3, 2, 1, 1]

    针对列表的常用函数

  • len()：返回列表的长度。
  • min()：返回列表中的最小值。
  • max()：返回列表中的最大值。
  • sum()：返回列表中所有元素的和（仅适用于数值列表）。
    1
    2
    3
    4
    5
    numbers = [1, 2, 3, 4, 5]
    print(len(numbers))  # 输出：5
    print(min(numbers))  # 输出：1
    print(max(numbers))  # 输出：5
    print(sum(numbers))  # 输出：15

    列表推导式

    这是一种非常简洁快速的列表创建方式
    1
    2
    3
    4
    5
    6
    # 创建一个包含 0 到 9 的平方的列表
    squares = [x**2 for x in range(10)]
    print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    # 创建一个包含偶数的列表
    evens = [x for x in range(10) if x % 2 == 0]
    print(evens)  # 输出：[0, 2, 4, 6, 8]

    列表的嵌套

    列表可以嵌套，但是在内存中的结构会显得比较复杂
    1
    2
    3
    4
    5
    6
    7
    matrix = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    # 访问嵌套列表中的元素
    print(matrix[1][2])  # 输出：6

    Tuple（元组）

    这玩意和列表及其接近，不同之处在于元组的元素不能修改。元组写在小括号()里，元素之间用逗号隔开。
    元组中的元素类型也可以不相同：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    #!/usr/bin/python3
    tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
    tinytuple = (123, 'runoob')
    print (tuple)             # 输出完整元组
    print (tuple[0])          # 输出元组的第一个元素
    print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
    print (tuple[2:])         # 输出从第三个元素开始的所有元素
    print (tinytuple * 2)     # 输出两次元组
    print (tuple + tinytuple) # 连接元组
    输出结果如下：

    (‘abcd’, 786, 2.23, ‘runoob’, 70.2)
    abcd
    (786, 2.23)
    (2.23, ‘runoob’, 70.2)
    (123, ‘runoob’, 123, ‘runoob’)
    (‘abcd’, 786, 2.23, ‘runoob’, 70.2, 123, ‘runoob’)


可以把字符串看作一种特殊的元组。

1
2
3
4
5
6
7
8
9
10
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

  • 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
  • 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
    例如：
    1
    2
    tup1 = ()    # 空元组
    tup2 = (20,) # 一个元素，需要在元素后添加逗号
    如果你想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。

如果不添加逗号，如下所示，它将被解释为一个普通的值而不是元组：

not_a_tuple = (42)

这样的话，not_a_tuple 将是整数类型而不是元组类型。
string、list 和 tuple 都属于 sequence（序列）。
注意：

1、与字符串一样，元组的元素不能修改。很像一个大号的字符串
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用 + 操作符进行拼接
基本和列表做好区分即可，性质基本上一致

Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。就像是正常的数学集合操作
在 Python 中，集合使用大括号{}表示，元素之间用逗号,分隔。
另外，也可以使用set()函数创建集合。
这里注意下：语法重叠
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1
2
3
parame = {value01,value02,...}
或者
set(value)

以下给出一个简单的实例
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
#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素

输出结果：

{‘Zhihu’, ‘Baidu’, ‘Taobao’, ‘Runoob’, ‘Google’, ‘Facebook’}
Runoob 在集合中
{‘b’, ‘c’, ‘a’, ‘r’, ‘d’}
{‘r’, ‘b’, ‘d’}
{‘b’, ‘c’, ‘a’, ‘z’, ‘m’, ‘r’, ‘l’, ‘d’}
{‘c’, ‘a’}
{‘z’, ‘b’, ‘m’, ‘r’, ‘l’, ‘d’}

Dictionary（字典）

这玩意是python中特有的数据类型，是内置数据类型，重要也非常有用
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键（key）来存取的，而不是通过偏移存取。
这个数据结构存储的是键值对，字典是无序的，可变的，且键必须是唯一的
字典用花括号 {} 表示，键值对之间用逗号 , 分隔大体构建实例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建一个空字典
empty_dict = {}

# 创建一个包含键值对的字典
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

# 使用 dict() 函数创建字典
another_dict = dict(name="Bob", age=30, city="San Francisco")

# 嵌套字典
nested_dict = {
    "person1": {"name": "Alice", "age": 25},
    "person2": {"name": "Bob", "age": 30}
}

访问字典元素

通过键访问值

1
2
3
4
5
6
7
8
person = {"name": "Alice", "age": 25, "city": "New York"}

# 访问键对应的值
print(person["name"])  # 输出：Alice
print(person["age"])   # 输出：25

# 如果键不存在，会抛出 KeyError
# print(person["gender"])  # 报错：KeyError: 'gender'

使用 get() 方法访问值
1
2
3
print(person.get("name"))        # 输出：Alice
print(person.get("gender"))      # 输出：None
print(person.get("gender", "N/A"))  # 输出：N/A（默认值）

这玩意可以避免键不存在时的错误，键不在返回返回None或指定的默认值

修改字典

添加或修改键值对

1
2
3
4
5
6
7
8
9
person = {"name": "Alice", "age": 25}

# 添加新键值对
person["city"] = "New York"
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

# 修改已有键的值
person["age"] = 26
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

合并字典
使用 update() 方法可以将一个字典的键值对合并到另一个字典中。
1
2
3
4
5
person = {"name": "Alice", "age": 25}
extra_info = {"city": "New York", "gender": "Female"}

person.update(extra_info)
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'Female'}

删除字典元素

  • del 语句：删除指定键的键值对。
  • pop() 方法：删除指定键的键值对，并返回对应的值。
  • popitem() 方法：删除并返回最后一个键值对（Python 3.7 及以上版本）。
  • clear() 方法：清空字典。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    person = {"name": "Alice", "age": 25, "city": "New York"}
    # 删除指定键值对
    del person["age"]
    print(person)  # 输出：{'name': 'Alice', 'city': 'New York'}
    # 删除并返回指定键的值
    city = person.pop("city")
    print(city)    # 输出：New York
    print(person)  # 输出：{'name': 'Alice'}
    # 删除并返回最后一个键值对
    last_item = person.popitem()
    print(last_item)  # 输出：('name', 'Alice')
    print(person)     # 输出：{}
    # 清空字典
    person.clear()
    print(person)  # 输出：{}

    常用操作

    获取所有键、值或键值对
  • keys()：返回字典中所有的键。
  • values()：返回字典中所有的值。
  • items()：返回字典中所有的键值对
    1
    2
    3
    4
    5
    6
    7
    person = {"name": "Alice", "age": 25, "city": "New York"}
    # 获取所有键
    print(person.keys())   # 输出：dict_keys(['name', 'age', 'city'])
    # 获取所有值
    print(person.values()) # 输出：dict_values(['Alice', 25, 'New York'])
    # 获取所有键值对
    print(person.items())  # 输出：dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])
    检查键是否存在，用in(重复了？)
    1
    2
    print("name" in person)  # 输出：True
    print("gender" in person)  # 输出：False
    使用 len() 函数获取字典中键值对的数量，字典长度
    1
    print(len(person))  # 输出：3

    bytes 类型

    在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。
    与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。
    bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。
    创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：
    此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码：

    x = bytes(“hello”, encoding=”utf-8”)

与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。例如：

1
2
3
x = b"hello"
y = x[1:3]  # 切片操作，得到 b"el"
z = x + b"world"  # 拼接操作，得到 b"helloworld"

需要注意的是，bytes 类型中的元素是整数值，因此在进行比较操作时需要使用相应的整数值。例如：
1
2
3
x = b"hello"
if x[0] == ord("h"):
    print("The first element is 'h'")

其中 ord() 函数用于将字符转换为相应的整数值。