语言基础 ¶

a, b, c, d = 20, 5.5, True, 4+3j

print(a, b, c, d)
# 20 5.5 True (4+3j)

print(type(a), type(b), type(c), type(d))
# <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

a = b = c = d = 1
print(a, b, c, d)
# 1 1 1 1

a = -15
print(f'{a}对应的十进制是{a}, 二进制是{a:b}, 八进制是{a:o}, 十六进制是{a:x}')

a = 'string is "special"'

b = "string's value"

c = '''string's value is 
"special"'''

d = """string's 
context
"""

string[start:end:step]

s = 'Python is very good'

# 获取从索引2到索引3的字符（包含索引2，不包含索引4）
print(s[2:4])
# th

# 获取索引5的字符
print(s[5])
# n

# 获取字符串最后一个字符
print(s[-1])
# d

# 获取字符串倒数第2、3个字符（左闭右开）
print(s[-3:-1])
# oo

# 字串反转
print(s[::-1])
# doog yrev si nohtyP

# 非迭代型，不可修改
s[3] = 'b'
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'str' object does not support item assignment

print(s + '!!!')
# Python is very good!!!

print(s.replace('is', 'we'))
# Python we very good

print(s.find('a'))
# -1

print(s.find('s'))
# 8

print(s.index('s'))
# 8

print(s.index('a'))
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# ValueError: substring not found

print(s.count('a'))
# 0
print(s.count('o'))
# 3

# 按空格分割
print(s.split(' '))
# ['Python', 'is', 'very', 'good']

# 按空格分割成2个子字符串
print(s.split(' ', 1))
# ['Python', 'is very good']

# 验证split()返回结果的类型
print(type(s.split(' ')))
# <class 'list'>

print(s)
# Python is very good

# 移除首尾字符d
print(s.strip('d'))
# Python is very goo

print(s.endswith('d'))
# True

print(s.endswith('a'))
# False

print(s.startswith('p'))
# False

print(s.startswith('P'))
# True

d = '+86-123'

print(d.isdigit())
# False

d = '86123'
print(d.isdigit())
# True

b = 'Ab?'

print(b.isalpha())
# False

c = 'Ab'
print()c.isalpha()
# True

x = '12\\34'
y = r'this\has\no\special\characters'
print(x)  # 12\34
print(y)  # this\has\no\special\characters

print("Hello,\nWorld!")
# Hello,
# World!

print("Hello,\rWorld!")
# World!（光标回到行首并覆盖）

print("Name\tAge")
# Name     Age（Name和Age之间有一个制表位的空格）

print("Name\vAge")
# Name
#     Age
# Name和Age之间有一个制表位的空格）

print("Name\bAge")
# NamAge

print("It's a beautiful day.")
# It's a beautiful day.

print('He said \"Hello\" to me.')
# He said "Hello" to me.

print("This is a path: C:\\Users\\Name")
# This is a path: C:\Users\Name

print("Hello\040World")
# Hello World（中间有一个空格）

print("Hello\x41rld")
# HelloArld（\x41是十六进制表示的大写A）

print("Hello\u0041")
# HelloA（\u0041是Unicode表示的大写A）

print("Hello\U00000041")
# HelloA（\U00000041是Unicode表示的大写A）

a = 'string is "special"'
print(a[2:4])
# ri
print(a[-4:-1])
# ial

template = '{0:.2f} {1:s} are worth US${2:d}'
print(template.format(4.5560, 'Argentine Pesos', 1))  # 4.56 Argentine Pesos are worth US$1

age = 32
name = 'Tom'
fstring = f'My name is {name} and I am {age} years old.'
print(fstring)
# My name is Tom and I am 32 years old.

height = 2
base = 3
fstring = f'The area of the triangle is {base*height/2}.'
print(fstring)
# The area of the triangle is 3.0.

person1 = {"name": "Tom", "age": 20, "gender": "male"}

person2 = {"name": "Jerry", "age": 20, "gender": "female"}

# 读取字典
fstring = f'{person1.get("name")} is {person1.get("age")} and is {person1.get("ender")}'
print(fstring)
# Tom is 20 and is None

# 遍历字典
people = [person1, person2]

for person in people:
    fstring = (
        f'{person.get("name")} is {person.get("age")} and is {person.get("ender")}'
    )
    print(fstring)

# Tom is 20 and is None
# Jerry is 20 and is None

person1 = {"name": "Tom", "age": 20, "gender": "male"}

person2 = {"name": "Jerry", "age": 20, "gender": "female"}

people = [person1, person2]

for person in people:
    fstring = f'{"She" if person.get("gender") == "female" else "He"} is watching TV.'
    print(fstring)

# He is watching TV.
# She is watching TV.

print(f'{"apple": >30}')
print(f'{"apple": ^30}')
print(f'{"apple": <30}')
#                          apple
#             apple             
# apple

number = 0.9124325345

# 百分比
fstring = f"百分比格式，保留2位小数: {number:.2%}"
print(fstring)
# 百分比格式，保留2位小数: 91.24%

# 保留小数点后3位
fstring = f"保留3位小数: {number:.3f}"
print(fstring)
# 保留3位小数: 0.912

