Python(2.x) 基础知识总结_python2.x-CSDN博客

本文链接：https://blog.csdn.net/wubinghengajw/article/details/53416277

* Python(2.x) 基础知识总结 *

数据类型

Python的变量无需声明数据类型，用一个变量名直接赋值，类型被设置为所赋值的数据类型，可以利用
* type(变量名) * 函数查看其类型。

一、数值

小数用浮点数表示，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小
数点位置是可变的。浮点数可以用数学写法，如1.23，-9.01，等等。但是对于很大或很小的浮点数，
就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成
1.2e-5，等等。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运
算则可能会有四舍五入的误差。
Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数，对于整数除法，即
使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数：

11 % 4    # ==> 3

如果我们要计算 11 / 4 的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的
法则，把两个数中的一个变成浮点数再运算就OK：

11.0 / 4    # ==> 2.75

二、字符串

字符串是以 ” 或 “” 括起来的任意文本，比如 ‘abc’ ，”xyz” 等等。请注意，”
或 “” 本身只是一种表示方式，不是字符串的一部分，因此，字符串 ‘abc’ 只有a，b，c这3个字符。
当字符串本身包含 "" 时，使用 '' 进行包含，但是如果同时包含了 '' 以及其
他特殊字符（如，换行符\n）时，就只能通过转义符 \ 来转义了，例如：

'Bob said \"I\'m OK\".'

raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免
这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，**里面的字符就不需要
转义了**。例如：

r'\(~_~)/ \(~_~)/ abcdefg'    # \(~_~)/ \(~_~)/ abcdefg

但是我们却发现 r'...' 表示法不能表示多行字符串，也不能表示包含’和 “的字符串，那么如果要
表示多行字符串，可以用 '''...''' 表示：

'''Line 1
Line 2
Line 3'''
# 上面这个字符串的表示方法和下面的是完全一样的：
'Line 1\nLine 2\nLine 3'
# 还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串：
r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

三、布尔值

一个布尔值只有True、False两种值。在Python中，直接用True、False表示布尔值（注
意首字母大写），也可以通过布尔运算计算出来。
布尔运算
1. and——与运算，只有所有都为 True，and 运算结果才是 True。
2. or ——或运算，只要其中有一个为 True，or 运算结果就是 True。
3. not——非运算，它是一个单目运算符，把True变成 False，False 变成 True。

四、空值

空值是Python里一个特殊的值，用None表示（注意首字母大写）。None不能理解为0，因
为0是有意义的，而None是一个特殊的空值。

打印输出

在交互环境下：

     >>> print 'hello, world'    # 得到 hello, world

使用 '' 包含字符串，其中的所有字符依次打印，如果是输出变量的话则不需要 ''直接

    >>> print a, b, c     # a, b, c 为三个变量，逗号为多个值之间的分隔符，会被打印成空格  
    >>> print a + ' ' + b + ' ' + c     # 与上述的效果一样，''中包含的是空格
    >>> print 1 + 2 + 3     # 也可以直接做运算，得到 6

在程序中也是直接使用 print 打印输出，也可以使用 print() 函数来打印

变量

Python是一种动态语言，前面讲其变量无需声明数据类型，事实上，其变量的类型不固定，可以由所赋的
值更改。例如：

a = 123    # a是整数
print a
a = 'imooc'   # a变为字符串
print a

在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。在Python程序中，变量是用一个变量名
表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头，比如：

a = 1   # 变量a是一个整数。
t_007 = 'T007'    # 变量t_007是一个字符串。

编码问题

