python标准数据类型与运算符

版权声明：本文为博主原创文章，欢迎一起学习交流。 https://blog.csdn.net/ym01213/article/details/86588749

标准数据类型

Python3有六个标准的数据类型：

1. Number（数字）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Set（集合）
6. Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据类型（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据类型（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

Python3 支持 int、float、bool、complex（复数）。只有一种整数类型 int，表示为长整型，没有 python2 中的 Long类型。

type() 函数可以用来查询变量所指的对象类型。

>>> a,b,c,d = 20,1.2,True,4+3j
>>> a
20
>>> b
1.2
>>> c
True
>>> d
(4+3j)
>>> print(type(a),type(b),type(c),type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

String（字符串）

字符串的本质是：字符序列。字符串是不可变的。

字符串截取（左闭右开区间），返回一个新对象。

加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。

>>> str = 'pythonstr'
>>> str[1:]
'ythonstr'
>>> str[-4:-2]
'ns'
>>> str[:5]
'pytho'
>>> str[:-5]
'pyth'
>>> str[1:-5]
'yth'
>>> str+' test'
'pythonstr test'
>>> str*2
'pythonstrpythonstr'

字符串序列中元素不可变！

>>> str[2] = 2
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    str[2] = 2
TypeError: 'str' object does not support item assignment

类型转换，使用str(变量名)

List（列表）

Python 中使用最频繁的数据类型，可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），有序可重复。

创建List的方法有“[]创建”，“list()创建”，“range()创建整数列表”，“推导式”。

>>> a = []  创建空list
>>> b = list('hello')  // list()可以将任何可迭代的数据转化成列表。
>>> b
['h', 'e', 'l', 'l', 'o']
>>> c = list(range(1,10,2)) //range()可以方便的创建整数列表
>>> c
[1, 3, 5, 7, 9]
>>> d = [x*2 for x in range(5)]  //推导式
>>> d
[0, 2, 4, 6, 8]
>>> d = [x*2 for x in range(5) if x%2==0]
>>> d
[0, 4, 8]

a = [10,20,30,40]，序列中存储的是对象的地址，而不是对象的值。

和字符串一样，列表同样可以被索引和截取，变量[头下标：尾下标：步长]，列表被截取后返回一个包含所需元素的新列表。不同的是，列表中的元素是可以改变的。

加号 + 是列表连接运算符，星号 * 是重复操作。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[2] = 5
>>> a
[1, 2, 5, 4, 5, 6]
>>> b = [ 'abcd', 786 , 2.23, 'dv', 70.2 ]
>>> a + b
[1, 2, 5, 4, 5, 6, 'abcd', 786, 2.23, 'dv', 70.2]
>>> a*2
[1, 2, 5, 4, 5, 6, 1, 2, 5, 4, 5, 6]

常用方法

sort()排序修改原列表，不建新列表的排序；
sorted()排序，这个方法返回新列表，

>>> a = [1,2,4,3]
>>> id(a)
2471495094664
>>> a.sort() //默认升序排序
>>> a
[1, 2, 3, 4]
>>> id(a)
2471495094664
>>> a.sort(reverse=True) //降序
>>> a
[4, 3, 2, 1]
>>> id(a)
2471495094664
>>> import random
>>> random.shuffle(a)  //打乱顺序
>>> a
[4, 2, 3, 1]

>>> b = [4,2,3,5]
>>> id(b)
2471495290696
>>> b = sorted(b)
>>> id(b)
2471495300552
>>> b = sorted(b,reverse=True)  //降序
>>> b
[5, 4, 3, 2]

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同。

元组的访问和处理速度比列表快。

创建元组，同list创建方式相同，tuple()可以接收列表、字符串、其他序列类型、迭代器等生成；list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

字符串看作一种特殊的元组，也可以被索引和切片，规则同上。

//创建tuple
>>> a = tuple(range(5))
>>> a
(0, 1, 2, 3, 4)
>>> b = tuple(['a',1,True])
>>> b
('a', 1, True)
>>> c = (1,2,3)
>>> d = zip(a,b,c)
>>> d
<zip object at 0x0000023F709651C8>
>>> list(d)
[(0, 'a', 1), (1, 1, 2), (2, True, 3)]
>>> s = (x*2 for x in range(5))   //生成器
>>> s
<generator object <genexpr> at 0x0000023F709643B8>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s)   //只能访问一次，第二次访问为空，需再生成一次
[]

//排序
>>> sorted(a)
[0, 1, 2, 3, 4]
//拼接
>>> a = (1, 2, 3, 4, 5, 6)
>>> b = (7,8)
>>> a+b
(1, 2, 3, 4, 5, 6, 7, 8)
>>> c = (1,2,3)
>>> a+c
(1, 2, 3, 4, 5, 6, 1, 2, 3)
>>> d = ()
>>> d
()
>>> a[0] = 11  //不能修改元素
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    a[0] = 11
TypeError: 'tuple' object does not support item assignment

string、list 和 tuple 都属于 sequence（序列）。

Dictionary（字典）