# 科学计数法表示
fstring = f"科学计数法表示: {number:e}"
print(fstring)
# 科学计数法表示: 9.124325e-01

# 带货币符号
number = 123456.78921
fstring = f"带货币符号，保留2位小数: ${number:.2f}"
print(fstring)
# 带货币符号，保留2位小数: $123456.79

# 带货币符号和千分位
number = 123456.78921
fstring = f"带货币符号，使用千分位，保留2位小数: ${number:,.2f}"
print(fstring)
# 带货币符号，使用千分位，保留2位小数: $123,456.79

# 左对齐，总宽度为20，不足的地方用*填充
print(f"{number:*<20}")
# 123456.78921********
print(f"{number = :*<20}")
# number = 123456.78921********

# 输出数值带正负符号
numbers = [1, -3, 5]

for number in numbers:
    fstring = f"The number is {number:+}"
    print(fstring)

# The number is +1
# The number is -3
# The number is +5


# Debug调试
# f-string内的{number = }表达式告诉Python输出变量number的名称（number）和它的值（2），并且在两者之间加上一个等号。因此，输出结果是number = 2。
number = 2
print(f"{number = }")
# number = 2

color = ['red', 'green', 'blue', 'yellow', 'white', 'black']

# 从0开始统计，读取第1，2位
print(color[1: 3])
# ['green', 'blue']

# 从0开始统计，读取从第1位到倒数第3位
print(color[1: -2])
# ['green', 'blue', 'yellow']

# 从0开始统计，读取从倒数第4位到倒数第3位
print(color[-4: -2])
# ['blue', 'yellow']

# 如果写成下面这样，则无输出。
print(color[-2: -4])
# []

print(color[::2])
# ['red', 'blue', 'white']

invoice = """
0     6                                 40           52   55
1909  Primoroni PiBrella                $17.50       3    $52.50
1489  6mm Tactile Switch x20            $4.19        2    $9.90
1510  Panavise JR.-PV-201               $28.00       1    $28.00
1601  PiTFT Mini Kit 320x240            $34.95       1    $34.95
"""

SKU = slice(0, 6)
DESCRIPTION = slice(6, 40)
UNIT_PRICE = slice(40, 52)
QUANTITY = slice(52, 55)
ITEM_TOTAL = slice(55, None)

line_items = invoice.split("\n")[2:]  # 按上面invoice的格式，第0和1行舍弃

for item in line_items:
    print(item[SKU], item[UNIT_PRICE], item[DESCRIPTION])

# 1909   $17.50       Primoroni PiBrella
# 1489   $4.19        6mm Tactile Switch x20
# 1510   $28.00       Panavise JR.-PV-201
# 1601   $34.95       PiTFT Mini Kit 320x240

import numpy as np

# 创建一个4行4列的二维数组
x = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])

# 使用省略号来获取第一行的所有元素
print(x[0, ...])
# [1 2 3 4]


# 使用省略号来获取最后一列的所有元素
print(x[..., 3])
# [ 4  8 12 16]

# 使用省略号来获取每一行的前2个元素
print(x[..., np.arange(2)])
# [[ 1  2]
#  [ 5  6]
#  [ 9 10]
#  [13 14]]

a = [1, 2, 3, 4, 5]

print(a)
# [1, 2, 3, 4, 5]

b = list('12345')

print(b)
# ['1', '2', '3', '4', '5']

c = list(12345)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'int' object is not iterable

print(a[2:3])
# [3]

print(a[:3])
# [1, 2, 3]

print(a[::-1])  # 倒序
# [5, 4, 3, 2, 1]

print(a[::])
# [1, 2, 3, 4, 5]

print(a[::1])
[1, 2, 3, 4, 5]

print(a[1])
# 2

a[1] = 'one'

print(a)
# [1, 'one', 3, 4, 5]

a.append(6)  # 注意，直接修改原列表，不是创建副本。

print(a)
# [1, 'one', 3, 4, 5, 6]

a.extend([7, 8, 9])

print(a)
# [1, 'one', 3, 4, 5, 6, 7, 8, 9]

a.insert(0, 'Italy')

print(a)
# ['Italy', 1, 3, 5, 6, 7, 8]

a.pop()
# 9

print(a)
# [1, 'one', 3, 4, 5, 6, 7, 8]

a.pop(3)
# 4

print(a)
# [1, 'one', 3, 5, 6, 7, 8]

print(a[1])
# one

del a[1]

print(a)
[1, 3, 5, 6, 7, 8]

a.remove('Italy')

print(a)
# [1, 3, 5, 6, 7, 8]

print(a.count(1))
# 1

print(a.index(2))
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# ValueError: 2 is not in list

print(a.index(3))
# 1

print(3 in a)
# True

print('3' in a)
# False

a.reverse()

print(a)
# [8, 7, 6, 5, 3, 1]

print(min(a))
# 1

print(max(a))
# 78

print(len(a))
# 6

a = [1, 2, 3]
b = [4, 5, 6]

print(a + b)
# [1, 2, 3, 4, 5, 6]

