python之内置函数的基本使用（python内置函数的使用方法）

python之内置函数的基本使用（python内置函数的使用方法）

abs的使用：

取绝对值

1 absprint(abs(123))print(abs(-123))result：123123

all的使用：

循环参数，如果每个元素都为真的情况下，那么all的返回值为True：

python中为假的情况：0， None， ""， []， ()， {}

ret = all([True, True])ret1 = all([True, False])result:TrueFalse

any的使用：

只要有一个为True，则全部为True

ret = any(None, "", [])ret1 = any(None, "", 1)result:FalseTrue

ascii的使用：

回到对象的类中，找到__repr__方法，找到该方法之后获取返回值【与直接print(对象变量)效果相同】

class Foo: def __repr__(self): return "hello"obj = Foo()ret = ascii(obj)print(ret)print(obj)result:hellohello自动去对象(类)中找到 __repr__方法并获取其返回值

bin的使用：

二进制：只能将十进制数转换为二进制数

ret = bin(11)result:0b1011

oct的使用：

八进制：只能将十进制转为八进制

ret = oct(14)result:0o16

int的使用：

十进制：

ret = int(10)result:10

hex的使用：

十六进制：将十进制转为十六进制

ret = hex(14)result:0xe 0x:表示16进制 e： 表示14

bool的使用：

判断真假，  True：真 ；False：假；

把一个对象转换成bool值

ret = bool(None)ret = bool(1)result:FalseTrue

bytearray的使用：

将字符串转换为二进制数据

bytes("xxx", encoding="utf-8")print(bytes("xxx", encoding="utf-8"))等同于print("字符串".encode(encoding='utf8'))print(bytes("字符串", encoding="utf-8"))result：b'\xe8\x83\xa1\xe6\xa2\x81\xe6\xa0\x91'b'\xe8\x83\xa1\xe6\xa2\x81\xe6\xa0\x91'

callable的使用：

判断对象是否可被调用

class Foo: #定义类 passfoo = Foo() # 生成Foo类实例print(callable(foo)) # 判断类的实例是否可被调用ret = callable(Foo) # 判断Foo类是否可被调用print(ret)result：FalseTrue

chr的使用：

给数字找到对应的字符

ret = chr(65)result:A

ord的使用：

给字符找到对应的数字

ret = ord("a")result:97

dict的使用：

new_dict = dict()print(new_dict)new_dict['key1'] = "test"print(new_dict)result:

{}  {'key1': 'test'}

dir的使用：

该方法将最大限制地收集参数信息， 查看当前，变量，方法， 类型的属性以及功能。

print(dir())list_one = list()print(dir(list_one)) result：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

divmod的使用：

将除数和余数运算结果结合起来，返回一个包含商和余数的元祖。

ret = divmod(7, 2)print(ret)ret_one = divmod(8, 2)print(ret_one)参数： 数字result：(3, 1)(4, 0)

exec的使用：

执行存储在字符串或文件中的python语句，相比eval，exec可以执行更复杂的python代码

import timeret = exec("""for i in range(0,5): time.sleep(1) print(i) """)# 注意代码块中的缩进result:01234

filter的使用：

用于过滤序列，过滤掉不符合条件的元素，返回符合条件元素组成的新list

def is_odd(n): return n % 2 == 1newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])print(newlist)参数：function 判断函数iterable 可迭代对象result：[1, 3, 5, 7, 9]

float的使用：

将整形转换成小数形

a_int = 10b_float = float(a_int)print(a_int)print(b_float)result：1010.0

format的使用：

字符串序列化，可以序列多种类型

str_format = "Helle World"list_format = ['list hello world']dict_format = {"key_one":"value_one"}ret_format_one = "{0}".format(str_format)ret_format_two = "{0}".format(list_format)ret_format_three = "{0}".format(dict_format)print(ret_format_one)print(ret_format_two)print(ret_format_three)result：Helle World['list hello world']{'key_one': 'value_one'}

