Python入门到高级【第二章】 

预计更新

第一章. Python 简介

  • Python 简介和历史
  • Python 特点和优势
  • 安装 Python

第二章. 变量和数据类型

  • 变量和标识符
  • 基本数据类型：数字、字符串、布尔值等
  • 字符串操作
  • 列表、元组和字典

第三章. 控制语句和函数

  • 分支结构：if/else 语句
  • 循环结构：for 和 while 循环
  • 函数
  • 参数传递与返回值
  • Lambda 表达式

第四章. 模块和文件 IO

  • 模块的概念
  • 导入模块
  • 文件 IO
  • 序列化和反序列化

第五章. 异常处理

  • 异常简介
  • try/except 语句
  • 自定义异常

第六章. 面向对象编程

  • 类和对象
  • 继承和多态
  • 属性和方法
  • 抽象类和接口

第七章. 正则表达式

  • 正则表达式概述
  • 匹配和搜索
  • 替换和分割

第八章. 并发编程

  • 多线程
  • 多进程
  • 协程和异步编程

第九章. 数据库编程

  • 关系型数据库介绍
  • 使用 SQLite 数据库
  • 使用 MySQL 数据库
  • 使用 PostgreSQL 数据库

第十章. 网络编程

  • Socket 编程简介
  • TCP Socket 编程
  • UDP Socket 编程
  • HTTP 编程

第十一章. Web 开发框架 Flask

  • Flask 简介
  • 安装 Flask
  • 路由和视图函数
  • 模板和静态文件

第十二章. 数据分析和科学计算

  • NumPy 基础
  • Pandas 基础
  • Matplotlib 基础

第十三章 机器学习入门

  • 机器学习概述
  • 监督学习和非监督学习
  • Scikit-Learn 简介
  • 利用 Scikit-Learn 进行数据预处理和模型训练

第十四章. 自然语言处理

  • 自然语言处理概述
  • 中文分词和处理
  • 文本分类和情感分析

第十五章. 游戏开发与 Pygame

  • Pygame 简介
  • Pygame 基础
  • 开发一个简单的游戏
第二章. 变量和数据类型
   - 变量和标识符
   - 基本数据类型：数字、字符串、布尔值等
   - 字符串操作
   - 列表、元组和字典

变量和标识符

Python是一门高级编程语言，它支持多种数据类型，包括数字、字符串、列表、元组、字典等等。在Python中，变量用于存储数据值或对象，而标识符则用于在代码中引用这些变量。

变量是Python中最基本的概念之一，它可以被看作是一个容器，用来存储某个特定的值或对象。在Python中，变量名是由字母、数字和下划线组成的字符串，必须以字母或下划线开头，不能以数字开头。例如，valid_variable_name、num1、_my_var等都是合法的变量名。

在Python中，变量的赋值可以使用等号（=）操作符完成。例如：

x = 10
name = 'John'

上述代码将整数值10分配给变量x，将字符串值’John’分配给变量name。注意，在Python中，变量的类型不需要显式地声明，它们会根据所分配的值自动推断。

在Python中，变量还具有动态性质，这意味着可以随时更改变量的值。例如：

x = 10
x = x + 5
print(x) # Output: 15

上述代码首先将整数值10分配给变量x，然后将x加上5，最后将结果15重新赋值给x。同时要注意，在Python中，变量名是区分大小写的。

Python中的标识符则是用于标识变量、函数、类等对象的名称。标识符也是由字母、数字和下划线组成的字符串，但必须以字母或下划线开头，不能以数字开头。例如，valid_identifier_name、_my_function、MyClass等都是合法的标识符。

在Python中，标识符有以下几种规定：

  1. 标识符是区分大小写的，这意味着my_var和MY_VAR是不同的标识符。
  2. 标识符应当具有描述性，能够清晰地表达所代表的对象的含义。
  3. 在命名标识符时，应避免使用Python关键字（例如if、while、for等）和内置函数/方法的名称（例如print、len等）作为标识符。
  4. Python约定俗成的规定是将单词之间用下划线隔开，如valid_identifier_name。

除此之外，还有一些Python中常见的命名规范，例如PEP 8规范，它是Python语言风格指南的一部分，提供了一系列关于代码编写和格式化方面的建议和规范。

