Python的数据类型讲座

分手后的思念是犯贱 2022-11-29 12:09 161阅读 0赞

### Python的数据类型讲座 ###

Python中的每个值都有一个数据类型。因为在Python编程中，所有的东西都是一个对象，数据类型实际上是类，变量是这些类的实例（对象）。

在python中的数据类型： numbers（数字）、string（字符串）、list（列表）、tuple（元组）、dictionary（字典）、集合（set）。

python的数据类型根据其结构划分为两类：原子类型和结构类型。

原子类型是python中最简单的一种数据类型，或者说是python中最原始的数据类型，仅包含一种值的集合：数字型或字符串型；结构类型则是包含多种值，结构较复杂的集合。python中常见的结构类型可以统称为容器类型的数据（或简称容器），序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。

数据类型分类：

![20210513215726978.png][]

或

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

或

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1][]

【在 CPython 中，id(x) 就是存放 x 的内存的地址。  
对象的类型决定该对象所支持的操作 (例如 "对象是否有长度属性？") 并且定义了该类型的对象可能的取值。type() 函数能返回一个对象的类型 (类型本身也是对象)。与编号一样，一个对象的 类型 也是不可改变的。  
有些对象的 值 可以改变。值可以改变的对象被称为 可变的；值不可以改变的对象就被称为 不可变的。(一个不可变容器对象如果包含对可变对象的引用，当后者的值改变时，前者的值也会改变；但是该容器仍属于不可变对象，因为它所包含的对象集是不会改变的。因此，不可变并不严格等同于值不能改变，实际含义要更微妙。) 一个对象的可变性是由其类型决定的；例如，数字、字符串和元组是不可变的，而字典和列表是可变的。[https://docs.python.org/zh-cn/3.9/reference/datamodel.html][https_docs.python.org_zh-cn_3.9_reference_datamodel.html]】

**numbers（数字）**

numbers（数字）数据类型用于存储数值Python支持的数字类型：int（整型）、float（浮点型）、complex（复数）。

int（整型）

相比于其他语言的整数的取值范围由机器位数（32位或64位）决定，python整数的取值范围，仅与机器支持的内存大小有关，也就是说Pyhton可以表示很大的数，可以超过机器位数所能表示的数值范围。python3中整型的长度，理论上可以说是不受限制（受计算机内存的限制，不是真正的无限大，但其长度足以供我们的日常使用）。Python的整数，包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

二进制、八进制、十六进制表示方式

二进制

以0b或0B开始，后续数码0，1，如0b1101

第一字母是0（零）第二字母是b，小写或者大写。

八进制

以0o或0O开始，后续数码0~7，如0o71

第一字母是0（零）第二字母是o，小写或者大写。

十六进制

以0x或0X开始，后续数码0~9，A~F，如0xA2

第一字母是0（零）第二字母是x，小写或者大写。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2][]

下面给出运行示例，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3][]

int()     函数用于将一个字符串或数字转换为整型

语法

int(x, base)

参数

x    字符串或数字。

base 进制数，默认（缺省）十进制。

不带参数时，得到结果0；对带小数的数值，得到结果舍弃小数部分；带参数base的话，x部分要以字符串的形式进行输入。如int('0xa2',16)

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4][]

hex()    将整数转换成十六进制，，如hex(122)

oct()    将整数转换成八进制，如oct(122)

bin()    将整数转换成二进制，如bin(122)

参见下图：

![20200820151836413.png][]

【获取函数帮助

在交互式命令行通过help(abs)查看abs函数

获取函数帮助

在交互式命令行通过help(abs)查看abs函数

you函数帮助行数太多，出现提示

squeezed text(xx lines)

鼠标指向它右键，参看下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5][]】

