python入门系列3―——数据类型

个人博客

之前我们已经接触了变量，变量是存储在内存中的值，这说明在创建变量的时候内存中会开辟一个空间用来存储整数、小数、字符串等等

我们先来看看变量赋值：

a =10
b=100.0
c="python"
print a
print b
print c

结果：

>>> 
10
100.0
python

这里我们还可以对多个变量同时赋值：

a,b,c=10,100.0,"python"
x=y=99
print a
print b 
print c
print x
print y

结果：

>>> 
10
100.0
python
99
99

标注数据类型

python定义了一些标准类型，用于存储各种类型的数据

主要包括五个：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

1.数学类型

数学类型有四种，分别是：

• int（有符号整型） 
• 例如：10，-10，1000
• long（长整型[也可以代表八进制和十六进制]，在结尾有L）
• 例如：10000000000L，122L，
• float（浮点型）
• 例如：100.0，22.2
• complex（复数，j是虚数）

    例如：456j，2+3j

2.字符串

字符串是由数字、字母、下划线组成的一串字符

例如：

s="ilovepython"

python有2种取值顺序：

从左到右，默认0开始，最大范围字符串长度-1

从右到左，默认-1开始，最大范围字符串开头

如果要去字符串中的一段字符串，可以使用变量[头下标:尾下标]，例如

print s[1:5]

结果输出：love

之前学习的运算符对字符串也有作用 比如 + 是连接字符串，*表示重复字符串，具体例子如下

str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串
print str[-2]       # 输出反向取倒数第二个字符
print str[-1]       # 输出反向取倒数第一个字符
print str[:-1]      # 输出从头到倒数第一个之间的字符串
print str[:]        # 输出全部字符串

结果：

>>> 
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
d
!
Hello World
Hello World!

另外需要注意一点：

python中的字符串具有不可变性，创建后不能改变。每个字符串都被定义为生成新的字符串作为其结果。例如，不能通过对其某一位置进行赋值而改变字符串。但可以通过建立新的字符串并以同一个变量名进行赋值，python在运行过程中会清理旧的对象。

str = 'Hello World!'
str[0] ="z" #报错，字符串不能改变

那如何改变？

str = 'Hello World!'
str = "z" +str[1:]
print str

3.List（列表）支持字符，数字，字符串甚至可以包含列表（即嵌套）。访问某个元素使用[ ]标识列表中值的也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。 + 是列表连接运算符， * 是重复操作。如下实例：

mylist1 = [ 'python', 12345 , 5.678, 'helloworld', 99.99]
mylist2 = [123, 'hello']
 
print mylist1               # 输出完整列表
print mylist1[0]            # 输出列表的第一个元素
print mylist1[1:3]          # 输出第二个至第三个的元素 
print mylist1[2:]           # 输出从第三个开始至列表末尾的所有元素
print mylist1[:-1]          # 输出从头开始至列表倒数第一个之间的所有元素
print mylist1[:]            # 输出所有元素
print mylist2 * 2           # 输出列表两次
print mylist1 + mylist2     # 打印组合的列表


print mylist1[10]   #放问的元素不存在，报错

结果：

['python', 12345, 5.678, 'helloworld', 99.99]
python
[12345, 5.678]
[5.678, 'helloworld', 99.99]
['python', 12345, 5.678, 'helloworld']
['python', 12345, 5.678, 'helloworld', 99.99]
[123, 'hello', 123, 'hello']
['python', 12345, 5.678, 'helloworld', 99.99, 123, 'hello']


Traceback (most recent call last):
  File "D:\Python27\Mytest\test.py", line 13, in <module>
    print mylist1[10]   #放问的元素不存在，报错
IndexError: list index out of range

需要注意：如果你访问的list下标不存在，python就会报错

list的一些常用函数

mylist=[1,3,41,7,1]
mylist.append("hello")          #在list末尾添加元素
print mylist
mylist.insert(0,"first")        #在list指定位置添加元素
print mylist
print mylist.count(1)           #统计 1 在list里出现的次数
mylist1=["python","list"]


mylist =mylist+mylist1          #添加一个list
print mylist
mylist.extend(mylist1)          #添加一个list，效率比+快
print mylist
print mylist.index("python")    #查找第一个匹配的元素的位置
mylist.pop()                    #移除最后一个元素
print mylist
mylist.pop(0)                   #移除第一个元素
print mylist
mylist.remove("python")         #移除匹配的第一个元素
print mylist
mylist.reverse()                #反转list
print mylist
mylist.sort()                   #排序
print mylist
mylist.sort(reverse=True)       #反向排序
print mylist

结果：

[1, 3, 41, 7, 1, 'hello']
['first', 1, 3, 41, 7, 1, 'hello']
2
['first', 1, 3, 41, 7, 1, 'hello', 'python', 'list']
['first', 1, 3, 41, 7, 1, 'hello', 'python', 'list', 'python', 'list']
7
['first', 1, 3, 41, 7, 1, 'hello', 'python', 'list', 'python']
[1, 3, 41, 7, 1, 'hello', 'python', 'list', 'python']
[1, 3, 41, 7, 1, 'hello', 'list', 'python']
['python', 'list', 'hello', 1, 7, 41, 3, 1]
[1, 1, 3, 7, 41, 'hello', 'list', 'python']
['python', 'list', 'hello', 41, 7, 3, 1, 1]

list还可以实现嵌套list：

mylist2 = [123, 'hello']
mylist2 = [456, 'python']
mylist1 = [ mylist2, mylist2 ]
print mylist1
print mylist1[0][0]  #输出第一个list中的第一个

4.元组

