【Python】Python的六大基本数据类型及其API详解（超全超详细）

1. 基本数据类型

Python3 中常见的数据类型有：

• Number（数字）
• bool（布尔）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

2. 数字类型

Number类型：

• int：整型，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，布尔(bool)是整型的子类型。
• float：浮点型，由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）
• complex：复数类型，由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

注：
1.数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
2.整数除了是10进制的形式，也可以是8进制和16进制的形式。

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3e+18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

2.1 数字运算

运算：+, -, * ,/ 和 %

# 1.加法
print(1+2) # 3
print(1+2.0) # 3.0
print(1+complex(2,3)) # (3+3j)

# 2.减法
print(3-1) # 2
print(3-1.0) # 2.0
print(complex(3,3)-1) # (2+3j)

# 3.乘法
print(2*3) # 6
print(2*3.0) # 6.0
print(2*complex(3,3)) # (6+6j)

# 4.除法
print(9/3) # 3.0
print(9/3.0) # 3.0
print(9/complex(3)) # (3+0j)

# 5.求余
print(9%2) # 1
print(9%3) # 0

注：除法 / 总是返回一个浮点数

2.2 数学函数

数学常量：

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）

数学函数：

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
fabs(x)	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x, y)	x**y 运算后的值，即x的y次幂
sqrt(x)	返回数字x的平方根

注：以上一些函数是math模块的函数，所以需要导入math模块

1.数学常量

import math

# 1.圆周率 π
print(math.pi) # 3.141592653589793

# 2.自然常数 e
print(math.e) # 2.718281828459045

2.绝对值

import math

# 1.返回数字的绝对值
print(abs(-10)) # 10
print(abs(-10.1)) # 10.1

# 2.以浮点数形式返回数字的绝对值
print(math.fabs(-10)) # 10.0
print(math.fabs(-10.1)) # 10.1

3.取整和四舍五入

import math

# 1.向上取整
print(math.ceil(1.0)) # 1
print(math.ceil(1.1)) # 2
print(math.ceil(1.9)) # 2

# 2.向下取整
print(math.floor(1.0)) # 1
print(math.floor(1.1)) # 1
print(math.floor(1.9)) # 1

# 3.四舍五入
print(round(1.0)) # 1
print(round(1.4)) # 1
print(round(1.5)) # 2
print(round(1.9)) # 2
print(round(1.474,2)) # 1.47
print(round(1.475,2)) # 1.48

4.指数和对数

import math

# 1.返回e的x次幂
print(math.exp(1)) # 2.718281828459045
print(math.exp(2)) # 7.38905609893065

# 2.返回x的对数
print(math.log(math.e)) # 1.0
print(math.log(100,10)) # 2.0

# 3.返回以10为基数的x的对数
print(math.log10(100)) # 2.0

5.返回序列的最大和最小值

# 1.返回序列的最大值
print(max(3,1,9,6,8)) # 9

# 2.返回序列的最小值
print(min(3,1,9,6,8)) # 1

6.返回数字的整数与小数部分

import math

print(math.modf(2)) # (0.0, 2.0)
print(math.modf(2.0)) # (0.0, 2.0)
print(math.modf(2.1)) # (0.10000000000000009, 2.0)

7.返回幂和平方根

import math

# 1.求x的y次幂
print(pow(2,3)) # 8
print(pow(9,0.5)) # 3.0

# 2.求平方根
print(math.sqrt(9)) # 3.0

2.3 随机数函数

随机数：可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

函数	描述
random()	随机生成下一个实数，它在[0,1)范围内
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
shuffle(lst)	将序列的所有元素随机排序
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed

import random

# 1.随机生成一个实数，区间范围是[0,1)
print(random.random()) # 0.28189502093878505

# 2.随机生成一个实数，区间范围是[x,y]
print(random.uniform(10, 20)) # 11.7446614812833

# 3.从序列的元素中随机挑选一个元素
a = [1, 3, 5, 7, 9]
print(random.choice(a)) # 5
print(random.choice(range(10,15))) # 13

# 4.将序列的所有元素随机排序
b = [1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(b)
print(b) # [1, 4, 8, 2, 6, 3, 9, 5, 7]

# 5.返回指定递增基数集合中的一个随机数，基数默认值为1
# 从 [1,10)中选取一个奇数
print(random.randrange(1,10,2)) # 7
# 从 [0,10)中选取一个偶数
print(random.randrange(0,10,2)) # 6
 

2.4 三角函数

函数	描述
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度
sin(x)	返回的x弧度的正弦值
cos(x)	返回x的弧度的余弦值
tan(x)	返回x弧度的正切值
asin(x)	返回x的反正弦弧度值
acos(x)	返回x的反余弦弧度值
atan(x)	返回x的反正切弧度值
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)

1.弧度和角度相互转换

import math

# 1.将弧度转换为角度
print(math.degrees(math.pi)) # 180.0
print(math.degrees(math.pi*2)) # 360.0
print(math.degrees(math.pi/2)) # 90.0

# 2.将角度转换为弧度
print(math.radians(180)) # 3.141592653589793
print(math.radians(360)) # 6.283185307179586
print(math.radians(90)) # 1.5707963267948966

2.三角函数

import math

# 1.返回的x弧度的正弦值
print(math.sin(math.radians(90))) # 1.0
print(math.sin(math.radians(30))) # 0.49999999999999994
print(math.sin(math.radians(60))) # 0.8660254037844386

# 2.返回的x弧度的余弦值
print(math.cos(math.radians(30))) # 0.8660254037844387
print(math.cos(math.radians(60))) # 0.5000000000000001

# 3.返回x弧度的正切值
print(math.tan(math.radians(45.0))) # 0.9999999999999999

3.反三角函数

import math

# 1.返回x的反正弦弧度值
print(math.degrees(math.asin(1))) # 90.0
print(math.degrees(math.asin(0.5))) # 30.000000000000004
print(math.degrees(math.asin(math.sqrt(3)/2))) # 59.99999999999999

# 2.返回x的反余弦弧度值
print(math.degrees(math.acos(0.5))) # 60.00000000000001
print(math.degrees(math.acos(math.sqrt(3)/2))) # 30.000000000000004

# 3.返回x的反正切弧度值
print(math.degrees(math.atan(1))) # 45.0

2.5 数字类型转换

数据类型的转换，只需要将数据类型作为函数名即可：

• int(x)： 将x转换为一个整数
• float(x)： 将x转换到一个浮点数
• complex(x)： 将x转换到一个复数，实数部分为 x，虚数部分为 0
• complex(x, y)： 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式
• bool(x)：将x转换为一个布尔值

# 1.强制转换为整型
print(int(1.1)) # 1
print(int(0.1)) # 0
print(int(True)) # 1
print(int(False)) # 0

# 2.强制转换为浮点型
print(float(1)) # 1.0
print(float(1.2)) # 1.2

# 3.强制转换为复数类型
print(complex(1)) # (1+0j)
print(complex(1,2)) # (1+2j)

# 4.强制转换为布尔类型
print(bool(1)) # True
print(bool(0)) # False

3. 字符串类型

字符串是 Python 中最常用的数据类型，可以使用单引号''或双引号""来创建字符串。

3.1 访问字符串

访问字符串：

• 访问整个字符串：变量
• 访问单个字符：变量[下标]，下标为正代表正序，下标为负代表逆序。

a = 'Hello World' 

# 1.访问整个字符串
print(a) # Hello World

