当前位置:   article > 正文

【Python】Python的六大基本数据类型及其API详解_python 基本类型api

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进制的形式。

intfloatcomplex
100.03.14j
10015.2045.j
-786-21.99.322e-36j
08032.3e+18.876j
-0490-90.-.6545+0J
-0x260-32.54e1003e+26J
0x6970.2E-124.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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
'
运行

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
'
运行

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

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

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
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

2.反斜杠、单、双引号

print("\\") # \
print("\'") # '
print("\"") # "
  • 1
  • 2
  • 3
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
'
运行

4.横向、纵向制表符

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

3.5 字符串格式化

3.5.1 格式化符号

% 代表格式符(也叫占位符),其语法规则如下:

%[(name)][flags][width].[precision]typecode
  • 1
  • (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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

3.5.3 f-string

f-stringpython3.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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

3.6 字符串方法

3.6.1 字符串长度

函数描述
len(string)返回字符串长度
a = "Hello World"
b = "H  "

print(len(a)) # 11
print(len(b)) # 3
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
'
运行

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']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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

  • sequence – 要连接的元素序列
  • 返回通过指定字符连接序列中元素后生成的新字符串
lists = ['H','e','l','l','o']

print("".join(lists)) # Hello
print("-".join(lists)) # H-e-l-l-o
  • 1
  • 2
  • 3
  • 4
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
'
运行

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    
  • 1
  • 2
  • 3
'
运行

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

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

  • width – 指定填充指定字符后中字符串的总长度
  • fillchar – 填充的字符,默认为空格
print("abc".ljust(8,'*')) # abc*****
print("abc".ljust(8)) # abc    
  • 1
  • 2
'
运行

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

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

  • width – 指定填充指定字符后中字符串的总长度
  • fillchar – 填充的字符,默认为空格
print("abc".rjust(8,'*')) # *****abc
print("abc".rjust(8)) #      abc
  • 1
  • 2
'
运行

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

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

  • width – 指定填充指定字符后中字符串的总长度
print("abc".zfill(8)) # 00000abc
  • 1
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

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

  • max(str):返回字符串 str 中最大的字母
  • min(str):返回字符串 str 中最小的字母
str = "abcd"

print(max(str)) # d
print(min(str)) # a
  • 1
  • 2
  • 3
  • 4
'
运行

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 解码:中国

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
'
运行

4. 列表类型

序列:

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

列表:

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

4.1 创建列表

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

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

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

# 3.列表可以嵌套
list3 = [[1, 2, 3], "abc", ["red", "blue"]]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

4.4 更新列表

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

a = ['red', 'green']

a[1] = 'blue'
print(a) # ['red', 'blue']
  • 1
  • 2
  • 3
  • 4
'
运行

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

  • obj – 添加到列表末尾的对象
a = ['red', 'green']

a.append('blue')
a.append(10)
print(a) # ['red', 'green', 'blue', 10]
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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']
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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']
  • 1
  • 2
  • 3
  • 4
'
运行

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']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

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']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

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']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

4.5.2 清空列表元素

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

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

a = []
print(a) # []
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

del a[:]
print(a) # []
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

a.clear()
print(a) # []
  • 1
  • 2
  • 3
  • 4
'
运行

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
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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
  • 1
  • 2
  • 3
'
运行

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

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

print(max(a)) # 10
print(min(a)) # 1
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

print(a.count('green')) # 3
  • 1
  • 2
  • 3
'
运行

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

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

print(a.index('green')) # 1
  • 1
  • 2
  • 3
'
运行

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]
  • 1
  • 2
  • 3
  • 4
'
运行

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]
  • 1
  • 2
  • 3
  • 4
'
运行

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]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

5. 元组类型

元组:

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

5.1 创建元组

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

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

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

# 3.元组可以嵌套
tup3 = ((1, 2, 3), "abc", ["red", "blue"])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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')

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

5.4 修改元组

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

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

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

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

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

2.拼接元组

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

print( tup1 + tup2 ) # ('red', 'green', 'blue', 'yellow')
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

a = ('red', 'green')
# 发现内存地址不一样了
print(id(a)) # 1223847784512
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

从以上实例可以看出,重新赋值的元组 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)
  • 1
  • 2
  • 3
  • 4

2.删除整个元组

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

del a
print(a) # NameError: name 'a' is not defined
  • 1
  • 2
  • 3
  • 4

3.清空元组

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

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

a=()
print(a) # ()
  • 1
  • 2
  • 3
  • 4