a.extend(b)  # a列表被修改
print(a)
# [1, 2, 3, 4, 5, 6]

print(b)
# [4, 5, 6]

a_list = [4, None, 'foo']
b_list = [7, 8, (2, 3)]

print(a_list + b_list)  
# [4, None, 'foo', 7, 8, (2, 3)]  使用+号连接

print(a_list.extend(b_list))
# None
print(a_list)  # [4, None, 'foo', 7, 8, (2, 3)]

list1 = ['1', 'one', '3', 'Four', '5', 'two', 'apple', '8', '9']
print(list1)
# ['1', 'one', '3', 'Four', '5', 'two', 'apple', '8', '9']

# 下面的操作不改变原列表
print(sorted(list1))
# ['1', '3', '5', '8', '9', 'Four', 'apple', 'one', 'two']
print(sorted(list1, reverse=True))
# ['two', 'one', 'apple', 'Four', '9', '8', '5', '3', '1']
print(sorted(list1, key=len))
# ['1', '3', '5', '8', '9', 'one', 'two', 'Four', 'apple']
print(list1)
# ['1', 'one', '3', 'Four', '5', 'two', 'apple', '8', '9']


# 下面的操作直接修改原列表，返回值是None
print(list1.sort())
# None
print(list1)
# ['1', '3', '5', '8', '9', 'Four', 'apple', 'one', 'two']

c = list('Python')

print(a + c)
# [1, 2, 3, 4, 5, 6, 'P', 'y', 't', 'h', 'o', 'n']

print(a * 3)
# [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

# 做法1
board = [['_'] * 3 for i in range(3)]
print(board)
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]

board[1][2] = 'X'
print(board)
# [['_', '_', '_'], ['_', '_', 'X'], ['_', '_', '_']]


# 做法2
board = [['_'] * 3] * 3
print(board)
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]

board[1][2] = 'X'
print(board)
# [['_', '_', 'X'], ['_', '_', 'X'], ['_', '_', 'X']]

# 方法1
row = ['_'] * 3
board = []

for i in range(3):
    board.append(row)

print(board)
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]

board[2][0] = 'X'
print(board)
# [['X', '_', '_'], ['X', '_', '_'], ['X', '_', '_']]


# 方法2
row = []
board = []

for i in range(3):
    row = ['_'] * 3
    board.append(row)

print(board)
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]

board[2][0] = 'X'
print(board)
# [['_', '_', '_'], ['_', '_', '_'], ['X', '_', '_']]

from collections import deque

d = deque([1, 2, 3])
print(d)
# deque([1, 2, 3])

# 注意插入顺序
d.extendleft(['a', 'b', 'c'])
print(d)
# deque(['c', 'b', 'a', 1, 2, 3])

print(len(d))
# 6
print(d[-2])
# 2

# 统计字符a出现的次数
print(d.count('a'))
# 1

# 返回字符a的索引值
print(d.index('a'))
# 2

# 第0位插入数字1，其余顺移
d.insert(0, 1)
print(d)
# deque([1, 'c', 'b', 'a', 1, 2, 3])

# 把右边2个元素放到左边，注意顺序，和extendleft不一样
d.rotate(2)
print(d)
# deque([2, 3, 1, 'c', 'b', 'a', 1])

d.rotate(-2)
print(d)
# deque([1, 'c', 'b', 'a', 1, 2, 3])

a_list = [4, None, 'foo', 7, 8, (2, 3)]
a_list.sort() 
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: '<' not supported between instances of 'NoneType' and 'int'

b_list = [7, 8, (2, 3)]
b_list.sort()
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: '<' not supported between instances of 'tuple' and 'int'

a_list = [7, 2, 5, 1, 3]
a_list.sort()  # 按数值大小排序
print(a_list)  # [1, 2, 3, 5, 7]

b_list = ['saw', 'small', 'He', 'foxes', 'six']
b_list.sort(key=len)  # 通过字符串的长度进行排序
print(b_list)  # ['He', 'saw', 'six', 'small', 'foxes']

import bisect

# 创建一个有序列表
sorted_list = [1, 3, 4, 6, 8]

# 使用 bisect_left 查找元素应该插入的位置
index = bisect.bisect_left(sorted_list, 5)
print(index)
# 输出: 3，因为 5 应该插入在索引 3 的位置

# 插入元素并保持有序
bisect.insort_left(sorted_list, 5)
print(sorted_list)
# 输出: [1, 3, 4, 5, 6, 8]

# 使用 bisect_right 查找元素应该插入的位置
index = bisect.bisect_right(sorted_list, 5)
print(index)
# 输出: 4，因为 5 已经存在于列表中，这是它右侧的位置

# 插入元素并保持有序
bisect.insort_right(sorted_list, 5)
print(sorted_list)  # 输出: [1, 3, 4, 5, 5, 6, 8]

import bisect

def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
    i = bisect.bisect(breakpoints, score)
    return grades[i]

result = [grade(score) for score in [15, 26, 31, 62, 79, 85]]
print(result)
# ['F', 'F', 'F', 'D', 'C', 'B']

import bisect
import random