在Python中，标识符通常用于以下场景：

  1. 变量名：标识符用于给变量命名，以便在程序中引用变量。
  2. 函数名：标识符用于给函数命名，以便在程序中调用函数。
  3. 类名：标识符用于给类命名，以便在程序中创建和操作对象。
  4. 模块名：标识符用于给模块命名，以便在程序中引入和使用模块。

总之，变量和标识符是Python编程中非常重要的概念。它们可以帮助我们更好地组织代码、管理数据，提高代码可读性和可维护性。当然，在实践过程中，合适的变量和标识符的使用，需要根据具体场景和需求进行灵活的选择。

基本数据类型：数字、字符串、布尔值等

Python是一门非常灵活的编程语言，它支持多种不同的数据类型。在Python中，数据类型用于存储和操作不同类型的数据值，例如数字、字符串、列表等。在本文中，我们将详细介绍Python中的基本数据类型，包括数字、字符串、布尔值等。

  1. 数字（Numbers）

在Python中，数字是最基本的数据类型之一，用于表示各种数值，例如整数、浮点数、复数等。Python中的数字类型包括以下三种：

  1. 整数（int）：用于表示没有小数部分的数值，可以是正数、负数或零。
  2. 浮点数（float）：用于表示有小数部分的数值，也可以是正数、负数或零。
  3. 复数（complex）：用于表示实部和虚部都为浮点数的复数。

在Python中，可以使用以下方式定义数字变量：

# 整数
x = 10
y = -20

# 浮点数
z = 3.14
w = -0.5

# 复数
a = 2 + 3j
b = 1.5 - 2.5j

可以使用type()函数检查一个变量的数据类型：

print(type(x)) # Output: <class 'int'>
print(type(z)) # Output: <class 'float'>
print(type(a)) # Output: <class 'complex'>

在Python中，支持各种数学运算，例如加减乘除、取余等。同时还支持一些高级数学运算，例如幂、对数、三角函数等。下面是一些常见的数学运算示例：

# 加、减、乘、除
a = 10 + 5
b = 20 - 6
c = 3 * 6
d = 8 / 2

# 取余
e = 9 % 2

# 幂
f = 2 ** 3

# 对数
import math
g = math.log(100, 10)

# 三角函数
h = math.sin(math.pi/2)
  1. 字符串（Strings）

在Python中，字符串是用来表示文本数据的数据类型，它是由一系列字符组成的序列。Python中的字符串可以包含字母、数字、标点符号等字符。字符串类型的变量可以使用单引号或双引号来定义，例如：

str1 = 'Hello, world!'
str2 = "Python is great."

在Python中，字符串也可以像列表一样进行切片和索引操作。例如：

text = 'Python is a great language.'
print(text[0])   # Output: P
print(text[-1])  # Output: .
print(text[7:13]) # Output: is a g

字符串还支持各种字符串操作，例如连接、重复、查找和替换等操作。例如：

# 字符串连接
a = 'Hello,'
b = ' world!'
c = a + b

# 字符串重复
d = a * 3

# 查找字符串
e = 'Python is great.'
print(e.find('great')) # Output: 10

# 字符串替换
f = e.replace('great', 'awesome')

在Python中，字符串还有许多内置方法，例如strip()、lower()、upper()等，用于操作和处理字符串数据。

  1. 布尔值（Booleans）

布尔值是一种逻辑数据类型，只有两个取值：True和False。在Python中，可以使用以下方式定义布尔变量：

is_true = True
is_false = False

在Python中，布尔值通常用于条件判断、循环控制等场景。例如：

# 条件判断
x = 10
if x > 5:
    print('x is greater than 5')

# 循环控制
while True:
    # do something
    if condition:
        break

同时，在Python中，还支持布尔逻辑运算，例如and、or、not等。例如：

# and 运算
a = True and False  # False

# or 运算
b = True or False   # True

# not 运算
c = not True        # False
  1. 列表（Lists）

列表是一种复合数据类型，用于存储一组有序的数据。在Python中，列表可以包含不同类型的数据，例如数字、字符串、甚至是其他列表。可以使用以下方式定义列表：

my_list = [1, 2, 'three', 4.5]

在Python中，列表支持各种操作，例如索引、切片、追加、插入、删除等。例如：

# 索引和切片
a = my_list[0]      # 1
b = my_list[-1]     # 4.5
c = my_list[1:3]    # [2, 'three']

# 追加
my_list.append(6)

# 插入
my_list.insert(2, 'new')

# 删除
del my_list[1]

同时，Python中还有许多内置方法可用于操作列表，例如sort()、reverse()等。

  1. 元组（Tuples）

