Python内置函数

内置函数 

作用域相关

1. globals()  

# 返回一个字典，包括所有的全局变量与它的值所组成的键值对

2. locals()

 # 返回一个字典，包括当前作用域内的局部变量与它的值所组成的键值对

 

迭代器和生成器相关

 1. range(start,end,step)

# 返回一个迭代器。start：起始值，可选参数，默认值为0 ，stop：终止值，必选参数， step：步长，可选参数，默认值为1，值为0时抛出ValueError异常

2. next()

# 从迭代器返回下一个值。 如果给定了默认值和迭代器已经耗尽，则返回StopIteration。

3. iter()

# 根据传入的参数创建一个新的可迭代对象

 

输入输出

1. input()

# 读取用户输入的值

2. print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

# 默认情况下将值打印到流或sys.stdout。 可选关键字参数： file：一个类似文件的对象， 默认为当前的sys.stdout。 sep：在值之间插入字符串，默认为空格。 end：在最后一个值之后附加的字符串，默认换行符。 flush：是否强制冲洗。

 

内存相关

1. id()

# 返回一下两个对象的身份标识

2. hash()

# 返回给定对象的hash值

 

文件操作

1. open()

# 使用指定的模式和编码打开文件，返回文件句柄。

 

导入模块

1. import

# 导入模块

 

帮助

1. help()

# 返回帮助信息

2. dir()

# 查看所有的内置函数和查看某对象的属性和方法。

 

数学运算

1. abs()

# 求数值的绝对值

>>> abs(10)
10
>>> abs(-18)
18

2. divmod()

# 接受两个数，返回一个元组包含两个数值的商和余数。

>>> divmod(10,3)
(3, 1)
>>> divmod(10,5)
(2, 0)

3. max()

# 返回可迭代对象中或参数中的最大值。key是一个函数名，判断的结果根据函数的返回值来确定。

>>> max(5,8,12)
12

>>> max([6,5,3,48])
48

>>> max('589')
'9'

>>> max({'k1':'v1','k2':'v2'})  # 求字典的key中对应的ASCII最大的值
'k2'

>>> dic = {'k1':10,'k2':400,'k3':30}
>>> max(dic.values())  # 求字典的value中最大的值
400

>>> dic = {'k1':10,'k2':400,'k3':30}
>>> max(dic, key=lambda n:dic[n])   # 找到最大的value对应的key
'k2'

4. min()

# 返回可迭代对象中或参数中的最小值。key是一个函数名，判断的结果根据函数的返回值来确定。

>>> min(1,2,3,4)
1
>>> min(-1,0,5,key=abs)
0

5. pow()

# 返回两个数值中的幂运算，如果传递三个值，则是按照第三个值对前两个值的幂运算结果取模。

>>> pow(3,2)
9
>>> pow(3,2,4)  # 等同于3^2%4
1
>>>

6. round()

# 对浮点数进行四舍五入。

>>> round(3.6)
4
>>> round(3.4)
3
>>> round(3.1415926,3)
3.142

7. sum()

# 对元素类型是数值的可迭代对象中的每个元素求和。或对两个参数求和。 

>>> sum([2,8])
10
>>> sum([2,8,5],10)
25

类型转换

1. bool()

#  将指定的值转换为布尔值

>>> bool(0)
False
>>> bool(8)
True
>>> bool('')
False
>>> bool(' ')
True

2. int()

# 将指定的值转换为整型

>>> int(3.14)
3
>>> int(3.6)
3

3. float()

# 将指定的值转换为浮点型

>>> float()
0.0
>>> float(8)
8.0
>>> float('8')
8.0

4. complex()

# 将指定的值转换为复数

>>> complex()
0j
>>> complex('1+2j')
(1+2j)
>>> complex(1,2)
(1+2j)

5. str()

# 将指定的值转换为字符串

>>> str()
''
>>> str(10)
'10'
>>> str(10.8)
'10.8'
>>> str(None)
'None'

