Python从入门到精通系列（初级阶段）——2.Python变量和数据类型

已于 2023-06-02 10:21:05 修改
阅读量546 收藏
点赞数
分类专栏： Python python从入门到精通系列 文章标签： python 开发语言
于 2023-03-01 14:24:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rantengfei1986/article/details/129276318
版权

变量

变量是计算机程序中用于存储和操作数据的一种基本工具。在Python中，变量是用来存储数据的容器，可以存储各种类型的数据，如数字、字符串、列表、元组、字典等。变量在程序中可以被多次使用和修改，使得程序更加灵活和易于维护。

在Python中，定义变量时不需要指定类型，可以直接将值赋给变量。例如：

a = 5
b = "Hello, world!"

这里的a和b就是变量名，5和"Hello, world!"则是变量的值。
在Python中，变量的命名规则比较灵活，可以包含字母、数字和下划线，但必须以字母或下划线开头。变量名不能与Python中的关键字重复，如if、while等。
在Python中，变量名是大小写敏感的，例如a和A是两个不同的变量名。

使用变量时，可以直接引用变量名，例如：

print(a)
print(b)

这将输出变量a和b的值。同时，变量也可以进行加减乘除等基本运算，例如：

c = a + 3
d = b * 2

这里的c和d就是根据a和b的值计算出来的新变量。

数据类型

在Python中，常见的数据类型包括：

整型(int)

整型（int）是Python中的一种基本数据类型，表示整数。Python支持对整型进行常见的算术运算和逻辑运算，包括：

  1. 算术运算和逻辑运算
加法运算：用“+”表示，例如 2 + 3 = 5。
减法运算：用“-”表示，例如 5 - 3 = 2。
乘法运算：用“*”表示，例如 2 * 3 = 6。
除法运算：用“/”表示，例如 6 / 3 = 2。
整除运算：用“//”表示，例如 7 // 3 = 2。
取余运算：用“%”表示，例如 7 % 3 = 1。
次方运算：用“**”表示，例如 2 ** 3 = 8。
  1. 位运算

按位与运算：用“&”表示，例如 0b110 & 0b011 = 0b010（即6 & 3 = 2）。
按位或运算：用“|”表示，例如 0b110 | 0b011 = 0b111（即6 | 3 = 7）。
按位异或运算：用“^”表示，例如 0b110 ^ 0b011 = 0b101（即6 ^ 3 = 5）。
按位取反运算：用“~”表示，例如 0b110 = 0b001（即6 = -7）。
左移运算：用“<<”表示，例如 0b110 << 1 = 0b1100（即6 << 1 = 12）。
右移运算：用“>>”表示，例如 0b110 >> 1 = 0b011（即6 >> 1 = 3）。
  1. 比较运算
<：小于
<=：小于等于
>：大于
>=：大于等于
==：等于
!=：不等于

这些比较运算符的结果都是布尔型，即True或False。例如：

>>> 3 < 5
True
>>> 3 >= 5
False
>>> 4 == 4
True
>>> 4 != 4
False
  1. 内置函数和方法