元组是一种类似于列表的复合数据类型，但与列表不同的是，元组一旦创建就不能修改。元组通常用于表示不可变的数据集合，例如坐标点、姓名和年龄等。可以使用以下方式定义元组：

my_tuple = (1, 2, 'three', 4.5)

在Python中，元组支持索引和切片操作，但不支持追加、插入和删除等修改操作。

  1. 集合（Sets）

集合是一种无序且唯一的数据类型，用于存储一组不同的元素。在Python中，可以使用以下方式定义集合：

my_set = {1, 2, 3, 4, 5}

在Python中，集合支持各种数学操作，例如交集、并集、差集等。同时，还支持添加、删除和判断元素是否存在等操作。例如：

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(2)

# 判断元素是否存在
print(3 in my_set)  # True

# 求交集
set1 = {1, 2, 3}
set2 = {2, 3, 4}
set3 = set1 & set2   # {2, 3}

# 求并集
set4 = set1 | set2   # {1, 2, 3, 4}

# 求差集
set5 = set1 - set2   # {1}
  1. 字典（Dictionaries）

字典是一种复合数据类型，用于存储键值对映射关系。在Python中，可以使用以下方式定义字典：

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

在Python中，可以通过键来访问字典中的值。同时，可以使用keys()、values()和items()等方法来操作字典。例如：

# 访问字典
a = my_dict['name']   # 'John'

# 修改字典
my_dict['age'] = 31

# 删除键值对
del my_dict['city']

# keys()
b = my_dict.keys()    # dict_keys(['name', 'age'])

# values()
c = my_dict.values()  # dict_values(['John', 31])

# items()
d = my_dict.items()  # dict_items([('name', 'John'), ('age', 31)])

总之，在Python中，有多种基本数据类型，包括数字、字符串、布尔值、列表、元组、集合和字典等。每种数据类型都有其特定的用途和操作方式，在编写代码时需要根据具体需求进行选择和应用。

Python字符串操作

Python是一种高级编程语言，它支持许多不同的数据类型，包括字符串。字符串在Python中是一个非常重要的数据类型，因为它们被广泛地用于文本处理、网络编程、数据库操作等许多应用领域。Python提供了很多内置函数和方法来操作字符串，使得字符串处理变得更加方便和高效。在本篇文章中，我们将介绍如何使用Python进行字符串操作，包括创建和初始化字符串、字符串切片、字符串连接、字符串搜索和替换、字符串大小写转换、字符串格式化等方面。

字符串基础

在Python中，字符串可以通过单引号（’ '）或双引号（" "）来定义。例如：

str1 = 'Hello, World!'
str2 = "Hello, Python!"

当然，如果您在字符串中需要使用单引号或双引号，那么您可以使用另外一种引号来定义该字符串。例如：

str3 = 'He said, "I love Python!"'
str4 = "She said, 'Me too!'"

此外，Python还支持三重引号来定义多行字符串。例如：

str5 = '''This is a multi-line string.
You can use triple quotes to define it.'''

在Python中，字符串是不可变的，也就是说，一旦创建了一个字符串，您就不能修改它的值。例如：

str6 = 'abc'
# 下面的代码会报错
str6[0] = 'd'

字符串切片

Python提供了一种方便的方法来从字符串中获取子字符串，这就是字符串切片（Slicing）。

字符串切片使用索引来指定要提取的子字符串的范围。例如：

str7 = "Hello, Python!"
print(str7[0:5])  # 输出: Hello

在上面的例子中，我们使用了切片操作符（[:]）来提取字符串的子字符串。左边的索引指定了要提取的子字符串的起始位置，右边的索引指定了要提取的子字符串的结束位置（不包括该位置）。例如，上面的代码中，[0:5]表示从字符串的第一个字符开始提取，直到第六个字符（不包括第六个字符）结束。

如果您只指定一个索引，则切片将从该索引开始，一直提取到字符串的末尾。例如：

str8 = "Hello, Python!"
print(str8[7:])  # 输出: Python!

此外，您还可以省略左边或右边的索引，这将使切片从字符串的开头或末尾开始。例如：

str9 = "Hello, Python!"
print(str9[:5])  # 输出: Hello
print(str9[7:])  # 输出: Python!
print(str9[-6:])  # 输出: Python!

在上面的例子中，我们使用了负数索引来指定要提取的子字符串的起始位置。负数索引表示从字符串的末尾开始计算，例如-1表示字符串的最后一个字符。

