【Python】数据类型 Number数字 String字符串 List列表 Tuple元组 Set集合 Dictionary字典

Python数据类型

/6/3 周四

学习内容: Python数据类型、Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

刚接触Python，主要是看 菜鸟教程、w3school 网站，以及电子工业出版社出版的Python编程入门指南上册的教材，并根据自己的情况对重点内容做的笔记。

如有错误，欢迎在评论区指出，非常感谢！

一、数据类型

1. 标准数据类型

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

Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

其中不可变数据（3个）：Number、String、Tuple；

可变数据（3个）：List、Dictionary、Set；

2. 构造函数

Python中的变量不需要声明类型，在为变量赋值时，就自动设置了数据类型。

x = 525print(x+"123")

x默认是int，这样写是会报错的。

如果希望指定数据类型，可以使用以下构造函数：

x = str(525)print(x+"123")

这样就不会报错了

3. 获取数据类型

可以使用type()函数获取任何对象的数据类型

x = 525print(type(x))>>> 输出>>> <class 'int'>

另外，还可以用isinstance()带上数据类型来判断是否是这个类型的，返回True或False：

x = 525print(isinstance(x,str))>>> 输出>>> False

区别在于，在判断对象的类型时，type() 不会认为子类是一种父类类型，而isinstance() 会认为子类是一种父类类型。

二、Number（数字）

数字类型包括int、float、complex三种数值和bool布尔值

1. 数值

int整数，是完整的数字，正数或负数，没有小数，长度不限。float浮点数，是包含小数的正数或负数，也可以是带有“e”的科学数字，表示 10的幂。比如"15E2"、“-49.8e100”。complex复数，与数学中的复数一样，都是由实部和虚部组成，用 “j” 作为虚部编写。比如"2+3j"、“-3j”。

类型转换

可以使用 int()、float() 和 complex() 构造函数，将数字从一种类型转换为另一种类型（但是复数无法转换为其他数字类型）。

比如：

int(6.3)就是向下取整，结果为6，

float(5) 是后面加个.0，结果为5.0，

complex(3.5) 就是加个+0j，结果为(3.5+0j)。

符合格式的字符串也可以与数值类型互相转换，比如：

int(“2”) 结果为 整数2

float(“4.6”) 结果为 浮点数4.6

complex(“2+3j”) 结果为 复数(2+3j)

str(4.0) 结果为 字符串"4.0"

2.布尔值

Python布尔类型 bool 主要用来表示真或假的值。

比如比较两个值时，将对表达式求值，返回布尔值答案True或 False：

如 8>7 为True， 8<7 和 8==7 都为False。

布尔值可以转换为数值，True表示1， False表示0。

bool() 函数可评估任何值，只有一个参数，并根据这个参数的值返回 True或 False。

对数字使用 bool() 函数时，0返回False，任何其他值都返回True。对字符串使用 bool() 函数时，对于没有值的字符串（None或""空字符串）返回False，否则返回True。bool() 函数对于空的列表、字典和元组返回False，否则返回True。

总的来说，其实大多数值都是True的，被评估为False很少，比如：

bool(False)bool(None)bool(0)bool("")bool(())bool([])bool({})

（0是指数值中的0，包括0、0.0和虚数0）

3.随机数

Python没有 random() 函数来创建随机数，但有一个名为random的内置模块，可用于生成随机数：

导入 random 模块，并显示1到9之间的随机数：

import randomprint(random.randrange(1,10))

randrange左闭右开，不能取到10

另外还有一个randint左右都是闭区间，两边极限都可以取到

三、String（字符串）

1. 写法

python中的字符串字面量由单引号或双引号括起。

多行字符串：

也可以使用三个引号（单引号双引号都可以）将多行字符串赋值给变量：

a = """When your dreams come alive you're unstoppabletake a shot chase the sun, find the beautiful"""b = '''We will glow in the dark turning dust to goldAnd we'll dream it possible'''

在结果中，换行符插入与代码中相同的位置。

字符串拼接和复制：

