python-基本数据类型学习

概念

python中存在6种基本的数据类型，分别为：数字，字符串，集合，列表，字典，元祖 而数据根据变量的值变更后地址也变更又细分为可变和不可变类型，值变更后地址也变更叫不可变数据类型，值变化后地址无变化叫可变数据类型，下面来一起学习一下吧

1. 整型

如下：1，2，3，使用最多的数据类型，根据下图代码判断我们知道整型是不可变的数据类型

a = 2 b = 3 print(id(a),id(b)) # id(object)输出对象内存地址 结果： 140703149748528 140703149748560 显然不一致

2. 字符串

2.1、基本概念 字符串是python中使用最广泛的数据类型，在python2中对字符串的要求相对高，要写中文必须加上编码格式为utf-8，在python3中就兼容中文，字符串可以用双引号/单引号/三引号括起来的任意字符，如下：

str_one = '123' str_two = "abc" str_three = '人生苦短，我选python！' ！""" print(str_one) print(str_two) print(str_three) 结果： 123 abc 人生苦短，我选python！

还有一种特殊的字符串符号–>三引号，是可换行输入的字符串符号，同时也是注释符，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了，如下：

"""注释"""/'''注释''' str_fore = """我想要 学习 python print(str_fore) 结果： 我想要 学习 python

原始字符串，对于路径等字符串中会有反斜杠，反斜杠有特殊的作用，因此要在字符串前面加上r，使得反斜杠\不被转义，\才不会被当成特殊字符

# 这是不加r运行的结果： File "C:/Users/HUAWEI/PycharmProjects/ceshi/pc.py", line 1 path='C:\Users\HUAWEI\PycharmProjects\youxiaocai\venv\Scripts\python.exe' ^ SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape # 加上r与信念跟结果： path=r'C:\Users\HUAWEI\PycharmProjects\youxiaocai\venv\Scripts\python.exe' print(path) 结果： C:\Users\HUAWEI\PycharmProjects\youxiaocai\venv\Scripts\python.exe

2.2、字符串符号冲突如何解决

（1）当我们要使用的字符串中包含单引号或者双引号，那怎么正确输出来呢，如：我们需要输出 I‘m a grils，如果我们按照下图这样输出：

print('I'm a girls') 结果为： File "C:/Users/HUAWEI/PycharmProjects/ceshi/pc.py", line 2 print('i'm a girls') ^ SyntaxError: invalid syntax

其实在python中，引号会自动寻找和他距离最近的另一半配对，其他就不管了，因为会导致第一个’和I后面的’配对，导致报错，怎么解决？若我们的字符串中带有引号，我们只需把最外层的字符串引号和字符串本身的引号写成不一致即可。如下：

print("i'm a girls") print('这是我“集美”') 结果： i'm a girls 这是我“集美”

2.3 字符串拼接 有时候我们会想到，如何把两句话拼在一起，如:a=‘我爱’,b=‘python’ 或者把不同类型的数据拼在一起，如：a=‘我今年’，b=5，c=‘岁’，来一起动手操作一下吧

先看第一个例子：

a='我爱' b='python' print(a+b) 结果： 我爱python

第二个例子

a='我今年' b=1 c='岁了' print(a+b+c) 结果： Traceback (most recent call last): File "C:/Users/HUAWEI/PycharmProjects/ceshi/pc.py", line 7, in <module> print(a+b+c) TypeError: can only concatenate str (not "int") to str

思考一下为什么第二个报错了呢，看提示我们知道是因为数据类型不支持，整型int和字符串str不能进行拼接，怎么办呢

print(a+str(b)+c) 结果： 我今年1岁了

总结：通过str()函数，我们可以把其他任意类型的数据和字符串数据拼接。

3. 集合

3.1 定义 集合（set）是一个无序的不重复元素序列，要定义集合，可用{}和set()函数，但是需要注意的是，创建空集合必须用set函数，{}是用来定义空字典的，如下：

parm = {'1234'} a = set('1234') print(type(parm),parm,type(a),a) 结果： <class 'set'> {'1234'} <class 'set'> {'1', '2', '4', '3'}

3.2 集合基本操作 （1）添加元素，add()函数，添加的规则为，如果新增的元素不存在集合中，则添加，如果已存在集合中，则不添加，因为集合元素是不重复的

# 添加一个元素 parm = {'1234'} parm.add(1) parm.add(1) print(parm) 结果： {1, '1234'}

添加多个元素，使用update()函数，数据对象可用集合，列表，字典，元组形式

parm = {'1234'} parm.update([4,5]) parm.update({1,2}) print(parm) 结果： {1, 2, 4, 5, '1234'}

（2）移除元素 使用remove()来移除元素，移除不存在的元素会报错，因此这里要注意

parm = {'1234',1,2,3,4,5} parm.remove(1) print(parm) 结果： {2, 3, 4, 5, '1234'}

（3）计算集合元素个数len()

parm = {'1234',1,2,3,4,5} print(len(parm)) 结果： 6

（4）清空集合clear()

parm = {'1234',1,2,3,4,5} parm.clear() print(parm) 结果： set()

