Python_Note4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import logging

# 配置基本日志记录
logging.basicConfig(level=logging.INFO)

# 记录不同级别的日志
logging.debug('这是一条调试信息')# 不会显示
logging.info('这是一条普通信息')
logging.warning('这是一条警告信息')
logging.error('这是一条错误信息')
logging.critical('这是一条严重错误信息')

1
2
3
4
5
6
7
8
9

import logging

logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)

logging.info('这是一条格式化的日志信息')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import logging

# 创建 logger 对象
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)

# 创建控制台 handler 并设置级别
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# 创建 formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 将 formatter 添加到 handler
ch.setFormatter(formatter)

# 将 handler 添加到 logger
logger.addHandler(ch)

# 记录日志
logger.debug('调试信息')
logger.info('普通信息')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import logging

logger = logging.getLogger('file_logger')
logger.setLevel(logging.INFO)

# 创建文件 handler
fh = logging.FileHandler('app.log')
fh.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)

logger.addHandler(fh)

logger.info('这条信息会被记录到文件中')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from logging.handlers import RotatingFileHandler

logger = logging.getLogger('rotating_logger')
logger.setLevel(logging.INFO)

# 每个文件最大 1MB，保留 3 个备份文件
handler = RotatingFileHandler('app.log', maxBytes=1024*1024, backupCount=3)
handler.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)

logger.addHandler(handler)

for i in range(10000):
logger.info(f'这是第 {i} 条日志信息')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from logging.handlers import TimedRotatingFileHandler

logger = logging.getLogger('timed_rotating_logger')
logger.setLevel(logging.INFO)

# 每天午夜轮转日志，保留 7 天备份
handler = TimedRotatingFileHandler('app.log', when='midnight', backupCount=7)
handler.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)

logger.addHandler(handler)

logger.info('这条日志会根据时间轮转')

1

logger = logging.getLogger(__name__)

1
2

if logger.isEnabledFor(logging.DEBUG):
logger.debug('Message with %s', expensive_arg())

1
2
3
4

try:
1 / 0
except ZeroDivisionError:
logger.exception("发生了除以零的错误")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import logging.config

config = {
'version': 1,
'formatters': {
'detailed': {
'format': '%(asctime)s %(name)-15s %(levelname)-8s %(processName)-10s %(message)s'
}
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'level': 'INFO',
},
'file': {
'class': 'logging.FileHandler',
'filename': 'app.log',
'mode': 'w',
'formatter': 'detailed',
},
},
'root': {
'level': 'DEBUG',
'handlers': ['console', 'file']
},
}

