名词介绍

1° 迭代器

迭代器是一个有next()方法的对象，不是通过索引来计数。当使用一个循环机制需要下一个项时，调用迭代器的next()方法，迭代完后引发一个StopIteration异常。迭代器只能向后移动、不能回到开始、再次迭代只能创建另一个新的迭代对象。reversed()将返回一个反序访问的迭代器。

1.abs()

abs()：返回数值的绝对值

abs(-1)
## Out[1]: 1

2.divmod()

divmod(a,b)：返回一个包含商和余数的元组(a // b, a % b)

divmod(13,2)  ## 实数运算
## Out[1]: (6, 1)

3.max()

根据ASCII码返回给定参数的最大值。（a-z：97-122，A-Z：65-90，0-9：48-57）

str_e = '1,2,3,4'
max(str_e)  ## 1.比较字符串的最大值
## Out[1]: '4'

list_e = [1,2,3,4]
max(list_e)  ## 2.比较列表元素的最大值
## Out[2]: 4

tup_e = ((1,2),(2,3),(3,4),(3,5))
max(tup_e)  ## 3.比较元组元素的最大值，先比较第一个元素，相同情况下比较第二个
## Out[3]: (3, 5)

dic_e = {1:1,2:1,3:1,4:1} 
max(dic_e)  ## 4.比较字典元素的最大值，比较键值，输出最大键值
## Out[4]: 4

4.min()

根据ASCII码返回给定参数的最小值。（a-z：97-122，A-Z：65-90，0-9：48-57）

str_e = '1,2,3,4'
min(str_e)  ## 1.比较字符串的最小值，逗号的ASCII码值为44
## Out[1]: ','

list_e = [1,2,3,4]
min(list_e)  ## 2.比较列表元素的最小值
## Out[2]: 1

tup_e = ((1,2),(2,3),(3,4),(3,5))
min(tup_e)  ## 3.比较元组元素的最小值，先比较第一个元素，相同情况下比较第二个
## Out[3]: (1, 2)

dic_e = {1:5,2:5,3:5,4:5} 
min(dic_e)  ## 4.比较字典元素的最小值，比较键值，输出最小键值
## Out[4]: 1

5.pow(x,y)

返回x的y次方。

（1）引用math模块

import math
math.pow(2,3)  ## 计算2的3次方
## Out[1]: 8.0

（2）内置函数

pow(x, y[, z])：计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z
注：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float

pow(2,3)  ## 计算2的3次方
## Out[2]: 8

pow(2,3,3)  ## 计算2的3次方后对3取余
## Out[3]: 2

6.reduce()

reduce(function, iterable[, initializer]):对参数序列中的元素通过函数进行累积。

• function – 函数，有两个参数
• iterable – 可迭代对象
• initializer – 可选，初始参数

from functools import reduce
def add(x, y):
    return x + y
sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
sum1
## Out[1]: 15

sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
sum2
## Out[2]: 15

sum3 = reduce(lambda x, y: x+y, [1,2,3,4,5],3)  # 初始值为3,3 + 1+2+3+4+5
sum3
## Out[2]: 18

7.round()

round( x [, n] )：返回浮点数x的四舍五入值，n为小数点位数。

round(22.2222,2)  ## 返回22.2222带2位小数点的四舍五入值
## Out[1]: 22.22

8.sum()

sum(iterable[, start])：对序列进行求和计算。

• iterable – 可迭代对象，如：列表、元组、集合。
• start – 指定相加的参数，如果没有设置这个值，默认为0。

sum([1,2,3,4,5])  ## 对列表进行求和
## Out[1]: 15

sum([1,2,3,4,5],6)  ## 对列表求和后再加6
## Out[2]: 21

9.len()

len(s)：返回对象（字符、列表、元组等）长度或项目个数。

str_e = 'ERROR'
len(str_e)
## Out[1]: 5

list_e = [1,2,3,4,5,6]
len(list_e)
## Out[2]: 6

10.filter()

filter(function, iterable)：用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。

## 返回奇数
def is_odd(n):
    return n % 2 == 1

tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
tmplist
## Out[1]: <filter at 0x204ca295488>

list(tmplist)
## Out[2]: [1, 3, 5, 7, 9]

11.map()

map(function, iterable, …)：根据提供的函数对指定序列做映射，返回迭代器。

map(lambda x:x**2,[1,2,3,4,5])  ## 计算列表中每个元素的平方，返回一个迭代器
## Out[1]: <map at 0x231e1bee108>

list(map(lambda x:x**2,[1,2,3,4,5]))
## Out[2]: [1, 4, 9, 16, 25]

12.iter()

iter(object[, sentinel])：用来生成迭代器。如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

list_e = [1,2,3,4,5]
for i in iter(list_e):
    print(i)
## Out[1]: 1 2 3 4 5

13.next()

next(iterable[, default])：返回迭代器的下一个项目。default可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

it = iter([1, 2, 3, 4, 5])
while True:
    try:
        x = next(it)  ## 获得下一个值
        print(x)
    except StopIteration:
        break  ## 遇到StopIteration就退出循环
## Out[1]: 1 2 3 4 5

14.input()

input([提示信息])：接受一个标准输入数据，返回为 string 类型。在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

name = input("请输入用户名：")
password = input("请输入密码：")
print("用户名："+name)
print("密码："+password)
## Out[1]: 请输入用户名：ERROR
##         请输入密码：error
##         用户名：ERROR
##         密码：error

15.open()

open()：用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

（1）打开模式

（2）file对象方法

创建text.txt文件

f = open('test.txt')
f.readlines()
## Out[1]: ['ERROR\n', 'error']

16.print()

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)：用于打印输出。

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

