公司产品发布新版本比较忙，已经一个礼拜没有更新了 本来想着把所有类型的常用方法都整理出来再发布的，但是最近时间好像不太允许，就先发一部分吧。 其中包含(整型、浮点型、字符串、列表)，剩下的元组、字典、集合会在下一章发布出来 希望大家多多支持(点赞、转发、关注都可以的)

扯的好像有点远了，废话不多说，上干货：

整数(int)类型相关的方法

int.bit_length()

返回以二进制表示一个整数所需要的位数，不包括符号位和前面的零

n = -37

print(bin(n))

>>> '-0b100101'

print(n.bit_length())

>>> 6

int.to_bytes(length, byteorder, *, signed=False)

返回表示一个整数的字节数组

是int.from_bytes的逆过程，把十进制整数，转换为bytes类型的格式

• length要使用的字节对象的长度；byteorder主要有两种：'big'和'little'；signed=True表示需要考虑符号位

x = -37

res = x.to_bytes(8, byteorder='little', signed=True)

print(res)

>>> b'\xdb\xff\xff\xff\xff\xff\xff\xff'

int.from_bytes(bytes, byteorder, signed=False)

把bytes类型的变量x，转化为十进制整数

• bytes是输入的变量；byteorder主要有两种：'big'和'little'；signed=True表示需要考虑符号位。

x = b'-0b100101'

res = int.from_bytes(x, byteorder='little', signed=True)

print(res)

>>> 907363069382992474157

int(x, base=10)

用于将一个字符串或数字转换为整型

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

>>>int() # 不传入参数时，得到结果0

0

>>> int(3)

3

>>> int(3.6)

3

>>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制

18

>>> int('0xa',16)

10

>>> int('10',8)

8

浮点(float)类型的相关方法

float.as_integer_ratio()

返回一对整数，其比例与原始浮点数完全相等，并带有一个正的分母

x = 5.0

res = x.as_integer_ratio()

print(res)

>>> (5, 1)

float.is_integer()

如果小数点后全是 0, 返回 True, 否则返回 False

x = 5.0

res = x.is_integer()

print(res)

>>> True

float.hex()

将浮点数的表示形式返回为十六进制字符串

x = 5.0

res = x.hex()

print(res)

>>> 0x1.4000000000000p+2

float.fromhex(s)

返回由十六进制字符串 s 表示的 float

res = float.fromhex("0x1.4000000000000p+2")

print(res)

>>> 5.0

字符串(str)类型相关的方法

capitalize()

将字符串的第一个字母变成大写,其他字母变小写

s = 'a, B'
s.capitalize()
print(s)
>>> 'A, b'
# a 前面有空格
s = 'a, B'
s.capitalize()
print(s)
' a, b'

casefold()

Python3.3版本之后引入的，其效果和 lower() 方法非常相似，都可以转换字符串中所有大写字符为小写

• 区别：lower() 方法只对ASCII编码，也就是‘A-Z’有效，对于其他语言（非汉语或英文）中把大写转换为小写的情况只能用 casefold() 方法

S1 = "Runoob EXAMPLE....WOW!!!" #英文
S2 = "ß"  #德语

print( S1.lower() )
print( S1.casefold() )
print( S2.lower() )
print( S2.casefold() ) #德语的"ß"正确的小写是"ss"
>>> runoob example....wow!!!
>>> runoob example....wow!!!
>>> ß
>>> ss

center(width[, fillchar])

返回长度为 width 的字符串，原字符串在其正中，如果 width 小于等于 len(s) 则返回原字符串的副本。

• wigth -- 指定的长度
• fillchar -- 可选，长度不够时补充的字符(默认使用 ASCII 空格符)

s = '123'
s.center(15, '&')
print(s)
>>> '&&&&&&123&&&&&&'
# width小于字符串本身
s = '123'
s.center(2, '&')
print(s)
>>> '123'

count(sub[, start[, end]])

统计字符串里某个字符或子字符串出现的次数

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

str = "this is string example....wow!!!";

sub = "i";
print(str.count(sub, 4, 40))
>>> 2
sub = "wow";
print(str.count(sub))
>>> 1

encode(encoding="utf-8", errors="strict")

以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案

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

str1 = "this is string example....wow!!!"
str1.encode('GBK', 'strict')
print(str1)
>>> this is string example....wow!!!

endswith(suffix[, start[, end]])

