Python有很多内置方法，这些都全局可用
abs() 求数值的绝对值，如果是复数则返回其模
print(abs(-17), abs(30.2), abs(3+4j))
# Python中复数表示为 3 实部 4虚部， + j
all() 可迭代对象所有元素为True则返回True，否则返回False
print(all([1, 3, ""]), all([1, 3, " "]))
# 空格字符也算一个有效字符
print(all([1, 3, " "]), all([1, 3, None]))
any() 可迭代对象所有元素为False则返回False，否则返回True
print(any([None, {}, ""]), any([1, (), ""]))
ascii() 以ascii码依据转换为字符串，非ascii如UTF-8字符则有\u前缀进行转义
print(ascii("北门吹雪"), ascii(33))
bin() 整数转换为二进制字符串，遵守Python协议 __index__返回整数
class Number:
def __index__(self):
int_number = 33
return int_number
print(bin(33))
print(bin(Number()))
bool() 对值进行布尔运算，一般 None、空字符串、空列表、空元组、空集合、空字典、0等空元素和空数据结构为False，其他为True
print(bool(None))
print(bool(" "))
print(bool(""))
print(bool([]))
print(bool({}))
bytearary 返回新的二进制数组，和list数据结构类似，拥有序列大多数方法，这个是存放二进制数据，添加数据需要输入整数参数范围为(0, 256)
number = bytearray("北门吹雪", encoding="utf-8")
number.append(11)
number.insert(0, 12)
print(number, type(number))
bytes 返回一个二进制不可变对象
# 通过encoding指定转换对象字符编码
print(bytes("北门吹雪", encoding="utf-8"))
callable 判断对象是否可调用，遵守Python协议 __call__ ，类通过该魔法方法调用
class BeiMenChuiXue:
def __call__(self, *args, **kwargs):
print("Hai, BeiMenChuiXue")
BeiMenChuiXue()()
print(callable(BeiMenChuiXue))
chr 返回数字对应的Unicode字符
print(chr(21271))
print(chr(38376))
print(chr(21561))
print(chr(38634))
ord 返回Unicode字符对应的数字
print(ord("北"))
print(ord("门"))
print(ord("吹"))
print(ord("雪"))
complex 返回复数， 分real和imag两个部分，通过+来连接real和imag，j标识imag部分
print(complex("4+5j"))
print(complex(4, 6))
delattr 删除对象中一个实例属性
class BeiMenChuiXue:
def __init__(self, name, skin, is_student):
self.name = name
self.skin = skin
self.is_student = is_student
beimenchuixue = BeiMenChuiXue("北门吹雪", 'yellow', True)
print(beimenchuixue.name)
# 删除对象中的属性
delattr(beimenchuixue, "name")
print(beimenchuixue.name)
dict 生成一个新的字典对象
print(dict(), type(dict()))
dir 没有参数返回当前作用域变量和方法列表，添加对象则返回对象中变量和方法列表，遵守Python协议 __dir__ 必须返回属性列表
name = "北门吹雪"
print(dir())
def study():
age = 10
return age
class Student:
def __init__(self, name):
self.name = name
def study(self):
age = 10
return age
beimenchuixue = Student("北门吹雪")
print(dir(study))
print(dir(beimenchuixue))
divmod 非复数整数，a//b a%b， 返回整除整数和余数
print(divmod(10, 3.0))
enumerate 返回一个枚举对象，可以指定start指定枚举计数，默认为0
# start指定枚举计数， 参数必须是iterable对象
enu_object = enumerate("BeiMenChuiXue", start=1)
print(enu_object, type(enu_object))
# 返回的是元组形式
for member in enu_object:
print(member)
eval 运行字符串代码，不更改源码逻辑，可完成数学运算
sum = 0 print(sum + 1)
print(eval("sum + 1"))
eval("sum + 1")
print(sum) result = eval("1+3*(6+1)*5") print(result)
exec 运行字符代码，改变源码逻辑
sum = 0
exec("sum += 1")
print(sum)
filter 依次取出iterable中元素交给一个函数，取返回True的元素
import random
# 生成 -10 到 10 之间的随机整数
numbers = [random.randint(-10, 10) for _ in range(10)]
def is_natural(number):
"""判断是否是自然数"""
if isinstance(number, int) and number >= 0:
return True
else:
return False
# 返回filter对象
result = filter(is_natural, numbers)
print(list(result))
float 把字符串转换为float数据，自动去除两边空格，遵守Python协议 __float__
print(float("12.3"))
print(float(" 12"))
print(float("+105 "))
print(float(" -105 "))
# 没参数则返回 0.0
print(float())
class BeiMenChuiXue:
def __float__(self):
return 10.3
print(float(BeiMenChuiXue()))
format 格式化字符串
name = "BeiMenChuiXue"
print("{name} is studying Python".format(name=name))
globals 当前模块的全局变量字典
print(globals())
def hello():
age = 19
print(globals())
hello()
getattr 通过字符串获取对象属性和方法值，一般联合hasattr使用
class BeiMenChuiXue:
def hello(self):
print("Heai, biemenchuixue")
beimenchuixue = BeiMenChuiXue()
print(getattr(beimenchuixue, 'hello', None))
hasattr 判断对象中是否有对应字符串的属性和方法
class BeiMenChuiXue:
def hello(self):
print("Heai, biemenchuixue")
beimenchuixue = BeiMenChuiXue()
if hasattr(beimenchuixue, "hello"):
getattr(beimenchuixue, "hello")()
hash 返回对象的hash值，遵守Python协议 __hash__， 依据主机位宽截取，分32位和64位
class BeiMenChuiXue:
def __hash__(self):
return 6666
beimenchuixue = BeiMenChuiXue()
print(hash("2222"))
print(hash(beimenchuixue))
help 获取方法名和方法名下面的注释
class BeiMenChuiXue:
def __hash__(self):
"""北门吹雪"""
return 6666
beimenchuixue = BeiMenChuiXue()
print(help(beimenchuixue))
hex 将整数转换为16进制，遵守Python协议 __index__,返回一个整数
class BeiMenChuiXue:
def __index__(self):
return 222
beimenchuixue = BeiMenChuiXue()
print(hex(beimenchuixue))
print(hex(222))
id 获取对象内存地址，10进制
name = "BeiMenChuiXue"
print(id(name))
print(hex(id(name)))
input 获取终端标准输入，自动去除末尾换行符，返回的是字符串
name = input("请输入你的名字:")
print(name)
int 默认10进制，将其他对象转换为10进制，base指定字符的进制，无对象则为0，遵守Python协议 __index__返回一个整数
print(int(1.10))
print(int(" 22"))
print(int('0b10110', base=2))
isinstance 判断对象是否是某种或多个类型，判断对象是否继承某个类
Python-判断变量类型和继承树-isinstance type
issubclass 判断类是否是某个类的子类
class Father:
pass
class Son(Father):
pass
print(issubclass(Son, Father))
iter 返回迭代器对象，遵守Python协 __iter__ __next__ 或 __getitem__
students = ["QiNiuYun", "BeiMenChuiXue", "JinRiTouTiao", "TengXun"]
print(hasattr(students, '__next__'))
# 返回一个迭代器对象
students_iter = iter(students)
print(hasattr(students_iter, '__next__'))
print(students_iter.__next__())
len 获取对象长度, 遵守Python协议 __len__, 需要返回 len() 对象
class Student(object):
def __init__(self, names):
self.names = names
def __len__(self):
return len(self.names)
students = Student(["QiNiuYun", "BeiMenChuiXue", "JinRiTouTiao"])
print(len(students))
print(len(["QiNiuYun", "BeiMenChuiXue", "JinRiTouTiao"]))
list Python中列表，可以将Iterable转换为列表
print(list())
print(list("BeiMenChuiXue"))
print(list((i*5 for i in range(10))))
local 返回当前作用域中变量和值字典
def beimenchuixue():
name = "BeiMenChuiXue"
age = 19
print(locals())
beimenchuixue()
map 将可迭代对象依次传入函数，返回可迭代对象
def go_upper(value):
if isinstance(value, str):
return value.upper()
return ''
result = map(go_upper, ["beimenchuixue", 'qiniuyun', 'jinritoutiao'])
print(type(result))
print(result.__next__())
max 获取可迭代对象最大项元素
print(max([1, 2, 3]))
print(max('beimenchuixue'))
min 获取可迭代对象最小项元素
print(min([1, 2, 3]))
print(min('beimenchuixue'))
next 获取迭代器下一个值，没有则触发StopIteration错误，也可以传递一个默认值，迭代耗尽时返回默认值，遵守Python协议 __next__
def go_upper(value):
if isinstance(value, str):
return value.upper()
return ''
result = map(go_upper, ["beimenchuixue", 'qiniuyun', 'jinritoutiao'])
print(next(result))
class BeiMenChuiXue:
def __init__(self):
self.index = 0
def __next__(self):
self.index += 1
return self.index
beimenchuxue = BeiMenChuiXue()
print(next(beimenchuxue))
print(next(beimenchuxue))
oct 将整数转换为8进制，遵循Python协议 __index__ 返回一个整数
print(oct(11))
ord 将Unicode字符转换为对应的整数
print(ord("北"))
pow 返回 x * y 或 返回 x * y % z的值
print(pow(10, 3))
print(pow(10, 3, 33))
print 输出流，到终端或者到文件
print("bemenchuixue", end=':QiNiuYun')
with open('bemenchuixue.txt', 'a+') as f:
print("beimenchuxue\nQiNiuYun", file=f)
range 不可变数据序列，有三个参数 start, stop, step
print(type(range(10)))
print(list(range(1, 10)))
for i in range(1, 10, 2):
print(i)
reper 将对象转换为字符串，遵守Python协议 __repr__
repr_str = repr(11)
print(repr_str, type(repr_str))
class BeiMenChuiXue:
def __repr__(self):
return "BeiMenChuiXue"
beimenchuixue = BeiMenChuiXue
print(beimenchuixue())
print(repr(BeiMenChuiXue()))
print(beimenchuixue())
reversed 将iterable对象反转，返回iterator，遵守Python协议 __reversed__ 或 __len__ __getitem__
class BeiMenChuiXue:
def __init__(self, names):
self.names = names
def __reversed__(self):
return reversed(self.names)
# def __len__(self):
# return len(self.names)
#
# def __getitem__(self, item):
# return self.names[item]
beimenchuixue = BeiMenChuiXue(["beimenchuixue", 'qiniuyun', 'jinritoutiao'])
result = reversed(beimenchuixue)
print(type(result), next(result))
round 四舍五入保留多少小数位
print(round(10.3367, 3))
set 集合，将iterable对象中元素依次添加到集合中，集合天生无序和去重
print(set("北门吹雪 beimenchuixue"))
print(set())
setattr 往对象中添加属性和方法
class BeiMenChuiXue:
pass
beimenchuixue = BeiMenChuiXue()
# 设置属性
name = "北门吹雪"
setattr(beimenchuixue, 'name', name)
print(beimenchuixue.__dict__)
print(beimenchuixue.name)
# 设置方法, 自动添加上 self
def study():
print('%s is studying Python' % name)
setattr(beimenchuixue, 'study', study)
beimenchuixue.study()
slice 返回切片范围对象， start, end, step，不写默认None
bei = slice(0, 3)
print("beimenchuixue"[bei])
print("北门吹雪"[bei])
str 把对象转换为字符str类型，类似 repr，遵循Python协议 __str__
class BeiMenChuiXue:
def __str__(self):
return "北门吹雪"
beimenchuixue = BeiMenChuiXue
print(beimenchuixue())
print(str(12))
sorted 将iterable对象进行排序
import random
numbers = [random.randint(-10, 10) for _ in range(10)]
print(numbers)
print(sorted(numbers))
print(numbers)
print(sorted(numbers, reverse=True))
sum 序列求和，整数序列
print(sum([1, 23, 4]))
super 调用父类方法，本质上是寻找.__mro__下一个类中方法
class Student:
def __init__(self, name, language):
self.name = name
self.language = language
class Programmer:
def __init__(self, language):
self.language = language
class BeiMenChuiXue(Student, Programmer):
def __init__(self, name, language, age):
super().__init__(name, language)
self.age = age
print(BeiMenChuiXue.__mro__)
beimenchuixue = BeiMenChuiXue("北门吹雪", '汉语', '18')
print(beimenchuixue.language)
tuple 元组，不可变序列类型
print(tuple(), type(tuple()))
print(tuple("北门吹雪"))
type 返回对象是由什么类型构建的
print(type("北门吹雪"))
print(type(int))
print(type(object))
print(type(type))
vars 获取对象(模块、类、实例、字典等)具有__dict__属性的字典，对象 __dict__另外一种实现方式
def beimenchuixue():
name = "北门吹雪"
age = 18
print(vars())
beimenchuixue()
print(vars(beimenchuixue))
class BeiMenChuiXue:
def __init__(self, name, language, age):
self.name = name
self.language = language
self.age = age
beimenchuixue = BeiMenChuiXue("北门吹雪", '汉语', '18')
print(beimenchuixue.language)
# 获取对象 模块、字典、类、实例等具有 __dict__属性的字典
print(vars(beimenchuixue))
zip 依次取出可迭代对象中元素组成新的元组，返回一个迭代器
beimenchuixue = zip("beimenchuixue", "北门吹雪", "Hello word!")
print(beimenchuixue.__next__())
print(beimenchuixue.__next__())
print(beimenchuixue.__next__())
print(beimenchuixue.__next__())