0%

Python编程—数据类型

Posted on Edited on In

Python提供了大量的内置数据结构，包括列表，集合以及字典等，本文主要记录这些基本数据类型的使用。

Python中的标准数据类型主要有：

  • 数值(Number)
  • 字符串(String)
  • 列表(List)
  • 元组(Tuple)
  • 字典(Dict)
  • 集合(Set)
  • 其他(Others)：Byte，Boolean，None

Note:在Python中，类型是属于对象的，变量只是一个对象的引用，没有类型。例如

1
2
a=[1,2,3,4]
b=5

其中，[1,2,3,4]是List类型，变量a没有类型，它只是一个指向List类型对象的引用。
在Python中，String, Tuples和Number是不可变对象，而List，Dict和Set是可变对象

  • 不可变对象：变量b重新赋值实际上是生成一个新的对象，再让b指向新对象，原来对象被丢弃，不是改变b的值
  • 可变对象：变量a指向的对象的元素被修改，a没有改变

1. 数值

Python支持三种不同类型的数值类型

  • 整型(int)
    1
    2
    a=10
    b=0x10 # 16
  • 浮点型(float)
    1
    2
    3
    a=1.2
    b=.5     # 0.5
    c=.314e1 # 3.14
  • 复数(complex)
    1
    2
    a=1+2j
    b=complex(1,2) # 1+2j

1.1 数据类型转换

1
2
3
4
5
6
7
8
9
'''
int->float
'''
float(1)  # 1.0
a=1/1     # 1.0
'''
float->int
'''
int(3.14)  # 3

1.2 算数运算

  • 加，减，乘，除，求余：+,-,*,/,%
  • 幂运算：**
  • 取整除，即取商的整数部分：//
  • 数学函数：abs(),ceil(),exp(),floor(),max(),min(),log(),pow(),sqrt()等
  • 三角函数：sin(),cos(),tan(),radians(),degrees()等
  • 数学常量：pi,e

Note:关于比较运算==和is：

  • ==是比较两个对象的内容是否相等，默认调用对象的__eq()__方法
  • is比较的是两个对象的id是否相等，即是否是同一个对象，也就是是否指向同一个内存地址

2. 字符串