python还有一个元组的概念，用法类list类似，但是使用()标志，内部也是使用逗号。唯一的区别是元组不能二次赋值，相当于只读。

python提供了list转元组的功能：

mylist=[1,3,41,7,1]
print mylist
mylist = tuple(mylist)
print mylist

结果:

[1, 3, 41, 7, 1]
(1, 3, 41, 7, 1)

在python3.0 中 元祖还有两个和专有的可调用方法，但它的专有方法不想列表拥有那么多

>>>T = (1,2,3,4)

>>>T.index(4) 

3

>>>T.count(4)

1

与列表和字典一样 元祖支持混合类型的嵌套，但是不能增长或缩短，它们都是个不可变的

>>>T = ('ap' , 3.0,[11,22,33])

>>>T[1]

3.0

>>>T[2][1]

22

* 有了列表为什么还要用元组，因为元组提供了一套完整性的约束，即不可变。如果有重要的server消息传回或者需要发出的话可防止意外的修改

5.字典

字典也是一种很灵活的数据类型，基本用法跟list相似，不过list是有序的，字典是无序的。

字典是通过键值来存取的，他使用{}标志，由key和value组成。详细看下例子吧

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值,list的只能是数字
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict['dept']     # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

print tinydict['code']+=1  # 输出通过键对字典进行索引来读取或改变所关联的值

结果：

>>>   
This is one  
This is two  
{'dept': 'sales', 'code': 6734, 'name': 'john'}  
sales  
['dept', 'code', 'name']  
['sales', 6734, 'john']  
[python] view plain copy
['sales', 6735, 'john']  
  

字典的嵌套
>>> Info = { ‘name’: { 'A' :'A1' ,‘B’ : ‘B1’ },
'job' : [ 'Work1' , ' Work2' ],
'age' : 30.5 }
字典的键：name  job  age
值的部分：嵌套字典作为name的值    嵌套列表作为job的值  
取值：
>>> Info['name']
{'A' :'A1' ,‘B’ : ‘B1’ }


>>>Info['name']['A']
'A1'


>>>Info['job'][-1]
'Work1'


>>>Info['job'].append('Work3')
>>>Info['job']
['Work1','Work2','Work3']


*当不在需要这个对象时，必须小心的释放对象空间。Info = 0


字典的排序
字典是无序的，但是如果特定情况需要排序的话：
>>> data = { 'a':1,'b':2,‘c’:3}
>>> data
{ 'a':1,‘c’:3,'b':2}
>>>ks = list(data.keys())
>>>ks
['a','c','b']
>>> ks.sort()
>>>ks
['a','b','c']


>>>for key in ks:
print(key,'=>',data[key]) //此处为3.x打印方式。2.x print
a =>1
b =>2
c =>3



特殊类型：文件

文件对象是python代码对电脑上外部文件的主要接口也是核心类型之一。

特殊性：没有特定的常量语法创建文件。要创建一个文件对象，需要调用内置open函数以字符串形式传递一个外部的文件名以及一个处理模式的字符串

写入：

>>>f = open('data.txt','w')

>>>f.write('hello\n')

6

>>>f.write('world\n')

6

f.close

读取：

>>> f=open('data.txt')

>>>text = f.read()

>>>text

'hello\nworld\n'

集合

集合不是映射也不是序列，他是唯一的不可变的对象的无序集合。集合更像是一个无值的字典的键

>>> X=set('spam') # 2.6 and 3.0

>>>Y={'h','a','m'}   #3.0

>>>X,Y

( {'a','p','s','m'},{'a','h','m'} )

（需要导包用的时候介绍随版本有差异）

十进制数

分数

6.数据类型转换  


int 函数可以把数字型字符串和浮点数 转换成整数
例如：


x=9.99  
y="1234"  
nx=int(x)  
ny=int(y)  
print nx  
print ny结果：  

>>>   
9  
1234注意，如果y="1234a"带有字母，是不能转换的，会报错  


float函数可以把数字型字符串和整数数 转换成浮点数


x=9  
y="12.34"  
nx=float(x)  
ny=float(y)  
print nx  
print ny结果：  

>>>   
9.0  
12.34同样，如果y="12.34a"带有字母，是不能转换的，会报错  
  
str函数可以把数字转换成字符串  


x=9  
y=12.34  
nx=str(x)  
ny=str(y)  
print nx  
print ny结果：  

>>>   
9  
12.34看不出变化，那怎么知道是否正确呢？  

我们可以使用type()来查看该变量的数据类型，例如：

x=9  
nx=str(x)  
print type(x)  
print type(nx)结果：  


>>>   
<type 'int'>  
<type 'str'>  
还有一些其他的数据转换类型，可能用得不多，后面如果有需要会说到。  
现在全部发出来给大家参考，自行实验  
  

函数
描述
  
int(x [,base])
将x转换为一个整数


long(x [,base] )
将x转换为一个长整数


float(x)
将x转换到一个浮点数


complex(real [,imag])
创建一个复数


str(x)
将对象 x 转换为字符串
  


repr(x)
将对象 x 转换为表达式字符串
  


eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象


tuple(s)
将序列 s 转换为一个元组
  
list(s)
将序列 s 转换为一个列表


set(s)
转换为可变集合


dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。
 
frozenset(s) 
转换为不可变集合
  
chr(x)
将一个整数转换为一个字符


unichr(x)
将一个整数转换为Unicode字符


ord(x)
将一个字符转换为它的整数值


hex(x)
将一个整数转换为一个十六进制字符串


oct(x)
将一个整数转换为一个八进制字符串


  
好了，基本数据类型说得差不多了，下一节开始学习语句  

 
 

  
  >>>f.write('hello\n')