「学习笔记」Python基础入门

# coding=utf-8
score = int(input("请输入一个0~100整数:"))
if score >= 90:
    grade = 'A' # 缩进推荐4个半角空格
elif score >= 60:
    grade ='B
else:
    grade ='F
print("Grade ="+ grade)

# coding=utf-8
i = 0
while i*i < 10:
    i += 1
    if i == 3:
        break # 在i==3时终止循环
    print(str(i) + '*' str(i) + '=', i*i)
else: # else子语句只有在循环体正常结束时才执行，这里while被break中断,else不会执行
    print('While Over!')

# coding=utf-8
for item in range(10):
    if item == 3:
        continue # 在i==3时终止本次循环，接着进行下次循环i==4
    print(item)
else: # for循环体未中断,执行else语句
    print('For over!')

list = [20,10,50]
list.append(80) # [20, 10, 50, 80]
a = [60,30]
list += a       # [20, 10, 50, 80, 60, 30]
b = [70,90]
list.extend(b)  # [20, 10, 50, 80, 60, 30, 70, 90]

21,32,43,45    # 指定具体的组元素
               # (21, 32, 43, 45)
tuple('Hello') # tuple函数创建
               # ('H', 'e', 'l', 'l', 'o')
tuple([21,32,43,45]) # (21, 32, 43, 45)
1,  # 创建只有一个元素的元组 (1,)
()  # 创建空元组 () 

{100:'张三',101:'李四'} # 指定具体的字典键值对
                      # {100: '张三', 101: '李四'}
dict([(100,'张三'),(101,'李四')]) # dict()函数，传入列表
                      # {100: '张三', 101: '李四'}
dict(((100,'张三'),(101,'李四'))) # dict()函数，传入元组
                      # {100: '张三', 101: '李四'}
dict(zip([100,101],['张三','李四'])) # 通过zip()函数将两个可迭代对象打包成元组，第一个对象为键，第二个为值，它们元素个数相同，一一对应。
                      # {100: '张三', 101: '李四'}

d = {100:'张三',101:'李四',102:'王五'}
for s_id in d.keys():
    print('ID:' + str(s_id)) # ID:100  ID:101  ID:102
for s_name in d.values():
    print('姓名:' + s_name)  # 姓名:张三  姓名:李四  姓名:王五
for s_id,s_name in d.items():
    print('ID:{0},姓名:{1}'.format(s_id,s_name))
    # ID:100,姓名:张三  ID:101,姓名:李四  ID:102,姓名:王五

s1 = 'Hello\n World'
print(s1)
# Hello
#  World
s2 = r'Hello\n World'
print(s2)
# Hello\n World

str(123) # '123'
str(True) # 'True'
float('60.0') # 60.0
int('60') # 60
int('AB',16) # 171

i = 32
'i*i={}'.format(i*i) # 'i*i=1024'
'{0}*{0}={1}'.format(i,i*i) # '32*32=1024'
'{p1}*{p1}={p2}'.format(p1=i,p2=i*i) # '32*32=1024'

'{0:s}年龄{1:d}，工资{2:f}元'.format('Tony',20,6868.00)
# 'Tony年龄20，工资6868.000000元'
'{p1:s}年龄{p2:d}，工资{p3:f}元'.format(p1='Tony',p2=20,p3=6868.00)
# 'Tony年龄20，工资6868.000000元'
'{%s}年龄{%d}，工资{%f}元'%('Tony',20,6868.00)
# '{Tony}年龄{20}，工资{6868.000000}元'

def 函数名(参数列表):
    函数体
    return 返回值（可选）

def rect_area(width, height):
     area = width * height
     print("width:{0},height:{1},面积:{2}".format(width,height,area))
     return area

rect_area(50,60)  # 实参与形参按顺序匹配
width:50,height:60,面积:3000
3000
rect_area(height=60,width=50) # 参数名=值,无需考虑顺序
width:50,height:60,面积:3000
3000
def sum(*nums):   # 元组可变参数
     total = 0.0
     for num in nums:
          total += num
     return total

