python内置方法

一、字符串的内置方法

一、字符串的内置方法

split 切割

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );       # 以空格为分隔符，包含 \n
print str.split(\' \', 1 ); # 以空格为分隔符，分隔成两个
# 结果：
[\'Line1-abcdef\', \'Line2-abc\', \'Line4-abcd\']
[\'Line1-abcdef\', \'\nLine2-abc \nLine4-abcd\']

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 判断是否是谁的子类

class Father:
    pass

class Sub(Father):
    pass

class Foo:
    pass

print(issubclass(Sub, Father))  # True   判断Sub是否为Father的子类
print(issubclass(Foo, Father))  # False

isinstance判断一个对象是否是另一个类的实例化

class Foo:
    pass
class Boo:
    pass

foo_obj = Foo()
boo_obj = Boo()

print(isinstance(foo_obj, Foo))  # True
print(isinstance(boo_obj, Foo))  # False

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、hasattr：查找-反射

foo_obj对象中是否存在x属性

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y
foo_obj = Foo(10, 20)
# 通过字符串x 判断对象中是否有 x属性
print(hasattr(foo_obj, \'x\'))  # True
print(hasattr(foo_obj, \'z\'))  # False

24、getattr :取值反射

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

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y

foo_obj = Foo(10, 20)

res = getattr(foo_obj, \'x\')
print(res)  # 10

25、setattr：添加-反射

为foo_obj对象中添加z属性30

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y

foo_obj = Foo(10, 20)


setattr(foo_obj, \'z\', 30)  # 为对象添加z属性值为30
print(hasattr(foo_obj, \'z\'))  # True

26、delattr: 删除-反射

删除foo_obj对象中x属性

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y

foo_obj = Foo(10, 20)

delattr(foo_obj, \'x\')  # 删除对象中x属性
print(hasattr(foo_obj, \'x\'))  # False

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\'}


a = {\'a\':1,\'b\':2}
b = {\'c\':3,\'d\':4}
a.update(b)
print(a) # {\'a\': 1, \'b\': 2, \'c\': 3, \'d\': 4}  
如果键出现重复，则覆盖：
a = {\'a\':1,\'b\':2}
b = {\'b\':3,\'d\':4}
a.update(b)
print(a) # {\'a\': 1, \'b\': 3, \'d\': 4}

45、字符串join，连接字符串

str0 = \'123\'
str1 = str0.join(\'a\')  # a
str2 = str0.join(\'ab\')  # a123b
str3 = str0.join(\'abc\')  # a123b123c
python中连接字符串join的效率>用+的效率

str1 = \'\'.join([\'123\',\'456\'])
print(str1) # 123456

46、insert指定添加

name=["张三","李四","果冻"]
name.insert(1,"奥丁")  #insert 在索引前面插入数据
# [\'张三\', \'奥丁\', \'李四\', \'果冻\']

47、append 最后添加

name=["张三","李四","果冻"]
name.append("辜友银") #append 在最后增加元素
# [\'张三\', \'李四\', \'果冻\', \'辜友银\']

48、remove 删除

name=["张三","李四","果冻"]
name.remove("果冻")     # 删除前面第一次出现的数据“果冻”,remove删除指定数据
# print(name) # [\'张三\', \'李四\']

name=["张三","李四","果冻",\'果冻\']
name.remove("果冻")
print(name) # [\'张三\', \'李四\', \'果冻\']

49、pop默认删除最后一个数据

name=["张三","李四","果冻"]
name.pop()              # pop,默认情况删除最后一个数据
name.pop(0)             #指定删除对应列数据
name.clear()            #清空列表

50、index拿索引

name=["张三","李四","果冻",\'果冻\']
print(name.index(\'果冻\'))  2 # 只拿第一个索引

51、dir 获取当前范围参数信息

from conf import config

print(dir(config))

[\'MODE\', \'PLUGINS_DICT\', \'USER\', \'__builtins__\', \'__cached__\', \'__doc__\', \'__file__\', \'__loader__\', \'__name__\', \'__package__\', \'__spec__\']

52、intersection 获取集合的交集

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。


a = {1,2,3}
b = {2,3,4}

c = a.intersection(b)
print(c) # {2, 3}