abs()
:返回一个数的绝对值divmod(a,b)
: 结合除法和取模运算,返回一个包含商和模的元祖(a//b, a%b)
, 在 python 2.3 版本之前不允许处理复数。
>>> divmod(7,2)
(3, 1)
>>> divmod(-7,2)
(-4, 1)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
input()
和raw_input()
Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ,用来获取控制台的输入。
input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
python3 里 input() 默认接收到的是 str 类型。
input()
在Python2.x中
>>> a = input("Please input:")
Please input:123
>>> a
123
>>> type(a)
<type ‘int‘>
>>> a = input("Please input:")
Please input:"Tom"
>>> a
‘Tom‘
>>> type(a)
<type ‘str‘>
>>> a = input("Please input:")
Please input:Tom
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name ‘Tom‘ is not defined
>>> a = input("Please input:")
Please input:1+2
>>> a
3
input()
在Python3.x中
[email protected]:~/code$ python3.5
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> a = input("Please input:")
Please input:123
>>> type(a)
<class ‘str‘>
>>> a
‘123‘
>>> a = input("Please input:")
Please input:Tom
>>> a
‘Tom‘
>>> type(a)
<class ‘str‘>
>>> a = input("Please input:")
Please input:"Tom"
>>> type(a)
<class ‘str‘>
>>> a
‘"Tom"‘
raw_input()
在Python3.x中未定义
>>> a = raw_input("input:")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘raw_input‘ is not defined
raw_input()
在Python2.x中将所有的输入当作字符串:
[email protected]:~/code$ python
Python 2.7.12 (default, Dec 4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = raw_input("input:")
input:123
>>> a
‘123‘
>>> a = raw_input("input:")
input:‘Tom‘
>>> a
"‘Tom‘"
>>> a = raw_input("input:")
input:Tom
>>> a
‘Tom‘
>>> a = raw_input("input:")
input:1+2
>>> a
‘1+2‘
staticmethod
返回函数的静态方法
# -*- coding: UTF-8 -*-
class C(object):
@staticmethod
def f():
print "Hello World"
C.f() #静态方法无需实例化
cobj = C() #也可以实例化再调用
cobj.f()
all(iterable)
:iterable为列表或者元祖,用于判断给定的可迭代参数中所有的参数是否都为True,如果是则返回Ture,否则返回False;等价于以下函数:
def all(iterable):
for element in iterable:
if not element:
return False
return True
- 注意:如果iterable得所有元素不为0,"", False或者iterable为空,
all(iterable)
返回True,否则返回False; 空元组或者空列表返回值为True
print all([])
print all(())
print all((1,2,3,0))
print all((‘1‘,‘2‘,‘‘,‘4‘))
print all((1,2,3,4))
输出:
[email protected]:~/code$ python test.py
True
True
False
False
True
enumerate()
: 用于将一个可遍历的数据对象(如列表,元祖,字符串)组合成一个索引序列,同时列出数据和数据下标,一般用在for循环中enumerate(seq [, start=0)):
seq: 一个序列,迭代器或其他支持迭代对象
start: 下标起始位置
>>> seasons = [‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> seasons
[‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> enumerate(seasons)
<enumerate object at 0x7f5b24858870>
>>> list(enumerate(seasons))
[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fail‘), (3, ‘Winter‘)]
>>> list(enumerate(seasons,start = 1))
[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fail‘), (4, ‘Winter‘)]
普通的for
循环
>>> i = 0
>>> seq = [‘one‘, ‘two‘, ‘three‘]
>>> for element in seq:
... print i,seq[i]
... i += 1
...
0 one
1 two
2 three
使用enumerate
的for
循环
>>> for i, element in enumerate(seq):
... print i,element
...
0 one
1 two
2 three
int()
函数:用于将一个字符串或数字转换为整型int (x, base = 10)
x: 字符串或者数字
base: 进制数,默认十进制
>>> int() #不传入参数时,得到结果0
0
>>> int(3) #可以传入数字
3
>>> int(‘3‘) #也可以传入字符串
3
>>> int(‘12‘,16) #如果是要带 base 的话,12要以字符串形式进行输入,12为16进制数
18
>>> int(‘0xa‘,16)
10
>>> int(‘10‘,8)
8
ord()
函数,以一个字符(长度为1的字符串)作为参数,返回对应的ASCII数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常。
>>> ord(‘a‘)
97
>>> ord(‘b‘)
98
str()
:返回一个对象的string格式
>>> str(123)
‘123‘
>>> dict = {‘a‘:123,45:‘abc‘}
>>> str(dict)
"{‘a‘: 123, 45: ‘abc‘}"
>>> dict
{‘a‘: 123, 45: ‘abc‘}
any()
:any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True;元素除了0,空,False外都算True,等价于以下函数:
def any(iterable):
for element in iterable:
if element:
return True
return False
测试:
print any(())
print any([])
print any([‘a‘,‘‘])
print any([False])
print any((0,))
输出:
[email protected]:~/code$ python test.py
False
False
True
False
False
eval()
用来执行一个字符串表达式,并返回表达式的值eval(expression[, globals[, locals]])
expression -- 表达式。
globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
>>> x = 7
>>> eval(‘3*x‘)
21
>>> eval(‘x*x‘)
49
>>> eval(‘(1+2j)*x‘)
(7+14j)
isinstance()
判断一个对象是否属于一个已知的类型,与type()
的区别在于:type()
认为子类不属于父类类型,不考虑继承关系isinstance()
认为子类是一种父类类型,考虑继承关系如果要判断两个类型是否相同推荐使用
isinstance
- isinstance(object, classinfo)
object: 实例对象
classinfo: 可以直接或间接类名、基本类型或者由他们组成的元祖:
- isinstance(object, classinfo)
>>> a = 2
>>> isinstance(a,int)
True
>>> isinstance(a,str)
False
>>> isinstance(a,(str, int, list))
True
type()
与isinstance()
区别
# -*- coding: UTF-8 -*-
class father(object):
pass
class son(father):
pass
if __name__==‘__main__‘:
print type(son())==father
print isinstance(son(),father)
print type(son())
print type(son)
输出:
[email protected]:~/code$ python test.py
False
True
<class ‘__main__.son‘>
<type ‘type‘>
type()
主要用来获取未知变量的类型isinstance()
主要用于判断A类是否属于B类
pow(x, y[, z])
与math.pow()
: 计算 x 的 y 次方,分别相当于x ** y % z
、x**y
- 通过内置的方法直接调用,内置方法会把参数作为整型,如果有 z,再对z取模
- 而 math 模块则会把参数转换为 float
>>> import math
>>> math.pow(2,1,2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3
>>> math.pow(2,1)
2.0
>>> pow(2,1)
2
>>> pow(2,1,2)
0
sum()
函数:求序列的和sum(iterable[, start])
iterable: 可迭代对象,如:列表,元祖,集合
start: 在前面序列和的基础上再加上 start, 如果没有这个值,则默认为0
>>> sum((1,2,3))
6
>>> sum([1,2,3])
6
>>> sum([1,2,3],4)
10
basestring()
是str
和unicode
的父类,也是抽象类,因此不能被调用和实例化,但是可以用来判断一个对象是否是str
或者unicode
的实例
- isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
>>> isinstance(‘Hello world‘,basestring)
True
>>> isinstance(‘Hello world‘,str)
True
execfile()
:用来执行一个文件execfile(filename[, globals[, locals]])
filename -- 文件名。
globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值:返回表达式的执行结果
>>> execfile(‘test.py‘)
False
True
<class ‘__main__.son‘>
<type ‘type‘>
- Python 3 中删去了
execfile()
,代替如下:
with open(‘test.py‘,‘r‘) as f:
exec(f.read())
issubclass()
函数:用于判断参数 class 是否是类型参数 classinfo 的子类。issubclass(class, classinfo)
# -*- coding: UTF-8 -*-
class father(object):
pass
class son(father):
pass
print(issubclass(son,father))
输出:
[email protected]:~/code$ python test.py
True
print
: print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。print(*object, sep=‘ ‘, end=‘\n‘, file=sys.stdout)
*object
-----表示一次性可以接收多个对象,输出多个对象时,需要用,
隔开sep
-----用来间隔多个对象,默认是一个空格end
-----用来设定以什么结尾,默认是一个换行符\n
,可以更改换成其它字符file
-----要写入的文字对象
python 3下的测试
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("aaa","bbb",sep=‘---‘) #设置间隔符
aaa---bbb
super()
函数:用于调用父类的方法,super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表
- Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
# -*- coding: UTF-8 -*-
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).__init__()
print(‘Child‘)
def bar(self,message):
super(FooChild,self).bar(message)
print (‘Child bar function‘)
print(self.parent)
if __name__==‘__main__‘:
fooChild = FooChild()
fooChild.bar(‘Hello World‘)
输出:先调用父类,再调用自己的子类
[email protected]:~/code$ python test.py
Parent
Child
Hello World from parent
Child bar function
I‘m the parent
__init__
方法的第一参数永远是self,表示创建的类实例本身,因此,在__init__
方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身。(2)有了__init__
方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__
方法匹配的参数,但self不需要传,Python解释器会自己把实例变量传进去- 如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线,在Python中,实例的变量名如果以
__
开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问 - 在Python中,变量名类似
__xxx__
的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__
、__score__
这样的变量名。 - 参考:self的用法详解
bin()
函数:返回一个整数 int 或一个长整型 long int的二进制表示
>>> bin(10)
‘0b1010‘
>>> bin(8)
‘0b1000‘
file()
用于创建一个对象,与open()
类似file(name[, mode[, buffering]])
name-----文件
mode-----打开模式
buffering-----0表示不缓冲,如果为1则表示进行缓冲,大于1为缓冲大小
>>> f = file(‘b.txt‘,‘r+‘)
>>> f.read()
‘Hello world!!!‘
iter()
用来生成一个迭代器iter(object[, sentinel])
object-----支持迭代的集合对象
sentinel-----如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的
__next__()
方法时,都会调用 object
>>> lst = [1,2,3]
>>> for x in iter(lst):
... print x
...
1
2
3
tuple()
将列表转换为元祖
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:2,3:4,‘xsd‘:7}) #针对字典,会返回字典的 key 组成的 tuple
(1, 3, ‘xsd‘)
>>> tuple((1,2,3,4)) #元祖则会返回元祖本身
(1, 2, 3, 4)
bool()
用于将给定参数转换为bool
类型,如果没有参数,则 返回False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(19)
True
>>> bool(-1)
True
>>> issubclass(bool,int)
True
>>> isinstance(False,bool)
True
filter()
函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表filter(function, iterable)
该函数接收两个参数,第一个为函数,第二个为序列;序列的每个元素分别作为函数的参数进行判断,然后返回 True 或者 False ,最后将返回 True的元素放在新列表中
Python 2 实例1. 滤出列表中所有的奇数
# -*- coding: UTF-8 -*-
def is_odd(n):
return n%2==1
list = [1,2,3,4,5,6]
newlist = filter(is_odd, list)
print newlist
输出:
[email protected]:~/code$ python test.py
[1, 3, 5]
Python 2 实例2. 滤出1-100中平方根是整数的数
# -*- coding: UTF-8 -*-
import math
def is_sqrt(x):
return math.sqrt(x)%1==0
newlist = filter(is_sqrt, range(1,101))
print newlist
输出:
[email protected]:~/code$ python test.py
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Python 2.x中
filter()
返回的是过滤后的列表,而Python3返回的是一个filter
类
Python 3 运行输出:
[email protected]:~/code$ python3.5 test.py
<filter object at 0x7f1cbecf3b00>
[0, 2, 4, 6, 8]
Python 2.5 运行输出:
[email protected]hine:~/code$ python test.py
[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]
len()
返回对象(元祖,列表,字符、字典等)的长度或者项目个数
>>> str = "Hello World"
>>> len(str)
11
>>> list = [1,2,3,4]
>>> len(list)
4
>>> tuple = (1,2,3,4)
>>> len(tuple)
4
>>> dict = {1:2,3:4}
>>> len(dict)
2
range(start, stop[, step])
:创建一个整数列表,一般用在 for 循环中start: 计数从start开始,默认值为0,因此,range(5)等价于range(0,5)
stop: 计数到stop结束,但不包括stop
step: 步长,默认值为1,因此,range(3,2,1)等价于range(3,2)
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>> range(0)
[]
>>> range(10,1)
[]
>>> range(0,-10,-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
callable()
:检查一个函数是否是可调用的函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
format()
格式化函数通过
{}
和:
来代替以前的%
实例1.
>>> "{} {}".format("Hello","World")
‘Hello World‘
>>> "{0} {1}".format("Hello","World")
‘Hello World‘
>>> "{1} {0} {1}".format("Hello","World")
‘World Hello World‘
实例2.也可以设置参数:
>>> print ("Name:{name} Age:{age}".format(name="Tom",age=6))
Name:Tom Age:6
>>> info = {"name":"Jack","age":12} #通过设置元祖 但是要加双星号
>>> print ("Name:{name} Age:{age}".format(**info))
Name:Jack Age:12
>>> list = ["Rose",20] #对于列表,要加 0
>>> print ("Name:{0[0]} Age:{0[1]}".format(list)) # 0 是必须的,代表括号中的列表名
Name:Rose Age:20
>>> print ("Name:{[0]} Age:{[1]}".format(list)) # 不带 0 就会出错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
实例3. 也可传入对象
# -*- coding: UTF-8 -*-
class AssignValue(object):
def __init__(self,value):
self.value = value
my_value = AssignValue(7)
print ("value is :{0.value}".format(my_value)) #这里的 0 则是可选的
print ("value is :{.value}".format(my_value)) # 这里的 0 则是可选的,但是点 . 要留着
输出:
[email protected]:~/code$ python test.py
value is :7
value is :7
- 数字格式化
^
>
<
分别代表居中对齐,右对齐,左对齐,后面跟 宽度:
后面带填充的字符,只能是一个字符,不指定则默认用空格填充+
表示在正数面前显示+
,在负数面前显示-
,` `(空格)在正数面前加空格b, d, o, x 分别表示二进制, 十进制,八进制,十六进制
数字 | 格式 | 输出 | 描述 |
---|---|---|---|
3.14159265 | {:.2f} |
3.14 | 保留2位小数 |
3.14159265 | {:+.2f}} |
+3.14 | 带符号保留2位小数 |
-1 | {:+.2f} |
-1.00 | 带符号保留2位小数 |
3.14159265 | {:.0f} |
3 | 不带小数 |
5 | {:0>2d} |
05 | 数字往右对齐,不足左边补零 |
5 | {:x<2d} |
5x | 数字往左对齐,不足的右边补0 |
1000000 | {:,} |
1,000,000 | 以逗号分隔的数字格式 |
0.23 | :.2% |
23% | 百分比表示 |
1000000 | :.2e |
1.00e6 | 指数计数法 |
13 | {:10d} |
13 | 右对齐(默认右对齐,空缺补空格) |
"{:b}".format(11) |
1101 | 二进制 | |
"{:d}".format(11) |
11 | 十进制 | |
"{:o}".format(11) |
13 | 八进制 | |
"{:x}".format(11) |
b | 十六进制 | |
"{:#x}".format(11) |
0xb | 十六进制 | |
"{:#X}".format(11) |
0XB | 十进制 |
- 使用大括号
{}
来转义大括号{}
>>> print("{}对应的位置是{{0}}".format("Hello"))
Hello对应的位置是{0}
>>> print("{0}对应的位置是{1}{{0}}".format("Hello","World"))
Hello对应的位置是World{0}
locals()
以字典类型返回当前位置的全部局部变量
# -*- coding: UTF-8 -*-
def f(x):
z = 1
print(locals())
f(6)
输出:
[email protected]:~/code$ python test.py
{‘x‘: 6, ‘z‘: 1}
reduce(function, iterable[, initializer])
function----- 函数,有2个参数
iterable-----可迭代对象
initializer-----可选,初始参数
功能: 先用集合 iterable 中的第 1, 2 两个元素传入给函数 function 的两个参数进行操作,得到的结果再与第三个数据继续传入给 function 的两个参数进行操作,直到得到最后一个结果
>>> def add(x, y):
... return x+y
...
>>> reduce(add, [1,2,3,4])
10
>>> reduce(lambda x, y: x + y, [1,2,3,4])
10
- 在Python 3中
reduce()
函数已经从全局名字空间中移除,被放置在functools
模块
# -*- coding: UTF-8 -*-
from functools import reduce
def add(x, y):
return x+y
print (reduce(add, [1,2,3,4]))
输出:
[email protected]:~/code$ python test.py
10
实例2. 统计某字符串的重复次数
from functools import reduce
sentences = [‘The Deep Learning textbook is a resource intended to help students
and practitioners enter the field of machine learning in general
and deep learning in particular. ‘]
word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
print(word_count)
分析:
reduce()
的源码如下:
def reduce(function, iterable, initializer = None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value,element)
return value
上面首先value=initializer=0
,然后value=function(0, element)
,即lambda匿名函数中的参数a = 0, x=序列的元素,因此不能互换 a 和 x的位置,因为只有序列有count方法,而 int 没有,互换之后就会报错,
File "test.py", line 16, in <lambda> word_count = reduce_1(lambda x,a:x.count(‘learning‘)+a,sentences,0) AttributeError: ‘int‘ object has no attribute ‘count‘
输出:
[email protected]:~/code$ python test.py
2
next()
返回迭代器的下一个项目next(iterator[, default])
iterator -- 可迭代对象
default -- 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。
# -*- coding: UTF-8 -*-
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
输出:
1
2
3
4
5
chr()
用一个范围在 range(256) 即0-255的整数(可以是十进制,也可以是十六进制,二进制等)做参数,返回一个对应的字符
>>> print chr(48), chr(49), chr(97)
0 1 a
>>> print chr(0x30),chr(0x31),chr(0x61)
0 1 a
frozenset()
返回一个冻结的集合,冻结后集合不能再添加或删除任何元素frozenset([iterable])
iterable-------可迭代的对象,比如列表,字典,元祖等
返回新的 frozenset 对象,如果不提供任何参数,默认生成空集合。
>>> a = frozenset(range(10))
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset("Hello World")
>>> b
frozenset([‘ ‘, ‘e‘, ‘d‘, ‘H‘, ‘l‘, ‘o‘, ‘r‘, ‘W‘])
>>> b[0]=1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘frozenset‘ object does not support item assignment
long()
将数字或字符串转换为一个长整型long(x, base = 10)
x -------- 字符串或者数字,当指定进制后,x 只能是字符串
base --------可选,进制数,默认十进制
>>> long(123)
123L
>>> long(123,base = 10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: long() can‘t convert non-string with explicit base
>>> long(‘123‘,base = 10)
123L
>>> long(‘0b100‘,base = 2)
4L
>>> long(‘0x10‘,base = 16)
16L
reload()
用于重新载入之前载入的模块reload()
会重新加载已加载的模块,但原来使用的实例还是会使用旧的模块,而新的实例会使用新的模块reload()
后还是使用原来的内存地址reload()
不支持from xxx import xxx
格式的模块进行重新加载vars()
返回对象 object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。
>>> print(vars())
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__package__‘: None, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None}
>>> class Name:
... x = 1
...
>>> print(vars(Name))
{‘x‘: 1, ‘__module__‘: ‘__main__‘, ‘__doc__‘: None}
- 对于
x = 1
,这样一个赋值语句,在执行后,名称 x 引用到值 1,这就像字典一样,键引用值,当然,变量和所对应的值是个"不可见的"字典,可以使用vars()
来返回这个字典
x = 2
>>> x = 2
>>> vars()[‘x‘] #vars()相当于返回当前变量的字典,其中就存在键值对应的(‘x‘: 1),因此像字典一样可以通过键取值
2
classmethod()
修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的cls
参数,可以调用类的属性,类的方法,实例化对象等
# -*- coding: UTF-8 -*-
class A(object):
bar = 1
def fun1(self):
print("fun1")
@classmethod
def fun2(cls):
print ("fun2")
print (cls.bar)
cls().fun1()
A.fun2() #不需实例化
输出:
[email protected]:~/code$ python test.py
fun2
1
getattr()
用于获取对象的属性值getattr(object, name[, default])
object------对象
name-----字符串,对象属性
default------默认返回值,如果不提供该参数,在没有对应属性时,将触发AttributeError
>>> class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a,‘bar‘)
1
>>> getattr(a, ‘bar2‘)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘A‘ object has no attribute ‘bar2‘
>>> getattr(a, ‘bar2‘,3)
3
map()
根据提供的函数对指定序列映射,Python2返回列表,Python3返回迭代对象map(function, iterable, ...)
function ------函数,有两个参数
iterable ------一个或者多个序列
函数function 调用序列中的每一个参数,最后返回包含每个function返回值的新列表
>>> map(square, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x**2, [1,2,3,4])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes exactly 2 arguments (1 given)
>>> map(lambda x: x**2, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x*y, [1,2,3,4],[1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y, z: x*y*z, [1,2,3,4],[1,2,3,4],[1,2,3,4])
[1, 8, 27, 64]
- 在Python3.x 如果函数含有多个参数,但每个参数序列的元素数量不一样,会根据最少的序列进行,Python2.X中报错
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> x = [1,2,3]
>>> y = [1,2]
>>> z = [1,2,3,4]
>>> print(map(lambda x,y,z:x+y+z,x,y,z))
<map object at 0x7f0e926c0d68>
>>> print(list(map(lambda x,y,z:x+y+z,x,y,z)))
[3, 6]
- map完成规范名字格式
# -*- coding: UTF-8 -*-
name_list = [‘tom‘,‘tony‘,‘jack‘]
def format_name(s):
ss = s[:1].upper() + s[1:].lower()
return ss
print(list(map(format_name, name_list)))
输出:
[email protected]:~/code$ python test.py
[‘Tom‘, ‘Tony‘, ‘Jack‘]
repr()
将对象转化为供解释器读取的形式,返回一个对象的string格式
>>> s = ‘Hello world‘
>>> str(s)
‘Hello world‘
>>> repr(s)
"‘Hello world‘"
>>> s = {‘1‘:1,‘2‘:2}
>>> str(s)
"{‘1‘: 1, ‘2‘: 2}"
>>> repr(s)
"{‘1‘: 1, ‘2‘: 2}"
xrange()
与range()
相似,不同的是range
生成的是一个数组,而xrange
是一个生成器
>>> xrange(8)
xrange(8)
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(0,6,2)
xrange(0, 6, 2)
>>> list(xrange(0,6,2))
[0, 2, 4]
cmp(x, y)
用与比较两个对象。如果 x<y, 则返回 -1;如果 x==y, 则返回0;如果 x>y, 则返回1
>>> cmp(80,9)
1
>>> cmp(8,9)
-1
>>> cmp(‘a‘,‘b‘)
-1
>>> cmp(‘a‘,‘ac‘)
-1
>>> cmp(‘x‘,‘bcd‘)
1
- Python3.X 已经没有
cmp()
函数,若需实现比较功能,需引入operator
模块
operator.lt(a, b) # less than
operator.le(a, b) # less equal
operator.eq(a, b) # equal
operator.ne(a, b) # not equal
operator.ge(a, b) # greater equal
operator.gt(a, b) # greater than
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)
globals()
以字典类型返回当前位置的全部全局变量
>>> a = ‘Hello‘
>>> globals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}
>>> locals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}
max()
返回当前参数的最大值
>>> max(1,2,3,4)
4
>>> max(‘a‘,‘b‘,‘c‘)
‘c‘
>>> max((1,2,3),(4,1,2)) #一个一个元素地进行对比,从左往右
(4, 1, 2)
>>> max({1:10,2:8,3:7}) #字典则先比较键值,键值相同再比较后面的 value
3
>>> max({1:10,1:8,1:7})
1
reverse()
用于反向列表中的元素
>>> a = [1,2,3,4]
>>> a.reverse()
>>> a
[4, 3, 2, 1]
zip()
函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元祖,然后返回由这些元祖组成的列表
- 如果各个迭代器的元素个数不一样,则返回列表长度与最短的对象相同
- 利用
*
操作,可以将元祖解压为列表 - 在Python3中返回的是一个对象,需要手动
list()
转换
>>> a = [1,2,3,4]
>>> b=[5,6,7]
>>> c = [7,8,9]
>>> ac = zip(a,c)
>>> ac
[(1, 7), (2, 8), (3, 9)]
>>> bc = zip(b,c)
>>> bc
[(5, 7), (6, 8), (7, 9)]
>>> bc = zip(*bc)
>>> bc
[(5, 6, 7), (7, 8, 9)]
compile()
将一个字符串编译为字节代码compile(source, filename, mode[, flags[, dont_inherit]])
source -- 字符串或者AST(Abstract Syntax Trees)对象。。
filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
flags和dont_inherit是用来控制编译源码时的标志
>>> str = "for i in range(0,10):print i,"
>>> exec(str)
0 1 2 3 4 5 6 7 8 9
>>> c = compile(str,‘‘,‘exec‘)
>>> c
<code object <module> at 0x7f9328f04db0, file "", line 1>
>>> exec(c)
0 1 2 3 4 5 6 7 8 9
hasattr()
判断对象是否包含对应的属性hasattr(object, name)
object------对象
name-----字符串,属性名
如果对象有该属性则返回 True, 否则返回 False
>>> class coordinate:
... x = 10
... y = -5
... z = 0
...
>>> point1 = coordinate()
>>> hasattr(point1, ‘x‘)
True
>>> hasattr(point1, ‘y‘)
True
>>> hasattr(point1, ‘no‘)
False
round()
返回浮点数 x 的四舍五入值round(x[, n])
>>> round(10.0044,3)
10.004
>>> round(10.0045,3)
10.005
complex(real[, imag])
用于创建一个值为real + imag * j
的复数或者转化一个字符串或数为复数,如果第一个参数为字符串,则不需要指定第二个参数
>>> complex(1,2)
(1+2j)
>>> complex(1.1,2.2)
(1.1+2.2j)
>>> complex("1+2j")
(1+2j)
>>> complex("1 + 2j") # + 两侧不能有空格
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string
>>> complex("1")
(1+0j)
>>> complex("2j")
2j
hash()
返回对象的哈希值
- 函数可以应用于数字、字符串和对象,不能直接应用于 list、set、dictionary。
>>> hash(1)
1
>>> hash(2)
2
>>> hash(‘hello‘)
840651671246116861
>>> hash(str([1,2,3]))
1335416675971793195
>>> hash([1,2,3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: ‘list‘
min()
返回多个参数的最小值
>>> min(1,2,3)
1
>>> min(‘a‘,‘b‘)
‘a‘
>>> min({1:10,2:8,3:7})
1
>>> min({1:10,1:8,1:7})
1
set(iterable)
创建一个无序不重复元素集
- 可进行关系测试,删除重复数据,还可以计算交集,并集等
>>> x = set(‘hello‘)
>>> y = set(‘google‘)
>>> x,y
(set([‘h‘, ‘e‘, ‘l‘, ‘o‘]), set([‘e‘, ‘o‘, ‘g‘, ‘l‘]))
>>> x
set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
>>> y
set([‘e‘, ‘o‘, ‘g‘, ‘l‘])
>>> x & y # 交集
set([‘e‘, ‘l‘, ‘o‘])
>>> x | y # 并集
set([‘e‘, ‘g‘, ‘h‘, ‘l‘, ‘o‘])
>>> x -y # 差集
set([‘h‘])
delattr(object, name)
用于删除属性
>>> class coordinate:
... x = 10
... y = -5
... z = 0
...
>>> point1 = coordinate()
>>> point1.x
10
>>> delattr(point1,‘x‘)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘
>>> delattr(coordinate,‘x‘)
>>> point1.x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘
help()
返回对象的帮助信息
>>>help(‘sys‘) # 查看 sys 模块的帮助
……显示帮助信息……
>>>help(‘str‘) # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a) # 查看列表 list 帮助信息
……显示帮助信息……
>>>help(a.append) # 显示list的append方法的帮助
……显示帮助信息……
setattr()
对应于函数getattr()
用于设置属性值,可以增加属性setattr(object, name, value)
>>> class coordinate:
... x = 10
... y = -5
... z = 0
...
>>> point1 = coordinate()
>>> point1.x
10
>>> setattr(point1,‘x‘,20)
>>> point1.x
20
>>> point1.m
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘m‘
>>> setattr(coordinate,‘m‘,9) #当以类名为参数时,实例的值也会修改
>>> point1.m
9
>>> setattr(point1,‘m‘,90) #当以实例为参数时,再以类名为参数,则不会改变
>>> point1.m
90
>>> setattr(coordinate,‘m‘,9)
>>> point1.m
90
dict()
函数用于创建一个字典
>>> dict() #创建一个空字典
{}
>>> dict(a=‘a‘,b=‘b‘,c=3) #传入关键字
{‘a‘: ‘a‘, ‘c‘: 3, ‘b‘: ‘b‘}
>>> dict(zip([‘one‘,‘two‘,‘three‘],[1,2,3])) #映射函数方式来构造字典
{‘three‘: 3, ‘one‘: 1, ‘two‘: 2}
>>> dict([(‘one‘,1),(‘two‘,2),(3,‘three‘)]) # 可迭代对象来构造字典
{‘one‘: 1, 3: ‘three‘, ‘two‘: 2}
slice()
实现切片,slice(start, stop[, step])
返回一个切片对象
>>> myslice = slice(5)
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
range(0, 10)
>>> arr[myslice]
range(0, 5)
>>> list(arr[myslice])
[0, 1, 2, 3, 4]
>>> list(arr[slice(6,10,1)])
[6, 7, 8, 9]
dir()
函数
- 不带参数时,返回当前范围内的变量、方法和定义的类型列表;
- 带参数时,返回参数的属性、方法列表
- 如果参数包含方法
__dir__()
,该方法被调用;如果参数不包含__dir__()
,该方法将最大限度地收集参数信息
- 如果参数包含方法
>>> dir()
[‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘,
‘__spec__‘, ‘arr‘, ‘coordinate‘, ‘myslice‘, ‘p2‘, ‘point1‘]
>>> dir([])
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘,
‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘,
‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘,
‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘,
‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘,
‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘,
‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘,
‘reverse‘, ‘sort‘]
id()
获取对象的内存地址
>>> a = ‘Hello‘
>>> id(a)
140540780793224
>>> b = ‘Hello‘
>>> id(b)
140540780793224
>>> c = a
>>> id(c)
140540780793224
- 可以看到,对于同一个字符串对象,可以有多个引用 a,b,c但是其地址都是相同的
oct()
将一个整数转换为 8 进制字符串
>>> oct(0b1000)
‘0o10‘
>>> oct(8)
‘0o10‘
>>> oct(0x8)
‘0o10‘
>>> oct(0x10)
‘0o20‘
sorted()
原文地址:https://www.cnblogs.com/qiulinzhang/p/9513571.html