tup = (4, 5, 6)  # 使用圆括号创建元组
print(tup)      # 输出: (4, 5, 6)

tup = 4, 5, 6  # 不使用括号创建元组
print(tup)    # 输出: (4, 5, 6)

my_list = [4, 0, 2]           # 创建一个列表
my_tuple = tuple(my_list)     # 将列表转换为元组
print(my_tuple)              # 输出: (4, 0, 2)

string_tuple = tuple('string') # 将字符串转换为元组
print(string_tuple)           # 输出: ('s', 't', 'r', 'i', 'n', 'g')

print(string_tuple[0])  # 访问元组的第一个元素，输出: 's'

nested_tup = (4, 5, 6), (7, 8) # 创建一个嵌套元组
print(nested_tup)             # 输出: ((4, 5, 6), (7, 8))
print(nested_tup[0])          # 访问第一个元组，输出: (4, 5, 6)
print(nested_tup[1][0])       # 访问第二个元组的第一个元素，输出: 7

tup = tuple(['foo', [1, 2], True]) # 创建一个包含列表的元组
# tup[2] = False  # 这行代码会引发 TypeError，因为元组不可变！

# 但是，可以*在原处*修改可变元素：
tup[1].append(3)  # 向列表 [1, 2] 中追加元素 3
print(tup)       # 输出: ('foo', [1, 2, 3], True)

tuple1 = (4, None, 'foo')          # 创建元组 tuple1
tuple2 = (6, 0)                   # 创建元组 tuple2
tuple3 = ('bar',)                 # 创建单元素元组 tuple3（注意逗号）
combined_tuple = tuple1 + tuple2 + tuple3 # 连接三个元组
print(combined_tuple)             # 输出: (4, None, 'foo', 6, 0, 'bar')

repeated_tuple = ('foo', 'bar') * 4 # 将元组重复 4 次
print(repeated_tuple)             # 输出: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')

tup = (4, 5, 6) # 创建一个元组
a, b, c = tup    # 将元组解包到变量 a, b, c 中
print(b)        # 输出: 5

tup = 4, 5, (6, 7) # 创建一个嵌套元组
a, b, (c, d) = tup  # 解包嵌套元组
print(d)         # 输出: 7

a, b = 1, 2        # 将 a 赋值为 1，b 赋值为 2
print(f"a: {a}, b: {b}") # 输出: a: 1, b: 2
b, a = a, b        # 交换 a 和 b 的值
print(f"a: {a}, b: {b}") # 输出: a: 2, b: 1

values = 1, 2, 3, 4, 5 # 创建一个元组
a, b, *rest = values   # 将前两个元素赋值给 a 和 b，其余赋值给 rest
print(a)             # 输出: 1
print(b)             # 输出: 2
print(rest)          # 输出: [3, 4, 5]

a, b, *_ = values  # 忽略剩余的元素

a = (1, 2, 2, 2, 3, 4, 2) # 创建一个元组
count_of_2 = a.count(2)   # 计算元组中 2 出现的次数
print(count_of_2)         # 输出: 4

a_list = [2, 3, 7, None]     # 使用方括号创建列表
tup = ('foo', 'bar', 'baz')  # 创建一个元组
b_list = list(tup)          # 将元组转换为列表
print(b_list)               # 输出: ['foo', 'bar', 'baz']

b_list[1] = 'peekaboo' # 将列表的第二个元素修改为 'peekaboo'
print(b_list)          # 输出: ['foo', 'peekaboo', 'baz']

gen = range(10)     # 创建一个 range 对象（迭代器）
print(gen)          # 输出: range(0, 10)
my_list = list(gen) # 将 range 对象转换为列表
print(my_list)      # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

b_list.append('dwarf') # 在列表末尾添加 'dwarf'
print(b_list)         # 输出: ['foo', 'peekaboo', 'baz', 'dwarf']

b_list.insert(1, 'red') # 在索引 1 处插入 'red'
print(b_list)           # 输出: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

