第二章 python数据类型

第一节    数字和字符串类型 

123和“123”一样吗

() [] {} 

计算机是用来辅助人们的，在程序设计中也映射了现实世界的分类，以便于抽象的分析。 

数字 

字符串 

列表 

元组 

字典 

 

我们通过数据类型去查看一些简单的数据类型，python会自动识别数据的类型 

>>> num1=123 
>>> type(123) 
 
>>> type(num1) 
 
>>> num2=99999999999999999999999999 
>>> type(num2) 
 

>>> num='hello' 

>>> type(num) 
 

在python中整数int表示的范围-2,147，483,648到2,147,483,647 

例如：0,100，,100 

Int的范围示例如上面所示。 

>>> num3=123L        这里我们是以长整型来赋值的 
>>> type(num3) 
 

例如：0.0,12.0，,18.8,3e+7等 

示例： 

>>> num=0.0 
>>> type(num) 
 
>>> num=12 
>>> type(num) 
 
>>> num=12.0 
>>> type(num) 
 

Python对复数提供内嵌支持，这是其他大部分软件所没有的： 

复数举例：3.14j，8.32e-36j 

示例： 

>>> num=3.14j 
>>> type(num) 
 
>>> num 
3.14j 
>>> print num 

3.14j 

>>> 

我们在这里判别下面两个不同类型的变量 

>>> a=123 
>>> stra="123" 
>>> print a 
123 
>>> print stra 
123 
>>> a+stra          在这里我们发现这两个不同类型的变量不能进行运算 
Traceback (most recent call last): 
  File "", line 1, in  
TypeError: unsupported operand type(s) for +: 'int' and 'str' 
>>> 
>>> type(a) 
 
>>> type(stra) 
 

字符串String 

使用引号定义的一组可以包含数字，字母，符号（非特殊系统符号）的集合。 

>>> str1='hello world' 

>>> str2="hello world"

>>> say='let's go'       这样定义出现错误，因为我们在这里定义的时候里面还包含一个单引号 
  File "", line 1 
    say='let's go' 
             ^ 
SyntaxError: invalid syntax 

>>> say="let's go"        我们将外面的单引号改为双引号即可 

>>> say="let's "go""        如果我们的双引号里面还有双引号，我们就要使用转义字符了 
  File "", line 1 
    say="let's "go"" 
                 ^ 
SyntaxError: invalid syntax 
>>> say="let's \"go\"" 
>>> print say 

let's "go" 

下面我们看一些转义字符的使用 

>>> mail='tom: hello i am jack' 
>>> print mail 
tom: hello i am jack 
>>> mail='tom:\n hello\n i am jack'        对于上面的字符如果我们想使用换行的形式输出 
>>> mail 
'tom:\n hello\n i am jack' 
>>> print mail 
tom: 
 hello 

 i am jack 

下面我们使用三重引号实现换行的效果： 

>>> mail="""tom: 
...     i am jack 
...     goodbye 
... """ 
>>> print mail 
tom: 
    i am jack 
    goodbye 

>>> mail        这里我们可以看到我们使用三重引号的时候他会将我们的输入记录下来 
'tom:\n\ti am jack\n    goodbye\n' 

另外我们在代码中也可以用三重引号取注释某一行，也可以使用他做doc数据 

通过索引取值 

>>> a='abcde'

>>> a[0]        我们通过索引来取字符串里面的某个值

'a' 
>>> a[1] 
'b' 
>>> a[0]+a[1]        如果我们想取多个可以在中间使用+号做连接 

'ab' 

使用切片进行取值 

>>> a 

'abcde' 

下面我们看一下这里的操作，a[开始位置：结束位置+1：步长] 

>>> a[1:4]        这里我们取bcd，要使用[开始位置：结束位置+1]来取值

'bcd' 

>>> a[:4]        这表示从头开始到d切断

'abcd' 

>>> a[4:]        从第四个位置这里切断取后面的值 

'e' 

>>> a[2:] 

'cde' 

>>> a[::1]        通过步长来取值，下面步长为2的时候更加清晰 
'abcde' 
>>> a[::2] 

'ace' 

>>> a[-4:-1]  通过负数索引取值，这里我们开始的时候从是从后向前的，-1代表倒数第二个值 

'bcd' 

>>> a[:-1]        从倒数最后一个值切断，然后显示前面的值 

'abcd' 

下面两种我们可以看到他的取值顺序 

