语言基础 ¶

$ cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=24.04
DISTRIB_CODENAME=noble
DISTRIB_DESCRIPTION="Ubuntu 24.04.3 LTS"

sudo apt install python3, python3-pip, python3-venv

$ python3 --version
Python 3.12.3

python3 myfile.py

sudo apt install python3-venv

cd /opt/mySite
python3 -m venv .mySite

source .mySite/bin/activate

deactivate

deactivate
rm -rf .mySite

#!/usr/bin/env python3 
print("Hello, world!")

$ ./.mySite/bin/python -c "import sys; print(sys.executable)"
/opt/mySite/.mySite/bin/python

#!/opt/mySite/.mySite/bin/python
print("Hello, world!")

# -*- coding: latin-1 -*-

$ pip --version
pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12)

$ pip3 --version
pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12)

pip install --upgrade pip
pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/
python3 -m pip install --upgrade pip
python3 -m pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/

pip config list

extra-index-url = https://{USERNAME}:{TOKEN}@<YOUR REPOSITORY HOST>/artifactory/api/pypi/deploy-releases-hyperspace-pypi/simple
                  https://{USERNAME}:{TOKEN}@<YOUR REPOSITORY HOST>/artifactory/api/pypi/deploy.releases.pypi/simple
                  https://pypi.org/simple
trusted-host = <YOUR REPOSITORY HOST>

$ ll /etc/pip.conf 
-rw------- 1 root root 314 Aug 29 16:58 /etc/pip.conf

$ sudo chmod og+rw /etc/pip.conf 

$ ll /etc/pip.conf 
-rw-rw-rw- 1 root root 314 Aug 29 16:58 /etc/pip.conf

pip install -r requirements.txt
pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/

pip install package_name
pip install -U package_name

pip show package_name
pip show package_name | grep "Version:"

pip list --outdated
pip install package_name==specific_version

pip install --upgrade package_name

$ cat > requirements.txt << EOF
sqlite-utils
numpy
matplotlib
scikit-learn
pandas
seaborn
selenium
pandas-datareader
beautifulsoup4
statsmodels
black
pipdeptree
python-dotenv
flask
mkdocs
python-minifier
mkdocs-material
mkdocs-material-extensions
mkdocs-minify-plugin
mkdocs-mermaid2-plugin
mkdocs-awesome-pages-plugin
EOF

$ pip install -r requirements.txt

ERROR: Could not install packages due to an OSError: [Errno 13] Permission denied: '/usr/local/bin/normalizer'
Consider using the `--user` option or check the permissions.

$ python3
Python 3.12.3 (main, Jun 18 2025, 17:59:45) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print(sys.path)
['', '/usr/lib/python312.zip', '/usr/lib/python3.12', '/usr/lib/python3.12/lib-dynload', '/usr/local/lib/python3.12/dist-packages', '/usr/lib/python3/dist-packages']

pylint sample.py

flake8 sample.py

mypy sample.py

autopep8 --in-place --aggressive --aggressive sample.py

black sample.py

import unittest

def add(a, b):
    return a + b

class TestMathOperations(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(0, 0), 0)

if __name__ == '__main__':
    unittest.main()

pip install pytest

def add(a, b):
    return a + b

def test_add():
    assert add(1, 2) == 3
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

pip install nose2

import unittest

def add(a, b):
    return a + b

class TestMathOperations(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(0, 0), 0)

if __name__ == '__main__':
    import nose2
    nose2.main()

pip install ward

from ward import test

def add(a, b):
    return a + b

@test("add function works correctly")
def _():
    assert add(1, 2) == 3
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

message = "Hello, world!"; print(message)

# This is a comment
print("Hello, world!")
print("How are you?")  # This is an inline comment.
print("Please use # to add comments.")

def hello_world():
    """
    This is a docstring. 
    It can span multiple lines and is used to document the function.
    It is somewhat, but not exactly, like a multi-line comment.
    """
    #  ...function logic...

print(hello_world.__doc__)  # This will print the docstring of the function.

# 定义一个变量
x = 10  # x 是整数类型
print(type(x))  # 输出: <class 'int'>

# 重新赋值为字符串
x = "Hello, World!"  # x 现在是字符串类型
print(type(x))  # 输出: <class 'str'>

# 重新赋值为列表
x = [1, 2, 3]  # x 现在是列表类型
print(type(x))  # 输出: <class 'list'>

x = 10
y = "20" 
result = x + y  # 这会抛出 TypeError

answer = 42
insight = answer

spam = 123456789
maps = spam
eggs = 123456789

print(spam == maps)  # 输出：True
print(spam == eggs)  # 输出：True
print(spam is maps)  # 输出：True
print(spam is eggs)  # 输出：False (也可能是True，取决于Python的实现)

print(id(spam))  # 输出：134627774496688
print(id(maps))  # 输出：134627774496688
print(id(eggs))  # 输出：134627774496688 (也可能是其他值，取决于Python的实现)