removed_element = b_list.pop(2) # 删除索引 2 处的元素，并将其赋值给 removed_element
print(removed_element)         # 输出: peekaboo
print(b_list)                   # 输出: ['foo', 'red', 'baz', 'dwarf']

b_list.append('foo')         # 再次在列表末尾添加 'foo'
b_list.remove('foo')        # 删除第一个出现的 'foo'
print(b_list)               # 输出: ['red', 'baz', 'dwarf', 'foo']

print('dwarf' in b_list)     # 检查 'dwarf' 是否在列表中，输出: True
print('dwarf' not in b_list) # 检查 'dwarf' 是否不在列表中，输出: False

list1 = [4, None, 'foo']      # 创建列表 list1
list2 = [7, 8, (2, 3)]      # 创建列表 list2
combined_list = list1 + list2 # 连接两个列表
print(combined_list)         # 输出: [4, None, 'foo', 7, 8, (2, 3)]

x = [4, None, 'foo']       # 创建列表 x
x.extend([7, 8, (2, 3)]) # 使用 extend 方法追加多个元素
print(x)                   # 输出: [4, None, 'foo', 7, 8, (2, 3)]

a = [7, 2, 5, 1, 3] # 创建一个列表
a.sort()            # 对列表进行就地排序
print(a)            # 输出: [1, 2, 3, 5, 7]

b = ['saw', 'small', 'He', 'foxes', 'six'] # 创建一个字符串列表
b.sort(key=len)   # 按照字符串长度对列表进行排序
print(b)            # 输出: ['He', 'saw', 'six', 'small', 'foxes']

seq = [7, 2, 3, 7, 5, 6, 0, 1] # 创建一个列表
sub_list = seq[1:5]          # 从索引 1（包含）到 5（不包含）进行切片
print(sub_list)              # 输出: [2, 3, 7, 5]

seq[3:5] = [6,3] # 使用切片替换元素
print(seq) # 输出: [7, 2, 3, 6, 3, 6, 0, 1]

print(seq[:5])    # 获取前 5 个元素，输出: [7, 2, 3, 6, 3]
print(seq[3:])    # 从索引 3 开始到结尾，输出: [6, 3, 6, 0, 1]
print(seq[-4:])   # 获取最后 4 个元素，输出: [3, 6, 0, 1]
print(seq[-6:-2]) # 获取倒数第 6 个到倒数第 2 个元素（不包含），输出: [3, 6, 3, 6]

print(seq[::2])   # 每隔一个元素取一个，输出: [7, 3, 3, 0]
print(seq[::-1])  # 反转列表，输出: [1, 0, 6, 3, 6, 3, 2, 7]

string = "HELLO!"
print(string[2:4]) # 使用正索引进行切片，输出: LL
print(string[-5:-2]) # 使用负索引进行切片, 输出: ELL

empty_dict = {} # 创建一个空字典
d1 = {'a': 'some value', 'b': [1, 2, 3, 4]} # 创建一个字典
print(d1) # 输出: {'a': 'some value', 'b': [1, 2, 3, 4]}

d1[7] = 'an integer'  # 添加键值对 7: 'an integer'
print(d1)            # 输出: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
print(d1['b'])       # 访问键 'b' 对应的值，输出: [1, 2, 3, 4]

print('b' in d1)  # 检查键 'b' 是否存在于字典中，输出: True

d1[5] = 'some value'      # 添加键值对 5: 'some value'
d1['dummy'] = 'another value' # 添加键值对 'dummy': 'another value'
print(d1)                   # 输出: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 5: 'some value', 'dummy': 'another value'}
del d1[5]                 # 删除键 5 及其对应的值
print(d1)                   # 输出: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 'dummy': 'another value'}

ret = d1.pop('dummy') # 删除键 'dummy' 及其对应的值，并将值赋给 ret
print(ret)            # 输出: another value
print(d1)            # 输出: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