print(sum(100.0,20.0,60.0))
180.0
def show_info(**infos):   # 字典可变参数
     for key,value in infos.items():
          print("{0}：{1}".format(key,value))

show_info(name="Tom", age=18, sex=True)
name：Tom
age：18
sex：True

data1 = [66,15,91,28,98,50,7,80,99]
filtered = filter(lambda x: (x > 50), data1)
list(filtered) # [66, 91, 98, 80, 99]
mapped = map(lambda x: (x + 10), data1)
list(mapped) # [76, 25, 101, 38, 108, 60, 17, 90, 109]

class Car(object): # 定义类
    pass # 类体
car = Car() # 实例化一个对象

class Account:
     interest_rate = 0.0668  # 类变量-利率
     def __init__(self, owner, amount):
          self.owner = owner   # 实例变量-账户名
          self.amount = amount # 实例变量-账户金额
     # 类方法
     @classmethod
     def interest_by(cls, amt):
          return cls.interest_rate * amt
interest = Account.interest_by(12000.0) # 调用类方法
print('计算利息：{0:.4f}'.format(interest)) # 计算利息：801.6000

class Dog:
    # 构造方法
    def __init__(self, name, age):
      self.__name = name # 私有变量name
      self.__age = age   # 私有变量age
    # get方法
    def get_age(self):
      return self.__age
    # set方法
    def set_age(self, age):
      self.__age = age
    @property
    def name(self): # 属性,替代get_name方法,方法名就是属性名
      return self.__name
    @name.setter
    def name(self, name): # 属性,替代set_name
      self.__name = name

# 实例化一个对象
dog = Dog('球球', 2)
print('{0}的年龄是{1}'.format(dog.name, dog.get_age())) # 球球的年龄是2
dog.set_age(3)
dog.name = '胖胖'
print('修改后，{0}的年龄是{1}'.format(dog.name, dog.get_age())) # 修改后，胖胖的年龄是3

class Animal:
    def __init__(self, name):
      self.name = name
    def infos(self):
      return '动物的名字：{0}'.format(self.name)

class Dog(Animal): # 指定父类Animal
    def __init__(self, name, age):
        super().__init__(name) # 调用父类构造方法
        self.age = age

# 实例化一个对象
dog = Dog('球球', 2)
print(dog.infos()) # 动物的名字：球球

def start(obj): # 接收的obj对象具有speak()方法
    obj.speak()

class Animal:
    def speak(self):
        print('动物叫...')
class Dog(Animal):
    def speak(self):
        print('狗：旺旺叫...')
class Cat(Animal):
    def speak(self):
        print('猫：喵喵叫...')
class Car:
    def speak(self):
        print('汽车：滴滴叫...')
# start()函数可以接收所有speak()方法对象
start(Dog()) # 狗：旺旺叫...
start(Cat()) # 猫：喵喵叫...
start(Car()) # 汽车：滴滴叫...

Traceback (most recent call last):
  File "test.py", line 1, in <module> # test.py文件第一行发生异常
    result = n / int(i)               # 发生异常的表达式
ZeroDivisionError: division by zero   # 异常信息描述,这里是除零异常 ZeroDivisionError

try
    <可能会引发异常的语句>
except [异常类型]:
    <处理异常>
finally:
    <释放资源>

i = input('请输入数字：')
n = 8888
try:
    result = n / int(i)
    print('{0}除以{1}等于{2}'.format(n,i,result))
except (ZeroDivisionError, ValueError) as e: # 多个except处理类似可以合并
    print('除0或无效数字异常：{}'.format(e))
except:
    print('其他异常...')
finally:
    print('释放资源...')

class myException(Exception): # 自定义异常类
    def __init__(self, message): # message是异常描述信息
        message = '自定义异常：'+ message
        super().__init__(message) # 把message传给父类构造方法

