一、逻辑运算符
1.1.算术运算符
运算符 |
描述 |
+ |
加 - 两个对象相加 |
- |
减 - 得到负数或是一个数减去另一个数 |
* |
乘 - 两个数相乘或是返回一个被重复若干次的字符串 |
/ |
除 - x除以y |
% |
取模 - 返回除法的余数 |
** |
幂 - 返回x的y次幂 |
// |
取整除 - 返回商的整数部分 |
a = 5 b = 3 print(a + b) print(a - b) print(a * b) print(a / b) print(a // b) print(a % b) print(a ** b)返回结果：
8
2
15
1.6666666666666667
2
125
1
1.2.比较运算符
运算符 |
描述 |
== |
等于 - 比较对象是否相等 |
!= |
不等于 - 比较两个对象是否不相等 |
<> |
大于 - 返回x是否大于y python3已经取消 |
> |
大于 - 返回x是否大于y |
< |
小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 |
>= |
大于等于 - 返回x是否大于等于y |
<= |
小于等于 - 返回x是否小于等于y |
a = 5 b = 3 print(a == b) print(a != b) print(a > b) print(a < b) print(a >= b) print(a <= b)返回结果：
False
True
True
False
True
False
1.3.赋值运算符
运算符 |
描述 |
备注 |
= |
简单的赋值运算符 |
|
+= |
加法赋值运算符 |
c += a 等效于 c = c + a |
-= |
减法赋值运算符 |
c -= a 等效于 c = c - a |
*= |
乘法赋值运算符 |
c *= a 等效于 c = c * a |
/= |
除法赋值运算符 |
c /= a 等效于 c = c / a |
%= |
取模赋值运算符 |
c %= a 等效于 c = c % a |
**= |
幂赋值运算符 |
c **= a 等效于 c = c ** a |
//= |
取整除赋值运算符 |
c //= a 等效于 c = c // a |
示例：
a = 5 b = 3 c = 0 c = a + b print(c) a += b print(a) a -= b print(a) a *= b print(a) a /= b print(a) a %= b print(a) a **= b print(a) a //= b print(a)
结果：
8
8
5
15
5.0
2.0
8.0
2.0
1.4.逻辑运算符
运算符 |
逻辑表达式 |
描述 |
and |
x and y |
布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 |
or |
x or y |
布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值 |
not |
not x |
布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True |
示例：
a = 5
b = 3
print("结果为True")
else:
print("a和b有一个不为true")
if(a or b):
print("a 或 b 有一个是true，结果为true")
else:
print("a 和 b 都不为true,返回结果是false")
print("======================================================")
a = 0
if(a and b):
print("结果为True")
else:
print("a=0,返回结果为 False")
if (a or b):
print("a=0,b!=0，结果为true")
else:
print("a和b都是0,返回结果是false")
if(not(a and b)):
print("a=0，a and b 返回的结果是false,not取反，返回结果是true")
else:
print("a and b返回结果是true，最终返回结果是false")
结果：
结果为Truea 或 b 有一个是true，结果为true======================================================a=0,返回结果为 Falsea=0,b!=0，结果为truea=0，a and b 返回的结果是false,not取反，返回结果是true
1.5.成员运算符
运算符 |
描述 |
in |
如果在指定的序列中找到值返回 True，否则返回 False。 |
not in |
如果在指定的序列中没有找到值返回 True，否则返回 False。 |
示例：
a = 3
b = 10
list = [1,2,3,4,5,6]
if(a in list):
print("a in list,return true")
else:
print("a not in list,return false")
if(a not in list):
print("List does not contain b,return true")
else:
print("List contain b,return false")
结果：
a in list,return true
List contain b,return false
1.6.身份运算符
运算符 |
描述 |
说明 |
is |
is 是判断两个标识符是不是引用自一个对象 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
Is not |
is not 是判断两个标识符是不是引用自不同对象 |
x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注： id() 函数用于获取对象内存地址。
示例：
a = 20
b = 20
if ( a is b ):
print("1 - a 和 b 有相同的标识")
else:
print("1 - a 和 b 没有相同的标识")
if ( a is not b ):
print("2 - a 和 b 没有相同的标识")
else:
print("2 - a 和 b 有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
print("3 - a 和 b 有相同的标识")
else:
print("3 - a 和 b 没有相同的标识")
if ( a is not b ):
print("4 - a 和 b 没有相同的标识")
else:
print("4 - a 和 b 有相同的标识")
结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
1.7.运算符优先等级
运算符 |
描述 |
** |
指数 (最高优先级) |
~ + - |
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // |
乘，除，取模和取整除 |
+ - |
加法减法 |
>> << |
右移，左移运算符 |
& |
位 'AND' |
<= < > >= |
比较运算符 |
== != |
等于运算符 |
= %= /= //= -= += *= **= |
赋值运算符 |
is is not |
身份运算符 |
in not in |
成员运算符 |
not or and |
逻辑运算符 |
二、字符串
2.1. 字符串方法
2.1.1. find()方法
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1
语法
str.find(str, beg=0, end=len(string))
str.rfind(str, beg=0 end=len(string))
参数
str -- 查找的字符串beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
返回值
find()：如果包含子字符串返回开始的索引值，否则返回-1。
rfind()：返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
示例
str1 = "this is really a string example let is test is try again apple"
str2 = "is"
print (str1.rfind(str2))
print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))
print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))
返回结果如下
44
5
-1
2
2
-1
2.1.2.replace()方法
语法：
str.replace(old, new[, max])
参数：
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
返回值：
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次
示例
str1 = "this is 3sss"
str2 = "6666"
print("replace character is",str1.replace("3sss",str2))
str3 = "aaa123kkkk123dddd123uuu123"
print(str3.replace("123","OK",3))
结果：
replace character is this is 6666
aaaOKkkkkOKddddOKuuu123
2.1.3.strip()、lstrip()、rstrip()
strip() 方法用于移除字符串头尾指定的字符（默认为空格）lstrip() 方法用于截掉字符串左边的空格或指定字符。
rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.
语法：
str.strip([chars])
str.lstrip([chars])
str.rstrip([chars])
参数：
chars -- 指定截取的字符（默认为空格）
返回值：
strip()返回移除字符串头尾指定的字符生成的新字符串
lstrip() 返回截掉字符串左边的空格或指定字符后生成的新字符串
rstrip() 返回删除 string 字符串末尾的指定字符后生成的新字符串
示例：
str = "#####this is string example let us try it!!!#####"
print("删除字符串头尾指定的字符串：{0}".format(str.strip("#")))
print("删除字符串左侧指定的字符串：{0}".format(str.lstrip("#")))
print("删除字符串右侧指定的字符串：{0}".format(str.rstrip("#")))
结果：
删除字符串头尾指定的字符串：this is string example let us try it!!!
删除字符串左侧指定的字符串：this is string example let us try it!!!#####
删除字符串右侧指定的字符串：#####this is string example let us try it!!!
2.1.4.join()方法
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串语法：
str.join(sequence)
参数：
sequence -- 要连接的元素序列
返回值：
返回通过指定字符连接序列中元素后生成的新字符串
示例：
str1 = "-"
str2 = ""
seq = ("j","i","o","n","t","e","s","t")
print(str1.join(seq))
print(str2.join(seq))
结果：
j-i-o-n-t-e-s-t
jiontest
2.1.5.split()方法
split()方法使用str作为分隔符(如果未指定则使用空格分割)在字符串返回所有单词的列表。可选 num 限制拆分数量。语法
str.split(str="", num=string.count(str))
参数
str -- 这是分隔符，默认情况下使用空格
num -- 这是指定要作出的行数
返回值：
此方法返回行的列表
示例：
str1 = "testing is bester begin leter alter is come test bad"
print(str1.split())
print(str1.split("i"))
print(str1.split("t",3))
结果：
['testing', 'is', 'bester', 'begin', 'leter', 'alter', 'is', 'come', 'test', 'bad']
['test', 'ng ', 's bester beg', 'n leter alter ', 's come test bad']
['', 'es', 'ing is bes', 'er begin leter alter is come test bad']
2.1.6.format()方法
通过 {}按顺序设置字符串参数
语法：
“{0} {2}".format("str1","str2")
参数：
{0} 指定参数 str1
{1}指定参数str2
示例：
str1 = "hello"
str2 = "python"
print("{0} apple bnana {1}".format(str1,str2))
结果：
hello apple bnana python
2.1.7.分片查询
查询结果是 前开后闭，截取字符串中的一部分示例:
str1="This is Python testing" print(str1[1:8]) #打印字符串的第1字符到第7个字符 print(str1[5:]) #打印字符串的第5字符到最后一个字符 print(str1[6:-2]) #打印字符串的第6字符到倒数第二个字符结束 print(str1[::-1]) #转置
结果
his is
is Python testing
s Python testi
gnitset nohtyP si sihT
2.1.8.三引号
引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
如果字符串是一行 的话，三引号表示是注释
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
结果：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
2.1.9.capitalize()函数
capitalize()将字符串的第一个字母变成大写,其他字母变小写
语法
str.capitalize()
参数
无
返回值
该方法返回一个首字母大写的字符串
示例
s1="this is BEST Good idea" print(s1.capitalize())This is best good idea结果
This is best good idea
2.1.10.center()函数
center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格语法
str.center(width[, fillchar])
参数
- width -- 字符串的总宽度。
- fillchar -- 填充字符
返回值
返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充
示例
s2="hello python" print(s2.center(40,"*"))结果
**************hello python**************
2.1.11.count()函数
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置语法
str.count(sub, start= 0,end=len(string))
参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
返回值
该方法返回子字符串在字符串中出现的次数
示例
s1="hello pan xiang hehe test please xia guo ta ha la"
print(s1.count("i"))
print(s1.count("a",4,20))
结果
2
2
2.1.12.bytes.decode()和encode()函数
encode() 方法以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。
语法
str.encode(encoding='UTF-8',errors='strict')
bytes.decode(encoding="utf-8", errors="strict")
参数
encoding -- 要使用的编码，如"UTF-8"。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
该方法返回解码后的字符串。
示例
s1="欢迎来到Python世界"
s_uft8=s1.encode("utf-8")
s_gbk=s1.encode("GBK")
print(s1)
print("UTF-8编码：{0}".format(s_uft8))
print("GBK编码：{0}".format(s_gbk))
print("UTF-8解码：{0}".format(s_uft8.decode("utf-8","strict")))
print("GBK解码：{0}".format(s_gbk.decode("gbk","strict")))返回值
欢迎来到Python世界
UTF-8编码：b'\xe6\xac\xa2\xe8\xbf\x8e\xe6\x9d\xa5\xe5\x88\xb0Python\xe4\xb8\x96\xe7\x95\x8c'
GBK编码：b'\xbb\xb6\xd3\xad\xc0\xb4\xb5\xbdPython\xca\xc0\xbd\xe7'
UTF-8解码：欢迎来到Python世界
GBK解码：欢迎来到Python世界
2.1.13.startswith()和endswith()函数
startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置
语法
str.startswith(str, beg=0,end=len(string));
str.endswith(suffix[, start[, end]])
参数
str -- 检测的字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
返回值
如果检测到字符串则返回True，否则返回False。
示例1
str = "this is string example test hello good" print (str.startswith( 'this' )) print (str.startswith( 'string', 8 )) print (str.startswith( 'this', 2, 4 ))结果1
True
True
False
示例2
s1="hello,python world!!!"
subffix="!!"
print(s1.endswith("!!"))
print(s1.endswith("he",0,1))结果2
True
False
2.1.13.expandtabs()函数
expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。语法
str.expandtabs(tabsize=8)参数
tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数
返回值
该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。
示例
s1="this is test\texpendtabs function test" print(s1.expandtabs(tabsize=6))结果
this is test expendtabs function test
2.1.14.isalnum()函数
isalnum() 方法检测字符串是否由字母和数字组成。语法
str.isalnum()
参数
无
返回值
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
示例
s1="slkdllwlke52521wjje666"
s2="sldie#ksoe.com822d2(ksjd"
print("s1.isalnum()结果是：{0}".format(s1.isalnum()))
print("s2.isalnum()结果是：{0}".format(s2.isalnum()))结果
s1.isalnum()结果是：True
s2.isalnum()结果是：False
2.1.15.isalpha()函数
isalpha() 方法检测字符串是否只由字母组成语法
str.isalpha()
参数
无
返回值
如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
示例
s1 = "lssoelskdlsdkow"
s2 = "sldie#ksoe.com822d2(ksjd"
print("s1.isalpha()结果是：{0}".format(s1.isalpha()))
print("s2.isalpha()结果是：{0}".format(s2.isalpha()))结果
s1.isalpha()结果是：True
s2.isalpha()结果是：False
2.1.16.isdigit()函数
isdigit() 方法检测字符串是否只由数字组成语法
str.isdigit()
参数
无
返回值
如果字符串只包含数字则返回 True 否则返回 False
示例：
s1 = "1234963822"
s2 = "sldie#ksoe.com822d2(ksjd"
print("s1.isdigit()结果是：{0}".format(s1.isdigit()))
print("s2.isdigit()结果是：{0}".format(s2.isdigit()))
结果
s1.isdigit()结果是：True
s2.isdigit()结果是：False
2.1.17.isnumeric()和isdecimal()函数
isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可。
语法
str.isnumeric()
参数
无
返回值
如果字符串中只包含数字字符，则返回 True，否则返回 False
示例
s1 = "1252511"
s2 = "sldie#ksoe.com822d2(ksjd"
print("s1.isnumeric()结果是：{0}".format(s1.isnumeric()))
print("s2.isnumeric()结果是：{0}".format(s2.isnumeric()))结果
s1.isnumeric()结果是：True
s2.isnumeric()结果是：False
s.isdigit、isdecimal 和 s.isnumeric 区别：
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无
isdecimal()
True: Unicode数字，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）
isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）
示例
num = "1" #unicode
num.isdigit() # True
num.isdecimal() # True
num.isnumeric() # True
num = "1" # 全角
num.isdigit() # True
num.isdecimal() # True
num.isnumeric() # True
num = b"1" # byte
num.isdigit() # True
num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'
num = "IV" # 罗马数字
num.isdigit() # True
num.isdecimal() # False
num.isnumeric() # True
num = "四" # 汉字
num.isdigit() # False
num.isdecimal() # False
num.isnumeric() # True
2.1.18.isupper()和islower()函数
isupper() 方法检测字符串中所有的字母是否都为大写islower() 方法检测字符串是否由小写字母组成
语法
str.isupper()
str.islower()
参数
无
返回值
isupper() :如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
islower():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
示例1
s1 = "THIS TEST PYTHON"
s2 = "Welcome to python world"
print("s1.isupper()结果是：{0}".format(s1.isupper()))
print("s2.isupper()结果是：{0}".format(s2.isupper()))
结果1
s1.isupper()结果是：True
s2.isupper()结果是：False
2.1.19.upper()、lower()、swapcase()函数
upper() 方法将字符串中的小写字母转为大写字母lower() 方法转换字符串中所有大写字符为小写
swapcase() 方法用于对字符串的大小写字母进行转换
语法
str.upper()
str.lower()
str.swapcase()
参数
无
返回值
upper()：返回小写字母转为大写字母的字符串。
lower()： 返回将字符串中所有大写字符转换为小写后生成的字符串
swapcase()：返回大小写字母转换后生成的新字符串
示例
str = "THIS is STRING eXample test hello Good"
print("str全部转成大写：{0}".format(str.upper()))
print("str全部转成小写：{0}".format(str.lower()))
print("str大小写字母进行转换：{0}".format(str.swapcase()))结果
str全部转成大写：THIS IS STRING EXAMPLE TEST HELLO GOOD
str全部转成小写：this is string example test hello good
str大小写字母进行转换：this IS string ExAMPLE TEST HELLO gOOD
2.1.20.isspace()函数
isspace() 方法检测字符串是否只由空白字符组成。语法
str.isspace()
参数
无
返回值
如果字符串中只包含空格，则返回 True，否则返回 False.
示例
s1 = " "
s2="hello world !!"
print("s1.isspace()：{0}".format(s1.isspace()))
print("s2.isspace()：{0}".format(s2.isspace()))
结果
s1.isspace()：True
s2.isspace()：False
2.1.21.title()函数
title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())语法
str.title()
参数
无
返回值
返回"标题化"的字符串,就是说所有单词都是以大写开始。
示例
s1 = "this is python test result"
print("s1.title()：{0}".format(s1.title()))结果
s1.title()：This Is Python Test Result
2.1.22.istitle()函数
istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。语法
str.istitle()
参数
无
返回值
如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False
示例
s1 = "This Is Python Test Result"
s2 = "hello the Python World"
print("s1.istitle()：{0}".format(s1.istitle()))
print("s2.istitle()：{0}".format(s2.istitle()))
结果
s1.istitle()：True
s2.istitle()：False
2.1.23.len()函数
len() 方法返回对象（字符、列表、元组等）长度或项目个数。语法
len( s )
参数
s -- 对象。
返回值
返回对象长度
示例
s1 = "This Is Python Test Result"
print("s1字符串长度为：{0}".format(len(s1)))
结果
s1字符串长度为：26
2.1.24.ljust()、rjust()、zfill()函数
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0
语法
str.ljust(width[, fillchar])
str.rjust(width[, fillchar])
str.zfill(width)
参数
width -- 指定填充指定字符后中字符串的总长度.
fillchar -- 填充的字符，默认为空格。
返回值
ljust(): 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
rjust() : 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
zfull()：返回指定长度的字符串
示例
s1="thisabigtest"
print("s1左对齐结果：{0}".format(s1.ljust(30,"*")))
print("s1右对齐结果：{0}".format(s1.rjust(30,"*")))
print("s1 zfill右对齐结果：{0}".format(s1.zfill(30)))
结果
s1左对齐结果：thisabigtest******************
s1右对齐结果：******************thisabigtest
s1 zfill右对齐结果：000000000000000000thisabigtest
2.1.25.maketrans()函数
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。
注：Python3.4已经没有string.maketrans()了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()
语法
str.maketrans(intab, outtab)
参数
intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。
返回值
返回字符串转换后生成的新字符串。
示例
以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的字符：
intab="aeiou"
outab="123$5"
trantab=str.maketrans(intab,outab) # 制作翻译表
s1="this is our python test"
print(s1.translate(trantab))
结果
th3s 3s $5r pyth$n t2st
2.1.26.translate()函数
translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。语法
str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])
参数
table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
返回值
返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。
示例
# 制作翻译表
bytes_tabtrans=bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
# 转换为大写，并删除字母o
print(b'goooogle.com'.translate(bytes_tabtrans, b'o'))
b'GGLE.CM'
2.1.27.max()和min()函数
max() 方法返回字符串中最大的字母。
min() 方法返回字符串中最小的字母。
语法
max(str)
min(str)
参数
str -- 字符串。
返回值
max()：返回字符串中最大的字母
min()：返回字符串中最小的字母
示例
s1 = "aeckdodksed"
print("最大字符: {0}".format(max(s1)))
print("最小字符: {0}".format(min(s1)))
结果
最大字符: s
最小字符: a
2.1.28.index()和rindex()函数
index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
语法
str.index(str, beg=0, end=len(string))
str.rindex(str, beg=0 end=len(string))
参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
返回值
index()：如果包含子字符串返回开始的索引值，否则抛出异常。
rindex() ： 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
示例
str1 = "this is test example is a good idea"
str2 = "is";
print ("str1.index(str2)：{0}".format(str1.index(str2)))
print ("str1.index(str2, 5)：{0}".format(str1.index(str2, 5)))
print ("str1.index(str2, 10)：{0}".format(str1.index(str2, 10)))
print ("str1.rindex(str2)：{0}".format(str1.rindex(str2)))
print ("str1.rindex(str2,10)：{0}".format(str1.rindex(str2,10)))
结果
str1.index(str2)：2
str1.index(str2, 5)：5
str1.index(str2, 10)：21
str1.rindex(str2)：21
str1.rindex(str2,10)：21
2.1.29.splitlines()函数
splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。语法
str.splitlines([keepends])
参数
keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符
返回值
返回一个包含各行作为元素的列表
示例
print('ab c\n\nde fg\rkl\r\n'.splitlines())
结果
['ab c', '', 'de fg', 'kl']
2.2. 转义字符
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
2.3. 字符串运算符
下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 1 |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 1 |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
2.4. 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
结果
我叫 小明 今年 10 岁!
python字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
三、列表 (list)常用方法
元素使用[]显示
3.1. append()方法
在列表末尾添加新的对象
语法：
list.append(obj)
参数：
obj -- 添加到列表末尾的对象
返回值：
该方法无返回值，但是会修改原来的列表。
示例：
list1 = ["good","time","world","beging"]
list1.append("let")
print(list1)
结果：
['good', 'time', 'world', 'beging', 'let']
3.2. pop()方法
pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
语法：
pop(key[,default])
参数：
key: 要删除的键值
default: 如果没有 key，返回 default 值
返回值：
返回被删除的值。
示例：
list1 = ["good","time","world","beging","apple"] list1.pop() print(list1) list2 = ["good","time","world","beging","apple"] list2.pop(2) print(list2)
结果：
['good', 'time', 'world', 'beging']
['good', 'time', 'beging', 'apple']
3.3. index()方法
index() 函数用于从列表中找出某个值第一个匹配项的索引位置
语法：
list.index(obj)
参数：
obj -- 查找的对象。
返回值：
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常
示例：
list1 = ["good","time","world","beging","apple"]
print("world index is",list1.index("world"))
结果：
world index is 2
3.4. remove()方法
remove() 函数用于移除列表中某个值的第一个匹配项
语法：
list.remove(obj)
参数：
obj -- 列表中要移除的对象
返回值：
该方法没有返回值，但是会移除两种中的某个值的第一个匹配项
示例：
list1 = ["good","time","world","beging","apple"]
list1.remove("beging")
print(list1)
结果：
['good', 'time', 'world', 'apple']
3.5. sort()方法
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
语法：
list.sort([func])
参数：
func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
返回值：
该方法没有返回值，但是会对列表的对象进行排序。
示例：
list1 = ["good","time","world","beging","apple"] list1.sort() print(list1)
结果：
['apple', 'beging', 'good', 'time', 'world']
3.6. reverse()方法
reverse() 函数用于反向列表中元素。
语法：
list.reverse()
返回值：
该方法没有返回值，但是会对列表的元素进行反向排序
示例：
list1 = ["good","time","world","beging","apple"] list1.reverse() print(list1)结果：
['apple', 'beging', 'world', 'time', 'good']
3.7. insert()方法
insert() 函数用于将指定对象插入列表的指定位置。
语法：
list.insert(index, obj)
参数：
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
返回值：
该方法没有返回值，但会在列表指定位置插入对象
示例：
list1 = ["good","time","world","beging","apple"] list1.insert(3,"tos") print(list1)
结果：
['good', 'time', 'world', 'tos', 'beging', 'apple']
四、元组 tuple
元素使用()显示，是特殊的列表，不能删除里面的元素
4.1.index()方法
按元素查找下标
示例：
list1 = ("good","time","world","beging","apple")
print(list1.index("world"))
结果
2
4.2.count()方法
示例：统计3的个数
list1 = (1,3,2,4,3,6,9,3,2,7) print(list1.count(3))结果
3