通过自己使用过程中遇到的一些问题以及一些经验，觉得这个编码问题相当重要，一定要讲一讲。
我们知道世界上计算机是从美国诞生的，美国的语言是英语，设计的语言自然也是英语，
就跟我们今天编程使用英文字母一样（个人觉得没什么不妥），因此最初的计算机语言为了处理文本采
编码表被称为ASCII编码，应该很熟悉了，使用8个比特表示一个字节，这样就一共能表示256个符号，
但是如果要表示中文，中华文化博大精深，汉字这么多，使用一个字节的编码这显然是不够的，于是中
国就制定了GB2312编码，两个字节表示一个汉子，用来把中文编进去，后来在GB2312的基础上创建了一
种叫GBK的编码，同时收录了主要的少数名族文字，同样兼容ASCII编码。这也就是我们常说的什么
中文两个字节（可是一定不要把这个当成固定思维）。
事实上，不止中文需要解决这样的问题，全世界各地区的语言为了能在计算机中表示都必
须有可使用的编码，还不能冲突。为了统一所有文字的编码，**
Unicode **应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为
0就可以。因为Python的诞生比Unicode标准发布的时间还要早，Python后来才添加对Unicode的支持，
因此Python的默认编码就是ASCII编码（一定要记住这点，程序中很容易出现这个问题）
Python中以Unicode表示的字符串用 u'...' 表示，比如：

>>> print u'中文'
中文

该使用方法对转义字符、多行及raw表示法不影响，同时使用raw+多行表示法：
（使用raw的Unicode：ur''）

ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''

在这里还需要搞清楚的是，Unicode是一种编码方式或者说统一编码标准，但是其实现方
式有多种，最著名的就是我们最常见到的UTF-8了，它是一种变长的字符编码，可以根据具体情况用
1-4 个字节来表示一个字符。因此我前面说不要以为中文汉字就一定是两个字节，在这里可就不一定了。
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可
以在第一行添加注释，目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为
… 并选择UTF-8格式保存。

# -*- coding: utf-8 -*-

现在可以梳理一下什么叫编码了，就是把我们想要表示的文字用特定的编码方式存在计算
机里，那我们想要计算机显示出来就要以该编码方式对应的解码方式将其解释出来，比如Unicode编码，
以UTF-8方式实现编码，那我们就需要指定这种方式将其解释出来才能看到正确的信息（文件的编码格式
可以通过用Notepad++ 软件打开查看其格式），否则编码解码方式不一致就是乱码。
在python中，在处理含有中文（或其他文字）的源程序中，一定要指明具体编码，下面是
通过导入 sys 模块查看其默认编码，显示为’ascii’码：

    >>> import sys
    >>> sys.getdefaultencoding()
    'ascii'

在程序中，也可以通过这种方式设置默认编码，例如，使用GBK的中文编码方式时：
（一般当程序执行出现错误提示信息包含’ascii’时就是由于默认编码问题）

import sys
sys.setdefaultencoding('gbk')   # utf-8编码时即sys.setdefaultencoding('utf-8')

在 Python 中，和字符串相关的数据类型，分别是 str、unicode 两种类型，他们都是
basestring的子类，可见 str 与 unicode 是两种不同类型的字符串对象。str 表示的一般是操作系
统相关的默认编码格式，windows下和linux下也是不同的。例如在Linux下，汉字“中文”，用 str 表示
时，它对应的就是 UTF-8 编码’\xe4\xb8\xad\xe6\x96\x87’，在Windows下可能对应的就是 GBK 编
码’\xd6\xd0\xce\xc4’。而用 Unicode 表示时，它对应的符号就是u’\xd6\xd0\xce\xc4’。

    >>> b = u'中文'
    >>> type(b)
    <type 'unicode'>
    >>> b
    u'\xd6\xd0\xce\xc4'

str与unicode转换

str(s) 和 unicode(s) 是两个方法，分别返回str字符串对象和Unicode字符串对象，
默认编码为ASCII时，unicode(s)是s.decode(‘ascii’)的简写，str(s)是s.encode(‘ascii’)
的简写。因此如果字符串 s 的编码格式不是 ASCII时，执行这条语句就会报错，例如：

    >>> b = u'中文'
    >>> type(b)
    <type 'unicode'>
    >>> b
    u'\xd6\xd0\xce\xc4'
    >>> str(b)

    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        str(b)
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-3: ordinal not in range(128)

