Python 变量和数据类型

最新推荐文章于 2024-07-12 19:06:42 发布

Kali与编程～

最新推荐文章于 2024-07-12 19:06:42 发布

阅读量858

点赞数 17

文章标签： python 开发语言

本文链接：https://blog.csdn.net/xiao1234oaix/article/details/136648791

版权

预计更新

第一章. 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中，标识符有以下几种规定：

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

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

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

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

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

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

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

数字（Numbers）

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

整数（int）：用于表示没有小数部分的数值，可以是正数、负数或零。
浮点数（float）：用于表示有小数部分的数值，也可以是正数、负数或零。
复数（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)

字符串（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()等，用于操作和处理字符串数据。

布尔值（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

列表（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()等。

元组（Tuples）

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

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

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

集合（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}

字典（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中使用这些常用数据类型的基本操作。

Kali与编程～

关注

17
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python 变量和数据类型

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

扫一扫