字符串连接

在Python中，您可以使用加号（+）来连接两个字符串。例如：

str10 = "Hello,"
str11 = " Python!"
str12 = str10 + str11
print(str12)  # 输出: Hello, Python!

此外，在Python中还有一种更简单的方法来连接多个字符串，那就是使用join()方法。例如：

str13 = ["Hello", "Python", "!"]
str14 = " ".join(str13)
print(str14)  # 输出: Hello Python !

在上面的例子中，我们将字符串列表str13中的所有元素连接起来，并以空格作为分隔符。

字符串搜索和替换

在处理字符串时，搜索和替换是常见的操作之一。在Python中，我们可以使用一些内置函数和方法来实现字符串搜索和替换。

find()方法

find()方法用于在字符串中查找子字符串，并返回其第一次出现的位置。例如：

str15 = "Hello, Python!"
print(str15.find("Python"))  # 输出: 7

在上面的例子中，我们使用了find()方法来查找字串"Python"在字符串中第一次出现的位置，返回结果为7。

如果要查找的子字符串不存在，find()方法将返回-1。例如：

str16 = "Hello, Python!"
print(str16.find("Java"))  # 输出: -1

replace()方法

replace()方法用于将字符串中指定的子字符串替换为另一个字符串。例如：

str17 = "Hello, Python!"
str18 = str17.replace("Python", "Java")
print(str18)  # 输出: Hello, Java!

在上面的例子中，我们使用了replace()方法将字符串中的"Python"替换为"Java"，并将新字符串赋值给str18。

count()方法

count()方法用于计算字符串中指定的子字符串出现的次数。例如：

str19 = "Python is a great programming language. Python is easy to learn."
print(str19.count("Python"))  # 输出: 2

在上面的例子中，我们使用了count()方法来计算字符串中出现的"Python"的次数，返回结果为2。

字符串大小写转换

在Python中，我们可以使用一些内置函数和方法来实现字符串的大小写转换。

upper()方法

upper()方法将字符串中所有字符转换为大写字母。例如：

str20 = "Hello, Python!"
print(str20.upper())  # 输出: HELLO, PYTHON!

在上面的例子中，我们使用了upper()方法将字符串中的所有字符都转换成了大写字母。

lower()方法

lower()方法将字符串中所有字符转换为小写字母。例如：

str21 = "Hello, Python!"
print(str21.lower())  # 输出: hello, python!

在上面的例子中，我们使用了lower()方法将字符串中的所有字符都转换成了小写字母。

capitalize()方法

capitalize()方法将字符串的第一个字符转换为大写字母，其余字符转换为小写字母。例如：

str22 = "hello, world!"
print(str22.capitalize())  # 输出: Hello, world!

在上面的例子中，我们使用了capitalize()方法将字符串的第一个字符转换成了大写字母，其余字符转换成了小写字母。

字符串格式化

在Python中，我们可以使用字符串格式化来创建格式化的输出。字符串格式化允许我们将变量插入到字符串中，并按照指定的格式进行格式化。

百分号（%）格式化

百分号（%）格式化是一种最基本的字符串格式化方式。它使用类似于C语言中的printf()函数的格式化方式。例如：

name = "John"
age = 28
print("My name is %s, and I am %d years old." % (name, age))
# 输出: My name is John, and I am 28 years old.

在上面的例子中，我们使用了百分号（%）格式化将变量插入到字符串中，并按照指定的格式进行输出。其中%s表示字符串类型，%d表示整数类型。

format()方法

format()方法是一种更为灵活和强大的字符串格式化方式。它使用花括号（{}）作为占位符，并可以根据需要对占位符进行格式化。例如：

name = "John"
age = 28
print("My name is {}, and I am {} years old.".format(name, age))
# 输出: My name is John, and I am 28 years old.

在上面的例子中，我们使用了format()方法将变量插入到字符串中，并按照指定的格式进行输出。

在format()方法中，占位符可以带有参数。例如：

x = 3.14159265359
print("The value of x is {:.2f}".format(x))
# 输出: The value of x is 3.14

在上面的例子中，{:.2f}表示对变量x进行浮点数格式化，保留小数点后两位。

f-strings

Python 3.6引入了一种新的字符串格式化方式，即f-strings。f-strings使用花括号（{}）作为占位符，并在字符串前加上字母"f"。例如：

