03-Python的数据类型1

概述# Python中的数据类型 - 集合：集合中的元素无序，不可变。 - 数字：整数、浮点数、复数、分数等，支持各种算数运算。 - 序列：字符串、列表和元组都属于序列，支持索引、分片和合并等 *** 作。 - 映射：字典，将键映射到值。 # 列表list - list是一种最具灵活性的有序集合对象类型。是有序可变的元素集合。 - 列表的定义： 　　- 列表基本特点： 　　　　- 列表可以包含任意类型的对象： # Python中的数据类型

- 集合：集合中的元素无序，不可变。
- 数字：整数、浮点数、复数、分数等，支持各种算数运算。
- 序列：字符串、列表和元组都属于序列，支持索引、分片和合并等 *** 作。
- 映射：字典，将键映射到值。

# 列表List

- List是一种最具灵活性的有序集合对象类型。是有序可变的元素集合。

- 列表的定义：

　　- 列表基本特点：

　　　　- 列表可以包含任意类型的对象：数字、字符串、列表、元组或其他对象。

　　　　- 列表是一个有序的序列

　　　　- 列表是可变的

　　　　- 列表存储的对象是引用的。

　　- 创建列表
　　　　- 通常使用左右方括号（即: [ 和 ]）将数据元素包裹起来创建一个列表

　　　　　　- 方式：[元素1， 元素2， 元素3....]

# 创建空列表ls1 = []print(type(ls1))# 创建带值的列表ls2 = [1,2,3,"List"]print(type(ls2),ls2)

# 结果<class ‘List‘><class ‘List‘> [1,‘List‘]　　　

　　　   - 使用List()函数

# 直接调用不带参的List()函数时，会返回一个空列表。ls1 = List()print(type(ls1),ls1)# 用课迭代对象创建列表对象ls2 = List("abcd")print(ls2)# 使用元组创建列表对象ls3 = List((1,3))print(ls3)# 使用解析结构创建# range(stop)# range(start,stop,[,step]): step默认值时1.ls = [i for i in range(10)]ls4 = [i for i in range(0,10,2)]ls5 = List(x*2 for x in range(4) )print(ls,ls4,ls5)

# 结果<class ‘List‘> [][‘a‘,‘b‘,‘c‘,‘d‘][1,3][0,1,4,5,6,7,8,9] [0,8] [0,6]

- 列表的 *** 作 - 访问列表（索引）

　　* List中每个元素都会分配一个下标，即数字位置。
　　* List中元素下标是从0开始的，第n个元素下标为n-1。

# 访问元素ls = [1,"abc",[1,3]]# 访问列表第一个元素print(ls[0])# 访问列表最后一个元素print(ls[4])# 超出列表范围，会报错# print(ls[10])

# 结果1[1,3]

- 分片 *** 作

　　* 通过分片来获得列表部分的对象

# 创建列表l = List(range(11))print(l)# 分片# 返回分片列表print(l[1:3])print(l[1:4])   # 包含左边下标值，不包含右边下标值print("-"*20)print(l[:])print(l[2:])    # 省略分片结束位置时，分片直到列表结束print(l[:5])    # 下标值可以为空，左边默认为0，右边为最大值加1print("-"*20)# 分片可以控制增长幅度，默认增长幅度为1,默认往左移动，变成负数就相反print(l[1:8:1])print(l[1:8:2])print("-"*20)# 下标可以超出范围，超出后就不管多余的下标内容，#下标的值和幅度都可以为负数 但规定：数组最后一个下标为-1# print(l[-1:-3])   默认分片总是从左往右截取，即正常情况，分片的左边的值一定小于右边的  print(l[-3:-1])print(l[-2:-4:-1])# 幅度反转

# 结果[0,9,10][1,2][1,3]--------------------[0,10][2,10][0,4]--------------------[1,7][1,7]--------------------[8,9][9,8]

　　　　　　* 分片 *** 作时生成一个新的List
　　　　　　　　- 内置函数ID，负责显示一个变量或者数据的唯一编号

# ID函数a,b = 1,2c = aprint(a,ID(a))print(b,ID(b))print(c,ID(c))# 指向的关系a = 10print(a,ID(a))print(c,ID(c))print("-"*25)# 通过ID可以直接判断出分片是重新生成一份数据l = [i for i in range(10)] l1 = l[:]l2 = l1print(l,ID(l))print(l1,ID(l1))print(l2,ID(l2))

