Bruce的博客 - Python基础
type: channel
link: https://www.wanglin.blog/index.php/category/Python%E5%9F%BA%E7%A1%80/
items: Python学习笔记｜爬虫基础（二）Cookie 模拟登录、Post请求
items: Python学习笔记｜Python文件操作
items: Python学习笔记｜面向对象编程
items: Python学习笔记｜模块
items: Python学习笔记｜偏函数
items: Python学习笔记｜装饰器
items: Python学习笔记｜返回函数
items: Python学习笔记｜高阶函数
items: Python学习笔记｜高级特性
items: Python学习笔记｜函数

Python学习笔记｜爬虫基础（二）Cookie 模拟登录、Post请求
type: item
date: 2024-01-20T11:32:19+08:00
description: 一、Cookie 模拟登录import requests headers = { 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36', 'Cookie':'' } url = '' res = requests.get(url, headers = headers) print(res.text)二、使用post请求获取金山翻译import requests import json import random from fake_useragent import UserAgent # 获取请求url url = 'https://ifanyi.iciba.com/index.php?c=trans' # 构造headers headers = { 'User-Agengt':UserAgent().random } #输入待译文本 word = input("请输入待译文本：") # 构建data参数字典 post_data ={ 'from':'zh', 'to':'en', 'q': word } #发起请求 res = requests.post(url, headers = headers, data = post_data) #获取请求内容 # print(res.text) #将Json数据解析为字典 dic = json.loads(res.text) #获取输出内容格式 # print(type(dic)) #打印译文 print(dic["out"])请输入待译文本： 金山翻译Jinshan translationimport requests import json # import random # from fake_useragent import UserAgent # 获取请求url url = 'https://app.languagex.com/api/translator/translation/text' # 构造headers headers = { 'User-Agengt':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36', 'Cookie': 'Hm_lvt_d78dae91eafe9d7af5ea9e954247f348=1704525651; token=eyJhbGciOiJIUzI1NiJ9.eyJ1aWQiOjE1NzI5NjUwNjIzMDU0OTcwOTAsIm1pZCI6MTY4MjIzMDI2MTM5NzAwMSwidXNlcm5hbWUiOiJMWDYzMmM3OTdkYTdmNjBhYzJlMjM5YjMyOCIsImV4cCI6MTcwNTU5MjUzNH0.YktHsPJ7aXhERNmvLQ3w0SAwabweGsoqsQ1wFAbiFoQ; org=eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTcwMTg1MTc3NzAwNjg3MywibmFtZSI6IumrmOagoee_u-ivkemhueebriIsInR5cGUiOiJFTlRFUlBSSVNFIiwicm9sZUlkIjoyLCJ0ZWFtSWRMaXN0IjpbMTcwMTg1MTc3NzAwNjg3N119.nCdkNCDrkBxHCDJxvYGZo4nFOUgsGKwUPDq4KwaStTw; Hm_lpvt_d78dae91eafe9d7af5ea9e954247f348=1705333336' } #输入待译文本 # word = input("请输入待译文本：") # 构建data参数字典 post_data ={ "domain":"general", "engine":"chatgpt", "engineKey":"chatgpt", "sourceLang":"zh", "sourceText":"美国", "targetLang":"en", "terms":[] } #发起请求 res = requests.post(url, headers = headers, data = post_data) #获取请求内容 # print(res.text) print(res) #将Json数据解析为字典 # dic = json.loads(res.text) #获取输出内容格式 …

Python学习笔记｜Python文件操作
type: item
date: 2024-01-14T16:12:00+08:00
description: 一、文件相关概念（一）文件路径# 绝对路径示例 "D:\\lecture\\ex\\file.txt" "D/lecture/ex/file.txt" # 相对路径示例 # 假设`file.txt保存在D盘的lecture目录的ex子目录下，源程序保存在D盘的lecture目录下，那么包含相对路径的文件名应该保存为： "ex\\file.txt" "ex/file.txt" # Windows系统中建立路径的特殊符号 # ".\" :当前目录 # "..\"：上一级目录（二）文件编码在Python 3.x版本中：文件默认编码是UTF-8；字符串使用的是Unicode编码；文本文件使用Unicode编码。在Python语言中，对文本文件的存取以字符为单位，输入/输出的字符流开始和结束由程序控制。每个文件的结尾处通常由一个结束标志EOF。二、文件夹与目录操作（一）os.path模块模块功能介绍：https://www.runoob.com/python/python-os-path.html获取工作目录：os.getcwd()# 获取和改变当前目录 import os print("当前的工作目录：", os.getcwd()) os.chdir('../') print("改变后的工作目录：", os.getcwd())当前的工作目录： D:\pythonProject\09 IO编程 改变后的工作目录： D:\pythonProjectimport os print(os.path.dirname("D:\pythonProject\09 IO编程")) #返回path目录 print(os.path.basename("D:\pythonProject\09 IO编程")) #返回path的最后文件名 print(os.path.exists('D://pythonProject/09 IO编程')) #判断文件路径是否存在D:\ pythonProject9 IO编程 True（二）目录与文件操作获得目录中的文件：os.listdir(patn)os.listdir('D:\音乐')['AlbumArtSmall.jpg', 'Folder.jpg', 'Home Free - Auld Lang Syne_英文（en）-auto.srt', 'Joel P West - Summer Storm.lrc', 'Joel P West - Summer Storm.mp3', 'videoplayback.mp4', '周杰伦 - 听妈妈的话.flac', '杨坤、郭采洁 - 答案.mp3', '清明上河图.mp3', '王力宏 - 需要人陪.mp3', '纯音乐 - Love home.mp3', '金玟岐-岁月神偷.mp3']创建目录：os.mkdir(path)os.mkdir("D://pythonProject//09 IO编程//test")删除目录：os.rmdir(path)os.rmdir("D://pythonProject//09 IO编程//test")（三）文件的重命名与删除文件重命名：os.rename(src, dst) src：要修改的文件名；dst：修改后的目录名import os, sys # 列出目录 print("目录为：%s" % os.listdir(os.getcwd())) #重命名 os.rename("test", "test1") print("重命名成功。") # 列出重命名后的目录 print("重命名后的目录为：%s" % os.listdir(os.getcwd()))目录为：['.idea', '.ipynb_checkpoints', '01 Python基础', '02 函数', '03 高级特性', '04 函数式编程', '05 模块', '06 面向对象编程', '07 面向对象的高级编程', '08 爬虫', '09 IO编程', 'draft.py', 'test'] 重命名成功。 重命名后的目录为：['.idea', '.ipynb_checkpoints', '01 Python基础', '02 函数', '03 高级特性', '04 函数式编程', '05 模块', '06 面向对象编程', '07 面向对象的高级编程', '08 爬虫', '09 IO编程', 'draft.py', 'test1']删除文件：os.remove(path)import os, sys # 列出目录 print("目录为：%s" % os.listdir(os.getcwd())) #移除 os.remove("test1.txt") #移除后的目录 pr…

Python学习笔记｜面向对象编程
type: item
date: 2024-01-11T23:17:35+08:00
description: 一、定义定义：面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。举一例说明面向过程和面向对象在程序流程上的不同，假设我们要处理学生的成绩表，为了表示一个学生的成绩：# 面向过程的程序可以用一个dict表示 std1 = {'name':'Michael','score':98} std2 = {'name':'Bob','score':81} # 处理学生成绩可以通过函数实现，比如打印学生的成绩 def print_score(std): print('%s:%s' % (std['name'], std['score'])) print_score(std1) print_score(std2)Michael:98 Bob:81如果采用面向对象的程序设计思想，首先思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print('%s: %s' % (self.name, self.score)) bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score()Bart Simpson: 59 Lisa Simpson: 87二、类（Class）和实例（Instance）（一）定义类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。在Python中，通过class关键字定义类：class Student(object): # passclass后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：bart = Student() bart<__main__.Student at 0x1ee22272dd0>变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样；Student__main__.StudentStudent本身则是一个类。可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：bart.name = 'Bart Simpson' bart.name'Bart Simpson'由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：class Students(object): def __init__(self, name, score): self.name = name self.score = score注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：bart = Students('Bart Simpson', 59) bart.name'Bart Simpson'bart.score59和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且调用时不用传递该参数。此外，可以用默认参数、可变参…

Python学习笔记｜模块
type: item
date: 2023-12-26T00:19:18+08:00
description: 一、模块的基本概念模块：在Python中，一个.py文件就称之为一个模块（Module）使用模块的好处：（1）提高了代码的可维护性。（2）编写代码不必从零开始。（3）使用模块还可以避免函数名和变量名冲突。注意：尽量不要与Python的内建函数冲突。Python内建函数介绍：https://docs.python.org/3/library/functions.html二、包的基本概念为了避免模块名冲突，引入按目录组织模块，避免冲突。方法是选择一个顶层的包名，比如mycompany，按照如下目录存放：mycompany ├─ __init__.py ├─ abc.py └─ xyz.py引入包名后，只要顶层的包名不与别人冲突，那么所有模块都不会与别人冲突。abc.py模块的名称就变为了mycompany.abc，xyz.py的模块名就变为了mycompany.xyz。每一个包名目录下都会有一个__init__.py文件，这个文件必须存在，否则Python就会把这个目录当做普通目录，而不是一个包。__init__.py文件可以是空文件，也可以有Python代码。它本身就是一个模块，而它的模块名就是mycompany类似的，可以有多级目录，组成多层级的包结构。mycompany ├─ web │ ├─ __init__.py │ ├─ utils.py │ └─ www.py ├─ __init__.py ├─ abc.py └─ utils.py文件www.py的模块名就是mycompany.web.www，两个文件utils.py的模块名分别是mycompany.utils和mycompany.web.utils。总结：模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。在此模块。创建自己的模块时，要注意：模块名要遵循Python变量命名规范，不要使用中文、特殊字符；模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行import abc，若成功则说明系统存在此模块。三、使用模块以内建的sys为例，写一个hello的模块。#!/user/bin/env python3 #第一行注释让hello.py文件可以直接在Unix/Linux/Mac上运行 # -*- coding: utf-8 -*- #第二行注释表示.py文件本身使用UTF-8编码 'a test module' # 字符串，表示模块的文档注释。任何模块代码的第一个字符串都被视为模块的文档注释 __author__ = 'Bruce Wang' # __author__变量把作者写进去 #以上是一个Python模块的标准文件模板，也可以全部删掉不写。 # 后面是真正的代码 import sys def test(): args = sys.argv if len(args) == 1: print("Hello, world!") elif len(args) == 2: print("Hello, %s!" % args[1]) else: print("Too many arguments!") if __name__ == '__main__': test()Too many arguments!四、作用域类似__xxx__这样的变量（__author__，__name__）是特殊变量，可以被直接引用但是有特殊用途，我们自己的变量一般不要用这种变量名；类似_xxx和__xxx这样的函数或变量是非公开的（private），不应该被直接引用。def _private_1(name): return 'Hello, %s' % name def _private_2(name): return 'Hi, %s' % name def greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name) print(greeting("Bruce"))Hello, Bruce我们在模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来了，这样，调用greeting()函数不用关心内部的private函数细节，这也是一种非常有用的代码封装和抽象的方法，即：外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。五、模块搜索路径加载一个模块时，Python会在指定的路径下搜索对应的.py文件，默认情况下Python解释器会搜索(1)当前目录;（2）所有已安装的内置模块（3）第三方模块。搜索路径存放在sys模块的path变量中：import sys s…

Python学习笔记｜偏函数
type: item
date: 2023-12-24T15:11:49+08:00
description: 偏函数可以通过设定参数的默认值，降低函数调用的难度。functools.partial就是帮助我们创建一个偏函数。import functools int2 = functools.partial(int, base = 2) int2('1000')8这个函数等价于：# 转换二进制字符串 # int函数默认将字符串转换为整数，base默认为10。如果传入base参数，就可以做n进制转换。 def int2(x, base = 2): return int(x, base) int2('1000')8总结：functools.partial函数作用是将一个函数的某个参数给固定住（也就是设置一个默认值），返回一个新的函数，调用这个新函数会更加简单。在int2函数中，仅仅把base参数重新设置为默认值2，但也可以在函数调用时传入其他参数。int2('1234', base = 8)668创建偏函数的时候，可以接受函数对象、*args、**kw这三个参数，当传入int2 = functools.partial(int, base = 2),就固定住了int函数的关键字参数base。int2('10010')18kw = {'base':2} int('10010',**kw)18当传入：max2 = functools.partial(max, 10)10会作为*args的一部分自动加到左边。也就是：max2(5,6,7)10总结：当函数参数太多需要简化的时候，可以使用functools.partial创建一个新的函数，这个函数可以固定住原函数的部分参数，从而在调用的时候更加简单。

Python学习笔记｜装饰器
type: item
date: 2023-12-24T15:07:00+08:00
description: 装饰器（decorators）用于拓展原来函数功能的一种函数，目的是在不改变原来函数名（或类名）的情况下，给函数增加新功能。在Python中，装饰器的语法以@开头。装饰器主要应用于：引入日志、函数执行时间统计、执行函数前的预备处理、执行函数后清理功能、权限校验、缓存。【案例1】利用装饰器实现统计函数的执行时间import time def timeit(func): #func()为装饰器绑定的方法，绑定装饰器后自动传入 def result(): start_time = time.time() func() end_time = time.time() print('函数运行时间为：%.2fs'%(end_time - start_time)) return result @timeit def func_0(): time.sleep(3) @timeit def func_1(): time.sleep(3) func_0() func_1()函数运行时间为：3.01s 函数运行时间为：3.01s【案例2】无参数的装饰器应用import time def timeit(func): def result(): start_time = time.time() func() #调用test方法 end_time = time.time() print('函数运行时间为：%.2fs'%(end_time - start_time)) return result @timeit def test(): time.sleep(1) print("测试函数运行") test()测试函数运行 函数运行时间为：1.00s装饰器@timeit会将test()函数进行包装，实际上调用的是result()函数。在result()函数中，先调用了func()，也就是test()函数，然后再计算函数的运行时间并输出。因此，"测试函数运行"会先输出，然后才会输出"函数运行时间为：1.00s"。【案例3】有参数的装饰器应用import time def timeit(func): def result(arg1): #调用test方法的参数 start_time = time.time() func(arg1) #调用test方法 end_time = time.time() print('函数运行时间为：%.2fs'%(end_time - start_time)) return result @timeit def test(mStr): time.sleep(2) print("函数运行时间：" + mStr) test("传入参数")函数运行时间：传入参数 函数运行时间为：2.00s【案例4】定义一个打印日志的装饰器def log(text): def decorator(func): def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decorator @log('execute') def now(): print('2015-3-25') now()execute now(): 2015-3-25上面的函数，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。函数也是对象，它有__name__等属性，但经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：now.__name__'wrapper'因为返回的wrapper()函数名字是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。下：不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps即可实现，所以，一个完整的decorator的写法如下：import functools def log(text): def decorator(func): @functools.wraps(func) # wrapper()的前面加上@functools.wraps(func) def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return deco…

Python学习笔记｜返回函数
type: item
date: 2023-12-24T15:04:22+08:00
description: 一、函数作为返回值高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。实现一个可变参数的求和：# 可变参数求和 def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax如果不需要立即求和，而是在后面的代码中根据需要计算，可以不返回求和结果，而是返回求和函数。def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum f = lazy_sum(1,3,5,7,9) #调用函数f，结果是<function __main__.lazy_sum.<locals>.sum()> f<function __main__.lazy_sum.<locals>.sum()># 调用函数f时，才真正求和结果 f()25调用lazy()函数时，每次调用都会返回一个新的函数，即使传入相同的参数。f1 = lazy_sum(1, 3, 5, 7, 9) f2 = lazy_sum(1, 3, 5, 7, 9) f1 == f2Falsef1() == f2() #返回的值相同，评估为 TrueTrue二、闭包（1）在函数嵌套（函数里面再定义函数）的前提下（2）内部函数使用了外部函数的变量（还包括了外部函数的参数）（3）外函数的返回值是内函数的引用返回的函数并没有被立即执行，而是直到调用了f()才执行。def count(): fs = [] for i in range(1,4): def f(): return i * i fs.append(f) return fs f1, f2, f3 = count() f1()9f2()9f3()9三个返回结果全部都是9，原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。注意：返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。如果要引用循环变量，需要再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。def count(): def f(j): def g(): return j * j return g fs = [] for i in range(1,4): fs.append(f(i)) # f(i)立即被执行，因此i的当前值被传入f() return fs1f1, f2, f3 = count() f1()4f2()4f3()9如果对外层变量赋值，由于Python解释器会把x当作函数fn()的局部变量，它会报错:def inc(): x = 0 def fn(): # nonlocal x x = x + 1 return x return fn f = inc() print(f()) # 1 print(f()) # 2 # 在x = x + 1的表达式中，Python解释器会认为x是一个局部变量，但是在此之前没有对x进行赋值操作，所以会报错。 # 要解决这个问题，可以在fn函数中加上nonlocal关键字，将x声明为非局部变量，这样就可以对x进行赋值操作。修改后的代码如下： # def fn(): # nonlocal x--------------------------------------------------------------------------- UnboundLocalError Traceback (most recent call last) Cell In[44], line 10 7 return fn 9 f = inc() ---> 10 print(f()) # 1 11 print(f()) # 2Cell In[44], line 5, in inc.<locals>.fn() 3 def fn(): 4 # nonlocal x ----> 5 x = x + 1 6 return xUnboundLocalError: local variable 'x' referenced before assignment使用闭包，就是内层函数引用了外层函数的局部变量。如果只是读外层变量的值，我们会发现返回的闭包函数调用一切正常：def inc(): x = 0 def fn(): # 仅读取x的值: return x + 1 return fn f = inc() print(f()) # 1 print(f()) # 11 1小结变量。一个函数可以返回一个计算结果，也可以返回一个函数。返回一个函数时，牢记该函…

Python学习笔记｜高阶函数
type: item
date: 2023-12-19T23:20:00+08:00
description: 一、高阶函数基础（一）、变量可以指向函数abs<function abs(x, /)>abs(-10)10x = abs(-10) print(x)10f = abs print(f)<built-in function abs># 变量f指向了一个函数 # f = abs # print(f(-10))（二）、函数名也是变量# abs指向数值后，就无法 # abs = 10 # abs(-10)（三）、传入函数变量可以指向函数，函数的参数能接受变量，那么一个函数的变量就能指向另一个函数。这种函数即为高阶函数。def add(x,y,f): return f(x) + f(y) add(-5,5,abs)10二、Map函数map函数接受两个参数，一个是函数，一个是Iterable(可迭代对象)，map将传入的函数依次作用于序列中的每个元素，并把结果作为新的Iterator返回。def f(x): return x * x r = map(f,[1,2,3,4,5,6,7,8,9,10]) list(r) # 输出结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100][1, 4, 9, 16, 25, 36, 49, 64, 81, 100]上面这个例子也可以使用循环实现：def f(x): return x * x L =[] for i in range(1,11): L.append(f(i)) print(L)[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]但用循环的缺点在于稍微有些抽象，不如直接用map函数形象。三、reduce函数reduce函数把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce()函数把结果和序列的下一个元素做累计计算。from functools import reduce def add(x,y): return x + y reduce(add, [1,3,5,7])16将序列[1,3,5,7]变换为整数1357from functools import reduce def str2int(x,y): return x *10 + y reduce(str2int, [1,3,5,7])1357将str转换为int函数from functools import reduce def str2int(x,y): return x *10 + y def convert(i): digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} return digits[i] reduce(str2int, map(convert, '1357'))1357整理为一个str2int函数：from functools import reduce digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def str2int(n): def s2t(x,y): return x *10 + y def convert(n): return digits[n] return reduce(s2t, map(convert, n)) str2int('255')255使用lambda函数可以进一步简化：from functools import reduce digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def convert(i): return digits[i] def str2int(i): return reduce(lambda x, y: x * 10 + y, map(convert, i)) #使用lambda x, y: x * 10 + y替换了str2int(n)函数 str2int('2566')2566利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：def normalize(names): return names[0].upper() + names[1:].lower() names = ['adam', 'LISA', 'barT'] list(map…

Python学习笔记｜高级特性
type: item
date: 2023-11-30T23:23:58+08:00
description: 一、切片L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] # 取前三个元素 # 如果第一个索引是0，还可以省略： L[0:3] L[:3] ['Michael', 'Sarah', 'Tracy'] # 从索引1开始，取出2个元素出来 L[1:3] ['Sarah', 'Tracy'] # Python支持倒数切片 L[-2:] ['Bob', 'Jack'] L[-2:-1] ['Bob'] S = list(range(100)) print(S) # 取前10个数 print(S[0:10]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 取后10个数 print(S[-10:]) # [90, 91, 92, 93, 94, 95, 96, 97, 98, 99] # 前11-12个数 print(S[11:22]) # [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21] # 前10个，每两个取一个 print(S[0:10:2]) print(S[:10:2]) # [0, 2, 4, 6, 8] # 所有数，每5个取一个 print(S[:100:5]) # [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95] # 复制一个list print(S[:]) T = (1,2,3,4,5,6,7,8,9,10) print(T[:3]) # (1, 2, 3) # 字符串也可以看做成一个list Str = 'ABCDEFG' print(Str[0:3]) # ABC# 利用切片操作，实现一个trim()函数，去除字符串首尾的空格 def trim(s): start = 0 end = len(s) # 找到字符串首部的空格 while start < end and s[start] == ' ': start += 1 # 找到字符串尾部的空格 while end > start and s[end-1] == ' ': end -= 1 return s[start:end]二、迭代如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。字典可以迭代：d = {'a':1, 'b':2,'c':3} for key in d: print(key) for value in d.values(): print(value)字符串可以迭代d = {'a':1,'b':2,'c':3} for key in d: print(key) for value in d.values(): print(value) # 同时迭代key和value for key, value in d.items() print(key,value) # 输出结果 a c b 1 2 3 a 1 b 2 c 3 ''' items()是一个字典(dict)的方法，用于返回字典中所有键值对的元组。每个元组包含两个元素，第一个元素是键(key)，第二个元素是对应的值(value)。 在for key, value in d.items()这个语句中，d是一个字典对象，items()方法会返回一个包含所有键值对的可迭代对象。通过for循环遍历这个可迭代对象，每次迭代时，将键值对解包为key和value两个变量，可以对每个键值对进行操作。 '''使用迭代查找一个list中最小和最大值，并返回一个tuple：def findMinAndMax(L): #没有初始化max_value for i in L: if i > L[0]: max_value = i if i < L[0]: min_value = i print(max_value,min_value) findMinAndMax([1,2,3,1]) # 报错 ''' Traceback (most recent call last): File "D:\pythonProject\高级特性\迭代.py", line 44, in <module> findMinAndMax([1,2,3,1]) File "D:\pythonProject\高级特性\迭代.py", line 43, in findMinAndMax print(max_value,min_value) UnboundLocalError: local variable 'min_value' referenced befor…