name = "John"
age = 28
print(f"My name is {name}, and I am {age} years old.")
# 输出: My name is John, and I am 28 years old.

在上面的例子中，我们使用了f-strings将变量插入到字符串中，并按照指定的格式进行输出。

f-strings也支持在占位符中添加参数。例如：

x = 3.14159265359
print(f"The value of x is {x:.2f}")
# 输出: The value of x is 3.14

在上面的例子中，{x:.2f}表示对变量x进行浮点数格式化，保留小数点后两位。

结论

本文介绍了Python中常用的字符串操作，包括创建和初始化字符串、字符串切片、字符串连接、字符串搜索和替换、字符串大小写转换、字符串格式化等方面。Python提供了丰富的内置函数和方法来处理字符串，使得字符串处理变得更加方便和高效。熟练掌握这些字符串操作，将有助于您在Python中进行文本处理、网络编程、数据库操作等应用领域的开发工作。

列表、元组和字典

Python是一种高级编程语言，它支持许多不同的数据类型，包括列表、元组和字典。这些数据类型在Python中被广泛地使用，并且非常重要。在本篇文章中，我们将详细介绍如何在Python中使用这三种数据类型。

列表

列表（List）是Python中最常用的数据类型之一。它可以存储任意数量的有序元素，并且可以动态地增加或删除元素。列表可以包含不同种类的数据，例如整数、浮点数、字符串等。

创建和初始化列表

在Python中，您可以使用方括号来创建一个列表，例如：

list1 = [1, 2, 3, 4, 5]

在上面的例子中，我们创建了一个包含5个整数的列表。

如果您想创建一个空的列表，可以使用空的方括号，例如：

list2 = []

在上面的例子中，我们创建了一个空的列表。

列表也可以使用内置函数list()来创建，例如：

list3 = list((1, 2, 3, 4, 5))

在上面的例子中，我们创建了一个包含5个整数的元组，并使用list()函数将其转换为列表。

访问列表元素

在Python中，您可以使用索引来访问列表中的元素。列表中的第一个元素的索引为0，第二个元素的索引为1，以此类推。例如：

list4 = [1, 2, 3, 4, 5]
print(list4[0])  # 输出: 1

在上面的例子中，我们使用索引0来访问列表中的第一个元素。

您还可以使用负数索引来访问列表中的元素。负数索引表示从列表的末尾开始计算，例如-1表示列表的最后一个元素。例如：

list5 = [1, 2, 3, 4, 5]
print(list5[-1])  # 输出: 5

在上面的例子中，我们使用负数索引-1来访问列表中的最后一个元素。

列表切片

Python中，您可以使用切片（Slicing）来获取列表的子列表。切片使用索引来指定要提取的子列表的范围。例如：

list6 = [1, 2, 3, 4, 5]
print(list6[1:3])  # 输出: [2, 3]

在上面的例子中，我们使用切片操作符（[:]）来获取列表中从索引1到索引3之间的元素，不包括索引3对应的元素。

如果您只指定一个索引，则切片将从该索引开始，一直提取到列表的末尾。例如：

list7 = [1, 2, 3, 4, 5]
print(list7[2:])  # 输出: [3, 4, 5]

此外，您还可以省略左边或右边的索引，这将使切片从列表的开头或末尾开始。例如：

list8 = [1, 2, 3, 4, 5]
print(list8[:3])  # 输出: [1, 2, 3]
print(list8[-3:])  # 输出: [3, 4, 5]

在上面的例子中，我们使用负数索引来指定要提取的子列表的范围。

修改列表元素

在Python中，列表是可变的数据类型，也就是说，您可以修改列表中的元素。例如：

list9 = [1, 2, 3, 4, 5]
list9[0] = 6
print(list9)  # 输出: [6, 2, 3, 4, 5]

在上面的例子中，我们使用索引0来修改列表中的第一个元素，将其从1改为6。

您还可以使用切片来修改列表中的多个元素。例如：

list10 = [1, 2, 3, 4, 5]
list10[1:3] = [6, 7]
print(list10)  # 输出: [1, 6, 7, 4, 5]

在上面的例子中，我们使用切片操作符（[:]）来修改列表中从索引1到索引3之间的元素，将它们从[2, 3]改为[6, 7]。

列表追加和插入元素

在Python中，您可以使用append()方法向列表末尾添加新元素。例如：

list11 = [1, 2, 3, 4, 5]
list11.append(6)
print(list11)  # 输出: [1, 2, 3, 4, 5, 6]