如果字符串以指定的 suffix 结束返回 True，否则返回 False

• suffix -- 一个字符串或者是一个元组
• start -- 字符串中的开始位置
• end -- 字符中结束位置

str = "this is string example....wow!!!"

suffix = "wow!!!"
print(str.endswith(suffix))
print(str.endswith(suffix, 20))

suffix = "is"
print(str.endswith(suffix, 2, 4))
print(str.endswith(suffix, 2, 6))
>>> True
>>> True
>>> True
>>> False

expandtabs(tabsize=8)

把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。

• tabsize -- 指定转换字符串中的tab符号("\t")转为空哥的字符数

str = "tester\t12345\tabc"
# 默认 8 个空格
# tester 有 6 个字符，后面的 \t 填充 2 个空格
# 12345 有 5 个字符，后面的 \t 填充 3 个空格
print(str.expandtabs())
>>> tester  12345   abc
# 3 个空格
# runnob 有 6 个字符，刚好是 3 的 2 倍，后面的 \t 填充 3 个空格
# 12345 有 5 个字符，不是 3 的倍数，后面的 \t 填充 1 个空格
print(str.expandtabs(3))
>>> tester   12345 abc

find(sub[, start[, end]])

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引

• sub -- 指定检索的字符串
• start -- 开始索引，默认为0
• end -- 结束索引，默认为字符串的长度

info = 'abca'
# 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
print(info.find('a'))
>>> 0
# 从下标1开始，查找在字符串里第一个出现的子串：返回结果
print(info.find('a', 1))
>>> 3
# 查找不到返回-1
print(info.find('3'))    
>>> -1

format(*args, **kwargs)

执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域

print("The sum of 1 + 2 is {0}".format(1+2))
>>> 'The sum of 1 + 2 is 3'

请参阅 格式字符串语法 了解有关可以在格式字符串中指定的各种格式选项的说明

format_map(mapping)

类似与str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况

class Default(dict):
    def __missing__(self, key):
        return key
print('{name} was born in {country}'.format_map(Default(name='Guido')))
>>> 'Guido was born in country'

index(sub[, start[, end]])

与find()方法类似，用于检测字符串中是否包含子字符串，如果不包含的话会抛出ValueError

• sub -- 指定检索的字符串
• start -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

str1 = "this is string example....wow!!!";
str2 = "exam";

print(str1.index(str2))
print(str1.index(str2, 10))
print(str1.index(str2, 40))
>>> 15
>>> 15
>>> Traceback (most recent call last):
            print(str1.index(str2, 40))
        ValueError: substring not found

isalnum()

如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False

str1 = "abc123"
str2 = "!@#$"

print(str1.isalnum())
print(str2.isalnum())
>>> True
>>> False

isalpha()

如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False

str1 = "xiaoqi"
str2 = "!@#$"
str3 = " "
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
>>> True
>>> False
>>> False

isdigit()

如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False

str1 = "12345"
str2 = "abcde"
print(str1.isalnum())
print(str2.isalnum())
>>> True
>>> False

islower()

如果字符串中至少有一个区分大小写的字符，且此类字符均为小写则返回 True ，否则返回 False

str1 = "xiaoqi"
str2 = "Test123"
print(str1.islower())
print(str2.islower())
>>> True
>>> False

isspace()

如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False

str1 = "          "
str2 = "Test 123"
print(str1.isspace())
print(str2.isspace())
>>> True
>>> False

istitle()

如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False

str1 = "Test Doc"
str2 = "Test doc"
print(str1.istitle())
print(str2.istitle())
>>> True
>>> False

isupper()

如果字符串中至少有一个区分大小写的字符，且此类字符均为大写则返回 True ，否则返回 False

str1 = "TESTDOC"
str2 = "Test doc"
print(str1.isupper())
print(str2.isupper())
>>> True
>>> Fals