logging.config.dictConfig(config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

[loggers]
keys=root

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=simpleFormatter

[logger root]
level=DEBUG
handlers=consoleHandler,fileHandler

[handler consoleHandler]
class=StreamHandler
level=INFO
formatter=simpleFormatter
args=(sys.stdout,)

[handler fileHandler]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=('app.log', 'a')

[formatter simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=%Y-%m-%d %H:%M:%S

1
2
3

import logging.config

logging.config.fileConfig('logging.conf')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class MyFilter(logging.Filter):
def filter(self, record):
# 只允许包含特定文字的日志通过
return 'important' in record.getMessage()

logger = logging.getLogger('filtered_logger')
logger.addFilter(MyFilter())

logger.info('这是一条普通信息')# 不会被记录
logger.info('这是一条重要信息 important')# 会被记录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import logging
from logging import LoggerAdapter

logger = logging.getLogger(__name__)
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.INFO)

class ContextFilter(logging.Filter):
def filter(self, record):
record.user = 'John'# 添加上下文信息
return True

logger.addFilter(ContextFilter())
formatter = logging.Formatter('%(asctime)s - %(user)s - %(levelname)s - %(message)s')
for handler in logger.handlers:
handler.setFormatter(formatter)

logger.info('系统消息')

# 或者使用 LoggerAdapter
extra = {'user': 'Alice'}
logger = LoggerAdapter(logger, extra)
logger.info('系统消息')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import logging
import logging.handlers
import multiprocessing

def listener_process(queue):
root = logging.getLogger()
h = logging.FileHandler('multi_process.log')
f = logging.Formatter('%(asctime)s %(processName)-10s %(name)s %(levelname)-8s %(message)s')
h.setFormatter(f)
root.addHandler(h)

while True:
try:
record = queue.get()
if record is None:
break
logger = logging.getLogger(record.name)
logger.handle(record)
except Exception:
import sys, traceback
print('Error in listener:', file=sys.stderr)
traceback.print_exc(file=sys.stderr)

def worker_process(queue):
queue_handler = logging.handlers.QueueHandler(queue)
root = logging.getLogger()
root.addHandler(queue_handler)
root.setLevel(logging.DEBUG)

logging.info('来自工作进程的消息')

if __name__ == '__main__':
queue = multiprocessing.Queue()
listener = multiprocessing.Process(target=listener_process, args=(queue,))
listener.start()

workers = []
for i in range(2):
worker = multiprocessing.Process(target=worker_process, args=(queue,))
workers.append(worker)
worker.start()

for worker in workers:
worker.join()

queue.put(None)
listener.join()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

"""
日志处理
"""
import logging
import os
from logging.handlers import RotatingFileHandler
import colorlog  # 导入 colorlog
def setup_logging(log_file=None, log_level=logging.INFO, max_bytes=1 * 1024 * 1024, backup_count=5):
    """
    配置日志记录，包括日志轮换和控制台输出，支持彩色日志
    :param log_file: 日志文件路径，如果为None则使用默认路径
    :param log_level: 日志等级
    :param max_bytes: 单个日志文件的最大字节数，默认为1MB
    :param backup_count: 保留的日志文件备份数
    """
    if log_file is None:
        log_file = os.getenv('LOG_FILE_PATH', 'docs/log/test.log')

    # 确保日志文件夹存在
    log_dir = os.path.dirname(log_file)
    if not os.path.exists(log_dir):
        os.makedirs(log_dir)

    # 创建根记录器
    logger = logging.getLogger()
    logger.setLevel(log_level)

    # 清除已有的处理器，避免重复添加
    if logger.hasHandlers():
        logger.handlers.clear()

    # 创建文件处理器，支持日志轮换
    file_handler = RotatingFileHandler(log_file, mode='w', maxBytes=max_bytes, backupCount=backup_count)
    file_handler.setLevel(log_level)

    # 创建控制台处理器，日志输出到控制台
    console_handler = logging.StreamHandler()
    console_handler.setLevel(log_level)

    # 定义日志格式
    log_format = '%(asctime)s - %(levelname)-8s - %(message)-60s - [%(filename)-15s:%(lineno)-4d]'
    color_format = "%(log_color)s" + log_format

    # 设置文件处理器的格式
    file_formatter = logging.Formatter(log_format)
    file_handler.setFormatter(file_formatter)

    # 设置控制台处理器的彩色格式
    color_formatter = colorlog.ColoredFormatter(
        color_format,
        log_colors={
            'DEBUG': 'cyan',
            'INFO': 'green',
            'WARNING': 'yellow',
            'ERROR': 'red',
            'CRITICAL': 'bold_red',
        }
    )
    console_handler.setFormatter(color_formatter)

    # 将处理器添加到记录器中
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)

    # 添加日志分隔符
    logger.info("=" * 60)
    logger.info("新日志开始".center(60, ' '))
    logger.info("=" * 60)


def log_data(data):
    """
    记录数据的日志
    """
    logging.info(f"数据记录: {data}")