在上面的例子中，我们使用append()方法向列表末尾添加了一个新元素6。

如果您想在列表中的特定位置插入一个新元素，可以使用insert()方法。例如：

list12 = [1, 2, 3, 4, 5]
list12.insert(3, 6)
print(list12)  # 输出: [1, 2, 3, 6, 4, 5]

在上面的例子中，我们使用insert()方法在索引3处插入了一个新元素6。

列表删除元素

在Python中，您可以使用remove()方法从列表中删除指定的元素。例如：

list13 = [1, 2, 3, 4, 5]
list13.remove(3)
print(list13)  # 输出: [1, 2, 4, 5]

在上面的例子中，我们使用remove()方法从列表中删除元素3。

如果您想删除列表中特定位置的元素，可以使用del语句。例如：

list14 = [1, 2, 3, 4, 5]
del list14[2]
print(list14)  # 输出: [1, 2, 4, 5]

在上面的例子中，我们使用del语句从列表中删除了索引为2的元素。

列表的其它操作

在Python中，列表还有许多其他有用的操作。例如，您可以使用len()函数获取列表的长度（即元素的数量）。例如：

list15 = [1, 2, 3, 4, 5]
print(len(list15))  # 输出: 5

在上面的例子中，我们使用len()函数获取列表list15的长度。

您还可以使用in关键字来检查某个元素是否在列表中。例如：

list16 = [1, 2, 3, 4, 5]
print(3 in list16)  # 输出: True
print(6 in list16)  # 输出: False

在上面的例子中，我们使用in关键字检查元素3和6是否在列表list16中。

您还可以使用+运算符将两个列表合并为一个新列表。例如：

list17 = [1, 2, 3]
list18 = [4, 5, 6]
list19 = list17 + list18
print(list19)  # 输出: [1, 2, 3, 4, 5, 6]

在上面的例子中，我们使用+运算符将两个列表list17和list18合并为一个新列表list19。

列表的排序和反转

在Python中，您可以使用sort()方法对列表进行排序。例如：

list20 = [3, 1, 4, 2, 5]
list20.sort()
print(list20)  # 输出: [1, 2, 3, 4 , 5]

在上面的例子中，我们使用sort()方法对列表list20进行升序排序。

如果您想对列表进行降序排序，可以将reverse参数设置为True。例如：

list21 = [3, 1, 4, 2, 5]
list21.sort(reverse=True)
print(list21)  # 输出: [5, 4, 3, 2, 1]

在上面的例子中，我们使用sort()方法对列表list21进行降序排序。

如果您不想修改原始列表，可以使用sorted()函数来创建一个新的已排序列表。例如：

list22 = [3, 1, 4, 2, 5]
sorted_list = sorted(list22)
print(sorted_list)  # 输出: [1, 2, 3, 4, 5]
print(list22)  # 输出: [3, 1, 4, 2, 5]

在上面的例子中，我们使用sorted()函数创建了一个新的已排序列表sorted_list，而不改变原始列表list22。

您还可以使用reverse()方法来反转列表中的元素的顺序。例如：

list23 = [1, 2, 3, 4, 5]
list23.reverse()
print(list23)  # 输出: [5, 4, 3, 2, 1]

在上面的例子中，我们使用reverse()方法反转了列表list23中元素的顺序。

元组

元组（Tuple）是Python中另一个常用的数据类型。与列表不同，元组是不可变的，即一旦创建，就无法修改。元组可以存储任意数量的有序元素，包括整数、浮点数、字符串等。

创建和初始化元组

在Python中，您可以使用圆括号来创建一个元组，例如：

tuple1 = (1, 2, 3, 4, 5)

在上面的例子中，我们创建了一个包含5个整数的元组。

如果您想创建只包含一个元素的元组，必须在元素后面添加逗号，例如：

tuple2 = (1,)

在上面的例子中，我们创建了一个只包含一个整数1的元组。

元组也可以使用内置函数tuple()来创建，例如：

tuple3 = tuple((1, 2, 3, 4, 5))

在上面的例子中，我们创建了一个包含5个整数的元组，并使用tuple()函数将其转换为元组。

访问元组元素

在Python中，您可以使用索引来访问元组中的元素。元组中的第一个元素的索引为0，第二个元素的索引为1，以此类推。例如：

tuple4 = (1, 2, 3, 4, 5)
print(tuple4[0])  # 输出: 1