print("www","baidu","com",sep=".")  # 设置间隔符
## Out[1]: www.baidu.com

print("www","baidu","com",sep=".",end='..')  # 设置结束符
## Out[2]: www.baidu.com..

17.range()

range(start, stop[, step])：返回start到stop（不包含stop），步长为step的可迭代对象。

list(range(0,10,2))
## Out[1]: [0, 2, 4, 6, 8]

18.slice()

slice(start, stop[, step])：用在切片操作函数里的参数传递。

myslice = slice(1,6,1)    # 设置截取5个元素的切片
## myslice = slice(5)
arr = list(range(10))
arr[myslice]
## Out[1]: [1, 2, 3, 4, 5]

19.sorted()

sort 与 sorted 区别

当sorted()函数被调用时，它会提供一个新的有序（默认升序）的列表作为返回值。sort()的原始顺序会被修改。

sorted()

（1）对列表、元组、集合、字符串进行简单排序

num = [2,1,9,5]
sorted(num)  ## 1.对列表进行排序
## Out[1]: [1, 2, 5, 9]

num_tup = (2,1,9,5)
sorted(num_tup)  ## 2.对元组进行排序
## Out[2]: [1, 2, 5, 9]

num_set = {2,2,1,9,5}
sorted(num_set)  ## 3.对集合进行排序
## Out[3]: [1, 2, 5, 9]

num_str = 'I like to sort'
sorted(num_str)  ## 4.sorted()函数将一个str看作一个列表，并遍历其中的每一个元素（每一个字符），按ASCII码进行排序
## Out[4]: [' ', ' ', ' ', 'I', 'e', 'i', 'k', 'l', 'o', 'o', 'r', 's', 't', 't']

（2）参数reverse

reverse = True：降序
reverse = False：升序

num = [2,1,9,5]
sorted(num,reverse=True)  ## 对列表按降序进行排序
## Out[5]: [9, 5, 2, 1]

（3）参数key

key参数可以接收一个函数，该函数将作用于排序列表中的每个值，以确定结果的顺序。

num_str = ['I','like','to','sort']
sorted(num_str)  ## 对列表中的字符串进行排序，根据字符串的第一个字符的ASCII值进行排序
## Out[6]: ['I', 'like', 'sort', 'to']

