python定义全局函数_Python-全局函数(内置方法、内置函数)

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　　判断对象是否是某种或多个类型，判断对象是否继承某个类

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__())