一、列表
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()，可找出列表中独一无二的元素，并创建一个集合
# 嵌套：字典列表、在字典中存储列表、在字典中存储字典