python基础_内置函数+整形函数+字符串函数

内置函数

官网地址：https://docs.python.org/3/library/functions.html#next

中文讲解文档地址：www.runoob.com/python3/python3-built-in-functions.html

abs(x)：返回一个数字的绝对值。 参数可以是整数或浮点数。 如果参数是一个复数，则返回其大小.

bin(x)：将整数转换为以“0b”为前缀的二进制字符串。
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'
>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

eval(expression, globals=None, locals=None)：参数是一个字符串表达式和可选的全局变量和局部变量。
如果提供，全局变量必须是字典。 如果提供，局部变量可以是任何映射对象。返回表达式的结果。
>>> x = 1
>>> eval('x+1')#把字符串中的表达式进行运算
2
>>>eval('{"key":"value"}')#把字符串中的数据结构提取出来
{'key': 'value'}

exec (object [，globals [，locals]])：object：要执行的表达式。返回值必须为None。

input()：输入

print():打印

int()：用于将一个字符串或数字转换为整型。
>>>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

len()：对象（字符、列表、元组等）长度或项目个数。
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5

list()：用于将元组转换为列表。返回值为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

range(start, stop[, step])：开始默认为0，步长默认为1。
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0)
[]
>>> range(1, 0)
[]

type(x):返回x的类型

enumerate()：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
enumerate(sequence, [start=0])
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>>list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>>list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

seq = ['one', 'two', 'three']
for i, element in enumerate(seq, 10):
   print(i, seq[i])
 
10 one
11 two
12 three

all()：如果可迭代对象做布尔运算（bool()）都为True，则返回True。
        如果可迭代对象为空，返回True。
布尔运算：空，None，0的布尔值为False，其余都为True

any()：如果可迭代对象有一个做布尔运算为True，返回True。
           如果可迭代对象为空，则返回False。

bytes()：把输入的对象，按固定的编码格式进行编码
name='你好'
print(bytes(name,encoding='utf-8'))
b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(name,encoding='ascii'))#报错，ascii编码格式，不能对中文进行编码

dir()：以列表形式返回目标属性
print(dir(dict))
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

divmod()：返回商和余数，可用于分页操作
print(divmod(10,3))
(3, 1)

str()：将目标转换为字符串类型
dic={'name':'alex'}
dic_str=str(dic)
print(dic_str,type(dic_str))
{'name': 'alex'} <class 'str'>

hash()：哈希操作
可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))
-3431728047873877990
8130042922071578663
不同的字符串，hash操作得到的数字位数相同，不可逆，不能有hash得到的数反推出字符串
name='alex'
print('--->before',hash(name))
name='sb'
print('--->after',hash(name))
--->before 3132669943485153629
--->after 2132815119069350463
可用于查看，字符串是否被修改

进制转换：
print(bin(12))#10进制->2进制
print(hex(12))#10进制->16进制
print(oct(12))#10进制->8进制
0b1100
0xc
0o14

isinstance()：判断对象类型，对返回True，错返回False
print(isinstance(1,int))
print(isinstance('abc',str))
print(isinstance([],list))
print(isinstance({},dict))
print(isinstance({1,2},set))
True
True
True
True
True
可用于查看是否为可迭代对象

zip()：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

 

整形函数

bit_length()：返回整型数字转化为为二进制后的位数
a=5
a.bit_length()
3

 

字符串函数

find("字符串")：从开始往后找，找到第一个后，返回其位置
>>>a = "alexalex"
>>>a.find("ex")
2

未找到 -1

# index找不到，报错   忽略
# test = "alexalex"
# v = test.index('8')
# print(v)

format()：格式化，将一个字符串中的占位符替换为指定的值
test = 'i am {name}, age {a}'
print(test)
v = test.format(name='alex',a=19)
print(v)

test = 'i am {0}, age {1}'
print(test)
v = test.format('alex',19)
print(v)

格式化，传入的值 {"name": 'alex', "a": 19}
test = 'i am {name}, age {a}'
v1 = test.format(name='df',a=10)
v2 = test.format_map({"name": 'alex', "a": 19})

isalnum()：字符串中是否只包含 字母和数字
test = "123"
v = test.isalnum()
print(v)

expandtabs(n)：输出为n位一组，遇到|\t则与前面的不足n位的，插入空格，补齐n位
test = "12345678\t9"
v = test.expandtabs(6)
print(v,len(v))
12345678    9 13（8后有4个空格）

endwith()：以什么什么结尾
startwith（）：以什么什么开始
test = "alex"
v1 = test.endswith('ex')
v2 = test.startswith('ex')
print(v1, v2)
True False

count()：去字符串中寻找，寻找子序列的出现次数
test = "aLexalexr"
v = test.count('ex')
print(v)
2

test = "aLexalexr"
v = test.count('ex', 5, 6)
print(v)
0

center()：设置宽度，并将内容居中
20 代指总长度
空白未知填充，一个字符，可有可无
test = "alex"
v = test.center(20)
print(v)
        alex        

test = "alex"
v = test.center(20, "中")
print(v)
中中中中中中中中alex中中中中中中中中

lower():所有变小写，casefold更牛逼，很多未知的对相应变小写
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2)

capitalize()：首字母大写
test = "aLex"
v = test.capitalize()
print(v)

upper()：将字母转换为大写

join()：
test = "abcdefg"
v = "_".join(test)
print(v)
a_b_c_d_e_f_g

split()：通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串
test = "alexalexalexalexalex"
v1 = test.split("ex")
v2 = test.split("ex",2)
print(v1,v2)
['al', 'al', 'al', 'al', 'al', ''] ['al', 'al', 'alexalexalex']

strip()：移除字符串头尾指定的字符（默认为空格）
str = "*****this is string example....wow!!!*****"
print (str.strip( '*' ))
this is string example....wow!!!

replace()：方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
str = "www.old.cc"
print ("旧地址：", str)
print ("新地址：", str.replace("old.cc", "new.com"))
str = "this is string example....wow!!!"
print (str.replace("is", "was", 1))
旧地址： www.old.cc
新地址： www.new.com
thwas is string example....wow!!!

索引（下标），切片
test = "abcd"
print(test[2])
print(test[0:2])
c
ab