python标准数据类型与运算符

素颜马尾好姑娘i 2022-04-23 00:24 303阅读 0赞

# 标准数据类型 #

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（字符串） ##

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

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

![o99aU.png][]

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

>>> 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\]，序列中存储的是对象的地址，而不是对象的值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70][]

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 1][]

>>> 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]

常用方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 2][]

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}

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

# 运算符 #

## 成员运算符 ##

![20190122123615780.png][]

## 身份运算符 ##

比较的是对象的内存地址

![20190122124409104.png][]

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

## 比较运算符 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 3][]

## 逻辑运算符 ##

![20190122125114460.png][]

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

## 赋值运算符 ##

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 4][]

// 表示向下取整

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

# #

[o99aU.png]: /images/20220325/7c12584d5fc24071aeef7e2fa8a625c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70]: /images/20220325/e9427753cea84dd691ee7a6a499a2128.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 1]: /images/20220325/8d2e86e6b2b940249de24d22db71533f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 2]: /images/20220325/b28c4d7b7cb64b15bc57730966e89b55.png
[20190122123615780.png]: /images/20220325/71028eaf32e54b9fa75f4e9b73138cc4.png
[20190122124409104.png]: /images/20220325/17fbadaa4bd445748a2d9cdff75c296c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 3]: /images/20220325/70a173d9d5b74efea4d0988e4bdda49f.png
[20190122125114460.png]: /images/20220325/3ea32d6b23dd4f8688f789071520df68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ltMDEyMTM_size_16_color_FFFFFF_t_70 4]: /images/20220325/d95e7962f91c4a8880f26a98906babc5.png