语法基础和数据类型

标识符

在 Python 编程语言中，理解标识符和变量的概念对于编写高效、易读的代码至关重要。以下是关于标识符和变量的详细解析，旨在为初学者提供清晰的指南。

标识符的基本规则

组成：标识符可以由字母、数字以及下划线（_）组成。
开头：标识符的第一个字符不能是数字，可以是字母或下划线。
区分大小写：在 Python 中，标识符是区分大小写的。例如，ABC 和 abc 被视为两个不同的标识符。
作用：标识符用作变量名、函数名、方法名等，是对程序中某些实体的命名。

变量

变量的概念

定义：变量是程序中用于存储数据的标识符。Python 通过变量名访问这块存储单元。
命名规则：变量名遵循标识符的命名规则，但不能使用 Python 的保留字（关键字）作为变量名。
关键字查询：Python 的标准库提供了一个 keyword 模块，可以用来查看当前 Python 版本的所有关键字。

变量使用注意事项

类型声明：Python 是动态类型语言，变量不需要事先声明类型。
赋值前必须初始化：变量在使用前必须被赋值，变量的赋值操作同时也是变量声明的过程。
值可变性：变量的值可以随时修改，Python 中的变量更像是数据的引用而非数据存储的实体。
数据类型：变量的数据类型是根据赋值的数据类型自动确定的。
赋值运算符：Python 使用 = 作为赋值运算符，赋值的顺序是从右向左。
多变量赋值：Python 支持同时为多个变量赋值，例如 a, b, c = 1, 2, "python"。

实用示例

查看所有关键字：

import keyword
print(keyword.kwlist)

变量赋值与使用：

# 单个变量赋值
x = 10

# 多变量同时赋值
a, b, c = 5, 3.2, "Hello"

# 交换两个变量的值
a, b = b, a

避免与关键字冲突的命名：

# 错误的命名，因为 if 是一个关键字
if = 10  # 这将引发语法错误

# 正确的命名
if_condition = 10

在 Python 中，理解基础数据类型、输入输出操作以及代码的基本结构对于编写有效且易于理解的程序至关重要。以下是关于 Python 数据类型转换、输入输出操作、注释、缩进和导入模块等方面的专业整理。

Python 数据类型转换

Python 支持多种数据类型的转换，使用以下内置函数：

int(): 将数据转换为整型 (int)，适用于字符串、浮点数等。
str(): 将数据转换为字符串 (str) 类型，适用于数字等。
float(): 将数据转换为浮点数 (float) 类型，适用于字符串、整数等。
complex(x): 将 x 转换为复数，实数部分为 x，虚数部分为 0。
complex(x, y): 将 x 和 y 转换为复数，实数部分为 x，虚数部分为 y。

输入

使用 input(prompt) 函数读取用户的键盘输入，返回值为字符串类型。

示例：创建一个简单的加法程序。

num1 = input("请输入一个数字: ")
num2 = input("请再输入一个数字: ")
print(int(num1) + int(num2))

输出

print 函数：用于在屏幕上显示文本、变量或其他类型的数据。
支持直接打印文本（中文需要加引号）、数学表达式、变量等。
空格与连接：使用 , 会自动在变量间添加空格，使用 + 连接时不添加空格。
英文大小写转换：title() 将字符串首字母大写，upper() 转换为全大写，lower() 转换为全小写。
不换行输出：使用 end 参数指定结尾字符，默认为换行符 \n。
指定分隔符：使用 sep 参数定义输出间的分隔符，默认为空格。

注释