必须执行b.encode(‘utf-8’):

    >>> b.encode('utf-8')
    '\xc3\x96\xc3\x90\xc3\x8e\xc3\x84'
但是如果打印输出b.encode('utf-8')，你发现是乱码，这说明 unicode 和 utf-8 确实不是一回事：
    >>> print b.encode('utf-8')
    脰脨脦脛

刚是从unicode转换为str，使用encode，现在我们从str转换为unicode，使用decode：

    >>> a = '中文'
    >>> print a
    中文
    >>> type(a)
    <type 'str'>
    >>> decode(a)

    Traceback (most recent call last):
      File "<pyshell#34>", line 1, in <module>
        decode(a)
    NameError: name 'decode' is not defined
    >>> a.decode('gbk')
    u'\u4e2d\u6587'
&emsp;&emsp;对于如 Unicode 形式的字符串（str 类型)：
    >>> s = 'id\u003d215903184\u0026index\u003d0'
    >>> print s
    id\u003d215903184\u0026index\u003d0
    >>> type(s)
    <type 'str'>
    >>> s = s.decode('unicode-escape')
    >>> type(s)
    <type 'unicode'>
    >>> print s
    id=215903184&index=0

## Python 列表和元组
在Python中，列表和元组是两种内置的重要数据类型，可以用来直接处理集合。

列表list

list是一种有序的集合，可以随时添加和删除其中的元素。list是数学意义上的有序集合，也就是说，list中的元素是按照顺序排列的。构造list非常简单，直接使用 [] 就可以创建一个包含很多元素的列表，元素之间用逗号隔开。由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种类型数据，（这与C语言的数组集合是有区别的，大多时候其实也是优点）。我们可以将列表赋给一个变量，然后就可以通过变量来引用列表中的任何一个元素。例如：

    >>> li = ['abc', 'def', 50, 60, True, False]
    >>> print li
    ['abc', 'def', 50, 60, True, False]
    >>> lis = []
    >>> print

    # 列表lis没有赋值，所以为空
    >>> temp = li
    >>> print temp
    ['abc', 'def', 50, 60, True, False]
    >>> print temp[0], temp[3], temp[5]
    abc 60 False    # 输出第一、三、五个元素的值

上述已经展示了通过变量访问元素，即使用[]包含索引，Python列表的索引是从0开始的，这一点同C语言的数组一样，但其实Python的列表还可以通过倒序的方式来访问，倒数第一个索引就是-1，以此类推，不能越界。还可以利用索引访问某一区间的元素。例如：

    >>> number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> print number[-1]
    9
    >>> print number [0:-3]
    [1, 2, 3, 4, 5, 6]
    >>> print number[3:-3]
    [4, 5, 6]
    >>> print number[0:7:2]   # 对列表进行切片访问，[::]可以设置起始位置、结束位置、步长（可不设置，默认为1），元组也是如此
    [1, 3, 5, 7]

添加删除元素

Python列表中对数据类型的基本操作都是利用其内置的方法，对列表也不例外，当我们需要删除或者添加某一列表中的元素时只需要调用该列表的相应方法，例如：

    >>> number = [1, 2, 3, 4, 5, 6]
    >>> number.append(7)    # 使用append()在末尾添加元素
    >>> print number
    [1, 2, 3, 4, 5, 6, 7]
    >>> number.insert(3, 'abc')   # 使用insert()在索引位置插入元素
    >>> print number
    [1, 2, 3, 'abc', 4, 5, 6, 7]
    >>> number.pop(0)     # 使用pop()将列表中索引位置的元素删除，需要注意的是每pop一个元素，原来列表中在被删除元素后面的元
    # 素的索引就会发生改变，即删除元素过程中，后面的元素依次向前移动
    1
    >>> number.pop(2)
    'abc'
    >>> print number
    [2, 3, 4, 5, 6, 7]
    >>> number[3] = 'def'   # 对列表替换元素直接赋值
    >>> print number
    [2, 3, 4, 'def', 6, 7]

