[Python基础]Python内置函数
文章目录
一、强制类型转换
int(x,base=10)
: 将一个字符串或数字转换为整型。
float([x])
: 将整数和字符串转换成浮点数。
str(object='')
: 返回一个对象的string格式。
bool([x])
: 转换为布尔类型。如果没有参数,返回 False
。bool
是 int
的子类。
bytes([source[, encoding[, errors]]])
: 返回一个新的 bytes 对象,该对象是一个 0 <= x < 256 区间内的整数不可变序列。
list( seq )
: 将元组或字符串转换为列表。
iter(object[, sentinel])
: 用来生成迭代器,返回一个可迭代的对象。object是支持迭代的集合对象。
dict()
: 创建一个字典。
enumerate(sequence, [start=0])
: 将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,start
指下标起始位置,一般用在 for
循环当中,返回一个枚举对象。
tuple( seq )
: 将列表转换为元组。
set(iterable)
: 创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
int()函数参数
若 x
为纯数字,则不能有 base
参数,否则报错;其作用为对入参 x
取整
>>> int(2.5)
2
>>> int(-11.123)
-11
若 x
为 str
,则 base
可略可有。默认10进制。base
存在时,视 x
为 base
类型数字,并将其转换为 10 进制数字。若 x
不符合base
规则,则报错。str
须为整数,否则也会报错
>>>int("9",2) #报错,因为2进制无9
>>> int("1.2") #报错,str须为整数
>>>int("1001",2)
9
bytes()函数参数
①如果source
为整数,则返回一个长度为 source
的初始化数组;
②如果 source
为字符串,则按照指定的 encoding
将字符串转换为字节序列;
③如果 source
为可迭代类型,则元素必须为[0 ,255] 中的整数;
④如果 source
为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray
。
⑤如果没有输入任何参数,默认就是初始化数组为0个元素。
>>> a = bytes(5)
>>> a
b'\x00\x00\x00\x00\x00'
>>> a = bytes('hello','ascii')
>>> a
b'hello'
>>> a = bytes([1,2,3,4])
>>> a
b'\x01\x02\x03\x04'
>>> a = bytes(range(50,60))
>>> a
b'23456789:;'
>>> a = bytes()
>>> a
b''
转换 int 为 bytes
bytes()
方法
struct.pack()
方法
int.to_bytes()
方法
定义python3字节序列类型bytes的三种方法
bytes([100,123,111])#0<=[ ]<256
bytes('Hello','utf-8')#第二个编码类型必须制定,没有默认
'Hello'.encode('utf-8')#编码方式可以改变,也可以省略,默认utf-8
iter()的用法
#判断一个对象是否可迭代
from collections import Iterable
isinstance(object,Iterable)
sentinel
参数:如果传递了第二个参数,则参数 object
必须是一个可调用的对象(如,函数),此时,iter
创建了一个迭代器对象,每次调用这个迭代器对象的__next__()
方法时,都会调用object
。
class data:
list: list = [1, 2, 3, 4, 5, 6]
index = 0
def __call__(self, *args, **kwargs):
item = self.list[self.index]
self.index += 1
return item
def __iter__(self):
self.i = iter(self.list)
return self.i
for item in iter(data(), 3): #每一次迭代都会调用一次__call__方法,当__call__的返回值等于3是停止迭代
print(item)
创建字典的方式
#1.创建空字典
>>> dic = {}
>>> dic = dict()
#2.直接赋值创建
>>> dic = {'spam':1, 'egg':2, 'bar':3}
#3.通过关键字dict和关键字参数创建
>>> dic = dict(spam = 1, egg = 2, bar =3)
#4.通过二元组列表创建
>>> list = [('spam', 1), ('egg', 2), ('bar', 3)] # 可迭代对象方式来构造字典
>>> dic = dict(list)
#5.dict和zip结合创建
>>> dic = dict(zip('abc', [1, 2, 3])) # 映射函数方式来构造字典
{'a': 1, 'b': 2, 'c': 3}
#6.通过字典推导式创建
>>> dic = {i:2*i for i in range(3)}
#7.通过dict.fromkeys()创建
>>> dic = dict.fromkeys(range(3), 'x')
#8.其他
>>> list = ['x', 1, 'y', 2, 'z', 3]
>>> dic = dict(zip(list[::2], list[1::2]))
二、输入输出
input([prompt])
:接受一个标准输入数据,返回为 string 类型。
在 Python3.x 中 raw_input() 和 input() 进行了整合,去除了 raw_input( ),仅保留了input( )函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。
print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。
>>> a=input() # 输入3
>>> a*2
33
>>> a=int(input()) #输入3
>>> a*2
6
print()
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
:打印输出。
objects
:复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。sep
:用来间隔多个对象,默认值是一个空格。end
:用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。file
:要写入的文件对象。flush
:输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新。
%
运算符就是用来格式化字符串的。有几个%?
占位符,后面就跟几个变量或者值,顺序要一一对应。如果只有一个%?,括号可以省略。
使用 repr() 或 str() 函数来实现将输出的值转成字符串。
>>> s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob' #str():函数返回一个用户易读的表达形式。
>>> repr(s)
"'Hello, Runoob'" #repr():产生一个解释器易读的表达形式。
# repr() 函数可以转义字符串中的特殊字符
>>> hello = 'hello, runoob\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoob\n'
# repr() 的参数可以是 Python 的任何对象
>>> repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"
python字符串格式化符号:
符 号 | 描述 |
---|---|
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数字,可指定小数点后的精度 |
%e | 用科学计数法格式化浮点数 |
%p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
符号 | 功能 |
---|---|
n1.n2 | n1 表示显示的最小总宽度,小数点也算一位,若超出,则原样输出;n2 表示小数点后的位数 |
- | 用做左对齐 |
+ | 在正数前面显示加号( + ) |
# | 八进制数前显示 0o ,在十六进制前面显示’0x’或者’0X’(取决于用的是x 还是X ) |
0 | 用于填充空格 |
(var) | 映射变量(用于处理字典参数) |
<sp> | 在正数前面显示空格 |
% | %% 输出一个单一的% |
print("%6.3f" % 3.1) # 3.100
print("%7.3e" % 314.159265) #3.142e+02
#000000
print("%-6.2f" % 3.1) #3.10
print("%+6.2f" % 3.1) # +3.10
print("%6.2f" % 3.1) # 3.10
print("%x" % 100) #64
print("%#x" % 100) #0x64
print("%#X" % 100) #0X64
print("%#o" % 100) #0o144
#00000
print("%5d" % 3) # 3
print("%05d" % 3)#00003
students = [{"name":"Wilber", "age":27}, {"name":"Will", "age":28}]
for student in students:
print ("%(name)s is %(age)d years old" %student) #Wilber is 27 years old \n Will is 28 years old
format()
通过{}
和:
来代替传统%方式。
#设置数字顺序指定格式化的位置,如果不设置指定位置,则按默认顺序
print('I {1} {0} {1}, and I\'am learning'.format('like', 'Python'))#I Python like Python, and I'am learning
#设置关键字指定格式化的内容
print('I {l} {p}, and I\'am learning'.format(p='Python', l='like'))#I like Python, and I'am learning
#利用元组传参,传参形式 *tuple
T = 'like', 'Python'
print('I {} {}, and I\'am learning'.format(*T))#I like Python, and I'am learning
print('I {0} {1}, and I\'am learning'.format(*T))#I like Python, and I'am learning
#字典传参
D = {'l':'like', 'p':'Python'}
print('I {l} {p}, and I\'am learning'.format(**D))#I like Python, and I'am learning
#列表传参
L0 = ['like', 'Python']
L1 = [' ', 'Lerning']
# `[]`前的0、1用于指定传入的列表顺序
print('I {0[0]} {1[1]}, and I\'am learning'.format(L0, L1)) #I like Lerning, and I'am learning
进制转换
字符 | 含义 |
---|---|
b | 二进制 |
c | Unicode 字符 |
d | 十进制整数 |
o | 八进制数 |
x | 十六进制数,a 到 f 小写 |
X | 十六进制数,A 到 F 大写 |
N = 99
print('{:b}'.format(N)) #1100011
print('{:c}'.format(N)) #c
print('{:d}'.format(N)) #99
print('{:o}'.format(N)) #143
print('{:x}'.format(N)) #63
print('{:X}'.format(N)) #63
填充与对齐
:
号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充,且填充常跟对齐一起使用
^
、<
、>
分别是居中、左对齐、右对齐,后面带宽度。
N = 99
print('{:>8}'.format(N)) #99
print('{:->8}'.format(N)) #------99
print('{:-<8}'.format(N)) #99------
print('{:-^8}'.format(N) #---99---
精度
:
号后面设置精度(以.
开始加上精度),然后用f
结束,若不是设置,默认为精度为6,自动四舍五入,可带符号显示数字正负标志。
转义
可以使用大括号 {}
来转义大括号。
format()方法中文对齐问题解决方法
原因:系统默认填充的是英文空格,而输出占用的是中文字符的宽度。单位不一致,就会出现不能对齐的状况。
解决方法:将中文输出部分原先的默认英文空格填充换成中文空格填充chr(12288)
,即可解决问题。
三、数学函数
abs(x)
: 函数返回x(数字)的绝对值。
max()
: max() 方法返回给定参数的最大值,参数可以为序列。
min()
:返回给定参数的最小值
sum(iterable[, start])
: iterable
是可迭代对象如列表、元组、集合。start意思是元组计算总和后再加start后输出,默认为0
sorted(iterable, key=None, reverse=False)
:返回重新排序的列表。
len(s)
: 返回对象(字符、列表、元组等)长度或元素个数。参数可以是序列(如 string、bytes、tuple、list 或 range 等)或集合(如 dictionary、set 或 frozen set 等)
divmod(a,b)
: 接收两个数字类型(非复数)参数,返回一个包含商和余数的元组(a // b, a % b)
。
pow(x, y[, z])
: 计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
round( x [, n] )
: 获取指定位数的小数。n代表要保留的位数。
range(start, stop[, step])
: 左闭右开,步长为step。range(stop)
等价于(0,stop)
max方法的参数
>>> a='1,2,3,4'#类型为字符串
>>> max(a)#max 返回了最大值
'4'
>>> a=[1,2,3,4]#类型是列表
>>> max(a)#max函数也返回了最大值
4
>>> a=[(1,2),(2,3),(3,4)]#列表里面的元素都由元组构成,元组都由数字组成
>>> max(a) #按照元素里面元组的第一个元素的排列顺序,输出最大值(如果第一个元素相同,则比较第二个元素,输出最大值)据推理是按ascii码进行排序的
(3,4)
>>> a={1:2,2:2,3:1,4:'aa'} #比较字典里面的最大值,会输出最大的键值
>>> max(a)
4
sorted()函数的参数
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法会修改原始的 list(返回值为None),而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。如果我们不需要原来的数据而且数据是list类型,可以用sort方法,能够节省空间。否则要用sorted方法。
在python2中,sort
方法可以有3个参数:key
、cmp
和reverse
。但在python3中取消了cmp
这个参数,只有key
和reverse
两个可选参数。参数reverse
指定排序是正序还是倒序,默认是正序FALSE
;参数key
指定了只含一个参数的方法,这个方法用来从列表的每个元素中提取比较键。
#利用key进行倒序排序
>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]
#通过 key 的值来进行数组/字典的排序
>>> array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
>>> array = sorted(array,key=lambda x:x["age"])
>>> print(array)
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
#先按照成绩降序排序,相同成绩的按照名字升序排序:
>>> d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
>>> ans = sorted(d1, key=lambda x:(-x['score'], x['name']))
>>> print(ans)
[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]
divmod()函数
python3该函数不支持复数。
- 如果参数 a 与 参数 b 都是整数,函数返回的结果相当于
(a // b, a % b)
。 - 如果其中一个参数为浮点数时,函数返回的结果相当于
(q, a % b)
,q 通常是math.floor(a / b)
,但也有可能是 1 ,比小,不过q * b + a % b
的值会非常接近 a。 - 如果
a % b
的求余结果不为 0 ,则余数的正负符号跟参数 b 是一样的,若 b 是正数,余数为正数,若 b 为负数,余数也为负数,并且0 <= abs(a % b) < abs(b)
。
pow()与math.pow的区别
pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。
#!/usr/bin/python3
import math # 导入 math 模块
print ("math.pow(100, 2) : ", math.pow(100, 2)) #math.pow(100, 2) : 10000.0
print ("pow(100, 2) : ", pow(100, 2)) #pow(100, 2) : 10000
range()函数返回值
Python3 range()
函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。
Python3 list()
函数是对象迭代器,可以把range()返回的可迭代对象转为一个列表,返回的变量类型为列表。
Python2 range()
函数返回的是列表。
>>> type(range(10))
<class 'range'>
>>> list(range(0))
[]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(1, 0))
[]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
四、进制转换与编码
hex(int)
: 将一个指定数字转换为16进制数。返回一个字符串,以 0x
开头。
oct(int)
: 将一个整数转换成8进制字符串,以0
开头
bin(int)
: 返回一个整数 int
或者长整数 long int
的二进制表示字符串。结果以前缀 0b
开头。
chr(int)
: 返回当前整数对应的Unicode
数值。0 <= i <= 0x10ffff
,可以是10进制也可以是16进制。
ord(str)
: 返回一个单字符字符串的Unicode
数值(十进制)
五、功能相关函数
eval(expression[, globals[, locals]])
: 执行一个字符串表达式,并返回表达式的值。globals
必须是一个字典对象,locals
可以是任何映射对象。
exec(object[, globals[, locals]])
: 执行储存在字符串或文件中的 Python 语句,返回值永远为 None
。
filter(function, iterable)
: 用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象。函数接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断后返回 True
或 False
,最后将返回True
的元素放到新列表中。
map(function, iterable, ...)
: 根据提供的函数对指定序列做映射。返回迭代器对象。
zip([iterable, ...])
: 将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
isinstance(object, classinfo)
:判断一个对象是否为该类的一个实例。
type(object)
:返回对象的类型。
type(name, bases, dict)
:name
是类的名称,bases
是基类的元组,dict
是类内定义的命名空间变量。返回新的类型对象。
id([object])
: 返回对象的内存地址。
hash(object)
:返回一个对象的hash值,可以应用于数字、字符串和对象,不能直接应用于list
、set
、dictionary
。在 hash()
对对象使用时,所得的结果不仅和对象的内容有关,还和对象的 id()
,也就是内存地址有关。
help([object])
:用于查看函数或模块用途的详细说明。
issubclass(class, classinfo)
:判断参数 class
是否是类型参数 classinfo
的子类。
globals()
: 以字典类型返回当前位置的全部全局变量。
next(iterator[, default])
: 返回迭代器的下一个元素,如果设置了default
,则当迭代器中的元素遍历后,输出default
内容。
reversed(seq)
: 生成一个反转序列的迭代器,可以是tuple
, string
, list
或 range
。
callable(object)
:检查一个对象是否是可调用的。如果返回 True
,object
仍然可能调用失败
compile(source, filename, mode[, flags[, dont_inherit]])
:将一个字符串编译为字节代码。
complex([real[, imag]])
:创建一个值为 real + imag * j
的复数或者转化一个字符串或数为复数。
frozenset([iterable])
:返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
getattr(object, name[, default])
:返回一个对象属性值。
setattr(object, name, value)
:设置属性值,该属性不一定是存在的。
all(iterable)
:判断给定的可迭代参数iterable
中的所有元素是否都为 TRUE
,如果是返回 TRUE
,否则返回 False
。
any(iterable)
:判断给定的可迭代参数 iterable
是否全部为False
,则返回False
,如果有一个为 TRUE
,则返回 TRUE
。
__import__(name)
:用于动态加载类和函数 。
eval()
eval这个函数就是在返回它觉得正确的那个值。
#使字符串本身的引号去掉,保留字符的原本属性。
>>> a = "123" #a为str
>>> b = eval(a)
>>> b
123 #b为int
#直接来提取用户输入的多个值。
>>> a,b = eval(input())
exec()
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr) #60
exec(expr, {'x': 1, 'y': 2}) #33
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) #34
func()
filter()
#!/usr/bin/python3
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist) #将迭代器转化为list后输出,注意这里必须用list()转换为列表
print(newlist)
map()
def square(x) :
return x * x
a = map(square, [1,2,3,4,5])
b = list(map(square, [1,2,3,4,5]))
print(type(a),type(b)) #<class 'map'> <class 'list'>
zip()
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 *
号操作符,可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同:在 Python 2.x zip() 返回的是一个列表。
a = [1,2,3]
b = [4,5,6]
print(type(zip(a,b)),type(list(zip(a,b)))) #<class 'zip'> <class 'list'>
print(zip(a,b),list(zip(a,b))) #<zip object at 0x000001E8FC7E84C8> [(1, 4), (2, 5), (3, 6)]
zipped = list(zip(a,b)) #为[(1, 4), (2, 5), (3, 6)]
unzip = zip(*zipped)
print(type(unzip),list(unzip),type(list(unzip))) #<class 'zip'> [(1, 2, 3), (4, 5, 6)] <class 'list'>
#使用zip调换字典的键与值
dicta = {'a':'aa','b':'bb'}
dictb = dict(zip(dicta.values(),dicta.keys()))
print(dictb)
{'aa':'a','bb':'b'}
type() 与 isinstance()区别
isinstance
中的classinfo
可以是直接或间接类名、基本类型或者由它们组成的元组。对于基本类型来说 classinfo
可以是:int,float,bool,complex,str,list,dict,set,tuple
(注意str
和dict
)
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False