Python基本运算
Python标识符
合法的标识符定义规则，同C语言。
1 标识符只能由字母（包括大小写）、数字和下划线（
_）组成。
2 标识符的第一个字符不能是数字
3 标识符不能与python的关键字冲突
4 标识符是区分大小写的
Python数据类型
数据类型转换：int() 、float()、str()、list()
Python运算符及优先级
基本运算：+, -, *, /,%, //,**
比较运算：>, <, ==, >=, <=, !=
逻辑运算：and, or, not
常见数据结构
列表list: 可变，有序
字符串string：不可变，有序
元组tuple：不可变，有序
字典dictionary：可变，无序
集合set：可变、不可变两种，无序
列表
1 增、删、改、查
增
append()：在list的最后加入一个元素
ls=['1','2','3']
ls.append('4')
print(ls)#['1', '2', '3', '4'] extend()：在list的最后加入一个列表
ls=['1','2','3']
ls.extend(['2','3'])
print(ls)#['1', '2', '3', '2', '3'] insert()：在list的某个位置加入一个元素
ls=['1','2','3']
ls.insert(0,'2')
print(ls)#['2', '1', '2', '3']
ls.insert(1,['2','3'])
print(ls)#['2', ['2', '3'], '1', '2', '3']删
remove()：删除list中的特定元素
ls=['1','2','3']
ls.remove('2')
print(ls)#['1', '3']pop()：移除list最后一个元素
ls=['1','2','3']
ls.pop(1)
print(ls)#['1', '3']
ls.pop()
print(ls)#['1']
改
ls=['1','2','3']
ls[1]='6'
print(ls)#['1', '6', '3']查
index()：查询某元素的在列表中的位置（索引）
ls=['1','2','3']
print(ls.index('3'))#2count(x) : 计算元素x在列表中的出现的次数
ls=['1','2','3','2']
print(ls.count('2'))#2切片
ls[:2] 是一个列表（或其他可切片对象）的切片操作，它表示从列表的开头（索引为0）开始，直到（但不包括）索引为2的元素。
ls[1:3] 会从列表 ls 中取出索引为 1 的元素，直达但不包括索引为3的元素
[start:stop:step] 开始索引start、结束索引stop和步长step。当步长step为正数时，切片从start开始向右进行；当步长step为负数时，切片从start开始向左进行。
ls=['1','2','3','2']
print(ls[1:3])#['2', '3']
print(ls[1:5:2])#['2', '2']
print(ls[:3])#['1', '2', '3']
print(ls[::2])#['1', '3']
print(ls[::-2])#反向['2', '2']
print(ls[-2::2])#从倒数第二个开始['3']
print(ls[2::-2])#反向['3', '1']索引
ls=['1','2','3','2']
print(ls[2][0])#3len、sum、max、min函数
ls=['1','2','3','2']
print(len(ls))#4
print(max(ls))#3
ls=[1,2,3,4]
print(sum(ls))#10
print(min(ls))#1排序
sort() / sorted() 顺序
reverse() / reversed() / sort() / [::-1] 反转 / 倒序
ls=['1','2','3','2']
ls.sort()
print(ls)#['1', '2', '2', '3']
ls.reverse()
print(ls)#['3', '2', '2', '1']
print(sorted(ls))#不改变原来的值['1', '2', '2', '3']
a=reversed(ls)#本身是一个迭代器
for i in a:
print(i,end='')#1223
print(ls)#['3', '2', '2', '1']
print(ls[::-1])#['1', '2', '2', '3']lambda函数排序
# 原始列表
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 使用lambda函数和sorted()函数按照字符串长度进行排序
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)
# 输出: ['date', 'apple', 'cherry', 'banana', 'elderberry']
ls=[1,21,3111,1]
ls.sort(reverse=True)
print(ls)#[3111, 21, 1, 1]# 包含字典的列表
students = [
{'name': 'Alice', 'age': 20},
{'name': 'Bob', 'age': 18},
{'name': 'Charlie', 'age': 22},
]
# 使用lambda函数和sorted()函数按照年龄进行排序
sorted_students = sorted(students, key=lambda x: x['age'])
print(sorted_students)
# 输出: [{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 22}]去重set
ls=[1,21,3111,21,1]
print(set(ls))#[3111, 21, 1, 1]#不是list形式{1, 21, 3111}列表 --> 字符串：join()
字符串 --> 列表：split()
ls=['1','21','3111','21','1']
l='nnn'.join(ls)
print(l)#1nnn21nnn3111nnn21nnn1
print(l.split('nnn'))#['1', '21', '3111', '21', '1']
#注意l的位置列表加法/乘法
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2
list4=list1*2
print(list3) # 输出: [1, 2, 3, 4, 5, 6]
print(list4) # [1, 2, 3, 1, 2, 3]列表解析式
a=[x**2 for x in range(10)if x%2==0]
print(a)#[0, 4, 16, 36, 64]ls=[[1,2],[1,4],[4,2]]
ls.sort(key=lambda x:x[-1])#取最后第1位
print(ls)#[[1, 2], [4, 2], [1, 4]]字符串
字符串是一种不可变的序列
单引号/双引号/三引号
-
单引号（
'）和双引号（"）：- 两者在定义字符串时是完全等效的。
- 选择使用哪一个主要取决于个人偏好或字符串内容。
- 如果字符串中包含一个引号，并且你想避免使用转义字符（
\），那么你可以选择另一种引号来定义字符串。
s4 = "She said, 'Hello, World!'" # 注意，内部的单引号不需要转义
print(s4)#She said, 'Hello, World!'-
三引号（
'''或"""）：- 三引号通常用于定义多行字符串或文档字符串（docstring）。
- 使用三引号，你可以在不使用任何换行符或转义字符的情况下，直接定义多行字符串。
- 文档字符串通常用于解释函数、模块或类的目的和行为。
s5 = '''这是一个 多行字符串 使用三引号定义''' s6='这是一个\n多行字符串' print(s5) # 这是一个 # 多行字符串 # 使用三引号定义 print(s6)#这是一个 #多行字符串 '''这还可以拿来当注释'''
字符串合并、重复、索引、切片
s1 = "Hello"
s2 = "World"
s3 = s1 + " " + s2 # 使用加号拼接字符串
print(s3) # 输出: Hello World
print(s1*3)#HelloHelloHello
print(s1[0])#H
print(s1[1:3])#el
print(s1[::-2])#olH
print(s1[-1:-2:])#默认向右，所以为空字符串转化：
数字转换成字符串：str(20)
字符串转换成数字：int('32'),float('1.2'),不允许int('3.2")
大小写字母转换，包括首字母、标题
capitalize()：将首字母大写，其余均为小写
title():将单词首字母大写，其余均为小写
lower(): 所有字母变为小写
upper():所有字母变为大写
swapcase(): 大小写互换
s = "hello world"
uppercase_s = s.upper()
print(uppercase_s) # 输出: HELLO WORLD
s = "HELLO WORLD"
lowercase_s = s.lower()
print(lowercase_s) # 输出: hello world
s = "Hello World"
if s.isupper():
print("字符串已经是大写")
else:
s = s.upper()
print("转换为大写:", s) # 输出: 转换为大写: HELLO WORLD字符串格式化
"%3.4f"%(1.2)
print("%2.3f"%(2.3))#2.300
print("%6.f"%(3.2)) # 3不输出小数部分
print("%6f"%(4)) #4.000000format
字符串拆分和组合
split、join
ls=['1','21','3111','21','1']
l='nnn'.join(ls)
print(l)#1nnn21nnn3111nnn21nnn1
print(l.split('nnn'))#['1', '21', '3111', '21', '1']
#注意l的位置其他方法
find、index、count、strip
find() 方法用于查找子串在主字符串中首次出现的位置（索引），如果未找到则返回 -1。
s = "Hello, world!"
index = s.find("world") # 查找 "world" 的位置
print(index) # 输出: 7
index = s.find("python") # 查找 "python" 的位置，但不存在
print(index) # 输出: -1index() 方法与 find() 类似，也是用于查找子串在主字符串中首次出现的位置（索引）。但是，如果子串不存在，index() 会抛出一个 ValueError 异常，而 find() 会返回 -1。
s = "Hello, world!"
index = s.index("world") # 查找 "world" 的位置
print(index) # 输出: 7
# 尝试查找不存在的子串会抛出 ValueError
index = s.index("python") # 这会抛出一个 ValueErrorcount() 方法用于计算子串在主字符串中出现的次数。
s = "Hello, world! Hello, everyone!"
count = s.count("Hello") # 计算 "Hello" 出现的次数
print(count) # 输出: 2strip() 方法用于移除字符串开头和结尾的指定字符（默认为空格）。它不会修改原始字符串，而是返回一个新的字符串。
s = " Hello, world! "
stripped_s = s.strip() # 移除开头和结尾的空格
print(stripped_s) # 输出: "Hello, world!"
# 也可以指定要移除的字符
s = "---Hello, world!---"
stripped_s = s.strip('-') # 移除开头和结尾的 '-'
print(stripped_s) # 输出: "Hello, world!"数据结构
元组
元组在输出时总是有括号的
元组在输入时可以没有括号
像字符串一样，元组是不可变的
索引、切片以及一些方法很多与列表相似
courses = ('History', 'Math', 'Physics')
print(courses)
courses[0] = 'Art' # ❌错误: 元组内元素为只读，不可更改
print(courses)
字典
键（key)与值（value)
√关键字（键值）必须是不可变类型，如不能用列表作为关键字
√关键字必须互不相同
字典元素索引方法
student = {'name': 'John', 'age': 25, 'courses': ['Math', 'CompSci']}
# get方法可以使得在字典中缺少要查询的值时显示出默认或自定义的结果，而不是抛出异常
# 括号内第二个参数为自定义默认输出内容
print(student.get('name'))
print(student.get('phone', 'Sorry. Not Found~'))
# ------------------------
# 添加
student['phone'] = '199-8011-8011'
# 更新
student['name'] = 'Jane'
print(student)
# ------------------------
# 使用update可以一次更新多个值！！！
student.update({'name': 'Silk', 'age': 100, 'phone': '188-0525-7633'})
print(student)
# ------------------------
# 删除 方法一：使用del
del student['age']
# 删除 方法二：使用pop
# pop会删除该值，但也会同时返回删除的值，需用变量来接收
age = student.pop('age')
print(student)
print(age)
# ------------------------
# 查看长度
print(len(student))
# 查看键
print(student.keys())
# 查看值
print(student.values())
# 成对展现键与值
print(student.items())
重点
# 以键循环
for key in student:
print(key)
# 键、值循环
for key, value in student.items():
print(key, value)
集合
集合set的交&、并|、差一、对称差^等运算
去重：把一个列表变成集合，就自动去重了
关系测试：测试两组数据之间的交集、差集、并集等关系
cs_courses = {'History', 'Math', 'Physics', 'CompSci'}
art_courses = {'History', 'Math', 'Art', 'Design'}
# 交集（共有的元素）
print(cs_courses.intersection(art_courses))
# 不同（独有的元素）
print(cs_courses.difference(art_courses))
# 并集（所有的元素）
print(cs_courses.union(art_courses))a={"peace","peace","rong","rong","nick"}
print("a:",a)
b=set(["peace","peace","rong","rong"])
print("b:",b)
print("并集：",a|b)#演示联合
print("交集：",a&b)#演示交
print("差集：",a-b)#演示差
print("对称差：",a^b)#对称差集 交集减去并集
# a: {'nick', 'rong', 'peace'}
# b: {'peace', 'rong'}
# 并集： {'nick', 'rong', 'peace'}
# 交集： {'peace', 'rong'}
# 差集： {'nick'}
# 对称差： {'nick'}控制结构
条件控制
在Python中，与大多数程序设计语言一样，整数0代表假，1代表真。不过，除此之外，Python也把任意的空数据结构视为假。
更一般的，真和假的概念是Python中每个对象的固有属性：每个对象不是真就是假
if <test1>:
<statements1>
elif <test2>:
<statements2>
else:
<statements3>
数字如果非零，则为True
对象如果非空，则为True
数字零、空对象以及特殊对象None都被认作是假
比较和相等测试会返回True或False
在python中，布尔运算 and 和 or 会返回True或False的操作对象
使用 and 运算符：
由于 and 运算符在遇到第一个假值时停止评估，因此它通常不会返回假值对象本身（除非它是表达式中唯一的元素）。但是，如果所有值都是真值，它将返回最后一个评估的对象。
使用 or 运算符：
or 运算符在遇到第一个真值时停止评估，并返回该真值对象。
result = 1 and 2 # result 是 2，因为两个值都是真值
result = 0 and "foo" # result 是 0，因为 0 是假值，所以不会评估 "foo"
result = 0 or "foo" # result 是 "foo"，因为 0 是假值，所以评估 "foo" 并返回它
result = "bar" or "foo" # result 是 "bar"，因为 "bar" 是真值，所以不会评估 "foo"三元运算
x=1
A = 2 if x==1 else 4 #相当于c语言的x=1?A=2:A=4
print(A)#2
循环控制
while循环
while <test>: #Loop test
<statements1> #Loop body
else: #Optional else
<statements2> #只有当循环正常离开（此时测试条件为假）时才会执行，如果循环被break语句中断，则else块不会执行。
for循环
for <target> in <object>:#Assign object items to target
<statements> #Repeated loop body:use target
else:
<statements> #如果循环被break语句中断，则else块不会执行。
√注意：range、enumerate、zip等函数在for循环中的运用
#range
# range() 函数返回一个不可变的序列类型，通常用于在 for 循环中生成一个数字序列。
# 你也可以指定 range() 的起始值、终止值和步长：
for i in range(5): # 生成0到4的整数序列
print(i) #0-4
for i in range(1, 6, 2): # 生成1到5（不包括5）的奇数序列，步长为2
print(i) #135my_set = {x for x in range(5) if x % 2 == 0} # 创建包含0到4之间偶数的集合
my_dict = {x: x**2 for x in range(5)} # 创建字典，键为0到4，值为其平方
#enumerate
# enumerate() 函数将一个可遍历的数据对象
# （如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
i = ['1','am','hello']
for index,season in enumerate(i):
print(f'season {index+1}:{season}')
# season 1:1
# season 2:am
# season 3:hello# zip()
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组
# 然后返回由这些元组组成的对象。
a=[1,2,3]
b=[2,2,3]
for n in zip(a,b):
print(n)
# (1, 2)
# (2, 2)
# (3, 3)
i1=[1,2,3]
i2=['python','必定','过']
for y1,y2 in zip(i1,i2):
print(f'{y1}:{y2}')
# 1:python
# 2:必定
# 3:过# map
# 函数将一个函数应用于一个或多个可迭代对象的每个元素，并返回一个迭代器
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers) # 使用lambda函数进行平方运算
for square in squared:
print(square) # 打印出每个数的平方
# filter
# 函数用于过滤可迭代对象中的元素，它接受一个函数和一个可迭代对象作为参数
# 并返回一个迭代器，其中只包含使函数返回True的元素。
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = filter(lambda x: x % 2 == 0, numbers) # 过滤出偶数
for number in even_numbers:
print(number) # 打印出偶数#iter
my_list = [1, 2, 3]
my_iter = iter(my_list) # 获取列表的迭代器
print(next(my_iter)) # 打印出列表的第一个元素
print(next(my_iter)) # 输出: 2 break、continue、pass
break语句会立即退出当前循环，不会执行else块的内容。
continue语句会忽略后面的语句，强制进入下一次循环。
pass不做任何事情
except-try语句
while 1:
name=input("Enter name:")
if name=='stop':
break
age=input("Enter age:")
try:
print('Hello', name, '=> ',int(age))
except:#在不输入任何值时进入异常处理
print('Please input correct age!')
列表解析与生成器表达式
[x for x in range(10) if x%2==0]
(x for x in range(10) if x%2==0)
列表解析
[expression for item in iterable if condition]# 创建一个包含列表中所有偶数平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出: [0, 4, 16, 36, 64]生成器表达
(expression for item in iterable if condition)# 创建一个生成器，它生成0到9的平方
squares_gen = (x**2 for x in range(10))
print(list(squares_gen)) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares_gen) # 输出: <generator object <genexpr> at 0x...>
# 要查看生成器的内容，你可以将其转换为列表或迭代它
print(list(squares_gen)) # 注意：由于squares_gen已经被迭代过一次，这里将输出空列表[]
# 创建一个新的生成器来生成偶数的平方
even_squares_gen = (x**2 for x in range(10) if x % 2 == 0)
for square in even_squares_gen:
print(square) # 输出: 0, 4, 16, 36, 64函数
函数概念及def定义
def function_name([arg1],[arg2],…):
[expression]
return [value]
def numcmp(a,b):
if a>b: return 1
elif a==b: return 0
else: return -1
print(numcmp(8,9),numcmp(12,1),numcmp(23,23))#-1 1 0
print(numcmp(a=13,b=78))# -1函数参数的几种形式
1 f(x1,x2,...)
2 f(x1,x2=value,...):提供默认值
√注：以上两种是有多少个形参，调用时就传多少个实参，然而有时 需要可变个形参，怎么办？【
3 可变位置参数 (f(*args))
- 使用
*args可以接收任意数量的位置参数，这些参数会被组织成一个元组。这样，函数可以接受不确定数量的位置参数。
f(*x):
√加*表示参数个数不确定，可以0个或n个，不管多少个，参数值都存 放在名为x的元组中
可变关键字参数 (f(**kwargs))
- 使用
**kwargs可以接收任意数量的关键字参数，这些参数会被组织成一个字典。这样，函数可以接受不确定数量的关键字参数。
4 f(**x):
√加**也表示参数个数不确定，参数值存放在名为x的字典中
以上多种参数定义方式的混合
*a表示位置参数，它不接受关键字名称
def test(x,y=1,*a,**b):
print(x,y,a,b)
test(1) # 1 1 () {}
test(1,2) # 1 2 () {}
test(1,2,3,4) # 1 2 (3, 4) {}
test(x=1,y=2) # 1 2 () {}
test(1,a=2) # 1 1 () {'a': 2} *a不能通过a=?的形式传递
test(1,a=(1,2)) #1 1 () {'a': (1, 2)}
test(1,2,3,a=4) # 1 2 (3,) {'a': 4}
test(1,2,3,c=4) # 1 2 (3,) {'c': 4}
test(1,2,3,y=4) #TypeError: test() got multiple values for argument 'y'
#y不能取多个值
函数调用
在调用函数时，默认参数不被传递实参，就使用默认值。
lambda函数
lambda是一个表达式，而def是一个语句
lambda函数的应用
排序：多维数据，排序以谁为准？
# 假设我们有一个字典列表，我们想要根据字典中 'age' 的值进行排序
data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 20}, {'name': 'Charlie', 'age': 23}]
sorted_data = sorted(data, key=lambda item: item['age'])
print(sorted_data)
#[{'name': 'Bob', 'age': 20}, {'name': 'Charlie', 'age': 23}, {'name': 'Alice', 'age': 25}]map、reduce、filter等函数
map 函数将一个函数应用于一个或多个可迭代对象的所有项，并返回一个迭代器，其中包含应用函数后的结果。
# 使用 lambda 函数将列表中的每个元素乘以 2
numbers = [1, 2, 3, 4, 5]
n = map(lambda x:x*2,numbers)
print(list(n)) #输出：[2, 4, 6, 8, 10]
i = [1,2,3]
sum = map(lambda x,y:x+y,i,numbers)
print(list(sum)) #输出：[2, 4, 6]reduce函数对一个序列的项进行累积操作，通常与 lambda 函数一起使用来定义累积操作。注意，reduce() 函数在 Python 3 中位于 functools 模块中。
from functools import reduce
# 使用 lambda 函数计算列表中所有数字的和
numbers = [1, 2, 3, 4, 5]
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers) # 输出: 15
#等价
def add(x,y):
return x+y
sum_add = reduce(add,numbers)
print(sum_add) # 输出: 15def add(x,y):
return x+y
print(reduce(add,"python","pass")) #passpython
print(list(map(add,"python","pass"))) #['pp', 'ya', 'ts', 'hs']filter函数函数使用指定的函数过滤序列，返回由指定函数判断为 True 的元素组成的迭代器。Lambda 函数再次提供了一个简洁的方式来定义这个判断函数。
x = filter(lambda x : not[ x%i for i in range(2,x) if x%i==0],range(3,20))
print(list(x)) #[3, 5, 7, 11, 13, 17, 19]
print([ 6%i for i in range(2,6) if 6%i==0])#[0,0] 有值就是true 否则false
模块、包
模块的含义
python模块一般对应于一个程序源文件（'py'源文件）
利用import导入模块，以及导入的几种方式
import modname 或 import modname as mn
● from modname import funcname
● from modname import *
常见的几个标准模块
math:sqrt、sin、cos、exp、log等函数
import math ----math.sqrt()
from marh import * ---sqrt()
sqrt(x): 计算平方根。sin(x): 计算正弦值，x 以弧度为单位。cos(x): 计算余弦值，x 以弧度为单位。exp(x): 计算 e 的 x 次幂。log(x,base): 计算以 base 为底 x 的对数。如果 base 未给出，则默认为 e。
random: random, randint, uniform, choice, shuffle等函数
import random
-
random(): 返回 [0.0, 1.0) 范围内的随机浮点数。randint(a, b): 返回 [a, b] 范围内的随机整数。uniform(a, b): 返回 [a, b] 范围内的随机浮点数。choice(seq): 从非空序列中随机选择并返回一个元素。shuffle(list): 将列表中的元素随机排序。
string
OS
-
os.path.basename(path): 返回路径中的文件名import os path = "/home/user/documents/file.txt" print(os.path.basename(path)) # 输出: file.txt -
os.path.dirname(path): 返回路径中的目录名。import os path = "/home/user/documents/file.txt" print(os.path.dirname(path)) # 输出: /home/user/documents -
os.path.split(path): 将路径分割为目录名和文件名，并返回一个元组。import os path = "/home/user/documents/file.txt" print(os.path.split(path)) # 输出: ('/home/user/documents', 'file.txt') -
os.path.splitdrive(path): 将路径分割为驱动器/挂载点和路径的其他部分（在非 Windows 系统中，通常返回空字符串作为驱动器部分）。import os path = "C:\\Users\\user\\documents\\file.txt" # Windows 路径 print(os.path.splitdrive(path)) # 输出: ('C:', '\\Users\\user\\documents\\file.txt') -
os.path.join(path, *paths): 将多个路径组件连接成一个。注意您提到的os.path.join0是不正确的，应该是os.path.join。import os print(os.path.join("/home", "user", "documents", "file.txt")) # 输出: /home/user/documents/file.txt -
os.path.exists(path): 检查指定路径是否存在。 -
os.path.isabs(path): 检查路径是否为绝对路径。 -
os.path.isdir(path): 检查指定路径是否存在且是一个目录。 -
os.path.isfile(path): 检查指定路径是否存在且是一个文件。
sys
-
命令行参数：
sys.argv是一个列表，包含命令行参数。sys.argv[0]是脚本的名字（当脚本作为主程序运行时），而sys.argv[1:]是任何额外的命令行参数。
python复制代码import sysprint('脚本名：', sys.argv[0])print('命令行参数：', sys.argv[1:]) -
退出程序：
sys.exit([status])用于退出 Python 程序。如果提供了一个可选的状态码（通常是整数），那么它将返回给操作系统。通常，0表示成功，而非零值表示出现了某种错误。
python复制代码import sysif some_error_condition:sys.exit(1) # 非零状态码表示出现错误 -
获取 Python 解释器信息：
sys.version返回一个字符串，表示 Python 解释器的版本信息。sys.version_info返回一个命名元组，提供 Python 解释器的版本信息的详细信息（主版本号、次版本号、微版本号等）。
python复制代码import sysprint('Python 版本：', sys.version)print('Python 版本信息：', sys.version_info) -
获取 Python 解释器的路径：
sys.executable返回 Python 解释器的绝对路径。
python复制代码import sysprint('Python 解释器路径：', sys.executable) -
设置/获取递归深度限制：
sys.setrecursionlimit(limit)用于设置 Python 解释器的最大递归深度。sys.getrecursionlimit()返回当前的最大递归深度。
python复制代码import sysprint('当前递归深度限制：', sys.getrecursionlimit())sys.setrecursionlimit(10000) # 设置新的递归深度限制 -
标准输入输出重定向：
sys.stdin、sys.stdout和sys.stderr分别表示标准输入、标准输出和标准错误输出流。你可以重定向它们来改变程序的输入/输出行为。
time
re 正则表达式
类的继承与派生
文件处理
读文件
打开文件
√ open("filename")或open("filename",'r')返回一个文件对象
读取数据方法
√read0:读取全部字符，返回一个字符串
√readline():读取一行，返回一个字符串
√readlines():读取所有行，返回字符串列表
写文件
打开文件
√ open('filename','w')创建新文件，并只允许写
√open(filename','a’)在已经存在的文件中追加内容
写数据
write(all_text)
writelines(list)
with语句
||
对象
对象的概念
一种数据结构，封装了属性和方法
Python从设计之初就是面向对象的一门语言
类
一种数据结构，封装了数据和方法
类的定义：关键字class
class Animal:
# 数据属性（类变量）
species = "Animal"
# 初始化方法（构造函数），用于设置实例属性
def __init__(self, name, age):
self.name = name # 实例属性
self.age = age # 实例属性
# 方法属性（实例方法）
def speak(self):
print(f"{self.name} says something generic.")
# 类方法（使用@classmethod装饰器）
@classmethod
def get_species(cls):
return cls.species
# 静态方法（使用@staticmethod装饰器）
@staticmethod
def is_alive():
return True类的实例化：实例对象
√数据属性
√方法属性
# 类的实例化
my_animal = Animal("Dog", 5)
# 访问数据属性
print(my_animal.name) # 输出: Dog
print(my_animal.age) # 输出: 5
# 访问类变量（数据属性）
print(Animal.species) # 输出: Animal
# 访问方法属性
my_animal.speak() # 输出: Dog says something generic.
# 调用类方法
print(Animal.get_species()) # 输出: Animal
# 调用静态方法
print(Animal.is_alive()) # 输出: True类的继承
class Dog(Animal):
# 覆盖父类的数据属性（如果有同名属性）
species = "Dog"
# 覆盖父类的初始化方法
def __init__(self, name, age, breed):
super().__init__(name, age) # 调用父类的初始化方法
self.breed = breed # 添加额外的实例属性
# 覆盖父类的方法
def speak(self):
print(f"{self.name} barks.")
# 实例化子类
my_dog = Dog("Buddy", 3, "Labrador")
# 访问数据属性
print(my_dog.name) # 输出: Buddy
print(my_dog.age) # 输出: 3
print(my_dog.breed) # 输出: Labrador
# 访问类变量（这里覆盖了父类的类变量）
print(Dog.species) # 输出: Dog
# 访问方法属性
my_dog.speak() # 输出: Buddy barks.
# 调用父类的方法（如果子类没有覆盖）
# 这里speak方法被覆盖了，但get_species和is_alive方法仍然可以调用
print(my_dog.get_species()) # 输出: Dog（注意这里子类覆盖了类变量，所以输出是Dog）
print(my_dog.is_alive()) # 输出: True面向对象编程：
数据与方法结合在一起，用对象的方式组织程序
python数据科学工具
导入方式：import numpy as np
数组创建与索引
数组的创建： ndarray对象的创建
利用np.array() 传递Python的序列对象创建数组
import numpy as np
# 列表转数组
list_data = [1, 2, 3, 4, 5]
array_from_list = np.array(list_data)
print("从列表创建的数组:", array_from_list)
# 元组转数组
tuple_data = (10, 20, 30, 40)
array_from_tuple = np.array(tuple_data)
print("从元组创建的数组:", array_from_tuple)由常见的arange、linspace、logspace等函数创建数组
# 使用arange创建数组
array_arange = np.arange(0, 10, 2) # 从0开始，到10（不包括），步长为2
print("arange创建的数组:", array_arange)
# 使用linspace创建数组
array_linspace = np.linspace(0, 1, 5) # 从0开始，到1结束，总共5个点
print("linspace创建的数组:", array_linspace)
# 使用logspace创建数组
array_logspace = np.logspace(0, 2, 3, base=10) # 从10^0开始，到10^2结束，总共3个点，底数为10
print("logspace创建的数组:", array_logspace)
# arange创建的数组: [0 2 4 6 8]
# linspace创建的数组: [0. 0.25 0.5 0.75 1. ]
# logspace创建的数组: [ 1. 10. 100.]创建特定数组： zeros()、ones()、identity()、empty()、 diag()
# 使用zeros创建全零数组
array_zeros = np.zeros((3, 3)) # 创建一个3x3的全零数组
print("全零数组:", array_zeros)
# 使用ones创建全一数组
array_ones = np.ones((2, 2)) # 创建一个2x2的全一数组
print("全一数组:", array_ones)
# 使用identity创建单位矩阵（对角线上为1，其余为0）
array_identity = np.identity(3) # 创建一个3x3的单位矩阵
print("单位矩阵:", array_identity)
# 使用empty创建未初始化的数组（内容可能是随机的）
array_empty = np.empty((2, 2))
print("未初始化的数组:", array_empty)
# 使用diag创建对角矩阵
array_diag = np.diag([1, 2, 3]) # 创建一个对角线上为[1, 2, 3]的对角矩阵
print("对角矩阵:", array_diag)
# 全零数组:
# [[0. 0. 0.]
# [0. 0. 0.]
# [0. 0. 0.]]
# 全一数组:
# [[1. 1.]
# [1. 1.]]
# 单位矩阵:
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
# 未初始化的数组:
# [[1. 1.]
# [1. 1.]]
# 对角矩阵:
# [[1 0 0]
# [0 2 0]
# [0 0 3]]一维数组和多维数组
数组元素的访问：下标或切片、整数序列、布尔数组
import numpy as np
# 创建一维数组
array_1d = np.array([1, 2, 3, 4, 5])
print("一维数组:", array_1d)
# 访问元素（下标）
print("访问第一个元素:", array_1d[0])
print("访问最后一个元素:", array_1d[-1])
# 切片
print("切片（获取第2到第4个元素，不包括第5个）:", array_1d[1:4])
# 使用整数序列访问
print("使用整数序列访问（获取第1和第4个元素）:", array_1d[[0, 3]])
# 使用布尔数组访问
bool_indices = np.array([True, False, True, False, True])
print("使用布尔数组访问:", array_1d[bool_indices])
# 一维数组: [1 2 3 4 5]
# 访问第一个元素: 1
# 访问最后一个元素: 5
# 切片（获取第2到第4个元素，不包括第5个）: [2 3 4]
# 使用整数序列访问（获取第1和第4个元素）: [1 4]
# 使用布尔数组访问: [1 3 5]多维数组的axis参数
# 创建二维数组（多维数组）
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("二维数组:", array_2d)
# 访问元素（下标）
print("访问第一行第二列的元素:", array_2d[0, 1])
# 切片
print("切片（获取前两行前两列）:", array_2d[:2, :2])
# 使用axis参数（示例：沿着第一轴（行）求和）
print("沿着第一轴（行）求和:", np.sum(array_2d, axis=0))
print("沿着第二轴（列）求和:", np.sum(array_2d, axis=1))
# 二维数组: [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 访问第一行第二列的元素: 2
# 切片（获取前两行前两列）: [[1 2]
# [4 5]]
# 沿着第一轴（行）求和: [12 15 18]
# 沿着第二轴（列）求和: [ 6 15 24]数组的ufunc运算
加+、减-、乘*、除/、幂**
三角函数：
np.sin()、np.cos()、np.sqrt()、np.exp()、np.log()等
import numpy as np
# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# ufunc运算
print("加法:", a + b)
print("减法:", a - b)
print("乘法:", a * b)
print("除法:", a / b)
print("幂运算:", a ** 2) # 注意这里是对a的幂运算，不是a和b之间的
# 三角函数等
print("np.sin(a):", np.sin(a))
print("np.cos(a):", np.cos(a))
print("np.sqrt(a):", np.sqrt(a))
print("np.exp(a):", np.exp(a))
print("np.log(a):", np.log(a))
# 加法: [5 7 9]
# 减法: [-3 -3 -3]
# 乘法: [ 4 10 18]
# 除法: [0.25 0.4 0.5 ]
# 幂运算: [1 4 9]
# np.sin(a): [0.84147098 0.90929743 0.14112001]
# np.cos(a): [ 0.54030231 -0.41614684 -0.9899925 ]
# np.sqrt(a): [1. 1.41421356 1.73205081]
# np.exp(a): [ 2.71828183 7.3890561 20.08553692]
# np.log(a): [0. 0.69314718 1.09861229]统计函数：
np.sum()、np.max()、np.min()、np.mean()、np.std()等
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 统计函数
print("总和:", np.sum(array_2d))
print("最大值:", np.max(array_2d))
print("最小值:", np.min(array_2d))
print("平均值:", np.mean(array_2d))
print("标准差:", np.std(array_2d))
# 使用axis参数
print("沿着第一轴（行）的最大值:", np.max(array_2d, axis=0))
print("沿着第二轴（列）的最小值:", np.min(array_2d, axis=1))
# 总和: 45
# 最大值: 9
# 最小值: 1
# 平均值: 5.0
# 标准差: 2.581988897471611
# 沿着第一轴（行）的最大值: [7 8 9]
# 沿着第二轴（列）的最小值: [1 4 7]特别关注axis参数
向量与矩阵运算
向量表示为一维数组，矩阵表示为二维数组
numpy
向量内积：np.dot(x1,x2)
a · b = |a| × |b| × cos(θ)= a1 × b1 + a2 × b2 + ... + an × bn
import numpy as np
# 定义两个向量
x1 = np.array([1, 2, 3])
x2 = np.array([4, 5, 6])
# 计算向量内积
dot_product = np.dot(x1, x2)
print("向量内积:", dot_product) # 输出: 32基本矩阵运算（+，-，*，/，//和**，以及矩阵乘积@）
import numpy as np
# 定义两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# 矩阵加法
C_add = A + B
print("矩阵加法:")
print(C_add)
# 矩阵减法
C_sub = A - B
print("矩阵减法:")
print(C_sub)
# 矩阵乘法（元素级）
C_mul = A * B
print("矩阵乘法（元素级）:")
print(C_mul)
# 矩阵除法（元素级）
C_div = A / B
print("矩阵除法（元素级）:")
print(C_div)
# 注意：整数除法 `//` 在矩阵中不常用，因为结果通常是向下取整，不适用于浮点数
# 矩阵幂运算（不是矩阵乘法，而是元素级的幂运算）
C_pow = A ** 2
print("矩阵幂运算（元素级）:")
print(C_pow)
# 矩阵乘法
C_matmul = A @ B
print("矩阵乘法:")
print(C_matmul)
# 矩阵加法:
# [[ 6 8]
# [10 12]]
# 矩阵减法:
# [[-4 -4]
# [-4 -4]]
# 矩阵乘法（元素级）:
# [[ 5 12]
# [21 32]]
# 矩阵除法（元素级）:
# [[0.2 0.33333333]
# [0.42857143 0.5 ]]
# 矩阵幂运算（元素级）:
# [[ 1 4]
# [ 9 16]]
# 矩阵乘法:
# [[19 22]
# [43 50]]矩阵的转置(a.T)
A_transpose = A.T
print("矩阵A的转置:")
print(A_transpose)
# 矩阵A的转置:
# [[1 3]
# [2 4]]数据排序np.sort
import numpy as np
# 对一维数组排序
vector = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
sorted_vector = np.sort(vector)
print("排序后的一维数组:")
print(sorted_vector)
# 对二维数组（矩阵）沿第一轴（行）排序
matrix = np.array([[3, 1, 4], [1, 5, 9], [2, 6, 5]])
print(matrix)
sorted_matrix_axis0 = np.sort(matrix, axis=0)
print("沿第一轴排序的二维数组:")
print(sorted_matrix_axis0)
# 对二维数组（矩阵）沿第二轴（列）排序
sorted_matrix_axis1 = np.sort(matrix, axis=1)
print("沿第二轴排序的二维数组:")
print(sorted_matrix_axis1)
# 排序后的一维数组:
# [1 1 2 3 3 4 5 5 5 6 9]
# [[3 1 4]
# [1 5 9]
# [2 6 5]]
# 沿第一轴排序的二维数组:
# [[1 1 4]
# [2 5 5]
# [3 6 9]]
# 沿第二轴排序的二维数组:
# [[1 3 4]
# [1 5 9]
# [2 5 6]]
pandas
pandas两个核心数据结构：
Series：对应于一维的序列
import pandas as pd
# 使用列表创建Series
s1 = pd.Series([1, 2, 3, 4, 5])
print(s1)
# 0 1
# 1 2
# 2 3
# 3 4
# 4 5
# dtype: int64
# 使用字典创建Series（索引为字典的键）
s2 = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5})
print(s2)
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64
# 显式指定索引
s3 = pd.Series([1, 2, 3, 4, 5], index=['A', 'B', 'C', 'D', 'E'])
print(s3)
# A 1
# B 2
# C 3
# D 4
# E 5
# dtype: int64DataFrame：对应于二维的表结构
Series、 DataFrame的创建
# 使用字典列表创建 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'Paris', 'London', 'Berlin']
}
df = pd.DataFrame(data)
print(df)
# Name Age City
# 0 Alice 25 New York
# 1 Bob 30 Paris
# 2 Charlie 35 London
# 3 David 40 Berlin
# 使用字典和索引创建 DataFrame
index = ['a', 'b', 'c', 'd']
df_indexed = pd.DataFrame(data, index=index)
print(df_indexed)
# Name Age City
# a Alice 25 New York
# b Bob 30 Paris
# c Charlie 35 London
# d David 40 Berlin
# 还可以使用 Series 对象创建 DataFrame
s1 = pd.Series([1, 2, 3, 4], name='A')
s2 = pd.Series([5, 6, 7, 8], name='B')
df_from_series = pd.DataFrame({'Col1': s1, 'Col2': s2})
print(df_from_series)
# Col1 Col2
# 0 1 5
# 1 2 6
# 2 3 7
# 3 4 8切片、索引
# 索引单个元素
print(s3['B']) # 输出：2
# 切片
print(s3['B':'D']) # 输出：B 2
# C 3
# D 4
# dtype: int64
# 使用整数位置索引（注意：这会基于整数位置而不是索引标签）
print(s3[1:4]) # 输出：B 2
# C 3
# D 4
# dtype: int64布尔型数组索引
# 创建一个布尔型数组
bool_idx = s3 > 2
print(bool_idx) # 输出：A False
# B False
# C True
# D True
# E True
# dtype: bool
# 使用布尔型数组索引Series
filtered_s3 = s3[s3>3]
print(filtered_s3) # 输出：
# D 4
# E 5
# dtype: int64正则表达式
特殊符号与字符
正则表达式的概念
文本处理工具
正则表达式模块re
核心函数或正则表达式对象的方法：
compile (重点关注)
re.compile() 函数用于将字符串形式的正则表达式编译为模式对象，以便复用。
import re
pattern = re.compile(r'\d+') # 匹配一个或多个数字
match = pattern.match("123abc") # 在字符串开头寻找匹配
if match:
print(match.group()) # 输出：123match (重点关注)
re.match() 或 Pattern.match() 尝试从字符串的开头匹配正则表达式。
import re
match = re.match(r'\d+', "123abc") # 在字符串开头寻找匹配
if match:
print(match.group()) # 输出：123
match = re.match(r'\d+', "abc123") # 在字符串开头没有找到匹配
if not match:
print("No match")search (重点关注)
re.search() 或 Pattern.search() 在整个字符串中搜索匹配项（不只是开头）。只匹配一个
import re
match = re.search(r'\d+', "abc123def") # 在整个字符串中搜索匹配
if match:
print(match.group()) # 输出：123findall (重点关注)：
正则表达式中是否含分组？输出情况不一样 多个
re.findall() 或 Pattern.findall() 搜索整个字符串，并返回所有匹配的列表。
分组情况：如果正则表达式中包含分组（由括号 () 定义），则 findall() 会返回分组捕获的内容，而不是整个匹配的内容。
import re
# 没有分组
matches = re.findall(r'\d+', "abc123def456")
print(matches) # 输出：['123', '456']
# 有分组
matches = re.findall(r'(\d+)', "abc123def456")
print(matches) # 输出：['123', '456'] 注意这里仍然是整个匹配的内容
# 但如果我们有嵌套分组
matches = re.findall(r'(\d+)(\w+)', "abc123def456ghi")
print(matches) # 输出：[('123', 'def'), ('456', 'ghi')] 这里返回的是元组的列表，每个元组包含两个分组的内容sub (重点关注)
re.sub() 或 Pattern.sub() 替换字符串中所有匹配的子串。
import re
new_string = re.sub(r'\d+', 'NUMBER', "abc123def456")
print(new_string) # 输出：abcNUMBERdefNUMBERsplit (重点关注)
re.split() 或 Pattern.split() 根据正则表达式的匹配项来分割字符串。
import re
split_string = re.split(r'\d+', "abc123def456")
print(split_string) # 输出：['abc', 'def', ''] 注意，匹配项之后的空字符串也会被包括在内group (重点关注)
import re
match = re.search(r'(\d+)(\w+)', "abc123def456ghi")
print(match.group()) # 输出：'123def' 整个匹配的内容
print(match.group(1)) # 输出：'123' 第一个分组的内容
print(match.group(2)) # 输出：'def' 第二个分组的内容正则表达式应用
正则表达式在网络爬虫阶段解析url中的应用
import re
# 假设这是从网页中抓取的一段文本
text = """
<a href="http://example.com/page1">Link 1</a>
<a href="https://www.example.org/page2">Link 2</a>
Some other text...
<a href="ftp://ftp.example.net/file.zip">Download</a>
"""
# 使用正则表达式匹配URL
url_pattern = re.compile(r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+')
# 查找所有URL
urls = url_pattern.findall(text)
# 打印结果
for url in urls:
print(url)正则表达式在文本分析中的应用
import re
# 假设这是我们要分析的文本
text = """
This is a sample text with an email address: example@example.com.
Please contact us at support@ourcompany.com for more information.
"""
# 使用正则表达式匹配电子邮件地址
email_pattern = re.compile(r'[\w\.-]+@[\w\.-]+\.\w+')
# 替换所有电子邮件地址为"[REDACTED]"
redacted_text = email_pattern.sub('[REDACTED]', text)
# 打印结果
print(redacted_text)
# This is a sample text with an email address: [REDACTED].
# Please contact us at [REDACTED] for more information.
难点实训
- 列表与numpy数组的区别
- 表达式[5,7,9]*2的结果是： [5,7,9,5,7,9]
- 表达式np.array([5,7,9])*2的结果是：array([10,14,18])
- 字符串的表示
-
以下哪个字符串表示是正确的( a)
(A) 'abc"ab ' (B) 'abc ' ab' (C) "abc" ab" (D) 'abc"ab"
-
- 列表解析式，也称列表推导式
- 已知 alist=[['a''b'],['c'''d']],则表达式[s for t in alist for s in t]的 值是：| ['a','b','c','d']
- 外层循环
for t in alist遍历alist中的每个子列表t。 - 内层循环
for s in t遍历当前子列表t中的每个元素s。 - 将
s添加到新列表中。
4：带*的函数参数
这些字符串之间用逗号和空格分隔，这里的空格是故意加上的，以增强可读性
2786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