# 通用异常处理装饰器
def log_exceptions(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            logging.error(f"{func.__name__} 执行时发生错误", exc_info=True)
            raise e

    return wrapper

# 示例：调用日志设置
if __name__ == "__main__":
    setup_logging(log_file='/Users/zhangxianping/Desktop/pythonProject/SiCore_ChipTest/docs/log//test.log', log_level=logging.DEBUG)
    log_data("这是一个测试数据记录")
    logging.debug("这是一条调试信息")
    logging.warning("这是一条警告信息")
    logging.error("这是一条错误信息")
    logging.critical("这是一条严重错误信息")

1
2

# 导入模块
import psutil

1
2
3
4
5
6
7
8

# 核心数
psutil.cpu_count(logical=False)
# 参数 logical=False 只会返回物理内核


# 使用率
psutil.cpu_percent(interval=0.5)
# 若加上参数 percpu=True 则会返回一个列表，包含各个核心的使用率

1
2
3
4

# 内存信息，包括：总容量、可用空间及占比等
psutil.virtual_memory()

# 可以通过点号访问具体的属性，例如 psutil.virtual_memory().total

1
2
3
4
5
6

# 磁盘分区信息，包括：总容量、可用空间及占比等
psutil.disk_partitions()


# 指定目录的磁盘信息
psuntil.disk_usage('/')

1
2

# 可以获取到收、发数据包的数量
。。。。。。

1
2

# 活动用户信息
psutil.users()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import psutil
import datetime
import unicodedata


def align_string(text, width, alignmethod):
    # 处理中英文混合字符串的对齐问题
    text_width = sum(2 if unicodedata.east_asian_width(c) in ('F', 'W') else 1 for c in text)
    if alignmethod == 'ljust':
        tmp = text.ljust(width - text_width)
    elif alignmethod == 'rjust':
        tmp = text.rjust(width - text_width)
    elif alignmethod == 'center':
        tmp = text.center(width - text_width)
    return tmp


cpu_per = psutil.cpu_percent(interval=0.5)
memory_info = psutil.virtual_memory()
disk_info = psutil.disk_usage("/")
net_info = psutil.net_io_counters()
current_time = datetime.datetime.now().strftime("%F %T")


log_template = f"""
|{align_string('监控时间', 19, 'center')}|{align_string('CPU使用率', 19, 'center')}|{align_string('内存使用率', 19, 'center')}|{align_string('硬盘使用率', 19, 'center')}|{align_string('网络收发量', 28, 'center')}|
|{align_string('', 19, 'ljust')}|{align_string(f'(共{psutil.cpu_count(logical=False):.2f}核CPU)', 19, 'center')}|{align_string(f'(总计{memory_info.total/1024/1024/1024:.2f}G内存)', 19, 'center')}|{align_string(f'(总计{disk_info.total/1024/1024/1024:.2f}G硬盘)', 19, 'center')}|{align_string('', 28, 'ljust')}|
|{'-' * 19}|{'-' * 19}|{'-' * 19}|{'-' * 19}|{'-' * 28}|
|{align_string(current_time, 19, 'ljust')}|{align_string(f'{cpu_per}%', 19, 'ljust')}|{align_string(f'{memory_info.percent}%', 19, 'ljust')}|{align_string(f'{disk_info.percent}%', 19, 'ljust')}|{align_string(f'收:{net_info.bytes_recv}/发:{net_info.bytes_sent}', 28, 'ljust')}|
|{'-' * 19}|{'-' * 19}|{'-' * 19}|{'-' * 19}|{'-' * 28}|
"""
print(log_template)

with open('log.txt', 'a') as f:
    f.write(log_template + '\n\n')

1
2

# 导入模块
import yagmail

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 先创建对象
ya_obj = yagmail.SMTP(
    user = "发件人邮箱",
    password = "授权码（非密码，在邮箱设置）",
    host = "网易邮箱服务器smtp.163.com"
)


# 配置邮件内容
content = '。。。'


# 发送邮件
ya_obj.send('收件人邮箱', '邮件主题', content)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from bs4 import BeautifulSoup
import smtplib
from email.mime.text import MIMEText


msg_from = '870407139@qq.com'    #发送方邮箱
passwd = '...'    #填入发送方邮箱的授权码
receivers = ['870407139@qq.com,503734057@qq.com']    #收件人邮箱

subject = "北大研招网更新连接"    #主题
content = "..."    #正文
msg = MIMEText(content)
msg['Subject'] = subject
msg['From'] = msg_from
msg['To'] = ','.join(receivers)

try:
    s = smtplib.SMTP_SSL("smtp.qq.com",465)                   #邮件服务器及端口号
    s.login(msg_from, passwd)
    s.sendmail(msg_from, msg['To'].split(','), msg.as_string())
    print("发送成功")
except:
    print("发送失败")
finally:
    s.quit()

1
2

if cpu_per>80 or memory_info.percent>90:
    # 发送邮件。。。

1
2
3

# 从字符串的【开头位置】匹配
# 可以用于【验证】输入的【内容是否满足某种格式】
re.match("正则表达式", "要验证/检测的字符串")

1
2

# 从需要检测的字符串中【搜索】满足正则的内容
re.search("正则表达式", "要搜索的字符串")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import re

def add(temp):
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)