print(list(d1.keys()))   # 获取字典中所有键的列表，输出: ['a', 'b', 7]
print(list(d1.values())) # 获取字典中所有值的列表，输出: ['some value', [1, 2, 3, 4], 'an integer']
print(list(d1.items()))  # 获取字典中所有键值对的列表，输出: [('a', 'some value'), ('b', [1, 2, 3, 4]), (7, 'an integer')]

d1.update({'b': 'foo', 'c': 12})  # 更新键 'b' 的值，并添加键值对 'c': 12
print(d1)                       # 输出: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

key_list = ['a', 'b', 'c']             # 创建一个键列表
value_list = [1, 2, 3]               # 创建一个值列表
mapping = {}                          # 创建一个空字典
for key, value in zip(key_list, value_list): # 使用 zip 将键列表和值列表配对
    mapping[key] = value            # 将键值对添加到字典中
print(mapping)                      # 输出: {'a': 1, 'b': 2, 'c': 3}

# 简洁写法：dict() 和 zip()
mapping = dict(zip(range(5), reversed(range(5)))) # 使用 zip 和 reversed 创建字典
print(mapping)                                  # 输出: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

# 冗长写法：
if 'some_key' in some_dict:   # 检查键是否存在
    value = some_dict['some_key'] # 如果存在，获取值
else:
    value = default_value     # 如果不存在，使用默认值

# 简洁写法：get()
value = some_dict.get('some_key', default_value) # 如果键存在，返回值；否则返回默认值

words = ['apple', 'bat', 'bar', 'atom', 'book'] # 创建一个字符串列表
by_letter = {}                                  # 创建一个空字典
for word in words:                             # 遍历列表中的每个单词
    letter = word[0]                          # 获取单词的首字母
    by_letter.setdefault(letter, []).append(word) # 使用 setdefault 设置默认值，并追加单词
print(by_letter)                                # 输出: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

from collections import defaultdict # 导入 defaultdict

by_letter = defaultdict(list)      # 创建一个 defaultdict，默认值为列表
for word in words:                # 遍历列表中的每个单词
    by_letter[word[0]].append(word) # 自动创建列表并追加单词
print(by_letter)                   # 输出: defaultdict(<class 'list'>, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})

print(hash('string'))        # 字符串可以哈希，输出一个哈希值
print(hash((1, 2, (2, 3)))) # 元组可以哈希，输出一个哈希值
# print(hash((1, 2, [2, 3])))  # 这行代码会引发 TypeError: unhashable type: 'list'，因为列表不可哈希

# 列表作为键？转换为元组：
d = {}                      # 创建一个空字典
d[tuple([1, 2, 3])] = 5    # 将列表转换为元组作为键
print(d)                    # 输出: {(1, 2, 3): 5}

set1 = {2, 2, 2, 1, 3, 3}  # 使用 {} 创建集合
print(set1)               # 输出: {1, 2, 3} （自动去重）
set2 = set([2, 2, 2, 1, 3, 3])  # 使用 set() 创建集合
print(set2)                      # 输出: {1, 2, 3}

a = {1, 2, 3, 4, 5} # 创建集合 a
b = {3, 4, 5, 6, 7, 8} # 创建集合 b

# 并集 (| 或 union())
print(a.union(b))     # 输出: {1, 2, 3, 4, 5, 6, 7, 8}
print(a | b)          # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

# 交集 (& 或 intersection())
print(a.intersection(b)) # 输出: {3, 4, 5}
print(a & b)          # 输出: {3, 4, 5}

# 差集 (- 或 difference())
print(a.difference(b)) # 输出: {1, 2}
print(a - b) #输出： {1, 2}

c = a.copy() # 创建 a 的副本
c |= b       # 就地并集
print(c)     # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

d = a.copy()  # 创建 a 的副本
d &= b        # 就地交集
print(d)      # 输出: {3, 4, 5}

my_data = [1, 2, 3, 4]   # 创建一个列表
# my_set = {my_data}  # 这行代码会引发 TypeError，因为列表不可哈希
my_set = {tuple(my_data)} # 将列表转换为元组
print(my_set)            # 输出: {(1, 2, 3, 4)}