i = input('请输入数字：')
n = 8888
try:
    result = n / int(i)
    print('{0}除以{1}等于{2}'.format(n,i,result))
except ZeroDivisionError as e:
    raise myException('不能除以0')
except ValueError as e:
    raise myException('输入数字无效')

请输入数字：0
Traceback (most recent call last):
  File "<python-input-0>", line 9, in <module>
    result = n / int(i)
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
  File "<python-input-0>", line 12, in <module>
    raise myException('不能除以0')
myException: 自定义异常：不能除以0

import math
math.ceil(6.6)    # 7，向上取整
math.floor(6.6)   # 6，向下取整
math.pow(5,2)     # 25.0，5的2次幂
math.sqrt(9)      # 3.0，9的平方根
math.log(8, 2)    # 3.0，以2为底8的对数，若省略底默E为底计算自然对数
math.pi           # 3.141592653589793
math.degrees(0.5 * math.pi) # 90.0，弧度转换成角度
math.radians(90 / math.pi)  # 0.5，角度转换成弧度
math.sin(0.3)     # 0.29552020666133955

import datetime
datetime.datetime(2025,11,11)  # datetime.datetime(2025, 11, 11, 0, 0)
datetime.datetime.today()      # datetime.datetime(2025, 11, 11, 14, 29, 2, 955960)
datetime.datetime.now(tz=None) # datetime.datetime(2025, 11, 11, 14, 29, 2, 955960)

import datetime
datetime.date(2025,11,11) # datetime.date(2025, 11, 11)
datetime.date.today()     # datetime.date(2025, 11, 11)
datetime.date.fromtimestamp(1762842883) # datetime.date(2025, 11, 11)

import datetime
datetime.time(23,59,59,955960) # datetime.time(23, 59, 59, 955960)
datetime.timedelta(weeks=5)    # datetime.timedelta(days=35)

d = datetime.date.today()      # datetime.date(2025, 11, 11)
delta = datetime.timedelta(weeks=1) # datetime.timedelta(days=7)
d -= delta                     # datetime.date(2025, 11, 4)

d = datetime.datetime.today()       # datetime.datetime(2025, 11, 11, 15, 9, 45, 770088)
s = d.strftime('%Y-%m-%d %H:%M:%S') # '2025-11-11 15:09:45'
d2 = datetime.datetime.strptime(s, '%Y-%m-%d %H:%M:%S') # datetime.datetime(2025, 11, 11, 15, 9, 45)

m = re.match(r'\w+@test\.com', 'tony@test.com')
type(m)  # <class 're.Match'>
>>> m    # <re.Match object; span=(0, 13), match='tony@test.com'>
p = r'Java|java|JAVA'
text = 'I like Java and java and JAVA.'
m1 = re.search(p, text)
m2 = re.findall(p, text)
>>> m1    # <re.Match object; span=(7, 11), match='Java'>
>>> m2    # ['Java', 'java', 'JAVA']

with open('test.txt') as f:
    content = f.read()
    print(content)

# coding=utf-8
with open('test.txt', 'r', encoding='gbk') as f:
    lines = f.readlines()
    with open('copy.txt', 'w', encoding='utf-8') as copy_f:
        copy_f.writelines(lines)
        print('文本文件复制成功！')

# coding=utf-8
with open('test.png', 'rb') as f:
    b = f.read()
    with open('copy.png', 'wb') as copy_f:
        copy_f.write(b)
        print('二进制文件复制成功！')

import urllib.request
url='http://localhost:8080/test.do'
# 创建Request对象，默认GET请求
req1 = urllib.request.Request(url)
# 准备POST请求参数(字节序列)
params = urllib.parse.urlencode({'id':'10'}).encode()
# 创建Request对象，提供了data参数就是POST请求
req2 = urllib.request.Request(url, data=params)

