导图社区 Python基础
- 34
- 0
- 0
- 举报
Python基础
这是一个关于Python基础的思维导图，总结了Python高阶技巧、 Pyecharts库的使用、SQL入门与实战、 PySpark案例实战等。
编辑于2024-03-12 21:45:47- Python基础知识
- Python高阶技巧
- 相似推荐
- 大纲
python
1. 知识补充
# -*- coding: utf-8 -*- 指定文件编码为utf-8
机器学习第三方库 tensorflow keras mxnet
Web应用框架 第三方库 Pylons
os模块
(1)常用方法： 1）os.listdir(目录地址) ： 列出该路径下的所有文件 2）os.path.isdir(路径)： 判断指定路径是不是文件夹（是为True，不是为False） 3）os.path.exists(路径)： 判断指定路径是否存在（存在为True，不存在为False） 4）os.path.join(path1[,path2[,......]])： 将多个路径组合后返回 <1> 如果不存在以‘/’或“\\”开始的参数，则函数从头开始拼接，并且会自动加上\ <2>存在以‘’/’’开始的参数，从最后一个以”/”开头的参数开始拼接，之前的参数全部丢弃 <3>同时存在以‘’./’与‘’/’’开始的参数，以‘’/’为主，从最后一个以”/”开头的参数开始拼接，之前的参数全部丢弃 <4>只存在以‘’./’开始的参数,会从头开始拼接。 eg1： eg 2：
help(request)帮助函数
dir(p_object)获取p_object对象中的所有方法、属性的名称列表
数据容器.sort(key,reverse=False) 指定排序规则排序
eg :
部分常见内置函数
eg：
map(func,iterable)映射函数的使用
（1）map(func,iterable)函数： 参数： function：我们指定的函数（或数据类型），可以是python内置的，也可以是自定义的 iterable：可迭代的对象，例如列表，元组，字符串等 （2）eg： ··
fliter(func,iterable)过滤函数的使用
（1）filter(function, iterable)： 参数： function：判断函数 iterable：可迭代对象，如列表，元组，甚至集合都可以 filter会遍历iterable中的每一个数据，用function判断，符合条件，才会被留下 （2）eg：
eval()函数的使用
（1）作用： eval是Python的一个内置函数，这个函数的作用是，返回传入字符串的表达式的结果。同时eval()函数能实现list、dict、tuple、与str之间 的转化 （2）eg：
join()字符串拼接函数的使用
（1）语法： 'sep'.join(sep_object) ·作用：用新的目标分隔符连接，返回新的字符串 1）sep：分割符，可为“，、；”等。 2）sep_object：分割对象，可为字符串、以及储存字符串的元组、列表、字典。 （2）eg :
Json数据格式的转换
（1）什么是JSON数据： JSON是一种轻量级的数据交换格式，可以按照JSON指定的格式去组织和封装数据，JSON本质上是一个带有特定格式的字符串 （2）主要功能： JSON就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，类似于英语、普通话（中转数据格式） （3）JSON数据格式： 字典或列表中嵌套字典（本质为字符串），同时要求的字典的key必须是双引号，单引号不行 eg："{"name":"ok","age":20}" ; "[{"name":"ok","age":20},{"name:"小李","age":25}]" （4）python和JSON数据的相互转换： import json(导入JSON模块) python数据=json.loads(JSON数据) # eval(JSON数据)方法也可以将JSON数据转为python数据 JSON数据=json.dumps(python数据，ensure_ascii=True) # ensure_ascii参数表示是否对中文进行Unicode编码，默认为True，字典中有中文汉字是需设置为False
format格式化字符的使用
传入参数
'{}{}..'.format(参数1,参数2,...) 省略参数
eg：
'{0}{1}{2}...'.format(参数1,参数2,参数3,...) 位置参数
eg :
' {name}{age}...'.format(name=参数1,age=参数2,...) 关键字参数
eg:
混用
注意事项： 1）数字和关键字段可以混合使用传递参数 2）关键字参数必须位于位置参数之后。 3）混合使用时，可以省略数字 4）省略字段名{}不能和数字形式的字段名同时使用 eg：
元组和字典作为传递参数
format可以使用元组和字典传参，俩者可以混合使用 多种混合使用的时候。位置参数要在关键字参数前面，元组要在字典前面
复合字段名的使用
（1）format使用数字和变量名俩种形式，这就是复合字段 复合字段名支持两种操作符，[] 方括号，. 点号
.点号的使用
eg：
[]方括号的使用
eg：
对齐字符串
（1）语法： {<参数序号>:<格式控制标记>} （2）格式控制标记包括： <填充>：用于填充的单个字符（默认空格） <对齐>：<左对齐(默认) ； >右对齐 ； ^ 居中对齐 <宽度>：格式化字符的输出宽度，指定宽度不足时以实际长度为准 <,> ：千位分隔符，适用于整数和浮点数， <.精度>：浮点数的精度（包括整数位数）或字符串的最大输出长度，不支持整数 <类型>：设置传入参数的类型，包括整数类型（b、c、d、o、x、X），浮点数类型（e、E、f、%） （3）记忆：（冒填对宽逗点类） （4）参数类型：
案例
（1）字符串： （2）整数： （3）浮点数： （4）保留小数的几种方法： （5）变量控制标记：
random模块的使用
导包： import random（导入random.py文件） from random import random (导入random类) eg :
random()方法 随机生成一个浮点数，范围在[0,1)之间
uniform(a,b)方法 随机生成一个浮点数，范围在[a,b)之间
randint(a,b)方法 随机生成一个整数，范围在[a,b)之间
randrange(start ,stop,step)方法 随机生成一个数，范围在[start,start+step,start+2*step，……，stop-step]间，step为整数，默认为1
choice(sequence)方法 随机从sequence序列中抽取一个元素
shuffle(x)方法 将x列表中的元素随机打乱，修改原列表
samle(sequence,k)方法 随机从sequence序列中取出k个元素，不修改原数组
send(a)方法 生成随机数种子 a可以是整数、浮点数、字符串等类型
（1）含义： 随机数种子（random seed)在伪随机数生成器中用于生成伪随机数的初始数值。对于一个伪随机数生成器，从相同的随机数种子出发，可以得到相同的随机数序列。随机数种子通常由当前计算机状态确定，如当前的时间。 随机数种子会保存获得的随机数，下次调用随机数种子，生成随机数时就会是之前保留的随机数 （2）eg：
jieba中文分词库的使用
（1）下载包： pip install jieba -i https://pypi.tuna.tsinghua.edu.cn/simple （2）导包： import jieba （3）jieba库的模式： 1）精确模式： 语法： jieba.lcut(str) 试图将语句最精确的切分，不存在冗余数据，适合做文本分析 2）全模式： 语法：jieba.lcut(str, cut_all=True) 将语句中所有可能是词的词语都切分出来，速度很快，但是存在冗余数据 3）搜索引擎模式： 语法：jieba.lcut_for_search(str) 在精确模式的基础上，对长词再次进行切分 （4）注意： jieba.setLogLevel(jieba.logging.INFO) # 通过该方法使得不报错（虽然报错也不影响结果） （5）eg：
2. 基础语法
1. 字面量
1. （1）含义：在代码中，被写下来的固定的值，称为字面量 （2）值类型：数字(int,float,commplex)、字符串、列表、元组、集合、字典 （3）print()输出语句
2. 注释
2. （1）单行注释：#（#号开头） （2）多行注释：""" """(三个双引号包围)
3. 变量
3. （1）含义：在程序运行中，能储存计算结果或能表示值的抽象概念 （2）定义格式：变量名称=变量的值
4. 数据类型
4. （1）string：字符串类型 （2）int：整型 （3）float：浮点型 type(...) 函数查看数据类型 变量无类型，但其存储的数据有类型
5. 数据类型的转换
5. （1）int(x): 将x转换为一个整数 （2）float(x): 将x转换为一个浮点数 （3）str(x): 将x转换为字符串 （4）complex(x)： 将x转换为复数形式 注：任何类型都可以转换为字符串，字符串内必须只有数字才可以转换为数字，浮点数转为整数会丢失精度
6. 标识符
6. （1）含义：用户在编程的时候所使用的一系列名字，用于变量、类、方法等命名 （2）标识符命名规则： 1）内容限定：只允许出现中文、英文、数字、下划线(_)(不推荐使用中文，数字不可以开头) 2）大小写敏感 3）不可以使用关键字（eg:and、as、if...） （3）变量命名规范：见名知意，下划线命名法、英文字母全小写、驼峰命名法
7. 运算符
7. （1）算数运算符： + - * / //(取整除、地板除) %(取余) **(指数) （2）赋值运算符： = （3）复合运算符： += -= *= /= %= **= //=
8. 字符串的三种定义方式
8. （1）单引号 （2）双引号 （3）三引号 双引号可以包含单引号，单引号可以包含双引号，转义字符(\)可以将引号解除效用，变成普通字符 eg: name='\'ok\''
9. 字符串的拼接（+）
9. （1）字符串字面量之间的拼接 （2）字符串字面量与字符串变量之间的拼接 注：无法和非字符串类型进行拼接
10. 字符串格式化
10. （1）%占位符，%s将内容转换为字符串，%d将内容转换为整数，%f将内容转换为浮点数 eg：message="我叫%s,今年%d岁"%("ok",20) （2）数字精度控制：eg:%m.nd、%m.nf。m控制宽度，数字类型，设置的宽度小于数字本身，不生效；n控制小数点精度，数字类型，会进行小数的四舍五入 eg：%5d: 11--->[空格][空格][空格]11； %7.2f: 11.345---->[空格][空格]11.35; %.2f:11.345----->11.35(不设置宽度) （3）f"{变量}{变量}" （4）"{0}{1}".format(变量1，变量2)
11. print(str,end="\n")数据输出语句
12. input()数据输入语句，返回输入的字符串
3. 判断语句
1. 布尔类型和比较运算符
1. （1）布尔类型的字面量：True(1)真、False(0)假 （2）比较运算符：== != > < >= <=
2. if语句的基本格式
2. if 要判断的条件： 条件成立时，要做的事情 # 判断语句的结果，必须是布尔类型True或False，True会执行if内的代码语句，False则不会执行
3. if else 组合判断语句
3. if 要判断的条件： 条件满足时要做的事情 else: 添加不满足要做的事情
4. if elif else多条件判断语句
4. if 条件1： 条件1满足应做的事情 elif 条件2： 条件2满足应做的事情 ..... elif 条件n: 条件n满足应做的事情 else: 条件都不满足时应做的事情
5. if x in 序列 判断x是否在序列中
6. 判断语句的嵌套
6. if 条件1： 满足条件1要做的事 if 条件2： 满足条件2要做的事
4. 循环语句
1. while循环基础语法
1. while 条件： 满足条件要做的事情
2. while循环的嵌套应用
2. while 条件1： 满足条件1要做的事情 while 条件2： 满足条件2要做的事情 eg：九九乘法表输出
3. for循环的基础语法
3. for 临时变量 in 待处理数据集（序列类型，包括字符串、列表、元组等）： 循环满足条件是执行的代码 注：for循环是将待处理数据集的数据依次取出，for循环也叫做便遍历循环,临时变量为局部作用域
4. range语句 获得一个简单的数字序列
4. （1）range(num)： 从0开始，不包括num本身。 eg：range(5) ---->[0,1,2,3,4] （2）range(num1,num2): 从num1开始，不含num2本身。 eg： range(5,10) ------>[5,6,7,8,9] （3）range(num1,num2,step): 从num1开始，不含num2本身,step为步长，默认为1。 eg：range(5,10,2) ------>[5,7,9]
5. for循环的嵌套使用
5. for 临时变量1 in 序列1： 满足条件应做的事情 for 临时变量2 in 序列2： 满足条件应做的事情 eg：for循环打印九九乘法表
6. continue和break
6. （1）continue：中断本次循环，直接进入下一次循环 （2）break： 直接结束循环
5. 函数
1. 函数介绍
1. （1）函数：是组织好的，可重复使用的，用来实现特定功能的代码段 eg：len(str)函数统计字符串str的长度 （2）使用函数的好处： 将功能封装在函数中，可以随时随地地重复利用； 提高代码的复用性，减少重复代码，提高开发效率
2. 函数的基础定义语法
2. def 函数名(传入参数): 函数体 return 返回值 注：参数如果不需要，可以省略； 返回值如不需要，可以省略； 函数必须先定义后使用
3. 函数的传入参数
3. 参数作用：在函数进行计算时，接收外部(函数调用时)提供的参数 eg :def 函数名(实参): 函数体 return 返回值 返回结果=函数名(形参) # 参数之间用逗号隔开
4. 函数的返回值
4. 含义： 函数在执行完成后，返回给调用者的结果 注意：函数体在遇到return后就结束了，所以写在return后的代码就不会执行了 None类型：空 None类型的使用场景： 1）用在函数无返回值上： return None 2）用在if判断上：在if判断中，None等同于False 3)用于声明无内容的变量上： 定义变量，但暂时不需要变量有具体值，可以用None代替
5. 函数的说明文档
5. 对函数进行说明解释： 语法： def func(x,y): """ 函数说明 :paramx: 形参x的说明 :paramy: 形参y的说明 :return: 返回值的说明 """ 函数体 return 返回值
6. 函数的嵌套调用
6. 一个函数里面又调用了另一个函数
7. 变量的作用域
7. 1）局部变量：作用范围在函数内部，在函数外部无法调用 2）全局变量：在函数体内、外都能生效的变量 3）global关键字：可以在函数内部声明变量为全局变量
6. 数据容器
1. 认识数据容器
1. 1）是什么： 数据容器是一种可以存储多个元素的python数据类型，容纳的每一份数据称之为元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等 2）分类： 数据容器根据特点的不同，如是否支持重复元素。是否可以修改，是否有序等，分为5类，分别是列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
2. list(列表)
2. （1）基础语法： 1）字面量：[元素1，元素2，元素3，...] 2)定义变量：变量名称=[元素1，元素2，元素3，...] 3)定义空列表： 变量名称=[]; 变量名称=list() # 列表中的每一个数据，称之为元素。以[]为标识，以逗号,隔开每一个元素。列表可以嵌套 （2）列表的下标索引： 1)列表的每一个元素都有下标索引，从前往后：从0开始；从后往前：从-1开始 2)列表[下标索引]即可取出指定位置的数据 （3）列表的常用操作： 1）列表.index(元素)方法 ：查找某元素的下标索引 2）列表[下标]=值：修改特定位置的元素值 3）列表.insert (下标，元素): 在指定的下标位置插入指定的元素 4）列表.append(元素): 将指定元素，追加到列表的尾部 5）列表.extend(其他数据容器)： 将其他数据容器的内容取出，依次追加到列表尾部 6）del 列表[下标]：删除列表指定位置的元素 7）列表.pop(下标)： 删除列表指定位置的元素，有返回值，可接收删除的元素，不写默认删除最后一个元素 8）列表.remove(元素)： 删除某一元素在列表中的第一个匹配项 9）列表.clear()： 清空列表内容 10) 列表.count(元素)： 统计某元素在列表中的数量 11）len(列表)： 统计列表中有多少个元素 12）列表1+列表2：返回新的列表，包含两个列表的所有数据 （4）列表的遍历：（即将容器中的元素依次取出进行处理的行为，又称迭代） 1）while循环遍历 2）for循环遍历 3）列表推导式遍历： eg：list=[i for i in range(5)]------->[0,1,2,3,4] ; list =[1 for i in range(5)]-------->[1,1,1,1,1] （5）while循环和foe循环的对比： 1）在控制循环上： while循环可以自定循环条件；for循环不可以自定循环条件，只可以从一个数据容器内取出数据 2）在无限循环上： while循环可以通过条件做到控制无限循环，for循环理论上不可以，因为被遍历的容器容量不是无限的 3）在使用场景上：while循环适用于任何想用循环的场景，for循环适用于遍历数据容器的场景或简单的固定次数循环场景
3. tuple(元组)
3. （1）定义元组： 1）eg: t1=(1,"hello",True) 2）eg：t2="1",2,"3" 2) eg: t2=() 3) eg: t3=tuple() 4) eg: t4=("hello",) #定义单个元素的元组要加逗号 元组嵌套: eg :((1,2),(,3,4),5) 下标索引取出指定位置元素 （2）常用操作 1）元组.index(元素)： 查找某元素的下标索引 2）元组.count(元素)： 统计某元素在元组中的数量 3）len(元组)： 统计元组中有多少个元素 4）元组1+元组2： 返回新的元组，包含两个元组的所有数据 4）注：不可以修改元组的内容，否者会报错，但可以修改元组内的list的内容 （4）元组的遍历：（即将容器中的元素依次取出进行处理的行为，又称迭代） 1）while循环遍历 2）for循环遍历 （5）创建生成器generator： eg：tuple(generator类型)=(i for i in range(5))------->for i in tuple---->(0,1,2,3,4) ; tuple(generator类型) =(1 for in range(5))-------->for i in tuple---->(1,1,1,1,1) （6）元组的特点： 可以容纳多个数据，可以容纳不同类型的数据（混装），数据是有序存储的（有下标索引），允许重复数据存在，不可以修改（带可以修改元组内的list内容），支持for、while循环
4. str(字符串)
4. （1）常用操作： 1）通过下标索引取值 2）字符串.index(子字符串)： 查找子字符串的起始下标索引 3）字符串.replace(字符串1,字符串2)： 将字符串内的全部字符串1全部替换为字符串2。 注意：不是修改字符串本身，而是得到一个新的字符串 4）字符串.split(分割符字符串)： 按照指定的分割符分割字符串，将分割好的多个字符串存入列表对象中。 注意： 字符串本身不变，而是得到一个列表对象 5）字符串.strip(): 去除字符串前后空格和换行符，得到一个新的字符串对象 6）字符串.strip(字符串1)： 去除字符串前后指定字符串1，得到一个新的字符串对象 7）字符串.count("字符串1")： 统计字符串中字符串1出现的次数，返回int类型整型数字 8）len(字符串)： 统计字符串长度（空格也算） 9）字符串1+字符串2：字符串拼接，返回新的字符串 10）字符串.lower \ upper : 将字符串中的英文字符全部转小\大写 11）字符串.islower \ isupper: 判断字符串中的英文字符是否全部为大\小写，是返回True，不是返回False （2）字符串数据容器的特点： 只可以存储字符，长度任意（取决于内存大小），支持下标索引，允许字符重复出现，不可以修改，支持for、while循环
5. 数据容器（序列）的切片
5. （1）序列的定义： 内容连续、有序，支持下标索引的一类数据容器。eg：列表，元组，字符串 （2）切片的定义： 从一个 序列中，取出一个子序列 （3）语法：序列[起始下标：结束下标：步长] 1）起始下标可省略，省略从头开始 2）结束下标可省略，省略到尾结束， 3）步长可省略，省略步长为1（可以为负数，表示倒序执行,倒序执行时起始下标和终止下标要交换位置，否者为空[]） # 切片时不包括结束下标 eg：my_list=[0,1,2,3,4,5,6] print(my_list[1:4])-------->[1,2,3] print(my_list[4:1:-1])------->[4,3,2] print(my_list[::-1])------->[6,5,4,3,2,1,0]
6. set(集合)
6. （1）定义集合： 1）my_set={"ok","name","age",..} 2) my_set=set() #定义空集合 （2）常用操作： 1）集合.add(元素)： 添加自定义元素到集合中 2）集合.remove(元素)： 从集合中移除指定元素 3）集合.pop(): 从集合中任意取出一个元素，返回取出的元素 4）集合.clear(): 清空集合中的所有元素 5）集合1.difference(集合2)： 从集合1中取出集合2没有的元素，返回一个新的集合 6）集合1.difference_update(集合2)： 在集合1中删除与集合2相同的元素 7）集合1.union(集合2)： 合并集合1和集合2中的元素，返回合并后的新集合 8）len(集合): 统计集合中的元素个数 9）集合推导式：eg: {i for i in range(5)} --------->{0,1,2,3,4,5} （3）集合的遍历： 1）只支持for循环，不支持while循环，因为集合无序，无法通过下标索引获取元素 （4）集合的特点： 可以容纳多个数据；可以容纳不同类型的数据（混装）；数据是无序存储的（不支持下标索引）；不允许重复数据存在，可以修改；支持for循环，不支持while循环
7. dict(字典)
7. （1）定义字典：（键：值） 1）my_dict{"姓名":"ok","年龄":20,"家":"北京"...} 2）my_dict={} ；my_dict=dict() #定义空字典 3）定义重复的key值，新的会替换旧的（不允许重复） 4）定义嵌套字典，key不可以为字典 （2）常用操作： 1）value=字典[key]: 基于字典的key(键)返回value(值) 2）字典[key]=value： 新增元素\更新元素 3）字典.pop(key): 删除键为key的元素 4）字典.clear(): 清空字典中的所有元素 5）字典.keys(): 获取字典的全部key值，返回dict_keys(['key1','key2',...]) (dict_keys对象，通过for循环获取单个key) 6）字典.values(): 获取字典的全部value值，返回dict_values(['value1','value2',...]) (dict_values对象，通过for循环获取单个value） 7）字典.get(key,defult=None): 获取字典中指定key(键)的value(值)，如果没有，则返回default参数中设置的默认值 8）字典.items(): 返回dict_items可迭代对象，每个元素是key和value组成的元组类型，eg:(key,value),可通过for循环遍历,还可以用list()函数转为列表 9）len(字典)： 获取字典中的元素个数 （3）遍历字典： 1）先获取所有的键keys: eg: keys=字典.keys() 2) for循环遍历获取的keys: eg: for key in keys: print(key,字典[key]) （4）字典的特点： 可以容纳多个数据；可以容纳不同类型的数据；每一份数据是key:value键值对；可以通过key 获取value；key不可重复（重复会覆盖）；不支持下标索引；可以修改；支持for循环但不支持while循环
8. 数据容器的对比总结
8. 更正：字符串不可修改
9. 数据容器的通用操作
9. （1）for循环： 遍历数据容器 （2）len()方法： 获取数据容器中元素的数量 （3）max(数据容器) / min(数据容器) ： 获取元素的最大值/最小值（字符串比较ASCII码值，字典比较key值） （4）类型转换： 1）list(数据容器)： 转列表（字符串转列表全部字符拆开作为元素，字典转列表将key值作为元素添加到列表中） 2）tuple(数据容器)： 转元组（字符串转元组全部字符拆开作为元素，字典转元组将key值作为元素添加到元组中） 3）str(数据容器)： 转字符串(外面加个引号) 4）set(数据容器)： 转集合（字符串转集合全部字符拆开作为元素，字典转集合将key值作为元素添加到集合中），可以达到去重的效果 （5）容器的排序 方法一（无法指定规则）： 语法：sorted(数据容器,reverse=False) 1)sorted(数据容器) / sorted(数据容器,reverse=False): 数据容器中元素按照ASCII码正向排序，返回新的数据容器 2)sorted(数据容器,reverse=True): 数据容器中元素按照ASCII码反向排序 （6）容器的排序 方法二（指定规则）： 语法：数据容器.sort(key,reverse=False) （无返回值，直接修改原数据容器） 1)参数key: 是要求传入一个函数，表示将数据容器的每一个元素都传入函数中，返回排序的依据 2)参数reverse： 是否反转排序结果，True表示降序，False表示升序（默认False升序） （7）字符串大小比较的方式：（ASCII码表值） 0~9： ASCII码值48~57 A~Z: ASCII码值65~90 a~z： ASCII码值97~122 字符串按位比较，也就是一位一位进行对比，只要有一位大，那么整体就大
7. 函数进阶
1. 函数多返回值
1. 语法： eg：def func(): return 1,"ok",[1,2] int,str,list=func() 按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
2. 函数多种传参方式
1. 位置参数
1. 位置参数：调用函数是根据函数的参数位置来传递参数 注意：传递的参数和定义的参数顺序及个数要一致 eg: def func(形参1，形参2，形参3)： ...... func(实参1,实参2，实参3)
2. 关键字参数
2. 关键字参数： 函数调用是通过“键=值”形式传递参数 作用：可以让函数更加清晰，容易使用，同时也消除了参数的顺序要求 注意：如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
3. 缺省参数
3. 缺省参数： 缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数是可不传该默认参数的值 作用：当调用函数时没有传递参数，就会使用缺省参数对应的值 注意：所有位置参数必须出现在默认参数前，包括函数定义和调用，函数调用时，如果为缺省参数传值则修改默认参数值，否者就使用这个默认值
4. 不定长参数
4. 不定长参数： 不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景 作用：当调用函数时不确定参数个数时，可以使用不定长参数 （1）位置传递： eg：def user-info(*args): print(args) user_info("Tom")---------->('Tom',) user_imfo("Tom",20)------->("Tom",20) #传递的所有参数都为被args变量收集，它会根据传进参数的位置合并为一个元组（tuple）,args是元组类型，这就是位置传递 （2）关键字传递： eg: def user_info(**kwargs): print(kwargs) user_info(name='Tom',age=20,id=110)------>{'name':'Tom','age':20,'id':110} #参数是“键=值”形式的情况下，所有的“键=值”都被kwargs接收，同时会根据“键=值”组成字典
3. 匿名函数
1. 函数作为参数传递
1. eg： def test_func(compute): result=compute(1,2) print(result) def compute(x,y): return x+y test_func(compute)---------->3
2. lambda匿名函数
2. （1）def关键字： 可以定义带有名称的函数，可以基于名称重复使用 （2）lambda关键字： 可以定义匿名函数（无名称），只可临时使用一次 语法： lambda 传入参数：函数体（一行代码）#只能写一行代码，不能写多行代码 eg： def test_func(compute): result=compute(1,2) print(f"结果是：{rsult}") test_func(lambda x,y : x+y)---------->3 test_func(lambda x,y : x*y)------------>2
8. 文件操作
1. 文件编码概念
1. 1）什么是编码： 编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。eg：UTF-8（世界通用），GBK（中文），Big5等，目前最常用的是UTF-8编码 2）为什么需要使用编码： 计算机自认0和1，所以需要将内容翻译成0和1才能保存在计算机中。同时也需要编码，将计算机保存的0和1，反向翻译会可以识别的内容
2. open（filename，mode，encoding）函数打开文件
2. open（filename，mode，encoding）函数： 可以打开一个已经存在的文件，或者创建一个新文件 参数： 1) filename： 目标文件地址（绝对路径/相对路径） 2）mode：打开文件的模式（访问模式），只读、写入、追加等 3）encoding： 编码格式，推荐使用UTF-8，即encoding="UTF-8" mode常用的几种基础访问模式： 1） r: 以只读方式打开文件。文件的指针会放在文件的开头,这是默认模式 2）w: 打开一个文件只用写入。如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除。如果该文件不存在，则会创建文件 3）a： 打开一个文件用于追加。如果该文件已存在，新的内容会被写入到已有内容之后。如果该文件不存在，则会创建文件并写入内容 4）b: 以二进制方式打开文件，常组合w模式用于将图片保存到文件中
3. 读取文件内容
1. 文件对象.read(num)方法
1. 文件对象.read(num): num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中的所有数据
2. 文件对象.readlines()方法
2. 文件对象.readlines(): readlines可以按照行的方式将整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据是一个元素
3. 文件对象.readline()方法
3. 文件对象.readline(): 一次读取一行
4. for循环读取文件行
4. eg: f=open(r"D:/测试.txt","r",encoding="utf-8") for line in f: print(f"每一行的内容为：{line}")
4. 文件对象.close()方法 关闭文件对象
4. close（）方法关闭文件对象，也就是关闭对文件的占用，如果不调用close，同时程序也没有停止运行，那么这个文件将一直被python程序占用，无法进行删除、重命名等操作
5. with open() as f:语法 自动关闭文件
5. 通过with open语句块对文件进行操作，可以在操作完成后自动关闭文件，避免忘记close文件
6. 文件对象.write(字符串)方法 写入字符串到文件中
6. 文件对象.open("...") 文件对象.write(字符串) 文件对象.flush() 注： 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存之中，称之为缓冲区，当调用flush方法的时候，内容才会真正写入文件，这样做是避免频繁的操作硬盘，导致效率下降（攒一堆一次性写入磁盘） 注：close()方法自带flush()方法的功能
7. 文件对象.seek(offset,whence)方法用来移动指针的位置
7. （1）.seek(offset[,whence]) 移动文件指针到新的位置 参数： offset：表示相对于whence的多少个字节的偏移量; 正值向文件头移动，负值向文件尾移动 whence：不同的值代表不同的含义 0: 从文件头开始计算(默认值), 1: 从当前位置开始计算, 2: 从文件尾开始计算
9. 异常、模块、包
1. 异常
1. （1）含义： 当我们检测到一个错误时，python解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”，也就是我们常说的BUG （2）异常与错误的区别： 异常和错误是两个概念 1）异常是不正常的事件，不是错误 异常是指程序运行的过程中，发生某些意外的事情，比如10除以0， 文件不存在等 2）错误通常指的是程序在执行过程中遇到的逻辑或语法错误，这些错误可能导致程序无法正常执行
1. try except else finally捕获异常
1. （1）为什么要捕获异常： 在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法进行 （2）语法： try: 可能要发生异常的语句 except[异常 as 别名]: 出现异常的准备手段 [else:] 未出现异常时应做的事情 [finally:] 不管出不出现异常都会做的事情 # except NameError as e（变量未定义异常） ; except ZeroDivisonError as e:（出现了除以0的异常） 捕获指定异常 # except: ; except Exception as e: 捕获所有异常 # except(NameError,ZeroDivisonError) as e: 捕获多个异常
2. 异常的传递性
2. eg： 、 运行结果： 当函数fun1中出现异常，并且没有捕获处理这个异常的时候，异常会传递到函数func2，当fun2也没有捕获处理这个异常的时候，main函数会捕获这个异常，这就是异常的传递性。当所有函数都没有捕获这个异常的时候，程序就会报错
2. 模块
2. （1）模块的含义： python模块（module），是一个Python文件，以.py结尾。模块能定义函数、类和变量，模块里也能包含可执行的代码，我们可以导入模块去使用 （2）模块的作用： python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能。比如实现和时间相关的功能就可以使用time模块，我们可以认为一个模块就是一个工具包，每一个工具包都有各种不同的工具供我们使用，进而实现各种不同的功能
1. 模块的导入方式
1. （1）语法： [from 模块名] import [模块|类|变量|函数|*] [as 别名] （2）常见组合方式： 1） import 模块名1 [,模块名2] （针对所有） 使用： 模块名.功能名() 2) from 模块名 import 功能名 （针对特定） 使用： 功能名（） 3) from 模块名 import * （针对所有） 使用： 功能名（） 4) import 模块名 as 别名 （针对所有） 使用： 别名.功能名（） 5) from 模块名 import 功能名 as 别名 （针对特定） 使用： 别名（）
2. 自定义模块并导入
2. （1）导入自定义模块使用： eg： （2）导入不同模块的同名功能： eg： 注意事项：当导入多个模块的时候，且模块内有同名功能，当调用这个同名功能时，调用到的是后面导入的模块的功能 （3）测试模块（__main__变量）： eg： （4）__all___变量： eg： 如果一个模块文件中有"__all__"变量，当使用“from xxx import *”导入时，就只能导入这个列表中的元素
3. 包
3. （1）包的含义： 从物理上看：包就是一个文件夹，在该文件夹下包含了一个__init__.py 文件，该文件夹可用于包含多个模块文件； 从逻辑上看：包的本质依然是模块 （2）包的作用： 当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块
1. 自定义python包
1. （1）导入包: 1） imprt 包名.模块名 使用：包名.模块名.功能名（） 2） from 包名 import 模块名 使用：模块名.功能名（） 3） from 包名.模块名 import 功能名 使用：功能名（） （2）__all__变量： 必须写在__init__.py文件中才能控制通过“from xxx import *”方式导包时只能导入__all__变量列表中添加的模块名 __all__针对的只是“from xxx import *“导包，对”import xxx“无效 （3）__init__.py文件的作用： 创建包会默认自动创建的文件，通过这个文件表示一个文件夹时python的包，而非不同的包
2. 安装第三方包
2. （1）常用的第三方包： 科学计算中常用的numpy包；数据分析中常用的pandas 包；大数据计算中常用的PySpark包；图形可视化中常用的matplotlib,pyecharts包 （2）pip程序安装第三方包： pip install 包名 -i http://pypi.tuna.tsinghua.edu.cn/simple（清华源） --target 指定安装的地址 （3）pycharm中安装第三方包：
10. 面向对象
1. 初始对象
1. 在程序中是也可以做到和生活中一样，类似设计表格、生产表格、填写表格的组织形式的。 eg：
2. 类的成员方法
2. （1）类的定义和使用： 语法： class 类名称： （class为关键字，表示要定义类了） 类的属性 （类的属性，即定义在类中的变量，成员变量） 类的行为 （类的行为，即定义在类中的函数，成员方法） 创建类对象的语法（实例化）：对象=类名称（） （2）成员方法 的定义语法： def 方法名(self，形参1，... ，形参N): 方法体 self关键字是成员方法定义的时候必须填写的 1>它用来表示类对象自身的意思 2>当我们使用类对象调用方法的时候，self会自动被python传入 3>在方法内部，想要访问类的成员变量，必须使用self 4>self关键字，尽管在参数列表中，但是传参的时候可以忽略它 eg：
3. 类和对象
3. （1）现实世界的事物由什么构成： 属性、行为（类也可以包含属性和行为，所以使用类对象描述现实世界是非常合适的） （2）类和对象的关系是什么： 类是程序中的“设计图纸”，对象是基于设计图纸生产的具体实体 （3）什么是面向对象编程： 面向对象编程就是使用对象进行编程，即设计类，基于类创建对象，并使用对象来完成具体的工作 eg：
4. __init__() 构造方法
4. 构造方法： python类可以使用__init__()方法，称之为构造方法，可以实现以下效果: 1) 在创建类对象（构造类）的时候，会自动执行 2）在创建类对象（构造类）的时候，将传入的参数自动传递到__init__方法使用 eg：
5. 其他内置方法（魔术方法）
5. （1）魔术方法：（python内置的类方法，各自有各自特殊的功能） 1）__init__ 构造方法 2）__str__ 字符串方法 3）__lt__ 小于、大于符号比较 4）__le__ 小于等于、大于等于符号比较 5）__eq__ ==符号比较 （2）__str__字符串方法： 当类对象需要被转换为字符串时，会输出内存地址，内存地址没有多大的作用，我们可以通过__str__方法，控制类转换字符串的行为 eg： （3）__lt__小于、大于符号比较方法（__le__,__eq__类似） eg：
6. 封装
6. （1）面向对象编程，是许多编程语言都支持得一 种编程语言。简单理解是：基于模块（类）创建实体（对象），使用对象完成功能开发。面向对象包含了3大主要 特征： 封装，继承，多态 （2）封装： 封装表示的是将现实世界事物的属性、行为封装到类中，描述为成员变量，成员方法，从而完成程序对现实世界事物的描述 （3）私有成员： 现实世界中的事物，有属性和行为。但是不代表这些属性和行为都是给用户使用的。既然现实事物中有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。类中提供了私有成员的形式来支持，包括私有成员变量和私有方法。定义私有成员的方式只需在变量名、方法名前加_ _(两个下划线）即可。 1）私有成员无法直接被类对象使用，私有变量无法赋值，也无法获得值 2）私有成员无法被类对象使用，但是可以被其他的成员使用 eg：
7. 继承
7. 继承：继承就是一个类，继承另外一个类的成员变量和成员方法 （1）单继承 { 从父类那里继承（复制）成员变量和成员方法（不含私有）}： 语法： class 类名(父类名)： 类内容体 子类创建的类对象，可以有自己的成员变量和成员方法，也可以使用父类的成员变量和成员方法 （2）多继承 （python的类之间也支持多继承，即一个类，可以继承多个父类） 语法：、 class 类名(父类1,父类2,....父类N): 类内容体 多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级，即：先继承的保留，后继承的被覆盖 （3）pass关键字的作用： pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容、空的意思 （4）复写： 子类继承父类的成员属性和成员方法后，如果对其不满意，那么可以进行复写，即：在子类中重新定义同名的属性或方法即可 （5）调用父类同名成员： 一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类的成员，需要特殊的调用方式 1）方式一：调用父类成员 使用成员变量：父类名.成员变量 使用成员方法：父类名.成员方法（） 2）方式二：使用super()调用父类成员 使用成员变量：super().成员变量 使用成员方法：super().成员方法() eg(1): eg(2): eg(3): eg(4):
8. 类型注释
8. （1）类型注释： 在代码中涉及数据交互的地方，提供数据类型的注释（显示的说明） 主要功能：帮助第三方工具（如pycharm）对代码进行类型推断，辅助做代码提示；帮助开发者自身对变量进行类型注释 支持：变量的类型注解；函数（方法）形参列表和返回值的类型注解 （2）为变量设置类型注解（Ctrl+P提示） 1）基础语法： 2）基础语法：（在注释中进行类型注释） 变量: 类型 # type: 类型 注意： 元组类型设置类型详细注解，需要将每一个元素都标记出来 字典类型设置类型详细注释，需要两个类型，第一个是key,第二个是value 为变量设置注释，显示的变量定义，一般无需注释；一般无法直接看出变量类型时会添加变量的类型注解 类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致程序出错 （3）为函数（方法）设置类型注解： 1）形参注解： 2）返回值注解： 基础语法：def 函数名(形参名:类型,形参名:类型...): 基础语法：def 函数/方法名(形参) ->返回值类型: pass pass （4）Union类型（定义联合类型注解）(导包：from typing import Union )(定位Union，Alt+回车 快速导包) 基础语法： Union[类型1,类型2,....]
9. 多态
9. （1）含义： 多态指的是多种状态，即完成某个行为时，使用不同的对象会得到不同的状态（同样的函数行为，传入不同的对象，得到不同的结果） （2）运用： 多态常用于继承关系上，函数（方法）形参声明接收父类对象，实际传入父类的子类对象进行工作，即父类作定义声明，以子类做实际工作，用以获得同行为不同状态 （3）抽象类（接口）： 抽象类就好比一个标准，包含了一些抽象的方法，要求子类必须实现 { 父类用来确定有哪些方法（设计标准），具体的实现由子类自行决定（实现标准）} 抽象类：含有抽象方法的类称为抽象类 抽象方法：方法是空现（pass）称之为抽象方法 eg1： eg2：
10. 综合案例
10. eg： （1）文件读取（从CSV和JSON数据格式中读取数据）： （2）数据计算+可视化： （3）运行结果：
11. turtle绘制图像库的使用
11. （1）含义： turtle库是Python语言中一个很流行的绘制图像的函数库，想象一个小乌龟，在一个横轴为x、纵轴为y的坐标系原点，(0,0)位置开始， 它 根据一组函数指令的控制，在这个平面坐标系中移动，从而在它爬行的路径上绘制了图形。
turtle.Turtle()方法 创建Turtle对象
也可以不创建，直接使用turtle.函数名，推荐创建
画笔（pen）
（1）画笔的状态： 1）在画布上，默认有一个坐标原点为画布中心的坐标轴，坐标原点上有一只面朝x轴正方向小乌龟。 2）这里我们描述小乌龟时使用了两个词 语：坐标原点(位置)，面朝x轴正方向(方向)， turtle绘图中，就是使用位置方向描述小乌龟(画笔)的状态。 （2）eg：
turtle.pensize(width=1)设置画笔的宽度
turtle.pensize()返回画笔大小（不传参的情况下）
turtle.speed(speed)设置画笔移动速度
设置画笔移动速度，画笔绘制的速度范围为[0,10]之间的整数，数字越大越快 tutle.speed()返回画笔移动速度（不传参的情况下）
turtle.pencolor()设置画笔的颜色
无形参。传入参数设置画笔颜色，，默认为"black"，可以是颜色英文名，如"green","red"；也可以是RGB三元组,eg (0.1,0.5,0.5)；还可以是16进制颜色字符串,eg "#000fff" turtle.pencolor()返回画笔颜色（不传参）
画笔移动命令
turtle.forward(distance) 向前移动
turtle.forward() <=>turtle.fd() 等价
turtle.backward(distance) 向后移动
turtle.backward() <=>turtle.bk() 等价
turtle.right(degree) 顺时针旋转
turtle.left(degree) 逆时针旋转
turtle.setheading(to_angle) 固定方向旋转
turtle.setheading() <==>turtle.seth()等价 传入参数为正顺时针旋转，为负逆时针旋转，以x轴正方向（东）为旋转的起始方向
前后移动、顺逆旋转 eg
eg（1）： eg（2）：对比setheading()、right()、left()方法
turtle.penup() 抬笔不画
turtle.pendown() 落笔开画
抬笔、落笔 eg
turtle.circle(radius,extend=None) 绘制指定半径、角度的圆
（1）turtle.circle(radius, extent=None) 根据半径radius绘制extent角度的弧形 参数： 1） radius ：弧形半径 当radius值为正数时，圆心在当前位置/小海龟左侧。 当radius值为负数时，圆心在当前位置/小海龟右侧。 2）extent ：弧形角度。当无该参数或参数为None时，顺海龟方向绘制整个圆形 当extent值为正数时，顺小海龟当前方向绘制。 当extent值为负数时，逆小海龟当前方向绘制。 口诀：正正左顺，负负右逆，正负左逆，负正右顺
turtle.dot(size,*color) 绘制指定半径、颜色的原点
默认半径为1像素，颜色为“black”，颜色可以是英文颜色名、16进制颜色、范围在[0,1]之间的rgb值
画圆、画点 eg
（1）eg :画圆 （2）eg：画点
turtle.setx(x:float) 移动海龟x坐标到指定位置
turtle.sety(y:float) 移动海龟y坐标到指定位置
turtle.goto(x,y) 画笔移动到指定位置
将画笔移动到坐标为（x,y）的位置，相对于画布中心的坐标系，直线移动（两点之间的最短距离），不改变海龟的方向
turtle.home() 画笔移动到原点，方向朝左
坐标移动 eg
setx(),sety(),goto()方法不会改变海龟的方向，home()方法回到指定位置，方向朝左
画笔控制命令
turtle.fillcolor(color='black') 设置图形的填充颜色
默认填充为黑色 turtle.fillcolor()返回填充颜色（不传参的情况下）
turtle.color(color1,color2) 设置画笔颜色和填充颜色
同时设置pencolor=color1,fillcolor=color2 turtle.color()返回画笔颜色、填充颜色组成的元组（不传参的情况下）
turtle.filling() 放回当前是否为填充状态
正在填充返回True，未填充返回False
turtle.begin_fill()开始填充
图形必须封闭，才会填充
turtle.end_fill()填充完成
turtle.isvisible()返回当前海龟形状可见状态
可见返回True，不可见返回False
turtle.hideturtle() 隐藏海龟形状
turtle.showturtle() 显示海龟形状
图形填充、画笔形状状态
eg：
全局控制命令
eg：
turtle.clear() 清空窗口、保留状态
turtle.reset() 清空窗口、重置状态
turtle.undo() 撤销上一个turtle动作
turtle.pos()返回当前海龟坐标位置（元组）
turtle.stamp()绘制一个海龟形状的副本
eg（1）： eg（2）： eg（3）：
turtle.write(arg,move=False,align='left',font=('Arial',8,'normal'))书写文本
（1）turtle.write(arg,move=False,align='left',font=('Arial',8,'normal')) 参数： 1）arg：为文本内容 2）move：默认为False;如果为True,则笔将移动到书写后字体的右下角 3）align：默认为left，用于设置文本与海龟的对齐方式，eg：left、center、right 4）font：字体三元组（fontname，fontsize，fonttype），fontname即字体名称，fontsize即字体大小，fonttype即字体类型，eg：normal、bold、italic （2）eg： （3）eg：
turtle.begin_poly() 开始记录多边形的顶点
开始记录多边形的顶点，当前的乌龟位置是多边形的第一个顶点
turtle.end_poly() 停止记录多边形的顶点
停止记录多边形的顶点，当前的乌龟位置是多边形的最后一个顶点。将于第一个顶点相连
turtle.get_ply()返回记录的多边形顶点
返回最后记录的多边形顶点，元组嵌套元组格式
清空、重置、撤销、书写、获取位置、海龟形状、记录顶点
turtle库常用函数
注意：turtle对象中没有这些方法
turtle.mainloop() 或 turtle.done() 启动事件循环
（1）turtle.done()：暂停程序，停止画笔绘制，但绘图窗体不关闭，直到用户关闭Python Turtle图形化窗口为止 （2）turtle.mainloop():启动事件循环，调用Tkinter的mainloop函数，必须是乌龟图形程序中的最后一个语句 （3）二者无太大差异，可以替换使用
turtle.delay(delay=10) 设置绘图延迟
设置或返回毫秒为单位的绘图延迟,默认10毫秒
turtle.mode(mode='standard') 设置乌龟模式
设置乌龟模式（"standard","logo"或"world"）并执行重置，默认standard，如果没有给出模式，则返回当前模式
画布（canvas）
画布就是turtle库为我们展开用于绘图区域，我们可以设置它的大小和初始位置
turtle.sceensize(canvwidth:int,canvheight:int,bg=None)方法设置画布的大小及背景颜色
turtle.sceensize(canvwidth=None,canvheight=None,bg=None）-->tuple[int,int](返回画布的宽高) （1）参数： canvwidth： 设置画布的宽（单位像素） canvheight： 设置画布的高（单位像素） bg: ： 设置画布的背景颜色，支持16进制颜色表示方法、已经颜色的英文名称 eg：turtle.screensize(800,600,"green") turtle.screensize(200, 200, bg="#000fff") turtle.screensize() # 返回默认大小（400,300） （2）eg：
turtle.setup(width=0.5,height=0.75,startx=None,starty=None)方法设置窗体的大小以及在电脑屏幕中的位置
turtle.setup(width=0.5,height=0.75,startx=None,starty=None) --None（无返回值） 作用：设置主窗体的大小和位置，表示像素值，如果值是小数，表示窗口宽度与屏幕的比例 （1）参数： 1）width：:窗口宽度，表示像素值，如果值是小数，表示窗口宽度与屏幕的比例 2）height：窗口高度 3）startx：窗口左侧与屏幕左侧的像素距离，如果值是None，窗口位于屏幕水平中央 4）starty：窗口顶部与屏幕顶部的像素距离，如果值是None，窗口位于屏幕垂直中央 （2）eg：
Python高阶技巧
1. SQL入门与实战
1. 数据库介绍
1. （1）数据： 1）数据的存储：txt,Excel,数据库（存储数据的库）（3个层级：库-->表-->数据） 2）数据的计算：（编程语言） （2）数据库管理系统（数据库软件）： eg：Oracle甲骨文数据库；MySQl数据库；微软的SQL Sever数据库；PostgreSQl数据库；SQLite数据库 （这些软件都能实现：管理库，管理表、基于表来管理数据） （3）数据库和SQL的关系： 数据库是用来存储数据的，在这个过程中，会涉及到：数据的新增，数据的删除，数据的修改，数据的查询，数据库、数据表的管理等等，而SQL语言，就 是一种对数据数据进行操作、管理查询的工具。使用数据库软件去获得库-->表-->数据，这种数据组织、存储的能力并凭借SQL的语言，完成对数据的增、 删、改、查等操作
2. MySQL的安装及入门使用
2. （1）下载地址： https://dev.mysql.com/downloads/; (http:www.mysql.com) （2）验证： 命令提示符(cmd)中输入【mysql -uroot -p】,Enter后输入密码，再次按Enter检查 （3）cmd中使用MySQL： 输入【mysql -uroot -p】,以及密码后，输入【show databases;】可查看有哪些数据库，输入【use 数据库名;】使用某个数据库,输入【show tables;】可查看数据库内有哪些表，【exit】退出MySQL的命令行环境 （4）第三方图形化工具DBeaver：下载地址：http://dbeaver.io/downloads
3. SQL基础
3. （1）SQL语言的分类： 由于数据库管理系统（数据库软件）功能非常多，不仅仅是存储数据，还包含数据的管理、表的管理、库的管理、账户管理、权限管理等。所以，操作数 据库的SQL语言，也基于功能，可以划分为4类： 1）数据定义：DDL（Data Definition Language）-----------库的创建删除、表的创建删除等 2）数据操作：DML（Data Manipulation Language）------新增数据、删除数据、修改数据等 3）数据控制：DCL（Data Control Language）--------------新增用户、删除用户、密码修改、权限管理等 4）数据查询：DQL（Data Query Language）---------------基于需求查询和计算数据 （2）SQL的语法特征：(选中运行) 1）SQL语言，大小写不敏感 2）SQL可以单行或多行书写，最后用;（分号）结束 3）SQL支持注释： 单行注释： -- 注释内容 ； # 注释内容 多行注释： /* 注释内容 */
4. SQL-DDL 数据定义
4. （1）DDL - 库管理： 1）查看数据库： show databases; 2）使用数据库：use 数据库名称； 3）创建数据库：create database 数据库名称; [charset utf8(可写可不写)] 4）删除数据库：drop database 数据库名称 5）查看当前使用的数据库：select database(); （2）DDL-表管理：（注意先选中数据库） 1）查看表：show databases; 2）删除表：drop table 表名称； drop table if exists 表名称; 3）创建表：create table 表名称(列名称 列类型，列名称 列类型，...); 列类型有：int整数； float浮点数； varchar(长度)文本，长度为数字，最大为255，做最大长度限制； date日期类型； timestamp时间戳类型 F5刷新
5. SQL-DML 数据操纵
5. （1）数据插入（insert）： 基础语法: insert into 表名称[(列1，列2，... ,列N)] values (值1，值2，... ，值N)[,(值1，值2， ... ，值N)].... ; （2）数据删除（delete）： 基础语法： delete from 表名称 [where 条件判断]； 条件判断： 格式：列 操作符 值 操作符：= ，<，>， <= ，>=，!=等 （3）数据更新（update）： 基础语法： update 表名 set 列=值 [where 条件判断]；
6. SQL-DQL 数据查询
6. （1）基础数据查询： 1）select 字段列表 / * from 表（从表中选中某些列进行展示） 2）select 字段列表 / * from 表 where 条件判断（从表中过滤符合判断条件的列进行展示） （2）分类聚合： 基础语法： select 字段|聚合函数 from 表 [where 条件] group by 列 ; 聚合函数有： sum(列)求和 ， avg(列)求平均值 ， max(列)求最大值 ，count(列 | *)求数量 注意事项：group by 中出现了那个列，那个列才能出现在select中的非聚合中 结果： （3）排序、分页： 1）结果排序：（指定某个列进行排序） 语法： select 列 | 聚合函数 | * from 表 where 判断条件 group by 列 order by 列 [ASC | DESC ] 【升序（默认） | 降序 】 2）结果分页限制： （对查询结果进行数量限制或分页显示） 语法： select 列 | 聚合函数 | * from 表 where 判断条件 group by 列 order by 列 [ASC | DESC ] limit n[,m]
7. python操作-MySQL基础使用
7. （1）pymysql库 : 除了使用图形化工具外，我们也可以使用编程语言来执行MySQL，从而操作数据库。在python中，使用第三方库：pymysql 来完成对MySQL数据库的操作 安装库：pip install pymysql -i http://pypi.tuna.tsinghua.edu.cn/simple （2）创建MySQL的数据库链接： （3）执行SQL语句： 1）执行非查询性质的SQL语句： 2）执行查询性质的SQL语句： 3）数据插入：
8. 综合案例
8. （1）将文件数据插入SQL表： 1）debeaver中创建表： （2）将面向对象综合案例中的数据存储到SQL表中： （2）将SQL表中的数据写入文件：
2. PySpark案例实战
1. 前言介绍
1. （1）什么是Spark、PySpark： 1）spark是Apache基金会旗下的顶级开源项目，用于对海量数据进行大规模云计算 2）pyspark是spark的python实现，是spark为跑一趟哄弄开发者提供的编程入口，用于以Python代码完成spark任务的开发 3）pyspark不仅可以作为Python第三方库使用，也可以将程序提交到spark集群环境中，调度大规模集群进行执行 （2）为什么学习pyspark： 大数据开发是Python众多就业方向中的明星赛道，薪资高岗位多，spark（pyspark）又是大数据开发中的核心技术
2. 基础准备
2. （1）pyspark库的安装： pip install pyspark -i https://pypi.tuna.tsinghua.edu.cn/simple --target D:\Download\python3.11\Lib\site-packages （2）构建pyspark执行环境入口对象： 想要pyspark库完成数据处理，首先需要构建有个执行环境入口对象。pyspark的执行环境入口对象是：类SparkContext的类对象 （3）pyspark的编程模型： 1）数据输入： 通过SparkContext类对象的成员方法，完成数据的读取操作，读取后得到RDD类对象 2）数据处理计算： 通过RDD类对象的成员方法，完成各种数据计算的需求 3）数据输出： 将处理完成的RDD对象，调用各种成员方法完成写出文件、转换为list等操作
3. 数据输入
3. （1）RDD对象： pyspark支持多种数据的输入，在输入完成后，都会得到一个RDD对象，RDD全称：弹性分布式数据集，pyspark针对数据的处理，都是以RDD对象作为载 体，即：数据存储在RDD中，各类数据的计算方法，也都是RDD的成员方法。RDD的数据计算方法，返回值依旧是RDD对象 pyspark的编程模型可以归纳为：准备数据到RDD----->RDD迭代计算---->RDD导出为list、文本文件等。即：源数据--->RDD---->结果数据
4. 数据计算
5. 数据输出
6. 综合案例
3. Pyecharts库的使用
1. 动态柱状图
基础柱状图
eg: 运行结果：
基础时间线柱状图绘制
eg： 运行结果：
动态GDP柱状图绘制
eg： 运行结果：
2. 地图可视化
基础地图使用
eg： 运行结果：
全国疫情地图构建
eg： 运行结果：
河南省疫情地图绘制
eg： 运行结果：
3. 折线图的开发
构建基础折线图
eg： 生成一个render.html文件，打开后点击右上角的游览器，就可以在网页中看到生成的图表了 运行结果：
案例：数据准备
打开准备好的文本数据文件 替换JSON数据中前后字符，使其符合JSON格式 将JSON数据转为python字典对象 取出字典中的日期列表（x轴数据）、确诊数列表（y轴数据）
案例：生成美日印疫情确诊折线图
eg： 运行结果：
4. 全局配置选项
4. 全局配置选项： 针对整个图像来进行设置，可登录pyecharts.org官网查看 eg：TitleOpts:标题配置项 ； LegendOpts:图例配置项 ； ToolBoxOpts:工具箱配置项 ； VisualMapopts:视觉映射配置项 ； TooltipOpts:提示框配置项 DataZoomOpts:区域缩放配置项 ； LabelOpts: 标签配置对象 系列配置选项： 针对具体的轴数据进行配置 eg： 运行结果：
TitleOpts 标题配置对象
导包： from pyecharts.options import TitleOpts 实例化： eg：title_opts=TitleOpts(title="GDP", pos_left="center", pos_bottom="1%",...)
LegendOpts 图例配置对象
导包： from pyecharts.options import LegendOpts 实例化： eg: legend_opts=LegendOpts(is_show=True,...)
ToolboxOpts 工具箱配置对象
导包： from pyecharts.options import ToolboxOpts 实例化： eg: toolbox_opts=ToolboxOpts(is_show=True,...)
VisualMapOpts 视觉映射配置对象
导包： from pyecharts.options import VisualMapOpts 实例化： eg: visualmap_opts=VisualMapOpts(is_show=True,is_piecewise=True,pieces=[ {"min": 1, "max": 9, "label": "1-9", "color": "#ccffff"}, {"min": 10, "max": 99, "label": "10-99", "color": "#fff666"}, {"min": 100, "max": 500, "label": "100-500", "color": "#990033"} ],....)
LabelOpts 标签配置对象
导包： from pyecharts.options import LabelOpts 实例化： label_opts=LabelOpts(is_show=True,position,color,font_size,font_style,font_weight,font_family,....)
5. 常用对象
Line 折线对象
Line()实例化 创建Line对象
导包： from pyecharts.charts import Line
add_xaxis(xaxis_data:Sequence)方法 添加x轴数据
add_yaxis(series_name:str,y_axis,color,label_opts)方法 添加y轴数据
set_global_opts(title_opts,legend_opts,toolbox_opts,visualmap_opts...)方法 设置图表全局配置选项
render(path)方法 生成图表的.html文件，返回文件地址字符串
Map 地图图像
Map()实例化 创建Map对象
导包： from pyecharts.charts import Map
add(series_name:str,data_pair,maytype:str="china")方法 添加数据
set_global_opts(title_opts,legend_opts,toolbox_opts,visualmap_opts...)方法 设置图表全局配置选项
render(path)方法 生成图表的.html文件，返回文件地址字符串
Bar 柱状图对象
Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))实例化 创建Bar对象
Bar(init_opts=InitOpts(theme=ThemeType.LIGHT)) (init_opts参数设置柱状图主题颜色) 导包： from pyecharts.charts import Line from pyecharts.options import InitOpts from pyecharts.globals import ThemeType
add_xaxis(xaxis_data:Sequence)方法 添加x轴数据
add_yaxis(series_name:str,y_axis,color,label_opts)方法 添加y轴数据
reversal_axis()方法 反转X、Y轴
render(path)方法 生成图表的.html文件，返回文件地址字符串
Timeline 时间线对象
如果说一个Bar、Line对象是一张图表的话，时间线就是创建一个一维的x轴，轴上的每一个点就是一个图表对象
Timeline(init_opts)
导包： from pyecharts.charts import TimeLine from pyecharts.globals import ThemeType 实例化： eg：timeline=Timeline({"theme":ThemeType.LIGHT}) # ThemeType: WHITE： 红蓝 ； LIGHT:蓝黄粉（高亮颜色） ； DARK：红蓝（黑色背景） ； CHALK：红蓝绿（黑色背景） ； ESSOR：红黄（暖色系） ..........
add(chart:Base,time_point:str)方法 添加图表到时间线上
add_schema(play_interval=None,is_auto_play=False,is_loop_play=True,is_timeline_show=True,...)方法 设置时间线自动、循坏切换（单位毫秒）等特性
6. Json数据格式的转换
6. （1）什么是JSON数据： JSON是一种轻量级的数据交换格式，可以按照JSON指定的格式去组织和封装数据，JSON本质上是一个带有特定格式的字符串 （2）主要功能： JSON就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，类似于英语、普通话（中转数据格式） （3）JSON数据格式： 字典或列表中嵌套字典（本质为字符串），同时要求的字典的key必须是双引号，但引号不行 eg："{"name":"ok","age":20}" ; "[{"name":"ok","age":20},{"name:"小李","age":25}]" （4）python和JSON数据的相互转换： import json(导入JSON模块) python数据=json.loads(JSON数据) # eval(JSON数据)方法也可以将JSON数据转为python数据 JSON数据=json.dumps(python数据，ensure_ascii=True) # ensure_ascii参数表示是否对中文进行Unicode编码，默认为True，有字典中有中文汉字 是需设置为False
7. pyecharts的模块简介
7. （1）pyecharts模块： 如果想要做出数据可视化效果图，可以借助pyecharts模块来完成。Echarts是个由百度开源的数据可视化的框架，凭借着良好的交互性、精巧的图标设计，得到了众多开发者的认可。二python是门富有表达力的语言，很适合用于数据处理。当数据分析遇上数据可视化时，pyecharts诞生了 （2）pyecharts官网：(pyecharts.org) pyecharts画廊官方网址：http://gallery.pyecharts.org （3）pyecharts模块安装： pip install pyecharts -i http://pypi.tuna.tsinghua.edu.cn/simple
4. Python高阶技巧
1. 闭包
1. （1）含义： 在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数叫做闭包 （2）nonlocal关键字（修改外部函数变量的值） （3）案例：存取款 （4）闭包注意事项： 优点： 无需定义全局变量即可实现通过函数，持续的访问、修改某个值 闭包使用的变量的作用域在函数内部，避免了被错误的调用修改 缺点：由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放，一直占内存
2. 装饰器
2. （1）含义： 装饰器其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能 （2）装饰器的一般写法（闭包写法）： （3）装饰器的语法糖写法：
3. 设计模式
3. （1）设计模式： 设计模式是一种编程套路，可以极大地方便程序的开发。最常见、最经典的设计模式，就是我们所学习的面向对象了。除了面向对象外，在编程中也有很多既定的套路可以方便开发，我们称之为设计模式。比如，单例、工厂模式，建造者、责任链、状态备忘录、解释器、访问者、中介、模板、代理模式等等 （2）单例模式： 1）创建类的实例后，就可以得到一个完整的、独立的类对象。通过print语句可以看出，它们的内存地址也是不相同的，即t1和t2是连个独立的类对象。 某些场景下，我们需要一个类无论获取多少次类对象，都仅仅2提供一个具体的实例，用于节省创建类对象的开销和内存开销。比如某些工具类，仅需 要1个实例，即可在各处使用，这就是单例模式所要实现的效果 2）单例模式是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。在整个系统中，某个类只能出现一个实例，单例对象 就能派上用场 3）定义：保证一个类只有一个实例，并提供一个访问它的全局访问点 4）使用场景： 当一个类只能有一个实例，而客户可以从一个众所周知的访问点访问它时 （3）单例的实现模式： 常规模式：（不同的内存地址） 单例模式：（相同的内存地址） （4）工厂模式： 1）当需要大量创建一个类的实例的时候，可以使用工厂模式。即，从原生的使用类的构造方法去创建类对象的形式迁徙到，基于工厂提供的方法去创建 对象的形式 2）优点：大批量创建类对象的时候有统一的入口，易于代码维护；当需要修改时，仅修改工厂类的创建对象即可；符合现实世界的模式，即由工厂来制 作产品（对象） 常规模式： 工厂模式：
4. 多线程
4. （1）进程和线程： 现代操作系统中，比如Mac、Linux、Windows、UNTX等，都是支持多任务的操作系统 1）进程： 就是一个程序，运行在操作系统之上，那么便称之这个程序为一个运行程序进程，并分配进程ID方便系统管理 2）线程： 线程是归属于进程的，一个进程可以开启多个线程，执行不同的工作，是进行的实际工作的最小单位 进程就好比一家公司，是操作系统对程序进行运行管理的单位 线程就好比一家公司的员工，进程可以有多个线程（员工），是进程实际的工作者 操作系统可以运行多个进程，即多任务运行 一个进程中可以运行多个线程，即多线程运行 （2）注意点： 进程之间是内存隔离的，即不同的进程拥有各自的内存空间。这就类似于不同的公司拥有不同的办公场所。线程之间是内存共享的，线程是属于进程 的， 一个进程内的多个线程之间是共享这个进程所拥有的内存空间的。这就好比，公司员工之间是共享公司的办公场所 （3）并行执行： 并行执行的意思指的是同一时间做不同的工作。进程之间就是并行执行的，操作系统可以同时运行多程序，这些程序都是在并行执行（多任务并行执 行） 除了进程外，线程其实也是可以并行执行的。比如，一个Python程序，其实是可以做到，一个线程在输出：你好，一个线程在输出：Hello，像这样一 个 程序在同一时间做两件乃至多件不同的事情，我们就称之为：多线程并行执行 （3）多线程编程语法： import threading thread_obj=threading.Thread([group,[,target[,name[,args[,kwargs]]]]]) thread_obj.start() # 启动线程，让线程开始工作 1) group: 占时无用，未来功能的予留参数 2) target: 执行的目标函数名（target=func） 3) args: 以元组的方式给执行任务传参 4) kwargs: 以字典的方式给执行任务传参
5. 网络编程
1. 服务端开发
1. （1）socket: socket(简称 套接字)是线程之间通信的一个工具，好比现实世界中的插座，所有的家用电器要想工作多事基于插座进行，进程之间要想进行网络通信需 要 socket。socket负责进程之间的网络传输，好比数据的搬运工。大多数软件（eg：QQ，微信）都使用了socket进行网络通讯 （2）客户端和服务端： 2个进程之间通过socket进行相互通讯，就必须有客户端和服务端 socket服务端： 等待其他进程的连接，可接收发来的信息，可以回复信息 socket客户端： 主动连接服务端，可以发送信息，可以接收回复 （3）socket服务端编程：（下载网络调试助手作为客户端） 步骤： 1）创建socket对象 2）绑定socket_server到指定IP和地址 3）服务端开始监听端口 4）接收客户端连接，获得连接对象 5）客户端连接后，通过recv方法，接收客户端发送的消息 6）通过conn（客户端当次连接对象），使用send方法可以回复消息 7）conn(客户端当次连接对象)和socket_server对象调用close方法，关闭连接
2. 客户端开发
2. （1）socket客户端编程： 步骤： 1）创键socket对象 2）连接到服务端 3）send方法发送信息 4）recv方法接收返回信息 5）close关闭连接
6. 正则表达式
6. （1）含义： 正则表达式，又称规则表达式，是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换那些符合模式（规则）的文本。简单来说，正则 表达式就是使用：字符串定义规则，并通过规则去验证字符串是否匹配。比如，验证一个字符串是否是符合条件的电子邮箱地址，只需要配置好正则规则，即 可匹配任意邮箱。比如通过正则规则：（^[\w-]）+(\.[\w-]+)*@[\w-]+(\.[\w-]+$)即可匹配 一个字符串是否为标准邮箱格式，但如果不使用正则，使用if else 来对字符串做判断就非常困难了 （2）导包： import re （3）常见的匹配方法 1）re.match: 从头开始匹配，匹配第一个命中项 2）re.search: 全局匹配，匹配第一个命中项 3）re.findall: 全局匹配，匹配全部命中项
1. 常见匹配方法
1. re.match(匹配规则，被匹配字符串),返回Match对象
1. 从被匹配字符串开头进行匹配，匹配成功，返回匹配对象（包含匹配的信息），匹配不成功返回空
2. re.search(匹配规则，被匹配字符串),返回Match对象
2. 搜索整个字符串，找出匹配的 。从前往后，找到第一个后，就停止，不会继续向后，整个字符都找不到，返回None
Match对象
1. span（）方法，获取匹配到的的字符索引元组
2. group（）方法，获取匹配到的字符串
3. re.findall(匹配规则，被匹配字符串),返回列表
3. 匹配整个字符串，找出全部匹配项，找不到返回空列表
2. 元字符匹配
1. 单字符匹配
1. （1）单字符匹配： 1） . 匹配任意一个字符（除了\n）； \.匹配点本身 2）[] 匹配【】中列举的字符 3）\d 匹配数字，即0-9 4）\D 匹配非数字 5） \s 匹配空白，即空格，tab键 7）\S 匹配非空白 8）\w 匹配单词字符，即a-z、A-Z、0-9、_ 9）\W 匹配非单词字符
2. 数量匹配
2. （1）数量匹配： 1）* 匹配前一个规则的字符出现0至无数次 2）+ 匹配前一个规则的字符出现1至无数次 3） ？ 匹配前一个规则的字符出现0次或1次 4）{m} 匹配前一个规则的字符出现m次 5）{m;} 匹配前一个规则的字符出现最少m次 6）{m,n} 匹配前一个规则的字符出现m到n次 7）.* 贪婪匹配 8）.*? 非贪婪匹配（惰性）匹配
3. 边界匹配
3. （1）边界匹配： 1）^ 匹配字符串开头 2）$ 匹配字符串结尾 3）\b 匹配一个单词的边界 4）\B 匹配非单词的边界
4. 分组匹配
4. （1）字符匹配 1）| 匹配左右任意一个表达式 2）() 将括号中字符作为一个分组
3. 案例
3. （1）eg: 匹配账号，只能由字符串和数字组成，长度限制为6到10位 （2）eg： 匹配QQ号，要求纯数字，长度为5-11，第一位不能为0 （3）eg： 匹配邮箱地址，只允许qq，163，gmail这三种邮箱地址
7. 递归
7. （1）认识： 递归在编程中是一种非常重要的算法，是方法（函数）自己调用自己的一种特殊编程写法 如：def func(): 函数调用自己，则称为递归调用 if …… ： func() return ……
1. 案例：递归找文件
1. eg：运用递归方法找出一个文件夹的全部文件