列表和字符串比较
- 列表和字符串都是序列,元素之间有先后顺序关系
字符串是不可变的序列,列表是可变的序列
字符串中每个元素只能存储字符,而列表可以存储任意类型的元素
列表和字符串都是可迭代对象
字符串文本解析方法split 和 join
- S.split(sep=None) 将字符串,使用sep作为分隔符拆分S字符串
返回拆分后的字符串列表,当不给定参数时,用空白字符进行
拆分
S.splitlines() 将字符串使用换行符'\n' 作为分隔符进行
拆分
S.join(iterable) 用可迭代对象中的字符串,返回合并后的
字符串
示例:
s = 'Beijing is capital'
L = s.split() # L=['Beijing', 'is', 'capital']
s2 = '这是第一行\n这是第二行\n这是第三行'
L2 = s.splitlines()
s3 = '#'.join(L) # s3='Beijing#is#capital'
列表推导式 list comprehension建列表的表达式
作用:
用简易方法创建列表w
语法:
[表达式 for 变量 in 可迭代对象]
或w
[表达式 for 变量 in 可迭代对象 if 真值表达式]
说明:
if 子句部分可以省略
示例:
# 生成一个数值为 1~9的平方的列表
# 用循环方式实现
L = []sa
for x in range(1, 10):
L.append(x**2)
# 用推导式实现
L = [x**2 for x in range(1, 10)]
示例2:
s = "hello"
L = [x for x in s]
元组 tuple
- 元组是不可改变的序列容器,同list一样,元组可以存入任意类型数据
- 表示方法:
用小括号() 括起来,单个元素括起来后加逗号(,)区分单个对象
还是元组
创建空元组的字面值
t = () # () 将创建空元组
创建非空元组的字面值
t = 200,
t = (20,)
t = (1, 2, 3)
t = 100, 200, 300
注:
type(x) 函数可以返回x的类型
元组创建的错误示例:
t = (20) # t 绑定20这个对象,不是元组
x, y, z = 100, 200, 300 # 序列赋值,不是元组
x, y, z = (100, 200, 300) # 序列赋值
x, y, z = [100, 200, 300] # 序列赋值
x, y, z = "ABC" # 序列赋值,不是元组
元组的构造函数 tuple
- tuple() 生成一个空的元组,等同于()
tuple(iterable) 用可迭代对象生成一个元组
示例:
t = tuple() # t绑定空元组 等同于 t=()
t = tuple(range(1, 10, 3)) # t = (1, 4, 7)
t = tuple("ABC") # t = ('A', 'B', 'C')
元组的运算:
- 算术运算:
+ += * *=
示例:
t1 = (1, 2, 3) + (4, 5, 6)
t1 += (7, 8, 9)
t2 = (1, 2) * 3
t2 *= 2
比较运算:
< <= > >= == !=
注: 元组比较的规则与列表的比较规则完全相同
示例:
(1, 2, 3) < (1, 2, 4) # True
("ABC", 456) > ("123", 789) # True
(1, '二') > ('二', 1) # 出错
in 和 not in 运算符
判断一个值是否存在于元组中,如果是返回True,否则返回False
规则写列表的in 和 not in 规则相同
示例:
x = (1, 'Two', 3)
2 in x # False
2 not in x # True
3 in x # True
[] 运算符
索引 index
用法等同于列表的索引
元组不支持索引赋值操作
切片 slice
用法等同于列表的切片
元组不支持切片赋值
示例:
x = (1, 2, 3, 4, 5, 6)
print(x[0]) # 1
print(x[1::2]) # (2, 4, 6)
元组的方法:
T.index(v[,begin[,end]]) 返回对应元组的索引下标,当v不
存在时,触发ValueError错误
T.count(x) 返回元组中对应元素的个数
文档参见:
python_base_docs_html/tupe.html
序列相关的函数小结
len(x) 返回序列的长度
max(x) 求最大
min(x)
sum(x) 求和(只能是数字)
any(x) 布尔测试,只要有一个为真,则返回真
all(x) 布尔测试,所有都为真,才返回真
序列的构造函数:
str(obj) 创建字符串
list(iterable) 创建列表
tuple(iterable) 创建元组
序列的反转函数:
reversed(可迭代对象) 返回反向顺序的可迭代对象
示例:
s = "ABCD"
for ch in reversed(s):
print(ch) # D C B A 顺序打印
L = list(reversed(s)) # L = ['D', 'C', 'B', 'A']
L2 = [x for x in reversed(s)]
序列的种类:
字符串 str
列表 list
元组 tuple
------- 以下后面才学-----
字节串 bytes
字节数组 bytearray
字典 dict
- 什么是字典:
字典是一种可变的容器,可以存储任意类型的数据
字典中的每个数据都是用"键"(key) 进行索引,而不像序
列(字符串等)可以用整数下标进行索引
字典中的数据没有先后顺序关系,字典的存储是无序的
字典中的数据以键-值(key-value) 对的形式进行映射存储
字典的键不能重复,且只能用不可变类型作为字典的键
- 字典的字面值创建方法:
字典的表示方式是以{} 括起来,以冒号(:) 分隔键-值对,各键值对
之间用逗号分割开
创建空字典
d = {}
创建非空的字典
d = {'name': '小明', 'age': 30}
不可变类型:
bool, int, float, complex, str, tuple,
frozenset(固定集合), bytes(字节串)
可变数据类型:
list, dict, set(集合), bytearray(字节数组)
创建字典示例:
d = {"a": 100}
d = {100: '一佰'}
d = {"a": tuple("ABC")}
d = {(1970, 1, 1): "计算机元年"}
d = {123: list(range(1, 4))}
字典的构造函数 dict
dict() 创建一个空的字典,等同于{}
dict(iterable) 用可迭代对象的数据创建一个字典
dict(**kwargs) 用关键字传参方式创建一个字典
示例:
d = dict()
L = [(1, 2),[3, 4],'AB'] #列表的内容都为两个元素的序列
d = dict(L) # d={1:2, 3:4, 'A':'B'}
d = dict(name='Tarena', age=17)
字典的基本操作
字典的键索引取值
用 [] 运算符可以获取字典内'键'所对应的'值'
语法:
v = 字典[键]
示例
d = {'name': 'Tarena', 'age': 17}
print(d['name'], '的年龄是', d['age'], '岁')
添加和修改字典的键值对
语法:
字典[键] = 表达式
说明:
键不存在,创建键,并绑定键对应的值
键存在,修改键绑定的值
示例:
d = {}
d['name'] = 'Tarena' # 创建键'name'同时关联'Tarena'
d['age'] = 16 # 创建键值对'age': 16
d['age'] = 17 # 修改键所对应的值
###del 语句用来删除字典的键值对
语法:
del 字典[键]
示例:
d = {‘name’: ‘Tarena’, ‘age’: 17}
del d[‘name’]
del d[‘age’]
###字典的成员资格判断 in 和 not in 运算符
in 用来判断一个键是否存在于字典中,如果存在则返回True,否则
返回False
not in 的返回值与 in 相反
示例:
d = {'name': 'Tarena', 'age': 16}
'name' in d # True
16 in d # False, in 运算符只判断键,不判断值
'name' not in d # False
100 not in d # True
字典的迭代访问
字典是可迭代对象,字典只能对键进行迭代访问
示例:
d = {'姓名': '小张', '年龄': 20}
for k in d:
print('键:', k, '值:', d[k])
字典的比较运算:
== !=
== 判断字典是否完全相同(键相同,值也相同返回True)
!= 判断字典是否不同(与 !=相反)
示例:
{'一': 1, '二': 2} == {'二': 2, '一': 1} # True
{'一': 1, '二': 2} == {'二': 2, '一': 1.11} #False
可以用于字典的内建函数
len(x) 返回字典键值对的个数
max(x) 返回字典键的最大值
min(x) 返回字典键的最小值
sum(x) 返回字典中所有键的和
any(x) 真值测试,如果字典中其中一个键为真值则返回真
all(x) 真值测试,字典中所有键都为真,才返回真
示例:
d = {0:'零', 1:'壹', 2:'贰', 5: '伍', 10:'拾'}
print(len(d)) # 5
print(max(d)) # 10
print(min(d)) # 0
print(sum(d)) # 18
print(any(d)) # True
print(all(d)) # False
字典的方法:
文档参见:
python_base_docs_html/dict.html
示例:
d = {1: '壹', 2: '贰', 10: '拾', 5: '伍'}
for k in d:
print(k) # 1 2 10 5
for k in d.keys():
print(k) # 1 2 10 5
for v in d.values():
print(v) # '壹','贰','拾','伍'
for t in d.items():
print(t) # (1,'壹'), (2,'贰'),(10,'拾'),(5:'伍')
for k,v in d.items(): # 元组会序列赋值给k和v
print("键:", k, '值:', v)
字典推导式
字典推导式是用可迭代对象依次生成字典内元素的表达式
语法:
{键表达式:值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注: [] 代表内部的内容可省略
示例:
# 生成一个字典,键为1~9的整数,值为键的平方
d = {x: x**2 for x in range(1, 10)}
字典推导式的嵌套
语法同列表推导式的嵌套规则一致(略)
- 方法 说明
D代表字典对象
D.clear() 清空字典
D.pop(key) 移除键，同时返回此键所对应的值
D.copy() 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default=None) 返回键key所对应的值,如果没有此键，则返回default
D.keys() 返回可迭代的 dict_keys 集合对象
D.values() 返回可迭代的 dict_values 值对象
D.items() 返回可迭代的 dict_items 对象