x = True
if x:
   pass

while True:
    command = input("Enter command(e,c): ")
    if command == "e":
        break
    elif command == "c":
        print("continue")
        continue
    print("Command unknown.")

for i in range(1, 11):
    print(i)

lunch_order = input("What would you like for lunch? ")

match lunch_order:
    case "bread":
        print("It's bread!")
    case "salad" | "soup":
        print("Eating healthy")
    case _:
        print("Yummy.")

lunch_order = input("What would you like for lunch? ")

class Nothing:
    order = "nothing"

match lunch_order:
    case "bread":
        print("It's bread!")
    case "salad" | "soup":
        print("Eating healthy")
    case Nothing.order:
        print(f"Enjoy your {Nothing.order}!")
    case _:
        print(f"Enjoy!")

lunch_order = input("What would you like for lunch? ")

order = "nothing"

match lunch_order:
    case "bread":
        print("It's bread!")
    case "salad" | "soup":
        print("Eating healthy")
    case order:
        print(f"Enjoy your {order}!")
# 输出：
# What would you like for lunch? noodle
# Enjoy your noodle!

lunch_order = input("What would you like for lunch? ")

class Nothing:
    order = "nothing"

match lunch_order:
    case "bread":
        print("It's bread!")
    case "salad" | "soup":
        print("Eating healthy")
    case Nothing.order:
        print(f"Enjoy your {Nothing.order}!")

from datetime import datetime, date, time

dt = datetime(2011, 10, 29, 20, 30, 21)

print(dt.day)  
# 29
print(dt.minute)  
# 30
print(dt.date())  
# 2011-10-29
print(dt.time())  
# 20:30:21
print(dt.replace(minute=0, second=0))  
# 2011-10-29 20:00:00  将分钟、秒替换为0
print(datetime.strptime('20091021', '%Y%m%d'))  
# 2009-10-21 00:00:00 字符串可以通过 strptime 函数转换为datetime对象

dt2 = datetime(2011, 11, 15, 22, 30)
delta = dt2 - dt
print(delta)  
# 17 days, 1:59:39
print(dt + delta)  
# 2011-11-15 22:30:00

spam = 123

print(type(spam))  # <class 'int'>

if type(spam) == int:
    print("spam是整数")

if isinstance(spam, int):
    print("spam是整数")

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}')

from decimal import Decimal 
from fractions import Fraction

third_fraction = Fraction(1, 3) 
third_fixed = Decimal("0.333") 
third_float = 1 / 3

print(third_fraction)  # 1/3
print(third_fixed)  # 0.333
print(third_float)  # 0.3333333333333333

third_float = float(third_fraction)
print(third_float)  # 0.3333333333333333

third_float = float(third_fixed)
print(third_float)  # 0.333

import math


print(float("nan"))  # nan
print(float("-nan"))  # nan


x = float("nan")

print(x == x)  # False
print(x != x)  # True
print(math.isnan(x))  # True

print(x + 1)  # nan
print(x * 2)  # nan

print(float("inf"))  # inf
print(float("-inf"))  # -inf


y = float("inf")

print(y > 1000)  # True
print(y < -1000)  # False
print(math.isinf(y))  # True

print(y + 1)  # inf
print(y * 2)  # inf

# 创建复数
z1 = 3 + 4j
z2 = 1 - 2j

# 访问实部和虚部
print("z1 的实部:", z1.real)  # 输出: z1 的实部: 3.0
print("z1 的虚部:", z1.imag)  # 输出: z1 的虚部: 4.0

# 复数运算
print("z1 + z2 =", z1 + z2)  # 输出: z1 + z2 = (4+2j)
print("z1 - z2 =", z1 - z2)  # 输出: z1 - z2 = (2+6j)
print("z1 * z2 =", z1 * z2)  # 输出: z1 * z2 = (11-2j)
print("z1 / z2 =", z1 / z2)  # 输出: z1 / z2 = (-1+2j)

# 复数的共轭
print("z1 的共轭:", z1.conjugate())  # 输出: z1 的共轭: (3-4j)

# 复数的绝对值
print("z1 的绝对值:", abs(z1))  # 输出: z1 的绝对值: 5.0

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

greeting = "Hello"
name = "Jason"

# 方法1：
message = greeting + ", " + name + "!"
print(message)  # 输出：Hello, Jason!

# 方法2：
message = "".join((greeting, ", ", name, "!"))
print(message)  # 输出：Hello, Jason!

# 方法3：
message = f"{greeting}, {name}!"
print(message)  # 输出：Hello, Jason!

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.

answer = 42
print(f"{{answer}}")          # 输出：{42}
print(f"{{{{answer}}}}")      # 输出：{{42}}
print(f"{{{{{{answer}}}}}}")  # 输出：{{{42}}}

print(f"{5+5=}")  # 输出：5+5=10

print(f"{ord('\"')}")
print(f"""{ord('"')}""")

print(f"{ord('\n')}")

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])