abs()：返回整数的绝对值。
divmod(a, b)：返回元组 (a // b, a % b)，即商和余数。
pow(x, y[, z])：返回 x 的 y 次幂，如果给定 z，则结果对 z 取模，等价于 (x**y) % z。
round(x[, n])：返回四舍五入的浮点数，如果给定 n，则保留小数点后 n 位，n 默认为 0。
bin(x)：将整数 x 转换为二进制字符串。
oct(x)：将整数 x 转换为八进制字符串。
hex(x)：将整数 x 转换为十六进制字符串。

以下是一些示例代码：

# abs() 函数示例
x = -10
print(abs(x)) # 输出：10

# divmod() 函数示例
a, b = 7, 3
q, r = divmod(a, b)
print(q, r) # 输出：2 1

# pow() 函数示例
x, y, z = 2, 3, 5
print(pow(x, y, z)) # 输出：3

# round() 函数示例
x = 3.1415926
print(round(x)) # 输出：3
print(round(x, 2)) # 输出：3.14

# bin() 函数示例
x = 10
print(bin(x)) # 输出：0b1010

# oct() 函数示例
x = 10
print(oct(x)) # 输出：0o12

# hex() 函数示例
x = 255
print(hex(x)) # 输出：0xff
浮点数(float)

浮点数是Python中的一种基本数据类型，它表示带有小数部分的数字。常用的浮点数操作包括：

  1. 加法、减法、乘法、除法
a = 2.5
b = 1.5
c = a + b  # 加法
d = a - b  # 减法
e = a * b  # 乘法
f = a / b  # 除法
  1. 幂运算
a = 2.0
b = 3
c = a ** b  # 幂运算，结果为8.0
  1. 取整操作
a = 2.5
b = -2.5
c = round(a)  # 四舍五入，结果为3
d = round(b)  # 四舍五入，结果为-2
e = int(a)  # 取整，结果为2
f = int(b)  # 取整，结果为-2
  1. 比较运算
a = 2.5
b = 1.5
c = 2.5
d = a > b  # 大于，结果为True
e = a < b  # 小于，结果为False
f = a == c  # 等于，结果为True
g = a != b  # 不等于，结果为True
  1. 浮点数转换为字符串
a = 2.5
b = str(a)  # 转换为字符串，结果为'2.5'
  1. 浮点数的格式化输出
a = 2.5
b = 3.14159
print('a = {:.2f}'.format(a))  # 输出保留两位小数的浮点数，结果为'a = 2.50'
print('b = {:.2e}'.format(b))  # 输出科学计数法形式的浮点数，结果为'b = 3.14e+00'

除了上述常用的操作外，还有许多其他的操作和方法可以用于浮点数，比如取绝对值、判断是否为无穷大或NaN等。

布尔类型 (bool)

布尔类型只有两个取值，即 True 和 False，常用的操作如下：

  1. 逻辑运算符：and、or 和 not
a = True
b = False
print(a and b)  # False
print(a or b)  # True
print(not a)   # False
  1. 比较运算符：==、!=、>、>=、< 和 <=
a = 10
b = 20
print(a == b)  # False
print(a != b)  # True
print(a > b)   # False
print(a >= b)  # False
print(a < b)   # True
print(a <= b)  # True
  1. 布尔值可以进行算术运算，True 被当作 1，False 被当作 0
a = True
b = False
print(a + b)  # 1
print(a * 3)  # 3
  1. 可以将其他类型转换为布尔值
print(bool(0))  # False
print(bool(1))  # True
print(bool(2))  # True
print(bool('hello'))  # True
print(bool(''))  # False
print(bool(None))  # False

需要注意的是，在 Python 中，其他数据类型的值也可以被当作布尔值使用，比如 0、空字符串和空列表等被当作 False，其他值被当作 True。

字符串(str)

字符串是Python中的一种数据类型，它用于表示文本数据。下面是字符串常用的操作：

  1. 定义字符串：可以用单引号或双引号定义一个字符串，如：
str1 = 'Hello, World!'
str2 = "Hello, World!"
  1. 字符串连接
  • 使用 + 运算符字符串连接
str1 = 'Hello,'
str2 = ' World!'
str3 = str1 + str2  # 结果为 'Hello, World!'
  • 使用字符串方法 join()
    该方法接收一个可迭代对象作为参数，将其中的字符串连接起来，连接符为调用该方法的字符串
words = ['hello', 'world', 'python']
joined_str = '-'.join(words)
print(joined_str)  # 输出: "hello-world-python"
  • 使用f-string
first_name = "John"
last_name = "Doe"
full_name = f"{first_name} {last_name}"
print(full_name)  # 输出: "John Doe"
  • 使用str.format()方法
age = 25
name = "Lucy"
message = "My name is {}, and I am {} years old".format(name, age)
print(message)  # 输出: "My name is Lucy, and I am 25 years old"
  1. 字符串重复：使用 * 运算符可以将一个字符串重复多次，如：
str1 = 'Hello,'
str2 = str1 * 3  # 结果为 'Hello,Hello,Hello,'
  1. 访问字符串中的字符：可以使用索引操作访问字符串中的单个字符，如：
str1 = 'Hello, World!'
char1 = str1[0]  # 结果为 'H'
  1. 切片操作：使用切片操作可以获取字符串的一个子串，如：
str1 = 'Hello, World!'
sub_str1 = str1[0:5]  # 结果为 'Hello'
sub_str2 = str1[7:]  # 结果为 'World!'
  1. 字符串长度：使用内置函数 len() 可以获取字符串的长度，如：
str1 = 'Hello, World!'
length = len(str1)  # 结果为 13
  1. 字符串查找：使用 in 关键字可以查找一个字符串是否包含另一个字符串，如：
str1 = 'Hello, World!'
if 'Hello' in str1:
    print('包含 Hello')
else:
    print('不包含 Hello')
  1. 字符串替换：使用 replace() 方法可以替换字符串中的指定子串，如：
str1 = 'Hello, World!'
new_str = str1.replace('World', 'Python')  # 结果为 'Hello, Python!'
  1. 字符串分割：使用 split() 方法可以将一个字符串按照指定的分隔符分割成多个子串，如：
str1 = 'Hello, World!'
words = str1.split(',')  # 结果为 ['Hello', ' World!']
  1. 字符串格式化：使用 % 或 format() 方法可以将一个字符串中的占位符替换为指定的值，如：
name = 'Tom'
age = 20
str1 = 'My name is %s, and I am %d years old.' % (name, age)  # 结果为 'My name is Tom, and I am 20 years old.'
str2 = 'My name is {}, and I am {} years old.'.format(name, age)  # 结果同上
列表(list)

列表是Python中常用的数据类型之一，其表示一个可变长度的有序集合，其中的元素可以是不同的数据类型。以下是列表常用的操作：

  1. 创建列表：用中括号 [ ] 表示一个列表，可以在其中添加元素，例如：
my_list = []  # 创建一个空列表
my_list = [1, 2, 3]  # 创建一个包含三个元素的列表
my_list = ['apple', 'banana', 'cherry']  # 创建一个包含字符串元素的列表
  1. 访问列表元素：列表中的元素可以通过下标进行访问，下标从0开始，例如：
my_list = ['apple', 'banana', 'cherry']
print(my_list[0])  # 输出：'apple'
print(my_list[1])  # 输出：'banana'
print(my_list[2])  # 输出：'cherry'
  1. 修改列表元素：可以通过下标对列表中的元素进行修改，例如：
my_list = ['apple', 'banana', 'cherry']
my_list[1] = 'orange'  # 修改第2个元素
print(my_list)  # 输出：['apple', 'orange', 'cherry']
  1. 添加元素：可以使用 append() 方法在列表末尾添加元素，例如：
my_list = ['apple', 'banana', 'cherry']
my_list.append('orange')
print(my_list)  # 输出：['apple', 'banana', 'cherry', 'orange']
  1. 插入元素：可以使用 insert() 方法在列表指定位置插入元素，例如：
my_list = ['apple', 'banana', 'cherry']
my_list.insert(1, 'orange')
print(my_list)  # 输出：['apple', 'orange', 'banana', 'cherry']
  1. 删除元素：可以使用 del 关键字、remove() 方法或 pop() 方法删除列表中的元素，例如：
my_list = ['apple', 'banana', 'cherry']
del my_list[1]  # 删除第2个元素
print(my_list)  # 输出：['apple', 'cherry']

my_list = ['apple', 'banana', 'cherry']
my_list.remove('banana')  # 删除指定元素
print(my_list)  # 输出：['apple', 'cherry']

my_list = ['apple', 'banana', 'cherry']
my_list.pop(1)  # 删除并返回第2个元素
print(my_list)  # 输出：['apple', 'cherry']
  1. 切片操作：可以使用切片操作获取列表的子列表，例如：
my_list = ['apple', 'banana', 'cherry', 'orange', 'grape']
sub_list = my_list[1:4]  # 获取第2个到第4个元素（不包含第5个元素）
print(sub_list)  # 输出：['banana', 'cherry', 'orange']
  1. 列表长度：可以使用 len() 函数获取列表的长度，例如：
my_list = ['apple', 'banana', 'cherry']
print(len(my_list))  # 输出：3
  1. 列表排序：
  • list.sort() 方法：在原列表上进行排序，无返回值。
  • sorted(list) 函数：返回一个新的排序后的列表，不会修改原列表。

这两种方法都支持指定排序的方式和顺序，可以传入一个 key 参数和一个 reverse 参数，分别用于指定排序的键和排序的顺序。

# 定义一个列表
fruits = ['apple', 'orange', 'banana', 'pear']

# 使用 list.sort() 方法对列表进行排序
fruits.sort()
print(fruits)  # ['apple', 'banana', 'orange', 'pear']

# 使用 sorted() 函数对列表进行排序
fruits_sorted = sorted(fruits)
print(fruits_sorted)  # ['apple', 'banana', 'orange', 'pear']

# 使用 key 参数指定排序的键
fruits.sort(key=len)
print(fruits)  # ['pear', 'apple', 'orange', 'banana']

# 使用 reverse 参数指定排序的顺序
fruits.sort(reverse=True)
print(fruits)  # ['pear', 'orange', 'banana', 'apple']

需要注意的是，这些排序方法和函数只能对列表中的元素进行排序，如果列表中包含不同类型的元素，会报错。另外，这些排序方法和函数是按照字典序进行排序的，如果需要对数字列表进行排序，需要指定排序方式。

除了上述常用的操作，列表还支持以下一些操作：

  • list.append(x)：将元素 x 添加到列表的末尾。

  • list.extend(iterable)：将可迭代对象 iterable 的所有元素添加到列表的末尾，相当于执行多次 list.append()。

  • list.insert(i, x)：将元素 x 插入到列表的索引 i 处，其他元素后移。

  • list.remove(x)：从列表中移除第一个值为 x 的元素。如果没有找到则抛出 ValueError 异常。

  • list.pop([i])：移除并返回列表中索引为 i 的元素，如果不指定 i 则默认移除并返回列表的最后一个元素。如果列表为空，则抛出 IndexError 异常。

  • list.index(x[, start[, end]])：返回第一个值为 x 的元素的索引，如果没有找到则抛出 ValueError 异常。可选参数 start 和 end 分别指定开始和结束搜索的位置。

  • list.count(x)：返回列表中值为 x 的元素的数量。

  • list.sort(key=None, reverse=False)：对列表进行排序，默认是升序排列。可选参数 key 指定一个排序函数，用于从每个列表元素中提取比较键，reverse 为 True 时则表示降序排列。

  • list.reverse()：将列表中的元素顺序反转。

  • list.copy() 或 list[:]：返回列表的一个浅拷贝。

示例代码：

# 常用操作
list1 = [1, 2, 3]
list1.append(4)         # [1, 2, 3, 4]
list1.extend([5, 6])    # [1, 2, 3, 4, 5, 6]
list1.insert(2, 0)      # [1, 2, 0, 3, 4, 5, 6]
list1.remove(0)         # [1, 2, 3, 4, 5, 6]
list1.pop()             # [1, 2, 3, 4, 5]
list1.index(3)          # 2
list1.count(3)          # 1
list1.sort()            # [1, 2, 3, 4, 5]
list1.reverse()         # [5, 4, 3, 2, 1]
list2 = list1.copy()    # [5, 4, 3, 2, 1]
list3 = list1[:]        # [5, 4, 3, 2, 1]
元组(tuple)

元组（tuple）和列表类似，也是Python中的一种容器类型，可以用来存储任意类型的数据。但与列表不同的是，元组是不可变的（immutable），一旦创建就不能进行修改，也就是说，不能增加、删除或修改元组中的元素。因此，元组可以看做是只读列表。

元组的常用操作包括：

  1. 创建元组
    元组可以使用小括号 () 来创建，也可以省略小括号。例如：
t1 = (1, 2, 3)
t2 = 4, 5, 6
t3 = ()
t4 = 7,
  1. 访问元组元素
    元组的元素可以通过索引来访问，与列表类似。例如：
t = (1, 2, 3)
print(t[0])  # 输出 1
  1. 元组切片
    元组也支持切片操作，语法与列表类似。例如：
t = (1, 2, 3, 4, 5)
print(t[1:3])  # 输出 (2, 3)
  1. 元组合并
    元组可以通过加号（+）运算符进行合并，生成一个新的元组。例如：
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = t1 + t2
print(t3)  # 输出 (1, 2, 3, 4, 5, 6)
  1. 元组重复
    可以使用乘号（*）运算符将元组重复指定的次数。例如：
t = (1, 2, 3)
print(t * 2)  # 输出 (1, 2, 3, 1, 2, 3)
  1. 元组长度
    可以使用 len() 函数获取元组的长度。例如：
t = (1, 2, 3)
print(len(t))  # 输出 3
  1. 元组转列表
    可以使用 list() 函数将元组转换为列表。例如：
t = (1, 2, 3)
lst = list(t)
print(lst)  # 输出 [1, 2, 3]
  1. 元组解包
    元组可以使用解包（unpacking）的方式，将元组中的元素赋值给多个变量。例如：
t = (1, 2, 3)
a, b, c = t
print(a, b, c)  # 输出 1 2 3

需要注意的是，变量的数量必须与元组的元素数量相同，否则会报错。

集合(set)

集合（set）是Python中的一种基本数据类型，它是由一组无序、不重复元素组成的数据结构，可以进行集合运算，如交集、并集、差集等。下面是集合的常用操作：

  1. 创建集合
    可以通过花括号 {} 或 set() 函数来创建一个集合。
# 创建一个空集合
s = set()

# 创建一个含有多个元素的集合
s = {1, 2, 3}
s = set([1, 2, 3])
  1. 集合的基本操作
    集合支持添加元素、删除元素、清空集合等基本操作。
# 添加元素
s.add(4)

# 删除元素
s.remove(3)

# 清空集合
s.clear()
  1. 集合运算
    集合支持交集、并集、差集、对称差集等集合运算。
a = {1, 2, 3}
b = {2, 3, 4}

# 交集
c = a & b
# 或者
c = a.intersection(b)

# 并集
c = a | b
# 或者
c = a.union(b)

# 差集
c = a - b
# 或者
c = a.difference(b)

# 对称差集
c = a ^ b
# 或者
c = a.symmetric_difference(b)
  1. 判断元素是否在集合中
a = {1, 2, 3}
print(2 in a)  # True
print(4 in a)  # False
  1. 集合的长度
a = {1, 2, 3}
print(len(a))  # 3
  1. 集合的复制
a = {1, 2, 3}
b = a.copy()
  1. 遍历集合
    可以使用 for 循环遍历集合中的元素。
a = {1, 2, 3}
for x in a:
    print(x)
字典(dict)

字典是 Python 中的一种映射类型，它可以存储键值对，其中每个键都对应一个唯一的值。字典的常用操作包括：

  1. 创建字典
  • 直接使用大括号 {} 创建字典：
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
  • 使用 dict() 函数创建字典：
my_dict = dict(apple=1, banana=2, orange=3)
  • 通过列表推导式创建字典：
keys = ['apple', 'banana', 'orange']
values = [1, 2, 3]
my_dict = {k: v for k, v in zip(keys, values)}

以上代码中，my_dict 是创建的字典对象，keys 表示键名列表，values 表示键对应的值。其中，第一种方法是最常用的创建字典的方式。

  1. 获取字典中的值

获取字典中的值可以使用键来进行索引，也可以使用 get() 方法。

  • 使用键进行索引的示例：
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

print(my_dict["name"])  # 输出：Alice
print(my_dict["age"])  # 输出：25
print(my_dict["city"])  # 输出：New York
  • 使用 get() 方法的示例：
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

print(my_dict.get("name"))  # 输出：Alice
print(my_dict.get("age"))  # 输出：25
print(my_dict.get("city"))  # 输出：New York

# 如果键不存在，使用 get() 方法不会报错，而是返回 None
print(my_dict.get("job"))  # 输出：None
  • 可以通过在 get() 方法中指定一个默认值，来避免返回 None 的情况：
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

print(my_dict.get("job", "unemployed"))  # 输出：unemployed
  1. 添加或更新键值对

可以使用以下两种方式添加或更新字典中的键值对：

  • 使用键来访问或设置值：
# 创建一个空字典
my_dict = {}

# 添加或更新键值对
my_dict['key1'] = 'value1'
my_dict['key2'] = 'value2'

# 打印字典
print(my_dict)

# 更新键值对
my_dict['key1'] = 'new_value1'

# 打印字典
print(my_dict)

输出：

{'key1': 'value1', 'key2': 'value2'}
{'key1': 'new_value1', 'key2': 'value2'}
  • 使用update()方法：
# 创建一个空字典
my_dict = {}

# 添加或更新键值对
my_dict.update({'key1': 'value1', 'key2': 'value2'})

# 打印字典
print(my_dict)

# 更新键值对
my_dict.update({'key1': 'new_value1'})

# 打印字典
print(my_dict)

输出：

{'key1': 'value1', 'key2': 'value2'}
{'key1': 'new_value1', 'key2': 'value2'}
  1. 删除键值对
  • 使用 del 关键字删除字典中的键值对。例如：
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除键为 'a' 的键值对
del my_dict['a']

print(my_dict)  # {'b': 2, 'c': 3}
  • 使用 pop 方法删除指定键的键值对，并返回该键对应的值。例如：
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除键为 'a' 的键值对，并返回该键对应的值
value = my_dict.pop('a')

print(my_dict)  # {'b': 2, 'c': 3}
print(value)    # 1
  • 如果要删除字典中所有的键值对，可以使用 clear 方法。例如：
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除字典中所有的键值对
my_dict.clear()

print(my_dict)  # {}
  1. 获取键或值的列表

可以使用字典的 keys()、values() 和 items() 方法获取键、值、键值对的列表。

示例代码：

d = {'a': 1, 'b': 2, 'c': 3}

# 获取键列表
keys = list(d.keys())
print(keys)  # ['a', 'b', 'c']

# 获取值列表
values = list(d.values())
print(values)  # [1, 2, 3]

# 获取键值对列表
items = list(d.items())
print(items)  # [('a', 1), ('b', 2), ('c', 3)]

注意：keys()、values() 和 items() 方法返回的是视图对象（view objects），而不是真正的列表，需要使用 list() 方法将其转换为列表。视图对象会随着字典的改变而动态更新。

  1. 检查键是否存在

可以使用 in 或者 not in 运算符来检查字典中是否存在某个键，例如：

my_dict = {"apple": 1, "banana": 2, "orange": 3}

if "apple" in my_dict:
    print("apple exists in my_dict")

if "watermelon" not in my_dict:
    print("watermelon does not exist in my_dict")

输出：

apple exists in my_dict
watermelon does not exist in my_dict
  1. 合并字典

可以使用 update() 方法将一个字典合并到另一个字典中。该方法会将另一个字典的键值对添加到当前字典中，如果存在相同的键，则会用新字典中的值覆盖原字典中的值。

以下是合并字典的示例代码：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1)  # {'a': 1, 'b': 3, 'c': 4}