在上面的例子中，我们使用索引0来访问元组中的第一个元素。

您还可以使用负数索引来访问元组中的元素。负数索引表示从元组的末尾开始计算，例如-1表示元组的最后一个元素。例如：

tuple5 = (1, 2, 3, 4, 5)
print(tuple5[-1])  # 输出: 5

在上面的例子中，我们使用负数索引-1来访问元组中的最后一个元素。

元组切片

Python中，您可以使用切片来获取元组的子元组。切片使用索引来指定要提取的子元组的范围。例如：

tuple6 = (1, 2, 3, 4, 5)
print(tuple6[1:3])  # 输出: (2, 3)

在上面的例子中，我们使用切片操作符（[:]）来获取元组tuple6中索引为1到2（不包括3）的子元组。

元组的其它操作

在Python中，您可以使用len()函数获取元组中元素的数量。例如：

tuple7 = (1, 2, 3, 4, 5)
print(len(tuple7))  # 输出: 5

在上面的例子中，我们使用len()函数获取元组tuple7中元素的数量。

您还可以使用in关键字来检查某个元素是否在元组中。例如：

tuple8 = (1, 2, 3, 4, 5)
print(3 in tuple8)  # 输出: True
print(6 in tuple8)  # 输出: False

在上面的例子中，我们使用in关键字检查元素3和6是否在元组tuple8中。

与列表一样，元组也支持+运算符将两个元组合并为一个新元组。例如：

tuple9 = (1, 2, 3)
tuple10 = (4, 5, 6)
tuple11 = tuple9 + tuple10
print(tuple11)  # 输出: (1, 2, 3, 4, 5, 6)

在上面的例子中，我们使用+运算符将两个元组tuple9和tuple10合并为一个新元组tuple11。

字典

字典（Dictionary）是Python中另一个非常有用的数据类型。字典是一个无序的键值对集合，其中每个键都唯一地映射到一个值。字典可以存储任意数量的键值对，包括整数、浮点数、字符串等。

创建和初始化字典

在Python中，您可以使用大括号来创建一个字典。每个键值对之间用逗号分隔，键和值之间用冒号分隔。例如：

dict1 = {'apple': 3, 'banana': 5, 'orange': 2}

在上面的例子中，我们创建了一个包含三个键值对的字典，其中’apple’是键，3是值。

字典也可以使用内置函数dict()来创建，例如：

dict2 = dict(apple=3, banana=5, orange=2)

在上面的例子中，我们使用dict()函数创建了一个与dict1相同的字典。

访问字典元素

在Python中，您可以使用键来访问字典中的值。例如：

dict3 = {'apple': 3, 'banana': 5, 'orange': 2}
print(dict3['banana'])  # 输出: 5

在上面的例子中，我们使用键’banana’来访问字典中对应的值。

如果您尝试访问不存在的键，则会引发KeyError异常。例如：

dict4 = {'apple': 3, 'banana': 5, 'orange': 2}
print(dict4['pear'])  # 引发KeyError异常

在上面的例子中，我们尝试访问不存在的键’pear’，因此引发了KeyError异常。

为了避免引发KeyError异常，您可以使用get()方法来访问字典中的值。如果指定的键不存在，则返回None或指定的默认值。例如：

dict5 = {'apple': 3, 'banana': 5, 'orange': 2}
print(dict5.get('pear'))  # 输出: None
print(dict5.get('pear', 0))  # 输出: 0

在上面的例子中，我们使用get()方法访问字典中键’pear’对应的值。由于’pear’不存在于字典中，因此第一个调用返回None，而第二个调用返回指定的默认值0。

字典修改元素

在Python中，您可以使用键来修改字典中的值。如果键不存在，则会创建一个新的键值对。例如：

dict6 = {'apple': 3, 'banana': 5, 'orange': 2}
dict6['apple'] = 4
print(dict6)  # 输出: {'apple': 4, 'banana': 5, 'orange': 2}

dict6['pear'] = 1
print(dict6)  # 输出: {'apple': 4, 'banana': 5, 'orange': 2, 'pear': 1}

在上面的例子中，我们使用键’apple’来修改字典中对应的值，并使用键’pear’来创建一个新的键值对。

字典的其它操作

在Python中，您可以使用len()函数获取字典中键值对的数量。例如：

dict7 = {'apple': 3, 'banana': 5, 'orange': 2}
print(len(dict7))  # 输出: 3