# 通过传入 add 函数，对 search 到的内容进行更加【多样化的替换】
ret = re.sub(r"\d+", add, "hello python = 997")
print(ret)

1
2
3
4

# 根据冒号或者空格拆分
result = re.split(":| ", "info:hello@163.com zhangsan lisi")
print(result)
# 相比于 str.split() 更加灵活

1
2
3

result = re.match("aaa(\d+?)", "aaa123456")
# 匹配到 1 就停止了
print(result.group())

1
2
3
4
5

# result = re.match("<([a-zA-Z0-9]+)><([a-zA-Z0-9]+)>.*</\\2></\\1>", "<html><h1>asdbj</h1></html>")
# 等价写法
result = re.match(r"<([a-zA-Z0-9]+)><([a-zA-Z0-9]+)>.*</\2></\1>", "<html><h1>asdbj</h1></html>")

print(result.group())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import pymysql

# 建立连接对象
conn = pymysql.connect(
    host='localhost',
    port=3306,
    user='root', password='123456'
)

# 创建游标对象
cur = conn.cursor()

# 使用游标对象执行 SQL 语句
sql = """
select * from students
"""
results = cur.execute(sql)
# 提交
conn.commit()
# 仅从查询的数据中取出一条数据
oneres = cur.fetchone()
# fetchall 返回嵌套元组，每个元组是一条数据
res = cur.fetchall()

# 关闭游标对象
cur.close()

# 关闭连接对象
conn.close()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import os
from pymongo import MongoClient


# 配置 mongodb 数据库
host = os.environ.get('MONGODB_HOST', '127.0.0.1')  # 本地数据库
port = os.environ.get('MONGODB_PORT', '27017')  # 数据库端口
mongo_url = 'mongodb://{}:{}'.format(host, port)
mongo_db = os.environ.get('MONGODB_DATABASE', '...')
client = MongoClient(mongo_url)
db = client[mongo_db]

#db['...'].create_index('id', unique=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

sql = f"""
select * from goods where name = {input_name} order by id desc
"""
# 当 input_name = ' or 1 or ' 时，执行
# select * from goods where name = '' or 1 or '' order by id desc
# 会导致注入问题


# 防止注入的写法
sql = """
select * from goods where name = %s order by id desc
"""
result = cur.execute(sql, [input_name, ])

1
2

co = ChromiumOptions()
co.incognito()

1
2
3

co = ChromiumOptions()
co.headless()
co.set_argument('--disable-blink-features=AutomationControlled')

1
2
3

co = ChromiumOptions()
co.set_argument('--no-sandbox')
co.set_argument('--disable-dev-shm-usage')

1
2
3
4
5

option = webdriver.ChromeOptions()
# 防止自动关闭浏览器
option.add_experimental_option('detach', True)

driver = webdriver.Chrome(chrome_options = option)

1

driver.find_element_by_id('search-input')

1

driver.find_element_by_name('keywords')

1

driver.find_element_by_class_name('toolbar-container')

1
2
3
4
5
6
7

# 绝对路径，根据层级关系定位
driver.find_element_by_xpath('/html/body/div/div/input[1]')

# 根据元素属性定位
driver.find_element_by_xpath("//*[@id='search-input']")

# 也可以结合上述二者

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 选择 class 为指定值的元素
driver.find_element_by_css_selector('.toolbar-container')

# 选择 id 为指定值的元素
driver.find_element_by_css_selector('#search-input')

# 选择所有 input 元素
driver.find_element_by_css_selector('input')

# 选择父元素为 div 的所有 input 元素
driver.find_element_by_css_selector('div>input')

# div 标签与 input 标签在同级，且 input 在 div 之后
driver.find_element_by_css_selector('div+input')

# 选择 type 属性值为 text 所有的元素
driver.find_element_by_css_selector("[type='text']")

