几个常用方法
字符串常用方法
# 字符串常用方法
string = "Python"
# 将列表中的字符合并为一个字符串
print("".join(['H', 'e', 'l', 'l', 'o']))
# 去除字符开头与结尾的空格或其他符号
print("#####shangsan######".strip('#'))
print(" lisi ".lstrip()) # 只去除左侧的空格
print(" wangwu ".rstrip()) # 只去除右侧的空格
# 切割：通过分隔符拆分列表,默认分隔符是空格
lis = "root:0:0::/root:/bin/bash".split(":")
lis[0] = "admin"
print(":".join(lis))
# 居中显示
print(string.center(20))
# find查找:通过字符查找下标
print(string.index('n'))
# replace:字符替换
print(string.replace("P", "J"))
print(string)
## 验证字符由纯数字构成
print("123".isdigit())
ch = input("请输入一个数字:")
if ch.isdigit():
print("您的输入正确！")
else:
print("您的输入有误！")
# 验证是否是纯字母构成
print("abc".isalpha())
# 验证是否是数字+字母构成
print("1a2b".isalnum())
# 验证纯小写、纯大写、大小写转换
print("abc".islower())
print("ABC".isupper())
print("ABCdef".swapcase())
# count:统计字符出现的数量
print("hello".count('l'))
# title：把首字母变成大写
print("abc".title())
# ord 字符 -> 数字编号
c = input("请输入一个小写字母：")
print(chr(ord(c) - 32))
# chr 数字-> 字符
# int\float\bool\list\dict\max\sum\min\len\round\input\print
"Python"
# 判断以"xxx"开头，以"xxx"结尾
print(string.endswith('n'))
print(string.startswith('P'))
list常用方法
1.可变
2.有序
3.可以嵌套
4.异构：同一个列表中可以存放任意类型的数据；
list的方法
1.创建列表
lis1 = []
lis2 = list()
2.添加数据
# 1.append(元素)，在结尾追加的作用
lis1.append('a')
lis1.append([1,2,3])
print(lis1)
# 2.合并序列
lis1.extend([1,2,3])
lis3 = lis1 + lis2
# 等价于+=，输出1,2,3,[1,2,3]
# 3.在列表任意位置添加元素，insert(下标,元素)
lis1.insert(0,’X’) # 在下标0的位置添加一个元素，尽量不在开头添加
3.查找数据
print(lis1.index(‘a’))
print(lis1.count(2)) # 查找数字不能带引号，带引号是字符串
4.修改数据：通过下标直接修改列表中的值
lis1[1] = ‘b’
print(lis1)
5.删除数据
# 1.pop()：通过下标弹出元素；
a = lis1.pop(2) # 不写下标默认弹出最后一个
print(lis1)
print(a)
# 2.del关键字：从内存中删除
# del lis1 # 不写下标的话会删除所有，输出结果会报错
del lis1[0]
print(lis1)
列表排序问题
lis1 = [3, 1, 88, 22, 34, 43, 26, 79]
# 列表排序方法，sort默认升序，改变列表本身
lis1.sort()
# 添加reverse=True，降序排序
lis1.sort(reverse=True)
print(lis1)
# sorted是Python内置排序函数；不改变原列表，会返回一个排好序的新列表
# lis2 = sorted(lis1) # 升序
lis2 = sorted(lis1, reverse=True) # 降序
print("lis1:", lis1)
print("lis2:", lis2)
# reverse逆序方法
lis1.reverse()
print(lis1)
# lis2 = reversed(lis1) # reversed()函数的返回值不是列表，而是一个迭代器对象
lis2 = list(reversed(lis1)) # 需要转成列表才能看到内容
print("lis2:", list(lis2))
lis2 = reversed('abcd') # 里面是字符串也要转换成列表或者元组
print("lis2:", tuple(lis2))
赋值操作 = is
# = 是赋值操作，赋值“变量”本身的内存地址。Python中赋值的存储地址；
lis1 = [3, 1, 88, 22, 34, 43, 26, 79]
lis2 = lis1
print(lis1, lis2)
print(id(lis1) == id(lis2))
lis1.append("A")
print("lis1:", lis1)
print("lis2:", lis2)
# == 判断的是值是否相等（两个人名字相同），is 判断的是内存地址是否相等（身份证号不同）；
print(lis1 is lis2) # True
数据浅拷贝.copy和深拷贝
# .copy 数据浅拷贝：将存储容器中的数据复制到一个新的容器中；
# copy是将存储“内容”的地址复制到另一个存储空间；
lis1 = [3, 1, 88, 22, 34, 43, 26, 79]
lis2 = lis1.copy()
print("lis1:", lis1)
print("lis2:", lis2)
print(lis1 is lis2)
print(id(lis1), id(lis2))
# Python的赋值是引用类型赋值；
# 值类型赋值方式：赋值内容是“值”本身；
# 引用型赋值方法：赋值内容是“值”的内存地址；
## 深拷贝：如果容器嵌套存储，会将每层的所有数据都拷贝
lis1 = [3, 1, 88, 22, 34, 43, 26, 79, ['A', 'B', 'C']]
import copy
lis3 = copy.deepcopy(lis1)
print("lis1:", lis1)
print("lis3:", lis3)
lis1[8].append("D")
lis3[8].pop(0)
print("lis1:", lis1)
print("lis3:", lis3)
函数
-
函数通过 def 定义，用 函数名() 调用，核心是“封装功能、重复使用”。
-
参数让函数更灵活（位置参数、默认参数、关键字参数）。
-
返回值用 return 指定，可返回单个值或多个值（元组）。
-
文档字符串提升函数可读性，作用域区分变量的访问范围。
普通参数
# 函数作用：封装、复用
# 优点：精简代码
def func():
pass
def show_menu():
"""
显示学生管理系统的菜单
:return:
"""
print("""
1.查看学生信息
2.添加学生信息
3.修改学生信息
4.删除学生信息
5.退出
""")
# 把函数作为参数，让别的函数使用这个参数（函数后面不加括号）
print(help(show_menu))
# 通过函数名调用，才会执行
show_menu()
help(show_menu)
# 函数参数：位置参数、命名参数、默认值参数、不等长参数、不定长命名参数
2.外部: 200
# 例子
def func(a, b, file="a.txt", *args, **kwargs):
print('a:', a) # 1
print('b:', b) # 2
print('file:', file) # b.txt，因为后面用位置参数赋值了
print('args:', args) # ('A','B','C')
print('kwargs:', kwargs) # (name='tom',age=18,address='石家庄')
位置参数：根据形参定义的顺序赋值
func(1, 2, 'b.txt', 'A', 'B', 'C', name='tom', age=18, address='石家庄')
def func2(*args, **kwargs):
print("sum:", sum(args))
for i, (k, v) in enumerate(kwargs.items()):
print(f"{i}.{k}-->{v}")
func2(1, 2, 3, 4, 5, 6, 7, 8, 9, a=100, b=200, c=300)
# 函数返回值：函数运行结束时，向函数外部传递的数据
# 如果只定义，不返回的话，会输出None
def func3(b):
a = 100
return a + b
print(func3(200)) # 输出300
# 返回元组
def func3(b):
a = 100
return a, b
print(func3(200)) # 输出(100, 200)
解包：将序列中的元素直接赋值给相同的变量；
def swap(a, b):
return b, a, 3
# 定义swap(a, b)函数：接收a,b，返回b, a, 3
x = 1
y = 2
x, y, z = swap(x, y) # x,y = (y,x)
print(x, y, z) # 解包成xyz，输出（2,1,3）
变量的作用域
局部变量：在函数、方法内部生效的变量
全局变量：在.py中全局获取到的变量值（先定义再获取，定义之前获取不到）
可以通过global在局部中修改全局变量
# 局部变量：只在函数、方法内部才有效、才能被使用的变量；
# 全局变量：变量定义后，在下方，全局都能获取到变量的值；
# 例子
a = 100 # 全局变量a，初始值100
def func(x, y):
global a # 声明：接下来的a是全局变量
print("修改前:", a) # 此时a还是全局变量的初始值100 → 输出：修改前: 100
a = 200 # 因为有global声明，这里修改的是“全局变量a”，把它改成200
print(x, y) # 输出形参：1 2
print("内部", a) # 此时a已经被改成200 → 输出：内部 200
print("修改后:", a) # 输出：修改后: 200
print("外部", a) # 此时a是全局变量，输出：外部 100
func(1, 2) # 调用函数 func 并传入参数
print("2.外部:", a) # 此时a是被函数修改后的全局变量，值为200 → 输出：
匿名函数：一般用于高阶函数的参数
#ambda 形参:返回值
print((lambda x, y: x + y)(1, 2))
或者也可以写成这样
add = lambda x, y: x + y
# 等价于
def add(x, y):
return x + y
print(add(1, 2))
print(type(add))
高阶函数
定义：（满足下列任一条件的函数）
1.把其他函数作为参数的函数；（此时函数不能加括号）
2.把函数作为返回值的函数；
1、map内置高阶函数：
第一参数是函数，第二参数是序列，将函数作用在每一个元素上生成新的序列
配合匿名函数 lambda 更简洁：
res = map(lambda x: x ** 2, range(0, 10, 2))
print(list(res))
# 以上等价于下面这个函数
def func(x): # 先定义函数
return x ** 2
res = map(func, range(0, 10, 2)) # 用map应用函数
print(list(res))
2、filter过滤器函数：
根据函数判断真假数据，真的留下，假的删除
res1 = filter(None, [0, 1, 2, '', 'a', 'b', [], [1, 2], ()])
res2 = filter(lambda x: True if x % 2 == 0 else False, range(10))
print(list(res1)) # 输出[1, 2, 'a', 'b', [1, 2]]
print(list(res2)) # 输出[0, 2, 4, 6, 8]
3、reduce累计函数
# 第一步：从functools模块导入reduce
from functools import reduce
# 第二步：使用reduce累乘
res = reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
print(res)
def my_map(f, lis):
new_lis = []
for i in lis:
new_lis.append(f(i))
return new_lis
高阶函数：
-
一切皆为对象（地址、数据成员、类型）
-
First Class Object
-
函数在Python中是一等公民
-
函数也对象，可调用的对象
-
函数可以作为普通变量、参数、返回值等等
-
-
高阶函数
-
数学中概念y=g(f(x))
-
在数学和计算机科学中，高阶函数至少应该满足下面的一个条件的函数
-
接收一个或多个函数的引用作为参数的函数
-
返回值是一个函数引用的函数
-
-
函数的引用 ：函数的名字
-
函数的执行结果：func() is return 的结果
-
4、闭包函数
闭包 = 内部函数 + 外部函数的变量记忆，本质是 “带着专属数据的函数”，核心用来「安全保存局部变量，避免全局污染」
定义：
1.内部函数使用外部函数的变量；
2.外部函数将内部函数作为返回值返回；
核心作用：保存外部函数的局部变量，避免全局变量污染。
示例：创建独立的计数器
def make_counter():
count = 0 # 外部函数的局部变量（被闭包引用）
# 内部函数（闭包）
def counter():
nonlocal count # 声明引用外部函数的变量（不是内部局部变量）
count += 1 # 修改外部函数的count（自增1）
return count # 返回当前计数
return counter # 返回内部函数（闭包，不执行，只返回“计数功能”）
# 创建计数器实例
counter1 = make_counter()
print(counter1()) # 1（第一次调用，count=1）
print(counter1()) # 2（第二次调用，count=2）
# 再创建一个独立的计数器
counter2 = make_counter()
print(counter2()) # 1（与counter1的count独立）
· nonlocal关键字：用于在内部函数中修改外部函数的局部变量（若无nonlocal，直接赋值会被视为内部函数的局部变量）。
5、装饰器函数 flask,fastApi
装饰器函数的作用：在不修改其他函数代码的前提下，修改函数的功能；
import datetime
# 装饰器函数
def logger(func):
def new_func(*args, **kwargs):
print(f"{func.__name__}执行前:{datetime.datetime.now()}")
func(*args, **kwargs)
print(f"{func.__name__}执行后:{datetime.datetime.now()}")
return new_func
@logger # 装饰器的语法糖，等价于show_enum =logger(show_enum)，也就是把原函数传给装饰器，再用返回的新函数覆盖原函数名。
def show_enum():
import time
import random
print('''
1.xxx
2.xxx
3.xxx
''')
time.sleep(random.randint(1, 3)) # 休眠1~3秒
show_enum()
6、递归函数
函数调用自身解决问题；
1.必须要有结束条件
2.没有结束则调用自身
def fibo(n):
if n <= 1:
return 1
return fibo(n - 1) + fibo(n - 2)
print(fibo(10))
# 阶乘\栈结构
def fac(n):
if n == 1:
return 1
return n * fac(n - 1)
# 5!
# 5*4!
# 5x4*3!
# 5*4*3*2!
# 5*4*3*2*1
print(fac(5))
# 生成器：当需要时，才会创建一个数据；
# 生成器的特点：不会一次性生成所有数据，而是迭代一次生成一个（省内存），只有 for 循环或 next() 调用时才会触发生成
# 元组生成器 Python3中range函数,也是生成器函数
tup = (i for i in range(100000000))
for t in tup:
print(t)
# 生成器函数
def f():
yield 1
yield 'a'
yield True
yield None
yield []
yield {}
x = f()
# print(x.__next__())
# print(x.__next__())
# print(x.__next__())
# 和下面意思一样
for i in x:
print(i)
# 结果会依次出现
# 用生成器（yield）模拟 Python 内置函数 range()
def my_range(n=0, m=0, b=1):
if m == 0:
s = 0 # 起始值固定为 0
while s < n: # 循环条件：s小于传入的n（结束值）
yield s # 生成当前s（暂停函数，返回s给迭代器）
s += b # 步长累加（默认加1）
else:
s = n # 起始值为传入的n
while s < m: # 循环条件：s小于传入的m（结束值）
yield s # 生成当前s
s += b # 步长累加
# 生成器函数调用后，不会直接执行代码，而是返回一个「生成器对象」
for i in my_range(3, 10, 1):
print(i)
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