（5）判断元素是否在集合内

parm = {'1234',1,2,3,4,5} x=1 if x in parm: print('True') else: print('False') 结果： True

5.3，集合的其他方法 （1）pop() ：移除随机元素 （2）copy() ：拷贝一个集合 （3）union() ：返回两个集合的并集 （4）symmetric_difference() ：返回两个集合中不重复的元素

4. 元组

4.1、Python的元组与列表类似，不同之处在于元组的元素不能修改。 元组使用小括号，列表使用方括号。 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，如下创建元祖

tuple_01 = (1,2,3) # 多元素元组 tuple_02 = (1,) # 单元素元组，要用都好隔开，不然就是一个整数 tuple_03 = () # 空元组 print(type(tuple_01),tuple_01) print(type(tuple_02),tuple_02) print(type(tuple_03),tuple_03) 结果： <class 'tuple'> (1, 2, 3) <class 'tuple'> (1,) <class 'tuple'> ()

4.2 元祖的读取 元组和列表一样，可通过索引来获取

tuple_01 = (1,2,3) # 多元素元祖 print(tuple_01[1]) print(tuple_01[-1] 结果： 2 3

4.3 元组的修改 （1）通过元组元素的索引进行修改元素的值，看看是否可以修改

tuple_01 = (1,2,3) tuple_01[1] = '22' print(tuple_01) 结果： TypeError: 'tuple' object does not support item assignment

因此，元组不可通过下标来修改元素的值，值一旦生成是不可变的，但是可以通过元组拼接的方式改变一个元祖，如下：

tuple_01 = (1,2,3) tuple_02 = (4,5,6) print(tuple_01+tuple_02) 结果： (1, 2, 3, 4, 5, 6)

4.4 删除元组 元祖中不支持单个元素的修改，但是可同感del方法对整个元组进行删除

tuple_01 = (1,2,3) # 多元素元祖 del tuple_01 print(tuple_01) 结果： NameError: name 'tuple_01' is not defined

4.5 元组基本运算符

1、len(元祖名) # 计算元祖的元素个数 2、元祖名+元祖名 # 连接两个元组的元素 3、i in 元祖名 # 判断i是否在元组内 4、元祖名*2 # 元组乘法 5、for i 元祖名： # 元组迭代 print(i) 6、max(元祖名) # 取出元组最大值元素 7、tuple(数据对象) # 将其他数据对象转化成元组类型

5. 列表

5.1、什么是列表 列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，每个元素都有自己的索引，因此列表和元组都可通过索引访问元素。二者的区别在于元组是不可修改的，但列表是可修改的

5.2、定义列表

列表元素可以是任意数据类型，如整型，列表，元祖，字符串

list=[1,2,34] list=['a',3,'acn',[1,2],(1,2)]

5.2 访问列表元素

（1）通过下标 列表可通过正序索引或者负序索引进行访问元素，列表第一个索引/下标从0，1…开始依次往后类推，最后一个元素索引/下标从-1，-2…依次往前类推，开始如下：

list=[1,2,3,4] print(list[0],list[-1]) 结果： 1 4

（2）通过for循环遍历列表元素

a = [1,5,3,4,4,3,6] for i in a: # print(i) 结果： 1 5 3 4 4 3 6

a是默认列表全部元素，如果想读取部分元素或者指定元素，怎么写表达式呢，大家动手在编辑器敲敲看看，像写成这样：a[1:],a[1:4],a[:]又会得到深恶结果呢，这就涉及到列表切片了，继续

5.4、列表切片

像这样的表达式a[1:],a[1:4],a[:]，都是列表切片读取数据的方式，根据索引读取需要的元素，list[a:b]，开始下标，b是结束下标，读取规则遵循取左不取右，也就是尾下标不取，取到为下表前一位即可，如下例子中，[2:4]取下标2和3的元素，下标为4不取

a = [1,5,3,4,4,3,6] print(a[2:4]) 结果： [3, 4] a = [1,5,3,4,4,3,6] print(a[-3:-2]) # 负数要也是从左往右取，如例子中去下标为-3元素，-2不取 结果： [4]

5.5、列表乘法

将一个乘以数字，得到类表的所有元素的两倍，如下：

a = [1,5,3,4,4,3,6] b = a*2 print(b) 结果： [1, 5, 3, 4, 4, 3, 6, 1, 5, 3, 4, 4, 3, 6]

5.6、列表内置方法

（1）append() 给列表增加新值，格式：列表名.append(‘要新增的元素’)，append()方法新增的元素只能在列表的最后面，如下图：

list=[1,2,3,4] list.append('23') print(list) 结果： [1, 2, 3, 4, '23']

（2）insert() 如果要在指定位置添加元素或者替换元素的话，需要用到列表索引

# 在指定位置添加元素 list=[1,2,3,4] list.insert(1,'22') # 0为列表list的索引，22是天灾在索引0位置的值 print(list) 结果： [1, '22', 2, 3, 4] # 替换指定索引的元素 list=[1,2,3,4] list[1]='33' # list[1]：列表索引为1的位置 print(list) 结果： [1, '33', 3, 4]

