学习2: 数据类型和变量

1. 变量

Python 变量仅是名称。变量名的创建是通过把类型的实例赋值给它们。变量本身并没有类型，而与它们绑定在一起的对象拥有类型。

名称只是个标签，同样，它也可以被一个完全不同的对象重新赋值。赋值操作使用=操作符，所以把一个值赋给一个变量就如下所示：

aVariable = aValue

这段代码把值aValue 绑定到变量名aVariable 上。如果此变量名不存在，解释器会把这个名称添加到合适的命名空间中。

因此，在Python 中区别变量和它指向的对象是非常重要的。

1) 变量判断： is 和 ==

is判断两个变量是否指向同一个变量,  ==判断两个变量指向的对象是否相等

>>> aString = 'I love spam'
>>> anotherString = 'I love spam'
>>> anInt = 6
>>> intAlias = anInt
>>> aString == anotherString # test equality of value
True
>>> aString is anotherString # test object identity
False
>>> anInt == intAlias # same value
True
>>> anInt is intAlias # also same object identity
True

2)  变量种类: 全局变量和局部变量

例如1： 

name='tom'
def test():
    print name
					
test()

输出：
tom
[Finished in 0.2s]
说明：函数中可以直接使用全局变量，打印name时候查找name变量，先查找局部name没有找到，再查找全局name，找到了然后输出。

例如2：

name='tom'
def test2():
    if name == 'tom':
        pass
    else:
        name = 'liming'
    print name
test2()

执行报错:UnboundLocalError: local variable 'name' referenced before assignment
说明：函数中先引用name判断是否等于'tom'，先找局部name没有找到，然后再找全局name找到了，所以使用全局name判断，然后else中又对这个全局name进行赋值，所以报错。

从上面代码中也可以看出函数中即使变量赋值的部分不会执行也会报错的。
所以如果函数中的变量是引用的全局变量，那么函数中不能包含对该变量直接重新赋值的代码（不管是否会执行），如果必须重新赋值那么需要在函数中先通过global引用，如下

例如3：

name='tom'
def test2():
    global name
    if name == 'tom':
        pass
    else:
        name = 'liming'
    print name
test2()
print name

正常输出:

tom
tom
[Finished in 0.1s]

说明：这个函数中通过使用global引用了全局name，所以在函数中可以对该全局name重新赋值。

例如4：

name='tom'
def test2():
    name = 'liming'
    print name
test2()
print name

正常输出：
liming
tom
[Finished in 0.3s]
说明：此处在函数中直接定义了一个局部name，注意这个是定义局部变量而不会查找全局变量。局部变量和全局变量都可以正常输出，互不影响。

2. 数值类型: 整数和浮点数

3. 布尔类型

在Python中 None,  False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False：

>>> bool()
False
>>> int(bool())
0
>>> int(True)
1
>>> int(False)
0

4. 空值类型None

空值是Python里一个特殊的值，用None表示。所有对None对象的引用都是同一个实例

>>> a=None
>>> b=None
>>> a==b
True
>>> a is b
True

5. 字符串

6. 列表

1) list是一种有序的集合，可以随时添加和删除其中的元素; 空列表定义a=[]

2) 可以用索引访问其中某一个元素，索引从0开始；当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，最后一个元素的索引是len(a) - 1
    如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素,以此类推，可以获取倒数第2个、倒数第3个

3）可以通过切片访问其中的多个元素
4) list相关函数，可以通过help(list)查看

注意：通过索引获取单个元素返回的是对应得元素数据类型，通过切片访问返回的是list类型

list相关操作：

添加

append(元素) : 末尾添加元素，相当于 a[len(a):] = [x]
extend(列表) : 将一个给定列表中的所有元素都添加到另一个列表中
insert(索引位置，元素): 在指定位置插入一个元素。例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)