Python算术运算符

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:126px;"> 运算符 </td> 
 <td style="border-color:#555555;width:381px;"> 描述 </td> 
 <td style="border-color:#555555;width:292px;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> + </td> 
 <td style="width:381px;"> 加 - 两个对象相加 </td> 
 <td style="width:292px;"> 10 + 20 输出结果 30 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> - </td> 
 <td style="width:381px;"> 减 - 得到负数或是一个数减去另一个数 </td> 
 <td style="width:292px;"> 10 - 20 输出结果 -10 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> * </td> 
 <td style="width:381px;"> 乘 - 两个数相乘或是返回一个被重复若干次的字符串 </td> 
 <td style="width:292px;"> 10 * 20 输出结果 200 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> / </td> 
 <td style="width:381px;"> 除 - x除以y </td> 
 <td style="width:292px;"> 20 / 10 输出结果 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> % </td> 
 <td style="width:381px;"> 取模 - 返回除法的余数 </td> 
 <td style="width:292px;"> 20 % 10 输出结果 0 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> ** </td> 
 <td style="width:381px;"> 幂 - 返回x的y次幂 </td> 
 <td style="width:292px;"> 10**5 为10的5次方， 输出结果 100000 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:126px;"> // </td> 
 <td style="width:381px;"> 取整除 - 返回商的整数部分（向下取整） </td> 
 <td style="width:292px;"> &gt;&gt;&gt; 9//2 4 &gt;&gt;&gt; -9//2 -5 </td> 
 </tr> 
 </tbody> 
</table>

float（浮点型）

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示，复数的实部 a 和虚部 b 都是浮点型。

浮点数数据类型是用来描述小数的。浮点型进行计算，会发现某些时候计算并不准确。如果想要计算精确，可以使用decimal 模块（参见[https://docs.python.org/zh-cn/3/library/decimal.html][https_docs.python.org_zh-cn_3_library_decimal.html]）提供的Decimal()方法，让浮点运算结果可以和人平时运算的结果一样，要使用Decimal()方法需要先用form decimal import 引入。

如

print(0.3+0.35+0.35) 显示结果为0.9999999999999999

print(4-3.7)显示结果为0.2999999999999998

print(Decimal('0.3')+Decimal('0.35')+Decimal('0.35')) 显示结果为1.00

print(Decimal('4')-Decimal('3.7'))显示结果为0.3

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6][]

上面Decimal()方法，括号里面使用了引号——数据表示成字符串形式

若括号里不使用引号——不想以字符串形式为Decimal()方法提供数据，需要先decimal 模块提供的getcontext().prec = x 指定有效数字位数，例如指定4位有效数字位数：getcontext().prec = 4

print(Decimal(0.3)+Decimal(0.35)+Decimal(0.35))

print(Decimal(0.142857))

参见下图：

![20210423091001765.png][]

complex（复数）

复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a + bj

例、

![20200821092434377.png][]

**字符串(string)**

在Python 3.x版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多国的语言文字。

字符串是由数字、字母、下划线组成的一串字符，用单引号也可以用双引号括起来。

比如'abc'，"xyz"等等。请注意，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK."，也可以使用转义字符\\表示为'I\\'m OK.'，包含的字符是I，'，m，空格，O，K，.这7个字符。参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7][]

Python字符串即可以用三引号括起来的多行文本，如

‘’‘梅花 王安石

墙角数枝梅，凌寒独自开。

遥知不是雪，为有暗香来。‘‘’

字符串格式化

若想输出类似**' xxx你好！你语言月的话费是yy'**之类的字符串，而xxx、yy的内容都是根据变量变化的，怎么办呢？c语言中可以采用%来控制输出的格式，python中也类似，

%运算符就是用来格式化字符串的。

在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，在括号内并用逗号分隔，顺序要对应好。如果只有一个%?，括号可以省略。 如：'%s你好！你本月的话费是%f' %("王小明",38.6)

