首页 > 编程语言 > 详细

python3数据类型_2

时间:2015-12-29 19:24:49      阅读:213      评论:0      收藏:0      [点我收藏+]

python中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

在Python中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。

Python3中有六个标准的数据类型:

  • Numbers_数字
  • String_字符串
  • List_列表
  • Tuple_元组
  • Sets_集合
  • Dictionaries_字典

Numbers(数字)

Python3支持int(整形)、float(浮点数)、bool(布尔型)、complex(复数)。

数值类型的赋值和计算都是很直观的,就像大多数语言一样。内置的type()函数可以用来查询变量所指的对象类型。例如:

1 >>> a,b,c,d = 20,5.5,True,4+3j
2 >>> print(type(a),type(b),type(c),type(d))
3 <class int> <class float> <class bool> <class complex> #用tpye()查看变量的数据类型
4 >>> exit()

数值运算:

 1 >>> 1+2 #加法
 2 3
 3 >>> 3.1-1 #减法
 4 2.1
 5 >>> 2*3 #乘法
 6 6
 7 >>> 2/4 #除法
 8 0.5
 9 >>> 2//4 #取整
10 0
11 >>> 17%3 #取余
12 2
13 >>> 2**5 #乘方
14 32

ps:

  • 1、Python可以同时为多个变量赋值,如a, b = 1, 2。
  • 2、一个变量可以通过赋值指向不同类型的对象。
  • 3、数值的除法(/)总是返回一个浮点数,要获取整数使用//操作符。
  • 4、在混合计算时,Python会把整型转换成为浮点数。

String(字符串)

Python中的字符串str用单引号(‘‘)或双引号("")括起来,同时使用反斜杠(\)转义特殊字符。

>>> a = Yes,he doesn\‘t
>>> print(a,type(a),len(a))
Yes,he doesnt <class str> 14

如果你不想让反斜杠发生转义,可以在字符串前面添加一个r,表示原始字符串:

1 >>> print(C:\some\name)
2 C:\some
3 ame
4 >>> print(rC:\some\name)
5 C:\some\name
6 >>> 

另外反斜杠可以作为续航符,表示上一行时下一行的延续,还可以使用"""..."""或者‘‘‘...‘‘‘跨越多行。

字符串可以使用+运算符串联接在一起,或者用*运算符重复:

1 >>> print(str+ing,my*3)
2 string mymymy

Python中的字符串有两种索引方式,第一种是从左往右,从0开始依次增加;从-1开始依次减少。

注意,没有单独的字符类型,一个字符就是长度为1的字符串。

1 >>> word = Python
2 >>> print(word[0],word[5])
3 P n
4 >>> print(word[-1],word[-6])
5 n P

还可以对字符串进行切片,获取一段字符串。用冒号分隔两个索引,形式为变量[头下标:尾下标]。

截取范围是前闭后开的,并且两个索引都可以省略;

 1 >>> word = ilovepython
 2 >>> word[1:5]
 3 love
 4 >>> word[:]
 5 ilovepython
 6 >>> word[5:]
 7 python
 8 >>> word[-10:-6]
 9 love
10 >>> 

注意:

  • 反斜杠可以用来转义,使用r可以让反斜杠不发生转义
  • 字符串可以用+运算符连接在一起,用*运算符重复
  • Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。
  • Python中的字符串不能改变

List(列表)

List(列表)是Python中使用最频繁的数据类型。

列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同:

>>> a = [him,23,554,her]
>>> print(a)
[him, 23, 554, her]

和字符串一样,列表同样可以被索引和切片,列表被切片后返回一个包含所需元素的新列表。

列表还支持串联操作,使用+操作符:

1 >>> a = [1,2,3,4,5]
2 >>> a
3 [1, 2, 3, 4, 5]
4 >>> a + [6,7,8]
5 [1, 2, 3, 4, 5, 6, 7, 8]

与Python字符串不一样的是,列表的元素是可以改变的:

 1 >>> a = [1,2,3,4,5,6]
 2 >>> a[0] = 9 #取值,0表示列表的索引也叫下标
 3 >>> a
 4 [9, 2, 3, 4, 5, 6]
 5 >>> a[2:5]
 6 [3, 4, 5]
 7 >>> a[2:5] = [13,14,15]
 8 >>> a
 9 [9, 2, 13, 14, 15, 6]
10 >>> a[2:5] = [] #删除2-5标志位的元素
11 >>> a
12 [9, 2, 6]

List内置方法

使用dir()可以查看看列表的内置方法:

