一.序列类型
1.列表list
1.列表是可变序列，通常用于存放同类项目的集合（其中精确的相似程度将根据应用而变化）。
2.可以用多种方式构建列表：
-
使用一对方括号来表示空列表:
[] -
使用方括号，其中的项以逗号分隔:
[a],[a, b, c] -
使用列表推导式:
[x for x in iterable] -
使用类型的构造器:
list()或list(iterable)
3.列表的操作
#list更多操作
#修改列表元素
student = ['张三','李四','王五','赵六','狗七']
student[4] = '张三丰'
print(student)
#删除列表元素
student = ['张三','李四','王五','赵六','狗七']
del student[4]
print(student)
#批量修改，【开始的元素:修改的个数】
student = ['张三','李四','王五','赵六','狗七']
student[0:2] = ['张三丰','李狗蛋']
print(student)
student = ['张三','李四','王五','赵六','狗七']
student[1:2] = ['张三丰','李狗蛋']
print(student)
#批量删除，【开始的元素:结束的元数】
student = ['张三','李四','王五','赵六','狗七']
del student[1:3]
print(student)
#追加列表元素
student = ['张三','李四','王五','赵六','狗七']
student.append('小王')
print(student)
#批量追加列表元素
student = ['张三','李四','王五','赵六','狗七']
student.extend(['小王','小张'])
print(student)
#返回要删除的列表元素
#sentence:I Love Natural Language Process
#CBOW:根据上下文预测中间的词
#context:I Love Language Process
#Label:Natural
sentence = 'I Love Natural Language Process'
words = sentence.split()
#提取目标 Natural
Label = words.pop(2)
print(Label)
#提取上下文 I Love Language Process
context = words
print(context)运行结果
2.元组tuple
1.元组是不可变序列，通常用于储存异构数据的多项集（例如由 enumerate() 内置函数所产生的二元组）。 元组也被用于需要同构数据的不可变序列的情况（例如允许存储到 set 或 dict 的实例）。
2.可以用多种方式构建元组：
-
使用一对圆括号来表示空元组:
() -
使用一个后缀的逗号来表示单元组:
a,或(a,) -
使用以逗号分隔的多个项:
a, b, cor(a, b, c) -
使用内置的 tuple():
tuple()或tuple(iterable)
3.元组的操作
#元组的操作与列表的操作相同，仅仅需要将【】改为（）即可
#元组的定义与基本操作
#1.（）2.tuple3.，
tuple1 = (1,2,3)
print(tuple1)
#访问元素值
print(tuple1[1])
#元组的元素不可修改
#使用逗号定义元组
tuple2 = 1,2,3
print(tuple2)
#使用tuple定义元组
tuple3 = tuple([1,2,3])
print(tuple3)
#使用元组进行解构赋值
username,age,gender = '张三',18,'男'
print(username)
print(age)
print(gender)
#不用的值用下划线(_)表示
username,age,gender,_ = '张三',18,'男','科技大学'运行结果
3.range 对象range
1.range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。
2.class range(start, stop[, step])
range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__() 特殊方法的对象）。 如果省略 step 参数，则默认为 1。 如果省略 start 参数，则默认为 0。 如果 step 为零，则会引发 ValueError。
如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。
如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.
如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。
3.range的操作
#range对象
r = range(0,10,1)
print(r)
print(list(r))
for i in range(0,10):
print(i)
#映射类型dict
student = {'name':'小王','age':18,'gender':'男'}
print(student['name'])
#英文到中文的映射
category = {'a':'可爱','b':'美丽','c':'无敌'}
print(category['a'])
#2 ---- two ---- to
A = {
'123':{
"name":"小王",
"age":18,
"where":["上海","北京",'杭州'],
"like":{"吃":'水果',
"喝":'咖啡' ,
"玩":'游戏'}
}
}
print(A['123']['where'])
print(A['123']['age'])
print(A['123']['like']['玩'])
print(A['123']['where'][1])运行结果
4.字符串str
1.在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 码位构成的不可变 序列。
2.符串字面值有多种不同的写法：
-
单引号:
'允许包含有 "双" 引号' -
双引号:
"允许嵌入 '单' 引号" -
三重引号:
'''三重单引号''',"""三重双引号"""
3.操作参考链接
5.通用序列操作
| 运算 | 结果： | 备注 |
|---|---|---|
|
| 如果 s 中的某项等于 x 则结果为 | (1) |
|
| 如果 s 中的某项等于 x 则结果为 | (1) |
|
| s 与 t 相拼接 | (6)(7) |
|
| 相当于 s 与自身进行 n 次拼接 | (2)(7) |
|
| s 的第 i 项，起始为 0 | (3) |
|
| s 从 i 到 j 的切片 | (3)(4) |
|
| s 从 i 到 j 步长为 k 的切片 | (3)(5) |
|
| s 的长度 | |
|
| s 的最小项 | |
|
| s 的最大项 | |
|
| x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） | (8) |
|
| x 在 s 中出现的总次数 |
在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。
in 和 not in 操作具有与比较操作相同的优先级。 + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级。
1.虽然 in 和 not in 操作在通常情况下仅被用于简单的成员检测，某些专门化序列 (例如 str, bytes 和 bytearray) 也使用它们进行子序列检测。
2.小于 0 的 n 值会被当作 0 来处理 (生成一个与 s 同类型的空序列)。 请注意序列 s 中的项并不会被拷贝；它们会被多次引用。
3.如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为 len(s) + i 或 len(s) + j。 但要注意 -0 仍然为 0。
4.s 从 i 到 j 的切片被定义为所有满足 i <= k < j 的索引号 k 的项组成的序列。 如果 i 或 j 大于 len(s)，则使用 len(s)。 如果 i 被省略或为 None，则使用 0。 如果 j 被省略或为 None，则使用 len(s)。 如果 i 大于等于 j，则切片为空。
5.s 从 i 到 j 步长为 k 的切片被定义为所有满足 0 <= n < (j-i)/k 的索引号 x = i + n*k 的项组成的序列。 换句话说，索引号为 i, i+k, i+2*k, i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。 当 k 为正值时，i 和 j 会被减至不大于 len(s)。 当 k 为负值时，i 和 j 会被减至不大于 len(s) - 1。 如果 i 或 j 被省略或为 None，它们会成为“终止”值 (是哪一端的终止值则取决于 k 的符号)。 请注意，k 不可为零。 如果 k 为 None，则当作 1 处理。
6.拼接不可变序列总是会生成新的对象。 这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。
7.某些序列类型 (例如 range) 仅支持遵循特定模式的项序列，因此并不支持序列拼接或重复。
8.当 x 在 s 中找不到时 index 会引发 ValueError。 不是所有实现都支持传入额外参数 i 和 j。 这两个参数允许高效地搜索序列的子序列。 传入这两个额外参数大致相当于使用 s[i:j].index(x)，但是不会复制任何数据，并且返回的索引是相对于序列的开头而非切片的开头。
6.不可变序列类型
1.不可变序列类型普遍实现而可变序列类型未实现的唯一操作就是对 hash() 内置函数的支持。
这种支持允许不可变类型，例如 tuple 实例被用作 dict 键，以及存储在 set 和 frozenset 实例中。
尝试对包含有不可哈希值的不可变序列进行哈希运算将会导致 TypeError。
2.应用
#变量可变类型与不可变类型
#不可变类型（指内存空间不可变）
n = 100
print(id(n),hex(id(n)))
print(n)
n = 200
print(id(n),hex(id(n)))
print(n)
#变量的赋值和引用
a = 100 #赋值
b = a #引用
print(id(a),id(b))
b = 200 #赋值(开辟一个新的内存块)（引用关系不存在了）
print(id(a),id(b))
c = 100
print(id(c))
print(a,b,c)
输出结果
7.可变序列类型
1.可变序列类型的操作
| 运算 | 结果： | 备注 |
|---|---|---|
|
| 将 s 的第 i 项替换为 x | |
|
| 将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容 | |
|
| 等同于 | |
|
| 将 | (1) |
|
| 从列表中移除 | |
|
| 将 x 添加到序列的末尾 (等同于 | |
|
| 从 s 中移除所有项 (等同于 | (5) |
|
| 创建 s 的浅拷贝 (等同于 | (5) |
|
| 用 t 的内容扩展 s (基本上等同于 | |
|
| 使用 s 的内容重复 n 次来对其进行更新 | (6) |
|
| 在由 i 给出的索引位置将 x 插入 s (等同于 | |
|
| 提取在 i 位置上的项，并将其从 s 中移除 | (2) |
|
| 从 s 中移除第一个 | (3) |
|
| 就地将列表中的元素逆序。 | (4) |
1.如果 k 不等于 1，则 t 必须与它所替换的切片具有相同的长度。
2.可选参数 i 默认为 -1，因此在默认情况下会移除并返回最后一项。
3.当在 s 中找不到 x 时 remove() 操作会引发 ValueError。
4.当反转大尺寸序列时 reverse() 方法会原地修改该序列以保证空间经济性。 为提醒用户此操作是通过间接影响进行的，它并不会返回反转后的序列。
5.包括 clear() 和 copy() 是为了与不支持切片操作的可变容器 (例如 dict 和 set) 的接口保持一致。 copy() 不是 collections.abc.MutableSequence ABC 的一部分，但大多数具体的可变序列类都提供了它。
6.n 值为一个整数，或是一个实现了 __index__() 的对象。 n 值为零或负数将清空序列。 序列中的项不会被拷贝；它们会被多次引用，正如 通用序列操作 中有关 s * n 的说明。
二.映射类型
1.定义
mapping 对象会将 hashable 值映射到任意对象。 映射属于可变对象。 目前仅有一种标准映射类型 字典。
2.部分应用实例
1.
#dict的操作
#返回字典d中所有的列表
d = {'name':'张三','age':18,'sex':'男'}
print(list(d))
print(d.keys())
print(d.values())
print(d.items())#元素
#获取键对应的值，如果没有对应的键，就使用默认的值
print(d.get('name',0))
d['name'] = '李四'
print(d)2.
#集合类型set
s1 = set([1,2,3,4,5])
print(s1)
print(type(s1))
s2 = set([1,2,3,4,5,4,3,2,1])
print(s2)
data = ''
data = data.replace(',','').replace('.','').replace('<','').replace('>','')
#做一个词典，去重
list(set(data.split()))
#数学的交集、差集、并集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#交集
print(set1 & set2)
print(set1.intersection(set2))
#并集
print(set1 | set2)
print(set1.union(set2))
#差集
print(set1 - set2)
print(set1.difference(set2))
三.集合类型
1.set
1.构造方式
class set([iterable])
class frozenset([iterable])
返回一个新的 set 或 frozenset 对象，其元素来自于 iterable。 集合的元素必须为 hashable。 要表示由集合对象构成的集合，所有的内层集合必须为 frozenset 对象。 如果未指定 iterable，则将返回一个新的空集合。
集合可用多种方式来创建:
-
使用花括号内以逗号分隔元素的方式:
{'jack', 'sjoerd'} -
使用集合推导式:
{c for c in 'abracadabra' if c not in 'abc'} -
使用类型构造器:
set(),set('foobar'),set(['a', 'b', 'foo'])
2.set的操作
#集合类型set
s1 = set([1,2,3,4,5])
print(s1)
print(type(s1))
s2 = set([1,2,3,4,5,4,3,2,1])
print(s2)
data = ''
data = data.replace(',','').replace('.','').replace('<','').replace('>','')
#做一个词典，去重
list(set(data.split()))
#数学的交集、差集、并集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#交集
print(set1 & set2)
print(set1.intersection(set2))
#并集
print(set1 | set2)
print(set1.union(set2))
#差集
print(set1 - set2)
print(set1.difference(set2))运行结果
2.frozenset
1.构造方式
class frozenset([iterable])
返回一个新的 set 或 frozenset 对象，其元素来自于 iterable。 集合的元素必须为 hashable。 要表示由集合对象构成的集合，所有的内层集合必须为 frozenset 对象。 如果未指定 iterable，则将返回一个新的空集合。
集合可用多种方式来创建:
-
使用花括号内以逗号分隔元素的方式:
{'jack', 'sjoerd'} -
使用集合推导式:
{c for c in 'abracadabra' if c not in 'abc'} -
使用类型构造器:
set(),set('foobar'),set(['a', 'b', 'foo'])
3.集合类型的操作实例
详见set部分
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