>>> a[-2:-4:-1]            他是从将所有的数先反过来，然后再进行从第二个位置开始切断取值到 'dc' 第三个位置 
>>> a[-4:-2:1]              他表示从倒数第四个位置开始取值到倒数第二个位置切断 

'bc' 

>>> a[-2:-5:-1]            倒过来取值 

'dcb' 

 

第二节    序列 

a.列表、元组和字符串都是序列 

b.序列的两个主要特点是索引操作符和切片操作符。 

    ——索引操作符让我们可以从序列中抓紧一个特定项目。 

    ——切片操作符让我们可以能够获取序列的一个切片，即一部分序列。 

c.索引同样可以是负数，位置是从序列尾开始计算的。 

    ——因此，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目 

d.切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。 

    ——注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。 

    ——切片操作符中的第一个数（冒号之前）表示开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。 

    ——注意：返回的序列从开始位置开始，刚好在结束位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。 

    a.shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。shoplist[:]返回整个序列的拷贝。你可以用负数做切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。 

序列的基本操作 

    1.len()：            求序列长度 

    2.+：                  连接2个序列 

    3.*：                   重复序列元素 

    4.in：                 判断元素是否在序列中 

    5.max()：          返回最大的值 

    6.min()：           返回最小的值 

    7.cmp(tuplel,tuple2)    比较2个的序列值是否相同 

下面我们来操作一下： 

>>> a 
'abcde' 
>>> len(a) 
5 
>>> str1='123' 
>>> str2='adbs' 
>>> str1+str2 

'123adbs' 

>>> str1*5        这样str1就会被重复五次

'123123123123123' 
>>> "#"*40 
'########################################' 
>>> str2 
'adbs' 

>>> 'c' in str2        查看'c'这个字符是否在str2这个字符串中不在返回False，在返回True

False 
>>> 'a' in str2 
True 

也可以使用not in判断不在里面 

>>> 'c' not in str2 
True 
>>> max(str1) 
'3' 
>>> max(str2) 
's' 
>>> min(str2) 

'a' 

cmp（str1，str2）用于两个字符串的比较 

>>> str1='12345' 
>>> str2='abcde' 
>>> cmp(str1,str2) 

-1 

>>> str2='123' 
>>> cmp(str1,str2) 
1 
>>> str2='12345'        这时两个值相等，比较的时候返回0 
>>> cmp(str1,str2)         
0 

第三节    元组（） 

元组和列表十分类似，只不过元组和字符串一样是不可变的即你不能修改元组。 

    ——元组通过圆括号中用逗号分割的项目定义。 

    ——元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。 

>>> str2='12345' 
>>> id(str2) 
139702043552192 
>>> str2='123456666' 
>>> id(str2) 

139702043552576 

下面我们开始元组的操作 

首先我们可以看看通过切片出来的姓名，会在长度不同的情况下有空格显示，这样我们从里面取元素是比较困难的 

>>> userinfo="milo 30 male" 
>>> userinfo[:4] 
'milo' 
>>> userinfo1="zou 25 famale" 
>>> userinfo1[:4] 
'zou ' 
>>> t=("milo",30,"male")   这里如果我们使用元组这种定义方式，在取值的时候就会方便很多 
>>> t[0] 
'milo' 
>>> t[1] 
30 
>>> t[2] 

'male' 

创建元组 
    ——一个空元组由一对空的圆括号组成 
        a.如myempty = () 
    ——含有单个元组的元组 
        a.singleton = (2,) 
    ——一般的元组 
        a.zoo = ('wolf','elephant','penguin') 

        b.new_zoo = ('monkey','dolphin',zoo) 

 

>>> t=()            定义一个空元组 
>>> t1=(2,)        定义一个只有一个元素的元组，这里要特别注意，那个逗号不能少 
>>> type(t) 
 
>>> type(t1) 
 

元组操作 

    ——元组和字符串类型一样属于序列类型，可通过索引和切片操作 

    ——元组值亦不可变 

>>> t=('milo',30,'male') 
>>> t 
('milo', 30, 'male') 
>>> t[1] 
30 
>>> t[1]=31        这里我们在视图更改年龄的时候发现报错 
Traceback (most recent call last): 
  File "", line 1, in  
TypeError: 'tuple' object does not support item assignment 
>>> t 

('milo', 30, 'male') 

 

>>> name,age,gender=t 
>>> name 
'milo' 
>>> age 
30 
>>> gender 
'male' 

>>> a,b,c=1,2,3 