a_set = {1, 2, 3, 4, 5} # 创建一个集合
print({1, 2, 3}.issubset(a_set))   # 检查 {1, 2, 3} 是否是 a_set 的子集，输出: True
print(a_set.issuperset({1, 2, 3})) # 检查 a_set 是否是 {1, 2, 3} 的超集，输出: True

print({1, 2, 3} == {3, 2, 1}) # 输出: True

collection = ['foo', 'bar', 'baz'] # 创建一个列表

# 不使用 enumerate 的写法：
i = 0                             # 初始化索引
for value in collection:         # 遍历列表
    print(f"Index: {i}, Value: {value}") # 打印索引和值
    i += 1                        # 索引递增

# 使用 enumerate：
for i, value in enumerate(collection): # 同时获取索引和值
    print(f"Index: {i}, Value: {value}") # 打印索引和值

print(sorted([7, 1, 2, 6, 0, 3, 2]))  # 对列表进行排序，输出: [0, 1, 2, 2, 3, 6, 7]
print(sorted('horse race'))          # 对字符串进行排序，输出: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']

seq1 = ['foo', 'bar', 'baz']   # 创建列表 seq1
seq2 = ['one', 'two', 'three'] # 创建列表 seq2
zipped = zip(seq1, seq2)       # 将 seq1 和 seq2 配对
print(list(zipped))           # 输出: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

seq3 = [False, True]           # 创建列表 seq3
print(list(zip(seq1, seq2, seq3))) # 输出: [('foo', 'one', False), ('bar', 'two', True)]

for i, (a, b) in enumerate(zip(seq1, seq2)): # 同时迭代多个序列，并获取索引
    print(f'{i}: {a}, {b}')                  # 输出: 0: foo, one \n 1: bar, two \n 2: baz, three

print(list(reversed(range(10))))  # 反向迭代 range(10)，输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 通用形式：[expr for val in collection if condition]

# 等效的 for 循环：
result = []                # 创建一个空列表
for val in collection:     # 遍历集合中的每个元素
    if condition:          # 如果条件为真
        result.append(expr) # 将表达式的结果添加到列表中

strings = ['a', 'as', 'bat', 'car', 'dove', 'python'] # 创建一个字符串列表
# 使用列表推导式将长度大于 2 的字符串转换为大写
upper_case_long_strings = [x.upper() for x in strings if len(x) > 2]
print(upper_case_long_strings)  # 输出: ['BAT', 'CAR', 'DOVE', 'PYTHON']

# {expr for val in collection if condition}
strings = ['a', 'as', 'bat', 'car', 'dove', 'python'] # 创建一个字符串列表
unique_lengths = {len(x) for x in strings}   # 使用集合推导式获取列表中字符串的唯一长度
print(unique_lengths)                       # 输出: {1, 2, 3, 4, 6}

# 使用 map 函数
print(set(map(len, strings))) # 使用map函数和set达到同样效果

# {key_expr: value_expr for val in collection if condition}

strings = ['a', 'as', 'bat', 'car', 'dove', 'python']   # 创建一个字符串列表
# 使用字典推导式创建一个字典，其中键是字符串，值是字符串在列表中的索引
loc_mapping = {val: index for index, val in enumerate(strings)}
print(loc_mapping) # 输出: {'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}

all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
            ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]

# 使用嵌套列表推导式找出名字中包含2个以上a的名字。
names_of_interest = [name for names in all_data for name in names
                     if name.count('a') >= 2]
print(names_of_interest) # 输出: ['Maria', 'Natalia']


some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)] # 创建一个元组列表
flattened = [x for tup in some_tuples for x in tup] # 使用嵌套列表推导式展开元组
print(flattened) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 列表推导式中的列表推导式
flattened = [[x for x in tup] for tup in some_tuples]  # 两层列表推导
print(flattened) # 输出： [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