<table style="width:375.65pt;"> 
 <tbody> 
 <tr> 
 <td colspan="2" style="width:375.65pt;"> 常见的占位符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:78pt;"> 占位符 </td> 
 <td style="border-color:#c0c0c0;width:297.65pt;"> 替换内容 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:78pt;"> %d </td> 
 <td style="width:297.65pt;"> 整数 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:78pt;"> %f </td> 
 <td style="width:297.65pt;"> 浮点数 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:78pt;"> %s </td> 
 <td style="width:297.65pt;"> 字符串 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:78pt;"> %x </td> 
 <td style="width:297.65pt;"> 十六进制整数 </td> 
 </tr> 
 </tbody> 
</table>

字符串格式化的另外一种方法：使用.format()。

它会用传入的参数依次替换字符串内的占位符\{0\}、\{1\}……，不过这种方式写起来比%要麻烦得多。如：'\{0\}, 你本月的话费 \{1:.2f\}元，余额 \{2:.2f\}元'.format('小明', 17.167, 45.235)

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8][]

**Python 转义字符**

在需要在字符中使用特殊字符时，python 用反斜杠 **\\** 转义字符。如下表：

<table style="width:371.55pt;"> 
 <thead> 
 <tr> 
 <td style="border-color:#555555;width:84.65pt;"> 转义字符 </td> 
 <td style="border-color:#555555;width:286.9pt;"> 描述 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \(在行尾时) </td> 
 <td style="width:286.9pt;"> 续行符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \\ </td> 
 <td style="width:286.9pt;"> 反斜杠符号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \' </td> 
 <td style="width:286.9pt;"> 单引号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \" </td> 
 <td style="width:286.9pt;"> 双引号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \a </td> 
 <td style="width:286.9pt;"> 响铃 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \b </td> 
 <td style="width:286.9pt;"> 退格(Backspace) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \e </td> 
 <td style="width:286.9pt;"> 转义 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \000 </td> 
 <td style="width:286.9pt;"> 空 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \n </td> 
 <td style="width:286.9pt;"> 换行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \v </td> 
 <td style="width:286.9pt;"> 纵向制表符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \t </td> 
 <td style="width:286.9pt;"> 横向制表符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \r </td> 
 <td style="width:286.9pt;"> 回车 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \f </td> 
 <td style="width:286.9pt;"> 换页 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \oyy </td> 
 <td style="width:286.9pt;"> 八进制数，yy代表的字符，例如：\o12代表换行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \xyy </td> 
 <td style="width:286.9pt;"> 十六进制数，yy代表的字符，例如：\x0a代表换行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> \other </td> 
 <td style="width:286.9pt;"> 其它的字符以普通格式输出 </td> 
 </tr> 
 </tbody> 
</table>

例、参见下图：

![20200821092534555.png][]

**字符串前加 r，去掉反斜杠的转义机制**

\\n被显示为了换行，这并不是我们想要的，如希望得到c:\\newPy\\dirA，怎么办呢？字符串前加 r，将前面的代码改为

S1 = r'c:\\newPy\\dirA'

print(S1)

参见下图：

![20200821093012692.png][]

Python字符串运算符

表实例变量 a = "Hello"，b="Python"

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:101px;"> 操作符 </td> 
 <td style="border-color:#555555;width:535px;"> 描述 </td> 
 <td style="border-color:#555555;width:280px;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> + </td> 
 <td style="width:535px;"> 字符串连接 </td> 
 <td style="width:280px;"> a + b 输出结果： HelloPython </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> * </td> 
 <td style="width:535px;"> 重复输出字符串 </td> 
 <td style="width:280px;"> a*2 输出结果：HelloHello </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> [] </td> 
 <td style="width:535px;"> 通过索引获取字符串中字符 </td> 
 <td style="width:280px;"> a[1] 输出结果&nbsp;e </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> [ : ] </td> 
 <td style="width:535px;"> 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 </td> 
 <td style="width:280px;"> a[1:4] 输出结果&nbsp;ell </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> in </td> 
 <td style="width:535px;"> 成员运算符 - 如果字符串中包含给定的字符返回 True </td> 
 <td style="width:280px;"> 'H' in a&nbsp;输出结果 True </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> not in </td> 
 <td style="width:535px;"> 成员运算符 - 如果字符串中不包含给定的字符返回 True </td> 
 <td style="width:280px;"> 'M' not in a&nbsp;输出结果 True </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> r/R </td> 
 <td style="width:535px;"> 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母&nbsp;r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 </td> 
 <td style="width:280px;"> print( r'\n' ) print( R'\n' ) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:101px;"> % </td> 
 <td style="width:535px;"> 格式字符串 </td> 
 <td style="width:280px;"> 参见print函数。如 print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) 输出结果： 我叫 小明 今年 10 岁! </td> 
 </tr> 
 </tbody> 