# 2.访问字符串中单个字符的值
# 下标值 0 为第一个元素，1 为第二个元素 
print(a[0]) # H 
print(a[1]) # e

# 下标值-1 表示倒数第一个元素，-2 表示倒数第二个元素 
print(a[-1]) # d
print(a[-2]) # l

3.2 截取字符串

截取子字符串有两种方式：变量[头下标:尾下标]和变量[头下标:尾下标:步长]

操作符	描述
s[i:j]	切片，返回序列 s 中从序号 i 到 j（不包括j）的元素子序列 i 缺省时，默认为 0；j 缺省时，默认为 len(s)； i、j 均缺省时，默认为全部
s[i:j:k]	切片，返回序列 s 中从序号 i 到 j（不包括j），以 k 为步长的元素子序列 k > 0，步长自左而右（正序）；k缺省时，k默认为 1； i缺省时，i默认为 0；j 缺省时，j默认为len(s) k < 0，步长自右而左（倒序）；i 缺省时，i默认为 -1；j 缺省时，j默认为 -len(s)-1

1.变量[头下标:尾下标]

• a[x:y] 表示截取a字符串从x下标开始，到y下标结束(不取y值)，即截取的范围是 [x, y)
• a[x:] 表示截取a字符串从x下标开始，到字符串末尾结束(取字符串末尾值)，即截取的范围是 [x, len(a))，也就是 [x, -1]
• a[:y] 表示截取a字符串从0下标开始，到y下标结束(不取y值)，即截取的范围是 [0, y)

a = 'Hello World' 

# 1.a[x:]，截取范围[x,-1]
print(a[0:]) # Hello World
print(a[3:]) # lo World

# 2.a[:y]，截取范围[0,y)
print(a[:3]) # Hel
print(a[:-1]) # Hello Worl

# 3.a[x:y]，截取范围[x,y)
print(a[0:5]) # Hello
print(a[1:5]) # ello
print(a[1:-1]) # ello Worl
print(a[-5:-1]) # Worl

2.变量[头下标:尾下标:步长]

• a[x:y:z] 中的x和y同a[x:y]，即截取的范围是[x,y)，z表示步长，有正负之分，正数代表正序截取字符串，负数代表逆序截取字符串。
• a[x::z] ，z表示步长
  • 当 z>0 时，取的范围是 [x, len(a))，也就是 [x, -1]
  • 当 z<0 时，取的范围是 [x, -len(s)-1)，逆向输出字符串
• a[:y:z] ，z表示步长
  • 当 z>0 时，取的范围是 [0, y)
  • 当 z<0 时，取的范围是 [ -1, y)，逆向输出字符串

a = 'Hello World' 

# 1.a[x::z]，z为步长（有正负）
print(a[0::1]) # Hello World
print(a[0::2]) # HloWrd
print(a[3::1]) # lo World
print(a[3::-1]) # lleH

# 2.a[:y:z]，z为步长（有正负）
print(a[:3:1]) # Hel
print(a[:-1:1]) # Hello Worl
print(a[:-1:2]) # HloWr
print(a[:3:-1]) # dlroW o

# 3.a[x:y:z]，z为步长（有正负）
print(a[0:5:1]) # Hello
print(a[0:5:2]) # Hlo
print(a[-1:5:-1]) # dlroW
print(a[-2:5:-1]) # lroW

# 4.字符串反转
print(a[-1::-1]) # dlroW olleH

3.3 转义字符

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

转义字符	描述
\	续行符 (在行尾时)
\\	反斜杠符号
\'	单引号
\"	双引号
\b	退格(Backspace)
\n	换行
\f	换页
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
\t	横向制表符
\v	纵向制表符
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
\000	空

1.续行符

a = "line1 \
... line2 \
... line3"

print(a) # line1 ... line2 ... line3

2.反斜杠、单、双引号

print("\\") # \
print("\'") # '
print("\"") # "

3.退格、换行、换页、回车

# 1.退格
print("Hello \b World!") # Hello World!

# 2.换行
'''
Hello
World!
'''
print("Hello\nWorld!")

# 3.换页
'''
Hello
World!
'''
print("Hello\fWorld!")

# 4.回车
print("Hello\rWorld!") # World!
print('google runoob taobao\r123456') # 123456 runoob taobao

4.横向、纵向制表符

# 1.横向制表符
print("Hello\tWorld!") # Hello   World!

# 2.纵向制表符
'''
Hello
World!
'''
print("Hello\vWorld!")

5.八进制数、十六进制数、空

# 1.八进制数
print("\110\145\154\154\157\40\127\157\162\154\144\41") # Hello World!

# 2.十六进制数
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") # Hello World!

# 3.空
print("\000") #
print("a\000a") # aa

3.4 字符串运算符

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
%	格式字符串

a = "Hello"
b = "World"

print(a+b) # HelloWorld
print(a*2) # HelloHello
print('H' in a) # True
print('h' not in a) # True
print(r'\n') # \n
print(R'\n') # \n

3.5 字符串格式化

3.5.1 格式化符号

% 代表格式符（也叫占位符），其语法规则如下：

%[(name)][flags][width].[precision]typecode

• (name)：可选，用于选择指定的 key

• flags：可选，表示辅助符号（例如：+、0 等）

• width：可选，占有宽度

• .precision：可选，小数点后保留的位数

• typecode：必选，类型码（例如：%d 对应的就是 d）

字符串格式化符号：

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令：

符 号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

1.格式化字符和字符串

# 1.格式化字符
print('%c' % 'a') # a
print('Hell%c' % 'o') # Hello
print('%c%c%c ' % ('a','b','c')) # abc

# 2.格式化字符串
print('%s' % 'abc') # abc
print('Hello %s' % 'World') # Hello World
print('%s %s' % ('Hello','World')) # Hello World

注：多个参数需要格式化，则用小括号括起来，并以逗号分隔

2.格式化整数（十进制）

# 1.格式化有符号整型
print('%d' % 10) # 10
print('%d' % -10) # -10
print('%d + %d = %d' % (1,1,2)) # 1 + 1 = 2

# 2.格式化无符号整型
print('%u' % 10) # 10
print('%u' % -10) # -10
print('%u + %u = %u' % (-1,-1,-2)) # -1 + -1 = -2

3.格式化进制数

# 1.格式化无符号八进制数
print('%o' % 10) # 12
print('%o' % -10) # -12
print('%o + %o = %o' % (10,10,20)) # 12 + 12 = 24

# 2.格式化无符号十六进制数
print('%x' % 20) # 14
print('%x' % -20) # -14
print('%x + %x = %x' % (20,20,40)) # 14 + 14 = 28

4.格式化浮点数

# 1.格式化浮点数，可指定小数点后的精度
print('%f' % 10) # 10.000000
print('%f' % 3.1415926) # 3.141593
print('%.2f' % 10) # 10.00
print('%.2f' % 3.1415926) # 3.14

# 2.用科学计数法格式化浮点数
print('%e' % 10**5) # 1.000000e+05
print('%.0e' % 10**5) # 1e+05

5.格式化操作符辅助指令

注：输出默认是右对齐

# 1.占有的宽度，%5d表示右对齐，最少取5位整数，如果数字位数>=5则全取，不足5位使用空格补齐     
print('%5d' % 123) #   123
print('%5d' % 123456) # 123456

# 2.小数点后保留的位数
print('%.2f' % 123) # 123.00
print('%.2f' % 3.1415926) # 3.14
print('%5.2f' % 123) # 123.00
print('%8.2f' % 123) #   123.00

