03-Python的数据类型1

# Python中的数据类型

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

# 列表list

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

- 列表的定义：

　　- 列表基本特点：

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

　　　　- 列表是一个有序的序列

　　　　- 列表是可变的

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

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

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

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

# 结果
<class 'list'>
<class 'list'> [1, 2, 3, 'list']　　　

　　　   - 使用list()函数

# 直接调用不带参的list()函数时，会返回一个空列表。
ls1 = list()
print(type(ls1),ls1)

# 用课迭代对象创建列表对象
ls2 = list("abcd")
print(ls2)

# 使用元组创建列表对象
ls3 = list((1, 2, 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, 2, 3]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 2, 4, 6, 8] [0, 2, 4, 6]

- 列表的操作

- 访问列表（索引）

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

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

# 结果
1
[1, 'b', 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，右边为最大值加1

print("-"*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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2]
[1, 2, 3]
--------------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4]
--------------------
[1, 2, 3, 4, 5, 6, 7]
[1, 3, 5, 7]
--------------------
[8, 9]
[9, 8]

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

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

print(l, id(l))
print(l1, id(l1))
print(l2, id(l2))

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

- 列表元素的替换　　

# 和字符串不一样，list可以在指定下标的值进行替换
# 1.直接替换
ls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(ls, id(ls))
ls[2] = "a"
print(ls, id(ls))

# 利用分片
ls[3:5] = ["eff", "ddd"]
print(ls, id(ls))

# 结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 2839901316104
[0, 1, 'a', 3, 4, 5, 6, 7, 8, 9] 2839901316104
[0, 1, 'a', 'eff', 'ddd', 5, 6, 7, 8, 9] 2839901316104

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

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

# 列表的删除
a = b = [1,2,3,4,5]
# 检测列表内容
print(id(a))

del a[2]
print(id(a))
# 检测列表内容   # 使用del后，id的值和删除前不一样，这说明删除后生成新的list
print(a)

# del一个变量后不能在继续使用此变量
del a  
# print(a)  #会报错

# 使用clear()
print(b, id(b))
b.clear()# 原地修改
print(b,id(b))

# 结果
2329926169544
2329926169544
[1, 2, 4, 5]
[1, 2, 4, 5] 2329926169544
[] 2329926169544

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

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

# 结果
[] 2329926114376
[1, 2, 3, 3, 5, 6, 'a', 'b', 'c'] 2329925884680
[1, 2, 3, 1, 2, 3]

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

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

# 结果
True
False

- 列表的遍历

# 使用for或者这while进行遍历,一般使用for
ls = 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 ---- 1
two ---- 2
three ---- 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", "b", "d" ]
print(cmp(ls1, ls2))

# 结果
[0, 1, 2, 3, 4, 5, 6, 7]
8 7 0 28
-1

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

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

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

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

ls = [1, 2, 3, 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, 2, 3, 4] 1816266667720
[1, 2, 3, 4, 6] 1816266667720
[1, 2, 3, 4, 6, 'a', 2] 1816266667720
[1, 'insert', 2, 3, 4, 6, 'a', 2] 1816266667720

　　* 检索元素

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

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

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

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

# 结果
3
True
3

　* 删除元素　　

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

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

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

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

# 结果
[1, 2, 'nn', 3, 3, 4, 5] 1816268108232
nn
[1, 2, 3, 3, 4, 5] 1816268108232
[1, 2, 3, 4, 5] 1816268108232

　* 列表排序

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

# 反向reverse() 函数用于反向列表中元素。
ls = [i for i in range(10)]
print(ls, id(ls))
ls.reverse()
print(ls, id(ls))# 原地修改
# 结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 1816267946504
[9, 8, 7, 6, 5, 4, 3, 2, 1, 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', 'c', 'd', 'b', 'e']
vls.sort(reverse=True)
# 输出结果
print("降序输出:", vls)
# 结果
List :  ['123', '125', 'abc', 'bcd', 'efg']
降序输出: ['e', 'd', 'c', 'b', 'a']

# 元组--tuple

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

- 元组的定义：

　　- 元组的特点：

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

　　　　- 元组是一个有序的序列

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

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

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

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

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

# 创建空元组
t = ()
print(type(t))

# 创建只有一i个值的元组
t = (1,) # 一定要有逗号
print(t, type(t))
temp = (1)
print(temp, type(temp))

# 创建多个值
t = 1, 2, 3, 4
print(t, type(t))

# 使用其他结构创建
l = [1,2,3,4,5,6,7]
t = tuple(l)
print(t, type(t))
# 结果
<class 'tuple'>
(1,) <class 'tuple'>
1 <class 'int'>
(1, 2, 3, 4) <class 'tuple'>
(1, 2, 3, 4, 5, 6, 7) <class 'tuple'>

　　- 基本操作

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

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

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

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

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

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

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

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

转载于:https://www.cnblogs.com/cmn-note/p/11179859.html