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　　判斷對象是否是某種或多個類型，判斷對象是否繼承某個類

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