size = 7
random.seed(1729)
my_list = []

for i in range(size):
    new_item = random.randrange(size * 2)
    bisect.insort(my_list, new_item)
    print(f"{new_item:2d} :--> {my_list}")

# 10 :--> [10]
#  0 :--> [0, 10]
#  6 :--> [0, 6, 10]
#  8 :--> [0, 6, 8, 10]
#  7 :--> [0, 6, 7, 8, 10]
#  2 :--> [0, 2, 6, 7, 8, 10]
# 10 :--> [0, 2, 6, 7, 8, 10, 10]

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('three', 3), ('one', 1)])
e = dict({'three': 3, 'one': 1, 'two': 2})

print(a == b == c == d == e)
# True

dict_a = {'name': 'Ming', 'id': 1001, 'age': 35}

print(type(dict_a))
# <class 'dict'>

dict_b = dict(city='Shanghai', strict='Xuhui', zip='200000')

print(type(dict_b))
# <class 'dict'>

print(dict_a['name'])
# Ming

print(dict_a['Name'])
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'Name'

dict_a['city'] = 'Chengdu'

print(dict_a)
# {'name': 'Ming', 'id': 1001, 'city': 'Chengdu'}

dict_a.pop('city')
# Chengdu

print(dict_a)
# {'name': 'Ming', 'id': 1001}

del dict_a['age']
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'age'

del dict_a['id']

print(dict_a)
# {'name': 'Ming'}

dict_a[23] = 'Hello World'

print(dict_a)
# {'name': 'Ming', 23: 'Hello World'}

print(23 in dict_a)
# True

print(35 in dict_a)
# False

print(dict_a.get('hai'))
# None

print(dict_a.get('hai', 1))
# 1

print(dict_a.get('name', 1))
# Ming

dict_a['hai']
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'hai'

dict_a.setdefault('name')
# Ming

dict_a.setdefault('hai', 1)
# 1

print(dict_a)
# {'name': 'Ming', 23: 'Hello World', 'hai': 1}

dict_a.setdefault('go')
print(dict_a)
# {'name': 'Ming', 23: 'Hello World', 'hai': 1, 'go': None}

print(dict_a.items())
# dict_items([('name', 'Ming'), (23, 'Hello World'), ('hai', 1), ('go', None)])

print(dict_a.keys())
# dict_keys(['name', 23, 'hai', 'go'])

print(dict_a.values())
# dict_values(['Ming', 'Hello World', 1, None])

print(list(dict_a.values()))
# ['Ming', 'Hello World', 1, None]

for key in dict_a.keys():
    print(dict_a[key])

# Ming
# Hello World
# 1
# None

dict_a.clear()

print(dict_a)
# {}

print(len(dict_a))
# 0

dict_a = {'name': 'Ming', 'id': 1001, 'age': 35}
dict_b = dict(city='Shanghai', id=2001, zip='200000')

# 将dict_b的键值对插入dict_a，键相同则用dict_b的值覆盖dict_a的值
dict_a.update(dict_b)

print(dict_a)
# {'name': 'Ming', 'id': 2001, 'age': 35, 'city': 'Shanghai', 'zip': '200000'}

# 方法1
mapping = {}
key_list = list(range(5))
value_list = list(reversed(range(5)))

for key, value in zip(key_list, value_list):
    mapping[key] = value

print(mapping)  
# {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

# 方法2。
mapping = {}
key_list = list(range(5))
value_list = list(reversed(range(5)))

mapping = dict(zip(key_list, value_list))  
print(mapping)  # {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

print(hash('string'))  
# -4368784820203065343

print(hash((1, 2, (2, 3))))  
# -9209053662355515447

print(hash((1, 2, [2, 3])))  
# TypeError: unhashable type: 'list'

print(hash((1, 2, tuple([2, 3]))))  
# -9209053662355515447  为了将列表作为键，一种方式就是将其转换为元组

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter = {}

for word in words:
    letter = word[0]  # word[0]把列表words的每个元素列表化，并取首字母。输出的是a, b, b, a, b这5个列表元素的首字母
    if letter not in by_letter:
        # 生成第一个键值对
        print(letter)
        by_letter[letter] = [word]  # 对比[word]和word[]的用法
        print(by_letter)
        # a
        # {'a': ['apple']}
        # b
        # {'a': ['apple'], 'b': ['bat']}
    else:
        # append其他键值对
        print(letter)
        by_letter[letter].append(word)
        print(by_letter)
        # b
        # {'a': ['apple'], 'b': ['bat', 'bar']}
        # a
        # {'a': ['apple', 'atom'], 'b': ['bat', 'bar']}
        # b
        # {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

print(by_letter)  
# {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter = {}

for word in words:
    letter = word[0]  # word[0]的输出依然是5个列表元素的首字母a, b, b, a, b
    by_letter.setdefault(letter, []).append(word)  # 如果letter不在[]则通过append添加word

print(by_letter)  
# {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter = {}

for word in words:
    letter = word[0]  # word[0]的输出依然是5个列表元素的首字母a, b, b, a, b
    by_letter.setdefault(letter, ['a']).append(word)

