变 量
3.1 引用变量----使用数据名称
给名称赋值：名称一般叫做变量，表明它们引用的数据可以变化，而名称保持不变。您会看到变量也叫做名称（name），这是Python的叫法。
>>> first_string = "This is a string"
>>> second_string = "This is another string"
>>> first_number = 4
>>> second_number = 5
>>> print ("The first variables are %s,%s,%d,%d" % (first_string , second_string , first_number , second_number))
The first variables are This is a string,This is another string,4,5示例说明：
可以用等号（=）将一个值（字符串或者整型数）与名称关联。所用的名称并不与所指的数据直接相关（如果将一个数据命名为“number”，并不意味着它实际保存了一个数值）
>>> first_string = 245
>>> second_number = "This isn't a number"
>>> print(first_string)
245
>>> print(second_number)
This isn't a number注意：仅希望将一个变量的值打印出来时并不需要使用引号。如果在print()函数中将一个变量用引号括起来，函数会打印出这个变量的名称，而不是它的内容，因为程序把它看做一个字符串而不是一个变量。
3.1.1 使用名称修改数据
>>> first_string = "a pen"
>>> first_string = first_string + " b pen"
>>> print(first_string)
a pen b pen >>> first_number = 0
>>> first_number = first_number + 1
>>> print(first_number)
1无论何时，在等号右端使用已命名的值时，即使同样的名称在左端，Python仍将这些名称看做它们引用的值。先对右端名称求值并计算结果，然后将结果赋值给左边的名称。
3.1.2 复制数据
>>> first_number = 1
>>> second_number = first_number
>>> print(second_number)
1
>>> first_number = first_number + 1
>>> print(first_number)
2
>>> print(second_number)
1给数据起名称仅仅是个名称，是表示要访问的数据的一种方法，可以用多个名称引用一个数据。当再次使用“=”时，就给名称赋值一个已创建的新值，而另一个名称仍然指向原来的值
3.1.3禁用名称和规则
Python 保留词，不可以用作数据的名称： and,as,assert,break,class,continue,def,elif,else,except,exec,False,finally,for,from,global,if,import,in,is,lambda,not,None,or,pass,print,raise,return,try,True,while,with,yield
另外，数据名称不能以数值或者多数非字母的字符开头（例如逗号、加减号、斜杠等），但下划线例外，是合法的。
3.2 内置类型
除了字符串和数值外，Python还提供了另外的4种基本类型：元组、列表、集合、字典。4种类型有很多共同点，都容许在一个名称下面组织多条数据。这些组织在一起的数据通过圆括号()、方括号[]、花括号{}表示。
3.2.1 元组-----不可更改的数据序列
元组是Python的基本类型，元组是值的序列，其中每个值都可以被单独访问，在创建时就可以识别出元组，因为它们被圆括号包围:
>>> filler = ("string","filled", "by a", "tuple")
>>> print(filler)
('string', 'filled', 'by a', 'tuple')元组包含对数据的引用，例如对字符串和数值的引用。虽然它们引用数据，但是仍然可以向其他类型的数据一样为它们命名。可以通过print()函数中调用元组，打印出其中的数据。元组的处理方式就好像输入一个序列来满足给定的格式规范。
>>> a = ("first" , "second" , "third")
>>> print("This is %s" % a[1])
This is second
>>> print("This is %s" % a[0])
This is first
>>> print("This is %s" % a[2])
This is third >>> print("%d" % len(a))
3 >>> print(a[len(a) -1])
third每个元素通过该语言的解除引用特性直接访问，通过在元组的名称后放置方括号并且从零起，因此，元组的第一个元素位置为0，第二个为1，以此类推到最后一个元素。
元组想知道包含元素的数目，可以使用内置函数len得到。返回的数目（此处为3），因此需要牢记len函数从1开始计数。当访问元组时，由于元组从0开始，所以必须在len返回的数小1的位置停止访问。
通过一个元组访问另外一个元组
>>> a = ("first" , "second" , "third")
>>> b = (a , "b's second element")
>>> print("%s" %b[1])
b's second element
>>> print("%s" %b[0][0])
first
>>> print("%s" %b[0][1])
second
>>> print("%s" %b[0][2])
third创建元组a和b ，这种情形下，代码的工作原理仿佛是先遵循元组b的第一个元素的引用，之后遵循第二层元组中的每个值的引用（第二层的元组最初来源于元组a）。若创建一个元素的元组，必须在该元素之后加一个逗号(,)负责就会创建一个字符串。
报错：TypeError 该类型并不支持此操作
IndexError 引用元组中并不存在的元素
3.2.2 列表-----可以更改的数据列表
列表如同元组，是包含从0开始引用的元素的序列。列表用方括号创建：
>>> breakfast = ["coffee" , "tea" , "toast" , "egg"]
>>> count = 0
>>> print("Today's breakfast is %s" % breakfast[count])
Today's breakfast is coffee
>>> count = 3
>>> print("Today's breakfast is %s" % breakfast[count])
Today's breakfast is egg使用列表和元组主要区别：元组在创建后不可以修改，列表在任何时候都可以被修改
>>> breakfast[count] = "sausages"
>>> print("Today's breakfast is %s" % breakfast[count])
Today's breakfast is sausages不仅可以修改已经存在的元素，还可以通过列表类型内置方法append向列表末端添加元素，利用append方法每次只能向列表末端添加一个元素：
>>> breakfast.append("waffle")
>>> count = 4
>>> print("Today's breakfast is %s" % breakfast[count])
Today's breakfast is waffle如果想一次性向列表末端添加多个元素，使用extend方法，添加的列表并不是整体作为原有列表的一个元素，相反，其中的每个元素将被复制到原来的列表中。
>>> breakfast.extend(["juice" , "decaf"])
>>> print(breakfast)
['coffee', 'tea', 'toast', 'egg','waffle', 'juice', 'decaf']列表的长度也通过len函数确认，跟元组一样，长豆从1开始，而列表的第一个元素位置从0开始。这一点非常重要
报错：IndexError:list index out of range 出错消息与元组略有不同，指出列表索引超出范围，不是元组超出范围。
3.2.3 字典-----以名称索引的分组数据
字典类似于列表和元组。包含一组数据的另外一种容器。然而，元组和列表以数字顺序索引，字典却用选择的名称索引。名称可以是字母、数值、字符串或者符号。字典用花括号创建。
>>> menu_specials = {"breakfast" : "sausage and eggs" , "lunch" : "split pea soup and garlic bread" , "dinner" : "2 hot dogs and onion rings"}
>>> print(menu_specials)
{'breakfast': 'sausage and eggs', 'lunch': 'split pea soup and garlic bread', 'dinner': '2 hot dogs and onion rings'}
>>> print("%s" % menu_specials["breakfast"])
sausage and eggs
>>> print("%s" % menu_specials["lunch"])
split pea soup and garlic bread
>>> print("%s" % menu_specials["dinner"])
2 hot dogs and onion rings使用字典时，索引和值都有特殊的名称。字典中索引的名称叫做键，对应的值叫做值。创建一个完全指定的字典，必须在花括号之间指定每个键以及和它对应的值，并以冒号分隔它们。打印某个字典所有的键和值，只需将该字典的名称作为print()函数的参数，也可以将键放在方括号中，如果键是字符串，需要将键放在引号中。如果键是数值，仅使用数值就可以了。
如果键是一个字符串，但是在方括号中意外地没有将键放在引号中，Python就试图将它看做一个名称，需要解除对它的引用来找到键。大部分情况下，将引起NameError异常，除非凑巧找到一个与该字符串相同的名称，又可能得到一个IndexError错误。
>>> hungry = menu_specials.keys()
>>> print(list(hungry))
['breakfast', 'lunch', 'dinner']
>>> starving = menu_specials.values()
>>> print(list(starving))
['sausage and eggs', 'split pea soup and garlic bread', '2 hot dogs and onion rings']keys方法要求字典以视图的方式返回所有键，以便用户查找所需的键，values方法也将以视图的形式返回所有的值。
>>> menu = {"breakfast" : "spam" , "lunch" : "spam" , "dinner" : "spam with a side of spam"}
>>> print(menu)
{'breakfast': 'spam', 'lunch': 'spam', 'dinner': 'spam with a side of spam'}
>>> menu.get("lunch")
'spam'
>>> menu.get("breakfast")
'spam' >>> menu2 = {"breakfast" : "spam" , "breakfast" : "ham" , "dinner" : "spam with a side of spam"}
>>> menu2.get("breakfast")
'ham'字典的工作原理是每个键都是不同的（不可以又完全相同的俩个键），但是可以有多个重复的值，menu2输入第二个“breakfst”的键时，Python替换了相同名称的第一个键的值。
3.2.4 像列表一样处理字符串
>>> last_names = ["Douglass" , "Jefferson" , "Williams" , "Frank" , "Thomas"]
>>> print("%s" % last_names[0])
Douglass
>>> print("%s" % last_names[0][0])
D
>>> print("%s" % last_names[1])
Jefferson
>>> print("%s" % last_names[1][0])
J >>> by_letter = {}
>>> by_letter[last_names[0][0]] = last_names[0]
>>> by_letter[last_names[1][0]] = last_names[1]
>>> by_letter[last_names[2][0]] = last_names[2]
>>> by_letter[last_names[3][0]] = last_names[3]
>>> by_letter[last_names[4][0]] = last_names[4]
>>> print(by_letter)
{'D': 'Douglass', 'J': 'Jefferson', 'W': 'Williams', 'F': 'Frank', 'T': 'Thomas'}可以根据字符串的字母顺序将字典中的元素以姓的首字母分组，并以此对名字归档。
通过字符串的分片功能，字典by_letter 仅包含了所有姓的首字母。因此，by_letter根据每个姓的首字母索引的字典。
3.2.5 特殊类型
Python包含几个特殊类型，None、True和False都是特殊的内置值，可以在不同的时刻发挥作用。
None比较特殊，因为仅有一个None。无论使用多少次，它都是一个名称，除了它本身没有任何其他对象与之匹配。如果函数没有可返回的值，即函数没有可以响应的动作时，返回None。
True和False是数值0和1的特殊表示，Python通过显式地命名这些值，使得区分这些值变得更容易。
>>> True
True
>>> False
False
>>> True == 1
True
>>> True == 0
False
>>> False == 0
True
>>> False == 1
False
>>> False > 0
False
>>> False < 1
True3.3 序列的其他共有属性
3.3.1 引用最后一个元素
经常需要知道一个序列最后一个元素的内容，有两种方法可以得到该消息。
一、获取列表中元素的个数，之后用该数直接访问值：然而，这个方法分两步，作为程序员，重复在程序中输入这些代码非常耗时。
>>> last_names = ["Douglass" , "Jefferson" , "Williams" , "Frank" , "Thomas"]
>>> len(last_names) 获取元素个数
5
>>> last_element = len(last_names) - 1
>>> print ("%s" % last_names[last_element])
Thomas二、可以通过使用数值-1访问一个序列的最后一个元素，使用数值-2访问倒数第二个元素，通过使用数-1到负的列表长度（在last_names列表中是-5），可以将列表的顺序颠倒过来。
>>> print("%s" % last_names[-1])
Thomas
>>> print("%s" % last_names[-3])
Williams3.3.2 序列的范围
您可以获取序列的一部分，从中提取一个片段，创建一个单独使用的副本。创建这些分组的方法叫做分片。当一个列表或者元组中创建一个片段时，得到的片段与创建该片段的数据类型一致。
>>> slice_me = ("The" , "next" , "time" , "we" , "meet" , "drinks" , "are" , "on" , "me")
>>> sliced_tuple = slice_me[5:9]
>>> print(sliced_tuple)
('drinks', 'are', 'on', 'me')
>>> slice_string = "The next time we meet , drinks are on me"
>>> slice_str = slice_string[5:9]
>>> print(slice_str)
ext在每种情形下，用冒号指定序列的一个片段指示Python创建一个新的序列，新序列恰好包含了片段中的元素。
3.3.3 通过附加序列增长列表
假如希望两个列表连接到一起。使用append方法向列表中添加一个分层的序列。
>>> living_room = ("rug" , "table")
>>> apartment = [1]
>>> apartment.append(living_room)
>>> apartment
[1, ('rug', 'table')] 如果想复制一个序列中所有元素，可以使用extend方法，而不是append方法，extend方法将给定序列中的每个元素插入到调用它的列表中。
>>> apartment = [1]
>>> apartment.extend(living_room)
>>> apartment
[1, 'rug', 'table']3.3.4 使用列表临时存储数据
经常需要从其他来源获取数据，在处理完数据之后，不再需要将这些数据保存在列表中，例如：特定时间有效的信息。为了防止列表变得笨重，可以使用pop方法在处理完列表的一个数据之后，将其引用在列表中删除。当删除引用之后，它原来的在列表中的位置会填上后续元素，列表减少的元素个数等于已经弹出的元素个数。
pop所操作的元素与使用方括号访问的列表元素具有相同的索引（记住，列表中第一个元素的位置是0）
>>> today_temp = [23 , 32 , 33 , 31]
>>> today_temp.append(29)
>>> today_temp
[23, 32, 33, 31, 29]
>>> morning = today_temp.pop(0)
>>> print("This mornings temp was %.02f" % morning)
This mornings temp was 23.00
>>> late_morning = today_temp.pop(0)
>>> print("This mornings temp was %.02f" % late_morning)
This mornings temp was 32.00
>>> today_temp
[33, 31, 29]
>>> late2_morning = today_temp.pop(1)
>>> print("This mornings temp was %.02f" % late2_morning)
This mornings temp was 31.00
>>> today_temp
[33, 29]
通过只使用pop填充字符串格式，可以避免使用中间名称，因为pop将返回列表中指定元素，可以像已经指定一个数值或者引用一个数值的名称那样使用该元素。如果没有告诉pop要删除列表的哪个元素，它将删除列表中的最后一个元素。
3.3.5 处理集合
Python中，集合与字典类似，只是它仅包含键，而没有与键相关联的值。本质上，集合是不包括重复数据的数据集，在从数据删除重复数据时，集合非常有用。
有两种类型的集合：可变集合与不可变集合。两者不同之处，从字面意思就可理解，可变集合，可以增加、删除、改变元素，不可变集合的元素在它们初始设定之后就不能再被更改。
>>> alphabet = ['a' , 'b' , 'b' , 'c' , 'a' , 'd' , 'e' ]
>>> print(alphabet)
['a', 'b', 'b', 'c', 'a', 'd', 'e']
>>> alph2 = set(alphabet)
>>> print(alph2)
{'e', 'a', 'c', 'd', 'b'}该示例接受数据集alphabet作为输入，并将其转换为一个集合。因为集合不允许重复的值，多余的字符a和b被删除。之后alphabet被赋给alph2.并且打印以显示结果。
