abs()
3 函数返回x的绝对值，如果参数是一个复数，则返回它的大小
5 print(abs(-40))
6 print(abs(100.10))
#40
#100.10 dict()
函数用于创建一个字典
a=dict()#创建空字典
b=dict(a='a',b='b',t='t')#传入关键字
c=dict(zip(['one','two','three'],[1,2,3]))#映射函数方式来构造字典
d=dict([('one',1),('two',2),('three',3)])#可迭代对象方式来构造字典
print(a)
print(b)
print(c)
print(d)
#{}
#{'a': 'a', 'b': 'b', 't': 't'}
#{'one': 1, 'two': 2, 'three': 3}
#{'one': 1, 'two': 2, 'three': 3} help（）
函数用于查看函数或模块用途的详细说明
help('sys')#查看sys模块的帮助
help('str')#查看str数据类型的帮助
a=[1,2,3]
help(a)#查看列表list帮助信息
help(a.append)#显示list的append方法的帮助 min()
返回给定参数的最小值，参数可以为序列
print(min(80,100,1000))
print(min(-20,100,400))
print(min(-80,-20,-10))
print(min(0,100,-400)) setattr()
setattr函数对应getattr,用于设置属性值，该属性必须存在
class A(object):
bar=1
a=A()
getattr(a,'bar')#获取属性bar值
setattr(a,'bar',5)#设置属性bar值 all()
2
3 函数用于判断给定的可迭代参数iterable中的所有元素是否为True,如果是返回True,否则返回False,元素除了0，空，False外都算True
4
5 函数等价于
6
7 def all(iterable):
8 for element in iterable:
9 if not element:
10 return False
11 return True
12
参数是元组或列表
13 print(all(['a','b','c','d']))#True 元素都不为空或0
14 print(all(['a','b','','d']))#False 存在一个为空的元素
15 print(all([0,1,2,3]))#False 存在一个为0的元素
16 print(all(('a','b','c','d')))#True 元素都不为空或0
17 print(all(('a','b','','d')))#False 存在一个为空的元素
18 print(all((0,1,2,3)))#False 存在一个为0的元素
19 print(all([]))#True 空列表
20 print(all(()))#True 空元组 dir()
函数不带参数时，返回当前范围内的变量、方法和定义的类型列表
带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),
该方法将被调用。如果参数不包含__dir__(),该方法将最大限度的收集参数信息
print(dir())#获得当前模块的属性列表
print(dir([]))#查看列表的方法 hex()
函数用于将10进制整数转换成16进制，以字符串形式表示
print(hex(255))#0xff
print(hex(-42))#-0x2a next()
返回迭代器的下一个项目
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break slice()
函数实现切片对象，主要用在切片操作函数里的参数传递
myslice=slice(5)#设置截取5个元素的切片
print(myslice) #slice(None, 5, None) arr=range(10)
print(arr) #range(0, 10)
print(arr[myslice]) #截取5个元素 range(0, 5) any()
函数用于判断给定的可迭代参数iterable是否全部为False,返回False,如果有一个为True,则返回True
元素除了是0，空，False外都算True
函数等价于
def any(iterable):
for element in iterable:
if element:
return True
return False
13 print(any(['a','b','c','d']))#True 元素都不为空或0
14 print(any(['a','b','','d']))#True 存在一个为空的元素 print(any([0,'',False]))#False 元素全为0 16 print(any(('a','b','c','d')))#True 元素都不为空或0
17 print(any(('a','b','','d')))#True 存在一个为空的元素
18 print(any((0,'',False)))#False 存在一个为0的元素
19 print(any([]))#False 空列表
20 print(any(()))#False 空元组 divmod（）
#函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组（a//b,a%b）
a=divmod(10,3)
print(a)
#(3,1)
b=divmod(8,2)
print(b)
#(4,0) id()
函数用于获取对象的内存地址
print(id('hello'))#34772336
print(id('123'))#34772504
print(id(123))#1414513536 sorted()
sorded()函数对所有可迭代对象进行排序操作
sort和sorted区别
sort是应用在list上的方法，sorted可以对所有可迭代对象进行排序操作
list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作
print(sorted([1,23,4,5,6]))#[1, 4, 5, 6, 23]
a=[11,42,33,4,5,6]
a.sort()
print(a)#[4, 5, 6, 11, 33, 42] sort没有返回值，直接对原来的列表进行修改
sorted函数可以接受任何的可迭代对象，如
a=sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
print(a)#[1, 2, 3, 4, 5] a=[1,23,4,5,55]
b=sorted(a,reverse=True)
print(b)#[55, 23, 5, 4, 1] ascii()
函数类似于repr()函数，返回一个表示对象的字符串，但是对于字符串中的非ASCII字符则返回通过repr()函数使用\x，\u或\U编码的字符，生成字符串类似python2版本中repr（）函数的返回值
print(ascii('hello'))#'hello' enumerate()
函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
a=[1,23,4,5,65,88]
b=enumerate(a,1)
for i in b:
print(i)
#(1, 1)
#(2, 23)
#(3, 4)
#(4, 5)
#(5, 65)
#(6, 88)
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, seq[i]) #0 one
#1 two
#2 three
input()
函数接受一个标准输入数据，返回为string类型
python3里input()默认接受到的是str类型
a=input('input:')
print(type(a))
#input:123
#<class 'str'> oct()
print(oct(10))
print(oct(20))
print(oct(15))
#0o12
#0o24
#0o17 staticmethod()
返回函数的静态方法,和类没有绑定关系，就是一个普通的函数
class C(object):
@staticmethod
def f():
print('runoob')
C.f()#静态方法无需实例化
cobj=C()
cobj.f()#也可以实例化后调用 bin()
bin()返回一个整数int的二进制表示
print(bin(10))
print(bin(20))
#0b1010
#0b10100 eval()
函数用来执行一个字符串表达式，并返回表达式的值
x=5
a=eval('3*x')
print(a)#15 int()
用于将一个字符串或数字转换为整型
print(int())#不传入参数时，得到结果0
print(int(10))#10
print(int(2.9))#2
print(int('12',16))#18 如果是带参数base的话，12要以字符串的形式进行输入，12为16进制
print(int('10',8))#8 open()
str()
str()函数将对象转化为适于人阅读的形式
a=str(1)
print(type(a))
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
print(type(dict))
s_dict=str(dict)
print(type(s_dict)) bool()
bool函数用于将给定参数转换为布尔类型，如果没有参数，返回False
bool是int的子类
print(bool())#False
print(bool(0))#False
print(bool(1))#True
print(bool(2))#True
print(issubclass(bool, int))#bool是int的子类 exec()
描述
exec执行存储在字符串或文件中的python语句，相比于eval,exec可以执行更复杂的python代码
语法
exec(object[,globals[,locals]])
参数：
object:必选参数，表示需要被指定的python代码，他必须是字符串或code对象，如果object是一个字符串，该字符串会先被解析为一组python语句，然后再执行,如果object是一个code对象，
那么他只是被简单地执行
globals:可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象
locals:可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象，如果该参数被忽略，那么它将会取与globals相同的值
返回值
exec返回值永远为None
实例
print(exec('print("Hello World")'))
# 单行语句字符串
print(exec("print ('runoob.com')"))
# 多行语句字符串
print(exec("""for i in range(5):
print ("iter time: %d" % i)
"""))
"""
Hello World
None
runoob.com
None
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
None
"""
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() isinstance()
描述
isinstance()函数来判断一个对象是否是一个已知的类型，类似type()
isintance()与type（）的区别：
type不会认为子类是一种父类类型，不考虑继承关系
isinstance（）会认为子类是一种父类关系，考虑继承关系
如果要判断两个类型是否相同推荐使用isintance()
语法
以下是isinstance（）方法的语法
isinstance（object，classinfo）
参数
object--实例对象
classinfo--可以是直接或间接类名、基本类型或者由它们组成的元组
返回值
如果对象的类型与参数二的类型(classinfo)相同则返回True,否则返回False
实例
a = 2
print(isinstance (a,int))
print(isinstance (a,str))
print(isinstance (a,(str,int,list))) # 是元组中的一个返回 True
class A:
pass
class B(A):
pass
print(isinstance(A(), A)) # returns True
print(type(A()) == A) # returns True
print(isinstance(B(), A)) # returns True
print(type(B()) == A) # returns False
"""
True
True
True
False
""" ord()
描述
ord（）函数是chr（）函数（对于8位的ASCLL字符串）或unichr（）函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应ASCLL数值，或者Unicode数值，如果所给的Unicode字符超出了你的python定义范围，则会引发一个typeerror的异常
语法
以下是ord（）方法的语法
ord(c)
参数
c--字符
返回值
返回值是对应的十进制整数
实例
print(ord('a'))
print(ord('b'))
print(ord('c'))
"""
97
98
99
""" sum()
描述
sum()方法对系列进行求和运算
语法
以下是sum（）方法的语法
sum(iterable[,start])
参数
iterable--可迭代对象，如列表、元组、集合
start--指定相加的参数，如果没有设置这个值，默认为0
返回值
返回计算结果
实例
print(sum([0,1,2]))
print(sum((2, 3, 4), 1)) # 元组计算总和后再加 1
print(sum([0,1,2,3,4], 2)) # 列表计算总和后再加 2 bytearray()
描述
bytearray()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<=x<256
语法
bytearray()方法语法
class bytearray([source[,encoding[,error]]])
参数
如果source为整数，则返回一个长度为source的初始化数组
如果source为字符串，则按照指定的encoding将字符串转换为字节序列
如果source为可迭代类型，则元素必须为[0,255]中的整数
如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray
如果没有输入任何参数，默认就是初始化数组为的元素
返回值
返回新字节数组
实例
print(bytearray())
# bytearray(b'')
print(bytearray([1,2,3]))
# bytearray(b'\x01\x02\x03')
print(bytearray('runoob', 'utf-8'))
# bytearray(b'runoob') filter()
描述
filter（）函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
该接受两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或Flase,最后将返回True的元素放到新列表中
number_list=range(-5,5)
less_than_zero=filter(lambda x:x<0,number_list)
print(list(less_than_zero))#[-5, -4, -3, -2, -1] filter类似于for循环，但它是一个内置函数，并且更快
语法
filter(function,iterable)
参数
function--判断函数
iterable--可迭代对象
返回值
返回列表
实例
#过滤出列表中所有的奇数
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))#[1, 3, 5, 7, 9] #过滤出1-100中平方根是整数的数
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(list(newlist))#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] issubclass()
描述
issubclass()方法用于判断参数class是否是类型参数classinfo的子类
语法
issubclass(class,classinfo)
参数
class--类
classinfo--类
返回值
如果class是classinfo的子类返回True,否则返回False
实例
class A:
pass
class B(A):
pass
print(issubclass(B, A)) # 返回 True pow()
描述
pow（）方法返回xy（x的y次方） 的值。
语法
以下是math模块pow()方法的语法
import math
math.pow(x,y)
内置的pow()方法
pow(x,y[,z])
函数是计算x的y次方，如果z在存在，则在对结果进行取模，其结果等效于pow(x,y)%z
注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float
参数
x--数值表达式
y--数值表达式
z--数值表达式
返回值
返回 xy（x的y次方） 的值。
实例
import math # 导入 math 模块
print ("math.pow(100, 2) : ", math.pow(100, 2))
# 使用内置，查看输出结果区别
print ("pow(100, 2) : ", pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))
"""
math.pow(100, 2) : 10000.0
pow(100, 2) : 10000
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0
""" super()
描述
super()函数适用于调用父类（超类）的一个方法
super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题
MRO就是类的方法解析顺序表，其实也就是继承父类方法时的顺序表
语法
super(type[,object-or-type])
参数
type--类
object-or-type--类，一般是self
python3.x和python2.x的一个区别是：python3可以直接使用super().xxx代替super(class,self).xxx
Python3.x 实例：
class A:
pass
class B(A):
def add(self, x):
super().add(x)
Python2.x 实例：
class A(object): # Python2.x 记得继承 object
pass
class B(A):
def add(self, x):
super(B, self).add(x)
返回值
无
实例
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print('Parent')
def bar(self, message):
print("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
super(FooChild, self).__init__()
print('Child')
def bar(self, message):
super(FooChild, self).bar(message)
print('Child bar fuction')
print(self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
"""
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
""" bytes()
描述
bytes函数返回一个新的bytes对象，该对象是一个0<=x<256区间内的整数不可变序列。它是bytearray的不可变版本
语法
class bytes([source[,encoding[,errors]]])
参数
如果source为整数，则返回一个长度为source的初始化数组
如果source为字符串，则按照指定的encoding将字符串转换为字节序列
如果source为可迭代类型，则元素必须为[0,255]中的整数
如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray
如果没有输入任何参数，默认就是初始化数组为0个元素
返回值
返回一个新的bytes对象
实例
a = bytes([1,2,3,4])
print(a)
#b'\x01\x02\x03\x04'
print(type(a))
#<class 'bytes'>
a = bytes('hello','ascii')
print(a)
#b'hello'
print(type(a))
#<class 'bytes'> float（）
描述
float（）函数用于将整数和字符串转换成浮点数
语法
class float([x])
参数
x--整数或字符串
返回值
返回浮点数
实例
print(float(1))
print(float(112))
print(float(-123.6))
print(float('123')) # 字符串
"""
1.0
112.0
-123.6
123.0
""" iter()
描述
iter（）函数用来生成迭代器,把一个可迭代对象变成迭代器对象
语法
iter(object[,sentinel])
参数
object--支持迭代的集合对象
sentinel--如果传递了第二个参数，则参数object必须是一个可调用的对象（如，函数），此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object
返回值
迭代器对象
实例
lst = [1, 2, 3]
for i in iter(lst):
print(i)
"""
1
2
3
""" print()
描述
print()方法用于打印输出，最常见的一个函数
print在python3.x是一个函数，但在python2.x版本不是一个函数，只是一个关键字
语法
print(*object,sep=' ',end='\n',file=sys.stdout)
参数
object--复数，表示可以一次输出多个对象。输出多个对象时，需要用，分隔
sep--用来间隔多个对象，默认值是一个空格
end--用来设定以什么结尾，默认值是换行符\n,我们可以换成其他字符串
file--要写入的文件对象
返回值
无
实例
print(1)
print("Hello World")
a = 1
b = 'runoob'
print(a, b)
print("aaa""bbb")
print("aaa", "bbb")
print("www", "runoob", "com", sep=".") # 设置间隔符
"""
1
Hello World
1 runoob
aaabbb
aaa bbb
www.runoob.com
""" tuple()
描述
tuple函数将列表转换为元组
语法
tuple(seq)
参数
seq--要转换为元组的序列
返回值
返回元祖
实例
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
print(tuple1)#('Google', 'Taobao', 'Runoob', 'Baidu') callable()
描述
callable()函数用于检查一个对象是否是可调用的，如果返回True,object仍然可能调用失败，如果是False,调用对象object绝对不会成功
对于函数、方法、lambda函数类，以及实现了__call__方法的类实例，它都返回True
语法
callable(object)
参数
object--对象
返回值
可调用返回True,否则返回False
实例
print(callable(0))#False
print(callable("runoob"))#False
def add(a, b):
return a + b
print(callable(add)) # 函数返回 True
class A: # 类
def method(self):
return 0
print(callable(A)) # 类返回 True
a = A()
print(callable(a)) # 没有实现 __call__, 返回 False
class B:
def __call__(self):
return 0
print(callable(B))#返回True
b = B()
print(callable(b)) # 实现 __call__, 返回 True format（）
python2.6开始，新增了一种格式化字符串的函数str.format(),它增强了字符串格式化的功能
基本语法是通过{}和：来代替以前的%
format函数可以接受不限个参数，位置可以不按顺序
实例
print("{} {}".format("hello", "world")) # 不设置指定位置，按默认顺序
print("{0} {1}".format("hello", "world")) # 设置指定位置
print("{1} {0} {1}".format("hello", "world")) # 设置指定位置
"""
hello world
hello world
world hello world
"""
设置参数
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
"""
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
"""
也可以向str.format()传入对象
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
"""
value 为: 6
"""
数字格式化
下表展示了str.format()格式化数字的多种方法
print("{:.2f}".format(3.1415926))#3.14 | 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| {:+.2f} | 带符号保留小数点后两位 | ||
| -1 | |||
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 数字补零 (填充左边, 宽度为2) | |
| {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) | |
| 10 | 10xx | ||
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 指数记法 | |
| 13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
| {:<10d} | 左对齐 (宽度为10) | ||
| {:^10d} | 13 | 中间对齐 (宽度为10) | |
| 11 | | | 进制 |
^,<,>分别是居中，左对齐，右对齐，后面带宽度，：号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
+表示在正数前显示+，负数前显示-； （空格）表示在正数前加空格
b、d、o、x分别是二进制、十进制、八进制、十六进制
此外我们可以使用大括号{}来转义大括号如下实例
print ("{} 对应的位置是 {{0}}".format("runoob"))#runoob 对应的位置是 {0} len()
描述
python len()方法返回对象（字符、列表、元组）长度或项目个数
语法
len(s)
参数
s--对象
返回值
返回对象长度
实例
str = "runoob"
print(len(str))#6 字符串长度
l = [1,2,3,4,5]
print(len(l))#5 列表元素个数 property()
描述
property（）函数的作用是在新式类中返回属性值
语法
class property([fget[,fset[,fdel[,doc]]]])
参数
fget--获取属性值的函数
fset--设置属性值的函数
fdel--删除属性值函数
doc--属性描述信息
返回值
返回新式类属性
实例
定义一个可控属性值x
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.")
如果c是C的实例化，c.x将触发getter,c.x=value将触发setter,del c.x触发deleter,如果给定doc参数，其将成为这个属性值的docstring，否则property函数就会复制fget函数的docstring(如果有的话)
将property函数用作装饰器可以很方便的创建只读属性：
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将voltage()方法转化成同名只读属性的getter方法
property的getter,setter和deleter方法同样可以用作装饰器
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
这个代码和第一个例子完全相同，但要注意这些额外函数的名字和property下的一样，例如这里的x type()
描述
type（）函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象
isintance（）与type()的区别
type()不会认为子类是一种父类类型，不考虑继承关系
isintance（）会认为子类是一种父类类型，考虑继承关系
如果要判断两个类型是否相同推荐使用isintance（）
语法
class type(name,bases,dict)
参数
name--类的名称
bases--基类的元组
dict--字典，类内定义的命名空间变量
返回值
一个参数返回对象类型，三个参数，返回新的类型对象
实例
# 一个参数实例
print(type(1))#<class 'int'>
print(type('runoob'))#<class 'str'>
print(type([2]))#<class 'list'>
print(type({0: 'zero'}))#<class 'dict'>
x = 1
print(type(x) == int)#True 判断类型是否相等
# 三个参数
class X(object):
a = 1
X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X
print(X)#<class '__main__.X'>
type和isintance的区别
class A:
pass
class B(A):
pass
print(isinstance(A(), A)) # returns True
print(type(A()) == A) # returns True
print(isinstance(B(), A)) # returns True
print(type(B()) == A) # returns False chr()
描述
chr()用一个范围在range(256)内的（就是0-255）整数做参数，返回一个对应的字符
语法
chr(i)
参数
i--可以是10进制也可以是16进制的形式的数字
返回值
返回值是当前整数对应的ascii字符
实例
print(chr(0x30), chr(0x31), chr(0x61)) # 十六进制
print(chr(48), chr(49), chr(97)) # 十进制 frozenset()
描述
frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
语法
class frozenset([iterable])
参数
iterable--可迭代的对象，比如列表、字典、元组等等
返回值
返回新的frozenset对象，如果不提供任参数，默认会生成空集合
实例
a = frozenset(range(10)) # 生成一个新的不可变集合
print(a)
#frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('runoob')
print(b)
#frozenset({'u', 'o', 'r', 'b', 'n'}) # 创建不可变集合 list()
描述
list()方法用于将元组转换为列表
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放在方括号中
语法
list(seq)
参数
list--要转换为列表的元组
返回值
返回列表
实例
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
#列表元素 : [123, 'Google', 'Runoob', 'Taobao']
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
#列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'] range()
python3 range()函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。
python3 list()函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表
python2 range()函数返回的是列表
函数语法
range(stop)
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)
实例
print(range(5))
for i in range(5):
print(i)
print(list(range(5)))
print(list(range(0)))
"""
range(0, 5)
0
1
2
3
4
[0, 1, 2, 3, 4]
[]
"""
有两个参数或三个参数的情况
print(list(range(0, 30, 5)))
print(list(range(0, 10, 2)))
print(list(range(0, -10, -1)))
print(list(range(1, 0)))
""" """ vars()
描述
vars()函数返回对象object的属性和属性值的字典对象
语法
vars([object])
参数
object--对象
返回值
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似locals()
实例
print(vars())
class Runoob:
a = 1
print(vars(Runoob))
runoob = Runoob()
print(vars(runoob))
"""
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DE8710>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/py3code/jintong_day1/jinrong/t2.py', '__cached__': None}
{'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, '__doc__': None}
{}
""" classmethod()
描述
classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象
语法
classmethod
参数
无
返回值
返回函数的类方法
实例
class A(object):
bar = 1
def func1(self):
print('foo')
@classmethod
def func2(cls):
print('func2')
print(cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化
#a=A()
#a.func2()#也可以实例化后调用 """ func2 1 foo """
getattr（）
描述
getattr()函数用于返回一个对象属性值
语法
getattr(object,name[,default])
参数
object--对象
name--字符串，对象属性
default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError
返回值
返回对象属性值
实例
class A(object):
bar = 1
a = A()
print(getattr(a, 'bar')) # 获取属性 bar 值
print(getattr(a, 'bar2')) # 属性 bar2 不存在，触发异常
print(getattr(a, 'bar2', 3)) # 属性 bar2 不存在，但设置了默认值,返回3 locals()
描述
locals()函数会以字典类型返回当前位置的全部全局变量
对于函数，方法，lambda函数，类，以及实现了__call__方法的类实例，它都返回True
语法
locals()
参数
无
返回值
返回字典类型的局部变量
实例
def runoob(arg): # 两个局部变量：arg、z
z = 1
print (locals())
runoob(4)# 返回一个名字/值对的字典 repr()
描述
repr()函数将对象转化为供解释器读取的形式
语法
repr(object)
参数
object--对象
返回值
返回一个对象的string格式
实例
s = 'RUNOOB'
print(repr(s))
dict = {'runoob': 'runoob.com', 'google': 'google.com'}
print(repr(dict))
"""
'RUNOOB'
{'runoob': 'runoob.com', 'google': 'google.com'}
""" zip()
描述
zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元祖解压为列表
语法
zip([iterable,])
参数说明
iterable--一个或多个迭代器
返回值
返回元祖列表
实例
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包为元组的列表
print(list(zipped))
print(list(zip(a,c))) # 元素个数与最短的列表一致
print(list(zip(*zipped))) # 与 zip 相反，可理解为解压，返回二维矩阵式
"""
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[]
""" compile()
描述
compile()函数将一个字符串编译为字节代码
语法
compile(source,filename,mode[,flag[,dont_inherit]])
参数
source--字符串或者AST对象
filename--代码文件名称，如果不是从文件读取代码则传递一些可辨认的值
mode--指定编译代码的种类，可以指定为exec,eval,single
flags--变量作用域，局部命名空间，如果被提供，可以是任何映射对象
flags和dont_inherit是用来控制编译源码时的标志
返回值
返回表达式执行结果
实例
str = "for i in range(0,10): print(i)"
c = compile(str,'','exec') # 编译为字节代码对象
print(c)
print(exec(c))
str = "3 * 4 + 5"
a = compile(str,'','eval')
print(eval(a)) globals()
描述
globals()函数会以字典类型返回当前位置的全部全局变量
语法
globals()
参数
无
返回值
返回全局变量的字典
实例
a='runoob'
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
"""
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DB8710>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/py3code/jintong_day1/jinrong/t2.py', '__cached__': None, 'a': 'runoob'}
""" map()
描述
map()会根据提供的函数对指定序列做映射
第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表
语法
map(function,iterable,)
参数
function--函数，有两个参数
iterable--一个或多个序列
返回值
python2.x返回列表
python3.x返回迭代器
实例
def square(x): # 计算平方数
return x ** 2
print(list(map(square, [1, 2, 3, 4, 5]))) # 计算列表各个元素的平方
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数
# 提供了两个列表，对相同位置的列表数据进行相加
print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
大多数时候，我们使用匿名函数来配合map,所以我在上面也是这么做的，不仅用于一列表的输入，我们甚至可以用于一列表的函数 def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs=[multiply,add]
for i in range(5):
values=map(lambda x:x(i),funcs)
print(list(values))
""" """ reversed()
描述
reversed函数返回一个反转的迭代器
语法
reversed(seq)
参数
seq--要转换的序列，可以是tuple,string,list或range
返回值
返回一个反转的迭代器
实例
# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
"""
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
""" __import__()
描述
__import__()函数用于动态加载类和函数
如果一个模块经常变化就可以使用__import__()来动态载入
语法
__import__(name[,globals[,locals[,fromlist[,level]]]])
参数说明
name--模块名
返回值
返回元祖列表
实例
a.py 文件代码：
#!/usr/bin/env python
#encoding: utf-8
import os
print ('在 a.py 文件中 %s' % id(os))
test.py 文件代码：
#!/usr/bin/env python
#encoding: utf-8
import sys
__import__('a') # 导入 a.py 模块
"""
在 a.py 文件中 31245400
""" complex()
描述
complex()函数用于创建一个值为real+imag*j的复数或者转化一个字符串或数为复数，如果第一个参数为字符串，则不需要指定第二个参数
语法
class complex([real[,imag]])
参数说明
real--int,long,float或字符串
imag--int,long,float
返回值
返回一个复数
实例
print(complex(1, 2))
print(complex(1)) # 数字
print(complex("1")) # 当做字符串处理
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(complex("1+2j"))
"""
(1+2j)
(1+0j)
(1+0j)
(1+2j)
""" hasattr()
描述
hasattr()函数用于判断对象是否包含对应的属性
语法
hasattr(object,name)
参数
object--对象
name--字符串，属性名
返回值
如果对象有该属性返回True,否则返回False
实例
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(hasattr(point1, 'x'))#True
print(hasattr(point1, 'y'))#True
print(hasattr(point1, 'z'))#True
print(hasattr(point1, 'no')) # False 没有该属性 max()
描述
max()方法返回给定参数的最大值，参数可以为序列
语法
max(x,y,z)
参数
x--数值表达式
y--数值表达式
z--数值表达式
返回值
返回给定参数的最大值
实例
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
"""
max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
max(-80, -20, -10) : -10
max(0, 100, -400) : 100
""" round()
描述
round()方法返回浮点数x的四舍五入值
语法
round(x[,n])
参数
x--数字表达式
n--表示从小数点位数，其中x需要四舍五入，默认值为0
返回值
返回浮点数x的四舍五入值
实例
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
"""
round(70.23456) : 70
round(56.659,1) : 56.7
round(80.264, 2) : 80.26
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0
""" delattr()
描述
delattr函数用于删除属性
delattr（x,'foobar'）相等于del x.foobar
语法
delattr(object,name)
参数
object--对象
name--必须是对象的属性
返回值
无
实例
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
delattr(Coordinate, 'z')
print('--删除 z 属性后--')
print('x = ', point1.x)
print('y = ', point1.y)
# 触发错误
print('z = ', point1.z)
"""
x = 10
y = -5
z = 0
--删除 z 属性后--
x = 10
y = -5
Traceback (most recent call last):
File "D:/py3code/t2.py", line 95, in <module>
print('z = ', point1.z)
AttributeError: 'Coordinate' object has no attribute 'z'
""" hash()
描述
hash()用于获取一个对象（字符串或者数值等）的哈希值
语法
hash(object)
参数说明
object--对象
返回值
返回对象的哈希值
实例
print(hash('test')) # 字符串
print(hash(1)) # 数字
print(hash(str([1,2,3]))) # 集合
print(hash(str(sorted({'1':1})))) # 字典
"""
13132176260035010
1
6599750410123157373
5131818324150481159
""" memoryview()
描述
memoryview()函数返回给定参数的内存查看对象
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许python代码访问
语法
memoryview（obj）
参数说明
obj--对象
返回值
返回元祖列表
实例
python2.x
v = memoryview('abcefg')
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes()) """
'b'
'g'
<memory at 0x77ab28>
'bce'
"""
python3.x
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes())
"""
98
103
<memory at 0x0000000001EAE708>
b'bce'
""" set()
描述
set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集，差集，并集
语法
class set([iterable])
参数说明
iterable--可迭代对象
返回值
返回新的集合对象
实例
x = set('runoob')
y = set('google')
print(x, y) # 重复的被删除
print(x & y) # 交集
print(x | y) # 并集
print(x - y) # 差集
"""
{'r', 'b', 'u', 'n', 'o'} {'g', 'e', 'o', 'l'}
{'o'}
{'r', 'b', 'l', 'g', 'e', 'u', 'n', 'o'}
{'r', 'b', 'u', 'n'}
""" reduce()
当需要对一个列表进行一些计算并返回结果时，reduce是个非常有用的函数，举个例子，当你需要计算一个整数列表的乘积时
通常在python中你可能会使用基本的for循环来完成任务
from functools import reduce
product=reduce((lambda x,y:x*y),[1,2,3,4])
print(product)#24 ![TestLink导出用例转换工具(XML2Excel)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)