python
python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
- Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
- Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
- Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
- python动态类型语言：Python是一种动态类型语言，变量的类型可以在运行时动态改变,不用声明变量数据类型
Python有运行模式：命令行模式和交互模式。
命令行模式： 用于执行保存在文件中的完整Python脚本，适合批量处理，执行后退出。
交互模式： 可以逐行输入代码并立即查看结果，适合学习、实验、快速调试。
Python是一种解释性语言，它的特点之一是逐行解释并执行代码，也就是所谓的"读一句执行一句
一.面向过程
1.python程序基础
1.1示例代码
def add_numbers(a, b):
"""计算两个数字的和。"""
result = a + b
return result
if __name__ == "__main__":
num1 = float(input("请输入第一个数字："))
num2 = float(input("请输入第二个数字："))
sum_result = add_numbers(num1, num2)
print(f"两个数字的和是：{sum_result}")
1.2注释
-
单行注释:单行注释以**#** 开头
-
多行注释:以
'''或"""开头和结尾
1.3标识符与关键字
a.标识符
- 第一个字符必须是字母表中字母或下划线 _ 。
- 标识符的其他的部分由字母、数字和下划线组成。
- 标识符对大小写敏感。
在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。
b.关键字
关键字既保留字,我们不能把它们用作任何标识符名称
Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
>>> import keyword >>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
1.4变量与常量
a.变量
变量，指值可以变的量
格式:变量名 =变量值
示例:
# 变量示例
x = 10 # 整数类型变量
x = 100
name = "Alice" # 字符串类型变量
def my_function():
y = 5 # 局部变量
print(y)
Python是动态类型语言，变量的数据类型可以在运行时自动更改。
变量赋值实质:
一个变量可以通过赋值指向不同类型的对象。可以使用del语句删除一些对象引用。
在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的：
a=[1,2,3] a="Run"以上代码中，[1,2,3] 是 List 类型，“Run” 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
- **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
- **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
b.常量
常量,是在程序中固定不变的值.
在Python中，没有严格的常量概念，但通常使用全大写字母来表示常量，以表示它们应该保持不变
示例:
# 常量示例
MAX_VALUE = 100 # 常量，约定俗成使用全大写命名
PI = 3.14159
1.5输入与输出函数
在Python中，使用
print,input()和函数不需要手动引入模块因为它是Python的标准库中的一个内置函数(
print,input函数是在Python解释器启动时自动加载的)
a.print()函数的使用
print()是一个内置函数，用于将文本、变量、表达式等输出到控制台（终端）或输出文件。
格式:print(对象, ...)
其中，
对象是要输出的数据，可以是一个或多个，用逗号分隔。
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
示例:
#!/usr/bin/python3 x="a" y="b" # 换行输出 print( x ) print( y ) print('---------') # 不换行输出 print( x, end=" " ) print( y, end=" " ) print()以上实例执行结果为：
a b --------- a b
b.input函数
input()是一个内置函数，用于从用户获取输入。它允许程序在运行时暂停，等待用户在键盘上输入一些文本，并将输入的文本作为字符串返回给程序。
格式:变量 = input([提示信息])
提示信息是一个可选参数，用于在等待用户输入时在控制台中显示一条提示。当用户键入回车键时，input()函数将等待并返回用户输入的文本。
示例:
name = input("请输入您的姓名：")
age = int(input("请输入您的年龄：")) # input()函数返回的是字符串类型。如果需要将输入解释为其他类型（如整数、浮点数等），则需要进行相应的类型转换
print("您好，", name)
1.6代码块(缩进&":"&";")
缩进:Python中的缩进是一种用于表示代码结构和层次关系的重要语法元素,缩进相同的一组语句构成一个代码块
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
冒号（:）： 在Python中，冒号用于引入代码块。通常，在条件语句、循环和函数定义之后，代码块使用缩进来表示。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
分号( ; ):Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠
\来实现多行语句，例如：total = item_one + \ item_two + \ item_three在 [], {}, 或 () 中的多行语句，不需要使用反斜杠
\，例如：total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']
2.基本数据类型
Python3 的六个标准数据类型中：
- **不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；
- **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。
此外还有一些高级的数据类型，如: 字节数组类型(bytes)。
内置的 type() 函数可以用来查询变量所指的对象类型
2.1数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
-
int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
-
bool (布尔), 如 True。
-
float (浮点数), 如 1.23、3E-2
-
complex (复数), 如 1 + 2j、 1.1 + 2.2j
复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
**注意：**Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True == 1、False == 0 会返回 True，但可以通过
is来判断类型。>>> issubclass(bool, int) True >>> True==1 True >>> False==0 True >>> True+1 2 >>> False+1 1 >>> 1 is True False >>> 0 is False False
2.2字符串(str)
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。
2…2.1字符串的定义
创建字符串： 可以使用单引号（' '）、双引号（" "）或三引号（''' '''或""" """）来创建字符串。
Python 中单引号 ’ 和双引号 " 使用完全相同。
使用三引号(’’’ 或 “”")可以指定一个多行字符串。
三引号和多行注释写法一样
- 使用变量接受它,它就是字符串
- 不使用变量接受它,就可以作为多行注释使用
示例
single_quoted = 'Hello, world!'
double_quoted = "Python programming"
triple_quoted = '''This is a
multi-line string.'''
2.2.2字符串的截取
字符串中的每个字符都有一个索引，索引值以 0 为开始值，-1 为从末尾的开始位置。可以使用索引来访问字符串中的单个字符，也可以使用切片来获取子字符串。
格式：变量[头下标:尾下标:步长]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lFgjE4xA-1692520125628)(https://static.runoob.com/wp-content/uploads/123456-20200923-1.svg)]
示例:
#!/usr/bin/python3
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
执行以上程序会输出如下结果：
Runoob
Runoo
R
noo
noob
引号的嵌套
- 可以使用:
\来进行转义- 单引号内写双引号or双引号内写单引号
2.2.3字符串的拼接
使用+运算符可以将多个字符串连接起来，形成一个新的字符串。
示例:
#!/usr/bin/python3
str='123456789'
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
执行以上程序会输出如下结果：
123456789123456789
123456789你好
字符串可以用+运算符连接在一起， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。。
2.2.4转义字符
可以使用反斜杠（\）作为转义字符来插入特殊字符，如换行符、制表符等。
text = "This is a\nnew line."
print(text)
执行以上程序会输出如下结果：
This is a
new line
反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
2.2.5字符串的格式化
符串格式化是一种在Python中将变量的值插入到字符串中的技术，使得输出能够动态地包含变量的内容。
在Python中，有多种方式可以进行字符串格式化，包括旧式格式化、str.format()方法和f-strings。
-
旧式字符串格式化：
旧式格式化使用%运算符将变量的值插入到字符串中。在格式字符串中，使用%后面跟着一个占位符，表示将要插入的值的类型。占位符可以是字符串（%s）、整数（%d）、浮点数（%f）等。name = "Alice" age = 30 message = "Hello, my name is %s and I am %d years old." % (name, age) -
str.format()方法：
str.format()方法允许你在字符串中使用花括号{}来指示插入变量的位置，然后通过调用format()方法传递变量的值。可以在花括号内指定索引号、关键字参数或空白，以便灵活地插入多个变量。name = "Alice" age = 30 message = "Hello, my name is {} and I am {} years old.".format(name, age)或使用位置参数：
message = "Hello, my name is {0} and I am {1} years old.".format(name, age) -
f-strings（格式化字符串字面值）：
f-strings 是在Python 3.6 版本中引入的一种字符串格式化方式。使用f前缀在字符串中插入变量，并在变量名前加上花括号{}。f-strings更加简洁易读，且速度较快。name = "Alice" age = 30 message = f"Hello, my name is {name} and I am {age} years old."f-strings还支持在花括号中进行表达式计算：
pythonCopy code result = f"The result of 5 times 3 is {5 * 3}."
2.3List（列表）
2.3.1列表的定义
列表（List）是一种在Python编程语言中用于存储一组有序、可变、可重复的元素的数据结构。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
与Python字符串不一样的是，列表中的元素是可以改变的
可变性（Mutable）: 你可以通过添加、删除元素来修改列表。
>>> a = [1, 2, 3, 4, 5, 6] >>> a[0] = 9 >>> a[2:5] = [13, 14, 15] >>> a [9, 2, 13, 14, 15, 6] >>> a[2:5] = [] # 将对应的元素值设置为 [] >>> a [9, 2, 6]
格式:my_list = [element1, element2, element3, ...]
使用方括号
[]来创建列表。列表中的元素由逗号,分隔，并可以包含各种不同类型的数据
示例:
mixed_list = [1, "hello", 3.14, True]
2.3.2列表下标与索引
下标（Index）:用于表示集合中元素的位置,以 0 为开始值，-1 为从末尾的开始位置
索引（Indexing）：索引是指使用下标来访问列表中的元素的操作。通过提供元素的下标，你可以获取该位置上的元素。
例如，如果要获取
my_list中的第二个元素（下标为1），你可以使用my_list[1]。
列表截取格式变量[头下标:尾下标:步长]
如果第三个参数为负数表示逆向读取
示例
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
加号 + 是列表连接运算符，星号 ***** 是重复操作
以上实例输出结果：
['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']
2.3.3列表的常用操作
Python 列表提供了许多操作和方法，用于对列表进行各种操作，包括添加、删除、修改元素，切片、排序等.
- 添加元素：
append(element)：将元素添加到列表的末尾。list.extend(seq):在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）insert(index, element)：在指定索引位置插入元素。
- 删除元素：
remove(element)：从列表中删除指定元素的第一个匹配项。pop(index)：删除并返回指定索引位置的元素，默认为列表末尾。del list[index]：删除指定索引位置的元素。clear()：清空列表中的所有元素。
- 修改元素：
- 通过索引直接赋值：
list[index] = new_value，用新值替换列表中指定位置的元素。
- 通过索引直接赋值：
- 切片操作：
- 切片操作用于获取列表的子列表，语法为
list[start:end]，包括起始索引，但不包括结束索引。
- 切片操作用于获取列表的子列表，语法为
- 排序和反转：
sort()：对列表进行原地排序（升序）。reverse()：将列表中的元素反转。
- 查找和计数：
index(element)：返回指定元素的第一个匹配项的索引。count(element)：返回指定元素在列表中出现的次数。
- 连接和复制：
+操作符：用于连接两个列表，生成一个新列表。*操作符：用于将列表重复多次，生成一个新列表。
- 长度和存在性检查：
len(list)：返回列表中元素的数量。element in list：检查指定元素是否在列表中，返回布尔值。
- 复制列表：
- 使用切片操作：
new_list = old_list[:]，可以复制整个列表。
- 使用切片操作：
# 初始列表
my_list = [1, 2, 3, 4, 5]
# 添加元素 6
my_list.append(6) # my_list = [1, 2, 3, 4, 5, 6]
# 在索引 1 处插入元素 10
my_list.insert(1, 10) # my_list = [1, 10, 2, 3, 4, 5, 6]
# 移除元素 3
my_list.remove(3) # my_list = [1, 10, 2, 4, 5, 6]
# 弹出索引 2 处的元素（值为 2）
popped_element = my_list.pop(2) # my_list = [1, 10, 4, 5, 6], popped_element = 2
# 删除索引 0 处的元素
del my_list[0] # my_list = [10, 4, 5, 6]
# 清空列表
my_list.clear() # my_list = []
# 创建新列表通过连接
new_list = my_list + [7, 8] # new_list = [7, 8]
# 创建重复的列表
repeated_list = my_list * 3 # repeated_list = []
# 对列表 [3, 1, 2] 进行排序（原地操作，返回值为 None）
sorted_list = [3, 1, 2].sort() # sorted_list = None
# 对列表 [1, 2, 3] 进行反转（原地操作，返回值为 None）
reversed_list = [1, 2, 3].reverse() # reversed_list = None
# 获取索引 1 到 3 之间的子列表
sub_list = my_list[1:4] # sub_list = []
# 查找元素 4 的索引
index = my_list.index(4) # IndexError: list index out of range
# 计算元素 2 在列表中出现的次数
count = my_list.count(2) # count = 0
# 获取列表长度
length = len(my_list) # length = 0
# 检查元素 5 是否在列表中
element_exists = 5 in my_list # element_exists = False
# 复制列表
new_list = my_list[:] # new_list = []
2.4Tuple（元组）
2.4.1元组的定义
元组（Tuple）是一种有序、不可变、可重复的数据结构，用于存储多个元素的集合。
- 元组中元素的类型可以不相同,如数字、字符串、布尔值等。
- 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
格式: my_tuple = (element1, element2, element3, ...)
使用圆括号
()来创建列表。列表中的元素由逗号,分隔，并可以包含各种不同类型的数据
示例:
my_tuple1 = (1, 2, 3, "apple", "banana")
注意:
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
2.4.2元组的下标与索引
下标（Index）:用于表示集合中元素的位置,以 0 为开始值，-1 为从末尾的开始位置
索引（Indexing）：索引是指使用下标来访问列表中的元素的操作。通过提供元素的下标，你可以获取该位置上的元素。
例如，如果要获取
my_tuple中的第二个元素（下标为1），你可以使用my_tuple[1]。
元组截取格式变量[头下标:尾下标:步长]
如果第三个参数为负数表示逆向读取
示例
#!/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')
# 示例2
>>> 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
>>>
2.4.3元组的常用操作
与列表不同的是，元组的元素在创建后不能被修改。
下面是元组的一些常见操作和方法的详细解释：
-
创建元组：
你可以使用圆括号来创建元组，其中的元素用逗号分隔。
my_tuple = (1, 2, 3) -
访问元素：
元组中的元素可以通过索引来访问，索引从 0 开始。
my_tuple = (1, 2, 3) first_element = my_tuple[0] # 1 -
元组拆包：
你可以将元组的元素拆解为多个变量，称为元组拆包。
my_tuple = (1, 2, 3) a, b, c = my_tuple -
元组合并：
你可以使用
+操作符将两个元组合并成一个新的元组。tuple1 = (1, 2, 3) tuple2 = (4, 5, 6) combined_tuple = tuple1 + tuple2 # (1, 2, 3, 4, 5, 6) -
重复元组：
你可以使用
*操作符将一个元组重复多次。my_tuple = (1, 2) repeated_tuple = my_tuple * 3 # (1, 2, 1, 2, 1, 2) -
元组方法：
元组虽然不可变，但它仍然有一些方法可以用来操作。
count()：返回指定元素在元组中出现的次数。len(tuple)计算元组元素个数。index()：返回指定元素在元组中的第一个出现位置的索引。
my_tuple = (1, 2, 2, 3, 4, 2) count_of_twos = my_tuple.count(2) # 3 index_of_three = my_tuple.index(3) # 3
总之，元组是一种有序的、不可变的数据结构，适用于存储一组元素，尤其是当你希望元素在创建后不被修改时。
2.5Set（集合）
2.5.1集合的定义
Python 中的集合（Set）是一种无序、可变、不可重复的数据类型,它是基于哈希表实现的数据结构
Python的集合可以容纳不同类型的数据，前提是这些数据都是可哈希的
可哈希性是指元素的值在其生命周期内不可变，且可以通过哈希函数得到一个唯一的哈希值。
- 这就意味着集合中的元素必须是不可变的类型，例如整数、浮点数、字符串、元组等。
- 这意味着你不能将列表、字典、集合等可变的类型作为集合的元素，因为它们的值是可以改变的，从而不满足可哈希性的要求。
可变性（Mutable）: 你可以通过添加、删除元素来修改集合。
不支持索引访问和切片（No Indexing or Slicing）: 由于集合是无序的，你不能通过索引来访问集合中的元素，也不能进行切片操作。
支持集合运算（Set Operations）: 集合提供了丰富的集合操作，如并集、交集、差集等。
格式:
my_set ={element1, element2, element3, ...}
或者
set(value)
集合使用大括号 {} 表示，元素之间用逗号 , 分隔。，并可以包含各种不同类型的数据
花括号{}或者set()构造函数来创建一个集合
示例:
my_set = {1, 2, 3, 4, 5}
注意:
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
2.5.2集合的常用操作
集合（Set）是Python中的一种无序、可变的数据结构，用于存储唯一的元素。
下面是集合的一些常见操作和方法的详细解释：
-
创建集合：
你可以使用花括号来创建集合，或者使用
set()构造函数。my_set = {1, 2, 3} another_set = set([3, 4, 5]) -
添加元素：
add()方法来向集合中添加一个元素。
my_set = {1, 2, 3} my_set.add(4) -
删除元素：
remove()方法来从集合中删除一个指定的元素，如果元素不存在会引发KeyError。discard()方法也可以删除元素，但如果元素不存在不会引发错误。
my_set = {1, 2, 3} my_set.remove(2) my_set.discard(3) -
集合运算：
集合提供了多种集合运算，如并集、交集、差集等。
-
并集：
union()方法或|操作符。 -
交集：
intersection()方法或&操作符。 -
差集：
difference()方法或-操作符。 -
对称差集（异或）：
symmetric_difference()方法或^操作符。
set1 = {1, 2, 3} set2 = {3, 4, 5} union_set = set1.union(set2) # {1, 2, 3, 4, 5} intersection_set = set1.intersection(set2) # {3} difference_set = set1.difference(set2) # {1, 2} symmetric_difference_set = set1.symmetric_difference(set2) # {1, 2, 4, 5} -
-
判断包含关系：
in操作符来判断一个元素是否在集合中。
my_set = {1, 2, 3} is_present = 2 in my_set # True -
清空集合：
clear()方法来清空集合中的所有元素。
my_set = {1, 2, 3} my_set.clear() -
集合方法：
集合有一些其他方法，
copy()用于复制集合pop()用于移除并返回集合中的一个随机元素。len()计算集合元素个数。
my_set = {1, 2, 3} new_set = my_set.copy() # 复制集合 popped_element = my_set.pop() # 移除并返回一个随机元素
总之，集合是一种用于存储唯一元素的数据结构，提供了丰富的操作和方法来处理集合中的元素。它适用于需要快速查找和操作唯一元素的情况。
2.6Dictionary（字典）
2.6.1字典的定义
字典是一种无序、可变、不可重复的数据结构，用于存储键-值（key-value）对的集合。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
每个键都是唯一的，而且与其关联的值可以是任何数据类型，例如整数、字符串、列表、字典等。键的唯一性（Unique Keys）: 键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
可变性（Mutable）: 你可以通过添加、删除、更新键-值对来修改字典。
哈希表实现（Hash Table）: 字典的实现基于哈希表，这使得在平均情况下，插入、删除和查找键-值对的操作都是很快的。
访问和修改（Access and Modification）: 通过键来访问和修改对应的值。
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过索引（偏移）存取。
格式: my_dict = {key1: value1, key2: value2, key3: value3, ...}
每个键-值对由键和与之关联的值组成，用冒号
:分隔。不同的键-值对之间用逗号,分隔。键可以是任何不可变的数据类型，例如整数、字符串、元组等，而值可以是任何数据类型，包括整数、字符串、列表、字典等。
示例:
# 定义一个存储人名和年龄的字典
person_info = {'Alice': 25, 'Bob': 30, 'Carol': 22}
# 定义一个存储水果和对应颜色的字典
fruit_colors = {'apple': 'red', 'banana': 'yellow', 'grape': 'purple'}
# 定义一个空字典
empty_dict = {}
# 使用dict()构造函数创建字典,传入键-值对的元组列表作为参数
fruit_colors = dict([('apple', 'red'), ('banana', 'yellow'), ('grape', 'purple')])
**注意:**字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
2.5.2字典的常用操作
字典（Dictionary）是Python中的一种无序、可变的数据结构，用于存储键-值（key-value）对的集合。字典使用花括号 {} 表示，其中的键-值对由键和与之关联的值用冒号 : 分隔，键-值对之间用逗号 , 分隔。
下面是字典的一些常见操作和方法的详细解释：
-
创建字典：
你可以使用花括号来创建字典，或者使用
dict()构造函数。my_dict = {'a': 1, 'b': 2, 'c': 3} another_dict = dict(x=10, y=20, z=30) -
访问值：
通过键来访问字典中的值。
my_dict = {'a': 1, 'b': 2, 'c': 3} value_a = my_dict['a'] # 1 -
添加或修改键-值对：
使用赋值操作来添加新的键-值对或修改已有键的值。
my_dict = {'a': 1, 'b': 2} my_dict['c'] = 3 # 添加新的键-值对 my_dict['b'] = 22 # 修改已有键的值 -
删除键-值对：
-
使用
del语句来删除指定的键-值对。 -
clear()用于删除字典内所有元素
my_dict = {'a': 1, 'b': 2, 'c': 3} del my_dict['b'] # 删除键为'b'的键-值对 -
-
键的存在判断：
使用
in操作符来检查一个键是否存在于字典中。my_dict = {'a': 1, 'b': 2, 'c': 3} is_key_present = 'b' in my_dict # True -
获取所有键和值：
keys()方法获取所有键的列表values()方法获取所有值的列表items()方法获取所有键-值对的元组列表。
my_dict = {'a': 1, 'b': 2, 'c': 3} keys_list = my_dict.keys() # ['a', 'b', 'c'] values_list = my_dict.values() # [1, 2, 3] items_list = my_dict.items() # [('a', 1), ('b', 2), ('c', 3)] -
字典方法：
字典还有一些其他方法，如
get()用于获取指定键的值pop()用于移除并返回指定键的值。len(dict)计算字典元素个数，即键的总数。
my_dict = {'a': 1, 'b': 2, 'c': 3} value_a = my_dict.get('a') # 1 popped_value = my_dict.pop('b') # 移除并返回键'b'的值
{‘a’: 1, ‘b’: 2}
my_dict[‘c’] = 3 # 添加新的键-值对
my_dict[‘b’] = 22 # 修改已有键的值
4. **删除键-值对**：
+ 使用`del`语句来删除指定的键-值对。
+ ``clear()``用于删除字典内所有元素
```python
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b'] # 删除键为'b'的键-值对
-
键的存在判断：
使用
in操作符来检查一个键是否存在于字典中。my_dict = {'a': 1, 'b': 2, 'c': 3} is_key_present = 'b' in my_dict # True -
获取所有键和值：
keys()方法获取所有键的列表values()方法获取所有值的列表items()方法获取所有键-值对的元组列表。
my_dict = {'a': 1, 'b': 2, 'c': 3} keys_list = my_dict.keys() # ['a', 'b', 'c'] values_list = my_dict.values() # [1, 2, 3] items_list = my_dict.items() # [('a', 1), ('b', 2), ('c', 3)] -
字典方法：
字典还有一些其他方法，如
get()用于获取指定键的值pop()用于移除并返回指定键的值。len(dict)计算字典元素个数，即键的总数。
my_dict = {'a': 1, 'b': 2, 'c': 3} value_a = my_dict.get('a') # 1 popped_value = my_dict.pop('b') # 移除并返回键'b'的值
总之，字典是一种用于存储键-值对的数据结构，提供了丰富的操作和方法来处理键和值。它适用于需要以键来访问值的情况，比如存储关联性数据。
1179
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
