赞
踩
Python3 中常见的数据类型有:
Python3 的六个标准数据类型中:
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 |
运算:+
, -
, *
,/
和 %
# 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
注:除法
/
总是返回一个浮点数
数学常量:
常量 | 描述 |
---|---|
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
随机数:可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
函数 | 描述 |
---|---|
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
函数 | 描述 |
---|---|
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
数据类型的转换,只需要将数据类型作为函数名即可:
int(x)
: 将x转换为一个整数float(x)
: 将x转换到一个浮点数complex(x)
: 将x转换到一个复数,实数部分为 x,虚数部分为 0complex(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
字符串是 Python 中最常用的数据类型,可以使用单引号''
或双引号""
来创建字符串。
访问字符串:
变量
变量[下标]
,下标为正代表正序,下标为负代表逆序。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
截取子字符串有两种方式:变量[头下标:尾下标]
和变量[头下标:尾下标:步长]
操作符 | 描述 |
---|---|
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
在需要在字符中使用特殊字符时,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
操作符 | 描述 |
---|---|
+ | 字符串连接 |
* | 重复输出字符串 |
[] | 通过索引获取字符串中字符 |
[ : ] | 截取字符串中的一部分,遵循左闭右开原则,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
%
代表格式符(也叫占位符),其语法规则如下:
%[(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
str.format()
是 python2.6
开始新增的一种格式化字符串的函数 ,它增强了字符串格式化的功能。
{}
和 :
来代替以前的 %
,其中 {}
表示占位符 :
表示格式化。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
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
函数 | 描述 |
---|---|
len(string) | 返回字符串长度 |
a = "Hello World"
b = "H "
print(len(a)) # 11
print(len(b)) # 3
函数 | 描述 |
---|---|
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
函数 | 描述 |
---|---|
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
函数 | 描述 |
---|---|
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
函数 | 描述 |
---|---|
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))
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')
分隔,返回一个包含各行作为元素的列表,# 读取到的文本内容
text = '''Hello
C
C++
Python
Java
'''
print(text.splitlines()) # ['Hello', 'C', 'C++', 'Python', 'Java']
3.join方法的语法:str.join(sequence)
lists = ['H','e','l','l','o']
print("".join(lists)) # Hello
print("-".join(lists)) # H-e-l-l-o
函数 | 描述 |
---|---|
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
函数 | 描述 |
---|---|
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])
print("abc".center(8,'*')) # **abc***
print("abc".center(9,'*')) # ***abc***
print("abc".center(9)) # abc
2.字符串左对齐,右边填充字符
ljust方法的语法:str.ljust(width[, fillchar])
print("abc".ljust(8,'*')) # abc*****
print("abc".ljust(8)) # abc
3.字符串右对齐,左边填充字符
rjust方法的语法:str.rjust(width[, fillchar])
print("abc".rjust(8,'*')) # *****abc
print("abc".rjust(8)) # abc
4.字符串右对齐,左边填充字符0
zfill方法的语法:str.zfill(width)
print("abc".zfill(8)) # 00000abc
函数 | 描述 |
---|---|
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))
注:当 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))
,判断字符串是否以指定值开头
注:当 beg 和 end 有值时,取值范围为左开右闭 [beg ,end)
endswith方法的语法:str.endswith(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
注:当 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
函数 | 描述 |
---|---|
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 对象
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.创建空列表
list1 = []
# 2.创建带初始值的列表
list2 = [1, 2, "abc", "red"]
# 3.列表可以嵌套
list3 = [[1, 2, 3], "abc", ["red", "blue"]]
访问列表:访问列表和访问字符串是一样的,如何访问字符串就如何访问列表
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
截取列表: 截取列表和截取字符串是一样的,如何截取字符串就如何截取列表
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.使用 =
赋值,修改列表元素
a = ['red', 'green']
a[1] = 'blue'
print(a) # ['red', 'blue']
2.list.append(obj)
,向列表末尾追加元素
a = ['red', 'green']
a.append('blue')
a.append(10)
print(a) # ['red', 'green', 'blue', 10]
3.list.extend(seq)
,向列表末尾追加另一个序列(用新列表扩展原来的列表)
a = ['red', 'green']
b = ['blue', 'yellow', 'white', 'black']
a.extend(b)
print(a) # ['red', 'green', 'blue', 'yellow', 'white', 'black']
4.list.insert(index, obj)
,插入元素到列表的指定位置
插入元素到指定位置,原先的元素往后移一位(例如:插入元素到索引为2的位置,那么原先索引为2及2之后的元素,都向后移一位)
a = ['red', 'green', 'blue', 'yellow', 'white']
a.insert(2,'black')
print(a) # ['red', 'green', 'black', 'blue', 'yellow', 'white']
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])
,移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
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)
,用于移除列表中某个值的第一个匹配项
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.使用 =
赋值为空,清空列表元素
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) # []
列表运算符 | 描述 | 例子 |
---|---|---|
+ | 拼接列表 | [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.使用 ==
操作符,比较列表
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
方法 | 描述 |
---|---|
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)
:
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.创建空元组
tup1 = []
# 2.创建带初始值的元组
tup2 = (1, 2, "abc", "red")
# 3.元组可以嵌套
tup3 = ((1, 2, 3), "abc", ["red", "blue"])
访问元组:访问元组和访问字符串是一样的,如何访问字符串就如何访问元组
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
截取元组: 截取元组和截取字符串是一样的,如何截取字符串就如何截取元组
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.元组中的元素不允许修改
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,是绑定到新的对象了,不是修改了原来的对象。
元组中的元素值是不允许删除的,但我们可以使用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) # ()
元组运算符 | 描述 | 例子 |
---|---|---|
+ | 拼接元组 | (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
方法 | 描述 |
---|---|
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
字典:
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'
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),提供了字典实体的动态视图,这就意味着字典改变,视图也会跟着变化。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
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'}
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(键)所对应的值,返回被删除的值
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) # {}
方法 | 描述 |
---|---|
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 = ('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
集合:
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'}
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|
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'}
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'}
集合操作回顾:
AUB
,元素存在于A中,或存在于B中A∩B
,元素存在于A中,且存在于B中A-B
,元素存在于A中,且不存在于B中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...)
:返回两个或更多集合的并集
set.intersection(set1, set2 ... etc)
:返回两个或更多集合的交集
注:
intersection_update()
方法与intersection()方法类似,区别在于intersection_update() 方法是直接在原来的集合上移除不重叠的元素,没有返回值
set.difference(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'}
方法 | 描述 |
---|---|
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,否则返回 Falseset.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}
数据类型转换可以分为两种:
隐式类型转换:在隐式类型转换中,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
例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'
在显式类型转换中,用户将对象的数据类型转换为所需的数据类型。 我们使用 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)
:将一个字符串或数字转换为整型
# 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
的复数或者转化一个字符串或数为复数
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))) # <class 'str'> # 读取字符串时,转义字符按原样输出 print(s2) # 物品\t单价\t数量\n包子\t1\t2 print(type(s2)) # <class 'str'>
eval(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)
# 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
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。