使用+加号可以拼接字符串，使用 * 星号并带上需要复制的次数可以复制字符串：

print("Hello"+" World!")print("Boom" * 5)>>> 输出：>>> Hello World!>>> BoomBoomBoomBoomBoom

转义特殊字符：

还可以使用反斜杠\来转义特殊字符，比如\n表示换行：

print("使用\n换行")>>> 输出:>>> 使用>>> 换行

同时，如果必须用到转义格式，但又不希望被转义的话，可以在引号前加上字母r或R：

print(r"使用\n换行")>>> 输出:>>> 使用\n换行

2.访问字符串元素

Python中的字符串是表示unicode字符的字节数组。

但是，Python没有类似char的字符数据类型，单个字符就是长度为1的字符串。

可以用[ ]方括号来访问字符串的元素:

a = "Hello, World!"print(a[1])

需注意，从前往后第一个字符的下标为 0，从后往前数第一个字符的下标为-1。

3.字符串截取

指定开始索引和结束索引，以冒号分隔，可以截取字符串的一部分。

获取从下标2到下标 5（不包括）的字符:

a = "Hello, World!"print(a[2:5])

如果使用负的索引，则是从字符串末尾开始切片：

a = "Hello, World!"print(a[-5:-2])

结果是orl，也就是从下标 -5 到下标 -2（不包括）的字符。

也可以省略一个参数，表示从头开始截到指定位置，或者从指定位置截到底：

a = "Hello, World!"print(a[:5])print(a[7:])print(a[:-1])print(a[-6:])>>> 输出：>>> Hello>>> World!>>> Hello, World>>> World!

4.in / not in

如需检查字符串中是否存在特定短语或字符，可以使用 in 或 not in 关键字，返回True或False。

例如，检查以下文本中是否存在短语 “ina”：

txt = "China is a great country"x = "ina" in txtprint(x)

结果是True。

5. 字符串常用方法

len()返回字符串的长度strip()删除开头和结尾的空白字符lower()返回小写的字符串upper()返回大写的字符串replace()用另一段字符串来替换字符串：

a = "Hello, World!"print(a.replace("World", "Kitty"))>>> 输出：>>> Hello, Kitty!

split()在找到分隔符的实例时将字符串拆分为子字符串：

a = "Hello, World!"print(a.split(",")) >>> 输出：>>> ['Hello', ' World!']

6.format()和占位符{}

如果用"+"号组合字符串和数字的话会报错，但format()方法，就可以组合字符串和数字。

它接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

age = 25txt = "My name is Bill, and I am {}"print(txt.format(age))

可以使用多个占位符来接受多个参数：

quantity = 3itemno = 567price = 49.95myorder = "I want {} pieces of item {} for {} dollars."print(myorder.format(quantity, itemno, price))

然后参数的位置也可以不按顺序，这就需要在占位符中标明索引表示填入第几个参数，索引从0开始算

quantity = 3itemno = 567price = 49.95myorder = "I want to pay {2} dollars for {0} pieces of item {1}."print(myorder.format(quantity, itemno, price))

四、List（列表）

1. 写法

List（列表）是 Python中使用最频繁的数据类型，写在方括号[ ]之间，并用逗号分隔开多个元素。

Python 没有内置对数组的支持，但可以使用 List 列表代替。

列表可以存放数字、字符串、列表（所谓嵌套）、元组等类型的内容，而且同一个列表中元素的类型都可以不相同。

list = ['abcd', 321, 321, 5.25, 1+1j]

列表允许重复值。

列表是有序的，索引值从前往后第一个元素的索引为 0，从后往前第一个元素的索引为-1。

2.截取

和字符串一样，列表也可以访问元素和截取，列表被截取后返回一个包含所需元素的新列表。

list = ["number",1,2,3,4,5]print(list[0])print(list[2:5])>>> 输出：>>> number>>> [2, 3, 4]

从上还可看出，输出列表单个元素时，如果是字符串，会自动去掉引号。

另外，列表的截取还可以接收第三个参数，参数作用是截取的步长(表示间隔几个数)：