def my_function(x, y):                      # 定义一个函数，名为 my_function，接受两个参数 x 和 y
    """Docstring: 解释函数的功能。"""   # 函数的文档字符串
    return x + y                            # 返回 x 和 y 的和

result = my_function(1, 2)                  # 调用函数，并将返回值赋给 result
print(result)                              # 输出: 3
print(my_function.__doc__) # 访问文档字符串, 输出: Docstring: 解释函数的功能。

def my_function2(x, y, z=1.5):  # 定义函数，z 是关键字参数，默认值为 1.5
    if z > 1:                   # 如果 z 大于 1
        return z * (x + y)      # 返回 z 乘以 x 和 y 的和
    else:                       # 否则
        return z / (x + y)      # 返回 z 除以 x 和 y 的和

print(my_function2(5, 6, z=0.7))  # 使用关键字参数调用函数，输出: 0.06363636363636363
print(my_function2(3.14, 7, 3.5)) # 使用位置参数调用函数，输出: 35.49
print(my_function2(10, 20))       # 使用默认参数调用函数，输出: 45.0

def func():        # 定义一个函数
    a = []          # 'a' 是局部变量
    for i in range(5): # 循环 5 次
        a.append(i) # 将 i 追加到列表 a 中

func()             # 调用函数
# print(a)  # 这行代码会引发 NameError: name 'a' is not defined，因为 'a' 在函数外部不可见

a = []  # 全局变量

def func2():          # 定义一个函数
    for i in range(5): # 循环 5 次
        a.append(i)  # 修改全局变量 'a'

func2()            # 调用函数
print(a)            # 输出: [0, 1, 2, 3, 4]

b = None # 全局变量
def bind_b_variable():  # 定义一个函数
    global b          # 声明 'b' 为全局变量
    b = []           # 将空列表赋值给全局变量 'b'
bind_b_variable()     # 调用函数
print(b)            # 输出: []

def f():             # 定义一个函数
    a = 5            # 局部变量
    b = 6            # 局部变量
    c = 7            # 局部变量
    return a, b, c  # 返回一个元组

x, y, z = f()        # 调用函数，并将返回的元组解包到变量 x, y, z 中
print(x, y, z)      # 输出: 5 6 7

# 或者返回一个字典
def f2():
  a = 5
  b = 6
  c = 7
  return {'a' : a, 'b' : b, 'c' : c} # 返回值改为字典

result = f2()
print(result) # 输出: {'a': 5, 'b': 6, 'c': 7}

import re  # 导入正则表达式模块

states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda',
          'south   carolina##', 'West virginia?'] # 列表

def clean_strings(strings):          # 定义一个函数，用于清理字符串列表
    result = []                      # 创建一个空列表
    for value in strings:            # 遍历列表中的每个字符串
        value = value.strip()         # 去除字符串两端的空格
        value = re.sub('[!#?]', '', value) # 使用正则表达式去除标点符号
        value = value.title()         # 将字符串转换为标题格式
        result.append(value)          # 将处理后的字符串添加到列表中
    return result                    # 返回处理后的列表

print(clean_strings(states)) #输出: ['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

# 替代方案：函数列表
def remove_punctuation(value):            # 定义一个函数，用于去除标点符号
    return re.sub('[!#?]', '', value)  # 使用正则表达式去除标点符号

clean_ops = [str.strip, remove_punctuation, str.title] # 定义一个函数列表

def clean_strings_functional(strings, ops): # 定义一个函数，接受字符串列表和操作列表
    result = []                         # 创建一个空列表
    for value in strings:               # 遍历字符串列表中的每个字符串
        for function in ops:            # 遍历操作列表中的每个函数
            value = function(value)     # 对字符串应用函数
        result.append(value)           # 将处理后的字符串添加到列表中
    return result                     # 返回处理后的列表

print(clean_strings_functional(states, clean_ops)) #输出: ['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

# 将函数与 map 结合使用：
for x in map(remove_punctuation, states): # 使用 map 函数对列表中的每个字符串应用 remove_punctuation 函数
  print(x)