1. python的优势
- 首选是网络应用，包括网站、后台服务等等；
- 其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
- 另外就是把其他语言开发的程序再包装起来，方便使用。
2. 缺点
- 运行速度相对慢
- 程序是明文，不能加密
3. 多行字符串'''...'''还可以在前面加上r使用
4. 逻辑运算 and、or、not和空值None
python的整数和浮点数都没有大小的限制
5. 字符编码（注意：python2中字符串默认不是unicode，与设置的编码一致）
- 用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件
- 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器，所以你看到很多网页的源码上会有类似的信息，表示该网页正是用的UTF-8编码。
image
image
- 如果知道字符的整数编码，还可以用十六进制这么写str：这样写和写字符串一致，因为写了字符串，python3默认会用utf-8解码，变量用unicode存储。
>>> '\u4e2d\u6587'
'中文'
6. Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符
7. 注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节
- 编码（encode）的过程就是，将unicode转化为转换为某种编码形式，每个字符在unicode中占用两个字节，转换为具体编码中的bytes形式。
注意：utf-8和unicode中的编码可以做到一一对应，但是别的编码方式都只能对应一部分字符集。因此从unicode转换成某种具体的编码的时候可能出现无法转码的情况。
>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
File "", line 1, in
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
9. 如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
注：如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'
10. len 返回字符串、列表、字典、元组等长度
注：区别于len方法，在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的len()方法。
>>> len('abcd')
4
>>> len([1,2,3])
3
>>> len((1,2,3))
3
>>> len({'a':'hello','b':'heihei'})
2
>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6
- python2环境--
# 将CRT设置为utf-8的编码格式
1. 默认的内置编码为ascii
miao@miao-VirtualBox:~$ 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.
>>> import sys
>>> reload(sys)
>>> print sys.getdefaultencoding()
ascii
2.
>>> zhongwen = '中文'
>>> type(zhongwen)
>>> len(zhongwen)
6
>>> sys.setdefaultencoding('utf-8')
>>> len(zhongwen)
6
>>> zhongwen_uni = u'中文'
>>> type(zhongwen_uni)
>>> len(zhongwen_uni)
2
# 可见unicode不是按照字节来统计的，而是暗中某个字符集的字符的个数统计
>>> repr(zhongwen_uni)
"u'\\u4e2d\\u6587'"
# 转换为utf-8
>>> zhongwen_utf8 = zhongwen_uni.encode('utf-8')
>>> print zhongwen_utf8
中文
>>> len(zhongwen_utf8)
6
>>> repr(zhongwen_utf8)
"'\\xe4\\xb8\\xad\\xe6\\x96\\x87'"
>>> type(zhongwen_utf8)
# 原始输入（终端输入格式为utf-8），与unicode转换为utf-8的编码格式一致
>>> print zhongwen_utf8 == zhongwen
True
>>> zhongwen_gbk = zhongwen_uni.encode('gbk')
>>> print zhongwen_gbk
# 输出没有显示，应该时CRT默认编码为utf-8而输出的变量是gbk无法显示。
>>> repr(zhongwen_gbk)
"'\\xd6\\xd0\\xce\\xc4'"
>>> yingwen = 'abc'
>>> repr(yingwen)
"'abc'"
>>> len(yingwen_uni)
3
>>> yingwen_uni = u'abc'
>>> repr(yingwen_uni)
"u'abc'"
>>> yingwen_utf8 = yingwen_uni.encode('utf-8')
>>> print yingwen_utf8
abc
>>> repr(yingwen_utf8)
"'abc'"
>>> yingwen_gbk = yingwen_uni.encode('gbk')
>>> repr(yingwen_gbk)
"'abc'"
>>> len(yingwen_gbk)
3
- python3 环境
miao@miao-VirtualBox:~$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> len('中文')
2
>>> len(u'中文')
2
总结：对于unicode，len函数按照真实的字符数量来统计，如果对于str，len函数按照字节数量统计
11. 格式化输出--C语言的风格
>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
#常用占位符
占位符 替换内容
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
#指定位数，指定是否用0补充，%02d代表两位，不足用0补充
>>> print('%2d-%02d' % (3, 1))
3-01
>>> print('%02d-%02d' % (3, 1))
03-01
>>> print('%03d-%02d' % (3, 1))
003-01
>>> print('%.2f' % 3.1415926)
3.14
# 用%%来表示一个%
>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'
# format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}
>>> a = 'Hello, {1}, 成绩提升了 {0:.1f}%'.format(17.125,'小明')
>>> print a
Hello, 小明, 成绩提升了 17.1%
#python2中默认编码为ascii，python3为unicode，所以python3可以直接显示
miao@miao-VirtualBox:~$ 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.
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, \xe5\xb0\x8f\xe6\x98\x8e, \xe6\x88\x90\xe7\xbb\xa9\xe6\x8f\x90\xe5\x8d\x87\xe4\xba\x86 17.1%'
miao@miao-VirtualBox:~$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
#例：小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出'xx.x%'，只保留小数点后1位：
>>> print('{0:.1f}%'.format(100*(s2-s1)/float(s1)))
18.1%
12 .列表和元祖
classmates = ['Michael', 'Bob', 'Tracy']
>>> len(classmates)
3
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "", line 1, in
IndexError: list index out of range
>>> classmates[-1]
'Tracy'
>>> classmates.insert(1, 'Jack')
>>> classmates.pop() #删除list末尾的元素
>>> classmates.pop(1) #删除指定位置的元素
# 列表的排序
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
# tuple的陷阱：只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
>>> t = (1)
>>> t
1
>>> t = (1,)
>>> t
(1,)
# 指向不变
# 表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
13 循环
sum = 0
for x in range(101):
sum = sum + x
print(sum)
# 终端中一行行地敲也要注意缩进
>>> L = ['Bart', 'Lisa', 'Adam']
>>> for word in L:
... print 'hello %s'%word
...
hello Bart
hello Lisa
hello Adam
14. 字典dict和set
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
>>> d.pop('Bob') #删除一个key
75
dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.remove(4)
>>> s
{1, 2, 3}
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
15. 可变对象与不可变对象
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
16. 函数名：就是指向一个函数对象的引用
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
17. 内置函数
1. abs：绝对值
2. divmod：把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
3. input：
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
Python2.x 中 input() 相等于eval(raw_input(prompt))，用来获取控制台的输入。
raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。
注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意：python3 里 input() 默认接收到的是 str 类型。
4. open() 函数用于打开一个文件
5. staticmethod()：
例：以下实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
6. all():用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空
例：
>>>all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3]) # 列表list，存在一个为0的元素
False
>>> all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
False
>>> all((0, 1，2, 3)) # 元组tuple，存在一个为0的元素
False
>>> all([]) # 空列表
True
>>> all(()) # 空元组
True
7. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标
8. int：函数用于将一个字符串或数字转换为整型。
9. ord：它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值
10. str() 函数将对象转化为适于人阅读的形式
11. any() 与all()对应，只要有一个为True就为True
12. eval() 函数用来执行一个字符串表达式，并返回表达式的值
13. isinstance(object, classinfo) 判断是否一个类的对象或者子类的对象
14. math.pow( x, y )，返回 xy（x的y次方） 的值
15. 求和：sum([0,1,2]) ， sum((2, 3, 4), 1)
16. basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))
17. execfile() 函数可以用来执行一个文件
18. issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类
19. print(*objects, sep=' ', end='\n', file=sys.stdout)
例：
print("www","runoob","com",sep=".") # 设置间隔符
www.runoob.com
20. super() 函数是用于调用父类(超类)的一个方法
21. bin() 返回一个整数 int 或者长整数 long int 的二进制表示
22. file() 用于创建一个 file 对象，它有一个别名叫 open()
23. iter() 用来生成迭代器
例子：
class counter:
def __init__(self, _start, _end):
self.start = _start
self.end = _end
def get_next(self):
s = self.start
if(self.start < self.end):
self.start += 1
else:
raise StopIteration
return s
c = counter(1, 5)
'''
iter(object[, sentinel])
If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its __next__() method; if the value returned is equal to sentinel,StopIteration will be raised, otherwise the value will be returned.
'''
iterator = iter(c.get_next, 4) #如果__next__的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值
print(type(iterator))
for i in iterator:
print(i)
#输出
1
2
3
24. property()：
例1：设置类某个属性的get、set、del、init方法
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
例2：做装饰器，创建只读属性
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
例3：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
25. tuple() 函数将列表转换为元组
26. bool()将给定参数转换为布尔类型
27. filter() 用于过滤序列，过滤掉不符合条件的元素
例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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]
28. len() 返回对象（字符、列表、元组等）长度或项目个数
29. range()：产生一个序列
例：
>>>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]
30. type() 一个参数返回对象类型
高级用法：三个参数，返回新的类型对象
>>>X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X，和用class定义一个类的效果一样
>>> X
31. bytearray()：返回值为一个新的字节数组
例：
# encoding:utf-8
a = '中文'
b = u'中文'
print type(a)
print bytearray(a.decode('utf-8'),'utf-8')
print type(b)
print bytearray(b,'utf-8')
32. float()用于将整数和字符串转换成浮点数
33. list() 用于将元组转换为列表
34. raw_input() 将所有输入作为字符串看待，返回字符串类型
35. unichr() 返回 unicode 的字符
例：
>>>unichr(97)
u'a'
>>> unichr(98)
u'b'
>>> unichr(99)
u'c'
36. callable()检查一个对象是否是可调用的
37. format()格式化字符串的函数 str.format()
>>> "{1} {0} {1}".format("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" 是必须的
# 通过对象设置属性
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
38. locals()会以字典类型返回当前位置的全部局部变量
例：
>>>def runoob(arg): # 两个局部变量：arg、z
... z = 1
... print (locals())
...
>>> runoob(4)
{'z': 1, 'arg': 4} # 返回一个名字/值对的字典
39. reduce() 规约操作
例：
>>>def add(x, y) : # 两数相加
... return x + y
...
>>> reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数
15
40. unicode() 一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
41. chr()
42. 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']) # 创建不可变集合
43. long() 将数字或字符串转换为一个长整型
44. reload() 重新载入之前载入的模块
场景：
如果此时在另一个窗口中改变并保存了模块的源代码文件
45. vars() 返回对象object的属性和属性值的字典对象
46. classmethod()：类的方法，用类名调用，不用实例化调用，参数cls而不是self
例：
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化
47. getattr() 返回一个对象属性值
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
48. map()根据提供的函数对指定序列做映射
例：
>>>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]
49. repr() 将对象转化为供解释器读取的形式（一个字符串会返回具体的编码格式）
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
50. xrange() 与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器
51. cmp()：比较大小
例：
cmp(80, 100) : -1
cmp(180, 100) : 1
cmp(-80, 100) : -1
cmp(80, -100) : 1
52. globals() 返回全局变量的字典
例：
>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': , '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
53. max() 求最大值
例：
max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
max([1, 3, 7, 10]) ： 10
54. reverse() 用于反向列表中元素
55. zip() 打包元祖列表，或者解压
例：
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
56. compile() 将一个字符串编译为字节代码
例：
>>>str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec') # 编译为字节代码对象
>>> c
at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
57. hasattr() 用于判断对象是否包含对应的属性
58. memoryview() 返回内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问（很少用到吧）
59. round() 返回浮点数x的四舍五入值
60. __import__() ：动态导入模块--具体如何啥场景需要再研究
61. complex() ：构建一个复数
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 数字
(1 + 0j)
>>> complex("1") # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
62. hash()
例：
>>>hash('test') # 字符串
2314058222102390712
>>> hash(1) # 数字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
63. min() 最小值
64. set() 集合操作
例：
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除
>>> x & y # 交集
set(['o'])
>>> x | y # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y # 差集
set(['r', 'b', 'u', 'n'])
65. delattr()
例：
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)
66. help() 用于查看函数或模块用途的详细说明
67. next() 返回迭代器的下一个项目
例：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
68. setattr() 设置一个属性，也可以用来设置新的属性
例：
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5) # 设置属性 bar 值
>>> a.bar
69. dict() 构造一个字典
例：
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
70. hex() 用于将10进制整数转换成16进制
71. object()
72. slice() 构建切片的方法
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
73. dir() 返回模块的属性列表
例：
>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
74. id() 用于获取对象的内存地址
例：
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
75. oct() 将一个整数转换成8进制字符串
76. sorted() 对所有可迭代的对象进行排序操作
注意：sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a) # 保留原列表
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2]) # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
77. 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