json(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError

• iterable -- 要连接的元素序列

str1 = "TESTDOC"
print("#".join(["a", "b", "c"]))
>>> a#b#c

strip([chars])

返回原字符串的副本，移除其中的前导字符 其中还有lstrip()、strip()方法，分别从左、右移除

• chars -- 指定要移除字符的字符串

print("      TEST_DOC        ".strip())
print("      TEST_DOC        ".lstrip())
print("      TEST_DOC        ".rstrip())
>>> 'TEST_DOC'
>>> 'TEST_DOC        '
>>> '      TEST_DOC'

replace(old, new[, count])

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串
• count -- 可选字符串, 替换不超过 count 次

str1 = "this is really string! this is"
print(str1.replace("is", "was"))
print(str1.replace("is", "was", 2))
>>> thwas was really string! thwas was
>>> thwas was really string! this is

split(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符

• sep -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
• maxsplit -- 分割次数。默认为 -1, 即分隔所有

txt = "Google#Runoob#Taobao#Facebook"
print(txt.split("#", 1))
>>> ['Google', 'Runoob#Taobao#Facebook']

startswith(prefix[, start[, end]])

如果字符串以指定的 prefix 开始则返回 True，否则返回 False

• prefix -- 检测的字符串
• start -- 可选参数用于设置字符串检测的起始位置
• end -- 可选参数用于设置字符串检测的结束位置

str = "this is string example....wow!!!";
print str.startswith( 'this' );
print str.startswith( 'is', 2, 4 );
print str.startswith( 'this', 2, 4 );
>>> True
>>> True
>>> False

• 以上只是字符串常用方法，若需要查看全部方法，请点击字符串的全部方法

列表(list)类型相关的方法

append(obj)

对于列表的操作主要实现的是在特定的列表最后添加一个元素，并且只能一次添加一个元素，并且只能在列表最后

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

list_a = [1, 2, 3]
list_a.append(5)
print(list_a)
>>> [1, 2, 3, 5]

extend(seq)

在列表末尾追加另一个序列中的多个值(用新列表扩展原来的列表)

• seq -- 元素列表

list1 = [123,456,789]
list1.extend(['wanglu','123',123])
print(list1)
>>> [123, 456, 789, 'wanglu', '123', 123]

insert(index, obj)

在特定位置添加对象。

• index -- 插入的位置，相当于下标+1的位置；
• obj -- 传入的数据(对象)

list1 = [123,456,789]
list1.insert(1,456)
print(list1)
>>> [123, 456, 456, 789]

remove(ele)

移除列表中指定的元素

• ele -- 要移除的元素

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
list1.remove("xyz")
print(list1)
>>> [123, 'zara', 'abc', 'xyz']

pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

• index -- 要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
list1.remove("xyz")
list_pop = list.pop(1)
print(list_pop)
print(list1)
>>> xyz
>>> [123, 'zara', 'abc', 'xyz']

del list[index]

用索引进行删除

• list -- 要操作的列表
• index -- 要删除的元素下标

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
del list1[2]
print(list1)
>>> [123, 'xyz', 'abc', 'xyz']

count(obj)

统计某个元素在列表中出现的次数

• obj -- 要统计的元素

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
count = list1.count("xyz")
print(count)
>>> 2

index(obj[, start[, end]])

从列表中找出某个值第一个匹配项的索引位置

• obj -- 需要匹配的元素
• start -- 可选，查找的起始位置
• end -- 可选，查找的结束位置

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
location = list1.index("xyz")
print(location)
>>> 1

reverse()

将列表元素进行反转

list1 = [123, 'xyz', 'zara', 'abc', 'xyz']
list1.reverse()
print(list1)
>>> ['xyz', 'abc', 'zara', 'xyz', 123]

sort(cmp=None, key=None, reverse=False) 列表进行排序，如果指定参数，则使用比较函数指定的比较函数

• cmp -- 可选参数，如果指定了该参数会使用该参数的方法进行排序
• key -- 只要是用来进行比较的元素，只有一个参数，具体的参数就是取自于可叠戴对象中，指定可迭代对象中的一个元素来进行排序
• reverse -- 排序规则，reverse=True为降序，reverse=False升序(默认)

# sort() 函数的使用方法
list1 = ['123', 'xyz', 'zara', 'abc', 'xyz']
list1.sort()
print(list1)
>>> ['123', 'abc', 'xyz', 'xyz', 'zara']
# 降序
list1.sort(reverse=True)
print(list1)
>>> ['zara', 'xyz', 'xyz', 'abc', '123']
# 指定列表中的元素排序来
def takeSecond(elem):
    return elem[1]  # 获取列表的第二个元素
list1 = [(2, 2), (3, 4), (4, 1), (1, 3)]
list1.sort(key=takeSecond)
print(list1)
>>> [(4, 1), (2, 2), (1, 3), (3, 4)]