print(by_letter)  
# {'a': ['a', 'apple', 'atom'], 'b': ['a', 'bat', 'bar', 'book']}

from collections import defaultdict

by_letter = defaultdict(list)  # list是内置的可变序列(Built-in mutable sequence)

print(dict(by_letter))  
# {}

for word in words:
    by_letter[word[0]].append(word)

print(by_letter)  
# defaultdict(<class 'list'>, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})

print(dict(by_letter))  
# {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

str = 'abracadabra'
ct = collections.Counter(str)

print(ct)
# Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

from types import MappingProxyType

d = {1: 'A'}
d_proxy = MappingProxyType(d)

print(d)
# {1: 'A'}
print(d_proxy)
# {1: 'A'}

print(d[1])
# A
print(d_proxy[1])
# A


d[2] = 'W'
print(d)
# {1: 'A', 2: 'W'}

d_proxy[2] = 'W'
# TypeError: 'mappingproxy' object does not support item assignment

print(d_proxy)
# {1: 'A', 2: 'W'}

haystacke = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'f', 'g', 'h', 'c', 'd', 'e', 'c', 'd', 'e', 'f', 'g', 'h'}
needles = {'c', 'h', 'w'}

type(haystacke)
# <class 'set'>
type(needles)
# <class 'set'>

# 传统方法
found = 0

for i in needles:
    if i in haystacke:
        found += 1

print(found)
# 2


# 集合方法一
found = len(needles & haystacke)
print(found)
# 2

# 集合方法二
found = len(needles.intersection(haystacke))
print(found)
# 2

a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}

print(a.union(b))  # {'c', 1, 2, 'd', 'a', 'b'}
print(a | b)  # {'c', 1, 2, 'd', 'a', 'b'}

print(a.intersection(b))  # {'c', 1}
print(a & b)  # {'c', 1}

a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}
a.intersection_update(b)
print(a)  # {1, 'c'}

print(a.difference(b))  # {'a', 2, 'b'}
print(a - b)  # {2, 'a', 'b'}

a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}
a.difference_update(b)
print(a)  # {2, 'b', 'a'}
a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}
a -= b
print(a)  # {2, 'a', 'b'}

a.add(7)
print(a)  # {1, 2, 'c', 7, 'a', 'b'} 每次输出的顺序是不一样的

a.remove(7)
print(a)  # {1, 2, 'c', 'a', 'b'}  如果a被清空，则报错 KeyError: 7

print(a.symmetric_difference(b))  # {2, 'd', 'b', 'a'}
print(a ^ b)  # {2, 'd', 'b', 'a'}

a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}
a.symmetric_difference_update(b)
print(a)  # {'a', 2, 'd', 'b'}
a = {'a', 'b', 'c', 1, 2}
b = {1, 'c', 'd'}
a ^= b
print(a)  # {2, 'd', 'a', 'b'}

print(a.issubset(b))  # False

print(a)  # {'a', 2, 'd', 'b'}
a = {'a', 'b', 'c', 1, 2}
a.update(b)
print(a)  # {1, 2, 'a', 'b', 'd', 'c'}

a.pop()  # 随机移除某个元素，没有输入变量，如果集合是空的，抛出KeyError: 'pop from an empty set'
print(a)  # {2, 1, 'd', 'b', 'a'}

a.clear()
print(a)  # set()

my_data1 = [1, 2, 3, 4]
my_data2 = [3, 4, 5, 6]

my_set = {my_data1, my_data2}
# TypeError: unhashable type: 'list'

my_set = {tuple(my_data1), tuple(my_data2)}
print(my_set)  # {(1, 2, 3, 4), (3, 4, 5, 6)}

# 此处括号被解析为运算符，而不是元组
tup1 = (10)
print(type(tup1))
# <class 'int'>

# 此处括号被解析为运算符，而不是元组
tup1 = (10.0)
print(type(tup1))
# <class 'float'>

# 此处括号被解析为元组
tup1 = (10,)
print(type(tup1))
# <class 'tuple'>

tup = 4, 5, 6
print(tup)  # (4, 5, 6)

nested_tup = (4, 5, 6), (7, 8)
print(nested_tup)  # # ((4, 5, 6), (7, 8))

tup = ('a', 'b', {'one': 1})
print(type(tup))
# <class 'tuple'>

tup = tuple((4, None, 'fool') + (6, 0) + ('bar',))
print(tup)  # (4, None, 'fool', 6, 0, 'bar')

tup = ('h', 'e', 'l', 'l', 'o')
print(id(tup))
# 139820353350208

tup = (1, 2, 3, 4, 5)
print(id(tup))
# 139820353298896

tup[0] = 'x'
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'tuple' object does not support item assignment

tup = tuple(['foo', [4, 5, 6], True])
tup[1].append(0)
print(tup)  # ('foo', [4, 5, 6, 0], True)
tup[1].append([9])
print(tup)  # ('foo', [4, 5, 6, 0, [9]], True)

tup = tuple(('fool', 'bar') * 4)
print(tup)  # ('fool', 'bar', 'fool', 'bar', 'fool', 'bar', 'fool', 'bar')

