Python的基本语法
2021/5/23 20:29:07
本文主要是介绍Python的基本语法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
文章目录
- 1、语句 statement
- 1、概念
- 语句是python程序执行的最小单位
- 2、说明
- 多条语句写在一行内需要用(;)分隔，但是不建议这样写
- 3、折行符【\】
- 1、显示换行
- 折行符【\】是告诉解释执行器，下一行的代码也是此语句的内容
- 2、隐式换行
- 所有括号内的内容换行时，解释执行器会自动去下一行找到相对应的括号，直到找到为止
- 2、if条件判断语句
- 1、作用
- 让程序根据条件选择性的执行某条或者某些语句
- 2、语法
- 3、说明
- 1、真值判断会自上而下进行，如果有一条真值表达式的值为True，则执行其中的语句，然后结束if语句的执行，如果所有的真值表达式的值都为False，那么则执行else语句中的语句块
- 2、elif子句可以有1个，0个或者多个
- 3、else子句只能有1个或者0个
- if与elif的区别：如果程序中判断事件很多，全部用if的话，会遍历整个程序，如果用elif程序运行时，只要if或后续某个elif之一满足条件后，则程序执行完对应输入语句后就会结束程序(即不再去冗余的执行后续elif和else语句)提高效率
- 练习
- 分别写一个程序，输入学生的三科成绩，判断出最高成绩和最低成绩
- 3、字符串【str】
- 1、作用
- 用来记录文本信息
- 2、表示方式
- 用引号引起来的部分都叫做字符串
- '' 单引号
- "" 双引号
- '''''' 三单引号
- """""" 三双引号
- 3、引号说明
- 单引号内的双引号不算结束符
- 双引号内的单引号不算结束符
- 三引号的作用：
- 三引号内可以包含单引号和双引号
- 三引号字符串中的换行符会自动转换为\n
- 三引号一般用来表示函数或者类的文档字符串
- 4、转义字符
- 用转义字符代表特殊的字符
- 字符串字面值中 用字符串\后接一些字符代表一个特殊的字符串
- 常见转义字符
- 5、原始字符串【raw】
- 1、作用
- 让转移字符\无效
- 2、语法
- r"字符串"
- 6、字符串的运算
- 1、符号
- + 加号运算用于拼接字符串
- += 运算符用于原字符串与右侧字符串进行拼接生成新的字符串
- * 用于生成重复的字符串
- *= 生成重复的字符串并让原变量绑定生成后的字符串
- 7、字符串的比较运算
- 1、符号
- > >= < <= == !=
- 2、比较规则
- 根据字符对应的Unicode编码值进行比较
- Unicode编码叫做万国码 65535
- 3、函数
- chr() 返回Unicode编码所对应的字符
- ord() 返回一个字符所对应的Unicode编码
- 8、字符串的索引【index】
- 1、作用
- 序列都可以通过索引来访问序列中的元素或对象
- 2、语法
- 字符串[整数表达式]
- 3、说明
- 正向索引是从0开始，第二个索引为1，以此类推，最后一个元素的索引为字符串的长度-1
- 反向索引是从-1开始，最后一个元素的索引为-1，倒数第二个为-1，以此类推，第一个元素的索引为字符串长度的相反数
- A B C D E F G
- 0 1 2 3 4 5 6
- -7 -6 -5 -4 -3 -2 -1
- 练习：
- 输入任意一段字符串，打印出这个字符串的第一个字符，最后一个字符
- 如果这个字符串的长度为偶数，打印出一个@符号，如果这个字符串的长度为奇数，打印出中间的字符
- len() 返回一个序列的长度
- 9、字符串的切片【slice】
- 1、作用
- 从字符串中取出连续或具有一定间隔的元素
- 2、语法
- 字符串[开始索引:终止索引:步长]
- 3、参数
- 1、开始索引：切片切下的位置，0代表第一个元素，1代表第二个元素
- 2、结束索引：切片的终止点，但不包含终止点
- 3、步长：切片每次获取完当前元素后移动的方向和偏移量，没有步长相当于取值完成后，向右移动一个索引的位置(默认为1)
- 当步长为正数时，取正向切片
- 当步长为负数时，取反向切片
- 当一个字符串的切片含有步长时，等于切完当前元素后，用当前元素的索引加上步长，得到一个新的索引，获取新的索引所对应的元素
- 当一个字符串切片的步长为负数时，起始索引所对应的元素必须在终止索引所对应元素的右边，才可以进行反向切片
- A B C D E F G
- 0 1 2 3 4 5 6
- -7 -6 -5 -4 -3 -2 -1
- 练习：
- 输入一段字符串，判断这个字符串是不是回文
- ABCBA
- 上海自来水来自海上
- 4、格式化字符串
- 1、作用
- 生成一定格式的字符串
- 2、语法
- 格式化字符串%参数值
- 格式化字符串%(参数值1，参数值2)
- 3、修饰符
- - 左对齐(默认为右对齐)
- + 显示正号
- 0 左侧空白位置补0
- 宽度：整个数据输出的宽度
- 精度：保留小数点后多少位
- 5、while循环
- 1、作用
- 让程序根据条件重复的执行一条语句或者多条语句
- 2、语法
- 3、流程
- 1、先定义一个初始条件
- 2、先判断真值表达式，测试布尔值为True还是False
- 3、如果真值表达式为True，则执行语句块1，再回到第二步，判断真值表达式
- 4、如果真值表达式为False，则执行语句块2，然后结束while语句的执行
- 4、注意
- 1、要控制循环的真值表达式的值来防止死循环
- 2、通常用真值表达式中的循环变量来控制循环条件
- 3、通常在循环语句块内部需要改变循环变量来控制循环的次数和变量的走向
- 6、while循环的嵌套
- while语句本身就是复合语句，他可以嵌套到另一个语句当中
- 1、语法
- 打1~20范围内的所有整数，显示在一行内，每个整数用一个空格分隔
- 打印10行这个数据
- 7、break语句
- 1、作用
- 用于循环语句while for循环中，用来终止当前循环语句的执行
- 2、说明
- 1、当break语句执行后，此循环语句break语句之后的所有语句都将不再执行
- 2、break语句通常和if语句组合使用
- 3、break语句终止循环时，循环语句的else子句将不会执行
- 4、break语句只能终止当前循环的执行，如果有循环嵌套时，不会跳出嵌套的外层循环
- 5、break语句只能在循环语句内部使用
- 练习：
- 输入一个正整数，打印这个数是不是素数
- 8、for循环
- 1、作用
- 用来遍历可迭代对象中的数据元素
- 2、语法
- 3、可迭代对象
- 是指能够依次获取数据的对象，包括非空字符串，非空列表，非空字典、元组等
- 4、说明
- 1、变量依次用可迭代对象每次给出的元素依次赋值，然后执行语句块1
- 2、可迭代对象不能提供数据元素后，执行else子句中的语句部分，然后退出循环
- 3、else子句部分可以省略
- 练习：
- 写一个程序，输入一段字符串，打印出这个字符串中有多少个空格
- 9、for循环的嵌套
- 10、range函数
- 1、作用
- 用来创建一个生成一系列整数的可迭代对象(也叫作整数序列生成器)
- range(stop)从0开始，每次生成一个整数后加1操作，直到stop为止
- range(start,stop,step)从start开始，每次生成一个整数后移动step，直到stop为止
- 11、continue语句
- 1、作用
- 用于循环语句中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
- 2、说明
- 1、在while循环中执行continue语句，将会直接跳转到while语句的真值表达式处重新判断循环条件
- 2、在for循环中执行continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次进行循环
- 12、random随机模块
- 1、random.random()
- 用于生成一个0到1范围内的随机浮点数
- 2、random.randint(a,b)
- 用于生成一个指定范围内的整数，其中a是下限，b是上限
- 3、random.randrange(start,stop,step)
- 从指定范围内，按照指定基数递增的集合中获取一个随机数
- 13、列表【list】
- 1、作用
- 用来存储任意类型数据的容器
- 2、概念
- 1、列表是一种容器，可以存储任意类型的数据
- 2、列表是可变序列
- 3、元素与元素之间没有任何的关联关系，他们之间具有先后顺序关系
- 3、表示方式
- []
- 4、列表的运算
- + 用于拼接列表，生成新的列表，内存地址会发生变化
- += 用于原列表与右侧列表进行拼接，并用该变量重新绑定新列表，内存地址不会改变
- * 生成重复列表，生成新的列表，内存地址会发生变化
- *= 用于生成重复列表，并用该变量重新绑定新列表，内存地址不会变化
- 5、列表的比较运算
- 1、符号
- > >= < <= == !=
- 2、规则
- 根据列表对应位置上字符(数据类型必须相同)的Unicode编码值比较大小
- 3、in not in运算符
- 判断一个对象是否存在于序列当中
- 6、列表的索引与切片
- 列表的索引与切片规则同字符串中的规则完全相同
- 7、列表的索引赋值
- 列表是可变序列，可以通过索引赋值来改变列表中的元素
- 8、列表的切片赋值
- 1、作用
- 可以改变原列表的排序，可以插入和修改数据
- 可以用切片来改变列表对应元素的值
- 2、语法
- 列表[切片]=可迭代对象
- append()方法
- 向列表末尾追加一个元素
- L.append()
- 14、字典【dict】
- 1、概念
- 1、字典是一种可变的容器，可以存储任意类型的数据
- 2、字典中每个数据都用键(key)值(value)对进行映射存储
- 3、字典中的每个数据都是用键进行索引，而不是用下标进行索引
- 4、字典中的键不能重复，且只可以用不可变类型作为字典的键
- 5、字典的数据没有先后顺序关系，字典的存储是无序的
- 2、作用
- 可以提高数据的检索速度
- 3、表示方式
- 用{}括起来，以逗号分隔每个键值对，键和值之间:分隔
- 4、字典的索引
- 1、语法
- dict[key]
- 5、字典的基本操作
- 1、增加键值对
- dict[key]=value
- 2、修改键值对
- dict[key]=value
- 3、删除键值对
- del dict[key]
- 6、in not 运算符
- 判断一个键是否存在于字典当中
- 15、元组【tuple】
- 1、概念
- 元组是不可变的序列
- 元组是可以存放任意数据类型的容器，他们之间具有先后顺序关系
- 2、表示方式
- 用()括起来，单个元素括起来后加逗号，区分是单个对象还是元组
- 3、元组的运算
- + += * *= < <= > >= == != in not in
- 规则同列表的运算规则 （数据类型相同才可以进行运算）
- 4、元组的索引与切片
- 元组的索引与切片规则等同于字符串的索引与切片规则，不具备切片和索引赋值功能
- 16、字符串文本解析函数
- 1、split()
- 拆分字符串，通过制定的分隔符对字符串进行切片，返回分割后的字符串列表
- S.split()
- 2、join()
- S.join(iterable)
- 用可迭代对象中的字符串，返回一个中间用S分隔的字符串
- 17、函数
- 1、概念
- 函数是可以重复的语句块
- 函数可以视为一段程序语句的集合，并且给予一个名称来代替
- 2、作用
- 可以重复使用，提高代码的重用性
- 3、语法
- 4、说明
- 1、函数名必须是标识符，符合变量的命名规则
- 2、函数有自己的名字空间，要让函数处理外部数据，通过参数列表对次函数传入一些数据，如果不需要传入参数，则参数列表可以为空，但是语句部分不能为空，需要用pass语句填充
- 3、函数名是一个变量，不能轻易对其赋值
- 5、函数的调用
- 1、函数的调用是一个表达式
- 2、如果没有return语句，此函数执行完毕后返回None对象
- 3、如果函数需要返回其他的对象则要使用return语句
- 6、return语句
- 1、语法
- return [表达式]
- 2、作用
- 用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个指对象的引用关系
- 3、说明
- 1、return语句后的表达式可以省略，省略后相当于return None
- 2、如果函数内没有return语句，则函数执行完最后一条语句后返回None，相当于在最后加了一条 return None语句
- 1、解析模块
- 1、数据的分类
- 1、结构化数据
- 特点:固定格式 html json xml
- 2、非结构化数据
- 图片 视频 音频 一般存储为二进制
- 2、正则表达式模块 re
- 1、正则表达式中的元字符
- 2、match()
- 尝试从字符串的起始位置匹配正则表达式，如果成功，返回匹配后的结果，否则返回None
- 3、匹配目标
- 想从字符串中获取一部分指定的内容，可以用括号将想提取的数据用括号括起来。括号实际上标记了一个子表达式的开始和结束索引，被标记的每个子表达式会依次对应一个分组，调用group方法传入分组的索引即可提取结果
- 4、通用匹配
- 有一个万能匹配可以使用就是.*，其中(.)可以匹配任意字符串(除换行符外)，星号代表匹配前面的字符无限次，所以他们组合在一起就是匹配任意字符
- 5、贪婪匹配与非贪婪匹配
- 1、贪婪匹配(.*):在整个表达式匹配成功的前提下，尽可能多的匹配
- 2、非贪婪匹配(.*?):在整个表达式匹配成功的前提下，尽可能少的匹配
- 6、修饰符
- 正则表达式可以包含一些可选标志修饰符来控制匹配的模式，修饰符被指定为一个可选标志
- 常见修饰符
- 7、search()
- match方法一旦开头不匹配，那么整个匹配就会失败
- 1、作用
- 会在匹配时扫描整个字符串，然后返回第一个成功匹配的结果
- 2、语法
- re.search(pattern,string,flags=0)
- 3、参数说明
- 1、pattern：匹配的正则表达式
- 2、string：需要匹配的字符串
- 3、flags：标志位
- 8、findall()
- 如果想要获取匹配正则表达式的所有文本内容，就需要用到findall()，该方法会搜索整个字符串，然后返回匹配正则表达式的所有内容
- sub()
- 可以使用正则表达式来修改文本
- 9、compile()
- 可以将正则表达式字符串变异成正则表达式对象，以便于在后面的匹配中重复使用
- 3、csv模块
- 1、导入模块
- import csv
- 2、打开csv文件
- with open("xx.csv","w",newline="",encoding="utf-8") as f:
- newline=""必须添加，否则会多出空行
- 3、初始化写入对象
- witer=csv.writer(f)
- 4、写入数据
- writer.writerow([列表])
- 4、猫眼电影项目
- 提取电影信息的正则表达式：
- 编写一个爬虫程序，可以爬取所有排行榜电影的名称，主演，上映时间，并且存储到excel表格当中，存储到本地
- 1、拼接每页的url信息
- 2、编写获取网页源代码的函数
- 3、编写从网页源代码中解析有用数据的函数
- 4、编写将数据写入到本地csv文件的函数
- 5、模块安装
- python -m pip install requests
- python -m pip install bs4
- python -m pip install lxml
- 6、requests模块
- 1、常用方法
- 1、res=requests.get(url,headers=)
- 向网站发起请求并获取响应对象
- 2、响应对应的属性(res)
- 1、res.text 从字节流变为字符串
- 2、res.encoding="utf-8"
- 3、res.content 二进制字节流(下载图片音频视频时需要使用)
- 4、res.status_code 返回HTTP响应码
- 5、res.url 返回实际数据的url
- 6、url编码参数(params)
- params:字典
- res=requests.get(url,params={},headers=)
- 自动对params进行url编码，然后和url进行拼接
- 7、BeautifulSoup解析器
- 1、节点选择器
- 2、获取属性
- 3、嵌套选择
- 4、方法选择器
- 1、find_all()
- 查询所有符合条件的元素，给他传入一些属性或文本，就可以得到所有符合条件的元素
- 5、attrs
- 除了根据节点名称查询外，我们也可以出入一些属性来查询
- 6、text
- text可以匹配节点的文本，传入的形式可以是字符串，也可以是正则表达式
- 7、find()
- 返回匹配到的第一个元素
- 8、css选择器
- 使用css选择器时，需要调用select()方法，传入相应的css选择器
- css选择器中id名前用 #表示
- css选择其中类名前用 . 表示
- 嵌套选择
- 获取文本
- 需要安装的模块
- python -m pip install jieba
- python -m pip install wordcloud
- python -m pip install matplotlib
- python -m pip install imageio
- 我想等 等等 等过的那辆车
- 项目3、爬取豆瓣网任意一部电影的短评存入到本的txt文本中
- 项目4、爬取www.gushiwen.org中的第一页的古诗词信息，并保存到本地
- day5
- 1,jieba分词
- 1，分词模式
- 1，精确分词，试图将句子最精确的分开，适合文本分析
- 2，全模式：将句子中所有可以成词的词语都扫秒出来，速度非常快，但是不能解决歧义问题
- 3，搜索引擎模式：在精确模式的基础上对长词进行切分，提高召回率，适用于搜索引擎
- 2，分词方法
- 对于一段长文字，分词原理大致分为三部分：
- 1，首先用正则表达式将中文段落粗略分为一个个的句子
- 2，将每个句子构造成有向无环图，之后寻找最佳切割方案
- 3，最后对于连续的词语，采用HMM模型再次划分
- 2，codecs
- 这种方法可以指定一个编码打开文件，使用这个方法打开的文件读取返回的是Unicode编码，写入时编码也是Unicode
- 使用open()时时指定Unicode编码写入，如果str，则根据源代码文件声明的字符编码解码成Unicode之后再进行操作,相对于open（），这个不容易出现问题
- 3,xpath解析模块
- 1，概念
- 全程为XML path language,即XML路径语言，他是一门再XML文档中查找信息的语言
- 2，使用流程
- 3,xpath常用规则
- 4，所有节点
- 1,返回类型是一个列表，每个元素是Element类型，后面跟了很多节点名
- 2,也可以指定节点名称，获取数据
- 5，子节点
- 可以通过/或者//查找字节点或者子孙节点
- 6，父节点
- 通过(..)可以查询当前节点的父节点信息
- 7，属性匹配
- 8，文本获取
- 用xpath中的text()方法可以获取节点
- 9，属性多值匹配(contains)
- 有时候某些节点的属性不止一个，此时我们就需要用到多值匹配
- 通过contains方法，第一个参数传入属性名称，第二个参数传入属性值，只要此属性包含所传入的属性值，就可以完成匹配
- 10，按序选择
- 有时候，在选择的时候某些属性同时匹配了多个节点，但是只想要其中的某个节点，就要
- 1、答辩的内容
- 1、PPT 介绍小组 组员 分工 项目的内容
- 2、实训总结
- 3、平时上课的源代码 笔记 (答辩项目的源代码)
- 2、答辩项目
- 任意选取网站，爬取网站的数据(文本信息 图片信息 音频信息)
- 3、json模块
- 1、概念
- javascript中的对象和数字
- 对象：{"key":"value"} json中的数据必须用双引号来表示
- 数组：[x1,x2,x3]
- 2、json模块的作用
- json格式的字符串和python数据类型之间的转换
- 3、读取json
- json.loads() :
- 作用：json格式 ————>python数据类型
- json python
- 对象 字典
- 数组 列表
- 4、输出json
- json.dumps()
- 作用：python数据类型------>json格式
- python json
- 字典 对象
- 列表 数组
- 元组 数组
- 注意：
- 1、json.dumpa() 默认使用ascii编码
- 2、添加 ensure_ascii=False，禁用ascii编码
- 如果存在中文，需要先指定编码，然后将ensure_ascii参数设置为False
- 4、抓取动态ajax请求网页的过程
- 1、分析网页的请求规则，打开审查元素，选择xhr选项，通过滚动滑轮，查看网页请求的变化规律，找到js的请求信息
- 2、找到请求信息后，选择请求，进入到请求体中，选择preview选项，查看返回信息中是否有我们想要的数据
- 3、如果返回信息中存在想要的数据，选择Headers选项，查看RequestURL参数，找到网页的真实的url，然后查询其中的参数，一般url的参数都在Headers选项中的Query Sring Parameters中存在
- 4、通过真实url的公有部分和参数进行拼接，得到可以获取更多信息的url，然后获取js中json信息
1.python解释器类型
1.cpython:c语言开发的
2.jpython：java语言开发的
3.Ironpython:.net语言开发
2.python中程序的组成
程序是有模块组成
模块中包含语句，函数，类等
语句包含表达式
表达式建立并处理数据对象并返回对象的引用关系
3.python中的数据类型
int float complex（1+2j相当于复数）布尔类型
4.python算术运算符和表达式
表达式：由数学和运算符组成
作用：让计算机做一些事并返回值
运算符：+ - * //地板除（除法取整） %取余 幂运算
5.数值类型函数
1.abs（）返回一个数的绝对值
2.round（number，【ndigits】）
number：将要处理的数据
ndigits：保留小数点后几位小数
在python中如果一个函数的参数带有【】。代表这个参数可有可无，可以传参数也可以不传参数
3.pow（x，y，z=None）
xy%z
6.变量
1.概念
变量是关联一个对象的标识符
2.作用
用来绑定一个对象，并返回对象的引用关系，以便于以后重复使用
3.变量的命名规则
以字母或下划线开头，后接字母下划线或者数字
不能用python中的关键字作为变量名（大约有33个）
7.赋值语句
1.语法
变量名=表达式
2.类型
变量本身没有类型，他的类型是由绑定的对象决定的
3.说明
1.当变量不存在时，创建此变量，并与对象建立起关系联系
2.当变量存在时，改变变量于对象的绑定关系
4.注意
1.一个变量只能绑定一个变量
2.一个对象可以绑定多个变量
8.python中的小整数对象池
在cpython中，-5~256这个范围内的数字会永远的存在于内存地址当中，永远不会被释放
9.pycharm中的大整数对象池
pycharm的开发者为了节省内存，把同一个文件下的相同对象默认为是同一个对象
10.基本输出函数【print】
1.作用
将一系列的值按照字符的形式输出到标准输出设备上
2.语法
print（value，sep="",end="/n"）
value 输出的内容
；sep代表输出内容之间的分隔符 默认
11,标准输入函数 [input]
1.作用：从标准输入设备上获取一系列的字符
2.语法：input(“提示字符串”)
3.返回类型：str字符串
注释用#。
12，类型转换函数
1.float()：将字符串或数字转换为浮点型数
2.int():将字符串或数字转换为十进制整数型数
int([obj],base=10)
obj:将要处理的数据，base:代表obj数据的进制
比如：int(“11”,base=2),则返回3，
13，比较运算
,>=,<,<=,==,!=
1、语句 statement
1、概念
语句是python程序执行的最小单位
2、说明
多条语句写在一行内需要用(;)分隔，但是不建议这样写
3、折行符【\】
1、显示换行
折行符【\】是告诉解释执行器，下一行的代码也是此语句的内容
2、隐式换行
所有括号内的内容换行时，解释执行器会自动去下一行找到相对应的括号，直到找到为止
s=100+300+56+2345+10
s1=100+300+56+\
2345+10
s2=(100+300+56+
2345+10)
print(s)
print(s1)
print(s2)
2、if条件判断语句
1、作用
让程序根据条件选择性的执行某条或者某些语句
2、语法
if 真值表达式1:
语句块1
elif 真值表达式2:
语句块2
elif 真值表达式3:
语句块3
else:
语句块4
3、说明
1、真值判断会自上而下进行，如果有一条真值表达式的值为True，则执行其中的语句，然后结束if语句的执行，如果所有的真值表达式的值都为False，那么则执行else语句中的语句块
2、elif子句可以有1个，0个或者多个
3、else子句只能有1个或者0个
# n=int(input("请输入一个数字："))
# if n%2==0:
# print(n,"是偶数！")
# else:
# print(n,"是奇数！")
# n=int(input("请输入一个数字："))
# if n>0:
# print(n,"是正数！")
# if n<0:
# print(n,"是负数！")
# else:
# print("n为0！")
month=int(input("请输入月份数："))
if 1<=month<=12:
# pass #占位符
if month<=3:
print("春季！")
elif month<=6:
print("夏季！")
elif month<=9:
print("秋季！")
else:
print("冬季！")
else:
print("您输入的月份有误，请重新输入！")
if与elif的区别：如果程序中判断事件很多，全部用if的话，会遍历整个程序，如果用elif程序运行时，只要if或后续某个elif之一满足条件后，则程序执行完对应输入语句后就会结束程序(即不再去冗余的执行后续elif和else语句)提高效率
练习
分别写一个程序，输入学生的三科成绩，判断出最高成绩和最低成绩
a=int(input("请输入第一科成绩:"))
b=int(input("请输入第二科成绩:"))
c = int(input("请输入第三科成绩:"))
# 方法一
# if c < a > b:
# print(a,"是最高成绩！")
# elif a<b>c:
# print(b,"是最高成绩！")
# else:
# print(c,"是最高成绩！")
# 方法二
m=a # 假设a就是最高成绩
if b>m:
m=b #因为b比最高成绩还高，所以把b赋值给最高成绩的变量
if c>m:
m=c
print(m,"是最高成绩！")
3、字符串【str】
1、作用
用来记录文本信息
2、表示方式
用引号引起来的部分都叫做字符串
‘’ 单引号
“” 双引号
‘’’’’’ 三单引号
“”"""" 三双引号
3、引号说明
单引号内的双引号不算结束符
双引号内的单引号不算结束符
>>> s='hello world'
>>> type(s)
<class 'str'>
>>> s
'hello world'
>>> s="hello world"
>>> s
'hello world'
>>> s='I'm a student'
File "<stdin>", line 1
s='I'm a student'
^
SyntaxError: invalid syntax
>>> s="I'm a student"
>>> s
"I'm a student"
三引号的作用：
三引号内可以包含单引号和双引号
三引号字符串中的换行符会自动转换为\n
三引号一般用来表示函数或者类的文档字符串
>>> s="""hello world ... my name is xx ... """ >>> s 'hello world\nmy name is xx\n' >>> print(s) hello world my name is xx
4、转义字符
用转义字符代表特殊的字符
字符串字面值中 用字符串\后接一些字符代表一个特殊的字符串
s='I\'m a student' #用\'代表一个‘
常见转义字符
| 符号 | 描述 | 符号 | 描述 |
|---|---|---|---|
| \’ | 代表一个单引号 | \" | 代表一个双引号 |
| \n | 代表一个换行符 | \\ | 代表一个\ |
| \r | 返回光标至行首 | \t | 水平制表符(Tab) |
5、原始字符串【raw】
1、作用
让转移字符\无效
2、语法
r"字符串"
>>> s="C:\newfile\test.py" >>> print(s) C: ewfile est.py >>> s=r"C:\newfile\test.py" >>> print(s) C:\newfile\test.py >>>
6、字符串的运算
1、符号
+ 加号运算用于拼接字符串
+= 运算符用于原字符串与右侧字符串进行拼接生成新的字符串
* 用于生成重复的字符串
*= 生成重复的字符串并让原变量绑定生成后的字符串
7、字符串的比较运算
1、符号
> >= < <= == !=
2、比较规则
根据字符对应的Unicode编码值进行比较
Unicode编码叫做万国码 65535
3、函数
chr() 返回Unicode编码所对应的字符
ord() 返回一个字符所对应的Unicode编码
>>> ord("徐")
24464
>>> ord("a")
97
>>> ord("A")
65
>>>
>>> chr(24464)
'徐'
>>> chr(55555)
'\ud903'
>>> chr(46783)
'뚿'
>>>
>>> "a">"A"
True
>>> "ABC">"abc"
False
>>> "ABC" > "Abc"
False
>>> "ABC" >"ABCD"
False
>>>
8、字符串的索引【index】
1、作用
序列都可以通过索引来访问序列中的元素或对象
2、语法
字符串[整数表达式]
3、说明
正向索引是从0开始，第二个索引为1，以此类推，最后一个元素的索引为字符串的长度-1
反向索引是从-1开始，最后一个元素的索引为-1，倒数第二个为-1，以此类推，第一个元素的索引为字符串长度的相反数
A B C D E F G
0 1 2 3 4 5 6
-7 -6 -5 -4 -3 -2 -1
练习：
输入任意一段字符串，打印出这个字符串的第一个字符，最后一个字符
如果这个字符串的长度为偶数，打印出一个@符号，如果这个字符串的长度为奇数，打印出中间的字符
len() 返回一个序列的长度
s=input("请输入一段字符串：")
print(s[0])
print(s[-1])
if len(s)%2==0:
print("@")
else:
mid_index=len(s)//2 #求出中间字符所对应的索引
print(s[mid_index])
9、字符串的切片【slice】
1、作用
从字符串中取出连续或具有一定间隔的元素
2、语法
字符串[开始索引:终止索引:步长]
3、参数
1、开始索引：切片切下的位置，0代表第一个元素，1代表第二个元素
2、结束索引：切片的终止点，但不包含终止点
3、步长：切片每次获取完当前元素后移动的方向和偏移量，没有步长相当于取值完成后，向右移动一个索引的位置(默认为1)
当步长为正数时，取正向切片
当步长为负数时，取反向切片
当一个字符串的切片含有步长时，等于切完当前元素后，用当前元素的索引加上步长，得到一个新的索引，获取新的索引所对应的元素
当一个字符串切片的步长为负数时，起始索引所对应的元素必须在终止索引所对应元素的右边，才可以进行反向切片
A B C D E F G
0 1 2 3 4 5 6
-7 -6 -5 -4 -3 -2 -1
>>> s[0:3] 'ABC' >>> s[1:5] 'BCDE' >>> s[1:-1] 'BCDEF' >>> s[0:-1:2] 'ACE' >>> s[-1:0:-2] 'GEC' >>> >>> s[0:-1:-2]
练习：
输入一段字符串，判断这个字符串是不是回文
ABCBA
上海自来水来自海上
4、格式化字符串
1、作用
生成一定格式的字符串
2、语法
格式化字符串%参数值
格式化字符串%(参数值1，参数值2)
fmt="姓名:%s,年龄:%d" name="小明" age=20 print(fmt%(name,age))
| 符号 | 描述 |
|---|---|
| %s | 字符串占位符 |
| %d | 十进制整数占位符 |
| %f | 十进制浮点数占位符 |
3、修饰符
- 左对齐(默认为右对齐)
+ 显示正号
0 左侧空白位置补0
宽度：整个数据输出的宽度
精度：保留小数点后多少位
>>> a 123 >>> "%d"%123 '123' >>> "%10d"%123 ' 123' >>> "%-10d"%123 '123 ' >>> "%-+10d"%123 '+123 ' >>> "%0+10d"%123 '+000000123' >>> "%f"%123.456 '123.456000' >>> "%.2f"%123.456 '123.46' >>> "%2f"%123.456 '123.456000' >>> "%f"%123.4567891 '123.456789' >>> "%.7f"%123.4567891 '123.4567891' >>>
5、while循环
1、作用
让程序根据条件重复的执行一条语句或者多条语句
2、语法
初始条件
while 真值表达式:
语句块1
条件变化量
else:
语句块2
3、流程
1、先定义一个初始条件
2、先判断真值表达式，测试布尔值为True还是False
3、如果真值表达式为True，则执行语句块1，再回到第二步，判断真值表达式
4、如果真值表达式为False，则执行语句块2，然后结束while语句的执行
i=1 #用来记录循环次数的变量
while i<=10:
print("hello world")
i+=1
4、注意
1、要控制循环的真值表达式的值来防止死循环
2、通常用真值表达式中的循环变量来控制循环条件
3、通常在循环语句块内部需要改变循环变量来控制循环的次数和变量的走向
6、while循环的嵌套
while语句本身就是复合语句，他可以嵌套到另一个语句当中
1、语法
while 真值表达式1:
语句块1
while 真值表达式2:
语句块2
else:
语句块3
else:
语句块4
打1~20范围内的所有整数，显示在一行内，每个整数用一个空格分隔
打印10行这个数据
j=1
while j<=10:
i=1
while i<=20:
print(i,end=" ")
i+=1
else:
print() #打印一个换行符
j+=1
7、break语句
1、作用
用于循环语句while for循环中，用来终止当前循环语句的执行
2、说明
1、当break语句执行后，此循环语句break语句之后的所有语句都将不再执行
2、break语句通常和if语句组合使用
3、break语句终止循环时，循环语句的else子句将不会执行
4、break语句只能终止当前循环的执行，如果有循环嵌套时，不会跳出嵌套的外层循环
5、break语句只能在循环语句内部使用
i=1
while i<10:
print("循环开始时的i=",i)
if i==5:
break
print("循环结束时的i=",i)
i+=1
else:
print("else语句被执行！")
print("程序退出时的i=",i)
练习：
输入一个正整数，打印这个数是不是素数
n=int(input("请输入一个正整数："))
if n<=1:
print("不是素数！")
elif n==2:
print(n,"是素数！")
else:
i=2
while i<n:
if n%i==0:
print("不是素数")
break
i+=1
else:
print("是素数！")
8、for循环
1、作用
用来遍历可迭代对象中的数据元素
2、语法
for 变量 in 可迭代对象:
语句块1
else:
语句块2
3、可迭代对象
是指能够依次获取数据的对象，包括非空字符串，非空列表，非空字典、元组等
4、说明
1、变量依次用可迭代对象每次给出的元素依次赋值，然后执行语句块1
2、可迭代对象不能提供数据元素后，执行else子句中的语句部分，然后退出循环
3、else子句部分可以省略
s="ABCDEF"
for i in s:
print(i,end=" ")
print()
else:
print("循环因迭代结束而终止！")
练习：
写一个程序，输入一段字符串，打印出这个字符串中有多少个空格
s=input("请输入一个字符串：")
count=0 #用来统计空格个数的变量
# i=0
# lenth=len(s)
# while i<lenth:
# if s[i]==" ":
# count+=1
# i+=1
# print("输入的空格个数为%d个"%count)
for i in s:
if i==" ":
count+=1
print("输入的空格个数为%d个"%count)
9、for循环的嵌套
for x in "ABC":
for y in "123":
print(x+y)
10、range函数
1、作用
用来创建一个生成一系列整数的可迭代对象(也叫作整数序列生成器)
range(stop)从0开始，每次生成一个整数后加1操作，直到stop为止
range(start,stop,step)从start开始，每次生成一个整数后移动step，直到stop为止
for i in range(10):
print(i,end=" ")
print()
for i in range(1,20,2):
print(i,end=" ")
11、continue语句
1、作用
用于循环语句中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
2、说明
1、在while循环中执行continue语句，将会直接跳转到while语句的真值表达式处重新判断循环条件
2、在for循环中执行continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次进行循环
for i in range(5):
if i==2:
continue
print(i)
12、random随机模块
1、random.random()
用于生成一个0到1范围内的随机浮点数
2、random.randint(a,b)
用于生成一个指定范围内的整数，其中a是下限，b是上限
3、random.randrange(start,stop,step)
从指定范围内，按照指定基数递增的集合中获取一个随机数
import random a=random.random() print(a) b=random.randint(1,100) print(b) c=random.randrange(1,100,2) print(c)
13、列表【list】
1、作用
用来存储任意类型数据的容器
2、概念
1、列表是一种容器，可以存储任意类型的数据
2、列表是可变序列
3、元素与元素之间没有任何的关联关系，他们之间具有先后顺序关系
3、表示方式
[]
4、列表的运算
+ 用于拼接列表，生成新的列表，内存地址会发生变化
+= 用于原列表与右侧列表进行拼接，并用该变量重新绑定新列表，内存地址不会改变
* 生成重复列表，生成新的列表，内存地址会发生变化
*= 用于生成重复列表，并用该变量重新绑定新列表，内存地址不会变化
>>> L=[100,200,300,400] >>> id(L) 1883498866184 >>> L=L+[500,600] >>> L [100, 200, 300, 400, 500, 600] >>> id(L) 1883498866824 >>> L=[100,200,300,400] >>> id(L) 1883498866184 >>> L+=[500,500] >>> L [100, 200, 300, 400, 500, 500] >>> id(L) 1883498866184 >>> >>> s="abc" >>> id(s) 1883497905432 >>> s=s+"de" >>> s 'abcde' >>> id(s) 1883498848184 >>> s="abc" >>> id(s) 1883497905432 >>> s+="de" >>> s 'abcde' >>> id(s) 1883498848128 >>>
5、列表的比较运算
1、符号
> >= < <= == !=
2、规则
根据列表对应位置上字符(数据类型必须相同)的Unicode编码值比较大小
3、in not in运算符
判断一个对象是否存在于序列当中
6、列表的索引与切片
列表的索引与切片规则同字符串中的规则完全相同
7、列表的索引赋值
列表是可变序列，可以通过索引赋值来改变列表中的元素
>>> L=[100,200,300] >>> L[0]="hello" >>> L ['hello', 200, 300] >>>
8、列表的切片赋值
1、作用
可以改变原列表的排序，可以插入和修改数据
可以用切片来改变列表对应元素的值
2、语法
列表[切片]=可迭代对象
>>> L=[100,200,300,400,500,600] >>> L[0:1] [100] >>> L[0:1]=["A"] >>> L ['A', 200, 300, 400, 500, 600] >>> L[0:1]=["A","B"] >>> L ['A', 'B', 200, 300, 400, 500, 600] >>> >>> L[0:3] ['A', 'B', 200] >>> L[0:5:2] ['A', 200, 400] >>> L[0:5:2]=["hello","world","name"] >>> L ['hello', 'B', 'world', 300, 'name', 500, 600] >>> L[0:5:2]=["hello","world","name",100] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: attempt to assign sequence of size 4 to extended slice of size 3 >>> L[0:5:2]=["hello","world","name",] >>> L ['hello', 'B', 'world', 300, 'name', 500, 600] >>> >>> L[0:0] [] >>> L[0:0]=[1000] >>> L [1000, 'hello', 'B', 'world', 300, 'name', 500, 600]
append()方法
向列表末尾追加一个元素
L.append()
14、字典【dict】
1、概念
1、字典是一种可变的容器，可以存储任意类型的数据
2、字典中每个数据都用键(key)值(value)对进行映射存储
3、字典中的每个数据都是用键进行索引，而不是用下标进行索引
4、字典中的键不能重复，且只可以用不可变类型作为字典的键
5、字典的数据没有先后顺序关系，字典的存储是无序的
2、作用
可以提高数据的检索速度
3、表示方式
用{}括起来，以逗号分隔每个键值对，键和值之间:分隔
>>> d={}
>>> d
{}
>>> type(d)
<class 'dict'>
>>> d={"name":"小明","age":20}
>>> d
{'name': '小明', 'age': 20}
>>>
4、字典的索引
1、语法
dict[key]
>>> d["name"] '小明' >>> d["age"] 20 >>>
5、字典的基本操作
1、增加键值对
dict[key]=value
2、修改键值对
dict[key]=value
3、删除键值对
del dict[key]
6、in not 运算符
判断一个键是否存在于字典当中
15、元组【tuple】
1、概念
元组是不可变的序列
元组是可以存放任意数据类型的容器，他们之间具有先后顺序关系
2、表示方式
用()括起来，单个元素括起来后加逗号，区分是单个对象还是元组
>>> t=(100,200) >>> t (100, 200) >>> type(t) <class 'tuple'> >>> t=(100) >>> t 100 >>> type(t) <class 'int'> >>> t=(100,) >>> t (100,) >>> type(t) <class 'tuple'>
3、元组的运算
+ += * *= < <= > >= == != in not in
规则同列表的运算规则 （数据类型相同才可以进行运算）
4、元组的索引与切片
元组的索引与切片规则等同于字符串的索引与切片规则，不具备切片和索引赋值功能
16、字符串文本解析函数
1、split()
拆分字符串，通过制定的分隔符对字符串进行切片，返回分割后的字符串列表
S.split()
>>> s="www.baidu.com"
>>> s.split(".")
['www', 'baidu', 'com']
>>>
2、join()
S.join(iterable)
用可迭代对象中的字符串，返回一个中间用S分隔的字符串
>>> L="hello" >>> "-".join(L) 'h-e-l-l-o' >>> " ".join(L) 'h e l l o' >>>
17、函数
1、概念
函数是可以重复的语句块
函数可以视为一段程序语句的集合，并且给予一个名称来代替
2、作用
可以重复使用，提高代码的重用性
3、语法
def 函数名(参数列表[形参]):
语句块
4、说明
1、函数名必须是标识符，符合变量的命名规则
2、函数有自己的名字空间，要让函数处理外部数据，通过参数列表对次函数传入一些数据，如果不需要传入参数，则参数列表可以为空，但是语句部分不能为空，需要用pass语句填充
3、函数名是一个变量，不能轻易对其赋值
def say_demo():
print("hello world")
print("wlecome to Hangzhou")
print("xxx")
say_demo() #函数的调用
5、函数的调用
1、函数的调用是一个表达式
2、如果没有return语句，此函数执行完毕后返回None对象
3、如果函数需要返回其他的对象则要使用return语句
6、return语句
1、语法
return [表达式]
2、作用
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个指对象的引用关系
3、说明
1、return语句后的表达式可以省略，省略后相当于return None
2、如果函数内没有return语句，则函数执行完最后一条语句后返回None，相当于在最后加了一条 return None语句
day3
1,函数的实参传递方式
1.位置传参
实参和形参的对应关系是按照位置来依次对应的
def func(a,b,c):
print(“a”,a)
print(“b”,b)
print(“c”,c)
func(100,200,300)
2.序列传参
序列传参是指函数调用过程中，用*将序列拆解后，按照位置传参的方式进行参数传递
def func(a,b,c):
print("a",a)
print("b",b)
print("c",c)
L【100,200,300】
func(*L)
3.关键字传参
传参时，形参和实参按照名称进行匹配
def func(a,b,c):
print("a",a)
print("b",b)
print("c",c)
func(a=100,b=200,c=300)
4.字典关键字传参
是指当实参为字典时，用**将字典拆解后，按照关键字传参的方式进行传参
def func(a,b,c):
print("a",a)
print("b",b)
print("c",c)
d=("a":100,"b":200,"c":300)
func(**d)
2,函数的缺省参数
1.语法
def 函数名(形参名1=默认值，。。。)：
pass
缺省参数必须自右至左依次存在，如果有一个参数为缺省参数，那么其右侧的所有参数都必须为缺省参数
3,函数的形参的定义方式
1.位置形参
按照形参的位置接受实参
2.星号元组形参
def 函数名(*args):
print("实参个数为"，len(args))
print("args",args)
3.命名关键字形参
1.语法
def func(*,命名关键字形参)
pass
def func(*args,命名关键字形参)
pass
2.作用
所有的命名关键字形参必须用关键字传参或者字典关键字进行传参
def func(**kwargs):
print("关键字参数个数为："，len(kwar gs))
print("kwar gs=",kwar gs)
func(a=100,b=200,c="300")
函数参数自左向右的顺序：
位置形参 星号元组形参 命名关键字形参 双星号关键字形参
4.双星号字典形参
1.语法
def func(**kwargs)
pass
2.作用
收集多余的关键字传参
def func(**kwargs):
print("关键字参数个数为："，len(kwar gs))
print("kwar gs=",kwar gs)
func(a=100,b=200,c="300")
函数参数自左向右的顺序：
位置形参 星号元组形参 命名关键字形参 双星号关键字形参
4,函数变量问题
1.局部变量
定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
局部变量只能在函数的内部使用
局部变量在函数调用时被创建，在函数调用之后自动销毁
2.全局变量
定义在函数外部，模块内部（当前.py）的变量称为全局变量
全局变量，所有函数都可以直接访问（但函数内部不能将其直接赋值）
局部变量的说明
1.在函数内首次对变量赋值时创建局部变量，再次为变量赋值时修改局部变量的绑定关系
2.在函数内部的赋值语句不会对全局变量造成影响
3.局部变量只能在被声明的函数内部访问，而全局变量可以在整个模块（当前文件）范围内访问
注意：cpython中解释执行器会把运算符左侧的变量默认为局部变量
5,面向对象编程
1.对象
现实生活中的物体或者实例
2.面向对象编程
把一切看成对象，对象和对象之间用行为建立起关系联系
对象可以有属性【名词】
对象可以有行为【动词】
3.类【class】
拥有相同属性和行为的对象分为一组，即为一个类型
类是用来描述对象的工具，类可以创建此类的对象（实例）
类定义了该集合中每个对象所共有的属性和方法
4.语法
class 类名（继承列表）：
"""类的文档字符串"""
实例方法
类变量
类方法
静态方法
5.作用
1.可以创建一个或多个对象（实例）
2.类内定义的变量和方法都能被此类创建的实例所拥有
6.说明
1.类名必须是标识符（和变量的命名规则相同）建议首字母大写
2.类名实质上就是变量，它绑定一个类实例
class Car():
"""此类是个汽车类"""
print("汽车工厂创建完成！")
def __init__(self,color)
self.colro=color
def run(self,speed): //self代表类产生的实例
"""用来给实例添加行驶的行为的方法"""
self.speed = speed //给实例添加上速度的属性
print("汽车正在以"，self.speed,"的速度行驶！")
def Loge(self,loge ):
self.loge=loge
print(“汽车的品牌”,self.loge)
car=Car()
car.run(100)
car.Loge(奔驰)
7.类的实例化（类的调用）
1.语法
变量=类名([创建参数列表])
2.作用
创建这个类的实例对象，并返回此实例对象的引用关系
3.说明
实例用自己的作用域和名字空间，可以为该实例田间实例变量（属性），实例可以调用类中的方法，访问类中的类变量
添加属性:car.color=黑色
8.类的实例方法
1.语法
class 类名():
def 实例方法名（self,参数1，参数2.。。）：
pass
2.作用
用于描述一个对象的行为，让此类的全部对象都可以拥有此行为
3.说明
1.实例方法本质是函数，定义在类内的函数
2.实例方法的第一个参数代表调用这个方法的实例，一般用self表示
3.实例方法属性类的属性
9.实例方法的调用
实例.实例方法名（参数列表）
类名.实例方法名（实例，调用参数）
10.类的构造函数（初始化函数）
1.语法
class 类名（）：
def __init__(self,参数列表)：
pass
2.作用
1.init方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建这个类的实例时会自动的调用该方法
2.self代表类的实例，在定义时是必须存在的，虽然不必传入相应的参数
3.如果像个自己创建的类添加形参，就需要用到构造函数
4.作用：对新创建的对象添加属性等必须的资源
11.继承
1.概念
1.继承：继承是延续旧类的功能
2.派生：在旧类的基础上添加新的功能
2.作用
1.用继承与派生机制，可以将一些共有功能加在基类
2.在不改变父类代码的基础上改变原有类的功能，实现代码共享
12.python中的文件操作
文件是用来数据存储的基本单位，通常用于长期存储数据
1.文件的操作步骤
1.打开文件
2.读写文件
3.关闭文件
2.操作格式
1，语法
open(filename,mod,[encoding])
filename文件的路径或者名称
mod文件的操作模式
encoding文件的编码格式
2.说明
打开一个文件，返回文件流对象，如果打开失败则触发ioError错误
3.关闭文件的方法
f.close()
1-1.mod参数设置
r:以只读方式打开
w:.........覆盖写入//写是具备自己创造文件的功能
a:以只写方式打开，如果源文件有内容，则追加写入
b:以二进制模式打开文件
wb:以二进制写模式打开文件
rb:以二进制读模式打开文件
t:以文本模式打开文件
4.文本的读取和写入（要自己写换行符）
1.文本的写入
1.f.write(字符串)：写字符串到一个已经打开的文件
2.fwritelines(字符串列表)：写多个字符串到一个已经打开的文件
2.文本的读取
1.f.readline() 读取一行文字
2.f.readlines() 读取多行文字
3.f.read(n) 读取N个字符
5.with语句
1.语法
with 表达式 as 变量
pass
7,python爬虫
1.web回顾
url:统一资源定位符
http:80
https：443
get获取显示在url里
post获取比较安全
8,爬虫请求模块
1.分类
1.python2中：urllib2 urllib3
2.python3中：urllib.request requests
2.常用方法
1.urllib.request.urlopen(url)
作用：向网站发起请求并获取响应
格式：字节流=res.read()//获取
字符串 res.read().decode("utf-8")//解码
2.req=urllib.request.Request(url,headers)
作用：创建一个请求对象，去向网站发起请求并获取响应
使用流程：
1.req=urllib.request.Request(url,headers) 创建请求对象
2.res=urllib.request.urlopen(req) 向网站发起请求
3.html=res.read().decode("utf-8") 解码
9,url编码模块
https://www.baidu.com/s?wd=%E8%94%A1%E5%BE%90%E5%9D%A4
1.模块名
urllib.parse：url编码模块
2.编码方法 urlencode
1.语法
urllib.parse.urlencode({字典})
//import urllib.parse
//key={"wd":"叶震源"}
//data=urllib.parse.urlencode(key) #对数据进行编码
//print(data)
3.quote方法——编码
//import urllib.parse
//data=urllib.parse.quote("源")
//print(data)
4.unquote方法——解码
//import urllib.parse
//data=urllib.parse.unquote("%E6%BA%90")
//print(data)
1
项目一
写一个小型爬虫，当程序运行起来时，在终端输入任意一个关键词，通过百度查询函数，获取查询后网页的源代码。
1.先获取查询的信息
2.对查询信息进行url编码
3.对真是的url进行拼接
4.通过真实的url进行访问，得到相应的对象
5.对相应对象进行转码。并保存到本地
/*import urllib.request
import urllib.parse
headers={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"}
base_url="https://www.baidu.com/s?" #网页的默认url
key=input("请输入您要查询的信息：")
key=urllib.parse.urlencode({"wd":key}) #对数据进行url编码
url=base_url+key #拼接得到真实的url
req=urllib.request.Request(url,headers=headers) #创建请求对象
res=urllib.request.urlopen(req) #向网站发起请求
html=res.read().decode("utf-8")
with open("百度.html","w",encoding="utf-8") as f:
f.write(html)
print("文件写入成功！")*/
项目二
写一个爬虫程序，当程序运行时，输入指定的贴吧名称，可以进入任意一个贴吧内，爬取这个贴吧内指定范围页数的源代码（用面向对象编程）
import urllib.request
import urllib.parse
class URL():
def __init__(self):
self.base_url= "https://tieba.baidu.com/f?"
self.headers= {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"}
def get_html(self,url,filename): #获取网页源代码的函数
req=urllib.request.Request(url,headers=self.headers)
res=urllib.request.urlopen(req)
html=res.read().decode("utf-8")
self.save_html(html,filename)
def get_page(self):
name=input("请输入查询的贴吧名称：")
begin=int(input("请输入爬取初始页码："))
end=int(input("请输入爬取终止页码："))
for i in range(begin,end):
key= urllib.parse.urlencode({"kw":name})#对输入的贴吧名称编码
pn=(i-1)*50 #得出控制页码数的参数
url=self.base_url+key+"&pn"+str(pn) #拼接得到的真实url
filename="第"+str(i)+"页.html"#给文件创建名称
self.get_html(url,filename) #调用上层函数获取源代码
def save_html(self,html,filename):
with open(filename,"w",encoding="utf-8") as f:
f.write(html)
print("数据保存成功")
tieba=URL()
tieba.get_page()
1、解析模块
1、数据的分类
1、结构化数据
特点:固定格式 html json xml
2、非结构化数据
图片 视频 音频 一般存储为二进制
2、正则表达式模块 re
1、正则表达式中的元字符
| 元字符 | 作用 |
|---|---|
| . | 匹配任意一个字符(不包括换行\n) |
| \d | 匹配任意数字 |
| \s | 匹配任意空白字符 |
| \S | 匹配任意非空白字符 |
| \n | 匹配一个换行符 |
| \w | 匹配字母、数字以及下划线 |
| \W | 匹配不是字母、数字、下划线 |
| * | 匹配0个或多个表达式 |
| + | 匹配出现一次或n次 |
| ？ | 匹配1个或0个前面的正则表达式定义的片段(非贪婪) |
| {m} | 精确匹配m个前面的表达式 |
| ^ | 匹配一行字符串的开头 |
| $ | 匹配一行字符串的结尾 |
| () | 匹配括号里的表达式，也表示一个组 |
2、match()
尝试从字符串的起始位置匹配正则表达式，如果成功，返回匹配后的结果，否则返回None
import re
content="Hello 123 4567 cxk_ji ni tai mei"
result=re.match("^Hello\s\d\d\d\s\d{4}\s\w{3}",content)
print(result.group())
print(result.span())
3、匹配目标
想从字符串中获取一部分指定的内容，可以用括号将想提取的数据用括号括起来。括号实际上标记了一个子表达式的开始和结束索引，被标记的每个子表达式会依次对应一个分组，调用group方法传入分组的索引即可提取结果
import re
content="Hello 123 4567 cxk_ji ni tai mei"
result=re.match("^Hello\s(\d\d\d\s\d{4})\s(\w{3})",content)
print(result.group(1))
print(result.group(2))
print(result.span())
4、通用匹配
有一个万能匹配可以使用就是.*，其中(.)可以匹配任意字符串(除换行符外)，星号代表匹配前面的字符无限次，所以他们组合在一起就是匹配任意字符
import re
content="Hello 123 4567 cxk_ji ni tai mei"
result=re.match("^Hello.*$",content)
print(result.group())
print(result.span())
5、贪婪匹配与非贪婪匹配
1、贪婪匹配(.*):在整个表达式匹配成功的前提下，尽可能多的匹配
import re
content="Hello 1234567 cxk_ji ni tai mei"
result=re.match("^Hello.*(\d+).*$",content) #贪婪匹配 得到的结果只有7
print(result.group(1))
print(result.span())
2、非贪婪匹配(.*?):在整个表达式匹配成功的前提下，尽可能少的匹配
import re
content="Hello 1234567 cxk_ji ni tai mei"
result=re.match("^Hello.*?(\d+).*$",content) #非贪婪匹配 得到的结果只有1234567
print(result.group(1))
print(result.span())
6、修饰符
正则表达式可以包含一些可选标志修饰符来控制匹配的模式，修饰符被指定为一个可选标志
import re
content="""Hello 1234567 cxk_ji
ni tai mei"""
result=re.match("^Hello.*$",content,re.S) #贪婪匹配 得到的结果只有7 re.S代表可以匹配换行符
print(result.group())
print(result.span())
常见修饰符
| 修饰符 | 描述 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地化识别匹配 |
| re.M | 多行匹配 |
| re.S | 可以匹配换行符 |
| re.U | 根据Unicode字符集解析字符 |
| re.X | 该标志通过给予你更灵活的格式以便于你正则表达式写的更易于理解 |
7、search()
match方法一旦开头不匹配，那么整个匹配就会失败
1、作用
会在匹配时扫描整个字符串，然后返回第一个成功匹配的结果
2、语法
re.search(pattern,string,flags=0)
3、参数说明
1、pattern：匹配的正则表达式
2、string：需要匹配的字符串
3、flags：标志位
import re
content="""Hello 1234567 cxk_ji
ni tai mei"""
result=re.search("cxk.*$",content,re.S)
print(result.group())
print(result.span())
8、findall()
如果想要获取匹配正则表达式的所有文本内容，就需要用到findall()，该方法会搜索整个字符串，然后返回匹配正则表达式的所有内容
sub()
可以使用正则表达式来修改文本
string="12dskjdskj34kdslkds56lkds78"
content=re.sub("\d+","",string) #去掉所有的数字，第二个参数为替换的字符串
print(content)
9、compile()
可以将正则表达式字符串变异成正则表达式对象，以便于在后面的匹配中重复使用
string1="2019-7-7 10:48"
string2="2019-7-8 11:48"
string3="2019-7-9 12:48"
pattern=re.compile("\d{2}:\d{2}") #把正则表达式编译为一个对象
result1=re.sub(pattern,"",string1)
result2=re.sub(pattern,"",string2)
result3=re.sub(pattern,"",string3)
print(result1)
print(result2)
print(result3)
3、csv模块
1、导入模块
import csv
2、打开csv文件
with open(“xx.csv”,“w”,newline="",encoding=“utf-8”) as f:
newline=""必须添加，否则会多出空行
3、初始化写入对象
witer=csv.writer(f)
4、写入数据
writer.writerow([列表])
import csv
with open("demo.csv","w",newline="",encoding="utf-8") as f:
writer=csv.writer(f) #初始化写入对象
L=["小明",20,"男"]
L1=["小红",30,"女"]
writer.writerow(L) #写入数据
writer.writerow(L1)
4、猫眼电影项目
提取电影信息的正则表达式：
'<div class="movie-item-info">.*?title="(.*?)".*?class="star">(.*?)</p>.*?class="releasetime">(.*?)</p>',re.S
编写一个爬虫程序，可以爬取所有排行榜电影的名称，主演，上映时间，并且存储到excel表格当中，存储到本地
1、拼接每页的url信息
2、编写获取网页源代码的函数
3、编写从网页源代码中解析有用数据的函数
4、编写将数据写入到本地csv文件的函数
5、模块安装
python -m pip install requests
python -m pip install bs4
python -m pip install lxml
6、requests模块
1、常用方法
1、res=requests.get(url,headers=)
向网站发起请求并获取响应对象
2、响应对应的属性(res)
1、res.text 从字节流变为字符串
2、res.encoding=“utf-8”
3、res.content 二进制字节流(下载图片音频视频时需要使用)
4、res.status_code 返回HTTP响应码
5、res.url 返回实际数据的url
import requests
url="https://www.baidu.com/"
headers={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36"}
res=requests.get(url,headers=headers)
res.encoding="utf-8"
print(res.text)
print(res.url) #返回实际数据的url地址
print(res.status_code) #返回HTTP响应码
print(res.content) #获取内容 bytes
6、url编码参数(params)
params:字典
res=requests.get(url,params={},headers=)
自动对params进行url编码，然后和url进行拼接
{"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "zh-CN,zh;q=0.9",
"Cache-Control": "max-age=0",
"Connection": "keep-alive",
"Cookie": "anonymid=jxsj5fy78nj65k; depovince=ZJ; _r01_=1; jebe_key=dacc7a51-8acd-46aa-ac34-9b0dcd0bf180%7C712e620fada2a7904696ec0f971e40cd%7C1562478178258%7C1%7C1562478176757; JSESSIONID=abcU3TNteZ-K-7OYbFlVw; ick_login=0feb451a-fdc7-4f21-9739-70aa6b149596; loginfrom=null; wp_fold=0; jebe_key=dacc7a51-8acd-46aa-ac34-9b0dcd0bf180%7C20431d0d28353673afdf82da213cc1fa%7C1562487391831%7C1%7C1562487390408; t=60525e04b0d5fb0611a37d12e64779fe7; societyguester=60525e04b0d5fb0611a37d12e64779fe7; id=964833547; xnsid=347dad61; jebecookies=5da84bdc-7000-4f30-8e5c-10fcff9ae57a|||||",
"Host": "www.renren.com",
"Upgrade-Insecure-Requests":"1" ,
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36"}
7、BeautifulSoup解析器
1、节点选择器
html = """ <html> <head> <title>The Dormouse's story</title> </head> <body> <p class="title" name="dromouse"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> """ from bs4 import BeautifulSoup soup=BeautifulSoup(html,"lxml") print(soup.title) print(soup.head) print(soup.p.string) print(type(soup.p))
2、获取属性
print(soup.p.attrs["name"]) print(soup.p.attrs) print(soup.p["name"])
3、嵌套选择
print(soup.head.title.string)
4、方法选择器
1、find_all()
查询所有符合条件的元素，给他传入一些属性或文本，就可以得到所有符合条件的元素
html="""
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
"""
from bs4 import BeautifulSoup
soup=BeautifulSoup(html,"lxml")
# print(soup.find_all(name="ul")) #按照节点名称进行查找
# print(type(soup.find_all(name="ul")[1])) #返回类型都是bs4.element.Tag 都是可迭代对象
for i in soup.find_all(name="ul"):
for li in i.find_all(name="li"):
print(li.string)
5、attrs
除了根据节点名称查询外，我们也可以出入一些属性来查询
print(soup.find_all(attrs={"id":"list-1"}))
print(soup.find_all(id="list-1"))
print(soup.find_all(class_="element"))
print(soup.find_all("ul",class_="list list-small"))
6、text
text可以匹配节点的文本，传入的形式可以是字符串，也可以是正则表达式
print(soup.find_all(text=re.compile("Hello")))
print(soup.find_all(text="Hello"))
7、find()
返回匹配到的第一个元素
print(soup.find(name="ul"))
8、css选择器
使用css选择器时，需要调用select()方法，传入相应的css选择器
css选择器中id名前用 #表示
css选择其中类名前用 . 表示
print(soup.select(".panel .panel-heading"))
print(soup.select("ul li")) #查找 ul下 li的节点信息
print(soup.select("#list-2 .element"))#查找id为list-2下的class=element的节点信息
print(soup.select("div > ul > li"))#查找 div下面的ul标签下面的li的节点信息
嵌套选择
for ul in soup.select("ul"):
print(ul["id"])
print(ul.attrs["id"])
获取文本
for li in soup.select("li"):
print("get_text:",li.get_text())
print("string:",li.string)
print("text:",li.text)
需要安装的模块
python -m pip install jieba
python -m pip install wordcloud
python -m pip install matplotlib
python -m pip install imageio
我想等 等等 等过的那辆车
项目3、爬取豆瓣网任意一部电影的短评存入到本的txt文本中
import requests
from bs4 import BeautifulSoup
class Douban():
def __init__(self):
self.baseurl="https://movie.douban.com/subject/30171425/comments?start="
self.headers ={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"}
self.star=0
def get_html(self,url):
html=requests.get(url,headers=self.headers).text
self.get_comment(html)
def get_comment(self,html):
comment_list=[]#保存处理之后的评论列表
soup=BeautifulSoup(html,"lxml")
comment=soup.select(".comment p")
# comment=soup.find_all("span",class_="short")
for i in comment:
comment_list.append(i.text)
self.save_comment(comment_list)
def save_comment(self,comment_list):
with open("comment.txt","w",encoding="utf-8") as f:
f.writelines(comment_list)
print("信息存储完成！")
def get_page(self):
begin=int(input("输入爬取起始页"))
end=int(input("输入爬取终止页"))
for page in range(begin,end+1):
self.star=(page-1)*10
url=self.baseurl+str(self.star)
self.get_html(url)#调用上层函数获取网页源代码
douban=Douban()
douban.get_page()
项目4、爬取www.gushiwen.org中的第一页的古诗词信息，并保存到本地
import requests
from bs4 import BeautifulSoup
import os
class Gushi():
def __init__(self):
self.url = "https://so.gushiwen.org/shiwen/default_0AA2.aspx"
self.headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"}
def get_html(self):
html=requests.get(self.url,headers=self.headers).text
self.get_info(html)
def get_info(self,html):
soup=BeautifulSoup(html,"lxml")
title=soup.select("div > p > a > b")
content=soup.find_all("div",class_="contson")
self.save_info(title,content)#调用保存函数
def save_info(self,title,content):
files=os.getcwd()+"\古诗词"#创建一个文件夹路径
if not os.path.exists(files):
os.mkdir(files)#创建一个文件夹
L=[]
for i in range(len(title)):
L.append(content[i].text)#把处理后的内容存入到列表当中
with open(files+"\%s.txt"%title[i].text,"w",encoding="utf-8")as f:
f.write(title[i].text)#写入标题
for j in L[i]:
if j!=" ":
f.write(j)#写入内容
if j=="。":
f.write("\n")
gushi=Gushi()
gushi.get_html()
day5
1,jieba分词
1，分词模式
1，精确分词，试图将句子最精确的分开，适合文本分析
2，全模式：将句子中所有可以成词的词语都扫秒出来，速度非常快，但是不能解决歧义问题
3，搜索引擎模式：在精确模式的基础上对长词进行切分，提高召回率，适用于搜索引擎
2，分词方法
对于一段长文字，分词原理大致分为三部分：
1，首先用正则表达式将中文段落粗略分为一个个的句子
2，将每个句子构造成有向无环图，之后寻找最佳切割方案
3，最后对于连续的词语，采用HMM模型再次划分
2，codecs
这种方法可以指定一个编码打开文件，使用这个方法打开的文件读取返回的是Unicode编码，写入时编码也是Unicode
使用open()时时指定Unicode编码写入，如果str，则根据源代码文件声明的字符编码解码成Unicode之后再进行操作,相对于open（），这个不容易出现问题
3,xpath解析模块
1，概念
全程为XML path language,即XML路径语言，他是一门再XML文档中查找信息的语言
2，使用流程
from lxml import etree
parseHTML=etree.HTML(html)
result=parseHTML.xpath("xpath表达式")
3,xpath常用规则
| nodename | 选择此节点的所有节点 |
|---|---|
| / | 从当前节点选取直接子节点 |
| // | 从当前节点选择子孙节点 |
| . | 选取当前节点 |
| … | 选取当前节点的父节点 |
| @ | 选取属性 |
4，所有节点
from lxml import etree
html=etree.HTML(text)#将数据转换为xpath对象
print(html.xpath('//*'))#获取所有的节点信息
1,返回类型是一个列表，每个元素是Element类型，后面跟了很多节点名
2,也可以指定节点名称，获取数据
from lxml import etree
html=etree.HTML(text)#将数据转换为xpath对象
print(html.xpath('//li'))#获取指定名称的节点信息
5，子节点
可以通过/或者//查找字节点或者子孙节点
print(html.xpath('//li/a'))#查找li下的子节点
print(html.xpath('//ul//a'))#查找ul下的子孙节点a
6，父节点
通过(…)可以查询当前节点的父节点信息
print(html.xpath('//a[@href="http://domestic.firefox.sina.com/"]/../@class'))#查询当前节点的父节点的class属性
print(html.xpath('//a[@href="http://domestic.firefox.sina.com/"]/../../@id'))#查询当前节点的爷爷节点的id属性
7，属性匹配
print(html.xpath('//li[@class="link1"]'))
print(html.xpath('//a[@id="channel"]'))
8，文本获取
用xpath中的text()方法可以获取节点
print(html.xpath('//li[@class="link2"]/a/text()'))#提取li节点下a节点的文字信息
print(html.xpath('//li[@class="link2"]/a/@href'))#提取li节点下a节点的href信息
9，属性多值匹配(contains)
有时候某些节点的属性不止一个，此时我们就需要用到多值匹配
text="""
<li class="li list-1"><a href="link.html">hello world</a></li>
<li class="li list-1"><a href="link.html">hello</a></li>
"""
from lxml import etree
html=etree.HTML(text)#将数据转换为xpath对象
print(html.xpath('//li[@class="li list-1"]/a/text()'))
print(html.xpath('//li[contains(@class,"li")]/a/text()'))
通过contains方法，第一个参数传入属性名称，第二个参数传入属性值，只要此属性包含所传入的属性值，就可以完成匹配
10，按序选择
有时候，在选择的时候某些属性同时匹配了多个节点，但是只想要其中的某个节点，就要
text="""
<div>
<ul>
<li class="item1"><a href="link1.html">cxk song</a></li>
<li class="item2"><a href="link2.html">cxk dance</a></li>
<li class="item1"><a href="link3.html">cxk rap</a></li>
<li class="item2"><a href="link4.html">cxk basketball</a></li>
</ul>
</div>
"""
from lxml import etree
html=etree.HTML(text)#将数据转换为xpath对象
# print(html.xpath('//li[@class="li list-1"]/a/text()'))
# print(html.xpath('//li[contains(@class,"li")]/a/text()'))
print(html.xpath('//li[last()]/a/text()'))
print(html.xpath('//li[1]/a/text()'))#获取第一个li标签中a标签内的文本信息
print(html.xpath('//li[position()<3]/a/text()'))
print(html.xpath('//li[last()-2]/a/text()'))#倒数第三个
print(html.xpath('//li[@class="lteml"][2]/a/text()'))
1、答辩的内容
1、PPT 介绍小组 组员 分工 项目的内容
2、实训总结
3、平时上课的源代码 笔记 (答辩项目的源代码)
2、答辩项目
任意选取网站，爬取网站的数据(文本信息 图片信息 音频信息)
3、json模块
1、概念
javascript中的对象和数字
对象：{“key”:“value”} json中的数据必须用双引号来表示
数组：[x1,x2,x3]
2、json模块的作用
json格式的字符串和python数据类型之间的转换
3、读取json
json.loads() :
作用：json格式 ————>python数据类型
json python
对象 字典
数组 列表
import json
str="""
[{"name":"小明"},{"age":"20"},{"sex":"男"}]
"""
print(type(str))
data=json.loads(str) #将json信息转换为python的数据类型
print(data)
print(type(data))
print(data[0]["name"])
print(data[1].get("age"))
print(data[0].get("address","北京")) #如果信息不存在返回默认值
4、输出json
json.dumps()
作用：python数据类型------>json格式
python json
字典 对象
列表 数组
元组 数组
注意：
1、json.dumpa() 默认使用ascii编码
2、添加 ensure_ascii=False，禁用ascii编码
with open("data.json","w",encoding="utf-8") as f:
f.write(json.dumps(data,indent=2,ensure_ascii=False)) #indent参数表示缩进字符个数
如果存在中文，需要先指定编码，然后将ensure_ascii参数设置为False
4、抓取动态ajax请求网页的过程
1、分析网页的请求规则，打开审查元素，选择xhr选项，通过滚动滑轮，查看网页请求的变化规律，找到js的请求信息
2、找到请求信息后，选择请求，进入到请求体中，选择preview选项，查看返回信息中是否有我们想要的数据
3、如果返回信息中存在想要的数据，选择Headers选项，查看RequestURL参数，找到网页的真实的url，然后查询其中的参数，一般url的参数都在Headers选项中的Query Sring Parameters中存在
4、通过真实url的公有部分和参数进行拼接，得到可以获取更多信息的url，然后获取js中json信息
获取下载地址json["data"]["items"]
然后 遍历 for i in json["data"]["items"]：
i["item"]["video_playurl"]
import requests
import json
import string
import time
import random
class BilibiliVideo():
def __init__(self):
self.url="http://api.vc.bilibili.com/board/v1/ranking/top?" #动态请求的公有url部分
self.headers={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36"}
self.all_str=string.punctuation+string.whitespace #将所有的特殊字符以及空白字符绑定
def get_json(self):
for offset in range(1,52,10): #通过循环更改offset的值来实现多次抓取
params={"page_size":"10",
"next_offset":str(offset),
"tag":"小视频",
"type":"tag_general_week",
"platform":"pc"}
html=requests.post(self.url,data=params,headers=self.headers).text #返回网页数据(json)
html=json.loads(html) #把json信息变成python中的数据类型
self.get_video_url(html) #调用获取视频链接的函数
def get_video_url(self,html): #获取小视频下载地址的函数
for video in html["data"]["items"]:
video_url=video["item"]["video_playurl"] #获取视频的下载地址
video_name=video["item"]["description"] #获取视频的名称
for char in video_name: #对视频名称中的字符进行遍历
if char in self.all_str: #如果存在特殊字符
video_name=video_name.replace(char,"") #如果存在，用空替换掉特殊字符
if len(video_name)>=50:
video_name=video_name[:51] #如果视频名称长度大于50，对名称进行切片，只保留前50位
filename=video_name+".mp4" #将文件保存文mp4格式
video_content=requests.get(video_url,headers=self.headers).content #对视频地址发起请求并获取二进制信息
with open(filename,"wb") as f:
f.write(video_content)
print("%s下载成功"%filename)
time.sleep(random.randint(1,5))
bilibili=BilibiliVideo()
bilibili.get_json()
这篇关于Python的基本语法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-05-08有遇到过吗？同样的规则 Excel 中 比Python 结果大
- 2024-03-30开始python成长之路
- 2024-03-29python optparse
- 2024-03-29python map 函数
- 2024-03-20invalid format specifier python
- 2024-03-18pool.map python
- 2024-03-18threads in python
- 2024-03-14python Ai 应用开发基础训练，字符串，字典，文件
- 2024-03-13id3 algorithm python
- 2024-03-13sum array elements python