1
2
3
4

driver.find_element_by_link_text('hello world')

# partial 只需要部分文本即可定位
driver.find_element_by_partial_link_text('hello')

1
2
3
4
5
6

# 打开新的标签页
js = "window.open('https://baidu.com')"
driver.execute_script(js)

# 滑动滚动条
js = "window.scrollTo(0, 500)"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By


driver = webdriver.Chrome()
element = WebDriverWait(driver, 5, 0.5)\
          .until(
            EC.presence_of_element_located((By.ID, 'kw')),
            message = '超时了'
          )

1
2
3

# 设置隐式等待 5 秒
driver.implicitly_wait(5)
# 一般配合 try except 捕获超时异常

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import sys
from PySide2.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton


def click():
    print("Button is clicked!")

# 每个 GUI 都必须包含一个 Qapplication
# argv 表示获取命令行参数，如果不用获取，则可以使用 [] 代替
app = QApplication(sys.argv)

# QMainWindow 类似一个容器（窗口）
# 用来包含按钮、文本、输入框等 widgets
win = QMainWindow()
# 定义窗口的尺寸，四个参数分别对应坐标 x、y 和宽高
win.setGeometry(400, 400, 400, 300)
win.setWindowTitle("PySide2 Tutorial")

# 设置文本内容
label = QLabel(win)
label.resize(200, 100)
label.setText("Hi this is PySide2")
label.move(100, 100)

# 按钮和事件
button = QPushButton(win)
button.resize(200, 100)
button.setText("Hi! Click Me")
button.move(100, 100)
# 将按钮和函数 click 进行绑定
button.clicked.connect(click)

# 显示窗口
win.show()
# 设置窗口一直运行，直到使用关闭按钮进行关闭
sys.exit(app.exec_())

1
2
3
4
5
6
7
8

import sys
from PyQt5 import QtWidgets, uic