在上面的示例中，dict1 和 dict2 两个字典被合并为一个新字典，结果为 {‘a’: 1, ‘b’: 3, ‘c’: 4}。其中，键 b 的值被更新为 3，因为在 dict2 中其对应的值为 3。

  1. 清空字典

清空字典可以使用 clear() 方法，示例如下：

# 创建一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 清空字典
my_dict.clear()

# 输出清空后的字典
print(my_dict)  # {}

该方法会将字典中所有的键值对全部删除，将字典清空。

  1. 复制字典

复制字典可以使用 copy() 方法或者使用字典的构造函数。以下是两种方法的代码示例：

# 使用 copy() 方法
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = dict1.copy()
print(dict2)  # {'a': 1, 'b': 2, 'c': 3}

# 使用字典构造函数
dict3 = dict(dict1)
print(dict3)  # {'a': 1, 'b': 2, 'c': 3}

需要注意的是，使用 copy() 方法或者字典构造函数复制字典时，复制出的字典与原字典是两个不同的对象，修改一个字典不会影响另一个字典。但是如果字典中的值是可变类型（比如列表），修改其中一个字典的值会影响另一个字典的值，因为它们共享同一个对象。

  1. 获取字典长度

可以使用内置函数len()来获取字典的长度，即键值对的个数。

