python不同类型的数据不能相互运算_Python学习笔记 - 3 - 数据类型及运算符

Python的数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：数值型、字符串型、列表型、元组型、字典型。

数值类型

顾名思义就是数字类型，但数字类型内部又分为：整型、浮点型、长整型、复数型

整数类型

整数类型的范围是2**32，其中包含正数和负数(2的31次方个正和2的31次方的个负数，所以它的范围是-2147483648 ——— 214748364。

PS:查看一个数据的类型使用type(数据)方法

In [1]: a=1

In [2]: type(a)

Out[2]: int # int表示为整型

In [18]: type(2/1)

Out[18]: int

浮点型

浮点类型就是带小数点的，多余的位数会被四舍五入。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的(除法难道也是精确的？是的！)，而浮点数运算则可能会有四舍五入的误差。

In [3]: a=1.23

In [4]: type(a)

Out[4]: float　　# float表示的是浮点数

In [19]: type(2.0/1)

Out[19]: float

长整型

用l或L表示，当我们赋值的时候使用l可以把变量赋值为长整型，注意在Python3中已经取消了长整型这个格式。

In [11]: a=1299999999999999999999999999999999999999999

In [12]: type(a)

Out[12]: long　　　　#long表示长整型

In [13]: a

Out[13]: 1299999999999999999999999999999999999999999L

In [15]: a=123l

In [16]: type(a)

Out[16]: long

#只有python2.x中有长整型的概念，python3.x只有整型

复数型

用j表示，当我们赋值的时候使用j可以把变量赋值为复数型，python对复数提供内嵌支持。(其他大部分软件没有)

复数一般用于科学计算，我们日常一般不会使用，这里知道即可。

In [20]: type(123j)

Out[20]: complex # 表示复数类型

字符串类型

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。有三种方法定义字符串：单引号，双引号，三引号。

str='this is string'

str="this is string"

str='''this is string''' #也可以是三个双引号，三个引号可以多行注释但是不能单双混合

其中三重引号除了能定义字符串以外，还可以表示注释。

字符串的基本操作

字符串是一个序列，可以通过索引和切片去操作

索引

类似数组的下标：

In [3]: a='1234567'

In [4]: a[0] -->#下标从0开始，0表示第一个数

Out[4]: '1'

In [5]: a[3] -->#表示第四个数

Out[5]: '4'

切片

类似shell变量的截取：

In [14]: a='abcd'

In [15]: a[0:2]

Out[15]: 'ab'

#从第0个开始截取2个字符，其中0可以省略

In [14]: a='abcd'

In [16]: a[:-1]

Out[16]: 'abc'

#默认是从左往右(前往后)，带减号，表示从右往左(后往前)，-1表示最后一个字符(a='abcd',-1的值是d，也就是3，顾a[:-1]，就等于a[0:3])

In [14]: a='abcd'

In [17]: a[1:]

Out[17]: 'bcd'

#从1开始截取到最后

In [14]: a='abcd'

In [20]: a[::2]

Out[20]: 'aceg'

#步长为2，表示从0开始步长为2，(取0,2,4,6)

In [26]: a

Out[26]: 'abcdefg'

In [27]: a[-5:-1]

Out[27]: 'cdef'

#表示倒着取，从倒数第五个取到倒数第一个(不包含倒数第一，要想取可以使用a[-5:])

In [29]: a

Out[29]: 'abcdefg'

In [30]: a[0:5:1]

Out[30]: 'abcde'

In [31]: a[0:5:2]

Out[31]: 'ace'

#从0开始取到第5个，步长为1，步长为2

In [32]: a

Out[32]: 'abcdefg'

In [34]: a[-1::-1]

Out[34]: 'gfedcba'

#从后往前取，步长为-1，表示每次倒着取1个，由于没有指定结尾，默认到最后，所以就把数字逆了过来。

In [36]: a

Out[36]: 'abcdefg'

In [38]: a[::2][:2]

Out[38]: 'ac'

#表示先每隔2个取出来，然后从头开始取2个。

字符串的内置方法

字符串是Python中的主要数据类型，其内置了非常多的方法，主要方法如下：

# 功能：首字母大写

# 调用方式：string.capitalize()

# 例：

name = 'hello' name.capitalize()

#结果：

'Hello'

capitalize

# 3.x新增 字符串转换为小写，可以转换各种语言大小写(法语、德语...)

# 用法 ：string.casefold()

例子：

name = 'HELLO'

name.casefold()

结果： 'hello'

casefold

# 功能：字符串转换为小写，只能转换英文字母

# 用法：string.lower()

例：

name = 'World'

name.lower()

结果：

'world'

lower

# 功能：文本填充，width为字符串的总长度，str居中然后两端用fillcharacter填充，fillchar默认为空格

# 用法：str.center(width,filechar=None)

例:

name = 'hello'

name.center(7,'*')

结果：

*hello*

center

# 功能：sub为统计的字符串(子序列),统计sub出现的次数，start为起始位置，end为结尾位置

# 用法：str.counter(sub,start=None,end=None)

例：

name = 'hello'

name.counter('l')

结果：

2

counter

# 功能：以suffix为开头，返回bool值,start起始位置，end结束位置

# 用法：str.startswith(suffix,start=None,end=None)

例：

name = 'Hello'

name.startswith('H')

结果：

True

startswith

# 功能：以suffix为结尾，返回bool值,start起始位置,end结束位置

# 用法：str.endswith(suffix,start=None,end=None)

例：

name = 'world'

name.endswith('d')

结果：

True

endswith

序列类型

字符串、列表和元组都是序列的一种，序列的两个主要特点是索引操作符和切片操作符

索引操作符让我们可以从序列中抓取要给特定的项目

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

序列类型的基本操作方法

序列同样支持索引和切片操作，但是字符串、列表、元组的索引和切片又有些许不通

len()

计算字符串的长度

In [7]: a='123'

In [8]: len(a)

Out[8]: 3

In [9]: len('123')

Out[9]: 3

+

加号在这里并不是加减乘除的意思，而是用来连接两个序列

In [10]: a

Out[10]: '123'

In [11]: a + '4'

Out[11]: '1234'

#字符串和数字不能连接到一起

*

重复序列元素(字符串的时候)

In [18]: '#' * 10

Out[18]: '##########'

#当变量为数字的时候就为乘了。

in

判断元素是否在序列中

In [23]: a = 'abcd'

In [24]: 'a' in a

Out[24]: True

#当字符串在某个序列中的时候返回真，否则返回假(not in表示不在)

max(),min()

求最大值和最小值

In [25]: max(a)

Out[25]: 'd'

In [26]: min(a)

Out[26]: 'a'

In [27]: a

Out[27]: 'abcd'

注意：如果对字符进行对比，程序内部会把字符转换成ascii码对应的数字进行比较。

>>> ord('a')

97

>>> ord('b')

98

>>> ord('c')

99

>>>

cmp()

比较两个序列是否相等

#若相等则返回0，若前大于后则返回正数，若后大于前则返回负数

In [30]: cmp("123","456")

Out[30]: -1

In [33]: cmp("789","456")

Out[33]: 1

In [34]: cmp("456","456")

Out[34]: 0

#注意cmp的比较是从左向右开始比对的，大于就返回1，小于就返回-1，等于就继续向后比对

In [43]: cmp('5','456')

Out[43]: 1

In [44]: cmp('45','456')

Out[44]: -1

In [45]: cmp('455','456')

Out[45]: -1

In [46]: cmp('457','456')

Out[46]: 1

元组概念

元组(类型为 tuple)和列表十分相似

元组和字符串一样是不可变的

元祖的特点

元组可以存储一系列的值，使用括号来定义。

元组通常用在用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变，不可变的含义是：不能改变这个值中的某个字符。

元祖也通常用来接收函数的返回值。

In [8]: a='123456'

In [9]: a[-1]

Out[9]: '6'

In [10]: a[-1]=1

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 a[-1]=1

TypeError: 'str' object does not support item assignment

In [11]:

#变量a是可以被定义成任何值的，但是不能在定义之后，修改里面的值，如果想要修改就需要重新定义这个变量

In [11]: a='123451'

In [13]: a[-1]

Out[13]: '1'

定义一个元组

使用()来表示定义的是元组，但是如果元组里面的值只有一个的话，需要加在值后面加上，(逗号)，表示是一个元组。

另外，元组中可以同时储存不同类型的数据，也可以引用其他元组。

In [18]: t=(1)

In [19]: type(t)

Out[19]: int

In [20]: t=(1,)

In [21]: type(t)

Out[21]: tuple # tuple表示元组类型

#引用其他元组

In [22]: a=(1,2,3)

In [23]: t=('123',a)

In [24]: t

Out[24]: ('123', (1, 2, 3))

#通过索引只引用某一个值

In [27]: t=('123',a[1])

In [28]: t

Out[28]: ('123', 2)

元祖的基本操作方法

元组和其他数据类型相同，它支持的操作如下。

元祖的拆分

通过变量去接收元组中的值

In [34]: a=('123','456')

In [35]: first,second=a 　　--> # 定义first接收元组的第一个值，second接收元组的第二个值

In [36]: first

Out[36]: '123'

In [37]: second

Out[37]: '456'

#注意接收值的变量要与元组中的值的个数保持一致，若元组中有3个值，必须定义三个变量去接收，否则无法接收(当元组中有两个值的时候，用一个变量去接不会报错，但是也还是用元组的形式表达)

PS：假如元祖中有三个元素，那么我们可以定义3个变量来接受元祖的值，如果元祖中有4个元素，那么我们只能通过定义1个或者定义4个来接受，定义1个就等于元祖复制，定义4个才表示接受元素

PS：如果我们不想要某个元素的时候，可以使用_,来获取，分割元组的时候可以有如下操作。

>>> a = ('a','b','c','d')

>>> a,b,_,d = a

>>> a

'a'

>>> b

'b'

>>> d

'd'

>>>

_忽略部分元素的方法

元组的方法

如果安装了ipython可以通过tab键查看元组的方法，如果没有安装，就需要使用dir(元组名)去查看了

# 会列出一些内饰的属性，和方法

>>> dir(a)

['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

>>>

# 已__开头的先忽略，后面会讲，所以可以看到有两个方法。

# 使用help查看使用方法

In [3]: help(a.count)

count(...)

T.count(value) -> integer -- return number of occurrences of value

# a.count(value) 用来统计value在元组中出现的次数，不存在返回0。

In [4]: a=('1','2','3')

In [7]: a.count("4")

Out[7]: 0

In [8]: a.count("1")

Out[8]: 1

# a.index(value) 用来返回value在元组中的索引，如果value不在元组中，则会报错。如果有多个，默认返回第一个(可以指定从哪个索引开始查找到某个索引结束，指定范围区间)

In [4]: a=('1','2','3')

In [9]: a.index('1')

Out[9]: 0

In [10]: a.index('3')

Out[10]: 2

>>> t1

('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

>>> t1.index('a',5,7)

6

列表类型

列表(类型为 list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。

列表是可变类型的数据，创建列表使用[]中括号。

列表的基本操作

list是一种有序的集合，可以随时添加和删除其中的元素。它的方法有很多，这里列举主要的方法。

创建一个空的列表

# 1、创建一个空列表

list1 = []

list2 = list() # 工厂函数

# 2、创建列表并赋值

list3 = ['a',1,2]

# 3、列表可以包含变量，元组，列表等

In [15]: a=123

In [16]: b=['123',a,(1,),["hello","python"]]

In [17]: b

Out[17]: ['123', 123, (1,), ['hello', 'python']]

In [24]: len(b)

Out[24]: 4

#一共有4个变量

# 4、列表的值是可以改变的

In [25]: b

Out[25]: ['123', 123, (1,), ['hello', 'python']]

In [26]: b[0]

Out[26]: '123'

In [27]: b[0]=456

In [29]: b

Out[29]: [456, 123, (1,), ['hello', 'python']]

列表的追加

使用append在list的后面(右边)

In [30]: a=[]

In [31]: type(a)

Out[31]: list

In [32]: a.append("linux")

In [33]: a

Out[33]: ['linux']

列表的组合

使用+，对多个列表进行拼接

In [32]: a = [456, 123, (1,)]

In [33]: b = [['hello', 'python'], 'linux']

In [34]: b + a

Out[34]: [456, 123, (1,), ['hello', 'python'], 'linux']

In [35]: (b + a) * 2 # 重复2次

Out[35]:[456, 123, (1,), ['hello', 'python'], 'linux', 456, 123, (1,), ['hello', 'python'], 'linux']

>>>

列表的删除

使用list的remove方法删除一个元素

In [38]: b = [456, 123, (1,), ['hello', 'python'],'love']

In [39]: b.remove('love')

In [40]: b

Out[40]: [456, 123, (1,), ['hello', 'python']]

#直接移出元素名，如果有两个，则默认删除匹配的第一个。

In [55]: b

Out[55]: [123, 456, ['hello', 'python'], '123', (1,)]

In [56]: del b[0]

In [57]: b

Out[57]: [456, ['hello', 'python'], '123', (1,)]

#如果知道变量的索引可以直接通过del来进行删除，del还可以直接删除变量

列表的反转

使用list的reverse方法进行原地倒序。

In [41]: b = [456,123, (1,),['hello', 'python']]

In [42]: b.reverse()

In [43]: b

Out[43]: [['hello', 'python'], (1,), 123, 456]

列表的插入

使用list的insert进行数据的插入

In [47]: b

Out[47]: [456, 123, (1,), ['hello', 'python']]

In [48]: b.insert(0,'123')

In [49]: b

Out[49]: ['123', 456, 123, (1,), ['hello', 'python']]

# 在索引0的位置插入一个元素‘123’

查找列表中变量

In [62]: b

Out[62]: [456, ['hello', 'python'], '123', (1,)]

In [63]: '123' in b

Out[63]: True

In [65]: "a" in b

Out[65]: False

# 存在返回True,否则返回False

变量的修改

In [68]: b

Out[68]: [456, ['hello', 'python'], '123', (1,)]

In [69]: b[0]='123'

In [70]: b

Out[70]: ['123', ['hello', 'python'], '123', (1,)]

# 修改b的索引0的元素值为‘123’

字典类型

使用大括号定义，是Python中唯一的映射类型(哈希表)

字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的key。像元组，字符串等都是不可变的，都可以作为key。而列表是可变的，无法作为key。key是唯一的

字典的方法

字典有很多的方法，这里仅列举常用的方法，其他方法可以使用dir(dict)查看keys() 获取字典的key

values() 获取字典中所有的values

items() 把字典转换成列表

get() 如果字典中有该key，则返回key值，如果没有，则返回空，也可以自己定义返回值

dic.get('Name','python')，如果存在name，则返回values，否则返回Python

has_key('key') 判断key的是否存在，存在返回True，否则返回False

dic1 = dic.copy() 拷贝字典到一个新的字典中去

clear() 清除字典中的元素

pop() 删除一个key，同时打印该key的value，如果key不存在，则返回keyerror，或者指定返回值 dic.pop('name',True)

update() 把一个字典更新(添加)到另一个字典中

fromkeys(s,value) 把序列s，作为字典的key，如果不给value，则默认是none，如果指定value，那么所有key对应的值都为value

类型转换

注意虽然在Python中有很多的数据类型，但是这些类型是可以相互转换的，那么就要用到了俗称工厂函数的东西：str、list、dict、tuple等等。str()：用于把整型、浮点型等转换为字符串

list()：用于把一个可迭代对象转换为列表

dict()：把一个可迭代对象(每次迭代返回两个数据)，转换为字典

tuple()：把一个可迭代对象转换为元组

运算符表达式

python运算符：赋值运算符、算数运算符、关系运算符、逻辑运算符

python表达式：是将不同的数据(包括变量、函数)用运算符号按一定规则连接起来的一种式子。

赋值运算符

= 表示赋值，当把数字赋值给一个变量的时候不用加引号，而赋值字符串给变量的时候就需要加引号了，否则python认为你赋值的是另一个变量。

=：x=3 ,y='abc'

+= ：x+=2，表示x=x+2

-=：x-=2，表示x=x-2

*=：x*=2,表示x=x*2

/=：x/=2，表示x=x/2

%=：x%=2，表示取余，x对2取余数，加入x=6，那么取余为0

PS：Python下不用指定变量的类型，它会自动根据你赋值的类型来定，使用type(x) 来查看变量的类型。

算数运算符

+ 加 用来计算数字，如果字符串、列表等相加，等于是把两个对象拼到一起

- 减

* 乘

/ 除，4/3,默认是整除，为了得到小数，可以把其中一个变量变成浮点型，4.0/3或4/3.0

// 表示只取整数，4.0/3 答案是1.33333，如果用4.0//，因为取整则，答案是1

% 取余数

** 表示乘方 2**3 表示2的3次方

关系运算符

返回值为布尔值：true or false

> 1>2,值是false

< 1<2,值是true

>= 1>=2,值是false

<= 1<=2,值是true

== 1==2，值是flase

!= 1!=2,值是true

逻辑运算符

返回值为布尔值：true or false

and：逻辑与，只要有1个是false那么值就是false，1==2 and 1<2 ，值是false， 1!=2 and 1<2，值是true

or：逻辑或,只要有一个是true那么值就是true，1=2 and 1<2 ，值是true

not：逻辑非，取反 not 1<2，值是true

其他特殊符号

in/no in 成员测试，测试一个元素是否在一个序列中

is /is not 统一性的测试

练习

写一个四则运算器，从键盘读取数字可以使用input()或raw_input()

input()函数，一般用来接收数字，当我们输入字符串的时候，它会报错，如果需要用字符串那么需要用引号引起来

raw_input()函数，一般用来接收字符串，当我们输入数字的时候，它也会用引号引起来，表示是字符串

input方式

#!/usr/bin/env python

# _*_coding:utf-8_*_

# __time__: 2017/10/17 22:54

# __author__: daxin

# __file__: text.py∂

num1 = input("Please input a number:")

num2 = input("Please input a number:")

print " %s + %s = %s " % (num1,num2,num1+num2)

print " %s - %s = %s " % (num1,num2,num1-num2)

print " %s * %s = %s " % (num1,num2,num1*num2)

print " %s / %s = %s " % (num1,num2,num1/num2)