</table>

python的字符串的取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9][]

python的字符串的取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10][]

python 字符串操作常用操作，如字符串的拼接、截取、分割等。

Python字符串拼接，直接将两个字符串紧挨着写在一起，+运算符也能拼接字符串，如：

![20210423170952511.png][]

Python 不允许直接拼接数字和字符串，所以我们必须先将数字转换成字符串。可以借助 str()函数将数字转换为字符串，它们的使用格式为：

str(obj)

obj 表示要转换的对象，它可以是数字、列表、元组、字典等多种类型的数据。如：

![20210423170952537.png][]

Python截取字符串

获取单个字符，具体的语法格式为：

strname\[index\]

其中，strname 表示字符串名字，index 表示索引值。

![20210514073948822.png][]

获取多个字符（也称为字符串切片），也就是一个子串或者片段，具体格式为：

strname\[start : end : step\]

其中

strname：要截取的字符串；

start：表示要截取的第一个字符所在的索引（截取时包含该字符）。如果不指定，默认为 0，也就是从字符串的开头截取；

end：表示要截取的最后一个字符所在的索引（截取时不包含该字符）。如果不指定，默认为字符串的长度；

step：指的是从 start 索引处的字符开始，每 step 个距离获取一个字符，直至 end 索引出的字符。step 默认值为 1，当省略该值时，最后一个冒号也可以省略。

例如：

s3 = 'python字符串常用操作方法'
    #获取从索引8开始，直到末尾的子串
    print(s3[8:])
    #获取从索引-11开始，直到末尾的子串
    print(s3[-11:])
    #从开头截取字符串，直到索引11为止
    print(s3[:11])
    #每隔3个字符取出一个字符
    print(s3[::3])

结果如下：

![20210423170952540.png][]

Python的split()方法和join()方法

split() 方法可以实现将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值反馈回来。该方法的基本语法格式如下：

str.split(sep,maxsplit)

其中：

str：表示要进行分割的字符串；

sep：用于指定分隔符，可以包含多个字符。此参数默认为 None，表示所有空字符，包括空格、换行符“\\n”、制表符“\\t”等。

maxsplit：可选参数，用于指定分割的次数，最后列表中子串的个数最多为 maxsplit+1。如果不指定或者指定为 -1，则表示分割次数没有限制。

此方法中，如果不指定 sep 参数，那么也不能指定 maxsplit 参数。

例子

s4='www.baidu.com'

l2=s4.split('.')

print(l2)

结果如下：

\['www', 'baidu', 'com'\]

join() 方法是 split() 方法的逆方法，用来将列表（或元组）中包含的多个字符串连接成一个字符串。join() 方法的语法格式如下：

newstr = str.join(iterable)

其中：

newstr：表示合并后生成的新字符串；

str：用于指定合并时的分隔符；

iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。

例子

ls = \['www','baidu','com'\]

print('.'.join(ls))

结果如下：

www.baidu.com

下面简要介绍list（列表）、tuple（元组）、Dict\[ionary\]（字典）、set（集合）。

**list（列表）**

用于存储多个任意类型的数据。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

如：

List1=\[1,2,3,"hello world","abc",3.1415,\[1,2,3\]\]