sorted(num_str,key=len)  ## 根据字符串的长度按升序排序
## Out[7]: ['I', 'to', 'like', 'sort']

num_str1 = ['I','i','like','Like']
sorted(num_str1,key=str.lower)  ## 忽视大小写（转为小写）  对字符串进行排序
## Out[8]: ['I', 'i', 'like', 'Like']

words = ['cba','acb','bac']
sorted(words,key=lambda x:x[::-1])  ##根据字符串的最后一个字符进行排序
## Out[9]: ['cba', 'acb', 'bac']

sort()

sort是list类的一个方法，只能与list一起使用。

num = [2,1,9,5]
num.sort()
num
## Out[10]: [1, 2, 5, 9]

20.zip()

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

list1 = [1,2,3]
list2 = ['a','b','c']
list(zip(list1,list2))  ## 打包为元组
## Out[1]:[(1, 'a'), (2, 'b'), (3, 'c')]

list3 = [(1, 'a'), (2, 'b'), (3, 'c')]
list(zip(*list3))  ## 返回二维矩阵
## Out[2]:[(1, 2, 3), ('a', 'b', 'c')]

21.__ import __()

__ import __() 函数用于动态加载类和函数 。如果一个模块经常变化就可以使用 __ import __() 来动态载入。

a.py文件代码：

import os  
print ('在 a.py 文件中 %s' % id(os))

test.py文件代码：

import sys  
__import__('a')        # 导入 a.py 模块
## Out[1]:在 a.py 文件中 4394716136

22.list()

用于将元组转换为列表。

num_tup = (2,1,9,5)
list(num_tup)
## Out[1]:[2, 1, 9, 5]

23.int()

用于将一个字符串或数字转换为整型。

int('12')  ## 将字符串转换为整型
## Out[1]:12

int(12.222)  ## 将数字转换为整型
## Out[2]:12

24.bytearray()

返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。即bytearray()是可修改的二进制字节格式。

exp = bytearray("abcd",encoding="utf-8")
exp[0]  ## 返回“abcd”的“a"对应的ascii码
## Out[1]: 97

exp[0] = 99  ## 把字符串的第一个字节修改为99
exp
## Out[2]: bytearray(b'cbcd')

25.dict()

用于创建一个字典。

dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
## Out[1]: {'one': 1, 'two': 2, 'three': 3}

dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
## Out[2]: {'one': 1, 'two': 2, 'three': 3}

26.enumerate()

enumerate(sequence, [start=0]) ：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
## Out[1]: [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

list(enumerate(seasons, start=1))       # 下标从 1 开始
## Out[2]: [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

27.format()

format()是一种格式化字符串的函数 ，基本语法是通过 {} 和 : 来代替以前的 % 。
format()函数

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
## Out[1]: 网站名：菜鸟教程, 地址 www.runoob.com

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
## Out[2]: 网站名：菜鸟教程, 地址 www.runoob.com
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
## Out[3]: 网站名：菜鸟教程, 地址 www.runoob.com

28.float()

float(): 将整数和字符串转换成浮点数。

float(22)
## Out[1]: 55.0

29.repr()

repr(): 将对象转化为供解释器读取的形式。返回一个对象的 string 格式。

repr([1,2,3,4])
## Out[1]: '[1, 2, 3, 4]'

30.reversed()

reverse() : 反向列表中元素。

exp = [1,2,3,4]
exp.reverse()
exp
## Out[1]: [4, 3, 2, 1]

31.frozenset()

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

frozenset(range(10)) 
## Out[1]: frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

32.set()

set(): 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
set()函数

set([1,1,2,3,4,5])
## Out[1]: {1, 2, 3, 4, 5}

33.str()

str(): 返回一个对象的string格式。

str([1,1,2,3,4,5])
## Out[1]: '[1, 1, 2, 3, 4, 5]'

34.tuple()

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

tuple([1,2,3,4])
## Out[1]: (1, 2, 3, 4)

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

35.all()

