【python教程】2、列表、元组、字符串、字典

一、列表

1、函数 list：它实际上是一个类，可将任何序列作为 list 的参数

# 1、函数list
a = list('abc')
print(a)  # a结果为：['a','b','c']

# 2、将字符列表转化为字符串
print(''.join(a))  # 结果为：'abc'
print('1'.join(a))  # 结果为：'a1b1c'

2、修改列表的方式：给元素/切片赋值、删除元素

# 1、给元素赋值
x = [1,1,1,1]
x[1] = 2  # x为：[1,2,1,1]，注意不能给不存在的元素赋值

# 2、删除元素
del x[1]  # x为：[1,1,1]

# 3、给切片赋值
x[1:] = [2,2]  # x为：[1,2,2]
x[2:] = [3,4,5]  # x为：[1,2,3,4,5]，使用切片赋值，可将切片切换为长度与其不同的序列
x[1:1] = [0,0]  # x为：[1,0,0,2,3,4,5]，可在不替换原有元素的情况下插入新元素
x[1,2] = []  # x为：[1,2,3,4,5]，替换一个空切片，来删除切片

3、列表方法

方法是与对象联系紧密的函数。方法调用和函数调用很像，只是在方法名前加上了对象和句点。

lst = [1,2,3]
# 1、增加元素
lst.append(4)  # 增加元素，lst为：[1,2,3,4]
lst.extend(1,2,3,4)  # 扩展列表
lst.insert(1, 'test')  # 将一个对象插入列表，lst值为：[1,'test',2,3,4,1,2,3,4]
ls = [1,2] + [2，3]  # 拼接列表，返回新的序列

# 2、删除元素
i = lst.pop()  # 从列表中删除最后一个元素（栈，后进先出LIFO），并返回这个元素
i = lst.pop(0)  # 先进先出
lst.remove('test')  # 删除第一个为指定值的元素
lst.clear()  # 清空列表的内容，类似与切片赋值语句 lst[:] = []

l = [1,2,3]
# 3、元素排序
l.reverse()  # 按相反的顺序排列列表中的顺序，不返回值
list(reversed(l))  # 函数reversed，按相反的顺序迭代序列，返回一个迭代器
l.sort()  # 对列表就地排序，参数reverse=True（默认值）表示正序
n = sorted(l)  # 返回一个排过序的列表
# 高级排序
x = ['a','abc','ab']
x.sort(key=len)  # 根据元素长度进行排序（使用len函数为每个元素创建一个键，再按键排序）

ls.index(2)  # 查找指定值第一次出现的索引
lst.count(1)  # 计算指定元素在列表中出现的次数

a = [1,2,3]
b = a  # 将b关联到列表
b[2] = 0  # a为：[1,2,0]
c = a.copy()  # 类似于a[:]和list(a)；a和c指向不同的列表
c[2] = -1  # a为：[1,2,-1]

squares = [value**2 for value in range(1,11)]  # 列表解析

二、元组

元组：不可修改的序列。使用圆括号来标识。只包含一个值的元组，必须再这个值后面加上逗号。

x = 1, 2, 3  # 元组的定义
y = (1,)
z = tuple('abc')

a = 3 * (1 + 1,)  # a的值为：(2, 2, 2)
print(a[1])  # a[1]=2，用索引访问元素

# 修改元组变量。虽然不能修改元组的元素，但可以给存储元组的变量重新赋值
d = (200, 50)
d = (400, 100)

三、字符串

字符串是不可变的，所以给元素或切片赋值都是非法的。用引号括起的都是字符串，可以是单引号，也可以是双引号。

字符串的方法很多，其中很多都是继承自模块string。（在较早的python版本中，这些方法是string中的函数）。模块string中有一些字符串没有的常量和函数，如 string.digits。

'world'.center(10)  # 在两边添加填充字符让字符串居中，默认为空格
'world'.center(10, '-')

'12345'.find('23')  # 在字符串中查找子串，找到就返回子串第一个字符的索引，否则返回-1
print('a' in 'abc')  # 检查单个字符是否在序列中，返回True和False