（3）pop() 移除列表最后一个元素，并且移除的元素不会删除，可用变量接收，且仍然可以使用。 语法：list.pop([index])，不指定index参数时，pop()默认移除列表最后一位

list = [1,2,3,4] a = list.pop(-2) print('list={},a={}'.format(list,a)) 结果： list=[1, 2, 4],a=3

（4）remove() 删除元素，语法：列表名称.remove(‘要删除的元素对象’)，与pop()的区别为，remove移除的元素不能返回，移除了就没有了

list = [1,2,3,4] list.remove(2) print('list={}'.format(list)) 结果： list=[1, 3, 4]

（5）sort() 列表元素排序，列表名.sort(reverse=True/False) ，reverse是可选参数，值为True是降序，False是升序，不写reverse默认升序

a = [1,5,3,4] b = ['a','f','d','y','u'] a.sort() b.sort() print(a) print(b) 结果： [1, 3, 4, 5] ['a', 'd', 'f', 'u', 'y'] a = [1,5,3,4] a.sort(reverse=True) print(a) 结果： [5, 4, 3, 1]

(6)copy() 复制列表，a和b列表一样，但是要注意的是，copy和=又是有区别的，copy是生成一共独立的列表，二者不相影响，=赋值生成是指向同一个地址的列表，如果一个改变，另一个也改变

a = [1,5,3,4] b=a.copy() print(a) print(b) 结果： [1, 5, 3, 4] [1, 5, 3, 4]

copy和=区别如下：

# "copy"例子 a = [1,5,3,4] b=a.copy() b.append(66) a.append(99) print(a) print(b) 结果： [1, 5, 3, 4, 99] [1, 5, 3, 4, 66] # “=”例子 a = [1,5,3,4] b=a b.append(66) a.append(99) print(a) print(b) 结果： [1, 5, 3, 4, 66, 99] [1, 5, 3, 4, 66, 99]

（7）count() 统计列表中某个元素出现的次数，如下，4在列表中出现了2次，因此输出2

a = [1,5,3,4,4,3,6] print(a.count(4)) 结果： 2

（8）clear() 清空列表数据，没有返回值

a = [1,5,3,4,4,3,6] a.clear() print(a) 结果： []

其他内置方法： len()：获取列表长度/元素个数； max()：获取列表容器内最大值元素，如数字，字母，字母的话是根据ASCII码大小比较的； min()：获取列表容器内的最小元素； list()：将其他数据类型转化成列表；

（9）extend() 在列表的尾部追加单个或者多个元素集合，多个元素必须以集合形式，如下：

a = [1,5,3,4,4,3,6] a.extend([1,2,34]) print(a) 结果： [1, 5, 3, 4, 4, 3, 6, 1, 2, 34]

（10）index() 找出某个元素的第一个索引

a = [1,5,3,4,4,3,5，6] b=a.index(5) print(b) 结果： 1

6. 字典

（1）定义 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中，格式如下：

dict = {key1 : value1, key2 : value2 }

1、字典的键必须唯一 2、字典的值可以是任意字符类型

（2） 读取字典数据 通过字典名称(键名称)来读取字典得键值，还可以通过get函数来获取键值，如下实操代码中：

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} print(dict['a'],dict['d']) 结果： 123 {'a1': 1, 'b2': 2} dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} print(dict.get('a')) 结果： 123

注意：如果我们访问的键不存在是会报错的，切记实操中一定要写对键名称

（3）len() 返回字典中键-值对的数量；

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} print(len(dict)) 结果： 4

（4）dict[key]=value: 将值value关联到键值key上，如下：

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} dict['e']='123' dict['a'] = 'str' print(dict) 结果： {'a': 'str', 'b': 12, 'c': [1, 2, 3], 'd': {'a1': 1, 'b2': 2}, 'e': '123'}

（5）del dict[key] 删除键值为key的项，如下：

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} del dict['d'] print(dict) 结果： {'a': '123', 'b': 12, 'c': [1, 2, 3]}

(5) key in dict: 键值key是否在d中，在的话返回True，否则返回False，如下：

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} i= 'a' if i in dict.keys(): print('True') 结果： True

（6）items()和iteritems函数：items将所有的字典项以列表方式返回，当有两个参数时，分别接受键和值，当只有一个参数时，接受的是键值对，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} for i ,j in dict.items(): print(i,j) 结果： a 123 b 12 c [1, 2, 3] d {'a1': 1, 'b2': 2}

（7）只获取字典的值：dict.values()

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} for values in dict.values(): print(values) 结果： 123 12 [1, 2, 3] {'a1': 1, 'b2': 2}

（8）只获取字典的键：dict.keys()

dict = {'a':'123','b':12,'c':[1,2,3],'d':{'a1':1,'b2':2}} for values in dict.keys(): print(values) 结果： a b c d

（9）其他函数，大家可以自己动手敲敲实践一下 1、dict.clear()：清空字典 2、dict.copy()：复制字典，在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。dict.deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题 3、原字典名.update(要更新的字典名)函数：用一个字典更新另外一个字典