tup = tuple([4, 5, 6])
print(tup)
# (4, 5, 6)

tup = tuple('string')
print(tup)
# ('s', 't', 'r', 'i', 'n', 'g')
print(tup[2]) # 元组的元素可以通过中括号[]来获取
# r

tup = (9, 5, (8, 7))
a, b, c = tup
print(a)  # 9
print(b)  # 5
print(c)  # (8, 7)
a, b, (c, d) = tup
print(a)  # 9
print(b)  # 5
print(c)  # 8
print(d)  # 7

tup = (9, 5, (8, 7))
a, b, c = tup
c, a = a, c  # 利用拆包实现交换
print(a)  # (8, 7)
print(b)  # 5
print(c)  # 9

seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
for a, b, c in seq:
    print('a={0}, b={0}, c={0}'.format(a, b, c))  # 列表每个元素的取值顺序
    # a=1, b=1, c=1
    # a=4, b=4, c=4
    # a=7, b=7, c=7
    print('a={0}, b={1}, c={2}'.format(a, b, c))
    # a=1, b=2, c=3
    # a=4, b=5, c=6
    # a=7, b=8, c=9
    print('a={2}, b={0}, c={1}'.format(a, b, c))
    # a=3, b=1, c=2
    # a=6, b=4, c=5
    # a=9, b=7, c=8

values = 1, 2, 3, 4, 5
a, b, *rest = values
print(a)  # 1
print(b)  # 2
print(*rest)  # 3 4 5
a, b, *_ = values
print(*_)  # 3 4 5

from collections import namedtuple
from typing import NamedTuple

from collections import namedtuple

City = namedtuple("City", "name country population coordinates")

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))

print(beijing)
# City(name='Beijing', country='CN', population=22.596, coordinates=(39.9042, 116.4074))

print(beijing.population)
# 22.596

print(beijing[3])
# (39.9042, 116.4074)

print(City._fields)
# ('name', 'country', 'population', 'coordinates')

LatLong = namedtuple("LatLong", "lat long")
beijing_data = ("beijing NCR", "CN", 22.596, LatLong(39.9042, 116.4074))
beijing = City._make(beijing_data)

print(beijing)
# City(name='beijing NCR', country='CN', population=22.596, coordinates=LatLong(lat=39.9042, long=116.4074))

print(beijing._asdict())
# {'name': 'beijing NCR', 'country': 'CN', 'population': 22.596, 'coordinates': LatLong(lat=39.9042, long=116.4074)}

for key, value in beijing._asdict().items():
    print(key + ":", value)
# name: beijing NCR
# country: CN
# population: 22.596
# coordinates: LatLong(lat=39.9042, long=116.4074)

from typing import NamedTuple

class City(NamedTuple):
    name: str
    country: str
    population: float
    coordinates: tuple

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))

print(beijing)
# City(name='Beijing', country='CN', population=22.596, coordinates=(39.9042, 116.4074))

print(beijing.population)
# 22.596

print(beijing.coordinates)
# (39.9042, 116.4074)

print(City.__annotations__)
# {'name': <class 'str'>, 'country': <class 'str'>, 'population': <class 'float'>, 'coordinates': <class 'tuple'>}

class LatLong(NamedTuple):
    lat: float
    long: float

beijing_data = ("beijing NCR", "CN", 22.596, LatLong(39.9042, 116.4074))
beijing = City(*beijing_data)

print(beijing)
# City(name='beijing NCR', country='CN', population=22.596, coordinates=LatLong(lat=39.9042, long=116.4074))

print(beijing._asdict())
# {'name': 'beijing NCR', 'country': 'CN', 'population': 22.596, 'coordinates': LatLong(lat=39.9042, long=116.4074)}

for key, value in beijing._asdict().items():
    print(key + ":", value)
# name: beijing NCR
# country: CN
# population: 22.596
# coordinates: LatLong(lat=39.9042, long=116.4074)

list1 = [1, 2, 3, 4]
id(list1)
# 140409777308808

list1 *= 2
print(list1)
# [1, 2, 3, 4, 1, 2, 3, 4]
id(list1)
# 140409777308808


tuple1 = (1, 2, 3, 4)
id(tuple1)
# 140409777230536

tuple1 *= 2
print(tuple1)
# (1, 2, 3, 4, 1, 2, 3, 4)
id(tuple1)
# 140409780104888

t = (1, 2, [10, 20])

t[2] += [50, 60]
# TypeError: 'tuple' object does not support item assignment

print(t)
# (1, 2, [10, 20, 50, 60])

from array import array

numbers = array("h", [-2, -1, 0, 1, 2])

print(numbers)
# array('h', [-2, -1, 0, 1, 2])

print(type(numbers[0]))
# <class 'int'>

# 用5个短整型有符号整数的数组（类型码是'h'）创建一个memoryview。
memv = memoryview(numbers)

# memv里的5个元素跟数组里的没有区别。
print(len(memv))
# 5
print(memv[0])
# -2
print(memv.tolist())
# [-2, -1, 0, 1, 2]