列表格式：L = \[元素1, 元素2, 元素3,……\]，英文符号（\[ \]：中括号）

列表用 \[ \] 标识，是 python 最通用的复合数据类型。列表元素索引0指向第一个元素，依次递增。最后一个元素的索引既可以是len(列表)-1也可以是-1。

列表中值的切割也可以用到变量 \[头下标:尾下标\] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

元素赋值

列表赋值通过索引标记来为某个已知的位置明确的元素赋值，即L\[0\]=8。因此，改变列表是非常容易的。

向列表尾部追加元素使用append方法，删除列表中的元素，使用del方法。

列表常用的方法：append()、count()、index()、insert()、pop()、remove()、reverse()、sort()。

列表操作方法一般格式：对象.方法(参数)，对象被放置到方法名之前，并且两者之间用“.”（点号）隔开。

**例**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11][]

分片操作

列表分片就是指获取列表里面的一些列元素（不仅仅是某一个元素）

获取的规则如下：

TL=m\[A:B\] %表示将m列表里从索引号位置为A开始的元素到B-1处元素之间的列表获取赋给TL.

例、

![20200821111701204.png][]

常用的列表操作符

1）+:它主要实现的是多个列表之间的拼接

常见的列表操作符

2）\*：主要实现的是列表的复制和添加

3）比较>,<:主要进行数据型列表的元素比较

4）and等：；逻辑运算符，可以进行列表之间的逻辑判断

实例参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12][]

**tuple（元组）**

元组类似于特殊的 list（列表），在同一个元组中，元素的类型可以不同，元组一旦建立就不能改变，不能改变其中的元素（数据项）——不能修改、添加、删除元素，相当于只读列表。

元组用 () 标识，内部元素用逗号隔开，小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。参见下图：

![20200821164035999.png][]

定义只有一个元素的Tuple的时候，需要这样:

tuple1 = (123,)

后面要加上一个逗号，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义。参见下图：

![20200821164035996.png][]

可以通过 type() 函数来查看一下数据类型。

可以使用（）或tuple()创建空元组。

元组支持的方法很少，与list无法相提并论。tuple仅仅支持index()、count()等极少数的方法，没有append()等方法。

使用索引访问元组元素的格式为：

tuplename\[i\]

其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。

使用切片访问元组元素的格式为：

tuplename\[start : end : step\]

其中，start 表示起始索引，end 表示结束索引，step 表示步长。

**Dict\[ionary\]（字典）**

字典用"\{ \}"标识。字典由索引(key)和它对应的值value组成。key通常是描述性信息，通常是字符串类型，是不可变类型；value可以是任意类型。元素是通过键来存取。字典中的键是唯一的，不可变的，而值却可以相同，可以为字符串、数字（int、float）、元组等。列表是有序的对象集合，字典是无序的对象集合。

字典用"\{ \}"标识，键值对之间用冒号（:）隔开。如：

d = \{'Michael':95, 'Bob':75, 'Tracy':85\}

d2= \{'k1':95,'k2':'李明'\}

![20200822105311149.png][]

字典中的元素如何修改呢？

通过Key修改Value，例子参见下图：

![20200822105336294.png][]

字典删除的例子：

dict = \{'Name': 'Runoob', 'Age': 7, 'Class': 'First'\}

del dict\['Name'\] \# 删除键 'Name'

dict.clear()     \# 清空字典——清空字典所有条目

del dict         \# 删除字典——清空字典所有条目

**set（集合）**

Python 3.x中的set特征与数学中类似。

集合中的元素有三个特征：

1. 确定性：集合中的元素必须是确定的；

2. 互异性：集合中的元素互不相同；

3. 无序性：集合中的元素是无序的（没有先后之分）

可以使用大括号 \{ \} 或者 set() 函数创建集合，注意：创建一个空集合需要用 set() 而不是 \{ \}，因为 \{ \} 是用来创建一个空字典。