all(iterable)：判断给定的可迭代参数 iterable （元组或列表）中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
注：元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。

all([0,1,2,3])  ## 1.存在元素0
## Out[1]: False

all(['','a','b','c'])  ## 2.存在空元素
## Out[2]: False

all([None,'a','b','c'])  ## 3.存在元素None
## Out[3]: False

all([False,'a','b','c'])  ## 4.存在元素False
## Out[4]: False

all(['a','b','c'])  ## 5.不存在以上元素
## Out[5]: True

all([])  ## 6.空列表
## Out[6]: True

all(())  ## 7.空元组
## Out[7]: True

36.any()

any()：判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

any(["",0,False,None])  ## 1.当元素全为空、0、False、None
## Out[1]: False

any(["",0,False,None,1])  ## 2.当存在一个非空、0、False、None时
## Out[2]: True

any([])  ## 3.空列表
## Out[3]: False

any(())  ## 4.空元组
## Out[4]: Fasle

37.bool()

bool()：将给定参数转换为布尔类型，如果没有参数，返回 False。0为False，非0非空为true。

bool(0)
## Out[1]: Fasle

bool()
## Out[2]: Fasle

bool(1)
## Out[3]: True

38.calllable()

calllable(): 检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。Python3.0后不可再用，需要使用表达式hasattr(func,_ call _)代替。

callable(0)
## Out[1]: Fasle

def add(a, b):
    return a + b
callable(add)
## Out[2]: True

39.hasattr()

hasattr() ：判断对象是否包含对应的属性。

class Coordinate:
    x = 10
    y = -5
    z = 0

point1 = Coordinate() 
hasattr(point1, 'x')
## Out[1]: True

hasattr(point1, 'y')
## Out[2]: True

hasattr(point1, 'no')  ## 没有该属性
## Out[3]: Fasle

40.isinstance()

isinstance(object, classinfo)：判断一个对象是否是一个已知的类型，类似 type()。如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
classinfo的基本类型有：int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

a = 2
isinstance(a,int)
## Out[1]: True

isinstance (a,(str,int,list))  ## 是元组中的一个返回 True
## Out[2]: True

type和isinstance的区别

type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。

class A:
    pass

## B继承A
class B(A):
    pass

isinstance(A(), A)
## Out[3]: True
type(A()) == A
## Out[4]: True

isinstance(B(), A) 
## Out[5]: True
type(B()) == A
## Out[6]: False

41.issubclass()

issubclass(class,classinfo): 判断参数 class 是否是类型参数 classinfo 的子类。如果 class 是 classinfo 的子类返回 True，否则返回 False。

class A:
    pass
class B(A):
    pass

issubclass(B,A)
## Out[1]: True

42.dir()

dir() ：不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

43.globals()

globals()：以字典类型返回当前位置的全部全局变量。

44.help()

help()：用于查看函数或模块用途的详细说明。

help(str)

45.id()

id()：用于获取对象的内存地址。

46.type()

type(name, bases, dict)：（类的名称，基类的元组，字典类内定义的命名空间变量）一个参数返回对象类型, 三个参数，返回新的类型对象。

type(1)
## Out[1]: int

class X(object):
    a = 1
type('X', (object,), dict(a=1))  ## 产生一个新的类型 X
## Out[2]: __main__.X

47.bin()

bin()：返回一个整数 int 或者长整数 long int 的二进制表示。

bin(8)
## Out[1]: '0b1000'

48.oct()

oct()：将一个整数转换成 8 进制字符串。

oct(8)
## Out[1]: '0o10'

49.hex()

hex()：将10进制整数转换成16进制，以字符串形式表示。

hex(18)
## Out[1]: ''0x12''

50.hash()

hash()：获取取一个对象（字符串或者数值等）的哈希值。

hash(1)
## Out[1]: 1

51.chr()

chr()：用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。返回值是当前整数对应的 ASCII 字符。

chr(0x61)   ## 十六进制，十进制为97
## Out[1]: a

52.ord()

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

ord('a')
## Out[1]: 97