>>> a=[1,2]
>>> a[2]=3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a[len(a):]=[3]
>>> a
[1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> 

>>> a=[2,1,2]
>>> a[0]=3            
>>> a
[3, 1, 2]
>>> b
[4, 7, 6, 10]
>>> a.append(5)
>>> a
[3, 1, 2, 5]
>>> a.extend(b)
>>> a
[3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(0,9)
>>> a
[9, 3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(1,8)
>>> a
[9, 8, 3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(5,1)
>>> a
[9, 8, 3, 1, 2, 1, 5, 4, 7, 6, 10]

注： 两个列表相并除了用extend方法，用+可以扩展另外一个列表，用*可以扩展自身列表

>>> a=[1,2]
>>> b=[3,4]
>>> a+b
[1, 2, 3, 4]
>>> a*2
[1, 2, 1, 2]

删除：
remove(元素): 删除指定元素，如果有多个相同元素只删除第一个；
pop(索引位置): 删除指定位置元素，如果不指定表示删除最后一个元素；

del:

注意三者之间的区别.

>>> a
[9, 8, 3, 1, 2, 1, 5, 4, 7, 6, 10]
>>> a.remove(1)
>>> a
[9, 8, 3, 2, 1, 5, 4, 7, 6, 10]
>>> a.pop(0)
9
>>> a
[8, 3, 2, 1, 5, 4, 7, 6, 10]
>>> a.pop()
10
>>> a
[8, 3, 2, 1, 5, 4, 7, 6]

>>> a=[8, 7, 6, 6, 5, 4, 3, 2, 1]
>>> b=a
>>> del a[0]
>>> a
[7, 6, 6, 5, 4, 3, 2, 1]
>>> b
[7, 6, 6, 5, 4, 3, 2, 1]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> b
[7, 6, 6, 5, 4, 3, 2, 1]

修改：
直接根据列表索引位置重新赋值即可，注意首先必须保证索引位置没有超出列表的索引范围；
>>> a=[]
>>> a[0]=3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

查询：
index(元素): 根据元素内容查询其所在的索引位置;
count(元素）: 统计某个元素在列表中有多少个；
index和count的区别： 两者都可以用来查询列表元素，如果元素不在列表中的话index会出现异常，而count会返回0

len(列表): 统计列表的长度，也就是有多少个元素；
sort():
reverse():

>>> a
[8, 3, 2, 1, 5, 4, 7, 6]
>>> a.index(1)
3
>>> a.insert(2,6)
>>> a
[8, 3, 6, 2, 1, 5, 4, 7, 6]
 >>> a.count(3)
1
>>> a.count(6)
2
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 6, 6, 7, 8]
>>> a.reverse()
>>> a
[8, 7, 6, 6, 5, 4, 3, 2, 1]
>>> len(a)
9

判断某个元素是否存在于列表中也可以使用in的方法

循环遍历列表：

for循环：

test_list=['tom','tim','shom']
for name in test_list:
    print name

输出结果：

tom
tim
shom
[Finished in 0.1s]

若要在循环内部修改正在遍历的列表，可以通过对test_list[:]遍历，test_list[:]相当于对原始列表的拷贝，例如：

words = ['cat', 'window', 'defenestrate']
for w in words[:]: 
    if len(w) > 6:
        words.insert(0, w)
print words

输出结果：

['defenestrate', 'cat', 'window', 'defenestrate']
[Finished in 0.1s]

7. 元组

1) tuple称为元组，有序但是元素不可变更，一旦初始化之后就不能再修改；空元组定义为 a=()
2) tuple也可以通过索引访问某一个元素，索引从0开始
3) tuple相关函数：
index（元素): 和列表相同也是根据元祖内容查询它的索引位置；
count(元素): 和列表一样也是统计某个元素出现的次数；
index和count的区别： 两者都可以用来查询tuple元素，如果元素不在tuple中的话index会出现异常，而count会返回0

>>> m=(6,8,10,6)
>>> m.count(6)
2
>>> m.count(10)
1
>>> m.index(10)
2
>>> m.index(6)
0

>>> a=(1,2,3,4)
>>> a.index(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.count(0)
0
>>> a.index(1)
0
>>> a.count(1)
1

4) 只有一个元素的元组，定义为a=(1,)，不能定义为a=(1);