>>> a,b,c=(1,2,3)        在python中这两种方法都可以定义元组，但是我们尽量使用第二种方法 

第四节    序列-元组 

列表[] 

1）list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。 

2）列表是可变类型的数据 

3）列表的组成：用[]表示列表，包含了多个以逗号分隔开的数字，或者字串。 

    ——List1=['Simon','David','Clotho','张三'] 

    ——List2=[1,2,3,4,5] 

    ——List3=["str1","str2","str3","str4","str5"] 

>>> listmilo=[]        空列表的定义 
>>> type(listmilo) 
 
>>> listmilo=['milo',30,'male']        一般列表的定义 
>>> t=('milo',30,'male') 
>>> t[0] 
'milo' 
>>> listmilo[0] 
'milo' 
>>> listmilo[0:2]        从列表中取值 
['milo', 30] 
>>> t[0:2] 

('milo', 30) 

有区别的在下面 

>>> t3=('abc') 
>>> l3=['abc'] 
>>> type(l3)    在这里我们可以看到他是一个列表 
 
>>> type(t3) 
 

列表操作 

    ——取值 

        a.切片和索引 

        b.list[] 

    ——添加 

        a.list.append() 

    ——删除 

        a.del(list[]) 

        b.list.remove(list[]) 

    ——修改 

        a.list[]=x 

    ——查找 

        a.var in list 

>>> listmilo[0]        在这里我们发现列表可以改变存储的元素的值 
'milo' 
>>> listmilo[0]='zou' 
>>> listmilo[0] 
'zou' 

下面我们介绍一下如何向列表中添加一个元素 

>>> listmilo 
['milo', 30, 'male'] 
>>> listmilo.append("123444555") 
>>> listmilo 

['milo', 30, 'male', '123444555']        这时我们发现listmilo列表中已经添加了第四个元素 

>>> listmilo.remove('123444555')        从列表中删除一个值 
>>> listmilo 
['milo', 30, 'male'] 

>>> del(listmilo[1])        我们也可以使用del去通过列表的索引删除列表中的值

>>> listmilo 
['milo', 'male'] 

要学会使用help查询一些语法的使用，例如我们需要查看列表的内部的删除操作 

>>> help(list.remove)        

Help on method_descriptor: 

remove(...) 
    L.remove(value) -- remove first occurrence of value. 
    Raises ValueError if the value is not present. 
(END) 

>>> help(len)            这样查看一些内部函数的使用操作 

对象与类快速入门 

1）对象和类，更好的理解列表。 

2）对象=属性+方法 

3）列表是使用对象和类的一个例子。 

    ——当你使用变量i并给它赋值的时候，比如赋整数5，你可以认为你创建了一个类（类型）int的对象（实例）i。 

    ——help(int) 

4)类也有方法，即仅仅为类而定义地函数。 

    ——仅在该类的对象可以使用这些功能。 

    ——例如： 

        a.Python为list类提供了append方法，这个方法让你在列表尾添加一个项目。 

        b.mylist.append('an item')列表mylist中添加字符串。注意，使用点号来使用对象的方法。 

5）类也有变量，仅为类而定义的变量。 

    ——仅在该类的对象可以使用这些变量/名称。 

    ——通过点号使用，例如mylist.field。 

第五节    字典{} 

1）字典是python中唯一的映射类型（哈希表） 

2）字典对象是可变的，但是字典的键必须使用不可变对象，并且一个字典中可以使用不同类型的键值。 

3）key()或者 values()返回键列表或者值列表 

4）items()返回包含键值对的元组。 

 

创建字典： 

    - {} 

    - 使用工厂方法dict() 

       例：fdict=dict(['x',1],['y',2]) 

    - 内建方法：fromkeys(),字典中的元素具有相同的值，默认为None 

        例：ddict={}.fromkeys(('x','y'),-1) 

>>> dic={0:0,1:1,2:2}        这里我们定义了一个字典{key:value,key:value,key:value} 
>>> dic[0] 
0 
>>> dic[1] 
1 
>>> dic[2] 
2 

>>> dic1={'name':'milo','age':25,'gender':'male'}    通过这样定义会更有意义一些 

>>> dic1['name']        我们取值的时候才更有目的性 
'milo' 
>>> dic1['age'] 
25 
>>> dic1['gender'] 
'male' 

>>> dic2={1:'123','name':'milo','x':456} 

>>> dic2 

{1: '123', 'name': 'milo', 'x': 456} 