a = set() \#创建空集合

a1=\{'a','b',10,20\}  \#创建集合

a2=set(\{'a','b','cd'\})  \#创建集合

在集合中添加元素，可以使用add()方法，如

a.add(10)

两个set可以做数学意义上的交集&、并集|等操作，如a1 & a2 、a1 | a2

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13][]

字符串、列表、元组、字典、集合小结：

元组和字符串不可变（元素只读），列表、字典、集合可变。列表、元组、字符串是有序的容器，字典、集合是无序的容器。字典键唯一且为不可变类型，集合自带去重复元素。

关于list（列表）、tuple（元组）、Dict\[ionary\]（字典）、set（集合）更多情况参见[https://blog.csdn.net/cnds123/article/details/116805604][https_blog.csdn.net_cnds123_article_details_116805604]

**Bool\[ean\]布尔**

布尔类型提供了两个布尔值来表示真（对）或假（错），在 Python 中分别用 True（真或对）或False（假或错）来表示。

True 和 False 是 Python 的关键字，在使用时，一定要注意首字母要大写，否则解释器会报错。

查看 True 和 False的类型

![20200824094635138.png][]

在 Python 中，任何对象都可以进行真假值的判断。如：

![20200824094634792.png][]

布尔类型可以与and 、or 与not 进行运算。如：

![20200824094634791.png][]

布尔值可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0，如：

![20200824094634790.png][]

python是一种解释型语言，Python 中的变量不需要声明类型。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建：解释器自动完成对变量内存的分配，不需要我们自己去定义类型。我们所说的"类型"是变量所指的内存中对象的类型。

在python里，int整形是对象，整数2也是对象，你定义的函数啊，类啊都是对象，你定义的变量也是对象。总之，你在python里能用到的都可以称之为对象。

python可以通过直接赋值初始化让一个变量拥有内存和值。等号（=）用来给变量赋值，等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

counter = 100          \# 整型变量

length = 10.20       \# 浮点型变量

name = "张三"     \# 字符串

**数据类型之间的转换**

通过使用int（）、float（）、str（）等不同的类型转换函数，我们可以在不同的数据类型之间进行转换。

从float到int的转换将截断该值小数部分，如：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14][]

从字符串的转换必须包含兼容的值，否则出错，如：

![20210513203727197.png][]

可以把一个序列转换成另一个序列，如：

![202009091447235.png][]

要转换为字典，每个元素必须成对，如：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15][]

**python表达式**

表达式是运算符和操作数所构成的序列。单独的一个值是一个表达式，单独的变量也是一个表达式。前面已使用过，又如a=3; c=x+a\*b

python运算符的优先级

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

<table style="margin-left:6.75pt;width:382.35pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:84.65pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:297.7pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> ** </td> 
 <td style="width:297.7pt;"> 指数 (最高优先级) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> ~ + - </td> 
 <td style="width:297.7pt;"> 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> * / % // </td> 
 <td style="width:297.7pt;"> 乘，除，取模和取整除 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> + - </td> 
 <td style="width:297.7pt;"> 加法减法 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> &gt;&gt; &lt;&lt; </td> 
 <td style="width:297.7pt;"> 右移，左移运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> &amp; </td> 
 <td style="width:297.7pt;"> 位 'AND' </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> ^ | </td> 
 <td style="width:297.7pt;"> 位运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> &lt;= &lt; &gt; &gt;= </td> 
 <td style="width:297.7pt;"> 比较运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> &lt;&gt; == != </td> 
 <td style="width:297.7pt;"> 等于运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> = %= /= //= -= += *= **= </td> 
 <td style="width:297.7pt;"> 赋值运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> is is not </td> 
 <td style="width:297.7pt;"> 身份运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> in not in </td> 
 <td style="width:297.7pt;"> 成员运算符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> not and or </td> 
 <td style="width:297.7pt;"> 逻辑运算符 </td> 
 </tr> 
 </tbody> 