>>> a=(1,)
>>> type(a)
<type 'tuple'>
>>> a=(1)
>>> type(a)
<type 'int'>

5) 元组的不可变更是指元组的元素指向不可更新，如果元素指向某个列表的时候，列表的内容更新不受限制；

>>> m=(1,2)
>>> m
(1, 2)
>>> a=['a','b']
>>> m=(1,2,a)
>>> m
(1, 2, ['a', 'b'])
>>> a.append('c')
>>> a
['a', 'b', 'c']
>>> m
(1, 2, ['a', 'b', 'c'])

　　

8. 字典

1) dict全称dictionary，使用键-值（key-value）存储; 空字典 a={}; 支持增删改查操作；
2) 把数据放入dict的方法，除了初始化时指定外，还可以通过key放入;
3) 由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉;
4) 要避免key不存在的错误，有三种办法，一是通过in判断key是否存在：二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value；还可以通过函数has_key进行判断(这种一般不用了)；
5) 要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
del a[key] 也可以删除某个元素
del a 删除整个字典
6) 请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。
　　和list比较，dict有以下几个特点：
　　　　　查找和插入的速度极快，不会随着key的增加而增加；
　　　　　需要占用大量的内存，内存浪费多。
　　而list相反：
　　　　　查找和插入的时间随着元素的增加而增加；
　　　　　占用空间小，浪费内存很少。
　　所以，dict是用空间来换取时间的一种方法。
7) dict的key必须是不可变对象,这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key.
8) dict的常用函数,help(dict)可以查看
clear()：删除字典内所有元素
get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
has_key(key)：如果键在字典dict里返回true，否则返回false
items()：以列表返回可遍历的(键, 值) 元组数组
keys()：以列表返回一个字典所有的键
values()：以列表返回字典中的所有值
update(dict2)：把字典dict2的键/值对更新到dict里
setdefault(key, default=None)：
和get()类似, 如果键已经存在于字典中则返回字典中对应的value；但如果键不存在于字典中，将会添加键并将值设为default值;
len(dict)：计算字典元素个数，即键的总数。
fromkeys(seq,val)：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

创建字典

>>> g={'linken':'male','aobama':'male','xilali':'female'}
>>> g
{'aobama': 'male', 'xilali': 'female', 'linken': 'male'}

访问字典元素

>>> g['xilali']
'female'

字典元素判断

>>> 'xilali' in g
True
>>> 'xibushi' in g
False
>>> g.get('xilali')
'female'
>>> g.get('xibushi')
>>> g.get('xibushi',2)
2
>>> g.get('xilali',2)
'female'
>>> g.has_key('xilali')
True

修改字典

>>> g['xibushi']='female'
>>> g
{'aobama': 'male', 'xibushi': 'female', 'xilali': 'female', 'linken': 'male'}
>>> g['xibushi']='male'
>>> g
{'aobama': 'male', 'xibushi': 'male', 'xilali': 'female', 'linken': 'male'}
>>> k={'jj':'male'}
>>> g.update(k)
>>> g
{'aobama': 'male', 'linken': 'male', 'jj': 'male', 'xilali': 'female', 'xibushi': 'male'}
>>> n={'aobama':'female'}
>>> g.update(n)
>>> g
{'linken': 'male', 'jj': 'male', 'xilali': 'female', 'aobama': 'female', 'xibushi': 'male'}

update方法更新字典，如果两个字典元素中key值有重复则取用新的value

删除字典

>>> g = {'aobama': 'male', 'xibushi': 'male', 'xilali': 'female', 'linken': 'male'}
>>> g.pop('xibushi')
'male'
>>> g
{'aobama': 'male', 'xilali': 'female', 'linken': 'male'}
>>> del g['aobama']
>>> g
{'linken': 'male', 'xilali': 'female'}
>>> g.clear()
>>> g
{}
>>> g={'linken': 'male', 'xilali': 'female'}
>>> del g
>>> g
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'g' is not defined