单行注释：以 # 开头。
多行注释：使用三个单引号 ''' 或三个双引号 """ 包裹。

行与缩进

Python 使用缩进来定义代码块，而非大括号 {}。
同一代码块的语句必须具有相同的缩进空格数。
不一致的缩进会导致 IndentationError。

多行语句

多行语句可以使用反斜杠 \ 实现。
在 []、{}、() 中的语句不需要使用反斜杠。

同一行显示多条语句

Python 允许在同一行中使用多条语句，语句之间使用分号 ; 分割。

import 与 from…import

导入模块：使用 import modulename 或 from modulename import functionname。
安装模块：如果需要安装外部模块，可以使用 pip install modulename 命令。

Python 作为一门强大的编程语言，提供了丰富的数字运算能力，涵盖了从基本的算术运算到复杂的数学计算。本文档旨在全面概述 Python 中的数字运算，包括算术运算、位运算、比较运算，以及使用数学模块进行高级数学运算的方法。

算术运算

Python 支持的基本算术运算符包括：

加法 (+)
减法 (-)
乘法 (*)
除法 (/)
整数除法 (//)：返回除法运算结果的整数部分。
取余 (%)
指数 (**)：进行幂运算。

示例代码：

print(2 + 2)  # 加法
print(50 - 5 * 6)  # 减法
print((50 - 5 * 6) / 4)  # 除法
print(8 / 5)  # 除法总是返回一个浮点数

位运算

位运算符对整数在内存中的二进制位进行操作：

按位与 (&)
按位或 (|)
按位异或 (^)
按位取反 (~)
左移 (<<)
右移 (>>)

比较运算

Python 中的比较运算符包括：

等于 (==)
不等于 (!=)
大于 (>)
小于 (<)
大于等于 (>=)
小于等于 (<=)

数学模块 (`math`)

Python 的标准库中的 math 模块提供了许多常见的数学函数和常量。

常量：如 math.pi (圆周率) 和 math.e (自然对数的底数)。
函数：如 math.sqrt(x) (平方根)、math.floor(x) (向下取整)、math.ceil(x) (向上取整)、math.exp(x) (指数函数)、math.log10(x) (对数函数) 等。

示例代码：

import math

print("圆周率：", math.pi)
print("自然对数的底数：", math.e)

x = 2.5
y = 3.7

print(x, "的平方根：", math.sqrt(x))
print(y, "的向下取整值：", math.floor(y))

注意

浮点运算的结果可能会因机器而异，这是由于计算机内部对浮点数的表示和四舍五入误差有关。
整数和浮点数混合运算时，整数将被转换为浮点数。

给变量赋值

使用等号 (=) 对变量进行赋值。Python 中的变量不需要声明类型，解释器会根据赋值自动确定类型。

运算符

Python算术运算符

以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方，输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	`>>> 9//2 4 >>> -9//2 -5`

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 True。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：将二进制表示中的每一位取反，0 变为 1，1 变为 0。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011 (以补码形式表示)，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔”或” - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注意

id() 函数用于获取对象内存地址。

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ \|	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

数据类型

Python数据类型分为三大类：

数值类型
序列类型
散列（映射）类型

一数值类型

这些类型都是不可变的。

1. 整数类型 int

什么是整数？

由0-9组成的数都叫整数

# 0 1 2 3 4 5 6 7 8 9
a = 0

2. 浮点数类型 float

什么是浮点数？

有小数点的数叫浮点数也就是我们数学中说的小数

# 10.1
# 10.0
# 10.25
a = 10.1

3. 布尔类型 bool

什么是布尔类型？

布尔类型代表真假
只有两个值
布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
在Python中，布尔类型实际上是整型（int）的子类，因此布尔值在某些情况下可以与数字进行操作，并被视为数字 1（True）和 0（False）。与其他数值类型一样，布尔类型也是不可变的，它有两个值：True 和 False
- True 真
  1
  2
  True
  a = True # 1
- False 假
  1
  2
  False
  a = False # 0

注意

在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

4. 复数 complex

复数在Python中也是一种数值类型，用于表示具有实部和虚部的数。在数学中，复数通常写作 a + bj，其中 a 是实部，b 是虚部，而 j（在Python中用 j 或 J 表示）是虚数单位。

实部（Real Part）：这是复数中的常规数字部分，没有乘以虚数单位。
虚部（Imaginary Part）：这部分乘以虚数单位 j。在数学上，j 是一个特殊的值，其平方等于 -1。

在Python中，可以使用 complex(real, imag) 函数或直接用 real + imagj 表式来创建复数。例如

# 使用 complex 函数
c1 = complex(2, 3)  # 创建复数 2 + 3j

# 直接定义
c2 = 2 + 3j  # 同样创建复数 2 + 3j

5. 算术运算符

加法运算符（+）：用于对两个数值或字符串进行相加操作。
减法运算符（-）：用于对两个数值进行相减操作。
乘法运算符（*）：用于对两个数值进行相乘操作。
除法运算符（/）：用于对两个数值进行相除操作。

二序列类型

非常常见的一种数据类型，它表示一组按照一定顺序排列的值的集合

序列类型的基本介绍

1. 字符串 str

写在单引号、双引号的内容被称为字符串类型。可以随便写任何内容、小数、特殊符号、文字不能修改里面的数据

特点：可以存任意内容，不能修改

写法：

单引号

'我是字符串 随便写什么内容 @！123123'
# 示例：
a = '我是字符串 随便写什么内容 @！123123'

双引号

"我是字符串 随便写什么内容 @！123123"
# 示例：
a = "我是字符串 随便写什么内容 @！123123"

有没有区别？
- 没有区别

反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。如 r”this is a line with \n” 则 \n 会显示，并不是换行。
按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
字符串可以用 + 运算符连接在一起，用 ***** 运算符重复。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
Python 中的字符串不能改变。
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
索引值以 0 为开始值，**-1** 为从末尾的开始位置

Python字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符	描述	实例
+	字符串连接	>>>a + b ‘HelloPython’
*	重复输出字符串	>>>a * 2 ‘HelloHello’
[]	通过索引获取字符串中字符	>>>a[1] ‘e’
[ : ]	截取字符串中的一部分	>>>a[1:4] ‘ell’
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>”H” in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>”M” not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母”r”（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r’\n’ \n >>> print R’\n’ \n

2. 列表 list

可以存储多个值，每个数据用逗号分隔可以修改存储的数据，数据是可以修改的

特点：存多个值、可修改
写法：

[1, '武松', 12.3, True]
# 示例：
a = [1, '武松', 12.3, True]

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

Python列表截取

描述：

Python 表达式	结果	描述
L[2]	‘Taobao’	读取列表中第三个元素
L[-2]	‘Runoob’	读取列表中倒数第二个元素
L[1:]	[‘Runoob’, ‘Taobao’]	从第二个元素开始截取列表

3. 元组 tuple

可以存储多个值，每个数据用逗号分隔，不可以修改里面的数据

特点：存多个值、不可以修改
写法：

(1, '武松', 12.3, True)
# 示例
a = (1, '武松', 12.3, True)

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

Python 表达式	结果	描述
L[2]	‘SPAM!’	读取第三个元素
L[-2]	‘Spam’	反向读取，读取倒数第二个元素
L[1:]	(‘Spam’, ‘SPAM!’)	截取元素

序列类型的方法

1. 索引

作用：
		取序列类型的一个元素
	从左往右取值 从0开始：

# 以变量a为例子
a = '我真的很帅'

字符	我	真	的	很	帅
索引	0	1	2	3	4

a[0] # 我
a[1] # 真
a[2] # 的
a[3] # 很
a[4] # 帅

从右往左取值从-1开始

# 以变量a为例子
a = '我真的很帅'

字符	我	真	的	很	帅
索引	-5	-4	-3	-2	-1

2. 切片

作用：
		取序列类型的多个元素
	如何使用？

[形参1:形参2:形参3]
# 形参1 是从索引几开始
# 形参2 是到索引几结束 但是不包含当前索引
# 形参3 是步长 根据索引每次走几步
a = '我真的很帅'
print(a[0:3:1]) # 我真的
print(a[0:3:2])	# 我的

3. 类型切换

列表转字符串

假设有一个列表 my_list，可以使用 join() 函数将其元素连接成一个字符串。join() 函数需要一个字符串作为分隔符，用来连接列表中的元素。

my_list = ['apple', 'banana', 'cherry']
my_string = ', '.join(my_list)
print(my_string)  # 输出: apple, banana, cherry

使用字符串连接

lst = [1, 2, 3, 4, 5]
result_str = ""
for item in lst:
    result_str += str(item)  # 转换每个元素为字符串并连接

使用列表推导和字符串连接

lst = [1, 2, 3, 4, 5]
result_str = ''.join([str(item) for item in lst])

使用 join 和映射（map）

lst = [1, 2, 3, 4, 5]
result_str = ''.join(map(str, lst))

元组转字符串

对于元组，方法与列表类似。假设有一个元组 my_tuple，同样可以使用 join() 函数。

my_tuple = ('apple', 'banana', 'cherry')
my_string = ', '.join(my_tuple)
print(my_string)  # 输出: apple, banana, cherry

注意事项

如果列表或元组中包含非字符串类型（如整数或浮点数），则需要先将它们转换为字符串，然后才能使用 join() 函数。例如，对于一个整数列表 my_list = [1, 2, 3]，可以使用列表推导式 [str(x) for x in my_list] 将其转换为字符串列表，然后再使用 join()。
join() 函数中的分隔符可以是任何字符串，包括空字符串。
str(my_list)：提供列表的完整文本表示，包括方括号和元素引号。
str(my_tuple)：提供元组的完整文本表示，包括圆括号和元素引号。
join()：用于将列表或元组中的字符串元素连接成一个单一的、格式化的字符串，不包括列表的结构标记，如方括号。需要列表元素都是字符串类型。

字符串转列表

使用 split() 方法可以将字符串分割成列表。需要指定一个分隔符，它将字符串在每个分隔符处分割。

例如，有一个以逗号分隔的字符串，可以这样将其转换为列表：

my_string = "apple, banana, cherry"
my_list = my_string.split(", ")
print(my_list)  # 输出: ['apple', 'banana', 'cherry']

如果字符串没有明显的分隔符，split() 方法将默认以空格作为分隔符。

字符串转元组

将字符串转换为元组的过程与转换为列表类似，只是在分割字符串之后，需要将得到的列表转换为元组。这可以通过将列表作为参数传递给 tuple() 函数来实现。

例如：

my_string = "apple, banana, cherry"
my_list = my_string.split(", ")
my_tuple = tuple(my_list)
print(my_tuple)  # 输出: ('apple', 'banana', 'cherry')

注意事项

如果字符串中包含特殊字符或格式复杂，可能需要使用更复杂的方法（如正则表达式）来正确分割字符串。
分隔符应根据字符串的实际内容选择。如果选择错误的分隔符，结果可能不会按预期分割。

信息

.join() 是 Python 中的一个字符串方法，用于将序列中的元素连接成一个新的字符串。这个方法是非常有用的，尤其是在需要将多个字符串元素组合成一个单一字符串的情况下。下面详细介绍这个方法的工作原理和使用方式。

工作原理

.join() 方法被调用的对象必须是一个字符串，这个字符串会成为元素之间的连接符。
它接受一个参数，这个参数是一个包含字符串元素的序列（如列表、元组、集合或任何可迭代对象）。
方法将序列中的每个元素合并成一个字符串，元素之间插入调用 .join() 的字符串。

基本用法

假设有一个列表 ['a', 'b', 'c']，你想将其连接成一个字符串，每个元素之间用逗号分隔：

elements = ['a', 'b', 'c']
result = ','.join(elements)
print(result)  # 输出: a,b,c

在这个例子中，.join() 被逗号字符串 ',' 调用，因此它会在列表 elements 中的每个元素之间插入逗号。

注意事项

序列中的元素必须是字符串。如果序列中包含任何非字符串类型（如整数或浮点数），则会引发 TypeError。在这种情况下，你需要先将元素转换为字符串，通常可以通过列表推导和 str() 函数实现。
如果序列为空，.join() 返回一个空字符串。

示例

将数字列表转换为逗号分隔的字符串：

numbers = [1, 2, 3, 4, 5]
# 将数字转换为字符串
string_numbers = [str(num) for num in numbers]
result = ','.join(string_numbers)
print(result)  # 输出: 1,2,3,4,5

在这个例子中，我们首先使用列表推导将数字列表 numbers 转换为字符串列表 string_numbers。然后使用 .join() 方法来连接这些字符串。

使用场景

连接日志文件的多行。
生成或解析CSV文件。
创建查询字符串或URL。

.join() 是一个非常实用的方法，尤其在处理字符串和文本处理时非常有用。它的效率通常比传统的字符串连接（使用 + 操作符）要高，尤其是在处理大量字符串时。

三序列类型方法

什么是方法？

方法是对象的属性，是一种可以对对象进行操作的

函数

为什么使用方法？

使用方法可以让代码更加模块化和可复用。通过把一些操作封装在方法中，我们可以更方便地对数据进行处理，也可以避免代码的重复和冗余。同时，方法的使用也可以使代码更易读、易懂和易维护。

列表、元组、字符串方法？

用来对里面的数据进行增删改查

1.我们可以把

列表、字符串和元组、分别理解为三个英雄

2.它们都有

对应的方法、方法也就是英雄的技能、

3.使用

英雄的技能可以快速杀敌

4.使用方法能快速的进行数据的

增删改查

列表

1. 增加示例

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表

# 内置方法：
# 增加
# 1. append 方法 在列表末尾添加一个元素
# 添加 '这是添加物'
a.append('这是添加物') # 通过append 这个方法 向 变量a 增加了 这是添加物
print(a)	# ['这', '是', '一', '个', '列', '表', '这是添加物']

# 2. insert 方法 在列表指定位置插入元素
# 插入'这是插入物'
a.insert(1, '这是插入物')
print(a)	# ['这', '这是插入物', '是', '一', '个', '列', '表', '这是添加物']

# 3. extend 方法 在列表末尾添加另一个列表的所有元素
# 添加列表
b = ['这', '是', '另', '一', '个', '列', '表']
a.extend(b)
print(a) #['这', '这是插入物', '是', '一', '个', '列', '表', '这是添加物', '这', '是', '另', '一', '个', '列', '表']

2. 删除示例

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 删除
# 4. pop 方法 通过索引移除列表中的一个元素（默认最后一个），并返回该元素的值
a.pop(3)
print(a) # ['这', '是', '一', '列', '表']

# 5. remove 方法 通过元素移除列表中的一个元素
a.remove('一')
print(a) #['这', '是', '个', '列', '表']

# 6. clear 方法 移除列表的所有元素
a.clear()
print(a) #[]

3. 修改示例

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 7. 直接在对于索引修改用 '='
a[0] = '不'
print(a) #['不', '是', '一', '个', '列', '表']

4. 查询示例

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 8. index 方法 返回指定元素在列表第一次出现的索引位置
result = a.index('一')
print(result) # 2

# 9. count 方法 返回指定元素在列表出现的次数
result = a.count('列')
print(result) # 1

5. 其它示例

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 10. copy 方法 复制一份变量的内容
result = a.copy()
print(result) # ['这', '是', '一', '个', '列', '表']

# 11. reverse 方法 反转列表的元素
a.reverse()
print(a)  # ['表', '列', '个', '一', '是', '这']

b = [89, 5, 43, 38, 34, 78]	# 创建一个变量名b，存储列表用于排序
# 12. sort方法 从小到大排序列表
b.sort()
print(b) # [5, 34, 38, 43, 78, 89]
# reverse = True 则从大到小 
b.sort(reverse = True)
print(b) # [89, 78, 43, 38, 34, 5]

注意

1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

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

元组

1. 查询示例

a = ('这', '是', '一', '个', '元', '组')	# 创建一个变量名a，这是一个元组
# 1. count 方法 返回指定元素在元组出现的次数
result = a.count('列')
print(result) # 1

# 2. index 方法 返回指定元素在元组第一次出现的索引位置
result = a.index('一')
print(result) # 2

# 3. len 方法 返回元组中元素的个数
result = len(a)
print(result) # 6

2. 添加示例

a = ('这', '是', '一', '个', '元', '组')	# 创建一个变量名a，这是一个元组
b = ('这', '是', '另', '一', '个', '元', '组')	# 创建一个变量名b，这是另一个元组
# 4. 合并两个元组为一个元组
print(a + b) #['这', '是', '一', '个', '元', '组', '这', '是', '另', '一', '个', '元', '组']

# 5. 将元组重复指定次数
print(a * 4) # ['这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组']

3. 内置方法

c = (1, 2, 3)	# 创建一个变量名c，1,2,3
# 6. max 方法 返回元组中元素的最大值
print(max(c)) # 3

# 7. min 方法 返回元组中元素的最小值
print(min(c)) # 1

d = '12345'
# 8. tuple 方法 将列表或者其它可迭代对象转成元组
print(tuple(d)) # ('1', '2', '3', '4', '5')

字符串

1. 删除示例

# 1. replace 把对象中有的值放到第一个参数中替换成第二个参数
a = '值1'
b = a.replace('1','2')
print(a) # 值1, 字符串不允许被修改
print(b) # 值2，修改结果存储到新的变量b

2. 修改示例

# 2. upper 把所有字符串字母改成大写
a = 'asd'
result = a.upper()
print(result) # ASD

# 3. lower 把所有字符串字母改成小写
a = 'ASD'
result = a.lower()
print(result) # asd

# 4. strip 去除字符串首尾指定字符，不传参默认空格
a = 'AsAA'
result = a.strip('A')
print(result) # s

3. 查询示例

a = '这是一个字符串'	# 创建一个变量名a，这是一个字符串
# 5. count 方法 返回指定元素在字符串出现的次数
result = a.count('一')
print(result) # 1

# 8. find 方法 如果包含子字符串返回开始的索引值，否则返回-1
result = a.find('一')
print(result) # 2

# 7. index 方法 返回指定元素在字符串第一次出现的索引位置，没有则报错
result = a.index('一')
print(result) # 2

4. 转义示例

# 8. \n 换行
a = '这是一个\n字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个
       		#字符串
  
# 9.  \t 水平制表符/空格
a = '这是一个\t字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个	字符串

# 10. \b 退格
a = '这是一个\b字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一字符串

# 11. \r 回车，当前位置回到开头，会把前面整个去掉
a = '这是一个\r字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#字符串

# 12. \\ 反斜杠
a = '这是一个\\字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个\字符串

# 13. \' 单引号
a = '这是一个\'字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个'字符串

# 14. \0 空字符
a = '这是一个\0字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个 字符串

# 15. \a 系统提示音
a = '这是一个\a字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个字符串

5. 拼接示例

# 16. + 拼接方法
a = '这是'
b = '字符串'

print(a + b) # 这是字符串 

# 17. join 拼接方法
a = ['2023', '12', '02'] # 列表
result = '-'.join(a)
print(result) # 2023-12-02 结果会变为字符串

# 18. format 拼接方法
a = '这是'
b = '一个'
result = '{}{}字符串'.format(a, b) # 插入多个值有顺序关系与{}一一对应
print(result) # 这是一个字符串

# 19. f插值法
a = '这是'
b = '一个'
print(f"{a}{b}字符串") # 这是一个字符串

6. 编码和解码

# 编码
name = "字符串"  # 定义一个变量叫name 存储字符串
encode_result = name.encode("UTF-8")  # 通过encode进行编码为UTF-8
print(encode_result)  # 结果为b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
# "意味着字符串"在utf8中为\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2,其中b是二进制的意思

# 解码
decode_result = encode_result.decode("UTF-8")
print(decode_result) # 字符串

四散列（映射）类型

集合和字典

集合、字典方法

用来对里面的数据进行增删改查

我们可以把集合、字典、分别理解为二个英雄
它们都有对应的方法、方法也就是英雄的技能、
使用英雄的技能可以快速杀敌
使用方法能快速的进行数据的增删改查

1. 集合 set

集合的特点：

不重复
里面有字符串的话就是无规则排序
没有字符串则按照输入的顺序排序
集合不能取值，因为是无序的，因为索引只在序列类型不在散列类型

d = {"字符串2", 1, 2, 3, 2, "字符串1"}
print(d) # {1, 2, 3, '字符串2', '字符串1'}

增加：

d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
# 1. add 方法 将元素无序添加到集合中去
d.add('添加的字符串')
print(d) # {1, 2, 3, '字符串1', '添加的字符串', '字符串2'}

删除：

d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
# 2. pop 方法 随机删除一个元素
result = d.pop()
print("被删除的元素是：", result) # 被删除的元素是： 1
print("被删除后的集合结果：", d) # 被删除后的集合结果： {2, 3, '字符串2', '字符串1'}

# 3. remove 方法 删除指定元素，变量a里面没有的元素，就会报错
d.remove(2)
print(d) # {1, 3, '字符串2', '字符串1'}

# 4. update 方法 将另一个集合的元素随机且不重复添加到当前的集合中
d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
e = {"另外一个字符串3", "另外一个字符串4", 5, 5, 7, 8} # 变量d存储集合
d.update(e)
print(d) # {1, 2, 3, '字符串1', 5, '另外一个字符串4', 7, 8, '字符串2', '另外一个字符串3'}

2. 字典 dict

字典的特点：

存值的方式以键值对的方式存储
可以取值不能用索引

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

# 利用key来取值
print(a['key1'])  #value1

增加：

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

#5. setdefault 有则查，无则增
a.setdefault('key3', 'value2')
print(a) # {'key1': 'value1', 'key2': 12, 'key3': 'value2'} 增加
print(a.setdefault('key2')) # 12 查询

删除：

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

#6. pop 删除指定key的键值对
a.pop('key1') # 删除了变量a中的key1
print(a) # {'key2': 12}

# 7. popitem 返回并删除字典中的最后一对键和值
a.popitem() # 删除了变量a中的key2
print(a) # {'key1': 'value1'}

修改：

# 键值对
# 8. update 用于将一个字典中的键值对添加到另一个字典中
a = {
    #  'key' 键 所有的键都要用引号
    #  'value' 值 任意定义
    #  冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

b = {
    #  'key' 键 所有的键都要用引号
    #  'value' 值 任意定义
    #  冒号 作用分割 左右两边
    'key3': 'value3'
}

a.update(b) # 将字典b的值update 写到这个变量a中去
print(a) # {'key1': 'value1', 'key2': 12, 'key3': 'value3'}

查询：

a = {
    #      'key' 键 所有的键都要用引号
    #      'value' 值 任意定义
    #      冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

# 9. get 获取指定key对应的value，如果key不存在返回none
print(a.get('key1')) # value1

# 10. keys 取出所有的key
print(a.keys()) # dict_keys(['key1', 'key2'])

# 11. values 取出所有的values
print(a.values()) # dict_values(['value1', 12])

# 12. items 取出所有完整的键值对
print(a.items()) # dict_items([('key1', 'value1'), ('key2', 12)])

3. 区别

都是花括号，但是存值方式
集合是一个一个存，用逗号, 分割，无序不重复，不能取值
字典以键值对的方式存储，应用场景更多，可以取值

冻结集合

冻结集合（Frozen Set）是Python中的一个内置类型，它与普通集合（Set）类似，但有一个关键的区别：冻结集合是不可变的。这意味着一旦创建了冻结集合，就不能再添加或删除其中的元素。这种特性使得冻结集合成为一种特殊的、不可更改的集合类型。

特性和用途

不可变性（Immutability）：
- 冻结集合一旦创建，其内容不能被更改。这包括不能添加新元素，也不能从集合中删除元素。
可哈希性（Hashability）：
- 由于其不可变性，冻结集合是可哈希的（hashable），这意味着它们可以用作字典的键或另一个集合的元素。普通集合由于是可变的，不能被哈希，因此不能用在这些场景中。
支持集合操作：
- 冻结集合支持普通集合的各种操作，如并集、交集、差集和对称差集等。

创建冻结集合

冻结集合可以通过内置的 frozenset() 函数创建。例如：

# 创建一个空的冻结集合
f_set = frozenset()

# 从现有集合创建冻结集合
normal_set = {1, 2, 3}
f_set_from_normal = frozenset(normal_set)

# 从其他可迭代对象创建冻结集合
f_set_from_list = frozenset([4, 5, 6])

使用场景

由于其不可变性和可哈希性，冻结集合特别适用于以下场景：

作为字典的键。
作为另一个集合的元素。
在需要保证集合内容不被更改的情况下使用。

与普通集合的比较

普通集合：可变，支持添加和删除操作，不可哈希，不能用作字典的键或集合的元素。
冻结集合：不可变，不支持添加和删除操作，可哈希，可以用作字典的键或集合的元素。

总结

问：

哪种数据类型属于可变数据类型？

答：

在Python中，数据类型可以分为几种主要类别，如数值类型、序列类型和散列（映射）类型。在这些类别中，并不是只有列表是可变的。让我们逐一看看这些类型中的可变性：

数值类型（Numeric Types）:
- 这些包括整型（int）、浮点型（float）和复数（complex）。这些类型都是不可变的。
序列类型（Sequence Types）:
- 列表（List）: 这是可变的。你可以在列表中添加、删除或更改元素。
- 字符串（String）和元组（Tuple）: 这些是不可变的。一旦创建，你不能更改其内部的元素或字符。
散列类型（Mapping Types）:
- 字典（Dictionary）: 字典是可变的。你可以在字典中添加、删除或修改条目。

还有其他的类型，比如集合类型（Set Types），其中：

集合（Set） 是可变的，可以添加或删除元素。
冻结集合（Frozen Set） 是不可变的。

综上所述，在这些主要的数据类型中，列表、字典和集合是可变的，而数值类型、字符串、元组和冻结集合是不可变的。

角灯随笔

语法基础和数据类型

标识符

标识符的基本规则

变量

变量的概念

变量使用注意事项

实用示例

Python 数据类型转换

输入

输出

注释

行与缩进

多行语句

同一行显示多条语句

import 与 from…import

算术运算

位运算

比较运算

数学模块 (math)

给变量赋值

运算符

Python算术运算符

Python比较运算符

Python赋值运算符

Python位运算符

Python逻辑运算符

Python成员运算符

Python身份运算符

Python运算符优先级

数据类型

一 数值类型

1. 整数类型 int

2. 浮点数类型 float

3. 布尔类型 bool

4. 复数 complex

5. 算术运算符

二 序列类型

序列类型的基本介绍

1. 字符串 str

Python字符串运算符

2. 列表 list

Python列表脚本操作符

Python列表截取

3. 元组 tuple

元组运算符

元组索引，截取

序列类型的方法

1. 索引

2. 切片

3. 类型切换

列表转字符串

元组转字符串

注意事项

字符串转列表

字符串转元组

注意事项

三 序列类型方法

什么是方法？

为什么使用方法？

列表、元组、字符串方法？

列表

1. 增加示例

2. 删除示例

3. 修改示例

4. 查询示例

5. 其它示例

元组

1. 查询示例

2. 添加示例

3. 内置方法

字符串

1. 删除示例

2. 修改示例

3. 查询示例

4. 转义示例

5. 拼接示例

6. 编码和解码

四 散列（映射）类型

集合和字典

数学模块 (`math`)

一数值类型

二序列类型

三序列类型方法

四散列（映射）类型