示例代码：

my_dict = {"apple": 1, "banana": 2, "orange": 3}
length = len(my_dict)
print(length)  # 输出 3

以上是字典的常用操作，掌握这些操作可以更好地使用字典来存储和管理数据。

编程漫步者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python：变量
不怕猫的耗子A
12-06 4448
变量 1、在Python中，变量(variable)的概念基本上和初中代数的方程变量是一致的 ⑴例如，对于方程式 y=x*x ，x就是变量。当x=2时，计算结果是4，当x=5时，计算结果是25。x(变量)代表一个可以变化的值，我们传入的是什么，它就是什么 ⑵只是在计算机程序中，变量不仅可以是数字，可以是任意数据类型 2、变量代表某个值的名字，是指向各种类型值的名字，以后用到这个值时，直接引用名字即可，就不用再写具体的值 3、使用变量，可以提高我们程序的多样性、适应性：值不是固定的(没有......
Python 变量以及基本数据类型
weixin_42567943的博客
05-16 655
Python 变量以及基本数据类型
Python变量
晴天的博客
03-15 2739
Python变量
Python变量的基础类型。|整数类型|浮点数类型|字符串类型|布尔类型|
DEVELOPERAA的博客
08-04 105
学习编程语言，不得不忽视变量这个概念。Python 中的变量是用于存储数据的名称，你可以将值赋给变量，并在程序的其他地方使用该变量来引用该值。变量在程序中起到存储和操作数据的作用。
在Java中创建各种类型的变量的示例代码
最新发布
酱爆 Crazy
11-25 159
/ 初始化myString的值为"Hello, World!这段代码首先声明了一个布尔型变量myBoolean，然后将其值设置为true，最后输出myBoolean的值。这段代码首先声明了一个浮点型变量myFloat，然后将其值设置为3.14f，最后输出myFloat的值。// 输出myBoolean的值。// 输出myString的值。这段代码首先声明了一个整型变量myInt，然后将其值设置为5，最后输出myInt的值。// 输出myFloat的值。// 输出myInt的值。myInt = 5;
python爬虫从入门到精通（csdn）————程序.pdf
12-03
python爬虫从入门到精通（csdn）————程序
Python入门——环境的搭建和变量及数据类型解析
12-22
一.python的入门学习–环境的搭建 学习python首先我们要进行环境的搭建 当然，这个环境必须是官方网站提供的cpython解释器，这里提供官网链接 www.python.org 本次我选择的是最新的3.8.2版本64位的安装包 然后呢我们...
全网最全Python课程，从入门到精通！.pdf
06-13
【Python基础】Python_PYTHON⼊门_零基础Python⼊门_Python爬⾍_Python课程第⼆篇_Python进阶 【Python基础】Python_PYTHON⼊门_零基础Python⼊门_Python爬⾍_Python课程第三篇_Python终极 【Python基础】Python...
python3.8入门教程完整版-Python3.8从入门到精通（视频教学版）.pdf
06-11
python3.8⼊门教程完整版_Python3.8从⼊门到精通（视频教 学版） ⽬ 录 第壹章 感受Python精彩世界 1 1.1 Python概述 1 1.2 选择Python的理由 2 1.3 搭建Python的编程环境 2 1.3.1 在Windows下安装Python 3 1.3.2 在...
【精品分享】《Python编程从入门到实践》学习笔记——第二章 变量和简单数据类型
12-20
第2章 变量和简单数据类型 第3章 列表简介 第4章 操作列表 第5章 if语句 第6章 字典 未完待续 第7章 while循环 未完待续 第8章 函数 未完待续 第9章 类 未完待续 第10章 文件和异常 未完待续 项目实战 。。。。。。 ...
第三章 变量
Jrc1214的博客
10-23 5292
一、概念 变量是程序的基本组成单位，变量相当于内存中一个数据储存空间的表示，你可以把变量看作是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量。 void main() { int a=1;// 定义了一个整型变量，取名为a, 并赋值为1 (强数据类型语言) int b=3;// 定义了一个整型变量，取名为b, 并赋值为3 b=89;// 给变量赋值 为 89 printf("a=%d \n",a);// 使用输出语句，把变量a 值输出 %d 表示输出的形式为整数 printf
python变量详解_Python 变量详解[学习 Python 必备基础知识][看此一篇就够了]
weixin_39956558的博客
12-06 256
您的“关注”和“点赞”，是信任，是认可，是支持，是动力......如意见相佐，可留言。本人必将竭尽全力试图做到准确和全面，终其一生进行修改补充更新。1 Python 变量概述变量，英文叫做 Variable。从形式上看，每个变量都拥有独一无二的名字，通过变量的名字就能找到变量中的数据。从底层看，变量是内存的名字。因为程序中的数据最终都要放到内存中。2 Python 变量的命名变量名是标识符的一种，...
python中变量的声明和赋值
热门推荐
Mrical的博客
01-23 4万+
1、什么是变量？    变量：值会发生变化的的量，与常量相对.2、python支持的变量数据类型：    Python有五个标准的数据类型：1. 数字    2.字符串    3.元组    4.列表    5.字典3、python中的变量：python是弱类型的语言，变量的类型由其值的类型决定，不用为变量声名类型4、变量的命名规范：变量名称都是小写单词，每个单词之间用_下划线连接,尽量做到见名知...
Python基础语法——变量
m0_71494659的博客
04-15 916
在为一个值起名字时，它将存储在内存当中，我们将这块内存成为变量(variable)。在大多数语言中，把这种行为成为“给变量赋值”或“把值存储在变量当中”。
python基础01——变量的使用
sjsxdyd的博客
03-03 793
变量：在程序运行过程中，值会发生变化的量。把程序运算的中间结果临时存到内存里，以备后面的代码继续调用，这几个名字的学名就叫做“变量。
Python中的数据类型和变量
aidscooler的专栏
10-23 77
概述概述Python是一种动态类型的编程语言，它提供了丰富的数据类型和灵活的变量定义方式。了解Python中的数据类型和变量是编写高效、可读性强的代码的基础。本文将介绍Python中常见的数据类型和变量的使用方法。
python(9)-变量
sinat_40624829的博客
04-24 1260
数据输入1.input()2.类型转换函数3.Tips （关于函数，是一个提前准备好的代码；可以直接使用，不用关心内部细节。） 1.input() 变量名=input(‘提示输入的内容’) python2.x版本的input函数是自动识别数据类型类型，raw_input函数是字符串输入。 python3.x版本的只剩下input函数可用了，而且类型是字符串。 2.类型转换函数 int(x)：可...
python中的变量
zz_rong的博客
05-04 571
变量是指在程序运行过程中其值可以发生变化的量。变量由变量的“标志符”（又称“名字”）和变量的“内容”（又称“值”）两部分组成。我们可以把变量看作是保存信息的容器，它们的目的是在内存中标注和存储数据，然后，可以在整个程序中是用这些数据。在创建变量时，会在内存中开辟一个空间来存放变量值，通过变量名来访问变量的值。如下图，访问18，可以通过变量名age来访问。
黑马 python从入门到精通
10-10
从入门到精通的过程中，《黑马 Python从入门到精通》侧重于教授编程的基础知识和语法，包括变量、数据类型、运算符、控制流等等。同时，书中还介绍了 Python 的核心模块和常用库的用法，如字符串操作、文件读写、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程漫步者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值