list = [1,2,3,4,5,6,7,8,9,10]print(list[0:9:2])>>> 输出：>>> [1, 3, 5, 7, 9]

如果第三个参数为负数，表示逆向读取，可以用于翻转字符串语句：

list = ["he", "is", "Tony"]print(list[-1::-1])>>> 输出：>>> ['Tony', 'is', 'he']

3.合并列表和重复输出

也同样可以用+加号合并多个列表组成新的包含所有元素的列表，

以及用*星号重复输出列表：

list1 = ['abcd', 123, 321]list2 = [123, 456, 789]list3 = ["ha"]print(list1 + list2 + list3 * 3)>>> 输出：>>> ['abcd', 123, 321, 123, 456, 789, 'ha', 'ha', 'ha']

4. 更改元素值

与字符串不一样的是，列表中的元素是可以改变的。

可以通过访问和截取来修改列表中的元素：

list = ["number",1,2,3,4,5]list[0] = 0print(list)>>> [0, 1, 2, 3, 4, 5]list[1:5] = [-1,-2,-3,-4]print(list)>>> [0, -1, -2, -3, -4, 5]

如果修改的元素个数多于截取的位数，替换掉截取的部分后，剩下的部分依然会插入到列表：

list = [0,1,2,3,4,5]list[1:3] = [-1,-2,-3,-4,-5]print(list)>>> 输出：>>> [0, -1, -2, -3, -4, -5, 3, 4, 5]

5.列表排序

当列表中的元素都是实数（int或float）或都是字符串时，可以用sort()方法对列表进行排序：

list1=[32,4,7,1,10,5.5]list2.sort()print(list1)>>> [1, 4, 5.5, 7, 10, 32]list2=["a","bc","D"]list2.sort()print(list2)>>> ['D', 'a', 'bc']list2.sort(key=str.lower)print(list2)>>> ['a', 'bc', 'D']

在Python中的字符串排序，默认都是先大写，再小写。

如果不想区分大小写，可以给sort方法加一个key参数，设置key=str.lower。

6. 列表常用方法

len()返回列表的长度in / not in关键字，检验列表中是否存在指定的元素copy()复制列表（使用list2=list1这种写法不能复制列表，只是list2对 list1的引用，如果list1中有所更改，list2也会改变。）append()向列表的末尾添加元素insert()在指定的索引处添加元素remove()参数是列表里的元素，删除匹配的第一个元素pop()参数是索引，删除指定索引的元素（如果未指定索引，则删除最后一项）del关键字也可以删除指定索引的元素（如果未指定索引，则删除整个列表）clear()清空列表

以下是对这些方法的使用，用>>>代表输出：

list = [1,2,3,4,5,6,7,8,9,"number"]print(len(list))>>> 10print(5 in list)print(10 in list)>>> True>>> Falsemylist = list.copy()print(mylist)>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number']list.append(10)print(list)>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.insert(0,"number")print(list)>>> ['number', 1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.remove("number")print(list)>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.pop(9)print(list)>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]del list[9]print(list)>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]del listprint(list)>>> <class 'list'>mylist.clear()print(mylist)>>> []

五、Tuple（元组）

1. 写法

元组写在小括号( )里，元素之间用逗号隔开。

tuple = ('abcd', 321, 321, 5.25, 1+1j)

需要特别注意的是，如果创建只含有一个元素的元组，必须在该元素后面加一个 “,” 逗号，否则Python会把它识别为数值、字符串等：

tuple = ('abcd')print(type(tuple))>>> <class 'str'>tuple = (50)print(type(tuple))>>> <class 'int'>tuple = (50,)print(type(tuple))>>> <class 'tuple'>

2. 元组的操作

元组的特点基本与列表类似，也是有序可重复的，同样可以有访问、截取、重复输出、合并、检验是否存在元素等操作：

