1. python的优势

• 首选是网络应用，包括网站、后台服务等等；
• 其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
• 另外就是把其他语言开发的程序再包装起来，方便使用。

2. 缺点

• 运行速度相对慢
• 程序是明文，不能加密

3. 多行字符串'''...'''还可以在前面加上r使用

4. 逻辑运算 and、or、not和空值None

python的整数和浮点数都没有大小的限制

5. 字符编码（注意：python2中字符串默认不是unicode，与设置的编码一致）

• 用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件
• 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器，所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息，表示该网页正是用的UTF-8编码。

image

image

• 如果知道字符的整数编码，还可以用十六进制这么写str：这样写和写字符串一致，因为写了字符串，python3默认会用utf-8解码，变量用unicode存储。

>>> '\u4e2d\u6587'
'中文'

6. Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符

7. 注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节

8. 编码（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 "<stdin>", line 1, in <module>
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)
<module 'sys' (built-in)>
>>> print sys.getdefaultencoding()
ascii

2. 
>>> zhongwen = '中文'
>>> type(zhongwen)
<type 'str'>
>>> len(zhongwen)
6
>>> sys.setdefaultencoding('utf-8')
>>> len(zhongwen)
6

>>> zhongwen_uni = u'中文'
>>> type(zhongwen_uni)
<type 'unicode'>
>>> 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)
<type 'str'>
# 原始输入（终端输入格式为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 "<stdin>", line 1, in <module>
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)
    
    
    #输出
    <type 'callable-iterator'>
    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__': <module '__builtin__' (built-in)>, '__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
    <code object <module> 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