字符串是Python中最常用的数据类型，可以使用引号('或")来进行创建。Python可以使用三引号创建字符串，该字符串可以跨行，可以包含换行符、制表符以及其他特殊字符。

1
2
3
4
5
6
str1 = 'string1'
str2 = "string2"

str3 = """This is a long string, you can use enter. \n
 \t Tab has been used.""" 
 print(str3)

2.1 字符串运算符

  • +：字符串拼接
  • *：重复输出字符串，如str1*2输出结果为string1string1
  • []：通过索引获取字符串中的字符
  • [:]：截取字符串中的一部分，遵循左闭右开原则
  • in和not in：成员运算符，字符串中是否包含给定字符
  • r/R：原始字符串，不进行转义等操作
  • %：字符串格式化

2.2 字符串格式化

  • C风格字符串格式化
  • 字符串格式化函数：str.format()
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # C-style
    print("My name is %s, % years old" % ('String',100))

    # str.format()
    "{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
    "{0} {1}".format("hello", "world")  # 设置指定位置

    "姓名：{name}, 年龄: {age}".format(name="string", age="100)

    # 通过列表设置参数
    my_list = ['string','male']
    "姓名：{0[0]}, 性别: {0[1]}".format(my_list)

2.3 数据类型转换

1
2
int('1')       # 1
float('3.14')  # 3.14

3. 列表

列表是Python中最基本的数据结构，列表中的数据项可以具有不同的类型。列表的基本形式为一个方括号，其中的元素通过,进行分隔。

1
2
list = [1,2,3,4,5]
list_2s = [[0 for i in range(5)] for i in range(5)]

3.1 列表操作符

  • +：列表组合
  • *：重复
  • []：通过索引获取列表中的元素，并可以进行修改
  • [:]：截取列表中的一部分元素，遵循左闭右开原则
  • [::]：列表切片，除了起始索引和结束索引，还有步长，步长为负，反向索引
  • in和not in：成员运算符，列表中是否包含给定元素
  • len(list)：列表元素个数
  • max(list)和min(list)：返回列表元素最大/最小值
  • list(tuple)：将元组转换为列表

列表推导表达式：
[表达式 for 变量 in 列表 [if 条件]]

3.2 列表包含的方法

  • list.append(obj)：在列表末尾添加新的元素

  • list.insert(idx,obj)：在列表特定位置插入新的元素

  • list.extended(seq)：在列表末尾添加另一个序列的值

  • list.pop(idx=-1)：移除列表中特定位置的元素(默认是最后一个元素)，并且返回该元素

  • list.remove(obj)：移除列表中某个值的第一个匹配项

  • list.clear()：移除列表中所有值

    del list[idx]可以删除列表指定位置或者指定范围内的值，也可以删除整个列表。与pop()不同之处在于，del不会返回删除的值。

  • list.count(obj)：统计某个值在列表中出现的次数

  • list.index(obj)：索引某个值在列表中第一次出现的位置

  • list.sort(key=None,reverse=False)：对原列表进行排序

  • list.reverse()：反向原列表中的元素

  • list.copy()：复制列表

4. 元组

Python中的元组与列表类似，不同之处在于：

  • 元组的元素不能修改
  • 元组使用小括号，列表使用中括号

    Note:元组中包含一个元素时，需要在元素后面添加,，否则括号会被当做运算符使用

元组的操作符

元组的操作符与列表的操作符大致相同，不同之处在于：

  • []：通过索引获取列表中的元素，但是不可以对元素进行修改
  • tuple(list)：将列表转换为元组

5. 字典

字典是另一种可变容器类型，可以存储任意类型的对象。字典的基本格式为一个花括号，字典的键和值对用:进行分割，每个对之间用,分割。

1
dict={key1:val1,key2:val2}

字典具有以下特性：

  • 字典中的键是唯一的，值可以重复
  • 字典中的键必须是不可变的，因此可以是字符串、数字或者元组，不能是列表，值可以取任何数据类型
  • 字典中的键值必须要同时进行初始化

5.1 字典的操作符

  • [key]：通过键来访问字典中的值，并可以进行修改和删除(del dict[key])
  • in和not in：成员运算符，字典中是否包含给定的键
  • len(dict)：返回字典中元素的个数
  • str(dict)：以可以打印的字符串形式输出字典
  • type(var)：返回输入变量的类型

字典推导表达式：
[key:value for 变量 in 迭代器 [if 条件]]

5.2 字典的函数

  • dict.keys()和dict.values()：返回的是一个迭代器，可以通过list()转换为列表
  • dict.get(key,default=None)：获取指定键的值，没有值返回defaule值
  • dict.setdefault(key,default=None)：获取指定键的值，如果键不存在，添加键并将其值设为default值
  • dict.pop(key[,default=None])：删除指定键的值，并返回该值。key必须给出，否则返回default值
  • dict.update(dict2)：将字典dict2的键值对更新到dict中
  • dict.fromkeys(seq[,value])：创建一个新的字典，以序列中的元素作为字典的键，并将值初始化为value，默认为None
  • dict.items()：返回一个元组组成的列表，每个元组包含了一个键值对
  • dict.popitem()：返回并删除字典中的最后一个键值对
  • dict.clear()：删除字典内所有元素
  • dict.copy()：返回字典的浅拷贝
  • 直接赋值(=)：赋值引用，指向同一个对象
  • 浅拷贝(copy)：拷贝父对象，不会拷贝对象内部的子对象，因此两个字典子对象的值是同一个对象
    1
    2
    dict1={'a':[1,2,3,4],'b':2} # dict1['a']的值是一个子对象，dict1['b']的值是一个父对象
    dict2=dict1.copy()          # dict2['a']的值和dict1['a']的值指向的是同一个对象
  • 深拷贝(deepcopy)：完全拷贝了父对象及子对象，需要import copy

6. 集合

集合是一个无序的不重复元素序列，可以使用{}和set()函数来创建集合，创建格式：

1
2
set1 = {val1,val2,...}
set2 = set(val)

Note:创建一个空的集合只能使用set()，因为{}是用来创建一个空的字典的语法描述。

6.1 集合的操作符

  • &,|,-,^：集合的交集，并集，差集和对称差集
  • ==,!=：判断集合是否相等
  • >=,<=：包含和被包含
  • len(set)：返回集合中元素的个数
  • in：判断元素是否在集合中

    Note:因为集合是无序的，所以不能进行索引操作

6.2 集合的函数

  • set.add(obj)：为集合添加元素，若添加的元素已经存在，则不进行任何操作

  • set.update(obj)：为集合添加元素或集合到当先集合中

  • set.remove(obj)：移除指定的元素，元素不存在时会发生错误

  • set.discard(obj)：移除指定的元素，元素不存在也不会发生错误

  • set.pop()：随机移除一个元素，并返回移除的元素

  • set.clear()：移除集合中所有元素

  • set.intersection(set1,set2,...,etc)：计算两个或者多个集合的交集，并返回新的集合

  • set.intersection_update(set1,set2,...,etc)：计算两个或者多个集合的交集，并在原始集合上移除不同的元素

  • set.union(set1,set2,...,etc)：计算两个或多个集合的并集，并返回新的集合

  • set.difference(set1)：计算包含在set中但是不包含在set1中的元素，并返回新的集合

  • set.difference_update(set1)：计算包含在set中但是不包含在set1中的元素，并在set上移除相同的元素

  • set.symmetric_difference(set1)：计算两个集合中所有不重复的元素，并返回新的集合

  • set.symmetric_difference_update(set1)：移除当前集合中所有相同的元素，并将另一个集合中不同的元素插入到当前集合

  • set.isdisjoint(set1)：判断两个集合是否包含相同的元素，没有则返回True

  • set.issubset(set1)：判断集合set的所有元素是否都包含在集合set1中，是则返回True

  • set.issupersubset(set1)：判断集合set1的所有元素是否都包含在集合set中，是则返回True

  • set.copy()：用于复制一个集合

参考文献 & 资源链接