tuple = ('abcd', 321, 321, 5.25, 1+1j)print(tuple[0])print(tuple[1:5])print(tuple*2)print(tuple + ('efg','higk','lmn'))print(5.25 not in tuple)>>> 输出：>>> abcd>>> (321, 321, 5.25, (1+1j))>>> ('abcd', 321, 321, 5.25, (1+1j), 'abcd', 321, 321, 5.25, (1+1j))>>> ('abcd', 321, 321, 5.25, (1+1j), 'efg', 'higk', 'lmn')>>> False

3. 修改元组元素

不同之处在于，元组的元素不能修改。

如果使用类似列表修改的语句，如 tuple[0] = “aaa” 去操作元组，会报错：

【TypeError: ‘tuple’ object does not support item assignment】

但是如果非要改变元组里的元素，也可以把元组先转换为List列表，更改完再转回Tuple元组：

tu = ('abcd', 321, 321, 5.25, 1+1j)li = list(tu)li[0] ='aaa'tu = tuple(li)print(tu)>>> 输出：>>> ('aaa', 321, 321, 5.25, (1+1j))

也是由于元组不可改变，所以它没有排序方法。

4. 元组常用方法

len()返回元组的长度count()返回元组中指定元素出现的次数index()在元组中搜索指定的元素，并返回匹配的第一个元素的下标当元组里的元素全部是实数（int和float）时，可以使用max()、min()、sum()等数学方法，查找元素里的最大值最小值以及求和由于元组不可改变，因此没有List那些添加、删除元素的方法，但还是可以用del关键字删除整个元组

tuple = ('abcd', 321, 321, 5.25, 1+1j)print(len(tuple))print(tuple.count(321))print(tuple.index(321))>>> 5>>> 2>>> 1tuple = (12,3.4,56,78,90,87,6.5,43,21)print(max(tuple))print(min(tuple))print(sum(list))>>> 90>>> 3.4>>> 396.9del tupleprint(tuple)>>> <class 'tuple'>

（以上方法其实对于List列表也都适用）

六、Set（集合）

1. 创建集合

在Python中，Set是无序和无索引的集合，写在花括号{ }里。

可以使用花括号{ } 或者 set() 构造函数来创建集合。

注意如果是多个元素的话，set()里面还要再用小括号括起来：

myset1 = {'abcd', 321, 321, 5.25, 1+1j}print(myset1)myset2 = set((1,3,5,7,9,8,6,4,2,0,1,1,1))print(myset2)>>> 输出：>>> {321, 'abcd', (1+1j), 5.25}>>> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Set集合是无序的，不允许重复，所以如果有重复的元素，会被自动去掉。

这里第二个的结果看起来好像被排序了，这是因为set在去重时会有修改排序的操作，在set数据值过小时可能会有这种情况，如果数据值大一点就不会了：

myset2 = {3,4,2,123,87,328947,3263,124873,128595,7,9,8,6,4,2,0,1,1,1,8,6}print(myset2)>>> 输出：>>> {0, 1, 2, 3, 4, 6, 7, 8, 124873, 9, 328947, 128595, 87, 123, 3263}

这个输出只是其中一种情况，每次运行得到的顺序都可能不一样。

所以不应该认为Set集合中的元素存在顺序。

Set集合常用来进行成员关系测试（集合的&|-^运算）和删除重复元素，例如给list去重：

mylist = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]print(list(set(mylist)))>>> 输出：>>> [1, 2, 3, 4, 5]

2.{ }和set()的区别

如果要创建只有一个字符串的集合，{ }和set()构造方法是有区别的：

myset1 = {'abcdefgg'}print(myset1)myset2 = set('hijklmnn')print(myset2)>>> 输出：>>> {'abcdefgg'}>>> {'h', 'i', 'k', 'm', 'n', 'j', 'l'}

可发现set()会把字符串拆成单个单个字符的元素（并且去重）。

另外，如果要创建一个空集合，则必须用 set( )而不是 { }，因为{ }是用来创建一个空字典的。

myset1 = {}print(myset1)print(type(myset1))myset2 = set()print(myset2)print(type(myset2))>>> 输出：>>> {}>>> <class 'dict'>>>> set()>>> <class 'set'>

3. 操作