字典函数

>>> g={'linken': 'male', 'xilali': 'female'}
>>> g.items()
[('xilali', 'female'), ('linken', 'male')]
>>> g.keys()
['xilali', 'linken']
>>> g.values()
['female', 'male']
>>> g
{'xilali': 'female', 'linken': 'male'}
>>> g.setdefault('aobama','male')
'male'
>>> g
{'xilali': 'female', 'aobama': 'male', 'linken': 'male'}
>>> g.setdefault('aobama','male')
'male'
>>> g
{'xilali': 'female', 'aobama': 'male', 'linken': 'male'}
>>> g.setdefault('aobama','female')
'male'
>>> g
{'xilali': 'female', 'aobama': 'male', 'linken': 'male
>>> a
('xilai', 'aobama')
>>> v
('femail', 'male')
>>> dict.fromkeys(a,v)
{'xilai': ('femail', 'male'), 'aobama': ('femail', 'male')}

字典遍历

>>> for key in m:
... 	print key,m[key]
... 
xilai ('femail', 'male')
aobama ('femail', 'male
>>> for (k,v) in m.items():
... 	print "m[%s] = %r" % (k, v)
... 
m[xilai] = ('femail', 'male')
m[aobama] = ('femail', 'male')

　　

9. 集合

可变对象:

通过上面知道可以通过is判断是否同一个对象。

python中，万物皆对象。python中不存在所谓的传值调用，一切传递的都是对象的引用，也可以认为是传址。

python中，对象分为可变(mutable)和不可变(immutable)两种类型。

元组（tuple)、数值型（number)、字符串(string)均为不可变对象，元组严格意义上说也不是绝对不可变的。

而字典型(dictionary)和列表型(list)的对象是可变对象。

 

知道可以通过is判断是否指向同一个对象, 另外还可通过id查看内存地址来区别是否指向同一个对象。

另外是否可变是指内存地址中的数值是否可以变更。

List可变：

>>> a=[1]
>>> b=[1]
>>> a is b
False
>>> id(a)
48362888L
>>> id(b)
48400392L
>>> 

>>> a=[1]
>>> id(a)
48400392L
>>> a.append(2)
>>> a
[1, 2]
>>> id(a)
48400392L

数值型,字符串不可变

>>> x=1
>>> y=1
>>> x is y
True
>>> id(x)
12541880L
>>> id(y)
12541880L
>>> 

>>> x='hello'
>>> y='hello'
>>> x is y
True
>>> id(x)
48433392L
>>> id(y)
48433392L
>>> 

>>> a=(1,'hello')
>>> b=(1,'hello')
>>> a is b
False
>>> id(a)
48399688L
>>> id(b)
48399752L
>>> 
>>> a[0] is b[0]
True
>>> a[1] is b[1]
True
>>> 
>>> a=(1,'hello',['m'])
>>> b=(1,'hello',['m'])
>>> a is b
False
>>> id(a)
48395968L
>>> id(b)
12671808L
>>> a[0] is b[0]
True
>>> a[1] is b[1]
True
>>> a[2] is b[2]
False
>>> 

>>> a=[[]]*5
>>> a
[[], [], [], [], []]
>>> a[0].append(10)
>>> a
[[10], [10], [10], [10], [10]]
>>> a[1].append(20)
>>> a
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]]
>>> a.append(30)
>>> a
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30]
>>> 

说明： a=[ [ ] ] * 5的关键一点是它不是创造一个包含五个独立列表的列表，而是它是一个创建了包含对同一个列表五次引用的列表

　

给定一个含有N个数字的列表，取出偶数切片中的偶数值。以下两种方式，第二种先取出偶数切片的值再判断是否偶数。
a[::2]表示每两个元素取一个元素。

>>> a=[0,1,2,3,4,5,6]
>>> [x for x in a if x%2==0 and a.index(x)%2==0]
[0, 2, 4, 6]
>>> [x for x in a[::2] if x%2==0]
[0, 2, 4, 6]