# 创建一个memv_oct，这一次是把memv里的内容转换成'B'类型，也就是无符号字符。
memv_oct = memv.cast("B")
print(len(memv_oct))
# 10
print(memv_oct.tolist())
# [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]

# 把位于位置5的字节赋值成4。因为我们把占2个字节的整数的高位字节改成了4，所以这个有符号整数的值就变成了1024。
memv_oct[5] = 4
print(numbers)
# array('h', [-2, -1, 1024, 1, 2])

from array import array

# 创建一个有符号字符数组
signed_array = array('b', [-2, -1, 0, 1, 2])

# 打印原始值和无符号字符表示
for value in signed_array:
    print(f"Signed: {value}, Unsigned: {value & 0xFF}")

def printinfo(arg1, *vartuple):
    print("输出任何传入的参数: ")
    print(arg1)
    print(vartuple)

    for var in vartuple:
        print(var)
    return

printinfo(10)
# 输出任何传入的参数: 
# 10
# ()

printinfo(70, 60, 50)
# 输出任何传入的参数: 
# 70
# (60, 50)
# 60
# 50

def printinfo(arg1, **vardict):
    print("输出任何传入的参数: ")
    print(arg1)
    print(vardict)

printinfo(1, a=2, b=3)
# 输出任何传入的参数: 
# 1
# {'a': 2, 'b': 3}

a = 5
print(type(a))  
# <class 'int'>

a = 'foo'
print(type(a))  
# <class 'str'>

a = 4.5
b = 2
print('a is {0}, b is {1}'.format(type(a), type(b)))  
# a is <class 'float'>, b is <class 'int'>

print(a / b)  
# 2.25

a = 5
b = 4.5
c = 'foo'
print(isinstance(a, int))  
# True
print(isinstance(b, str))  
# False
print(isinstance(c, (str, int)))  
# True
print(isinstance(c, (float, int)))  
# False

def add_numbers(a, b):
    if not all(isinstance(x, (int, float)) for x in (a, b)):
        raise TypeError("Both arguments must be numbers")
    return a + b


print(add_numbers(2, 3))
# 5
print(add_numbers(2.5, 3))
# 5.5
print(add_numbers("a", 3))
# TypeError: Both arguments must be numbers

from typing import overload, Union


@overload
def process(value: int) -> str:
    return f"Integer: {value}"


@overload
def process(value: str) -> str:
    return f"String: {value}"


# 使用类型注解和函数重载实现简单的多态
def process(value: Union[int, str]) -> str:
    if isinstance(value, int):
        return f"Integer: {value}"
    elif isinstance(value, str):
        return f"String: {value}"


print(process(123))
# Integer: 123
print(process("hello"))
# String: hello

def function_name(param1: type1, param2: type2) -> return_type:
    # 函数体

from typing import List


def sum_list(numbers: List[int]) -> int:
    return sum(numbers)


my_list: List[int] = [1, 2, 3]

print(sum_list(my_list))
# 6

my_list: List[int] = [1, 2, "3"]  # 静态类型检查时会报错

pip install mypy
mypy example.py

def greet(name: object) -> None:
    if isinstance(name, str):
        print(f"Hello, {name}!")
    else:
        print("Invalid input. Please provide a string.")


greet("Tom")
# Hello, Tom!
greet(123)
# Invalid input. Please provide a string.

from typing import Dict, Any

def get_value(data: Dict[str, Any], key: str) -> Any:
    return data.get(key, None)

# 初始化字典info
info: Dict[str, Any] = {"name": "Bob", "age": 25}

print(get_value(info, "name"))
# Bob
print(get_value(info, "age"))
# 5
print(get_value(info, "gender"))
# None

from typing import TypeVar, Generic, List

T = TypeVar("T")


class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()


stack = Stack[int]()
stack.push(1)
stack.push(2)
print(stack.pop())
# 2

from typing import TypeVar, List

# 定义类型变量 T
T = TypeVar('T')

# 定义一个函数，它接受一个列表并返回列表的第一个元素
def first_item(container: List[T]) -> T:
    return container[0]

# 使用整数列表
int_list: List[int] = [1, 2, 3, 4, 5]
print(first_item(int_list))  # 输出: 1

# 使用字符串列表
str_list: List[str] = ["apple", "banana", "cherry"]
print(first_item(str_list))  # 输出: apple

# 使用浮点数列表
float_list: List[float] = [1.1, 2.2, 3.3]
print(first_item(float_list))  # 输出: 1.1

# 使用自定义对象的列表
class MyClass:
    def __init__(self, value: str) -> None:
        self.value = value

# 创建自定义对象的列表
obj_list: List[MyClass] = [MyClass("first"), MyClass("second")]
# 获取列表中的第一个对象
first_obj = first_item(obj_list)
print(first_obj.value)  # 输出: first

from typing import Generic, TypeVar, List

T = TypeVar("T")


class Stack(Generic[T]):
    def __init__(self):
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()


### 使用整数类型的栈

# 创建一个整数类型的栈
int_stack = Stack[int]()

# 向栈中推入一些整数
int_stack.push(1)
int_stack.push(2)
int_stack.push(3)