# 结果[0,8]

- 列表元素的替换　　

# 和字符串不一样，List可以在指定下标的值进行替换# 1.直接替换ls = [0,9]print(ls,ID(ls))ls[2] = "a"print(ls,ID(ls))# 利用分片ls[3:5] = ["eff","ddd"]print(ls,ID(ls))

# 结果[0,9] 2839901316104[0,‘a‘,‘eff‘,‘ddd‘,9] 2839901316104

- 列表的删除:
　　* del 删除命令，原地删除

　　* clear()方法可以删除列表中的全部对象

# 列表的删除a = b = [1,5]# 检测列表内容print(ID(a))del a[2]print(ID(a))# 检测列表内容   # 使用del后，ID的值和删除前不一样，这说明删除后生成新的Listprint(a)# del一个变量后不能在继续使用此变量del a  # print(a)  #会报错# 使用clear()print(b,ID(b))b.clear()# 原地修改print(b,ID(b))

# 结果23299261695442329926169544[1,5][1,5] 2329926169544[] 2329926169544

- 列表的相加和乘法：
　　* 使用加号+连接两个列表
　　* 列表和整数相乘*，把n个列表连接在一起
　　* 该过程是创建了一个新列表，并不是真正的原地扩展列表

# 列表之间相加a = [1,3]b = [3,6]c = [‘a‘,‘c‘]d = List()print(d,ID(d))d = a + b + cprint(d,ID(d))# 列表直接和一个整数相乘e = a * 2print(e)

# 结果[] 2329926114376[1,‘c‘] 2329925884680[1,3]

- 列表检查成员：
　　* 判断一个元素是否在列表里面in和not in

l = [1,3]print(2 in l)print(2 not in l)

# 结果TrueFalse

- 列表的遍历

# 使用for或者这while进行遍历,一般使用forls = List(range(8))for i in ls:    print(i,end="-")print(‘\n‘)# 双层列表循环a = [["one",1],["two",2],["three",3]]for b,c in a:    print(b,"----",c)  # 注意b,c要和a中的元素一一对应，

# 结果0-1-2-3-4-5-6-7-one ---- 1two ---- 2three ---- 3

- 列表的常用函数
　　* len 求长度： 列表元素个数 len(List)
　　* max 求最大值： 返回列表元素最大值 max(List)
　　* min 求最小值： 返回列表元素最大值 min(List)
　　* cmp 比较两个列表的元素 cmp(List1,List2)
　　* sum对数值型列表的元素进行求和运算，对非数值型列表运算则报错

# 使用for或者这while进行遍历ls = List(range(8))print(ls)print(len(ls),max(ls),min(ls),sum(ls))# cmp：若第一个列表大于第二个列表就返回1，相反返回-1.相同则为0.ls1 = ["a","b","c" ]ls2 = ["a","d" ]print(cmp(ls1,ls2))

# 结果[0,7]8 7 0 28-1

- *** 作符：
　　* 向列表添加元素：
　　　　- List.append(obj)
　　　　　　- obj---添加到列表末尾的对象。
　　　　　　- 原地修改列表速度快

　　　　- 使用+ ，将列表中的元素和新元素依次复制到新列表中
　　　　　　- 这并不是真正的为列表添加元素，而是创建一个新列表