# 3.左对齐
print('%-5d' % 123) # 123

# 4.在正数前面显示加号
print('%+d' % 123) # +123
print('%+d' % -100) # -100

# 5.显示的数字前面填充'0'而不是默认的空格
print('%05d' % 123) # 00123
print('%05d' % -100) # -0100

# 6.在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
print('%#o' % 12) # 0o14
print('%#x' % 12) # 0xc
print('%#X' % 12) # 0XC

3.5.2 format

str.format() 是 python2.6 开始新增的一种格式化字符串的函数 ，它增强了字符串格式化的功能。

• 基本语法是通过 {} 和 : 来代替以前的 % ，其中 {} 表示占位符 : 表示格式化。
• format 函数不限参数个数，位置可以不按顺序。

1.format函数中 {} 的基本用法

# 1.不设置指定位置，按默认顺序
print('{} {}'.format('hello', 'world')) # hello world

# 2.设置指定位置
print('{0} {1}'.format('hello', 'world')) # hello world
print('{1} {0} {1}'.format('hello', 'world')) # world hello world

# 3.设置参数
print('网站名：{name}, 地址 {url}'.format(name='百度', url='www.baidu.com')) # 网站名：百度, 地址 www.baidu.com

# 4.替换变量
name = 'Jack'
print('My name is {}'.format(name)) # My name is Jack

# 5.使用表达式
print('My age is {}'.format(2023-1997)) # My age is 26

2.format函数中 : 的基本用法

数字格式化：可以结合着格式化符号中的内容一起看，大体一致，略微有些改动。

例：{:<5.2f}中 :表示格式化，后面的<5.2f相当于格式化符号中-5.2f的意思（左对齐，宽度为5位，小数点后保留2位）。

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:-.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)

# 1.占有的宽度，%5d表示右对齐，最少取5位整数，如果数字位数>=5则全取，不足5位使用空格补齐     
print('{:5d}'.format(123)) #   123
print('{:5d}'.format(123456)) # 123456

# 2.小数点后保留的位数
print('{:.2f}'.format(123)) # 123.00
print('{:.2f}'.format(3.1415926)) # 3.14
print('{:5.2f}'.format(123)) # 123.00
print('{:8.2f}'.format(123)) #   123.00

# 3.左对齐和右对齐（默认右对齐）
print('{:<5d}'.format(123)) # 123
print('{:>5d}'.format(123)) #   123

3.5.3 f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法，用法与format函数基本一致，只是语法格式不太一样了。

语法：以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去。

1.f-string 的基本用法：

# 1.替换变量
name = 'Jack'
print(f'My name is {name}') # My name is Jack

info = {'name': '百度', 'url': 'www.baidu.com'}
print(f'网站名：{info["name"]}, 地址 {info["url"]}') # 网站名：百度, 地址 www.baidu.com

# 2.使用表达式
print(f'My age is {2023-1997}') # My age is 26

2.f-string 中的数字格式化

# 1.占有的宽度，%5d表示右对齐，最少取5位整数，如果数字位数>=5则全取，不足5位使用空格补齐     
print(f'{123:5d}') #   123
print(f'{123456:5d}') # 123456

# 2.小数点后保留的位数
print(f'{123:.2f}') # 123.00
print(f'{3.1415926:.2f}') # 3.14
print(f'{123:5.2f}') # 123.00
print(f'{123:8.2f}') #   123.00

# 3.左对齐和右对齐（默认右对齐）
print(f'{123:<5d}') # 123
print(f'{123:>5d}') #   123

3.6 字符串方法

3.6.1 字符串长度

函数	描述
len(string)	返回字符串长度

a = "Hello World"
b = "H  "

print(len(a)) # 11
print(len(b)) # 3

3.6.2 字符串替换

函数	描述
replace(old, new [, max])	把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

old_site = "https://www.baidu.com/"
new_site = old_site.replace("baidu","bilibili")
print(new_site) # https://www.bilibili.com/

calculation_rule = "(a+b)/c-d"
replaced_rule = calculation_rule.replace("a","10").replace("b","2").replace("c","3").replace("d","1")
print(replaced_rule) # (10+2)/3-1

old_str = "Hello World"
new_str = old_str.replace("abc","efg") # 未找到需要替换的字符串，也不会报错
print(new_str) # Hello World

3.6.3 去除字符串空白字符

函数	描述
lstrip([chars])	截掉字符串左边的空格或指定字符。
rstrip([chars])	删除字符串末尾的空格或指定字符。
strip([chars])	在字符串上执行 lstrip()和 rstrip()

# 1.去除字符串左边的空白
print(" abcd efg ".lstrip()) # abcd efg 

# 2.去除字符串右边的空白
print(" abcd efg ".rstrip()) #  abcd efg

# 3.去除字符串首位两端空白
print(" abcd efg ".strip()) # abcd efg

# 4.删除字符串首位两端指定字符
print("***this is a example***".strip('*')) # this is a example
print("123abc321".strip('12')) # 3abc3

3.6.4 字符串大小写

函数	描述
lower()	转换字符串中所有大写字母为小写
upper()	转换字符串中的小写字母为大写
capitalize()	将字符串的第一个字符转换为大写，其他字母变小写
swapcase()	将字符串中大写转换为小写，小写转换为大写
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

# 1.转换字符串中所有大写字母为小写
print("Hello World".lower()) # hello world

# 2.转换字符串中所有小写字母为大写
print("Hello World".upper()) # HELLO WORLD

# 3.将字符串中大写转换为小写，小写转换为大写
print("Hello World".swapcase()) # hELLO wORLD

# 4.将字符串的第一个字符转换为大写，其他字母变小写
print("hello Python".capitalize()) # Hello python

# 5.判断字符串中字符是否都是小写
print("Hello World".islower()) # False
print("abc".islower()) # True

# 6.判断字符串中字符是否都是大写
print("Hello World".isupper()) # False
print("ABC".isupper()) # True

3.6.5 字符串的分割与合并

函数	描述
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
splitlines([keepends])	按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

1.split方法的语法：str.split(str="", num=string.count(str))

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数，如果设置了这个参数，则最多分割成 maxsplit+1 个子字符串。默认为 -1, 即分隔所有。

str1 = "Hello World"
str2 = "Baidu#Alibaba#Tencent#Bytedance"

# 1.默认以空格为分隔符，返回列表
print(str1.split()) # ['Hello', 'World']

# 2.以'#'为分隔符，返回列表
print(str2.split('#')) # ['Baidu', 'Alibaba', 'Tencent', 'Bytedance']

# 3.以'#'为分隔符，只分割一次，返回列表
print(str2.split('#', 1)) # ['Baidu', 'Alibaba#Tencent#Bytedance']

2.splitlines方法的语法：str.splitlines([keepends])

• 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
• 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符，默认为 False。

# 读取到的文本内容
text = '''Hello
C
C++
Python
Java
'''

print(text.splitlines()) # ['Hello', 'C', 'C++', 'Python', 'Java']

3.join方法的语法：str.join(sequence)

• sequence – 要连接的元素序列
• 返回通过指定字符连接序列中元素后生成的新字符串

lists = ['H','e','l','l','o']

print("".join(lists)) # Hello
print("-".join(lists)) # H-e-l-l-o

3.6.6 判断字符串中的内容