在上面的例子中，我们使用len()函数获取字典dict7中键值对的数量。

您还可以使用in关键字检查某个键是否在字典中。例如：

dict8 = {'apple': 3, 'banana': 5, 'orange': 2}
print('banana' in dict8)  # 输出: True
print('pear' in dict8)  # 输出: False

在上面的例子中，我们使用in关键字检查键’banana’和’pear’是否在字典dict8中。

如果您想删除字典中的键值对，可以使用del语句。例如：

dict9 = {'apple': 3, 'banana': 5, 'orange': 2}
del dict9['apple']
print(dict9)  # 输出: {'banana': 5, 'orange': 2}

在上面的例子中，我们使用del语句删除了键’apple’对应的键值对。

集合

集合（Set）是Python中另一个常用的数据类型。集合是无序的元素集合，其中每个元素都是唯一的。集合可以存储任意数量的元素，包括整数、浮点数、字符串等。

创建和初始化集合

在Python中，您可以使用大括号来创建一个集合。每个元素之间用逗号分隔。例如：

set1 = {1, 2, 3, 4, 5}

在上面的例子中，我们创建了一个包含5个整数的集合。

如果您需要创建一个空集合，不能使用{}，因为这将创建一个空字典。相反，您可以使用内置函数set()来创建空集合，例如：

set2 = set()

在上面的例子中，我们使用set()函数创建了一个空集合。

访问集合元素

由于集合是无序的，因此不能使用索引来访问集合中的元素。相反，您可以使用in关键字检查某个元素是否在集合中。例如：

set3 = {1, 2, 3, 4, 5}
print(3 in set3)  # 输出: True
print(6 in set3)  # 输出: False

在上面的例子中，我们使用in关键字检查元素3和6是否在集合set3中。

集合的其它操作

在Python中，您可以使用len()函数获取集合中元素的数量。例如：

set4 = {1, 2, 3, 4, 5}
print(len(set4))  # 输出: 5

在上面的例子中，我们使用len()函数获取集合set4中元素的数量。

如果您想向集合中添加元素，可以使用add()方法。如果要向集合中添加多个元素，可以使用update()方法。例如：```python
set5 = {1, 2, 3}
set5.add(4)
print(set5) # 输出: {1, 2, 3, 4}

set5.update([5, 6, 7])
print(set5) # 输出: {1, 2, 3, 4, 5, 6, 7}


在上面的例子中，我们使用add()方法向集合set5中添加元素4，使用update()方法向集合set5中添加多个元素[5, 6, 7]。

如果您想从集合中删除元素，可以使用remove()或discard()方法。两者的区别在于，如果要删除的元素不存在于集合中，remove()方法会引发KeyError异常，而discard()方法不会。例如：

```python
set6 = {1, 2, 3, 4, 5}
set6.remove(3)
print(set6)  # 输出: {1, 2, 4, 5}

set6.discard(6)
print(set6)  # 输出: {1, 2, 4, 5}

在上面的例子中，我们使用remove()方法删除元素3，并使用discard()方法尝试删除元素6（该元素不存在于集合中）。

您还可以使用union()方法或|运算符将两个集合合并为一个新的集合。intersecti on()方法或&运算符可以获取两个集合的交集。difference()方法或-运算符可以获取两个集合的差集，即在第一个集合中但不在第二个集合中的元素。例如：

set7 = {1, 2, 3}
set8 = {2, 3, 4}

set9 = set7.union(set8)
print(set9)  # 输出: {1, 2, 3, 4}

set10 = set7.intersection(set8)
print(set10)  # 输出: {2, 3}

set11 = set7.difference(set8)
print(set11)  # 输出: {1}

在上面的例子中，我们使用union()方法将集合set7和set8合并为一个新的集合set9，使用intersection()方法获取set7和set8的交集，使用difference()方法获取set7和set8的差集。

总结

本文介绍了Python中常用的三种数据类型：列表、元组和字典。列表是有序的元素集合，可以包含任意数量的元素。元组是有序的元素集合，与列表类似，但一旦创建就不能修改。字典是无序的键值对集合，每个键都唯一地映射到一个值。本文还简要介绍了另一个常用的数据类型——集合，它是无序的元素集合，每个元素都是唯一的。通过学习本文，您应该已经掌握了在Python中使用这些常用数据类型的基本操作。

posted @ 2023-04-01 20:34  Kali与编程  阅读(36)  评论(0)  编辑  收藏  举报  来源