6. list()

# 将指定的值转换为列表

>>> list()
[]
>>> list('abc')
['a', 'b', 'c']
>>> list((1,2,3))  # 将元组转换为列表
[1, 2, 3]

7. tuple()

# # 将指定的值转换为元组

>>> tuple()
()
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple([1,2,3])  # 将列表转换为元组
(1, 2, 3)

8. dict()

# 将指定的值转换为整型

>>> dict(name = 'wu', age = 21)
{'name': 'wu', 'age': 21}
>>> dict((('name','wu'),('age',21)))
{'name': 'wu', 'age': 21}
>>> dict(zip(['a', 'b'],[1, 2]))
{'a': 1, 'b': 2}

9. set()

# 将指定的值转换为集合

>>> set()
set()
>>> li = [1,5,5,6,8]
>>> set(li)
{8, 1, 5, 6}

 

进制转换

1. bin()

# 将十进制转换为二进制

>>> res = bin(8)
>>> print(res)
0b1000

2. oct()

>>> res = oct(9)
>>> print(res)
0o11

# 将十进制转换为八进制

3. hex()

>>> res = hex(12)
>>> print(res)
0xc

# 将十进制转换为十六进制

 

sorted() 

对List、Dict进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

--------------------------------sorted---------------------------------------
sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.


-----------------------------------------------------------------------------
参数说明：
iterable：是可迭代类型;
key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，有默认值。
返回值：有序列表

示例：

li = [6, 3, -8, 0, 9]
print(sorted(li))
print(sorted(li, key=abs))  # 按每个元素的绝对值排序

li = [6, 3, -8, 0, 9]
print(sorted(li))
print(sorted(li, reverse=True))  # 按从大到小排序

 

zip()

zip()函数接收两个可迭代对象，并将两个可迭代对象的每个元素一一对应，组成一个元组，最后返回一个包含每个元组的列表

li = [1, 2, 3]
li2 = ['a', 'b', 'c', 'd']
dic = {'k1': 'v1', 'k2': 'v2'}

print(list(zip(li, li2)))
print(list(zip(li, dic)))

 

filter()

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

示例：

1. 过滤掉列表中的偶数

def is_odd(x):
    return x % 2 == 1


li = [1, 2, 3, 4, 5, 6, 7]

print(list(filter(is_odd, li)))

# [1, 3, 5, 7]

 2. 过滤掉列表中为None，或者空字符串，或者内容为空格的字符串。

def non_empty(s):
    return s and len(s.strip()) > 0


li = ['python', None, '', 'filter', '   ']
print(list(filter(non_empty, li)))

# ['python', 'filter']

 3. 过滤1-100中平方根为整数的数。

import math


def sqrt_is_int(n):
    return math.sqrt(n) % 1 == 0

print(list(filter(sqrt_is_int, range(1, 101))))

# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 map()

map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

示例：

1. 使用map函数计算每个元素的平方

li = [3, 5, 7, 9]


def func(n):
    return n ** 2


print(list(map(func, li)))

 

2. 使用map函数为列表中的每个元素在结尾添加'_map'

li = ['Python', 'VBScript', 'Java', 'JavaScript']


def add_map(s):
    return s + '_map'


print(list(map(add_map, li)))

 

小练习：

如下 列表中每个字典的name对应股票的名字，shares对应股票数量，price对应股票的单价

info = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'YHOO', 'shares': 445, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65},
]

1. 使用map计算购买每种股票的价格(shares*price)

def my_sum(d):
    s = d['shares'] * d['price']
    dic = {}
    dic[d['name']] = s
    return dic


print(list(map(my_sum, info)))

 

2. 求出单价大于100的股票的名字(使用filter和map)

def func(d):
    return d['price'] > 100


filter_list = list(filter(func, info))


def filter_name(d):
    return d['name']


print(list(map(filter_name, filter_list)))