函数	描述
isalnum()	如果字符串至少有一个字符并且所有字符都是字母、中文或数字则返 回 True，否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()	如果字符串只包含数字则返回 True 否则返回 False
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false
isspace()	如果字符串中只包含空白，则返回 True，否则返回 False
istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False

# 1.isalnum() 判断字符串中是否只有字母、中文或数字（不能含有空格或者其他字符）
print("abc123".isalnum()) # True
print("abc123中国".isalnum()) # True
print("abc 123".isalnum()) # False

# 2.isalpha() 判断字符串中是否只有字母或中文
print("abc中国".isalpha()) # True
print("abc 中国".isalpha()) # False
print("abc123".isalpha()) # False

# 3.isdigit() 判断字符串中是否只包含数字
print("123".isdigit()) # True
print("123 ".isdigit()) # False
print("abc123".isdigit()) # False

# 4.isnumeric() 判断字符串中是否只包含数字字符（Unicode数字、全角数字、罗马数字或汉字数字）
print("123".isnumeric()) # True
print("一二三".isnumeric()) # True
print("\u00BD".isnumeric()) # True
print("½".isnumeric()) # True
print("10²".isnumeric()) # True

# 5.isdecimal() 判断字符串中是否只包含十进制字符
print("123".isdecimal()) # True
print("123 ".isdecimal()) # False
print("abc123".isdecimal()) # False

# 6.isspace() 判断字符串中是否只包含空白（\t\r\n 都是空白符）
print(" ".isspace()) # True
print(" \t\r\n".isspace()) # True
print("".isspace()) # False

# 7.istitle() 判断字符串是否是标题化的（所有的单词拼写首字母为大写，且其他字母为小写）
print("This Is Title".istitle()) # True
print("This is title".istitle()) # False

3.6.7 字符串填充

函数	描述
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格
ljust(width[, fillchar])	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
rjust(width,[, fillchar])	返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0

1.字符串居中对齐，左右两边填充字符

center方法的语法：str.center(width[, fillchar])

• width – 指定填充指定字符后中字符串的总长度
• fillchar – 填充的字符，默认为空格

print("abc".center(8,'*')) # **abc***
print("abc".center(9,'*')) # ***abc***
print("abc".center(9)) #   abc    

2.字符串左对齐，右边填充字符

ljust方法的语法：str.ljust(width[, fillchar])

• width – 指定填充指定字符后中字符串的总长度
• fillchar – 填充的字符，默认为空格

print("abc".ljust(8,'*')) # abc*****
print("abc".ljust(8)) # abc    

3.字符串右对齐，左边填充字符

rjust方法的语法：str.rjust(width[, fillchar])

• width – 指定填充指定字符后中字符串的总长度
• fillchar – 填充的字符，默认为空格

print("abc".rjust(8,'*')) # *****abc
print("abc".rjust(8)) #      abc

4.字符串右对齐，左边填充字符0

zfill方法的语法：str.zfill(width)

• width – 指定填充指定字符后中字符串的总长度

print("abc".zfill(8)) # 00000abc

3.6.8 字符串查找

函数	描述
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常。
rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始.
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。

1.统计字符串中，指定的子字符串出现的次数

count方法的语法：str.count(sub, start= 0,end=len(string))

• sub – 搜索的子字符串
• start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

注：当 start 和 end 有值时，取值范围为左开右闭 [start ,end)

str = "Hello World"

print(str.count('l')) # 3
print(str.count('l',0,3)) # 1
print(str.count('l',0,4)) # 2
print(str.count('Wo')) # 1

2.查找字符串中，是否以指定子字符串开头或结束，是则返回 True，否则返回 False

startswith方法的语法：str.startswith(substr, beg=0,end=len(string))，判断字符串是否以指定值开头

• str – 检测的字符串
• substr – 指定的子字符串
• beg – 可选参数用于设置字符串检测的起始位置
• end – 可选参数用于设置字符串检测的结束位置

注：当 beg 和 end 有值时，取值范围为左开右闭 [beg ,end)

endswith方法的语法：str.endswith(suffix[, start[, end]])，判断字符串是否以指定值开头

• str – 检测的字符串
• suffix – 指定的子字符串
• start – 字符串中的开始位置
• end – 字符中结束位置

注：当 start和 end 有值时，取值范围为左开右闭 [start,end)

str = "Hello World"

# 1.判断字符串是否以指定值开头
print(str.startswith("Hello")) # True
print(str.startswith("Wo",6)) # True
print(str.startswith("Wo",8)) # False
print(str.startswith("Wo",6,8)) # True
print(str.startswith("Wo",6,7)) # False

# 2.判断字符串是否以指定值结束
print(str.endswith("World")) # True
print(str.endswith("ld",6)) # True
print(str.endswith("ld",6,8)) # False

3.查找字符串中，是否包含指定子字符串，是则返回索引值，否则返回 -1

find方法的语法：str.find(str, beg=0, end=len(string))，检测字符串中是否包含子字符串 str

• str – 指定检索的字符串
• beg – 开始索引，默认为0
• end – 结束索引，默认为字符串的长度

注：当 beg 和 end 有值时，取值范围为左开右闭 [beg ,end)

rfind方法的语法： rfind(str, beg=0,end=len(string))，类似于 find 方法，不过是从右边开始查找

index方法的语法： index(str, beg=0, end=len(string))，跟 find 方法一样，只不过如果子字符串不在字符串中会报一个异常

rindex方法的语法： rindex( str, beg=0, end=len(string))，类似于 index 方法，不过是从右边开始查找

str = "abca"

# 1.find() 查找字符串中是否包含子字符串，返回字符串第一次出现的位置，如果没有匹配项则返回-1
print(str.find('a')) # 0
print(str.find('d')) # -1
print(str.find('a',1)) # 3
print(str.find('a',1,3)) # -1

# 判断字符串是否包含子字符串，包含则返回True，否则返回False
print(str.find('a')!=-1) # True
print(str.find('d')!=-1) # False

# 2.rfind() 从右边开始查找，返回字符串最后一次出现的位置，如果没有匹配项则返回-1
print(str.rfind('a')) # 3
print(str.rfind('d')) # -1
print(str.rfind('a',1)) # 3
print(str.find('a',1,3)) # -1

# 3.index() 跟find方法一样，只不过如果子字符串不在字符串中会抛异常
print(str.index('a')) # 0
print(str.index('d')) # ValueError

# 4.rindex() 类似于index方法，不过是从右边开始查找
print(str.rindex('a')) # 3
print(str.rindex('d')) # ValueError

4.返回字符串中最大或最小的字母

• max(str)：返回字符串 str 中最大的字母
• min(str)：返回字符串 str 中最小的字母

str = "abcd"

print(max(str)) # d
print(min(str)) # a

3.6.9 字符串的编码与解码

函数	描述
encode(encoding='UTF-8',errors='strict')	以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
bytes.decode(encoding="utf-8", errors="strict")	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

encode方法对字符串进行编码，返回编码后的字符串，是一个 bytes 对象

• encoding – 要使用的编码，如: UTF-8。
• errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能的值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。

decode方法对bytes 对象进行解码，返回解码后的字符串

str = "中国"

# 对字符串进行编码
encode_utf8_str = str.encode("UTF-8")
encode_gbk_str = str.encode("GBK")
print(f"编码前字符串：{str}") # 编码前字符串：中国
print(f"UTF-8 编码：{encode_utf8_str}") # UTF-8 编码：b'\xe4\xb8\xad\xe5\x9b\xbd'
print(f"GBK 编码：{encode_gbk_str}") # GBK 编码：b'\xd6\xd0\xb9\xfa'