　　　　- 使用List.extend(obj）在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
　　　　　　- 不改变内存首地址，属于原地 *** 作

　　　　- 使用insert(index,obj) 将对象插入列表：
　　　　　　- 由于列表的自动内存管理功能，插入后所有元素移动，会影响处理速度

ls = [1,4]print(ls,ID(ls))# 末尾追加一个对象ls.append(6)print(ls,ID(ls))# 原地修改# 末尾追加多个对象ls1 = ["a",2]ls.extend(ls1)print(ls,ID(ls))# 原地修改# 向列表插入对象ls.insert(1,"insert")print(ls,ID(ls)) # 原地修改

# 结果[1,4] 1816266667720[1,6] 1816266667720[1,2] 1816266667720[1,‘insert‘,2] 1816266667720

　　* 检索元素

　　　　　- 统计某个元素在列表中出现的次数   List.count(obj)

　　　　　- 使用in运算符检查某个元素是否在列表中

　　　　　- 从列表中找出某个值第一个匹配项的索引位置：List.index(obj)

ls = [1,2]# 计算个数print(ls.count(2))# 检查是否存在print(1 in ls)# 查询下标print(ls.index(4))

# 结果3True3

　* 删除元素　　

　　　- 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值： List.pop(index=-1)　　

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

　　　　　　- 删除列表中指定元素的所有重复，不能使用“循环+remove()方法”
　　　　　　- 每插入或删除一个元素后，该元素后面所有元素的索引就改变了

ls = [1,"nn",5]print(ls,ID(ls))# 移除末尾的对象rl = ls.pop(2)print(rl)print(ls,ID(ls))# 原地修改# 移除选择对象ls.remove(3)print(ls,ID(ls))# 原地修改

# 结果[1,‘nn‘,5] 1816268108232nn[1,5] 1816268108232[1,5] 1816268108232

　* 列表排序

　　　- 反向列表中元素： List.reverse()

# 反向reverse() 函数用于反向列表中元素。ls = [i for i in range(10)]print(ls,ID(ls))ls.reverse()print(ls,ID(ls))# 原地修改# 结果[0,9] 1816267946504[9,0] 1816267946504

　　　- 对原列表进行排序：List.sort(cmp=None,key=None,reverse=False)
　　　　　　* cmp:可选参数,如果指定了该参数会使用该参数的方法进行排序。
　　　　　　* key:主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
　　　　　　* reverse:排序规则，reverse = True 降序， reverse = False 升序（默认）。

# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。要求相同的类型aList = [‘123‘,‘bcd‘,‘abc‘,‘efg‘,‘125‘]aList.sort()print( "List : ",aList)vls = [‘a‘,‘d‘,‘e‘]vls.sort(reverse=True)# 输出结果print("降序输出:",vls)# 结果List :  [‘123‘,‘125‘,‘efg‘]降序输出: [‘e‘,‘a‘]

# 元组--tuple

- 元组可以看作不可变的列表，它具有列表的大多数特点。

- 元组的定义：

　　- 元组的特点：

　　　　- 元组可以包含任意类型的对象。

　　　　- 元组是一个有序的序列

　　　　- 元组的大小不能改变，既不能为元组添加对象，也不能删除元组中的对象。

　　　　- 元组中的对象也不能改变。

　　　　- 与列表类似，元组中存储的是对象的引用，而不是对象本身。

　　- 元组的创建
　　　　- 将一个元组赋值给变量，就可以创建一个元组变量
　　　　- 在括号中添加元素，并使用逗号隔开即可创建元组，逗号不能少。

　　　　- 可用元组常量或tuple()方法来创建元组。

# 创建空元组t = ()print(type(t))# 创建只有一i个值的元组t = (1,) # 一定要有逗号print(t,type(t))temp = (1)print(temp,type(temp))# 创建多个值t = 1,4print(t,type(t))# 使用其他结构创建l = [1,7]t = tuple(l)print(t,type(t))# 结果<class ‘tuple‘>(1,) <class ‘tuple‘>1 <class ‘int‘>(1,4) <class ‘tuple‘>(1,7) <class ‘tuple‘>

　　- 基本 *** 作

　　　　- 元组的访问
　　　　　　- 只能通过切片的方式访问元组中的元素，不支持使用切片来修改元组中元素的值，也不支持增加和删除
　　　　　　- 切片是生成了一个新元组
　　　　- 元组特性：

　　　　　　- 可以进行加法和乘法运算

　　　　　　- 可以使用迭代遍历元组中的各个元素

　　　　　　- 可以使用in *** 作符判断对象是否在元组中

　　　　　　-  除了修改外，元组都有索引，分片

　　　　　　- append、extend、insert、remove、pop、reverse、和sort不能直接用于元组

　　　　　　- 元组支持两个方法; count()和index()

　　　　- 元组的内置方法　　　　　　- cmp(tuple1,tuple2)：比较两个元组元素。　　　　　　- len(tuple)：计算元组元素个数。　　　　　　- max(tuple)：返回元组中元素最大值。　　　　　　- min(tuple)：返回元组中元素最小值。　　　　　　- tuple(seq)： 　　　　　　　　- 将列表转换为元组。 　　　　　　　　- 可以接受一个列表、字符串或者其他序列类型和迭代器作为参数，并返回一个包含同样元素的元组

@H_206_301@ 总结

以上是内存溢出为你收集整理的03-Python的数据类型1全部内容，希望文章能够帮你解决03-Python的数据类型1所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。