1 >>> dir(a)
2 [__add__, __class__, __contains__, __delattr__, __delitem__, __dir__, __doc__, __eq__, __format__, __ge__, __getattribute__, __getitem__, __gt__, __hash__, __iadd__, __imul__, __init__, __iter__, __le__, __len__, __lt__, __mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __reversed__, __rmul__, __setattr__, __setitem__, __sizeof__, __str__, __subclasshook__, append, clear, copy, count, extend, index, insert, pop, remove, reverse, sort]

详细的使用方法使用help(a)

常用的有‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘这些个:

技术分享
Help on list object:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterables items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the  iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  __hash__ = None
 (END)
help(a)

append()追加

1 >>> name_list = [zk,dgs,xx]
2 >>> name_list
3 [zk, dgs, xx]
4 >>> name_list.append(wyj)
5 >>> name_list
6 [zk, dgs, xx, wyj]

追加就是放到最后

index()索引值

查找name_list中zk的索引值

>>> name_list.index(zk)
0

从0开始查找找到一个就停止

count()统计

在name_list中在追加一个元素zk,然后统计zk元素的的个数:

1 >>> name_list
2 [zk, dgs, xx, wyj]
3 >>> name_list.append(zk)
4 >>> name_list
5 [zk, dgs, xx, wyj, zk]
6 >>> name_list.count(zk)
7 2

extend()扩展

可以把两个列表和到一起

1 >>> name_list
2 [&, dgs, wyj, zsm, 22]
3 >>> b = [1,2,3]
4 >>> name_list.extend(b)
5 >>> name_list
6 [&, dgs, wyj, zsm, 22, 1, 2, 3]

insert()插入

在name_list列表中dgs中插入一个值:

1 >>> name_list
2 [zk, dgs, xx, wyj, zk]
3 >>> name_list.insert(2,zsm)
4 >>> name_list
5 [zk, dgs, zsm, xx, wyj, zk]
6 >>> 

pop()删除一个

1 >>> name_list
2 [zk, dgs, zsm, xx, wyj, zk]
3 >>> name_list.pop()
4 zk
5 >>> name_list
6 [zk, dgs, zsm, xx, wyj]

可以发现删除的是最后的一个元素

remove()指定删除一个

现在指定删除xx这个元素:

1 >>> name_list
2 [zk, dgs, zsm, xx, wyj]
3 >>> name_list.remove(xx)
4 >>> name_list
5 [zk, dgs, zsm, wyj]

reverse()反转

先查看name_list里面的元素,在反转可以看到name_list中的元素全部倒过来了:

1 >>> name_list
2 [zk, dgs, zsm, wyj]
3 >>> name_list.reverse()
4 >>> name_list
5 [wyj, zsm, dgs, zk]

sort()排序

在Python3中数据类型不一样无法排序,如下:

 1 >>> name_list.append(&)
 2 >>> name_list.append(22)
 3  name_list
 4 [wyj, zsm, dgs, zk, &, 22]
 5 >>> name_list.sort()
 6 Traceback (most recent call last):
 7   File "<stdin>", line 1, in <module>
 8 TypeError: unorderable types: int() < str()
 9 >>> type(name_list[-1])
10 <class int>
11 >>> type(name_list[0])
12 <class str>

全是数字的方式:

1 >>> num_lsit = [321,534,765,23,768]
2 >>> num_lsit
3 [321, 534, 765, 23, 768]
4 >>> num_lsit.sort()
5 >>> num_lsit
6 [23, 321, 534, 765, 768]

 

扩展:

name_list中在插入一个元素zk,就有两个元素zk了,现在想把两个zk全部删除怎么办呢?

可以根据上面的方法,先去找一共有多少个元素zk,然后循环找到的个数,删除指定的。

1 >>> for i in range(name_list.count(zk)): #循环查找zk这个元素的次数
2 ...     name_list.remove(zk)  #指定删除zk元素
3 ...     
4 >>> name_list
5 [&, dgs, wyj, zsm, 22]

这样就把列表name_list中zk元素给删除了

 

Tuple(元组)

元组和列表类似,不同之处在于元组的元素不能修改。元组写在小括号里,元素之间用逗号隔开。

元组中的元素类型也可以不相同:

1 >>> a = (123,456,test,math)
2 >>> a
3 (123, 456, test, math)
4 >>> print(a,type(a),len(a))
5 (123, 456, test, math) <class tuple> 4

元组与字符串类似,可以被索引且下标索引从0开始,也可以进行截取切片。

其实可以把字符串看做一种特殊的元组。

1 >>> tup = (1,2,3,4,5,6)
2 >>> print(tup[0],tup[1:5])
3 1 (2, 3, 4, 5)
4 >>> tup[0] = 11  #元组中的元素是不能修改的
5 Traceback (most recent call last):
6   File "<stdin>", line 1, in <module>
7 TypeError: tuple object does not support item assignment