# 对bytes对象进行编码
decode_utf8_str = encode_utf8_str.decode('UTF-8','strict')
decode_utf8_str = encode_gbk_str.decode('GBK','strict')
print(f"UTF-8 解码：{decode_utf8_str}") # UTF-8 解码：中国
print(f"GBK 解码：{decode_utf8_str}") # GBK 解码：中国

4. 列表类型

序列：

• 序列是 Python 中最基本的数据结构
• Python 有 6 个序列的内置类型，但最常见的是列表和元组

列表：

• 列表可以进行的操作包括索引，切片，加，乘，检查成员
• 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现
• 列表的数据项不需要具有相同的类型

4.1 创建列表

创建列表：创建一个列表，只要把逗号分隔的不同的数据项使用方括号 [] 括起来即可。

# 1.创建空列表
list1 = []

# 2.创建带初始值的列表
list2 = [1, 2, "abc", "red"]

# 3.列表可以嵌套
list3 = [[1, 2, 3], "abc", ["red", "blue"]]

4.2 访问列表

访问列表：访问列表和访问字符串是一样的，如何访问字符串就如何访问列表

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

print(a) # ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(a[0]) # red
print(a[2]) # blue
print(a[-1]) # black

4.3 截取列表

截取列表： 截取列表和截取字符串是一样的，如何截取字符串就如何截取列表

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

# 1.a[x:]，截取范围[x,-1]
print(a[2:]) # ['blue', 'yellow', 'white', 'black']

# 2.a[:y]，截取范围[0,y)
print(a[:3]) # ['red', 'green', 'blue']

# 3.a[x:y]，截取范围[x,y)
print(a[2:4]) # ['blue', 'yellow']

# 4.列表反转
print(a[-1::-1]) # ['black', 'white', 'yellow', 'blue', 'green', 'red']

4.4 更新列表

1.使用 = 赋值，修改列表元素

a = ['red', 'green']

a[1] = 'blue'
print(a) # ['red', 'blue']

2.list.append(obj) ，向列表末尾追加元素

• obj – 添加到列表末尾的对象

a = ['red', 'green']

a.append('blue')
a.append(10)
print(a) # ['red', 'green', 'blue', 10]

3.list.extend(seq) ，向列表末尾追加另一个序列（用新列表扩展原来的列表）

• seq – 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。

a = ['red', 'green']
b = ['blue', 'yellow', 'white', 'black']

a.extend(b)
print(a) # ['red', 'green', 'blue', 'yellow', 'white', 'black']

4.list.insert(index, obj)，插入元素到列表的指定位置

• index – 对象obj需要插入的索引位置
• obj – 要插入列表中的对象

插入元素到指定位置，原先的元素往后移一位（例如：插入元素到索引为2的位置，那么原先索引为2及2之后的元素，都向后移一位）

a = ['red', 'green', 'blue', 'yellow', 'white']

a.insert(2,'black')
print(a) # ['red', 'green', 'black', 'blue', 'yellow', 'white']

4.5 删除列表

4.5.1 删除列表元素

1.使用 del 关键字，删除列表元素

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

del a[2]
print(a) # ['red', 'green', 'yellow', 'white', 'black']

del a[-1]
print(a) # ['red', 'green', 'yellow', 'white']

2.list.pop([index=-1])，移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

• index – 要移除列表元素的索引值，默认为 index=-1

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

a.pop()
print(a) # ['red', 'green', 'blue', 'yellow', 'white']

print(a.pop(2)) # blue
print(a) # ['red', 'green', 'yellow', 'white']

3.list.remove(obj)，用于移除列表中某个值的第一个匹配项

• obj – 列表中要移除的对象

a = ['red', 'green', 'blue', 'green', 'white', 'black']

a.remove('green')
print(a) # ['red', 'blue', 'green', 'white', 'black']

a.remove('green')
print(a) # ['red', 'blue', 'white', 'black']

4.5.2 清空列表元素

1.使用 = 赋值为空，清空列表元素

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

a = []
print(a) # []

2.使用 del a[:]，删除列表中所有元素

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

del a[:]
print(a) # []

3.list.clear()，该方法用于清空列表

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

a.clear()
print(a) # []

4.6 列表运算符

列表运算符	描述	例子
+	拼接列表	[1, 2, 3] + [4, 5, 6]
*	重复列表	[‘Hi’] * 4
in	判断元素是否存在于列表中	3 in [1, 2, 3]
for ... in	迭代	for x in [1, 2, 3]: print(x, end=" ")

# 1.拼接列表
print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6]

# 2.重复列表
print(['a','b'] * 3) # ['a', 'b', 'a', 'b', 'a', 'b']

# 3.判断元素是否存在于列表中
print(3 in [1, 2, 3]) # True

# 4.遍历列表元素
for i in [1, 2, 3]:
    print(i, end='') # 123
    

4.7 列表比较

1.使用 == 操作符，比较列表

a = [1,2,3]
b = [1,2,3]
c = [1,3,4]

# 比较列表元素
print(a[1] == b[1]) # True
print(a[1] == c[1]) # False

# 比较整个列表
print(a == b) # True
print(a == c) # False

2.使用 operator 模块的 eq 方法，比较列表

from operator import eq

a = [1,2,3]
b = [1,2,3]
c = [1,3,4]

# 比较列表元素
print(eq(a[1],b[1])) # True
print(eq(a[1],c[1])) # False

# 比较整个列表
print(eq(a,b)) # True
print(eq(a,c)) # False

4.8 列表方法

方法	描述
len(list)	获取列表长度
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list.count(obj)	统计某个元素在列表中出现的次数
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.reverse()	反转列表中的元素
list.copy()	复制列表
list.sort( key=None, reverse=False)	对原列表进行排序

1.获取列表长度

a = ['red', 'green', 'blue', 'yellow', 'white', 'black']

print(len(a)) # 6

2.返回列表元素的最大或最小值

a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

print(max(a)) # 10
print(min(a)) # 1

3.统计元素在列表中出现的次数

a = ['red', 'green', 'blue', 'green', 'green', 'black']

print(a.count('green')) # 3

4.查找列表中的元素，返回该元素第一个匹配项的索引位置

a = ['red', 'green', 'blue', 'green', 'green', 'black']

print(a.index('green')) # 1

5.反转列表

a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

a.reverse()
print(a) # [10, 8, 6, 4, 2, 9, 7, 5, 3, 1]

6.复制列表

a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

b = a.copy()
print(b) # [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

7.对列表进行排序

list.sort( key=None, reverse=False)：

• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，True表示降序排序，False表示升序排序（默认）

a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

# 1.升序排序
a.sort()
print(a) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 2.降序排序
a.sort(reverse=True)
print(a) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

5. 元组类型

元组：

• 元组与列表类似，不同之处在于元组的元素不能修改
• 元组使用小括号 ()，列表使用方括号 []

5.1 创建元组

创建元组：创建一个元组，只要把逗号分隔的不同的数据项使用小括号 () 括起来即可。

# 1.创建空元组
tup1 = []

# 2.创建带初始值的元组
tup2 = (1, 2, "abc", "red")

# 3.元组可以嵌套
tup3 = ((1, 2, 3), "abc", ["red", "blue"])

5.2 访问元组

访问元组：访问元组和访问字符串是一样的，如何访问字符串就如何访问元组

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

