一.模块初识
python模块
模块让你能够有逻辑地组织你的Python代码段。
把相关的代码分配到一个 模块里能让你的代码更好用，更易懂。
模块也是Python对象，具有随机的名字属性用来绑定或引用。
简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码
列子
一个叫做test的模块里的python代码一般都能在一个叫做test.py的文件中找到。下例是一个简单的模块test.py。
def print_self(name):
print(name)
return
import语句
想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：
import module1[,module2[,.....moduleN]
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块support.py，需要把命令放在脚本的顶端：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#导入模块
import test
#现在就可以用test模块里的函数了
test.print_self("Alex")
以上实例输出结果：
Alex
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
解释器搜索模块的路径可以通过系统模块sys的path函数获取
二.三元运算
固定格式
三.字节型数据
引用别人的文章，写得非常清楚，我的理解其实就是字符编码，一个encode，一个decode完了！
http://www.cnblogs.com/txw1958/archive/2012/07/19/2598885.html，这篇写的很清楚
四.列表：
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识。是python最通用的复合数据类型。看这段代码就明白。
列表中的值的分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # 输出完整列表 print list[0] # 输出列表的第一个元素 print list[1:3] # 输出第二个至第三个的元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素 print tinylist * 2 # 输出列表两次 print list + tinylist # 打印组合的列表
以上实例输出结果：
['runoob', 786, 2.23, 'john', 70.2] runoob [786, 2.23] [2.23, 'john', 70.2] [123, 'john', 123, 'john'] ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
1.增
列表增加有两种方法：append和insert如下实例：
a = [1, 2, 3] print(a) a.append(4) #在列表的最后添加一个元素 print(a) a.insert(0, 'Alex') #在制定的位置添加一个元素 print(a)
运行结果：
[1, 2, 3] [1, 2, 3, 4] ['Alex', 1, 2, 3, 4]
2.删
列表的删除方法有del,pop,remove，clear如下实例
#!/usr/bin/env python
#-*- coding:utf8 -*-
a = [1, 2, 3, 4, 5, 'abc', 6, 7]
del a[0]#删除指定元素
print(a)
a.pop()#默认删除最后一个元素
print(a)
a.pop(0)#指定删除一个元素
print(a)
a.remove('abc')#删除值为abc的这个元素
print(a)
a.clear()#清空列表
print(a)
del a#删除变量a
print(a)
结果：
[2, 3, 4, 5, 'abc', 6, 7]
[2, 3, 4, 5, 'abc', 6]
[3, 4, 5, 'abc', 6]
[3, 4, 5, 6]
[]
Traceback (most recent call last):
File "E:\workspace2\studypython\day2\sys_path.py", line 17, in <module>
print(a)
NameError: name 'a' is not defined
3.改
列表元素修改比较简单直接修改即可例如：
#!/usr/bin/env python #-*- coding:utf8 -*- a = [1, 2, 3, 4, 5, 6, 7] a[0] = 8#修改列表中第一个值 print(a)
运行结果：
[8, 2, 3, 4, 5, 6, 7]
4.查
列表可以查元素，查下标，实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
a = ['Alex', 'WTL', 'XZMLY', 'LZLL', 5, 6, 7]
print(a.index('LZLL'))#查值的下标
print(a[2])#查第三个元素的值
运行结果：
3 XZMLY
5.列表还包含以下函数
1、len(list)：列表元素个数
2、max(list)：返回列表元素最大值 要求列表所有元素为数值型
3、min(list)：返回列表元素最小值 要求列表所有元素为数值型
实例：
#!/usr/bin/env python #-*- coding:utf8 -*- a = ['Alex', 'WTL', 'XZMLY', 'LZLL', 5, 6, 7] b = [1.1, 2, 3, 5] print(len(a))#列表的元素个数 print(max(b))#返回列表元素最大值条件是元素都是数值型 print(min(b))#返回列表元素最小值条件是元素都是数值型
运行结果：
7 5 1.1
6.其他方法
1、list.count(obj)：统计某个元素在列表中出现的次数
2、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
3、list.reverse()：反向列表中元素
4、list.sort([func])：对原列表进行排序
实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
a = ['a','l','e','x','a','c']
b = [1, 2, 3]
print(a.count('a'))#返回列表中a的出现次数
a.reverse()#翻转列表
print(a)
a.sort()#排序
print(a)
a.extend(b)
print(a)
运行结果：
2 ['c', 'a', 'x', 'e', 'l', 'a'] ['a', 'a', 'c', 'e', 'l', 'x'] ['a', 'a', 'c', 'e', 'l', 'x', 1, 2, 3]
8.深浅copy
这个我理解但是表述不出来，在网上copy了别人的说的很清楚这里引用过来（引用地址:http://blog.csdn.net/szchtx/article/details/22958333）
Python中关于对象复制有三种类型的使用方式，赋值、浅拷贝与深拷贝。他们既有区别又有联系，刚好最近碰到这一类的问题，研究下。
一、赋值
在python中，对象的赋值就是简单的对象引用，这点和C++不同。如下：
list_a = [1,2,3,"hello",["python","C++"]]
list_b = list_a
这种情况下，list_b和list_a是一样的，他们指向同一片内存，list_b不过是list_a的别名，是引用。
我们可以使用 list_b is list_a 来判断，返回true，表明他们地址相同，内容相同。也可使用id(x) for x in list_a, list_b 来查看两个list的地址。
赋值操作（包括对象作为参数、返回值）不会开辟新的内存空间，它只是复制了新对象的引用。也就是说，除了list_b这个名字以外，没有其它的内存开销。
修改了list_a，就影响了list_b；同理，修改了list_b就影响了list_a。
二、浅拷贝（shallow copy）
浅拷贝会创建新对象，其内容是原对象的引用。
浅拷贝有三种形式：切片操作，工厂函数，copy模块中的copy函数
比如对上述list_a，
切片操作：list_b = list_a[:] 或者 list_b = [each for each in list_a]
工厂函数：list_b = list(list_a)
copy函数：list_b = copy.copy(list_a)
浅拷贝产生的list_b不再是list_a了，使用is可以发现他们不是同一个对象，使用id查看，发现它们也不指向同一片内存。但是当我们使用 id(x) for x in list_a 和 id(x) for x in list_b 时，可以看到二者包含的元素的地址是相同的。
在这种情况下，list_a和list_b是不同的对象，修改list_b理论上不会影响list_a。比如list_b.append([4,5])。
但是要注意，浅拷贝之所以称为浅拷贝，是它仅仅只拷贝了一层，在list_a中有一个嵌套的list，如果我们修改了它，情况就不一样了。
list_a[4].append("C")。查看list_b，你将发现list_b也发生了变化。这是因为，你修改了嵌套的list。修改外层元素，会修改它的引用，让它们指向别的位置，修改嵌套列表中的元素，列表的地址并为发生变化，指向的都是同一 个位置。
三、深拷贝（deep copy）
深拷贝只有一种形式，copy模块中的deepcopy函数。
和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因而，它的时间和空间开销要高。
同样对list_a，若使用list_b = copy.deepcopy(list_a)，再修改list_b将不会影响到list_a了。即使嵌套的列表具有更深的层次，也不会产生任何影响，因为深拷贝出来的对象根本就是一个全新的对象，不再与原来的对象有任何关联。
四、关于拷贝操作的警告
1、对于非容器类型，如数字，字符，以及其它“原子”类型，没有拷贝一说。产生的都是原对象的引用。
2、如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝。
五.元祖
元组类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
一、创建元组
实例：
#!/usr/bin/env python #-*- coding:utf8 -*- tup1 = (1, 2, 3,'a','b')#创建元祖 tup2 = (1, 2, 3)#创建元祖 tup3 = 1, 2, 3#创建元祖 tup4 = ()#创建空元祖 tup5 = (1,)#创建一个元素的元祖的时候要加个'，'消除歧义 print(type(tup1)) print(type(tup2)) print(type(tup3)) print(type(tup4)) print(type(tup5))
运行结果：
<class 'tuple'> <class 'tuple'> <class 'tuple'> <class 'tuple'> <class 'tuple'>
二、访问元组
元组可以使用下标索引来访问元组中的值，可以进行截取如下实例:
#!/usr/bin/env python
#-*- coding:utf8 -*-
tup1 = (1, 2, 3,'a','b')#创建元祖
tup2 = (1, 2, 3)#创建元祖
tup3 = 1, 2, 3#创建元祖
tup4 = ()#创建空元祖
tup5 = (1,)#创建一个元素的元祖的时候要加个'，'消除歧义
print("tup1[0]:",tup1[0])#取第一个元素
print('tup1[1:5]',tup1[1:4])#截取第二到四个元素
print('tup1[::2]',tup1[::2])#各一个截取一个元素
运行结果
tup1[0]: 1 tup1[1:5] (2, 3, 'a') tup1[::2] (1, 3, 'b')
三、修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;
#以上实例输出结果：
#(12, 34.56, 'abc', 'xyz')
四、删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/env python
#-*- coding:utf8 -*-
tup1 = (1, 2, 3,'a','b')#创建元祖
del tup1
print("删除元祖之后")
print(tup1)
运行结果：
Traceback (most recent call last):
File "E:\workspace2\studypython\day2\sys_path.py", line 7, in <module>
删除元祖之后
print(tup1)
NameError: name 'tup1' is not defined
五、元组运算符
与字符串一样，元组之间可以使用 + 号， * 号可以与整数进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
实例：
#!/usr/bin/env python #-*- coding:utf8 -*- tup1 = (1, 2, 3,'a','b')#创建元祖 tup2 = (1,2) print(tup1*2)#等于tup1+tup1 print(tup2+tup1)
运行结果：
(1, 2, 3, 'a', 'b', 1, 2, 3, 'a', 'b') (1, 2, 1, 2, 3, 'a', 'b')
六、元组内置函数
Python元组包含了以下内置函数
1、len(tuple)：计算元组元素个数。
2、max(tuple)：返回元组中元素最大值。
3、min(tuple)：返回元组中元素最小值。
#!/usr/bin/env python
#-*- coding:utf8 -*-
tup1 = (1, 2, 3,'a','b')#创建元祖
tup2 = ('a','b')
print(len(tup1))#查询元祖元素个数
print(max(tup2))#找最大值
print(min(tup1))#找最小值
#max,min函数需要比较相同相同的数据类型
运行结果
Traceback (most recent call last):
File "E:\workspace2\studypython\day2\sys_path.py", line 10, in <module>
print(max(tup1))#找最小值
TypeError: unorderable types: str() > int()
5
b
七、另一种解读
tuple和list非常类似，但是tuple一旦初始化就不能修改，它也没有append()，insert()这样的方法，其他获取元素的方法和list是一样的。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
在来看一个“可变的”tuple：
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，
所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，
但指向的这个list本身是可变的！理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。
六.字典
Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型
一、创建字典
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下：
#!/usr/bin/env python
#-*- coding:utf8 -*-
dict1 = {'}
dict2 = {'Alex':123}
dict3 = {'Alex':123,11.2:33}
print(type(dict1))
print(type(dict2))
print(type(dict3))
运行结果：
<class 'dict'>
<class 'dict'>
<class 'dict'>
二、访问字典里的值
实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {'}
dict2 = {'Alex':123}
dict3 = {'Alex':123,11.2:33}
print('dict1["Alex"]:',dict1['Alex'])
print('dict3[11.2]:',dict3[11.2])
以上实例运行结果：
dict1["Alex"]: 123
dict3[11.2]: 33
如果用字典里没有的键访问数据，会输出错误
三、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {'}
dict1['Alex'] = 250#修改已经存在的值
dict1['Jly'] = 251#添加新的键值对
print(dict1)
#以上实例输出结果
{', 'Alex': 250}
四、删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
删除一个字典用del命令，如下实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {'}
del dict1['Alex']#删除键是'Alex'的键值对
print(dict1)
dict1.clear()#清空
print(dict1)
del dict1#删除字典
print(dict1)#这句会报错，因为del后字典不存在了
#以上实例运行结果：
Traceback (most recent call last):
File "E:\workspace2\studypython\day2\sys_path.py", line 12, in <module>
{'}
{}
print(dict1)#这句会报错，因为del后字典不存在了
NameError: name 'dict1' is not defined
五、字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {','Alex':250}
print(dict1)
#运行结果：
{'}
2）键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {(','Alex':250}
print(dict1)
dict2 = {['Alex']:250}
print(dict2)
#运行结果
{(', 'Alex': 250}
Traceback (most recent call last):
File "E:\workspace2\studypython\day2\sys_path.py", line 8, in <module>
dict2 = {['Alex']:250}
TypeError: unhashable type: 'list'
六、字典内置函数&方法
Python字典包含了以下内置函数：
1、cmp(dict1, dict2)：比较两个字典元素。（python3中没有了好像）
2、len(dict)：计算字典元素个数，即键的总数。
3、str(dict)：输出字典可打印的字符串表示。
4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
#!/usr/bin/env python
#-*- coding:utf8 -*-
from test.test_pprint import dict3
dict1 = {','Alex':250}
print(len(dict1))#取列表长度
print(str(dict1))#不知道啥意思
print(type(dict1))
#执行结果：
3
{', 'jly': ['asdf'], 'Alex': 250}
<class 'dict'>
Python字典包含了以下内置方法：
1、radiansdict.clear()：删除字典内所有元素
2、radiansdict.copy()：返回一个字典的浅复制
3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
这个给个案例：
#!/usr/bin/python
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print "New Dictionary : %s" % str(dict)
dict = dict.fromkeys(seq, 10)
print "New Dictionary : %s" % str(dict)
#输出结果
New Dictionary : {'age': None, 'name': None, 'sex': None}
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}
4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值（安全获取字典值得方法）
5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
7、radiansdict.keys()：以列表返回一个字典所有的键
8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值