seq = ['1', '2', '3', '4']
print('+'.join(seq))  # 结果为'1+2+3+4'，join合并序列的元素（元素须为字符串）
dirs = '', 'usr', 'bin', 'env'
print('C' + '\'.join(dirs))  # 结果为：C:usrinenv

print('/usr/bin/env'.split('/'))  # 结果为：['', 'usr', 'bin', 'env']
print('a b c'.split())  # 结果为：['a', 'b', 'c']

# title()：词首大写
# upper()/lower()：将字符串改为全部大写或全部小写
string.capwords("that's all, folks")  # 词首大写

print('ab c de'.replace('ab', 'b'))  # 将指定子串替换为另一个字符串

# rstrip()：删除末尾空白（空白：泛指任何非打印字符。空格、制表符	和换行符
）
# lstrip()：删除开头空白
# strip()：删除两端空白
print('***ab*cd!!**'.strip('!*'))  # 删除两端的指定字符，结果为ab*cd

# isspace()、isdigit()、isupper()：字符是否全为空白、数字、大写，是返回True，否则返回False

四、字典

字典是python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可能是数、字符串或元组。键必须是独一无二的。

Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

# 1、函数dict()
items = [('name', 'lisa')]
print(dict(items))  # 结果为：{'name': 'lisa'}
d = dict(name='lisi', age=42)  # 使用关键字实参调用这个函数，d为{'name': 'lisa', 'age':42}
d1 = dict()  # d1为{}

# 2、基本的字典操作（字典的基本行为在很多方面都类似于序列）
# len(d)；d[k]；d[k] = v；del d[k]；k in d（检查字典是否包含指定的键的效率更高，数据结构越大，效率差别越大）
# 键的类型：可以是任何不可变的类型，如实数，字符串或元组

# 3、将字符串格式设置功能用于字典
phonebook = {'beth': '9102', 'ceil': '3258'}
print("ceil's phone nember is {ceil}." .format_map(phonebook))

字典的方法：

x = {'name': 'amy', 'machines': ['foo', 'bar']}

# 1、copy浅赋值（替换副本中的值，原件不受影响；修改副本中的值，原件也将修改）
y = x.copy()  # copy返回一个新字典，其包含的键值对于原来的字典相同。
y['name'] = 'ame'
y['machines'].remove('bar')
print(x, y)  # x={'name': 'amy', 'machines': ['foo']}; y={'name': 'ame', 'machines': ['foo']}

# 2、deepcopy深复制(同时复制值及其包含的所有值)
from copy import deepcopy
dc = deepcopy(x)
x['age'] = 18
print(dc, y)  # dc={'name': 'amy', 'machines': ['foo']}; y={'name': 'amy', 'machines': ['foo'], 'age': 18};

# 3、fromkeys 创建一个新字典，包含指定的键，每个键对应的值都是None
{}.fromkeys(['name', 'age'])  # 结果为{'name':None, 'age': None}
dict.fromkeys(['name', 'age'])  # 直接对dict调用fromkeys（dict是所有字典所属的类型），结果为{'name':None, 'age': None}
dict.fromkeys(['name', 'age'],'(unknown)')  # 不使用默认值None，提供特定值unknown

# 4、get
d = {}
print(d['age'])  # 访问字典中没有的项，会引发错误
print(d.get('age'))  # 不会引发异常，而是返回Nona。可指定默认值：d.get('age', 'N/A')

# 5、items 返回一个包含所有字典项的列表，其中每个元素都为(key, value)的形式
p = {'name': 'lisa', 'age':42}
it = p.items())  # it=dict_items([('name': 'lisa'), ('age':42)])，这是一种名为字典视图的特殊类型，可用于迭代
# 字典视图的用法：len(it)、 ('age':42) in it、list(p.items())

# 6、keys 返回一个字典视图，其中包含指定字典中的键

# 7、pop 获取指定键相关联的值，并将该键值对从字典中删除
d = {'x': 1, 'y': 2}
print(d.pop('x'))  # 打印1，且d={'y': 2}

# 8、popitem 随机弹出一个字典项，因为字典项的顺序是不确定的
print(d.popitem())  # 结果为: {'y': 2}, d={}

# 9、setdefault 获取与指定键相关联的值。在字典不包含指定键时，在字典中添加指定的键值对
d = {}
d.setdefault('name', 'N/A')  # 打印：'N/A',d={'name': 'N/A'}
d.['name'] = 'ada'
print(d.setdefault('name', 'N/A'))  # 打印：'ada'

# 10、update 使用一个字典中的项来更新另一个字典
d = {'x': 1, 'y': 2, 'z': 3}
t = {'x': 3, 'y': 3}
d.updata(x)  # d={'x': 3, 'y': 3, 'z': 3}

# 11、values 返回一个由字典中的值组成的字典视图
d={'x': 2, 'y': 3, 'z': 3}
print(d.values())  # 打印：dict_values([2, 3, 3])

# 12、clear
r = x.clear()  # clear删除所有的字典项，d={}，r=None

常用操作

# 删除键—值对值对
del alien_0['points'] # 彻底删除

# 遍历键—值对值
for key, value in user_0.items():  # 将每个键—值对存储到指定的两个变量中，items()：把字典中每对key和value组成一个元组，并把元组放在列表中返回

# 遍历键
for name in favorite_languages:
for name in favorite_languages.keys():  # keys()并非只能用于遍历；它会返回一个列表，包含字典中的所有键

# 遍历值，使用方法values()
for language in set(favorite_languages.values()):  # 去重：对列表调用set()，可找出列表中独一无二的元素，并创建一个集合

# 嵌套：字典列表、在字典中存储列表、在字典中存储字典