print(a) # ('red', 'green', 'blue', 'yellow', 'white', 'black')
print(a[0]) # red
print(a[2]) # blue
print(a[-1]) # black

5.3 截取元组

截取元组： 截取元组和截取字符串是一样的，如何截取字符串就如何截取元组

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

# 1.a[x:]，截取范围[x,-1]
print(a[2:]) # ('blue', 'yellow', 'white', 'black')

# 2.a[:y]，截取范围[0,y)
print(a[:3]) # ('red', 'green', 'blue')

# 3.a[x:y]，截取范围[x,y)
print(a[2:4]) # ('blue', 'yellow')

# 4.列表反转
print(a[-1::-1]) # ('black', 'white', 'yellow', 'blue', 'green', 'red')

5.4 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。

注：元组的不可变指的是元组所指向的内存中的内容不可变

1.元组中的元素不允许修改

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

a[1] = 'orange' # TypeError: 'tuple' object does not support item assignment
print(a)

2.拼接元组

tup1 = ('red', 'green')
tup2 = ('blue', 'yellow')

print( tup1 + tup2 ) # ('red', 'green', 'blue', 'yellow')

3.元组的不可变指的是元组所指向的内存中的内容不可变

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')
# 查看内存地址
print(id(a)) # 1223847422624

a = ('red', 'green')
# 发现内存地址不一样了
print(id(a)) # 1223847784512

从以上实例可以看出，重新赋值的元组 a，是绑定到新的对象了，不是修改了原来的对象。

5.5 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

1.元组中的元素不允许删除

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

del a[0] # TypeError: 'tuple' object doesn't support item deletion
print(a)

2.删除整个元组

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

del a
print(a) # NameError: name 'a' is not defined

3.清空元组

此处清空元组，是重新赋值元组，绑定到新的对象了，而不是修改了原来的对象。

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

a=()
print(a) # ()

5.6 元组运算符

元组运算符	描述	例子
+	拼接元组	(1, 2, 3) + (4, 5, 6)
*	重复元组	(‘Hi’) * 4
in	判断元素是否存在于元组中	3 in (1, 2, 3)
for ... in	迭代	for x in (1, 2, 3): print(x, end=" ")

# 1.拼接元组
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

# 2.重复元组
print(('a','b') * 3) # ('a', 'b', 'a', 'b', 'a', 'b')

# 3.判断元素是否存在于元组中
print(3 in (1, 2, 3)) # True

# 4.遍历元组元素
for i in (1, 2, 3):
    print(i, end='') # 123
    

5.7 元组方法

方法	描述
len(tuple)	返回元组长度
max(tuple)	返回元组元素最大值
min(tuple)	返回元组元素最小值

1.获取元组长度

a = ('red', 'green', 'blue', 'yellow', 'white', 'black')

print(len(a)) # 6

2.返回元组元素的最大或最小值

a = (1, 3, 5, 7, 9, 2, 4, 6, 8, 10)

print(max(a)) # 10
print(min(a)) # 1

6. 字典类型

字典：

• 字典是另一种可变容器模型，且可存储任意类型对象
• 字典是以键值对的形式存放数据，键必须是唯一的，但值则不必
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字

6.1 创建字典

1.创建字典：创建一个字典，有两种方式

• 使用大括号 {} 创建字典
• 使用内建函数 dict() 创建字典

字典的每个键值对用冒号 : 分割，每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

# 1.创建空字典
dict1 = {}
dict2 = dict()

# 2.创建带初始值的字典
dict3 = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

# 3.字典可以嵌套
dict4 = {'Name': ['Jack','Bob'], 'Age': (18,19), 'Class': 'First'}

2.字典键的特性

• 同一个键不允许出现两次，创建时如果同一个键被赋值两次，那么后一个值会生效
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

# 1.同一个键被赋值两次，后一个值会生效
dict1 = {'Name': 'Jack', 'Age': 18, 'Age': 20}
print(dict1['Age']) # 20

# 2.列表不能用作键
dict2 = {['Name']: 'Runoob', 'Age': 7} # TypeError: unhashable type: 'list'

6.2 访问字典

1.使用 字典名[键]的语法格式，获取字典元素指定键的值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

# 1.访问整个字典
print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

# 2.访问单个字典元素值，根据key得到value
print(tinydict['Name']) # Jack
print(tinydict['Age']) # 18

注：如果使用字典里没有的键访问数据会报错

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict['Alex']) # KeyError: 'Alex'

2.dict.get(key, default=None)，返回指定键的值，如果键不在字典中返回 default 设置的默认值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict.get('Name')) # Jack
print(tinydict.get('Alex')) # None
print(tinydict.get('Alex',"The name doesn't exist")) # The name doesn't exist

3.dict.setdefault(key, default=None)，和 get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict.setdefault('Name')) # Jack
print(tinydict.setdefault('Age')) # 18

print(tinydict.setdefault('Gender')) # None
print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First', 'Gender': None}

print(tinydict.setdefault('School','MIT')) # MIT
print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First', 'Gender': None, 'School': 'MIT'}

4.dict.items()，以列表返回视图对象，是一个可遍历的key/value 对

• dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
• 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
• 不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(tinydict.items()) # dict_items([('Name', 'Jack'), ('Age', 18), ('Class', 'First')])
print(type(tinydict.items())) # dict_items

5.dict.keys()，以列表返回视图对象，是一个可遍历的key 值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(tinydict.keys()) # dict_keys(['Name', 'Age', 'Class'])
print(type(tinydict.keys())) # dict_keys

6.dict.values()，以列表返回视图对象，是一个可遍历的value 值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print(tinydict) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(tinydict.values()) # dict_values(['Jack', 18, 'First'])
print(type(tinydict.values())) # dict_values

6.3 修改字典

1.使用 = 赋值，修改列表元素

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

# 1.修改原有的字典元素
tinydict['Age'] = 20
print(tinydict) # {'Name': 'Jack', 'Age': 20, 'Class': 'First'}

# 2.新增字典元素到字典末尾
tinydict['Gender'] = 'Male'
print(tinydict) # {'Name': 'Jack', 'Age': 20, 'Class': 'First', 'Gender': 'Male'}

2.dict.update(dict2)，把字典dict2追加到字典dict末尾

dict1 = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
dict2 = {'Gender': 'Male', 'School': 'MIT'}

dict1.update(dict2)
print(dict1) # {'Name': 'Jack', 'Age': 18, 'Class': 'First', 'Gender': 'Male', 'School': 'MIT'}

6.4 删除字典

1.使用 del 关键字，删除字典元素

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

del tinydict['Age'] # 删除键 'Age'
print(tinydict) # {'Name': 'Jack', 'Class': 'First'}

2.dict.pop(key[,default])，删除字典 key（键）所对应的值，返回被删除的值

• key - 要删除的键
• default - 当键 key 不存在时返回的值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

tinydict.pop('Age') # 删除键 'Age'
print(tinydict) # {'Name': 'Jack', 'Class': 'First'}

3.dict.popitem()，删除并返回字典中的最后一对键和值

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

tinydict.popitem()
print(tinydict) # {'Name': 'Jack', 'Age': 18}

4.dict.clear()，清空字典

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

tinydict.clear()
print(tinydict) # {}

6.5 字典方法

方法	描述
dict.copy()	返回一个字典的浅复制
dict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
key in dict	如果键在字典dict里返回true，否则返回false

