内置方法
- Python解释器内置了许多函数和类型，这些函数和类型始终可用。
- 按照使用的频率做如下排序
排序
看代码
# ---------------------------- 排序 --------------------------------
# reversed()
# 翻转可迭代对象
print(list(reversed('abc')))
# # 返回反向迭代器序列 必须是具有 __reversed__() 方法或支持序列协议 __len__() 方法与 __getitem__() 方法的整数参数开始于 0 ）
# sorted()
# 返回排序过后的可迭代对象
# sorted(iterable, *, key=None, reverse=False)
lst = [{'address': 2, 'salary': 10000, 'age': 18, 'name': '小A'},
{'address': 3, 'salary': 12000, 'age': 25, 'name': '小B'},
{'address': 1, 'salary': 18000, 'age': 28, 'name': '小C'},
{'address': 1, 'salary': 23000, 'age': 31, 'name': '小D'},
{'address': 1, 'salary': 23000, 'age': 35, 'name': '小E', }]
print(sorted(lst, key=lambda x: x['address'])) # 以住址排序
print(sorted(lst, key=lambda x: (x['address'], -x['salary']))) # 以住址排序,之后再以薪资排序
print(sorted(lst, key=lambda x: (x['address'], -x['salary'], -x['age']))) # 以住址排序,之后再以薪资排序,之后再以年龄排序
lst = [(1, 3), (1, 5), (1, 2), (2, 1)]
print(sorted(lst, key=lambda x: x[0])) # [(1, 3), (1, 5), (1, 2), (2, 1)] ## 第一个元素以正序排序
print(sorted(lst, key=lambda x: (x[0], -x[1]))) # [(1, 5), (1, 3), (1, 2), (2, 1)] ## 第一个元素以正序排序 ,第二个元素以倒叙排序
print(sorted([36, 5, -12, 9, -21], key=abs)) # [5, 9, -12, -21, 36] ## 以绝对值排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)) # ['about', 'bob', 'Credit', 'Zoo'] ## 小写字母在前,大写在后
filter,map,zip,reduce
看代码
# ----------------------------------filter -- map -- zip --reduce --------------------------------------------
# filter(function, iterable)
# 内置过滤器
def func(x):
if x >= 2:
return True
else:
return False
filter_obj = filter(func, [1, 2, 3])
generator_obj = (i for i in [1, 2, 3] if func(i))
print([i for i in filter_obj]) # [2, 3]
print([i for i in generator_obj]) # [2, 3]
# 改写成匿名函数
filter_obj = filter(lambda x: True if x >= 2 else False, [1, 2, 3])
print([i for i in filter_obj]) # [2, 3]
# zip()
# zip(*iterables, strict=False) # strict= True 多个迭代器长度相同,则不会引发异常 3.10版本增加的
print(list(zip([1, 2, 3], range(4),
('a', 'b', 'c')))) # [(1, 0, 'a'), (2, 1, 'b'), (3, 2, 'c')]## 并行迭代多个iterable，生成包含每个iterable项的元组
# map(function, iterable, )
# 多个可迭代对象同时迭代 从可迭代第一个参数作为值 知道可迭代对象迭代完成
iterator_obj = map(lambda x: x, range(1, 4))
print([i for i in iterator_obj]) # [1, 2, 3]
iterator_obj = map(lambda x, y: x + y, range(1, 4), range(1, 4))
print([i for i in iterator_obj]) # [2, 4, 6]
iterator_obj = map(lambda x, y: {str(x): str(y)}, range(1, 4), range(1, 4))
print([i for i in iterator_obj]) # [{'1': '1'}, {'2': '2'}, {'3': '3'}]
# 三个列表进行比较 选出下表位置最大的值
lst1 = [4, 1, 12]
lst2 = [5, 2, 11]
lst3 = [6, 3, 16]
iterator_obj = map(lambda x, y, z: max(x, y, z), lst1, lst2, lst3)
print([i for i in iterator_obj]) # [6, 3, 16]
from functools import reduce
# 累计执行，返回一个值
print(reduce(lambda x,y: x*10 + y, [3,4,5,6])) # 3456
print(reduce(lambda x,y: x + y, [3,4,5,6])) # 18 ## 累加
print(reduce(lambda x,y: x - y, [3,4,5,6])) # 360 ##累减
print(reduce(lambda x,y: x * y, [3,4,5,6])) # -12 ##累乘
# 常常和map 一起使用
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return DIGITS[s]
return reduce(fn, map(char2num, s))
# 结果
# 123456789
判断对象类型
看代码
# -------------------判断对象类型 -------------------------
# isinstance(object, classinfo)
# 返回结果是 True| False 判断对象的类型
print(isinstance('123', str)) # True
print(isinstance('123', list)) # False
print(isinstance(['1', '2', '3'], list)) # True
print(isinstance(['1', '2', '3'], (int, list))) # True
# issubclass(class, classinfo)
# 返回结果是 True| False # 判断类书是否属于另一个类的子类
print(issubclass(bool, str)) # False
print(issubclass(bool, bool)) # True
print(issubclass(bool, int)) # True
print(issubclass(bool, (str, int))) # True
枚举
看代码
# ----------------------------------枚举------------------------
# enumerate(iterable, start=0)
# 返回枚举对象
print(enumerate([1, 2, 3])) # <enumerate object at 0x01EAABE8>
print(next(enumerate([1, 2, 3]))) # (0, 1)
print(list(enumerate([1, 2, 3]))) # [(0, 1), (1, 2), (2, 3)]
print(list(enumerate([1, 2, 3], 1))) # [(1, 1), (2, 2), (3, 3)]
@classmethod,@staticmethod
看代码
# ---------------------------装饰器 ------------------------
# 将方法转换为类方法。 接收一个cls对象参数, 被装饰函数 类可以调用,类对象也可以对用。
# 如果为派生类调用了类方法，则派生类对象将作为隐含的第一个参数传递。 (如果子类调用了父类的@classmethod方法 则cls对象是子类对象)
# @classmethod
# 将方法转换为静态方法, 不接收参数，类 和对象直接调用，Python中的静态方法与Java或C++中的方法类似。
# @staticmethod
常用运算
看代码
# ------------------------------常用运算------------------
# abs()
print(abs(-12.12)) # 12.12 ## 返回数字的绝对值。参数可以是整数、浮点数或实现 __abs__() . 如果参数是复数，则返回其大小。
# divmod()
# 返回商和余数组成的元祖
print(divmod(12.6, 2)) # (6.0, 0.5999999999999996)
print(divmod(12, 5)) # (2, 2)
print(divmod(-12, -5)) # (2, -2)
print(divmod(12, -5)) # (2, -2)
print(divmod(-12, 5)) # (-3, -3)
# round()
# 返回四舍五入
print(round(12.265, 2)) # 12.27 返回 四舍五入小数点后的精度。
print(round(12.345, 2)) # 12.35
# len(s)
# 返回对象长度
print(len('122334')) # 6
# pow()
print(pow(38, 2)) # 38 的2次方
print(pow(2, 6)) # 2的 6次方
print(pow(2, -1)) # 2的 -1次方
all,any,sum,max,min
看代码
# -----------------all -- any -- sum -- max -- min ---------------------
# all()
print(all([1, 2, 3])) # True ## 所有元素为真则返回True，否则返回假False
print(all([1, 0, 3])) # False ## 所有元素为真则返回True，否则返回假False
# any()
print(any([1, 0, 3])) # True ## 只要有一个元素为真返回True， 否则返回False
print(any([0, 0, 0])) # False ## 只要有一个元素为真返回True， 否则返回False
# sum()
print(sum([1, 2, 3])) # 可迭代对象所有项的和 可迭代对象的项必须是数字
# max()
# 返回最大项 返回iterable中的最大项或两个或多个参数中的最大小项。
print(max(iter([1, 2, 3]), default='None')) # 3
print(max(iter([]), default='null')) # null
print(max('123', '345')) # 345
# min()
# 返回最小项 返回iterable中的最大项或两个或多个参数中的最小项。
print(min(iter([1, 2, 3]), default='None')) # 1
print(min(iter([]), default='null')) # null
print(min('123', '345')) # 123
数字类型转换
看代码
# --------------------------- 数字类型转换 ----------------------------
# bin()
print(bin(4)) # ## 将整数转换为前缀为“0b”的二进制字符串。
print(bin(-4)) # ## 将整数转换为前缀为“0b”的二进制字符串。
# oct()
# 八进制
print(oct(10)) # 0o12 ## 将整数转换为以“0o”为前缀的八进制字符串。
# int()
# 十进制
print(int(12.7)) # 12
print(int('13')) # 13
# hex()
# 十六进制
print(hex(12)) # 0xc ## 将整数转换为前缀为“0x”的小写十六进制字符串
print(12.12.hex()) # 0x1.83d70a3d70a3dp+3 ## 将小数转换为前缀为“0x”的小写十六进制字符串
类型转换
看代码
# str()
# 常用字符串强转
# str(object='')
# str(object=b'', encoding='utf-8', errors='strict')
# tuple()
# 强制转换元组
# tuple([iterable])
# tuple(list)
# float()
# 强转浮点
print(float('+1.23')) # 1.23
print(float(' -12345\n')) # -12345.0
print(float('1e-003')) # 0.001
print(float('+1E6')) # 1000000.0
print(float('-Infinity')) # -inf
对象,类,查看属性
看代码
# type()
# type(name, bases, dict)## 使用三个参数，返回一个新的类型对象。
type(object) ## 使用一个参数，返回 object . 返回值是一个类型对象，通常与返回的对象相同 object.__class__ .
# help()
# 获取对象帮助文档
print(help(str)) # 显示对象的帮助文档
# vars()
print(vars(int)) # 返回 __dict__ 模块、类、实例或具有 __dict__ 属性
print(int.__dict__) #
# callable()
# 类是可调用的
# 类 派生出的对象可不可以调用 取决于类是否有 __call__(self, *args, **kwargs) 方法。
print(callable(int)) # True ## 返回对象是否可以调用
print(callable('a')) # False ## 返回对象是否可以调用
# dir() 返回对象的属性
now = '当前'
_new = '_类内部属性,可以被继承'
__new = '__ 仅限当前类内部使用' # 不会被dir捕获
print(dir(), '当前文件对象属性！')
# 返回模块属性
import datetime
print(dir(datetime))
# 内核方法
class Shape:
def __dir__(self):
return ['area', 'perimeter', 'location']
print(Shape()) # ['area', 'perimeter', 'location']
# dir([object])
# 1)参数为空值时 返回当前文件的可用属性名称列表
# 2)参数为 是一个类型或类对象 则列表包含其属性的名称，以及其基的属性的递归名称
# 3)参数为 是对象 该列表包含对象的属性名称、类属性的名称以及类的基类的递归属性。
# 4) 当参数是类时，元类属性不在结果列表中。
生成对象
看代码
# --------------------------------------生成对象--------------------------------
# 复数对象
# complex([real[, imag]])
# 生成字典对象
# dict(**kwarg)
# object()
# object() #返回一个新的无特征对象。 object 是所有类的基础。它具有所有Python类实例通用的方法。
# frozenset([iterable])
# 返回一个新的 frozenset 对象
print(frozenset([1, 2, 3])) # frozenset({1, 2, 3}) 不可变集合
print(set([1, 2, 3])) # {1, 2, 3} # 可变集合
# iter(object[, sentinel])
# 返回一个iterator 对象
iterable_obj = iter([1, 2, 3])
print(next(iterable_obj)) # 1
print(next(iterable_obj)) # 2
print(next(iterable_obj)) # 3
lst = [1, 2, 3]
# print(next(lst)) # 注意列表是可迭代对象，但是列表不是迭代器对象 这个语句会报错！
字节操作
看代码
# --------------------------------------字节操作--------------------------------
# bytearray()
# 返回新的字节数组。这个 bytearray 类是范围0<=x<256的可变整数序列。它具有大多数常用的可变序列方法，如 可变序列类型 以及大多数方法 bytes 类型已见 字节和字节数组操作 .
print(bytearray('你好世界'.encode('utf-8'))) # 如果是 string ，您还必须 encoding
print([i for i in bytearray('你好世界'.encode('utf-8'))])
print(bytearray(12)) # 如果是 整数 ，数组将具有该大小，并将用空字节初始化
print([i for i in bytearray(12)])
print(bytearray()) # 如果没有参数，将创建大小为0的数组。
print([i for i in bytearray()])
# 如果它是符合 buffer interface 对象的只读缓冲区将用于初始化字节数组
# 如果是 可迭代的 ，它必须是范围内整数的可Itable 0 <= x < 256 ，用作数组的初始内容。
# bytes()
# 返回一个新的“bytes”对象，该对象是范围内不可变的整数序列 0 <= x < 256 . bytes 是的不可变版本 bytearray --它具有相同的非变异方法和相同的索引和切片行为。
# print(bytes('你好世界'.encode()))
# print([i for i in bytes('你好世界'.encode())])
# print(bytes('你好世界'.encode())[0:2])
# print([i for i in bytes('你好世界'.encode()[0:2])])
# memoryview()
# memoryview() # 返回内存视图 目前不知道用法
# 从中检索下一项 迭代器 通过调用它的 __next__() 方法 返回迭代器的下一项
# print(next(iter([1,2,3]))) # 1
执行字符串python代码
看代码
# ----------------------------------执行字符串python代码 -----------------------
# 可执行对象
# compile(source, filename, mode) # 生成此对象交由 exec() 或 eval()执行
# source 可以是普通字符串、字节字符串或AST对象。
# filename 这个 filename 代码的文件地址；如果不是从文件中读取代码，则传递一些可识别的值 'string'。
# 这个 mode 参数指定必须编译的代码类型 三种: 分别是 exec ，eval，single
# 参数 optimize 指定编译器的优化级别 optimize 指定编译器的优化级别；默认值为 -1 选择解释器的优化级别，如 -O 选项。显式级别是 0 （无优化； __debug__ 是真的） 1 （断言被删除， __debug__ 是假的） 2 （文档字符串也被删除）。
# 此函数引发 SyntaxError 如果编译的源无效，并且 ValueError 如果源包含空字节。
# 注解 编译包含多行代码的字符串时 'single' 或 'eval' 模式，输入必须至少以一个换行符终止。这有助于检测 code 模块。
# 警告 由于python的ast编译器中的堆栈深度限制，在编译到ast对象时，可能会使用足够大/复杂的字符串使python解释器崩溃。
# 执行 字符类型的python代码
# eval(expression[, globals[, locals]])
# exec(object[, globals[, locals]])
格式化字符串
看代码
# ----------------------------------格式化字符串----------------------------------
# format(value[, format_spec])
# 1)默认值 format_spec 是一个空字符串，通常产生与调用相同的效果 str(value) .
print(format(14, '#b'), format(14, 'b')) # 0b1110 1110
print("二进制: {0:#b} 格式化二进制: {0:b}".format(14)) # 二进制: 0b1110 格式化二进制: 1110 去掉二进制的Ob
print(f'二进制: {14:#b}', f' 格式化二进制: {14:b}') # 二进制: 0b1110 格式化二进制: 1110 去掉二进制的Ob
print(format(5, 'b')) # '101'
print(format(5, '#b')) # '0b101'
print(format(5, '12b')) # ' 101'
print(format(5, '#12b')) # ' 0b101'
print(format(5, '012b')) # '000000000101'
print(format(5, '#012b')) # '0b0000000101'
print(format(1003.1415926, '.2f')) # 1003.14
print(format(1003.1415926, '.2%')) # 100314.16%
print(format(1003.1415926, ',.2f')) # 1,003.14
print(format(1003.1415926, ',.2%')) # 100,314.16%
print(format(1003.1415926, ',.12')) # 1,003.1415926
print(format(1003.1415926, '_.2%')) # 100_314.16%
反射
看代码
# -----------------------------------------反射 -----------------------------
# delattr(object, name)
# 删除对象属性
# 这是一个亲戚 setattr() . 参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。
# 如果对象允许，函数将删除命名属性。例如， delattr(x, 'foobar') 等于 del x.foobar .
# getattr(object, name[, default])
# 返回对象的属性
print(dir(str))
print(getattr(str, 'as', 'null')) # 返回对象属性的值 如果属性不存在则返回默认值 没有设置默认值则抛出异常！
# hasattr(object, name)
# 判断对象是否有属性方法
print(hasattr(str, 'as')) # False ## 参数是一个对象和一个字符串。结果是 True 如果字符串是对象属性之一的名称， False 如果没有
print(hasattr(str, 'count')) # True ##
# setattr()
# 设置对象属性
# setattr(object, name, value) # 这是 getattr() .参数是一个对象、一个字符串和一个任意值。# 该字符串可以命名现有属性或新属性。只要对象允许，函数就为属性赋值。例如， setattr(x, 'foobar', 123) 等于 x.foobar = 123 .
@property，property()
看代码
# 作用一： 防止属性被篡改
# 可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。
# 作用二： 使得方法变成属性的调用方式
# 作用三： 在获取属性，设置属性，删除属性时候设置一些限制，比如 显示年龄属性的范围
# 作用四： 在对属性操作的时候 做一些操作，在游戏中，角色死亡播放动画等
# 返回属性, 获取内部属性，修改内部属性，删除内部属性
# property(fget=None, fset=None, fdel=None, doc=None)
# fget 是用于获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。和 doc 为属性创建docstring。
class C:
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
# 此代码与第一个示例完全等效。确保为附加函数赋予与原始属性相同的名称 (x 在这种情况下）
class C:
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
# 函数转化成属性
class Parrot:
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
其他
看代码
# ------------------------------------------- 其他 --------------------------------------------
# __import__()
date = __import__('datetime') # 延迟导入 # 日常python代码编写不需要用到
print(dir(date)) #
# 内置功能 globals() 和 locals() 分别返回当前的全局和局部字典
print(globals()) # 返回表示当前全局属性的字典。这始终是当前模块的字典（在函数或方法中，这是定义它的模块，而不是从中调用它的模块）
print(locals()) # 更新并返回表示当前本地属性的字典。 当它在函数块中调用时，而不是在类块中调用。注意，在模块级， locals() 和 globals() 是同一本字典。
# property()
# 需要详细解释 内置模块经常使用
# property(fget=None, fset=None, fdel=None, doc=None) # 返回属性属性 # fget 是用于获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。和 doc 为属性创建docstring
# id()
# 返回对象id数值
print(id(1)) # 1515545744 # 返回对象的“标识”。这是一个整数，它保证在这个对象的生存期内是唯一的和不变的。生命周期不重叠的两个对象可能具有相同的 id
# hash()
# 返回对象hash数值
print(hash(str)) # -2052770554 # 返回对象的hash值（如果有）。hash值是整数。
print(hash('123')) # 字符串每次hash的值都不一样
print(hash(123)) # 123
print(hash(123.12)) # 1889806704
# repr()
# 返回包含对象的可打印表示形式的字符串，通常返回对象的名称和地址
print(repr(object)) # <class 'object'>
print(repr(object)) # <class 'object'> ## 返回包含对象的可打印表示形式的字符串。
# ascii()
# 返回对象的ascii编码格式
print(ascii('你好世界')) # '\u4f60\u597d \u4e16\u754c' # 返回对象的ascii编码格式
print(ascii([1, 2, 3])) # [1, 2, 3] # 返回对象的ascii编码格式
print(ascii(['你好', '世界'])) # ['\u4f60\u597d', '\u4e16\u754c'] # 返回对象的ascii编码格式
# bool()
# 返回对象的布尔值
print(bool('1')) # True
print(bool('0')) # True
print(bool('')) # False
# breakpoint() # 使得控制台进入pdb模式, （目前没有使用过，之后学习使用）
# chr()
# 返回表示其Unicode码位为整数的字符的字符串 i . 参数的有效范围是从0到1114111
print(chr(97)) # a
print(chr(98)) # b
print(chr(114)) # r
# ord()
# 返回单字符字符串的Unicode码位。 chr()对应
print(ord('a'))
print(ord('b'))
print(ord('r'))
print(ord('a')) # 97 ## 给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode码位的整数。
# range()
# print(range(3)) # range(0, 3) ## range 实际上是不可变的序列类型 并不是一个函数
# super()
# super([type[, object-or-type]]) 继承方法需要 研究下
# open()
# open() # 打开文件并返回文件对象 ##正常开放 file 并返回相应的 file object . 如果无法打开文件
# print()的特殊用法
wf = open('./text.txt', 'w', encoding='utf-8')
print('你好这是测试输出', '测试分隔', sep='$', end='\t', file=wf, flush=True)
print('你好这是测试输出', '测试分隔', sep='$', end='\t', file=wf, flush=True)
# wf.close()
result = input('标准输入:') # result 类型为str
测试
看代码
class A:
name = 'A'
...
def __init__(self):
self.age = 18
@classmethod
def get_name(cls, name):
print(cls.__base__)
return name
def __repr__(self):
return '这是A对象'
def __index__(self):
return 4
def __bool__(self):
return False
def __call__(self, *args, **kwargs):
return '调用结果a!'
# def __dir__(self):
# return ['A']
class B:
...
a = A()
b = B()
print(vars(a)) # {'age': 18} 返回对象的self属性
print(vars(b)) # {'age': 18}
print(dir(a)) # ['A']
print(dir(b)) # 其对象, 对象所属类， 所属类父类的所有属性名称。
# # 如果为派生类调用了类方法，则派生类对象将作为隐含的第一个参数传递。 (如果子类调用了父类的@classmethod方法 则cls对象是子类对象)
print(A.get_name('A')) # A ## 类可直接调用
print(a.get_name('a')) # a ## 对象可直接调用
print(callable(A)) # True
print(callable(a)) # True
print(callable(b)) # False b 对象是不可调用的
print(a()) # 调用结果a!
print(a.__call__()) # 调用结果a!
print(repr(a)) # 这是A对象
print(a.__repr__()) # 这是A对象
print(bin(a)) # 0b100
print(a.__index__()) # 4
print(bool(a)) # False
print(a.__bool__()) # False
print(hash(a))
print(hash(b))
引用文档地址
