第一章 初识python
1.1 python介绍
1. python是面向对象的
把一切东西看成是一个个对象， 比如人、耳机、鼠标、水杯等，他们各自都有属性， 比如：耳机是白色的，鼠标是黑色的，水杯是圆柱形的等等， 把这些对象拥有的属性变量和操作这些属性变量的函数打包成一个类来表示
面向对象有三大特性：封装，继承，多态。
封装： 将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化， 提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。 意义： 1. 将属性和方法放到一起做为一个整体，然后通过实例化对象来处理； 2. 隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了； 3. 对类的属性和方法增加 访问权限控制。
继承： 在程序中，继承描述的是多个类之间的所属关系， 如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里， 那么类A就是基类，也叫做父类； 类B就是派生类，也叫做子类。 继承进一步提高了代码的复用性。
多态： 所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态 ， 多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
鸭子类型：虽然我想要一只"鸭子"，但是你给了我一只鸟。 但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。
面向过程： 根据业务逻辑从上到下写代码
面向对象： 将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程，什么是面向对象可以看看这篇博客：链接
2. python的优点
a. 代码简短，具有较多的库可以直接使用
3. python的缺点
a. 运行速度慢
b. 代码不能加密
1.2 Python、pycharm、anaconda安装
1、解释器：安装python意思是安装python解释器
2、编辑器
3、包
- 方案一：只安装python解释器
- 方案二：只安装anaconda（自带很多库，还有编辑器，兼容python版本），但是anaconda版本不兼容
- 方案三：安装python解释器+安装pycharm（编辑器）或者VsCode等
- 方案四：安装Anaconda+安装pycharm或者VsCode等
1. pycharm安装
pycharm下载地址：添加链接描述
pycharm参考安装视频：视频链接
2. anaconda安装
anaconda下载地址：链接
anaconda参考安装博客博客
下载老版本的anaconda镜像源：链接
3. Python安装
python下载链接
1.3 print()和input()
1. print()
print()函数将括号内的字符串显示在屏幕上
1.输出数字
print(5) print(5.1)
2.输出字符串
格式1：print（‘内容’）
格式2：print（“内容”）
英文状态下的单引号、双引号都可
print('hello world') print("hello")
不可 ：printf；无括号
错误示例：
printf('hello world') print"hello"
3.含有运算符的表达式
print(3+1)
4
多个输出用逗号隔开，逗号相当于输出空格
print("Hello", "abc")
Hello abc
+：拼接字符串
print('well water'+'river') #字符型拼接
well waterriver
2. input()
函数input()的工作原理：
函数input()让程序暂停运行，等待用户输入一些文本。
获取用户输入后，python将其存储在一个变量里，以便使用
输入的内容为字符串型
例1
number = input("请输入一个整数：") # 字符型 number = int(number) # 字符型转化为整型 if number%2 == 0: print("The number " + str(number) + " is even.") # 偶数 else: print("The number " + str(number) + " is odd.") # 奇数
请输入一个整数：24 The number 24 is even.
1.4 保留字和标识符
1.保留字
一些被赋予特定的意义的
import keyword print(keyword.kwlist)
2.标识符
一些自己命名的变量、函数、模块、类，叫做标识符
1.5 变量和常量
1.变量
message = 'hello world' #message称为变量 print(message)
变量命名规则：
- 变量名只能包含字母、数字和下划线；变量名可以字母或下划线打头，但不能以数字开头。例如，可以message_1，但是不能1_message
- 变量名不能包含空格，但可以用下划线来分隔其中的单词。
- 不要将python关键字和函数名用作变量名
- 变量名应既简短又具有描述性，例如name比n好
- 慎用小写字母l和大写字母O，因为容易与数字1和0混乱
- 字母大小写不同
2.常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。
在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359
1.6 三重引号
功能：
- 多行注释
- 多行赋值
'''多行注释1 多行注释2''' a = ''' 赋值行1 赋值行2''' print(a)
赋值行1 赋值行2
第二章 数据类型
2.1 数据类型(int、float、str、bool、None)
1. 整型int
int，可以表示正数、负数和零
十进制：默认的进制
二进制：以0b开头
八进制：以0o开头
十六进制：以0x开头
print('十进制', 118) print(0b10101111) # 二进制 print(0o176) # 八进制 print(0xF) # 十六进制
十进制 118 175 126 15
2. 浮点型float
a = 3.14 print(type(a))
<class 'float'>
注意： 这里表示小数的加减可能不精确，因为是用二进制存储
n1 = 1.1 n2 = 2.2 print(n1+n2)
3.3000000000000003
可以这样解决：
from decimal import Decimal print(Decimal('1.1')+Decimal('2.2'))
3.3
科学计数法：记录比较大或者比较小的数，是浮点型
a = 15e10 print(a) print(type(a)) b = 15e-10 print(b) print(type(b))
150000000000.0 <class 'float'> 1.5e-09 <class 'float'>
3. 字符串型str
用单引号或者双引号或者三引号括起来，单双都可
print(type('hello')) print(type("hello")) print(type('''hello'''))
<class 'str'> <class 'str'> <class 'str'>
三引号定义的字符串可以分布在连续的多行
例1
print('''hello world''')
hello world
例2
a = 'hello' b = "hello" c = '''hello''' print(a, id(a)) print(b, id(b)) print(c, id(c))
hello 2356647880624 hello 2356647880624 hello 2356647880624
4. 布尔类型
只有True和False两种
布尔值可以用and、or和not运算。
True、False可当0、1运算
a=True+True print(a) a=True*True print(a)
2 1
5. 空值
空值是Python里一个特殊的值，用None表示。
None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
2.2 数据类型转换函数
1. int():转换为整型
字符型转整型
a='520' #字符型 print(int(a))
520 #整型
注意：字符串为小数串会报错
错误实例：
a='520.8' #字符型 print(int(a))
注意：字符串为字母串也会报错
浮点型转整型：是直接去掉小数部分
print(int(-5.99)) #直接去掉小数部分，不是四舍五入 print(int(5.99)) #直接去掉小数部分
-5 5
布尔型转整型
print(int(True)) print(int(False))
1 0
2. float():转换为浮点型
字符型转浮点型
print(float('8'))
8.0
注意：字符串为非数字串会报错
整型转浮点型
print(float(8))
8.0
布尔型转字符串
print(float(True)) print(float(False))
1.0 0.0
3. str():转换为字符串型
a = 10 b = 198.8 c = False print(str(a), str(b), str(c)) print(type(str(a)), type(str(b)), type(str(c)))
10 198.8 False <class 'str'> <class 'str'> <class 'str'>
例
b=str(5e5) print(b)
500000.0
例
b=str(5e19) #所以str不要当变量名 print(b)
5e+19
4. bool()：转换为布尔型
整数0，空字符，空列表，空元组，空字典，空集合都为False
其他均为True
例1：整型
print(bool(0)) print(bool(1)) print(bool(2))
False True True
例2：浮点型
print(bool(0.0)) print(bool(0.1)) print(bool(1.0)) print(bool(2.0))
False True True True
例3：字符型
print(bool('')) print(bool('0')) print(bool('1')) print(bool('abc'))
False True True True
2.3 两个判断类型的内置函数:type()、isintance()
1. type()函数：可输出类型
格式：type(需要判断的)
例1：
a='520' #字符型 print(type(a)) a=5.2 #浮点型 print(type(a)) a=True #布尔类型 print(type(a)) a=5e5 #浮点型 print(type(a))
<class 'str'> <class 'float'> <class 'bool'> <class 'float'>
2. isinstance()函数:可判断对象类型是否正确
格式：inistance(A,类型)
正确输出True，错误输出False
a='小甲鱼' print(isinstance(a,str)) print(isinstance(a,int)) a=1 print(isinstance(a,bool)) print(isinstance(a,int)) a=True print(isinstance(a,bool))
True False False True True
第三章 字符串操作
3.1 字符串的比较操作
运算符：>,>=,<,<=,==,!=
比较规则：
- 首先比较两个字符串中的第一个字符，
如果相等就继续比较下一个字符，
依次比较下去，知道两个字符串中的字符不相等
- 比较原理：
ord()：字符转编码，实际上是比较编码大小
print('apple' > 'app') # True print('apple' > 'banana') # False print(ord('a'), ord('b')) # 所以a < b print(ord('杨')) print(chr(26472)) """== 与 is 的区别 == 比较的是 value is 比较的是 ID是否相等""" a = b = 'python' c = 'python' # a, b, c ID相同 print(a == b, b == c) print(a is b, a is c)
True False 97 98 26472 杨 True True True True
字符串不具有增删改的操作，但是可以切片，同列表相似
3.2 字符串切片操作
s = 'hello,Python' s1 = s[:5] s2 = s[6:] s3 = '!' newstr = s1 + s3 + s2 print(s1) print(s2) print(newstr) print(s[::2])
hello Python hello!Python hloPto
3.3 格式化字符串：{}、%、format()
1. {}作占位符
name = '张三' age = 20 print('我叫{0}，今年{1}岁了'.format(name, age)) print(f'我叫{name}，今年{age}') # 这里多了f
我叫张三，今年20岁了 我叫张三，今年20
例2：数量少可省略不写
print('{}'.format(3.1415926)) print('{0}'.format(3.1415926))
3.1415926 3.1415926
例3：指定小数点后位数
# 总共三位数 print('{0:.3}'.format(3.1415926)) # 三位小数,这里加个f print('{0:.3f}'.format(3.1415926)) # 零代表第一个，可省略不写 print('{:.3f}'.format(3.1415926))
3.14 3.142 3.142
例4：指定总宽度
# 宽度10，3位小数 print('{:10.3f}'.format(3.1415926))
3.142
例
print('{0} love {1}.{2}'.format('I','FishC','com')) # 按索引顺序 print('{a} love {b}.{c}'.format(a='I',b='FishC',c='com')) # 指定 print('{0} love {b}.{c}'.format('I',b='FishC',c='com')) # 顺序+指定
I love FishC.com I love FishC.com I love FishC.com
例：
print('{0}{1}{2}'.format('你','是','猪')) print('{a}{b}{c}'.format(a='你',b='是',c='猪')) print('{0}{b}{c}'.format('你',b='是',c='猪'))
你是猪 你是猪 你是猪
2. %作占位符
name = '张三' age = 20 print('我叫%s，今年%d岁' % (name, age))
我叫张三，今年20岁
例2
print('%d' % 99) print('%10d' % 99) # 宽度10 print('hellohello')
99 99 hellohello
例3
# 表示小数点精度 print('%f' % 3.1415926) # 保留三位小数 print('%.3f' % 3.1415926) # 同时表示宽度精度 # 宽度是所有字符总宽度 print('%10.3f' % 3.1415926) # 宽度10，精度小数点后三位
3.141593 3.142 3.142
3.4 其他字符串操作符
| 符号 | 说明 |
| %c | 格式化字符及其 ASCII 码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同 %e，用科学计数法格式化浮点数 |
| %g | 根据值的大小决定使用 %f 或 %e |
| %G | 作用同 %g，根据值的大小决定使用 %f 或者 %E |
格式化操作符辅助命令
| 符号 | 说明 |
| m.n | m 是显示的最小总宽度，n 是小数点后的位数 |
| - | 用于左对齐 |
| + | 在正数前面显示加号（+） |
| # | 在八进制数前面显示 ‘0o’，在十六进制数前面显示 ‘0x’ 或 ‘0X’ |
| 0 | 显示的数字前面填充 ‘0’ 取代空格 |
1. %c :格式化字符及其 ASCII 码
print('%c' % 97) print('%c %c %c' % (97,98,99))
a a b c
2. %d ：格式化整数
print('%d + %d = %d' % (4,5,4+5))
4 + 5 = 9
3. %o ：格式化无符号八进制数
print('%o' % 10) #十进制转换八进制
12
4. %x ：格式化无符号十六进制数
%X ：格式化无符号十六进制数（大写）
print('%x' % 10) #十进制转换十六进制 print('%X' % 10) print('%X' % 160) #十进制转换十六进制
a A A0
5. %f：格式化浮点数字，可指定小数点后的精度
print('%f' % 27.658) #指定小数点后的精度，float
27.658000
6. %e ：用科学计数法格式化浮点数
%E ：作用同 %e，用科学计数法格式化浮点数
print('%e' % 27.658) #科学技术法技术 print('%E' % 27.658)
2.765800e+01 2.765800E+01
7. %g ：根据值的大小决定使用 %f 或 %e
%G：作用同 %g，根据值的大小决定使用 %f 或者 %E
print('%g' % 27.658) #根据值的大小决定使用 %f 或 %e
27.658
例
print('%5.1f' % 27.658) #5为长度； m.n m 是显示的最小总宽度，n 是小数点后的位数 print('%.2e' % 27.658) #小数点后两位 print('%10d' % 5) #十个空格 print('%+d' % 5)
27.7 2.77e+01 5 +5
例2
print('{{0}}'.format('不打印')) print('{0:.1f}{1}'.format(27.658,'GB'))
{0} 27.7GB
3.5 转义字符
python的转义字符及其含义
| 符号 | 说明 |
| \ ’ | 单引号 |
| \" | 双引号 |
| \a | 发出系统响铃声 |
| \b | 退格符 |
| \n | 换行符 |
| \t | 横向制表符（TAB） |
| \v | 纵向制表符 |
| \r | 回车符 |
| \f | 换页符 |
| \o | 八进制数代表的字符 |
| \x | 十六进制数代表的字符 |
| \0 | 表示一个空字符 |
| \\ | 反斜杠 |
1. \n：换行
print('Languages:\npython\nC\nJavaScript') #换行
Languages: python C JavaScript
2. \t :制表符（TAB），即添加空格
它会用空格补齐不足四个的
print('hello\tworld') # 四个制表位 print('helloo\tworld') print('hellooo\tworld') print('helloooo\tworld')
hello world helloo world hellooo world helloooo world
例：制表符+换行符
print('Languages:\n\tpython\n\tC\n\tJavaScript')
Languages: python C JavaScript
3. \ r：回车符
print('hello\rworld') # return回车，world覆盖了hello
world
4. \ b：退格符
print('hello\bworld') # 退一个格，所以o没了
hellworld
5. \ '：单引号
print('老师说:\'大家好\'')
老师说:'大家好'
例2：
print('let\'s go')
let's go
错误示例：
print('let's go')
6. \ \ :反斜杠
print("http:\\www.baidu.com") # 引号内两个反斜杠相当于一个 print("http:\\\\www.baidu.com")
http:\www.baidu.com http:\\www.baidu.com
7. 原字符：r
原字符，不希望字符串中的转义字符起作用，就是在字符串之前加上r或R
print(r'hello\nworld')
hello\nworld
注意事项：最后一个字符不能是反斜杠
错误实例：
print(r'hello\nworld\')
正确实例：
print(r'hello\nworld\\')
3.6 字符串函数
| 函数 | 作用 |
| capitalize() | 字符串中第一个字符若为小写字母改为大写 |
| casefold() | 将所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度 width 的新字符串 |
| count(sub[, start[, end]]) | 返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。 |
| encode(encoding=‘utf-8’, errors=‘strict’) | 以 encoding 指定的编码格式对字符串进行编码。 |
| endswith(sub[, start[, end]]) | 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。 |
| expandtabs([tabsize=8]) | 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。 |
| find(sub[, start[, end]]) | 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。 |
| index(sub[, start[, end]]) | 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。 |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 |
| isdecimal() | 如果字符串只包含十进制数字则返回 True，否则返回 False。 |
| isdigit() | 如果字符串只包含数字则返回 True，否则返回 False。 |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。 |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False。 |
| isspace() | 如果字符串中只包含空格，则返回 True，否则返回 False。 |
| istitle() | 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。 |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。 |
| join(sub) | 以字符串作为分隔符，插入到 sub 中所有的字符之间。 |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| lower() | 转换字符串中所有大写字符为小写。 |
| lstrip() | 去掉字符串左边的所有空格 |
| partition(sub) | 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 (‘原字符串’, ‘’, ‘’) |
| replace(old, new[, count]) | 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。 |
| rfind(sub[, start[, end]]) | 类似于 find() 方法，不过是从右边开始查找。 |
| rindex(sub[, start[, end]]) | 类似于 index() 方法，不过是从右边开始。 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| rpartition(sub) | 类似于 partition() 方法，不过是从右边开始查找。 |
| rstrip() | 删除字符串末尾的空格。 |
| split(sep=None, maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。 |
| splitlines(([keepends])) | 在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。 |
| startswith(prefix[, start[, end]]) | 检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。 |
| swapcase() | 翻转字符串中的大小写。 |
| title() | 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。 |
| translate(table) | 根据 table 的规则（可以由 str.maketrans(‘a’, ‘b’) 定制）转换字符串中的字符。 |
| upper() | 转换字符串中的所有小写字符为大写。 |
| zfill(width) | 返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。 |
1. 字符串查询方法
- .index()：查找子串第一次出现的索引值，不存在便报错
- .rindex()：查找子串最后一次出现的索引值，不存在便报错
- .find()：查找子串第一次出现的索引值，不存在返回 -1
- .rfind()：查找子串最后一次先hu的索引值，不存在返回 -1
s = 'hello.hello' print(s.index('lo')) print(s.find('lo')) print(s.rindex('lo')) print(s.rfind('lo'))
3 3 9 9
总结：index索引不存在的会报错，find索引不存在的会报-1.
2. 字符串大写转换
- .upper()：把字符串所有字符都转换成大写字母
- .lower()：把字符串中所有字符都转成小写字母
- .swapcase()：把字符串所有的大写字母转成小写字母，把所有的小写字母都转成大写字母
- .capitalize()：把第一个字符转成大写，把其余字符转成小写
- .title()：把每个单词的第一个字符转换为大写，把每个单词的剩余字符转成小写
暂时的，不覆盖原来的变量
例1：upper()、lower()
name = 'Ada Lovelace' print(name.upper()) #输出字母全改大写 print(name.lower()) #全小写
ADA LOVELACE ada lovelace
例2
s = 'hello.hello' a = s.upper() b = s.lower() print(a, id(a)) print(s, id(s)) print(b, id(b)) print(s, id(s)) print(b == s) print(b is s)
HELLO.HELLO 2409263131824 hello.hello 2409263073264 hello.hello 2409263115952 hello.hello 2409263073264 True False
例3：.swapcase()
s2 = 'hello,Python' print(s2.swapcase()) print(s2)
HELLO,pYTHON hello,Python
例4：.capitalize()
str1='xiaoxie' print(str1.capitalize()) str2='123xiaoxie' #数字不行 print(str2.capitalize()) str3='DAxie' print(str3.capitalize())
Xiaoxie 123xiaoxie Daxie
例5： .title()
name = 'ada lovelace' print(name.title())
Ada Lovelace
在name.title()中，name后面的句点(.)让python对变量name执行title()指定的操作
3. 字符串对齐
- .center()：居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
- .ljust()：左对齐，第一个参数指定宽度，第二个参数指定填充符，第二参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
- rjust()：右对齐，第一个参数指定宽度，第二个参数指定填充符，第二参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
- zfill()：右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身
例1：.center()
s = 'hello.Python' # 长度12 """居中""" print(s.center(20, '*')) # 居中对齐，宽度20，填充符*
****hello.Python****
例2：.ljust()
s = 'hello.Python' # 长度12 """左对齐""" print(s.ljust(20, '*')) # 左对齐 print(s.ljust(10)) # 10 < 12,返回原字符
hello.Python******** hello.Python
例3：rjust()
s = 'hello.Python' # 长度12 """右对齐""" print(s.rjust(20, '*')) print(s.rjust(20)) # 默认填充空格 print(s.rjust(10))
********hello.Python hello.Python hello.Python
例4：zfill()
s = 'hello.Python' # 长度12 """右对齐，用0填充""" print(s.zfill(20)) print(s.zfill(10)) # 返回原字符 print('-8941'.zfill(8))
00000000hello.Python hello.Python -0008941
4. startswith()和endswith()
- startswith()返回True，则所调用的字符串以该方法开始
- endswith()返回True，则所调用的字符串以该方法结束
a = 'Hello World'.startswith("Hello") b = 'Hello World'.startswith("abc") c = 'Hello World'.endswith("World") d = 'Hello World'.endswith("abc") print(a, b, c, d)
True False True False
5. join()和split()
- join()将字符串连接起来
- split()从字符串左边，将字符串劈分，默认空格劈分，返回一个列表
- rsplit()从字符串右边，将字符串劈分，默认空格劈分，返回一个列表
a = ','.join(['cats', 'rats', 'bats']) b = ' '.join(['cats', 'rats', 'bats']) c = 'A'.join(['cats', 'rats', 'bats']) print(a + '\n' + b + '\n' + c)
cats,rats,bats cats rats bats catsAratsAbats
'字符串'.split(sep='劈分符', maxsplit=最大劈分次数)
.split()
- 从字符串的左边开始劈分，默认的劈分字符是空字符串，返回的值都是一个列表
- 通过参数sep指定劈分字符串的劈分符
- 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次数劈分之后，剩余的子串会单独作为一部分
.rsplit()
- 从字符串的右边开始劈分，默认的劈分字符是空字符串，返回的值都是一个列表
- 通过参数sep指定劈分字符串的劈分符
- 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次数劈分之后，剩余的子串会单独作为一部分
s = 'hello world Python' list1 = s.split() print(list1) s1 = 'hello|world|Python' print(s1.split(sep='|')) print(s1.split(sep='|', maxsplit=1)) # 劈分一次 print('-----------------') """rsplit从右侧开始劈分""" print(s.rsplit()) print(s1.rsplit('|')) print(s1.rsplit(sep='|', maxsplit=1)) # 从右边劈分一次
['hello', 'world', 'Python'] ['hello', 'world', 'Python'] ['hello', 'world|Python'] ----------------- ['hello', 'world', 'Python'] ['hello', 'world', 'Python'] ['hello|world', 'Python']
6. isX字符串方法
- isalpha()返回True，如果字符串只包含字母，并且非空
- isalnum()返回True，如果字符串只包含字母和数字，并且非空
- isdecimal()返回True，如果字符串只包含数字字符，并且非空
- isspace()返回True，如果字符串只包含空格、制表符和换行，并且非空
- istitle()返回True， 如果字符串只包含以大写开头、后面都是小写字母的单词
- .isidentifier()：判断指定的字符串是不是合法的标识符
- isnumeric()：判断指定的字符串是否全部由数字组成
- islower()
例1：.isidentifier()
"""判断指定的字符串是不是合法的标识符""" s = 'hello.python' print('1.', s.isidentifier()) # False print('2.', 'hello'.isidentifier()) # True print('3.', '张三'.isidentifier()) # True print('4.', '张三_123'.isidentifier()) # True
1. False 2. True 3. True 4. True
例2： .isspace()
"""判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）""" print('5.', '\t'.isspace()) # True，制表符
5. True
例3：.isalpha()
'''判断指定的字符串是否全部由字母组成''' print('6.', 'abc'.isalpha()) # True，全是字母 print('7.', '张三'.isalpha()) # True，全是汉字这里也对的 print('8.', '张三1'.isalpha()) # False，汉字加数字不行
6. True 7. True 8. False
例4：.isdecimal()
判断指定的字符串是否全部由十进制的数字组成
'''判断指定的字符串是否全部由十进制的数字组成''' print('9.', '123'.isdecimal()) # True，十进制数字 print('10.', '123四'.isdecimal()) # False，汉字不行 print('11.', 'ⅡⅡⅡ'.isdecimal()) # False，罗马数字不行
9. True 10. False 11. False
例5： isnumeric()
判断指定的字符串是否全部由数字组成
'''判断指定的字符串是否全部由数字组成''' print('12.', '123'.isnumeric()) # True，全是数字 print('13.', '123四'.isnumeric()) # True，有汉字也是对滴 print('14.', 'ⅡⅡⅡ'.isnumeric()) # True，罗马数字不行
12. True 13. True 14. True
例6： isallnum()
判断指定的字符串是否全部由字母和数字组成
'''判断指定的字符串是否全部由字母和数字组成''' print('15.', 'abc'.isalnum()) # True，全是字母 print('16.', '张三abc'.isalnum()) # True，有汉字也是对滴 print('17.', 'abc！'.isalnum()) # False，感叹号不行
15. True 16. True 17. False
例7：islower()、istitle()
str='小甲鱼' print(str.islower()) str1 = 'Abc' print(str1.istitle())
False True
7. 字符串替换
.replace()：字符串的替换
- 第一个参数指定被替换的子串，
- 第二个参数指定替换子串的字符串
该方法返回替换后得到的字符串，替换前的字符串不发生变化，
调用该方法时可以通过第三个参数指定最大替换次数。
s = 'hello, python' print(s.replace('python', 'Java')) s1 = 'hello, python, python, python' print(s1.replace('python', 'Java', 2)) # 这里指定替换次数
hello, Java hello, Java, Java, python
8. 字符串删除空格字符
- rstrip()：删除右边，right，暂时的
- lstrip()：删除左边，left
- strip()：删除两边
例1
>>> favorite_language = 'python ' >>> favorite_language 'python ' >>> favorite_language.rstrip() #删除右边空格字符 'python' >>> favorite_language #暂时的删除，访问还是原来值 'python '
例2
>>> favorite_language = 'python ' >>> favorite_language = favorite_language.rstrip() #重新赋值覆盖变量 >>> favorite_language 'python'
例3
>>> favorite_language = ' python ' #两边都有空格 >>> favorite_language.rstrip() #删除右边 ' python' >>> favorite_language.lstrip() #删除左边 'python ' >>> favorite_language.strip() #删除两边
9. 其他
casefold()：所有字符改小写
str1 = 'DAXIE' print(str1.casefold())
daxie
count（sub[, start[, end]]）：
返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
str1='xiapxie' print(str1.count('xi')) #两次
2
encode(encoding=‘utf-8’, errors=‘strict’)
以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]])
检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
str1='xiapxie' print(str1.endswith('xi')) print(str1.endswith('xie'))
False True
expandtabs([tabsize=8])
把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
str3 = 'I\tlove\tyou' print(str3.expandtabs())
I love you
例
str1='ab111de' print(str1.translate(str.maketrans('1','c')))
abcccde