1.拷贝字典（浅拷贝）

dict1 = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

dict2 = dict1.copy()
print(dict2) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

2.创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

fromkeys方法的语法：dict.fromkeys(seq[, value])

• seq – 字典键值列表
• value – 可选参数, 设置键序列（seq）对应的值，默认为 None

seq = ('name', 'age', 'gender')

dict1 = dict.fromkeys(seq)
print(dict1) # {'name': None, 'age': None, 'gender': None}

dict2 = dict.fromkeys(seq, 10)
print(dict2) # {'name': 10, 'age': 10, 'gender': 10}

3.判断键是否在字典中

tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

print('Age' in tinydict) # True
print('Gender' in tinydict) # False

7. 集合类型

集合：

• 集合（set）是一个无序的不重复元素序列
• 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作

7.1 创建集合

1.创建元组：创建一个元组，有两种方式

• 使用大括号 {} 创建集合，元素之间用逗号 , 分隔
• 使用 set() 函数创建集合

注：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典

# 1.创建空集合
set1 = set()

# 2.创建带初始值的集合
set2 = {1, 2, 3, 4} 
set3 = set([4, 5, 6, 7])   

2.集合的特性：

• 元素不会重复
• 元素是无序的

fruit = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

# 发现重复的元素被剔除了
print(fruit) # {'apple', 'orange', 'banana', 'pear'}

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

# 由于是无序的，每次打印出来的元素顺序可能有变化
print(fruit) # {'pear', 'watermelon', 'orange', 'banana', 'apple'}
print(fruit) # {'watermelon', 'pear', 'orange', 'banana', 'apple'}

7.2 访问集合

1.由于集合是无序的，所以没有下标，不能通过集合名[下标]的方式访问，否则会报错

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

print(fruit[1]) # TypeError: 'set' object is not subscriptable

2.可以直接访问整个集合，或者使用迭代遍历集合

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

# 1.访问整个集合
print(fruit) # {'pear', 'watermelon', 'apple', 'orange', 'banana'}

# 2.迭代遍历集合
for i in fruit:
    print(i,end='|') # banana|apple|watermelon|pear|orange|
    

7.3 修改集合

1.set.add(elmnt)，给集合添加元素

fruit = {'apple', 'orange', 'banana', 'pear'}

fruit.add('watermelon')
print(fruit) # {'pear', 'apple', 'orange', 'watermelon', 'banana'}

2.set.update(set)，添加新的集合到当前集合中

fruit1 = {'apple', 'orange', 'banana', 'pear'}
fruit2 = {'watermelon','apple'}

fruit1.update(fruit2)
print(fruit1) # {'apple', 'orange', 'pear', 'watermelon', 'banana'}

7.4 删除集合

1.移除集合中的指定元素

• set.remove(item)：移除指定元素，当移除一个不存在的元素时，会发生错误
• set.discard(item)：移除指定元素，当移除一个不存在的元素时，不会发生错误

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

fruit.remove('apple')
print(fruit) # {'banana', 'pear', 'orange', 'watermelon'}

fruit.remove('mango') # KeyError: 'mango'
print(fruit)

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

fruit.discard('apple')
print(fruit) # {'banana', 'pear', 'watermelon', 'orange'}

fruit.discard('mango') 
print(fruit) # {'banana', 'pear', 'watermelon', 'orange'}

2.随机移除一个元素

• set.pop()，随机移除一个元素，并返回移除的元素

fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

fruit.pop()
print(fruit) # {'apple', 'banana', 'pear', 'watermelon'}

print(fruit.pop()) # apple
print(fruit) # {'banana', 'pear', 'watermelon'}

7.5 集合运算

集合操作回顾：

• 集合A和B的并集，表示为AUB，元素存在于A中，或存在于B中
• 集合A和B的交集，表示为A∩B，元素存在于A中，且存在于B中
• 集合A和B的差集，表示为A-B，元素存在于A中，且不存在于B中
• 集合A是 B的子集（或集合B包含了A)，表示为A⊆B，集合A中的每一个元素，也需要存在于B中

1.使用运算符完成集合运算：并集、交集、差集

a = {'a', 'b', 'c', 'd', 'r'}
b = {'a', 'c', 'l', 'm', 'z'}

# 1.求a和b的并集
print(a | b) # {'r', 'a', 'z', 'b', 'c', 'l', 'm', 'd'}

# 2.求a和b的交集
print(a & b) # {'a', 'c'}

# 3.求a和b的差集
print(a - b) # {'b', 'd', 'r'}

2.使用集合方法完成集合运算：并集、交集、差集

set.union(set1, set2...)：返回两个或更多集合的并集

• set1 – 必需，合并的目标集合
• set2 – 可选，其他要合并的集合，可以多个

set.intersection(set1, set2 ... etc)：返回两个或更多集合的交集

• set1 – 必需，要查找相同元素的集合
• set2 – 可选，其他要查找相同元素的集合，可以多个

注：intersection_update() 方法与intersection()方法类似，区别在于intersection_update() 方法是直接在原来的集合上移除不重叠的元素，没有返回值

set.difference(set)：返回两个集合的差集

• set – 必需，用于计算差集的集合

注：difference_update() 方法与difference()方法类似，区别在于difference_update() 方法是直接在原来的集合中移除元素，没有返回值

a = {'a', 'b', 'c', 'd', 'r'}
b = {'a', 'c', 'l', 'm', 'z'}

# 1.求a和b的并集
print(a.union(b)) # {'r', 'a', 'z', 'b', 'c', 'l', 'm', 'd'}

# 2.求a和b的交集
print(a.intersection(b)) # {'a', 'c'}

# 3.求a和b的差集
print(a.difference(b)) # {'b', 'd', 'r'}

7.6 集合方法

方法	描述
copy()	拷贝一个集合
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
issubset()	判断指定集合是否为该方法参数集合的子集
issuperset()	判断该方法的参数集合是否为指定集合的子集
symmetric_difference()	返回两个集合中不重复的元素集合
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

1.拷贝集合

a = {'apple', 'orange', 'banana', 'pear'}

b = a.copy()
print(b) # {'orange', 'apple', 'banana', 'pear'}

2.判断两个集合中，是否有相同的元素，如果没有返回 True，否则返回 False

a = {'apple', 'orange', 'banana'}
b = {1, 2, 3, 4}
c = {'apple', "cherry", 'pear'}

# 2.a和b集合中没有共同的元素
print(a.isdisjoint(b)) # True

# 2.a和c集合中有共同的元素
print(a.isdisjoint(c)) # False

3.判断是否为子集

• set.issubset(set)：判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False
• set.issuperset(set)：判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False

根据描述可得，这两个方法是反过来的，a.issubset(b) == b.issuperset(a)，表示判断a是否是b的子集

a = {1, 2, 3}
b = {1, 2, 9}
c = {1, 2, 3, 4, 5, 6}

print(a.issubset(c)) # True
print(b.issubset(c)) # False

4.获取两个集合中不重复的元素集合

• set.symmetric_difference(set)：返回两个集合中不重复的元素集合
• set.symmetric_difference_update(set)：symmetric_difference_update() 方法与symmetric_difference()方法类似，区别在于symmetric_difference_update() 方法是直接在原来的集合中移除元素，没有返回值

a = {1, 2, 3, 4, 5, 6}
b = {1, 2, 3, 7, 8, 9}

print(a.symmetric_difference(b)) # {4, 5, 6, 7, 8, 9}