</table>

[20210513215726978.png]: /images/20221124/0aa6e17ce2cc4c3d8465f52fe761efb6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221124/5badcd366d8d432bbd32de08c045222b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1]: /images/20221124/23e2b08f61ff4b52899bf14579b1004c.png
[https_docs.python.org_zh-cn_3.9_reference_datamodel.html]: https://docs.python.org/zh-cn/3.9/reference/datamodel.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2]: /images/20221124/ec669cb7c12f46e2ad5bd1d1842bbede.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3]: /images/20221124/142b166a729f4b36ae7ec38a4357effc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4]: /images/20221124/11a31bb6353a4d6dab45ca18e71f225a.png
[20200820151836413.png]: /images/20221124/7706a46fa27444dcb2173052b72316d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5]: /images/20221124/5c3ef9eb98cf4468954fa7522a4b00e3.png
[https_docs.python.org_zh-cn_3_library_decimal.html]: https://docs.python.org/zh-cn/3/library/decimal.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6]: /images/20221124/b1bc633006754586b05419842b7797d9.png
[20210423091001765.png]: /images/20221124/c982533e1a6c4b13940eea0317ce31e1.png
[20200821092434377.png]: /images/20221124/469ea64bfa59448a9121304e51b6f6a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7]: /images/20221124/a977cce76af145f7b6a4af27f44dc897.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8]: /images/20221124/a9cd988191aa497aa62643c725ebc37a.png
[20200821092534555.png]: /images/20221124/bd8042b2573549ffb7a15bde8c431990.png
[20200821093012692.png]: /images/20221124/a7b286bb06964e82bf33df44c3067720.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9]: /images/20221124/26209c277f084701a3eb14895ac3b3a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10]: /images/20221124/6e9cbccad45446a2a910a6b5e6b30c44.png
[20210423170952511.png]: /images/20221124/f1021622c0064ed7a35ff3bbd44e97f7.png
[20210423170952537.png]: /images/20221124/38d0bdc28e30404794cb09cd26ad44c4.png
[20210514073948822.png]: /images/20221124/fdad5de5aa924f989d5d0524716f5a5c.png
[20210423170952540.png]: /images/20221124/94c53e568cb241c492b8195f2f4b0344.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11]: /images/20221124/e3ece79a4b8d4b0a8ad4fd2f0f1abebc.png
[20200821111701204.png]: /images/20221124/3ba89083f3f24a639462407a8cf7090f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12]: /images/20221124/4b20660489a54b5792be4cc5b7697886.png
[20200821164035999.png]: /images/20221124/c28d0ed238d9456bb33e2fe280be6428.png
[20200821164035996.png]: /images/20221124/f7406f7bb2ba486bba684e45f2576047.png
[20200822105311149.png]: /images/20221124/85c24e8345a04f0a974aa9b53c861d15.png
[20200822105336294.png]: /images/20221124/16626643b62c4218899a8b6a0d3b0c30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13]: /images/20221124/c997735b78c64aa5bc6be39d526c5854.png
[https_blog.csdn.net_cnds123_article_details_116805604]: https://blog.csdn.net/cnds123/article/details/116805604
[20200824094635138.png]: /images/20221124/c2884ff222634a0bad2ec3a7774b16b4.png
[20200824094634792.png]: /images/20221124/af503a596a43414ea9846e1b91ed8149.png
[20200824094634791.png]: /images/20221124/0b50dcc72cc2445aabe889c15208d001.png
[20200824094634790.png]: /images/20221124/8ba76e8fffb1457c8db87ae333d3acaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14]: /images/20221124/adb23275a9e44732b7797b0349e85c18.png
[20210513203727197.png]: /images/20221124/be9cb8b151b9435eb3f4e18cc14d3c15.png
[202009091447235.png]: /images/20221124/1c88c961493b450a99480a009e63372d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15]: /images/20221124/bbf2040584fe459489f22d370b48a9f1.png