元组tuple

tuple是另一种有序的列表，。tuple 和 list 非常类似，不同的是tuple一旦创建完毕，就不能修改了。另外，tuple在创建时使用的是 ()，而不是 []，其获取其中元素的方法和list相同，但是不能进行增删改。由于tuple用 () 表示的特殊性，因此使用时需要注意的是当创建单元素 tuple 时需要在这个元素后面添加一个逗号，因为否则Python解释器会将()当作一个提高优先级的符号。还有一个有趣的现象是，当tuple中包含list时，元素就“可变”了。

    >>> tu = (1,)
    >>> tup = (1, 2, 3)
    >>> print tu[0]
    1
    >>> tup[2] = 5

    Traceback (most recent call last):
      File "<pyshell#36>", line 1, in <module>
        tup[2] = 5
    TypeError: 'tuple' object does not support item assignment
    >>> tupl = (1, 2, 3, [4, 5, 6])
    >>> print tupl[3]
    [4, 5, 6]
    >>> tupl[3][0] = 'abc'      # 因为tupl[3]是列表，实际上是列表中的值改变了
    >>> tupl[3][1] = 'def'
    >>> print tupl[3]
    ['abc', 'def', 6]

Python Dict 和 Set

Python中还有两种及其重要的内置数据类型，就是dict和set。尤其是dict，在Python中称之为字典。

字典dict

dict就是用来表示键值对的一种数据类型，这在许多编程语言里都是一种很重要的数据格式，只不过叫法不同，例如 JSON 就是以这种键值对方式存储数据的一种非常重要的轻量级数据交换格式。所谓键值对就是每一组数据由一个‘key’和一个‘value’来表示，组键值对之间使用逗号隔开，然后可以通过‘key’查找到其对应的值。在Python中，使用花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
dict也是一种列表，只不过区别在于它不是利用从0到n标识的有序列表，而是通过自己定义的索引 key 来访问特定值，dict的you点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样，但是这是其牺牲了较大内存换来的。

    >>> d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
    >>> print 'Adam:',d.get('Adam')   # 可以利用get()这种方法来访问元素
    Adam: 95
    >>> print d.get('Lisa')
    85
    >>> print d['Bart']   # 因为字典也是一种列表，也可以直接利用索引的方式来访问
    59
    >>> print d.get('anc')    # 当访问的key不存在时返回None
    None
    >>> print 'Paul' in d     # 可以通过 in 判断字典是否存在某个 key
    False
    >>> d['Paul'] = 80    # 直接添加元素，修改元素值也是直接制定要修改的key和value即可
    >>> print d
    {'Lisa': 85, 'Paul': 80, 'Adam': 95, 'Bart': 59}
    >>> for key in d:
        print key,':',d[key]    # 通过for循环可以很轻松地遍历所有值，只需使用in关键字制定字典，循环变量无需声明，遍历列表也
        # 如此。

    Lisa : 85
    Paul : 80
    Adam : 95
    Bart : 59

set

set 同样持有一系列元素，但是重要的set的元素没有重复，也不允许重复，而且是无序的。创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

s = set([‘A’, ‘B’, ‘C’])
由于set存储的是无序集合，所以我们没法通过索引来访问。set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。根据set的这些特点，set可以用来设置合法值的范围，然后用来和外部值进行比对，从而判断外部值的合法性，比如接受用户输入的月份英文单词，为了检查是否正确合法，提前使用一个set将所有的月份英文单词存储起来，然后将每一个输入的值进行判断，是否存在于该set中，判断是否存在的关键词就是前面提到的 in 。
set中的值是可以进行增加和删除的，利用remove()和add()方法就可以做到。

条件和循环