8. 基本数据类型转换

数据类型转换可以分为两种：

• 隐式类型转换 - 自动完成
• 显式类型转换 - 需要使用类型函数来转换

8.1 隐式类型转换

隐式类型转换：在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

例1：当整数和浮点数进行相加时，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失

num_int = 123
num_float = 1.23
num_new = num_int + num_float

print(type(num_int)) # 
print(type(num_float)) # 
print(type(num_new)) # 
print(num_new) # 124.23

例2：当整型和字符串进行运算时会报错，无法使用隐式转换，此时只能使用显示转换

num_int = 123
num_str = "456"

print(type(num_int)) # 
print(type(num_str)) # 
print(num_int + num_str) # TypeError: unsupported operand type(s) for +: 'int' and 'str'

8.2 显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

以下内置函数可以执行数据类型之间的转换：

函数	描述
[int(x [,base])]	将x转换为一个整数
[float(x)]	将x转换到一个浮点数
[complex(real [,imag])	创建一个复数
[str(x)]	将对象 x 转换为字符串
[oct(x)]	将一个整数转换为一个八进制字符串
[hex(x)]	将一个整数转换为一个十六进制字符串
[repr(x)]	将对象 x 转换为表达式字符串
[eval(str)]	用来计算在字符串中的有效Python表达式，并返回一个对象
[list(s)]	将序列 s 转换为一个列表
[tuple(s)]	将序列 s 转换为一个元组
[dict(d)]	创建一个字典，d 必须是一个 (key, value)元组序列
[set(s)]	转换为可变集合
[frozenset(s)]	转换为不可变集合
[ord(x)]	将一个字符转换为它的ASCII码
[chr(x)]	将一个ASCII码转换为一个字符

1.转换为数字类型

int(x, base=10)：将一个字符串或数字转换为整型

• x – 字符串或数字
• base – 进制数，默认十进制

# 1.字符串或数字，强制转换为整数
print(int(3)) # 3
print(int(3.6)) # 3
print(int('3')) # 3

# 2.如果带参数base的话，要以字符串的形式进行输入
print(int('12',16)) # 18    
print(int('0xa',16)) # 10    
print(int('11',8)) # 9

[float(x)]：将x转换为一个浮点数

print(float(1)) # 1.0
print(float(3.14)) # 3.14
print(float(-3.14)) # -3.14

[complex(real [,imag]) ：创建一个值为 real + imag*j 的复数或者转化一个字符串或数为复数

• real – int、long、float或字符串
• imag – int、long 或 float

print(complex(1)) # (1+0j)
print(complex(1,2)) # (1+2j)

print(complex("1")) # (1+0j)
print(complex("1+2j")) # (1+2j)

注意：complex(“1+2j”)，这个地方在"+“号两边不能有空格，也就是不能写成"1 + 2j”，应该是"1+2j"，否则会报错

2.转换为字符串

# 1.将数字转换为字符串
num = 3.14
print(str(num)) # 3.14

# 2.将列表转换为字符串
color = ['red', 'green', 'blue', 'black']
print(str(color)) # ['red', 'green', 'blue', 'black']

# 3.将元组转换为字符串
workday = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
print(str(workday)) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

# 4.将字典转换为字符串
tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(str(tinydict)) # {'Name': 'Jack', 'Age': 18, 'Class': 'First'}

# 5.将集合转换为字符串
fruit = {'apple', 'orange', 'banana', 'pear'}
print(str(fruit)) # {'orange', 'apple', 'banana', 'pear'}

3.转换和计算字符串表达式

[repr(x)] ：将对象 x 转换为表达式字符串

s1= "物品\t单价\t数量\n包子\t1\t2"
s2 = r"物品\t单价\t数量\n包子\t1\t2"

'''
物品	单价	数量
包子	1	2
'''
print(s1) 

# 读取字符串时，转义字符按原样输出（且字符串两边加上单引号）
print(repr(s1)) # '物品\t单价\t数量\n包子\t1\t2'
print(type(repr(s1))) # 

# 读取字符串时，转义字符按原样输出
print(s2) # 物品\t单价\t数量\n包子\t1\t2
print(type(s2)) # 

eval(expression[, globals[, locals]])：执行一个字符串表达式，并返回表达式的值

• expression – 表达式
• globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
• locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象

注意：eval() 函数执行的代码具有潜在的安全风险。如果使用不受信任的字符串作为表达式，则可能导致代码注入漏洞，因此，应谨慎使用 eval() 函数，并确保仅执行可信任的字符串表达式。

# 1.执行简单的数学表达式
result = eval("2 + 3 * 4")
print(result) # 14

# 2.执行变量引用
x = 10
result = eval("x + 5")
print(result) # 15

# 3.在指定命名空间中执行表达式
namespace = {'a': 2, 'b': 3}
result = eval("a + b", namespace)
print(result) # 5

4.转换为列表

# 1.将字符串转换为列表
color = 'Hello'
print(list(color)) # ['H', 'e', 'l', 'l', 'o']

# 2.将元组转换为列表
workday = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
print(list(workday)) # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

# 3.将字典转换为列表
tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(list(tinydict)) # ['Name', 'Age', 'Class']

# 4.将集合转换为列表
fruit = {'apple', 'orange', 'banana', 'pear'}
print(list(fruit)) # ['orange', 'banana', 'apple', 'pear']

5.转换为元组

# 1.将字符串转换为元组
color = 'Hello'
print(tuple(color)) # ('H', 'e', 'l', 'l', 'o')

# 2.将列表转换为元组
workday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(tuple(workday)) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

# 3.将字典转换为元组
tinydict = {'Name': 'Jack', 'Age': 18, 'Class': 'First'}
print(tuple(tinydict)) # ('Name', 'Age', 'Class')

# 4.将集合转换为元组
fruit = {'apple', 'orange', 'banana', 'pear'}
print(tuple(fruit)) # ('orange', 'apple', 'banana', 'pear')

6.dict()函数用于创建一个字典

dict函数的语法：dict(**kwarg)、dict(mapping, **kwarg)、dict(iterable, **kwarg)

• **kwargs – 关键字。
• mapping – 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
• iterable – 可迭代对象。

# 1.使用关键字参数，来创建字典
print(dict(x=5, y=0)) # {'x': 5, 'y': 0}

# 2.使用函数映射的方式，来创建字典
print(dict(zip(['x', 'y'], [5, 0]))) # {'x': 5, 'y': 0}

# 3.使用可迭代对象方式，来创建字典
print(dict([('x', 5), ('y', 0)])) # {'x': 5, 'y': 0}

7.转换为集合

• set([iterable])：创建一个无序不重复元素集
• frozenset([iterable])：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

# 1.创建一个集合
print(set('Hello')) # {'o', 'H', 'l', 'e'}
print(set(['b','l','u','e'])) # {'l', 'u', 'b', 'e'}

# 2.返回一个冻结的集合，元素不可修改
fruit = frozenset(['apple', 'orange', 'banana', 'pear'])
print(fruit) # frozenset({'apple', 'orange', 'pear', 'banana'})

8.字符与ASCII码（整数）的互相转换

• [ord(x)]：将一个字符转换为它的ASCII码
• [chr(x)]：将一个ASCII码转换为一个字符

# 1.将字符转换为ASCII码
print(ord('1')) # 49
print(ord('a')) # 97

# 2.将ASCII码转换为字符
print(chr(49)) # 1
print(chr(97)) # a