# 从栈中弹出元素并打印
print(int_stack.pop())  # 输出: 3
print(int_stack.pop())  # 输出: 2

### 使用字符串类型的栈

# 创建一个字符串类型的栈
str_stack = Stack[str]()

# 向栈中推入一些字符串
str_stack.push("hello")
str_stack.push("world")

# 从栈中弹出元素并打印
print(str_stack.pop())  # 输出: world
print(str_stack.pop())  # 输出: hello

### 使用自定义对象类型的栈


# 定义一个简单的自定义类
class Point:
    def __init__(self, x: int, y: int) -> None:
        self.x = x
        self.y = y


# 创建一个自定义对象类型的栈
point_stack = Stack[Point]()

# 创建一些自定义对象并推入栈中
point_stack.push(Point(1, 2))
point_stack.push(Point(3, 4))

# 从栈中弹出元素并打印
popped_point = point_stack.pop()
print(f"({popped_point.x}, {popped_point.y})")  # 输出: (3, 4)
popped_point = point_stack.pop()
print(f"({popped_point.x}, {popped_point.y})")  # 输出: (1, 2)

from typing import TypeVar, Generic, List

# 定义一个协变类型变量
T = TypeVar("T", covariant=True)


class Box(Generic[T]):
    def __init__(self, value: T) -> None:
        self.value = value

    def get_value(self) -> T:
        return self.value


# 因为T是协变的，所以可以将子类型的Box赋值给父类型的Box
int_box = Box[int](10)
str_box: Box[str] = int_box  # 在协变的情况下这是允许的

print(int_box.get_value())  # 输出： 10
print(str_box.get_value())  # 输出： 10

from typing import TypeVar, Generic, Dict

# 定义一个逆变类型变量
T = TypeVar("T", contravariant=True)


class KeyFinder(Generic[T]):
    def __init__(self, key: T) -> None:
        self.key = key

    def find_key(self, dictionary: Dict[T, str]) -> str:
        return dictionary[self.key]


# 因为T是逆变的，所以可以将父类型的KeyFinder赋值给子类型的KeyFinder
animal_key_finder = KeyFinder[str]("elephant")
zoo_animal_key_finder: KeyFinder[object] = animal_key_finder  # 在逆变的情况下这是允许的

print(animal_key_finder.find_key({"elephant": "大象"}))  # 输出： 大象
print(zoo_animal_key_finder.find_key({"elephant": "大象"}))  # 输出： 大象

from typing import TypeVar, List, Iterable

T = TypeVar('T', bound=Iterable)

def get_first_item(container: T) -> T:
   return next(iter(container))

# 创建一个整数列表
int_list: List[int] = [1, 2, 3, 4, 5]
print(get_first_item(int_list))  # 输出: 1

# 创建一个字符串
str_container: str = "Hello, World!"
print(get_first_item(str_container))  # 输出: H

# 创建一个元组
tuple_container: tuple = ("apple", "banana", "cherry")
print(get_first_item(tuple_container))  # 输出: apple

# 创建一个集合
set_container: set = {1, 2, 3, 4, 5}
print(get_first_item(set_container))  # 输出可能是 1（集合是无序的，所以输出可能不确定）

# 创建一个字典
dict_container: dict = {'a': 1, 'b': 2, 'c': 3}
print(get_first_item(dict_container))  # 输出: 'a'（字典的键）

from typing import List, Dict, Set

my_list: List[int] = [1, 2, 3]
my_dict: Dict[str, int] = {'a': 1, 'b': 2}
my_set: Set[str] = {'a', 'b', 'c'}

b = 'foo'
method_name = 'split'  # 方法名作为字符串
method = getattr(b, method_name)  # 通过反射获取方法

print(method)  # 输出: <built-in method split of str object at 0x7f1d603ba430>

# 调用获取到的方法
result = method()  # 相当于调用 b.split()
print(result)  # 输出: ['foo']

import types

def custom_getattr(obj, attr_name):
    # 检查对象是否有 __dict__ 属性
    if hasattr(obj, '__dict__'):
        # 在 __dict__ 中查找属性
        if attr_name in obj.__dict__:
            return obj.__dict__[attr_name]

    # 如果 __dict__ 中没有，尝试查找类属性或方法
    for cls in type(obj).__mro__:
        if attr_name in cls.__dict__:
            attr = cls.__dict__[attr_name]
            # 如果是方法，绑定到实例
            if callable(attr):
                return types.MethodType(attr, obj)
            # 如果是属性，直接返回
            return attr

    # 如果属性不存在，抛出 AttributeError
    raise AttributeError(f"'{type(obj).__name__}' object has no attribute '{attr_name}'")

# 示例使用
class MyClass:
    def __init__(self):
        self.value = 42

    def greet(self):
        return "Hello, World!"

obj = MyClass()

# 通过自定义的 custom_getattr 获取属性
print(custom_getattr(obj, 'value'))  # 输出: 42

# 通过自定义的 custom_getattr 获取方法
greet_method = custom_getattr(obj, 'greet')
print(greet_method())  # 正确输出: Hello, World!