内置方法

目录

• 一、字符串的内置方法
  • 1、replace 替换
  • 2、divmod 除数余数结合
  • 3.abs 返回绝对值
  • 4.eval 、exec执行字符串表达式
  • 5.isinstance 判断类型
  • 6.pow计算幂次方
  • 7.sum 求和
  • 8.basestring
  • 9.issubclass 判断是否是谁的子类
  • 10.super 超类
  • 11.iter 生成迭代器
  • 12.tuple 元组
  • 13.bool 真假
  • 14.filter 过滤
  • 15.range 范围
  • 16.type 判断类型
  • 17、ord、chr ASCLL码与字符相互转换
  • 18、frozenset 不可变集合
  • 19、long 长整型
  • 20、reload 重载模块
  • 21、vars
  • 22、classmethod装饰符
  • 23、getattr :取值 反射
  • 24、hasattr： 查找
  • 25、setattr： 添加
  • 26、delattr: 删除
  • 27、map 映射
  • 28、zip 拉链
  • 29、sorted 排序
  • 30、reduce 额外的
  • 31、globals 全局变量
  • 32、nonlocal 局部变量
  • 33、reverse 颠倒,逆序
  • 34、help 查看函数或模块的用途说明
  • 35、hex 十进制转十六进制
  • 36、oct 十进制转八进制
  • 37、bin 十进制转二进制
  • 38、int 其他进制转十进制
  • 39、id 获取对象的内存地址
  • 40、upper 把所有字符中字母转大写
  • 41、lower 把所有字符中字母转小写
  • 42、capitalize 把第一个字母转化为大写字母，其余小写
  • 43、title 把每个单词的第一个字母转化为大写，其余小写
  • 44、update 合并两个集合

一、字符串的内置方法

1、replace 替换

a = 'gyyx'
b = a.replace('x','0')   # 将x替换为0
# 结果：gyy0

2、divmod 除数余数结合

divmod(7, 2)
# 结果：(3, 1)
divmod(8, 2)
# 结果：(4, 0)

3.abs 返回绝对值

abs(-45) :  45
abs(100.12) :  100.12
abs(119L) :  119

4.eval 、exec执行字符串表达式

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

evel:

eval('500/10')
# 结果：50.0
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

exec:

>>>exec 'print "Hello World"'
Hello World
# 单行语句字符串
>>> exec "print 'runoob.com'"
runoob.com
 
#  多行语句字符串
>>> exec """for i in range(5):
...   print "iter time: %d" % i
... """
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
    

    
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
# 结果： 
60
33
34

5.isinstance 判断类型

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

6.pow计算幂次方

pow(2,3)  # 2的3次方
# 结果： 8
pow(3,2) # 3的2次方
# 结果 9

7.sum 求和

>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12

8.basestring

basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。

>>>isinstance("Hello world", str)
True
>>> isinstance("Hello world", basestring)
True

9.issubclass 判断是否是谁的子类

issubclass(class, classinfo)   # 判断class是否是classinfo的子类

10.super 超类

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

11.iter 生成迭代器

12.tuple 元组

Python 元组 tuple() 函数将列表转换为元组。

>>>tuple([1,2,3,4])
 
(1, 2, 3, 4)
 
>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
 
(1, 3)
 
>>> tuple((1,2,3,4))    #元组会返回元组自身
 
(1, 2, 3, 4)

13.bool 真假

返回值：真 假

14.filter 过滤

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

k = [1, 2, 3, 4, 5]
print(list(filter(lambda x: x != 3, k)))   # 后面可以加条件

过滤出列表中的所有奇数：

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
输出结果 ：

[1, 3, 5, 7, 9]

15.range 范围

顾头不顾尾

函数语法
range(start, stop[, step])
参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

16.type 判断类型

# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1          
>>> type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
>>> X
<class '__main__.X'>

17、ord、chr ASCLL码与字符相互转换

a-z：97-122

A-Z：65-90

0-9：48-57

print(" 的ASCII 码为", ord(c))
print(" 对应的字符为", chr(a))

18、frozenset 不可变集合

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>

19、long 长整型

long() 函数将数字或字符串转换为一个长整型

语法：class long(x, base=10)

• x -- 字符串或数字。
• base -- 可选，进制数，默认十进制。

>>>long()
0L
>>> long(1)
1L
>>> long('123')
123L
>>> 
>>>