Python中的条件判断和循环与C语言的类似，都是 if-else 和 for、while 等，只是Python的写法更为简洁，例如不需要花括号 {} 的包含，而采用控制提示符号 : 加执行部分四个字符的缩进的方式，也可采用break 退出循环使用continue继续下一个循环。Python中本身没有switch这样的多条件语句，多条件判断时采用elif(即else if)的反式，或者利用其他函数的方式自己构造实现。
在Python循环中有个常用的方法range()，这个函数实现的功能就是生成一个限定范围内的列表：

    >>> range(1, 10)    # 从0开始生成小于10的列表，默认步长为1，也可以通过设置第三个参数来设置步长
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print [x*(x+1) for x in range(1, 100, 5)] # 步长为5，这种写法就是Python特有的列表生成式，这种方法可以很简单地生成list
    [2, 42, 132, 272, 462, 702, 992, 1332, 1722, 2162, 2652, 3192, 3782, 4422, 5112, 5852, 6642, 7482, 8372, 9312]

迭代

在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。Python迭代是通过 for … in 来完成的，而很多语言比如C或者Java，迭代list是通过下标完成的。Python 的迭代不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。Python迭代永远是取出元素本身，而非元素的索引。对于有序集合，元素确实是有索引的，但对于无序集合想在 for 循环中拿到索引，方法是使用 enumerate() 函数，该函数将

    ['Adam', 'Lisa', 'Bart', 'Paul']

变成了形如

    [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

因此，迭代的每一个元素实际上是一个tuple：

    for t in enumerate(L):
        index = t[0]
        name = t[1]
        print index, '-', name

如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：

    for index, name in enumerate(L):
        print index, '-', name

迭代Dict

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    print d.values()
    # [85, 95, 59]
    for v in d.values():
        print v
    # 85
    # 95
    # 59

dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样。这两个方法的不同之处在于
1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
当需要同时迭代key和value时， dict 对象的 items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

    >>> for key, value in d.items():
    ...     print key, ':', value
    ...
    Lisa : 85
    Adam : 95
    Bart : 59

和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

函数

同其他编程语言一样，函数始终是一种重要的概念。我们前面提到的列表的一些方法其实就是内置的函数，现在我们已经知道如何调用，那么更重要的是如何编写自己需要的函数。在Python中，编写函数的方法同样很简单，就是使用关键字 def 声明函数名加参数，然后使用一个提示符号 : ，函数体使用四个字符缩进，就可以完成一个函数的编写，如果需要返回值的话，可以使用 return 进行返回，其他概念与C语言类似，比如定义默认参数、比如递归，编写方法大同小异。

    >>> def square_of_sum(L):
            sum = 0
            for x in L:
                sum = sum + x*x
            return sum
    >>> print square_of_sum([1, 2, 3, 4, 5])
    55
    >>> def average(*args):   # 定义可变参数，形成一个参数列表
    if len(args)!=0:
        return sum(args)*1.0/len(args)    # sum()对列表元素求和，len()求列表长度
    else:
        return 0.0
    >>> print average(1, 2)
    1.5
    >>> print average(1, 2, 2, 3)

lamba表达式

lamba是一种特殊的函数——匿名函数，即函数没有具体的名称，与 def 创建的函数有所不同。实际上：
1. lambda只是一个表达式，函数体比def简单很多。
2. lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
3. lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
lambda语法：

lambda [arg1[,arg2,arg3....argN]]:expression

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边定义返回值。lambda语句构建的其实是一个函数对象。

    >>> print lambda:'abcdef'   # 无参数的lamba
    <function <lambda> at 0x02DD43F0>
    >>> add2 = lambda x,y:x+y   # 有参数的lamba
    >>> print add2(1,2)
    3
    >>> sum2 = lambda x,y=10:x+y    # 设置默认参数
    >>> print sum2(1)
    11
    >>> print sum2(1,100)   # 自行传递参数，修改默认值
    101