frozenset的使用：

返回一个冻结集合，集合冻结之后不允许添加，删除任何元素

a = frozenset(range(10)) # 生成一个新的不可变集合print(a)b = frozenset('wyc') # 创建不可变集合print(b)result：frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})frozenset({'w', 'y', 'c'})

globals的使用：

会以字典类型返回当前位置的全部全局变量

print(globals())result：{'__cached__': None, '__name__': '__main__', '__builtins__': , '__doc__': None, '__package__': None, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/day1.py', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000011E78626B70>, '__spec__': None}

hash的使用：

用于获取一个对象(字符串或者数值等)的哈希值

str_test = "wyc"int_test = 5print(hash(str_test))print(hash(int_test))result：13052398781691228695

help的使用：

帮助查看类型有什么方法

str_test = "wyc"print(help(str))result：结果有点小长，就不粘贴再此了

id的使用：

查看当前类型的存储在计算机内存中的id地址

str_test = "wyc"print(id(str_test))result：2376957216616

input的使用：

接受标准数据，返回一个string类型

user_input = input("请输入：")print(user_input)result：请输入：wycwyc

isinstance的使用：

判断一个对象是否是一个已知的类型，类似type()

a = 1print(isinstance(a, int))print(isinstance(a, str))result:TrueFalse

issubclass的使用：

用于判断参数class是否是类型参数， classinfo的子类

class A: passclass B(A): passprint(issubclass(B, A)) # 判断B是否是A的子类result：True

iter的使用：

用来生成迭代器

lst = [1, 2, 3]for i in iter(lst): print(i)result：123

len的使用：

查看当前类型里边有多少个元素

str_one = "hello world"lst = [1, 2, 3]print(len(str_one)) # 空格也会算一个元素print(len(lst)) result：113

list的使用：

列表

list = [1, 2, 3, 4, 5]方法：索引： index切片： [1:3]追加： append删除： pop长度： len扩展： extend插入： insert移除：remove反转： reverse排序：sort

locals的使用：

以字典类型返回当前位置的全部局部变量

def func(arg): z = 1 return locals()ret = func(4)print(ret)result：{'arg': 4, 'z': 1}

map的使用：

根据提供的函数对指定序列做映射

def func(list_num): return list_num * 2print(map(func, [1, 2, 3, 4, 5]))result:[2, 4, 6, 8, 10]

max的使用：

返回最大数值

ret = max(1, 10)print(ret)result：10

memoryview的使用：

返回给定参数的内存查看对象

v = memoryview(bytearray("abc", 'utf-8'))print(v[0])restlt：97

min的使用：

取出最小数值

print(min(1, 10))result：1

next的使用：

返回迭代器的下一个项目

it = iter([1, 2, 3, 4, 5])while True: try: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 breakresult：12345

open的使用：

打开一个文件，创建一个file对象，相关的方法才可以调用它的读写

f = open('test.txt')f.read()f.close() # 文件读写完成之后，一定要关闭

ord的使用：

函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

ret = ord('a')ret1 = ord('b')ret2 = ord('c')result:979899

pow的使用：

返回 xy（x的y次方） 的值

import math # 导入 math 模块 print "math.pow(100, 2) : ", math.pow(100, 2)# 使用内置，查看输出结果区别print "pow(100, 2) : s%" % pow(100, 2)

property的使用：

新式类中的返回属性值

class C(object): 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.")

range的使用：

输出范围之内的数值

for i in range(1, 5): print(i)result:1234

repr的使用：

函数将对象转化为供解释器读取的形式

s = 'RUNOOB'repr(s)"'RUNOOB'"dict = {'runoob': 'runoob.com', 'google': 'google.com'};repr(dict)"{'google': 'google.com', 'runoob': 'runoob.com'}"

reversed的使用：

返回一个反转的迭代器

# 字符串seqString = 'Runoob'print(list(reversed(seqString))) # 元组seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')print(list(reversed(seqTuple))) # rangeseqRange = range(5, 9)print(list(reversed(seqRange))) # 列表seqList = [1, 2, 4, 3, 5]print(list(reversed(seqList)))result：['b', 'o', 'o', 'n', 'u', 'R']['b', 'o', 'o', 'n', 'u', 'R'][8, 7, 6, 5][5, 3, 4, 2, 1]

round的使用：

返回浮点数x的四舍五入值

print "round(80.23456, 2) : ", round(80.23456, 2)print "round(100.000056, 3) : ", round(100.000056, 3)print "round(-100.000056, 3) : ", round(-100.000056, 3)result：round(80.23456, 2) : 80.23round(100.000056, 3) : 100.0round(-100.000056, 3) : -100.0

slice的使用：

实现切片对象，主要用在切片操作函数里的参数传递

myslice = slice(5) # 设置截取5个元素的切片print(myslice)print(slice(None, 5, None))arr = range(10)print(list(arr))print(list(arr[myslice])) # 截取 5 个元素result:slice(None, 5, None)slice(None, 5, None)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9][0, 1, 2, 3, 4]

sorted的使用：

所有可迭代的对象进行排序操作

a = [5,7,6,3,4,1,2]b = sorted(a) # 保留原列表print(a) [5, 7, 6, 3, 4, 1, 2]print(b)[1, 2, 3, 4, 5, 6, 7] L=[('b',2),('a',1),('c',3),('d',4)]sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数[('a', 1), ('b', 2), ('c', 3), ('d', 4)]print(sorted(L, key=lambda x:x[1])) # 利用key[('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]print(sorted(students, key=lambda s: s[2]) ) # 按年龄排序[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] print(sorted(students, key=lambda s: s[2], reverse=True) ) # 按降序[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

staticmethod的使用：

返回函数的静态方法

class C(object): @staticmethod def f(): print('runoob'); C.f(); # 静态方法无需实例化cobj = C()cobj.f() # 也可以实例化后调用

str的使用：

str = "wyc"方法：cpitalize 首字母变大写count 子序列个数decode 解码encode 编码针对unicodeendswith 是否以xxx结束find 寻找子序列位置，如果没有找到，返回-1format 字符串格式化index 子序列位置，如果没有找到，报错isalnum 是否是字母数字isalpha 是否是字母isdigit 是否是数字islower 是否小写join 拼接lower 变小写lstrip 移除左侧空白replace 替换

sum的使用：

求数值整合

print(sum(1+1))result:2

super的使用：

用于调用父类(超类)的一个方法

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx python3class A: passclass B(A): def add(self, x): super().add(x)python2class A(object): # Python2.x 记得继承 object passclass B(A): def add(self, x): super(B, self).add(x)

type的使用：

查看当前类型是什么类型

lst = list()print(type(lst))result:

vars的使用：

返回对象object的属性和属性值的字典对象

print(vars()){'__builtins__': , '__name__': '__main__', '__doc__': None, '__package__': None}class Runoob: a = 1print(vars(Runoob)){'a': 1, '__module__': '__main__', '__doc__': None}runoob = Runoob()print(vars(runoob)){}

zip的使用：

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]b = [4,5,6]c = [4,5,6,7,8]zipped = zip(a,b) # 打包为元组的列表[(1, 4), (2, 5), (3, 6)]zip(a,c) # 元素个数与最短的列表一致[(1, 4), (2, 5), (3, 6)]zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式[(1, 2, 3), (4, 5, 6)]

__import__的使用：

函数用于动态加载类和函数

import time， os

扩展进制转换：

二进制转换十进制int('0b11', base=2)result: 3八进制转换十进制int('11', base=8)result: 9十六进制转换十进制int('0xe', base=16)result: 14

去期待陌生，去拥抱惊喜。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。