• Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。
    • 每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
    • 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
    • 等号（=）用来给变量赋值。
    • 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

    多个变量赋值

    Python允许你同时为多个变量赋值。例如：

    以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
    您也可以为多个对象指定多个变量。例如：

    1. a, b, c = 1, 2, "john"

    以上实例，两个整型对象1和2的分配给变量a和b，字符串对象”john”分配给变量c。

    常量

    所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。通常用大写字母表示常量。示例：

    1. PI = 3.14159265359

    与PHP、JAVA的常量不一样，Python本身并没有提供常量这一机制。也就是说，在Python里，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

    数据类型

    Python提供的基本数据类型主要有：布尔类型、整型、浮点型、字符串、列表、元组、集合、字典等等。

    Python有五个标准的数据类型：

    • Numbers（数字）
    • String（字符串）
    • List（列表）
    • Tuple（元组）
    • Dictionary（字典）

    Python数字类型是不可改变的数据类型。

    Python支持四种不同的数字类型：

    • int（有符号整型）
    • long（长整型[也可以代表八进制和十六进制]）
    • float（浮点型）
    • complex（复数）
    1. # 整数
    2. int=20;
    4. # 浮点数
    5. float=2.3;
    7. print(int)
    8. print(float)
    9. print(pow(2,5))
    10. print(2**5)

    输出：

    1. 20
    2. 2.3
    3. 32
    4. 32

    字符串(str)

    a、使用单引号(‘)
    用单引号括起来表示字符串，例如：

    1. str='this is string';
    2. print(str);

    b、使用双引号(“)
    双引号中的字符串与单引号中的字符串用法完全相同，例如：

    1. str="this is string";
    2. print(str);

    c、使用三引号(‘’’)
    利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号，例如：

    1. str='''this is string
    2. this is python string
    3. this is string'''
    5. print(str);

    当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

    加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

    1. #!/usr/bin/python
    2. # -*- coding: UTF-8 -*-
    4. str = 'Hello World!'
    6. print(str[0])        # 输出字符串中的第一个字符
    7. print(str[2:5])      # 输出字符串中第三个至第五个之间的字符串
    8. print(str[2:])       # 输出从第三个字符开始的字符串
    9. print(str * 2)       # 输出字符串两次
    10. print(str + "TEST")  # 输出连接的字符串

    以上实例输出结果：

    1. >>> print('I\'m ok.')
    2. I'm ok.

    如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：

    1. >>> print('\\\t\\')
    2. \       \
    3. >>> print(r'\\\t\\')
    4. \\\t\\

    字符串通过encode()方法可以编码为指定的bytes，例如：

    1. >>> 'ABC'.encode('ascii')
    2. b'ABC'
    3. >>> '中文'.encode('utf-8')
    4. b'\xe4\xb8\xad\xe6\x96\x87'
    5. >>> '中文'.encode('ascii')
    6. Traceback (most recent call last):
    7.   File "<stdin>", line 1, in <module>
    8. UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

    纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

    在bytes中，无法显示为ASCII字符的字节，用\x##显示。

    反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用方法：

    1. >>> b'ABC'.decode('ascii')
    2. 'ABC'
    3. >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    4. '中文'

    可以使用str()将其它类型转为字符串类型。

    列表(list)

    List（列表） 是 Python 中使用最频繁的数据类型。
    列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
    列表用[ ]标识。

    列表中使用切片操作符[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

    加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

    1. #!/usr/bin/python
    2. # -*- coding: UTF-8 -*-
    4. list = [ 'Hello', 786 , 2.23, 'john', 70.2 ]
    5. tinylist = [123, 'john']
    7. print(list)             # 输出完整列表
    8. print(list[0])            # 输出列表的第一个元素
    9. print(list[1:3])          # 输出第二个至第三个的元素 
    10. print(list[2:])           # 输出从第三个开始至列表末尾的所有元素
    11. print(tinylist * 2)       # 输出列表两次
    12. print(list + tinylist)    # 打印组合的列表

    以上实例输出结果：

    1. ['Hello', 786, 2.23, 'john', 70.2]
    2. Hello
    3. [786, 2.23]
    4. [2.23, 'john', 70.2]
    5. [123, 'john', 123, 'john']
    6. ['Hello', 786, 2.23, 'john', 70.2, 123, 'john']

    删除列表元素

    1. L=['spam', 'Spam', 'SPAM!'];
    2. del L[0]

    列表函数&方法

    1. len(list) 列表长度
    2. list.append(obj) 在列表末尾添加新的对象，相当于其它语言里的push
    3. list.count(obj) 统计某个元素在列表中出现的次数
    4. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    5. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
    6. list.insert(index, obj) 将对象插入列表
    7. list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
    8. list.remove(obj) 移除列表中某个值的第一个匹配项
    9. list.reverse() 反向列表中元素，倒转
    10. list.sort([func]) 对原列表进行排序

    元组(tuple)

    元组是另一个数据类型，类似于List（列表）。
    元组用()标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

    1. tup = ();
    2. tup1 = ('physics', 'chemistry', 1997, 2000);
    3. tup2 = (1, 2, 3, 4, 5 );
    4. tup3 = "a", "b", "c", "d";

    元组中只有一个元素时，需要在元素后面添加逗号，例如：tup1 = (50,);
    元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

    元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:

    元组中的元素值是不允许删除的，可以使用del语句来删除整个元组。

    1. cmp(tuple1, tuple2) 比较两个元组元素。
    2. max(tuple) 返回元组中元素最大值。
    3. min(tuple) 返回元组中元素最小值。
    4. tuple(seq) 将列表转换为元组。

    字典是一种无序存储结构，包括关键字（key）和关键字对应的值（value）。字典的格式为：dictionary = {key:value}。key为不可变类型，如字符串、整数、只包含不可变对象的元组，列表等不可作为关键字。字典也被称作关联数组或哈希表。

    示例：

    1. >>> dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

    字典操作：

    1. # 访问
    2. >>> dict['name']  
    3. 'Zara'
    4. >>> dict['age']  
    5. 7
    7. # 修改
    8. >>> dict['name'] = 'yjc'
    9. >>> dict['name']
    10. 'yjc'
    11. >>> dict["school"]="wutong"
    12. >>> dict["school"]
    13. 'wutong'
    16. del dict['name'];  # 删除键是'name'的条目
    17. dict.clear();  # 清空词典所有条目
    18. del dict ;  # 删除词典

    注意：字典不存在，del会引发一个异常。

    字典内置函数方法：

    1. cmp(dict1, dict2) 比较两个字典元素。
    2. len(dict) 计算字典元素个数，即键的总数。
    3. str(dict) 输出字典可打印的字符串表示。
    4. type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
    5. dict.clear() 删除字典内所有元素
    6. dict.copy() 返回一个字典的浅复制
    7. dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
    8. dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
    9. dict.has_key(key) 如果键在字典dict里返回true，否则返回false
    10. dict.items() 以列表返回可遍历的(键, 值) 元组数组
    11. dict.keys() 以列表返回一个字典所有的键
    12. dict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
    13. dict.update(dict2) 把字典dict2的键/值对更新到dict里
    14. dict.values() 以列表返回字典中的所有值

    集合(set)

    集合(set)和字典(dict)类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

    要创建一个set，需要提供一个list作为输入集合：

    1. >>> s = set([1, 2, 3])
    2. >>> s
    3. {1, 2, 3}

    注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

    重复元素在set中自动被过滤：

    1. >>> s = set([1, 1, 2, 2, 3, 3])
    2. >>> s
    3. {1, 2, 3}

    set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

    1. >>> s1 = set([1, 2, 3])
    2. >>> s2 = set([2, 3, 4])
    3. >>> s1 & s2
    4. {2, 3}
    5. >>> s1 | s2
    6. {1, 2, 3, 4}

    set 常用方法：

    1. s.add(key)
    2. s.remove(key)

    布尔类型(bool)

    在Python中，None、任何数值类型中的0、空字符串""、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了__nonzero__()或__len__()方法且方法返回0或False，则其实例也被当作False，其他对象均为True。

    布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，False，在Python中，可以直接用True、False（请注意大小写），也可以通过布尔运算计算出来：

    1. >>> True
    2. True
    3. >>> False
    4. False
    5. >>> 3 > 2
    6. True
    7. >>> 3 > 5
    8. False

    布尔值可以用and(与)、or(或)和not(非)运算（逻辑运算符，并不是位运算符）：

    空值(None)

    表示该值是一个空对象，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。