Python学习笔记｜函数
type: item
date: 2023-11-25T14:38:00+08:00
description: 一、调用函数（一）函数基本结构在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。例如：自定义一个求绝对值的my_abs函数def my_abs(x): if x >= 0: return x else: return -x函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None如果已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）>>> from abstest import my_abs >>> my_abs(-9) 9（二）空函数可以定义一个什么事也不做的空函数，可以用pass语句：def nop(): passpass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。pass还可以用在其他语句里，比如：if age >= 18: pass缺少了pass，代码运行就会有语法错误。（三）参数检查调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError。但是如果参数类型不对，Python解释器就无法帮我们检查。数据类型检查可以用内置函数isinstance()实现：def my_abs(x): if not isinstance(x, (int, float)): raise TypeError('bad operand type') if x >= 0: return x else: return -x添加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误：>>> my_abs('A') Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 3, in my_abs TypeError: bad operand type（四）返回多个值# 返回多个值 # 从一个点移动到另一个点，给出坐标、位移、角度，即可计算出新的坐标； # import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。 import math def move(x,y,step,angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx,ny x,y = move(100,100,60,math.pi/6) print(x,y) # 运行结果 >>> x, y = move(100, 100, 60, math.pi / 6) >>> print(x, y) 151.96152422706632 70.0 # Python返回的其实是一个tuple,任然是单一值 r = x,y = move(100,100,60,math.pi/6) print(r)（五）总结定义函数时，需要确定函数名和参数个数；如果有必要，可以先对参数的数据类型做检查；函数体内部可以用return随时返回函数结果；函数执行完毕也没有return语句时，自动return None。函数可以同时返回多个值，但其实就是一个tuple。### 求解一元二次方程 import math def quadratic(a,b,c): #quadratic()开根号 d = b ** 2 - 4*a*c if d > 0: x1 = (-b + math.sqrt(d)) / 2*a x2 = (-b - math.sqrt(d)) / 2*a return x1,x2 elif d == 0: x = -b/2*a return x else: return("无解") print(quadratic(5,5,5))二、函数的参数（一）位置参数对于power(x)函数，参数x就是一个位置参数# 计算x2的函数 def power(x): return x * x把power(x)修改为power(x, n)，用来计算x^n^# 计算x的n次方函数 def power(x, n): s = 1 while n > 0: n = n - 1 s = s * x return s（二）默认参数经常计算x^2^，所以，完全可以把第二个参数n的默认值设定为2…