import urllib.request
import json
url='http://localhost:8080/test.do'
# 创建Request对象，默认GET请求
req = urllib.request.Request(url)
with urllib.request.urlopen(req) as response:
    data = response.read()
    json_data = data.decode()
    print('JSON字符串:', json_data)
    py_dict = json.loads(json_data)
    for d_key,d_value in d.items():
        print('Python字典数据，key:{0},value:{1}'.format(d_key,d_value))

import mysql.connector
# 连接MySQL数据库
mydb = mysql.connector.connect(
  host="localhost", # 数据库主机地址
  user="test",      # 数据库用户名
  passwd="123456"   # 数据库密码
  database="test_db"
)
mycursor = mydb.cursor()
# 创建一个名为 test_db 的库
mycursor.execute("CREATE DATABASE test_db")
# 查看数据库
mycursor.execute("SHOW DATABASES")
# 创建一个名为 sites 的数据表
mycursor.execute("CREATE TABLE sites (name VARCHAR(255), url VARCHAR(255))")
# 查看数据表
mycursor.execute("SHOW TABLES")
# 创建一个主键，主键起始值为 1，逐步递增
mycursor.execute("ALTER TABLE sites ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY")
# 创建数据表时指定主键
mycursor.execute("CREATE TABLE sites (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), url VARCHAR(255))")
# 插入数据
sql = "INSERT INTO sites (name, url) VALUES (%s, %s)"
val = ("RUNOOB", "https://www.runoob.com")
mycursor.execute(sql, val)
mydb.commit() # 数据表内容有更新，必须使用到该语句
print("1 条记录已插入, ID:", mycursor.lastrowid)
# 批量插入
sql = "INSERT INTO sites (name, url) VALUES (%s, %s)"
val = [
  ('Google', 'https://www.google.com'),
  ('Github', 'https://www.github.com'),
  ('Taobao', 'https://www.taobao.com'),
  ('stackoverflow', 'https://www.stackoverflow.com/')
]
mycursor.executemany(sql, val)
mydb.commit()
print(mycursor.rowcount, "批量插入成功。")
# 查询数据
mycursor.execute("SELECT * FROM sites")
myresult = mycursor.fetchall()     # fetchall() 获取所有记录
# 查询数据-指定字段
mycursor.execute("SELECT name, url FROM sites")
myresult = mycursor.fetchall()     # 若 fetchone() 则只读取一条
# 删除记录
sql = "DELETE FROM sites WHERE name = 'stackoverflow'"
mycursor.execute(sql)
mydb.commit()
print(mycursor.rowcount, " 条记录删除")
# 更新数据
sql = "UPDATE sites SET name = %s WHERE name = %s"
val = ("Zhihu", "ZH")
mycursor.execute(sql, val)
mydb.commit()
print(mycursor.rowcount, " 条记录被修改")
# 删除表
sql = "DROP TABLE IF EXISTS sites"  # 删除数据表 sites
mycursor.execute(sql)

import threading
import time
# 线程体函数
def thread_run():
    t = threading.current_thread() # 当前线程对象
    for n in range(5):
        print('第{0}次执行线程{1}'.format(n, t.name)) # 当前线程名
        # 线程休眠（只有当前线程休眠，其他线程才有机会执行）
        time.sleep(2)
    print('线程{0}执行完成！'.format(t.name))
# 主线程
# 创建线程对象t1
t1 = threading.Thread(target=thread_run)
# 创建线程对象t2
t2 = threading.Thread(target=thread_run, name='MyThread')
# 启动线程t1
t1.start()
# 启动线程t2
t2.start()

第0次执行线程Thread-1 (thread_run)
第0次执行线程MyThread
第1次执行线程Thread-1 (thread_run)
第1次执行线程MyThread
第2次执行线程Thread-1 (thread_run)
第2次执行线程MyThread
第3次执行线程Thread-1 (thread_run)
第3次执行线程MyThread
第4次执行线程Thread-1 (thread_run)
第4次执行线程MyThread
线程Thread-1 (thread_run)执行完成！
线程MyThread执行完成！