20、reload 重载模块

reload() 用于重新载入之前载入的模块。

>>>import sys
>>> sys.getdefaultencoding()            # 当前默认编码
'ascii'
>>> reload(sys)                         # 使用 reload
<module 'sys' (built-in)>
>>> sys.setdefaultencoding('utf8')      # 设置编码
>>> sys.getdefaultencoding()
'utf8'
>>>

21、vars

vars() 函数返回对象object的属性和属性值的字典对象

vars() 函数语法：

vars([object])

>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
...     a = 1
... 
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}

22、classmethod装饰符

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化
# 结果 
func2
1
foo

23、getattr :取值 反射

getattr（p,'name'）：取值p对象中name属性

24、hasattr： 查找

p对象中是否存在name属性

25、setattr： 添加

为p对象中添加name属性jeff

26、delattr: 删除

删除p对象中name属性

27、map 映射

k = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x + 1, k)))  # map 基与for循环   每一个数+1

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

28、zip 拉链

• 取最短的拉

  k1 = [1, 2, 3, 4, 5]
  k2 = ['jeff', 'tank', 'jason']
  k3 = ['a', 'b', 'c']
  print(list(zip(k1, k2, k3)))
  # 结果：[(1, 'jeff', 'a'), (2, 'tank', 'b'), (3, 'jason', 'c')]
  
  

29、sorted 排序

k = ['jeff', 'tank', 'jason']
k.sort()   # 升序
k.sort(reverse=True)  # 降序
print(k)
print(sorted(k))  # 升序
print(sorted(k, reverse=True))  # 降序
k.reverse()              #逆序

30、reduce 额外的

from functools import reduce
k = [1, 2, 3]
print(reduce(lambda x, y: x+y, k, 10))   # 1+2+3+10   ,10是额外的
# 结果： 16

# 当初始值不存在的时候，按照下面的规律
# 第一次先获取两个元素 相加
# 之后每次获取一个与上一次相加的结果再相加

31、globals 全局变量

局部修改全局

# global 局部修改全局
x = 1
def func():
    global x  # 修改全局变量
    x = 2
func()
print(x)

32、nonlocal 局部变量

局部修改局部

# nonlocal 局部修改局部

def func():
    x = 1
    def func1():
        nonlocal x   # 声明修改局部
        x = 2
    func1()
    print(x)
func()

33、reverse 颠倒,逆序

reverse() 函数用于反向列表中元素。

#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc', 'xyz']

aList.reverse()
print "List : ", aList

list = [1,2,3,4,5]
print(list)   # [1, 2, 3, 4, 5]
list.reverse()
print(list)  # [5, 4, 3, 2, 1]

34、help 查看函数或模块的用途说明

>>>help('sys')             # 查看 sys 模块的帮助
……显示帮助信息……
 
>>>help('str')             # 查看 str 数据类型的帮助
……显示帮助信息……
 
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
 
>>>help(a.append)          # 显示list的append方法的帮助
……显示帮助信息……

35、hex 十进制转十六进制

cc = hex(666)
print(cc)
# 结果 ： 0x29a

36、oct 十进制转八进制

bb = oct(666)
print(bb)
# 结果 ：0o1232

37、bin 十进制转二进制

aa = bin(666)
print(aa)
# 结果 ：0b1010011010

38、int 其他进制转十进制

a = int('0b1010011010', 2)
b = int('0o1232', 8)
c = int('0x29a', 16)
print(a,b,c)
# 结果： 666 666 666

39、id 获取对象的内存地址

>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608

40、upper 把所有字符中字母转大写

str = "www.runoob.com"
print(str.upper())
# 结果：WWW.RUNOOB.COM

41、lower 把所有字符中字母转小写

str = "WWW.RUNOOB.COM"
print(str.lower())
# 结果：www.runoob.com

42、capitalize 把第一个字母转化为大写字母，其余小写

str = "WWW.RUNOOB.COM"
print(str.capitalize())
# 结果：Www.runoob.com

43、title 把每个单词的第一个字母转化为大写，其余小写

str = "WWW.RUNOOB.COM"
print(str.title()) 
# 结果：Www.Runoob.Com

44、update 合并两个集合

合并两个集合，重复元素只会出现一次：

实例 1
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

x.update(y)

print(x)
输出结果为：

{'banana', 'apple', 'google', 'runoob', 'cherry'}