字典是无序的对象集合。字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。通过“键对象”实现快速获取、删除、更新对应的“值对象”。列表List中我们通过“下标数字”找到对应的对象，字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。列表、字典、集合这些可变对象，不能作为“键”。并且“键”必须是唯一的。“值”可以是任意的数据，并且可重复。

字典的创建方式：

1、通过{}、dict()创建

//创建空字典
>>> a = {}
>>> b = dict()

>>> c = {'name':'张三','age':12}
>>> d = dict(name='李四',age=14)
//通过元组创建
>>> e = dict([('name','王五'),('age',12)])

2、通过zip创建

>>> key = ['name','age','gender']
>>> value = ['张三',12,'男']
>>> m = dict(zip(key,value))
>>> m
{'name': '张三', 'age': 12, 'gender': '男'}

3、通过fromkeys创建，值为空

>>> keys = dict.fromkeys(['name','age','gender'])
>>> keys
{'name': None, 'age': None, 'gender': None}

字典元素的访问：

1、通过[键对象]获取，如果键对象不存在会报错

>>> m = {'name':'张三','age':12,'gender':'男'}
>>> m
{'name': '张三', 'age': 12, 'gender': '男'}
>>> m['name']
'张三'
>>> m['age']
12
>>> m['date']
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    m['date']
KeyError: 'date'

2、通过get()获取，键对象不存在，返回None，也可设置返回默认值，推荐使用此方式。

>>> name = m.get('name')
>>> name
'张三'
>>> date = m.get('date','1900-02-03')
>>> date
'1900-02-03'

3、items()列出所有的键值对

>>> m.items()
dict_items([('name', '张三'), ('age', 12), ('gender', '男')])

4、列出键与值

>>> m.keys()
dict_keys(['name', 'age', 'gender'])
>>> m.values()
dict_values(['张三', 12, '男'])

5、键是否在字典中

>>> 'name' in m
True
>>> 'date' in m
False

字典的增、删、改

1、给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。

2、使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖。

>>> m = {'name': '王五', 'age': 12, 'gender': '男'}
>>> m2 = {'name': '李四', 'age': 10, 'gender': '女','date':'1980-02-03'}
>>> m.update(m2)
>>> m
{'name': '李四', 'age': 10, 'gender': '女', 'date': '1980-02-03'}

3、字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；

>>> del(m['name'])
>>> m
{'age': 10, 'gender': '女', 'date': '1980-02-03'}
>>> b = m.pop('date')
>>> b
'1980-02-03'
>>> m
{'age': 10, 'gender': '女'}
>>> m.clear()
>>> m
{}

序列解包：

用于元组、列表、字典，便于赋值。

>>> s = {'name':'李四','age':18,'gender':'男'}
>>> s1,s2,s3 = s.items()  //键值对赋值
>>> s1
('name', '李四')
>>> s2
('age', 18)
>>> s3
('gender', '男')
>>> k1,k2,k3 = s.keys()  //对键进行操作
>>> k1
'name'
>>> k2
'age'
>>> k3
'gender'
>>> v1,v2,v3 = s.values()   //对值进行操作
>>> v1
'李四'
>>> v2
18
>>> v3
'男'

Set（集合）

集合（set）是无序可变，元素不能重复。集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的

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

集合的创建与删除：

1、使用{}创建

>>> s = {1,2,'name',23.2}
>>> s
{1, 2, 'name', 23.2}
>>> s.add('str')
>>> s
{1, 2, 'str', 23.2, 'name'}

2、使用 set()，将列表、元组等可迭代对象转成集合，去重。

>>> a = [1,2,3,2]
>>> b = set(a)
>>> b
{1, 2, 3}
>>> b = set('hello')
>>> b
{'o', 'l', 'e', 'h'}
>>> c = set((1,2,2,3))
>>> c
{1, 2, 3}

3、remove()删除指定元素；clear()清空整个集合

4、交、差、并集

>>> a = {1,2,3}
>>> b = {2,3,4,5}
>>> a.union(b)  //并集
{1, 2, 3, 4, 5}
>>> a.intersection(b)  //交集
{2, 3}
>>> a.difference(b)  //差集
{1}

---

运算符

成员运算符

身份运算符

比较的是对象的内存地址

is与==的区别：

• is比较的是对象地址，是否指向同一个内存地址；
• ==比较的是值，默认调用对象的 __eq__()方法；
• is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is；

整数对象比较时，命令行中[-5, 256]区间会被缓存，文件中执行时，[-5,任意正整数]会被缓存，供重复使用。

>>> a = 1000
>>> b = 1000
>>> a is b
False
>>> a == b
True
>>> c = 5
>>> d = 5
>>> c is d
True
>>> c == d
True

比较运算符

逻辑运算符

>>> a = True
>>> b = False
>>> a and b
False
>>> a or b
True
>>> not a
False
>>> not b
True

赋值运算符

python不支持自增（++），自减（--）操作。

// 表示向下取整

>>> a = 9
>>> b = 2
>>> a //= b
>>> a
4
>>> c = -5
>>> c //= b
>>> c
-3