虽然tuple的元素是不能修改的,但它可以包含可变的对象,比如list列表。

构造包含0个或1个元素的元组是个特殊的问题,所以有一些额外的语法规则:

1 >>> tup1 = ()  #空元组
2 >>> tup2 = (10)  #用常规方法创建一个只有一个值元组的元素
3 >>> tup3 = (20,)
4 >>> print(tup1,type(tup1))
5 () <class tuple>
6 >>> print(tup2,type(tup2))  #可以看到这种方法创建的只是一个数据类型
7 10 <class int>
8 >>> print(tup3,type(tup3))  #所以创建只有一个值的元组时需要在值的后面加上一个逗号
9 (20,) <class tuple>

另外,元组也支持用+操作符:

1 >>> tup1 = (1,2,3)
2 >>> tup2 = (4,5,6)
3 >>> print(tup1+tup2)
4 (1, 2, 3, 4, 5, 6)

string、list和tuple都属于sequence(序列)

注意:

  • 与字符串一样,元组的元素不能修改
  • 元组也可以被索引和切片,方法一样
  • 注意构造0个或者一个元素的特殊语法和规则
  • 元组也可以使用+操作符进行拼接

Sets(集合)

集合是一个无序不重复元素的集。

基本功能是进行成员关系测试和消除重复元素。

可以使用大括号或者set()函数创建set集合,注意:创建一个空集合必须用set()而不是{},因为{}是用来创建一个空的字典的。

 1 >>> student = {Tom,Jim, Mary, Tom, Jack, Rose}  #创建一个集合
 2 >>> print(student)  #自动去重
 3 {Tom, Jack, Mary, Rose, Jim}
 4 >>> Rose in student  #测试成员有就为True
 5 True
 6 >>> zk in student  #没有就为False
 7 False
 8 >>> 
 9 >>> a = set(aglajgljasgjasl)
10 >>> b = set(qwetoqurnajksdfhagshdsjf)
11 >>> a
12 {g, j, l, a, s}
13 >>> b
14 {u, j, q, w, o, k, f, a, h, t, r, s, d, g, e, n}
15 >>> a - b  #a和b的差集
16 {l}
17 >>> a | b  #a和b的并集
18 {u, q, f, a, t, r, s, d, j, w, o, k, h, g, l, e, n}
19 >>> a & b  #a和b的交集
20 {g, j, a, s}
21 >>> a ^ b  #a和b不同时存在的元素
22 {u, q, f, t, r, d, w, o, k, h, l, e, n}
23 >>> 

 

Dictionarie(字典)

字典是Python中另一个非常有用的内置数据类型。

字典是一种映射类型(mapping type),它是一个无序的建:值对集合。

关键字必须使用不可变类型,也就是说list和包含可变类型的tuple不能做关键字。

在同一个字典中,关键字还必须互不相同。

 1 >>> dic = {}     #创建一个空的字典
 2 >>> tel = {Jack:1557,Tom:1320,Rose:1886}
 3 >>> tel
 4 {Tom: 1320, Jack: 1557, Rose: 1886}
 5 >>> tel[Jack]  #通过key查询对应的值
 6 1557
 7 >>> del tel[Rose]  #删除一个建值
 8 >>> tel
 9 {Tom: 1320, Jack: 1557}
10 >>> tel[Mary] = 4127  #添加一个键值
11 >>> tel
12 {Tom: 1320, Jack: 1557, Mary: 4127}
13 >>> list(tel.keys())  #返回所有key组成的list
14 [Tom, Jack, Mary]
15 >>> sorted(tel.keys())  #按key排序
16 [Jack, Mary, Tom]
17 >>> Tom in tel  #测试成员
18 True
19 >>> Tom not in tel
20 False
21 >>> 

构造函数dict()直接从键值对sequence中构建字典,当然也可以进行推导,如下:

1 >>> dict([(sape, 4139), (guido, 4127), (jack, 4098)])
2 {sape: 4139, jack: 4098, guido: 4127}
3 >>> {x: x**2 for x in (2, 4, 6)}
4 {2: 4, 4: 16, 6: 36}
5 >>> dict(sape=4139, guido=4127, jack=4098)
6 {sape: 4139, jack: 4098, guido: 4127}

另外,字典类型也有一些内置函数,例如clear()、keys()、values()等。

注意:

  • 字典是一种映射类型,它的元素是键值对
  • 字典的关键字必须为不可变类型,而且不能重复
  • 创建空字典使用{}

python3数据类型_2

原文:http://www.cnblogs.com/allan-king/p/5086643.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!