app = QtWidgets.QApplication(sys.argv)
window = uic.loadUi("mainwindow.ui")
window.show()
app.exec()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 通过全局变量设置样式
# 三对双引号内书写 css
startbutton_qss = """
    QPushButton{
        background:orange;
        color:white;
        font-size:18px;
        border-radius: 24px;
        font-family: 微软雅黑;
    }
    QPushButton:pressed{
        background:black;
    }
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

- `class FileConversionWindow()`
    - __init__
        初始化一些控件，绑定好点击事件和信号，设置好样式
    - callback
        用于进度条参数的回传
    - callback_done
        进度条结束的信号
    - messageDialog1
        通知对话框 `QtWidgets.QMessageBox` 实现通知信息
    - select_oldBomfile
        文件选择对话框 `QtWidgets.QFileDialog.getOpenFileName`
    - select_totalBomfile
    - run_convert
        主要的文件处理逻辑，最后将前面定义的信号 emit 出来


- `class BomCompareWindow()`
    - __init__
    - select_file
    - select_file_new
    - show_result
    - show_log
    - run_compare


- `class Ui_MainWindow(object)`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 创建 app
app = QtWidgets.QApplication(sys.argv)
# 设置主窗口
MainWindow = QtWidgets.QMainWindow()
# 初始化 UI
ui = Ui_MainWindow()
# 将 UI 设置到主窗口上
ui.setupUi(MainWindow)
# 展示主窗口
MainWindow.show()
# 当 app 执行结束动作时，系统关闭 app
sys.exit(app.exec_())

1
2
3
4
5
6
7

from turtle import *
# 注意这么导入的对象集很大，可能发生名称冲突


# 推荐如下导入方式
import turtle
# width() 就要变成 turtle.width()

1
2
3
4
5

from turtle import Turtle

t1 = Turtle()
t2 = Turtle()
# 通过这种方式，允许屏幕同时存在多只海龟

1
2
3

# 自定义屏幕
t1.screen.title('turtle demo')
t1.screen.bgcolor('orange')

1
2
3
4
5

for steps in range(100):
    for c in ('blue', 'red', 'green'):
        color(c)
        forward(steps)
        right(30)

1

import numpy as np

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

a = np.arange(12).reshape(3, 4)


a.ndim
# 返回维度数量

a.shape
# 返回二维数组，表示各个维度的大小

a.dtype.name
# 数据类型

a.size
# 数组的长宽相乘

type(a)
# 获取数据类型，numpy.ndarray

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

a.resize((2, 6))    # 不支持 -1
a.reshape((2, -1))
# 注意这里的 -1
# 不用去管几列，只要专注于自己想要将原矩阵修改为几行即可


# 将数组展平
a.flat    # 返回值是迭代器，可以通过list关键字转换成列表
list(a.flat)
a.ravel()    # 直接返回 numpy 数组对象

1
2
3

np.array([[1, 2], [3, 4]], dtype=complex)
# 这里在创建的时候指定了数据形式为【复数】
# 还可以指定 dtype=np.float32 等等

1
2
3
4
5
6
7
8
9

np.arange(10, 30, 5)
# 从10开始取值，步长为5，直到30但不包括30
np.arange(0, 2, 0.3)
# [0,2)，步长为 0.3


# 在区间 [0,2] 上生成【平均间隔】的 5 个数
np.linspace(0, 2, 5)
# array([0. , 0.5, 1. , 1.5, 2. ])

1
2
3
4
5
6
7
8

A * B
# elementwise product，相应位置的数字相乘


A.T @ B
# matrix product，矩阵相乘
A.T.dot(B)    # 同上
np.dot(A.T, B)    # 同上

1
2
3
4
5
6
7
8
9

c = np.array([[[  0,  1,  2],
               [ 10, 12, 13]],

              [[100, 101, 102],
               [110, 112, 113]]])


c[1, ...]    # 等同于 c[1, :, :] or c[1]
c[..., 2]    # 等同于 c[:, :, 2]

1
2
3

nums = [1,2,3,4,5,6,7]
a = np.random.RandomState(0)
a.permutation(nums)

1
2
3
4
5
6
7
8

data = pd.Series([0.2, 0.5, 0.7, 1])


print(data)
print('----------------')
print(data.index)    #查看 Serise 对象的索引
print('----------------')
print(data.values)    #查看 Serise 对象的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

arr = [0.2, 0.5, 0.7, 1]
ind1 = ['a', 'c', 'b', 'd']
ind2 = [2, 5, 3, 7]


d1 = pd.Series(arr)
# 默认索引是从 0 开始依次标号
print('d1的索引是:', d1.index)

# 将【字符（串）】作为索引
d2 = pd.Series(arr, index=ind1)
print('d2的索引是:', d2.index)

# 将【无序整数】作为索引
d3 = pd.Series(arr, index=ind2)
print('d3的索引是:', d3.index)

# 不同的索引表示同一值
print(d1[0], d2['a'], d3[2])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

pop_dict = {
    'California': 38332521,
    'Texas': 26448193,
    'New York': 19651127,
    'Florida': 19552860,
    'Illinois': 12882135
}


pop = pd.Series(pop_dict)
print(pop)
print('----------------')
# 取出 Series 对象 California 对应的值
print('California人口数为:', pop['California'])

1
2
3
4
5
6
7
8
9

import pandas as pd


# 创建一个单个 Series 对象
data = pd.Series([1, 2, 3, 4, 5])

# 使用该 Series 对象创建 DataFrame
df = pd.DataFrame(data, columns=['Column_Name'])
print(df)

1
2
3
4
5
6
7
8
9

# 创建一个字典列表
data = [
    {'a': 1, 'b': 2},
    {'a': 5, 'b': 10, 'c': 20}
]


# 使用字典列表创建 DataFrame
df = pd.DataFrame(data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

area_dict = {
    'Texas': 695662,
    'New York': 141297,
    'Florida': 170312,
    'Illinois': 149995,
    'California': 423967
}
area = pd.Series(area_dict)


# 两列，每列都为 Series 对象，通过字典传入
states = pd.DataFrame(
    {'pop': pop,
    'area': area}
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import numpy as np

# 创建一个 NumPy 二维数组
data = np.array(
    [[1, 2, 3],
    [4, 5, 6]]
)


# 使用 NumPy 二维数组创建 DataFrame
df = pd.DataFrame(
    data,
    columns=['Column1', 'Column2', 'Column3']
)