因为Set集合是无序无索引的，所以无法像List和Tuple一样访问某个元素，但可以使用in和not in来查询集合中是否存在某元素：

myset = {1,2,3,4,5,"a","bb","CCC"}print(1 in myset)print("a" not in myset)>>> 输出：>>> True>>> False

另外学了流程控制语句后，还可以用for循环遍历集合，这里先跳过。

Set集合是可变的，但里面的元素是不可变的，因为无法访问到集合中的某个元素。

不过一定需要修改的话，可以先删除一个元素，然后再添加一个元素达到差不多的效果。

Set集合也不能使用 +、* 等符号进行合并、重复，但是有一个union()合并集合的方法：

myset1 = {1,2,3,4,5}myset2 = {"a","bb","CCC"}print(myset1.union(myset2))>>> 输出>>> {1, 2, 3, 4, 5, 'a', 'bb', 'CCC'}

4.Set集合的运算

可以使用& | - ^符号进行Set集合的交集、并集、差集、对称差集（不同时存在的元素）的运算:

myset1 = set('abcdhi')myset2 = set('abhijk')print(myset1)print(myset2)>>> {'a', 'i', 'h', 'b', 'd', 'c'}>>> {'a', 'i', 'k', 'h', 'b', 'j'}print(myset1 & myset2)# 交集>>> {'h', 'b', 'a', 'i'}print(myset1 | myset2)# 并集>>> {'j', 'a', 'i', 'k', 'h', 'b', 'd', 'c'}print(myset1 - myset2)# 差集print(myset2 - myset1)# 差集>>> {'d', 'c'}>>> {'k', 'j'}print(myset1 ^ myset2)# 对称差集>>> {'k', 'd', 'j', 'c'}

5. Set集合其他常用方法

len()返回集合的长度add()向集合添加一个元素update()向集合添加多个元素，所有添加的元素需要是List或Tuple或Set(即必须用[]/()/{}括号括起来)copy()复制集合remove()删除匹配的元素，如果集合中没有该元素，会报错discard()删除匹配的元素，如果集合中没有该元素，不会报错pop()删除集合最后一项，由于集合是无序的，所以删除的元素是不确定的，但是方法会返回删除的值clear()清空集合del关键字删除整个集合

myset = {1,2,3,4,5}myset.add(6)print(myset)>>> {1, 2, 3, 4, 5, 6}myset.update([7,8,9])print(myset)>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}myset.remove(9)print(myset)>>> {1, 2, 3, 4, 5, 6, 7, 8}myset.remove(9)print(myset)>>> Traceback (most recent call last):>>> File "/usercode/file.py", line 11, in <module>>>>myset.remove(9)>>> KeyError: 9myset.discard(9)print(myset)>>> {1, 2, 3, 4, 5, 6, 7, 8}myset.pop()print(myset)>>> {2, 3, 4, 5, 6, 7, 8}

其他方法与之前的List差不多，所以这里不再贴对应的代码了。

七、Dictionary（字典）

1.创建字典

字典Dictionary是一种映射类型，类似Java中的Map，由 key:value 键值对组成。

字典是无序的，保存在字典中的项随机排序，这样可以提高查找效率。

字典在Python中用花括号{ }来编写：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}

其中键(key)是不可变类型（数字、字符串或元组）。

在同一个字典中，键(key)必须是唯一的。

如果创建字典时使用了重复的key，只会记录最后一个值：

mydict = {"01":"aa","02":"bb","01":"cc","02":"dd","02":"ee"}print(mydict)>>> 输出：>>> {'01': 'cc', '02': 'ee'}

如果一定要一个key对应多个value的话，可以把多个value存在list、tuple或set中，如:

mydict = {"01":["aa","cc"],"02":["bb","dd","ee"]}

也可以使用dict()构造函数来创建字典：

mydict = dict(a=123,b=456,c=789,CC=10)print(mydict)>>> 输出：>>> {'a': 123, 'b': 456, 'c': 789, 'CC': 10}

这种方式需注意：

参数格式为key=value（不是冒号了），且key不能带引号。