'
运行

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
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
'
运行

5.7 元组方法

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

1.获取元组长度

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

print(len(a)) # 6
  • 1
  • 2
  • 3
'
运行

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

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

print(max(a)) # 10
print(min(a)) # 1
  • 1
  • 2
  • 3
  • 4
'
运行

6. 字典类型

字典:

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

6.1 创建字典

1.创建字典:创建一个字典,有两种方式

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

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

d = {key1 : value1, key2 : value2, key3 : value3 }
  • 1
# 1.创建空字典
dict1 = {}
dict2 = dict()

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

# 3.字典可以嵌套
dict4 = {'Name': ['Jack','Bob'], 'Age': (18,19), 'Class': 'First'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

2.字典键的特性

  • 同一个键不允许出现两次,创建时如果同一个键被赋值两次,那么后一个值会生效
  • 键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
# 1.同一个键被赋值两次,后一个值会生效
dict1 = {'Name': 'Jack', 'Age': 18, 'Age': 20}
print(dict1['Age']) # 20

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

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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

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

print(tinydict['Alex']) # KeyError: 'Alex'
  • 1
  • 2
  • 3

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
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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'}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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'}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

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'}
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

6.4 删除字典

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

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

del tinydict['Age'] # 删除键 'Age'
print(tinydict) # {'Name': 'Jack', 'Class': 'First'}
  • 1
  • 2
  • 3
  • 4
'
运行

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'}
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

tinydict.popitem()
print(tinydict) # {'Name': 'Jack', 'Age': 18}
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

tinydict.clear()
print(tinydict) # {}
  • 1
  • 2
  • 3
  • 4
'
运行

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'}
  • 1
  • 2
  • 3
  • 4
'
运行

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}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

3.判断键是否在字典中

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

print('Age' in tinydict) # True
print('Gender' in tinydict) # False
  • 1
  • 2
  • 3
  • 4
'
运行

7. 集合类型

集合:

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

7.1 创建集合

1.创建元组:创建一个元组,有两种方式

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

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

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

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

2.集合的特性:

  • 元素不会重复
  • 元素是无序的
fruit = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

# 发现重复的元素被剔除了
print(fruit) # {'apple', 'orange', 'banana', 'pear'}
  • 1
  • 2
  • 3
  • 4
'
运行
fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

# 由于是无序的,每次打印出来的元素顺序可能有变化
print(fruit) # {'pear', 'watermelon', 'orange', 'banana', 'apple'}
print(fruit) # {'watermelon', 'pear', 'orange', 'banana', 'apple'}
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

7.2 访问集合

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

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

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

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|
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

7.3 修改集合

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

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

fruit.add('watermelon')
print(fruit) # {'pear', 'apple', 'orange', 'watermelon', 'banana'}
  • 1
  • 2
  • 3
  • 4
'
运行

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

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

fruit1.update(fruit2)
print(fruit1) # {'apple', 'orange', 'pear', 'watermelon', 'banana'}
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

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)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
fruit = {'apple', 'orange', 'banana', 'pear', 'watermelon'}

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

fruit.discard('mango') 
print(fruit) # {'banana', 'pear', 'watermelon', 'orange'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

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'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

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'}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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'}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

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'}
  • 1
  • 2
  • 3
  • 4
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
'
运行

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}
  • 1
  • 2
  • 3
  • 4
'
运行

8. 基本数据类型转换

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

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

8.1 隐式类型转换

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

例1:当整数和浮点数进行相加时,较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失

num_int = 123
num_float = 1.23
num_new = num_int + num_float

print(type(num_int)) # <class 'int'>
print(type(num_float)) # <class 'float'>
print(type(num_new)) # <class 'float'>
print(num_new) # 124.23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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

num_int = 123
num_str = "456"

print(type(num_int)) # <class 'int'>
print(type(num_str)) # <class 'str'>
print(num_int + num_str) # TypeError: unsupported operand type(s) for +: 'int' and 'str'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
'
运行

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

print(float(1)) # 1.0
print(float(3.14)) # 3.14
print(float(-3.14)) # -3.14
  • 1
  • 2
  • 3
'
运行

[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)
  • 1
  • 2
  • 3
  • 4
  • 5
'
运行

注意: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'}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
'
运行

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))) # <class 'str'>

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
'
运行

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
'
运行

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']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
'
运行

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')

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
'
运行

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}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
'
运行

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'})
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
'
运行
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/喵喵爱编程/article/detail/791999
推荐阅读
相关标签
  

闽ICP备14008679号