接下来我们看另外一个例子： 

>>> a=1            这里我们先定义两个变量 
>>> b=2 

>>> dic3={a:'aaa','b':'bbb'}        如果a没有被定义这里会出现报错 

>>> dic3[1] 
'aaa' 

>>> dic3[2]        在这里我们终于看到区别了，其实在字典里面，他并没有使用b之前定义的值

Traceback (most recent call last): 
  File "", line 1, in  
KeyError: 2 
>>> dic3['b'] 
'bbb' 
>>> dic1 
{'gender': 'male', 'age': 25, 'name': 'milo'} 
>>> for k in dic1:            在这里我们可以看到使用字典的方便了 
...     print k 
... 
gender 
age 
name 
>>> for k in dic1: 
...     dic1[k]            直接取出值 
... 
'male' 
25 
'milo' 

更新和删除： 

    - 直接用键值访问更新；内建的uodate()方法可以将整个字典的内容拷贝到另一个字典中。 

    - del dict1['a']删除字典中键值为a的元素 

        a.    dict1.pop('a')删除并且返回键为'a'的元素 

        b.    dict1.clear()删除字典所有元素 

        c.    del dict1删除整个字典 

>>> l 
[1, 2, 3, 4, 5] 
>>> l[5]=7 
Traceback (most recent call last): 
  File "", line 1, in  
IndexError: list assignment index out of range 
>>> dic1 
{'gender': 'male', 'age': 25, 'name': 'milo'} 
>>> dic1['tel']='123454565'      在这里我们看到在使用字典的时候可以这样添加一个值无报错 
>>> dic1 
{'gender': 'male', 'age': 25, 'tel': '123454565', 'name': 'milo'} 

我们看到他并不是增加到最后面的，因为字典中它本身并不是固定的，字典的无序性，hash类型的值，通过字典的key可以直接操作字典里面的元素 

>>> dic1['tel']='888888888' 
>>> dic1 

{'gender': 'male', 'age': 25, 'tel': '888888888', 'name': 'milo'} 

>>> dic1.pop('age')        弹出键‘age’对应的值，字典里面就没有age这个键值了

25 
>>> dic1 
{'gender': 'male', 'tel': '888888888', 'name': 'milo'} 
>>> dic1.clear()        清空字典 
>>> dic1 
{} 
>>> del(dic1)        直接删除字典 
>>> dic1 
Traceback (most recent call last): 
  File "", line 1, in  
NameError: name 'dic1' is not defined 

字典相关的内建函数： 

    - type(),str(),cmp()（cmp很少用于字典的比较，比较依次是字典的大小、键、值）。 

工厂函数dict()： 

    - 例如：dict(zip('x','y'),(1,2))或者dict(x=1,y=2) 

    -     {'y':2,'x':1} 

    -    使用字典生成字典比用copy慢，因此这种情况下推荐使用copy()。 

1）len()，hash()（用于判断某个对象是否可以做一个字典的键，非哈希类型报TypeError错误）。 

2）dict.clear()：删除字典中所有元素。 

3）dict.fromkeys(seq,val=None)：以seq中的元素为键创建并返回一个字典，val为制定的默认值。

4）dict.get(key,default=None)：返回key的value，如果该键不存在返回default指定的值。 

5）dict.has_key(key)：判断字典中是否存在key，建议使用in和not in代替。 

6）dict .items()：返回键值对元组的列表。 

7）dict.keys()：返回字典中键的列表。 

8）dict.iter*()：iteritems()，iterkeys()，itervalues()返回迭代而不是列表。 

9）dict.pop(key[,default])：同get(),区别是若key存在，删除并返回其dict[key]，若不存在切default未指定值，抛出KeyError异常。 

10）dict.setdefault(key,default=None)：同set()，若key存在则返回其value，若key不存在，则dict[key]=default。 

11）dict.update(dict2)：将dict2中的键值对添加到字典dict中，如果有重复覆盖，原字典不存在的条目添加进。 

12）dict 。values() :返回字典所有值的列表。 

>>> dic.get(3)        我们查看字典 

>>> dic.get(3,'error')        当字典中不存在的时候，定义返回error

'error' 

其他的例子我们可以练习一下，如果不懂我们可以使用help这个功能。 

>>> dic1={'a':123,'b':456,1:111,4:444} 
>>> dic1.keys() 
['a', 1, 'b', 4] 
>>> dic1.values() 
[123, 111, 456, 444]