所以key基本上只能用不带引号表示的字符串，否则都会报错

【SyntaxError: expression cannot contain assignment, perhaps you meant “==”?】

还可以通过dict()构造函数和zip()函数映射生成字典：

list1 = ['a','b','c','CC']list2 = [123,456,789,10]mydict = dict(zip(list1,list2))print(mydict)>>> 输出：>>> {'a': 123, 'b': 456, 'c': 789, 'CC': 10}

两个list分别作为键和值放进字典，如果list1和list2的长度不同，则与最短的list长度相同。

2.输出键和值

可以使用keys()、values()方=，单独输出字典的key或者value：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}print(mydict)print(mydict.keys())print(mydict.values())>>> 输出：>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}>>> dict_keys(['a', 2, (7, 8, 9), 'C'])>>> dict_values([123, 456, 789, 10])

3.字典嵌套

字典里面还可以包含字典，也就是嵌套.

创建包含3个字典的字典：

mydict = {'A':{'01':'aa','02':'bb'},'B':{'03':'cc','04':'dd'},'C':{'05':'ee','06':'ff'}}

或者也可以先创建3个字典，再把它们放进去：

A = {'01':'aa','02':'bb'}B = {'03':'cc','04':'dd'}C = {'05':'ee','06':'ff'}mydict = {'A':A,'B':B,'C':C}print(mydict)>>> 输出：>>> {'A': {'01': 'aa', '02': 'bb'}, 'B': {'03': 'cc', '04': 'dd'}, 'C': {'05': 'ee', '06': 'ff'}}

4. 访问、修改和添加元素

可以使用在方括号内引用键名、或者用get()方法来访问字典的元素：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}x = mydict["a"]y = mydict.get(2)z = mydict.get(1)print(x)print(y)print(z)>>> 输出：>>> 123>>> 456>>> None

如果指定键的值不存在时，返回None。

字典是可变的，可以引用键名来修改元素的值：

mydict = {'01':'aa','02':'bb'}mydict['02'] = 'AA'print(mydict)>>> 输出>>> {'01': 'aa', '02': 'AA'}

通过使用新的索引键并为其赋值，可以将元素添加到字典中：

mydict = {'01':'aa','02':'bb'}mydict['03'] = 'cc'print(mydict)>>> 输出：>>> {'01': 'aa', '02': 'bb', '03': 'cc'}

5.复制字典

可以使用copy()方法或者dict()构造函数复制字典：

mydict1 = {"a":123,2:456,(7,8,9):789,'C':10}mydict2 = mydict1.copy()mydict3 = dict(mydict1)print(mydict2)print(mydict3)>>> 输出：>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}

6. 字典其他常用方法

len()返回字典的长度in/not in关键字 检查字典中是否存在指定的键pop()删除具有指定键名的元素，找不到会报错popitem()删除最后插入的项目（在Python3.7之前的版本中是删除随机项目），如果没有元素会报错del关键字 删除具有指定键名的元素，找不到会报错clear()清空字典del关键字 删除整个字典，删除后原来那个字典就不存在了

mydict = {'01':'aa','02':'bb','03':'cc','04':'dd','05':'ee','06':'ff'}print(len(mydict))>>> 6print('01' in mydict)print('1' not in mydict)>>> True>>> Truemydict.pop('03')print(mydict)>>> {'01': 'aa', '02': 'bb', '04': 'dd', '05': 'ee', '06': 'ff'}mydict.popitem()print(mydict)>>> {'01': 'aa', '02': 'bb', '04': 'dd', '05': 'ee'}del mydict['05']print(mydict)>>> {'01': 'aa', '02': 'bb', '04': 'dd'}mydict.clear()print(mydict)>>> {}del mydictprint(mydict)>>> Traceback (most recent call last):>>> File "/usercode/file.py", line 23, in <module>>>>print(mydict)>>> NameError: name 'mydict' is not defined

八、List&Tuple&Set&Dictionary比较

List & Tuple & Set & Dictionary 都可以在同一个里面存放不同类型的数据。