python学习day2

一.模块初识

　　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()：以列表返回字典中的所有值