import threading
import time
# 自定义线程类，继承Thread类
class SubThread(threading.Thread):
    def __init__(self, name=None):
        super().__init__(name=name)
    def run(self):
        t = threading.current_thread() # 当前线程对象
        for n in range(5):
            print('第{0}次执行线程{1}'.format(n, t.name)) # 当前线程名
            # 线程休眠（只有当前线程休眠，其他线程才有机会执行）
            time.sleep(2)
        print('线程{0}执行完成！'.format(t.name))
# 主线程
# 创建线程对象t1
t1 = SubThread()
# 创建线程对象t2
t2 = SubThread(name='MyThread')
# 启动线程t1
t1.start()
# 启动线程t2
t2.start()

第0次执行线程Thread-1
第0次执行线程MyThread
第1次执行线程MyThread
第1次执行线程Thread-1
第2次执行线程MyThread
第2次执行线程Thread-1
第3次执行线程MyThread
第3次执行线程Thread-1
第4次执行线程MyThread
第4次执行线程Thread-1
线程MyThread执行完成！
线程Thread-1执行完成！

import threading
import time

# 线程停止变量
isRunning = True

# 工作线程体函数
def workthread_run():
    while isRunning: # 死循环
        # 线程开始工作
        print('工作线程执行中...')
        # 线程休眠
        time.sleep(5) # 每5秒调用一次
    print('工作线程结束。')

# 控制线程体函数
def controlthread_run():
    global isRunning
    while isRunning: # 死循环
        # 从键盘输入停止指令exit
        command =input('请输入停止指令:')
        if command == 'exit':
            isRunning = False  # 修改停止变量
            print('控制线程结束。')

# 主线程
# 创建工作线程对象workthread
workthread =threading.Thread(target=workthread_run)
# 启动线程workthread
workthread.start()
# 创建控制线程对象controlthread
controlthread=threading.Thread(target=controlthread_run)
# 启动线程controlthread
controlthread.start()

工作线程执行中...
工作线程执行中...
工作线程执行中...
工作线程执行中...
exit
控制线程结束。
工作线程结束。

# 没有类型注解的代码
name = "Alice"
age = 30
is_student = False
scores = [95, 88, 91]
def greet(name):
    return f"Hello, {name}"

# 有类型注解的代码
name: str = "Alice"         # 注解为字符串 (str)
age: int = 30               # 注解为整数 (int)
is_student: bool = False    # 注解为布尔值 (bool)
scores: list = [95, 88, 91] # 注解为列表 (list)
def greet(name: str) -> str: # 有类型注解的函数,参数和返回值都是字符串
    return f"Hello, {name}"

from typing import List, Dict, Tuple, Set, Optional, Union

# List[int] 表示这是一个只包含整数的列表
numbers: List[int] = [1, 2, 3, 4, 5]
# Dict[str, int] 表示这是一个键为字符串、值为整数的字典
student_scores: Dict[str, int] = {"Alice": 95, "Bob": 88}
# Tuple[int, str, bool] 表示这是一个包含整数、字符串、布尔值的元组
person_info: Tuple[int, str, bool] = (25, "Alice", True)
# Set[str] 表示这是一个只包含字符串的集合
unique_names: Set[str] = {"Alice", "Bob", "Charlie"}
# 可选类型 Optional[str] 等价于 Union[str, None] 字符串或None
name: Optional[str] = "Alice"
# 联合类型 Union 当值可能是多种类型之一时使用 
def process_input(data: Union[str, int, List[int]]) -> None:
    """处理可能是字符串、整数或整数列表的输入"""
    if isinstance(data, str):
        print(f"字符串: {data}")
    elif isinstance(data, int):
        print(f"整数: {data}")
    elif isinstance(data, list):
        print(f"列表: {data}")
process_input("hello")    # 输出：字符串: hello
process_input(42)         # 输出：整数: 42  
process_input([1, 2, 3])  # 输出：列表: [1, 2, 3]