Python学习

一，python的基础语法

1.字面量

代码中，被写下来的固定的值称为字面量

2.数据类型

使用type()函数可以查看数据类型
注意：python中的变量是没有数据类型的，其存储的数据有数据类型

数据类型的转换（注意float向int转换可能会有数据精度丢失）

3.标识符

是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。
标识符的命名规则：
标识符命名中，只允许出现:
英文
中文
数字
下划线(_)
其余任何内容都不被允许。
数字不能在开头

4.运算符

算数运算符
注意：//的使用

赋值运算符

5.字符串的拼接

1.如何完成字符串拼接?
使用“+”号连接字符串变量或字符串字面量即可
2.有哪些注意事项?
无法和非字符串类型进行拼接

6.字符串的格式化

由于+的拼接，无法完成不同类型数据的拼接，因此出现了格式化输出

num=20
s="20"
name="tels%d  %s"%(num,s)
print(name)

结果如下，成功将不同类型的字符串拼接成功

常见的站位符
字符串: %s
整数:%d
浮点数: %f

我们还可以对数字做精度上的控制
可以使用辅助符号"m.n"来控制数据的宽度和精度
m，控制宽度，要求是数字(很少使用),设置的宽度小于数字自身，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入

a=1.999;
print("宽度设置为6，精度控制为1:%6.1f"%a);

如果m比数字本身宽度还小，会发生什么事?
m不生效
.n会对小数部分做精度限制，同时:?
会对小数部分做四舍五入
快速格式化
通过语法:f"内容{变量}"的格式来快速格式化

name="张三"
a=6
price=15.23
print(f"我的名字是{name},今年{a}岁,我卖的东西的价格是{price}")

输出的结果为：

这一种方式
不理会类型
不做精度控制
适合对精度没有要求的时候快速使用

7.for循环的变量作用域

1.for循环中的临时变量，其作用域限定为:
循环内
2.这种限定:
是编程规范的限定，而非强制限定不遵守也能正常运行，但是不建议这样做如需访问临时变量，可以预先在循环外定义它

8.return

思考:如果函数没有使用return语句返回数据，那么函数有返回值吗?
实际上是:有的。
Python中有一个特殊的字面量:None，其类型是:<class’NoneType’>无返回值的函数，实际上就是返回了:None这个字面量
None表示:空的、无实际意义的意思函数返回的None，就表示，这个函数没有返回什么有意义的内容也就是返回了空的意思，
Node可以用于
函数返回值
if判断
定义变量

9.局部变量和全局变量

num=100;
def global_test():
    num=200;#num相当于函数内的一个局部变量
    print(num)
global_test()
print(num)

运行结果如下

要使函数内的num为全局变量，我们可以使用global

num=100;
def global_test():
    global num
    num=200;#num相当于函数内的一个局部变量
    print(num)
global_test()
print(num)

运行结果如下

10.数据容器

Python中的数据容器
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如:
是否支持重复元素
是否可以修改
是否有序，等分为5类，
分别是列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

1.列表

列表的定义
基本语法:
字面量 [元素1，元素2，元素3，元素4，…]
定义变量
变量名称 =[元素1，元素2，元素3，元素4]
#定义空列表
变量名称 =[]
变量名称 = 1ist()
列表内的每一个数据，称之为元素
特点：
可以存储不同的数据类型，支持嵌套
常用的方法

mylist=["test","test2","test3"]
#1.查找某个元素在列表的下表
print(mylist.index("test"))
#如果不存在，会报错

#2.修改指定索引的值
mylist[0]="study"

#3.在指定位置插入元素
mylist.insert(1,"学习")
print(mylist)

#4.在尾部插入元素
mylist.append("2222")
print(mylist)

#5.extend()可以追加一批元素
mylist2=[1,2,3,4,5,6,7,8,9]
mylist.extend(mylist2)
print(mylist)

#6.列表内容的删除
del mylist[0]
print(mylist)
test=mylist.pop(1)#pop会将被删除的元素删除
print(f"被删除的元素是{test}")
#将指定的元素删除,删除第一个匹配的
mylist.remove(1)
print(mylist)
#将整个列表清空
mylist.clear()
print(mylist)

#7.统计某个元素的数量
print(mylist2.count(1))

#8.获得列表的总个数
print(len(mylist2))

运行结果

2.元组

元组定义:定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
它是不可以被修改的
#定义元组字面量
(元素，元素，元素)
定义元组变量
变量名称=(元素，元素,:…)
#定义空元组
变量名称 =() #方式1
变量名称 = tuple()#方式2
注意:定义只有一个元素的元组的方法:要加一个,

num=(10,)
print(type(num))

元组虽然不能修改，但是对于其中某些（比如列表）嵌套的元素的内容可以修改，

num=(10,[1,2,3,4,5,6,7,8,9,10])
print(type(num))
num[1][2]=10;
print(num)

运行结果如下

其余操作除了修改，和列表一样

3.字符串

注意，字符串的修改，是返回一个修改后的数据，而非对数据本身修改

str_test="I am study in home"
#1.字符串下标访问
print(str_test[0])
#2.查找给定字符串的第一个匹配项的下标
print(str_test.index("in"))
#3.将字符串内的某个字符串替换
test=str_test.replace("in","at")
print(test)
#4.将字符串按照给定的字符串进行分割,会返回一个列表
a=str_test.split(" ")
print(f"{a},它的类型是{type(a)}")
#5.strip()不加参数时,默认移除首位的空格和换行,也可以加上参数去除指定的字符串
str_test1="  12I am study in home121  "
a=str_test1.strip()
print(a)
print(a.strip("12"))#在结果中,121也被除去，因此会把"12"拆分,将结尾中的1,2都删除
#6.统计某个字符出现的次数
print(a.count("1"))
#7.统计字符串的字符个数
print(len(a))

运行结果如下

4.序列

序列是指:内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
序列的常用操作-切片
序列支持切片，即:列表、元组、字符串，均支持进行切片操作
切片:从一个序列中，取出一个子序列
语法:序列[起始下标:结束下标:步长1]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:起始下标表示从何处开始，可以留空，留空视作从头开始结束下标==(不包含)==表示何处结束，可以留空，留空视作截取到结尾步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)

#对list进行切片，从1开始，4结束，步长1
my_list=[0,1,2,3,4,5,6,7]
a=my_list[0:3:2]
print(a)
#对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0,1,2,3,4,5,6,7)
a=my_tuple[::]
print(a)
#对str进行切片，从头开始，到最后结束，步长2
my_str="hello world"
a=my_str[::2]
print(a)
#对str进行切片，从头开始，到最后结束，步长-1
a=my_str[::-1]
print(a)
#对列表进行切片，从3开始，到1结束，步长-1
a=my_list[3:1:-1]
print(a)
#对元组进行切片，从头开始，到尾结束，步长-2
a=my_tuple[::-2]
print(a)

运行结果如下

5.集合的操作

集合的定义
基本语法:
#定义集合字面量
{元素，元素，…，元素}
#定义集合变量
变量名称 = {元素，元素，…元素)
#定义空集合
变量名称 = set()
集合的特点
可以容纳多个数据
可以容纳不同类型的数据(混装)
数据是无序存储的(不支持下标索引)
不允许重复数据存在
可以修改(增加或删除元素等)
支持for循环

#定义集合
my_set={"hello","world","Python"}
my_set_empty=set()
print(f"{my_set},{type(my_set)}")
#添加新元素
my_set.add("hello")#由于已经有了hello,会被去重
my_set.add("java")
print(my_set)
#移除元素
my_set.remove("hello")
print(my_set)
#随机取出一个元素
print(my_set.pop())
print(my_set)
#清空集合
my_set.clear()
print(my_set)
#取两个集合的差集
my_set={"hello","world","Python"}
set1={1,2,3}
set2={1,3,5}
print(set1.difference(set2))
print(set1)#取出后,原来的不变
print(set2)
#消除两个集合的差集
set1.difference_update(set2)
print(set1)
#将两个集合合并
set1={1,2,3}
set2={1,3,5}
set3=set1.union(set2)
print(set3)
#获得元素数量
print(len(set3))
#集合的遍历
for i in set3:
    print(i)

运行结果如下
{‘hello’, ‘world’, ‘Python’},<class ‘set’>
{‘java’, ‘hello’, ‘world’, ‘Python’}
{‘java’, ‘world’, ‘Python’}
java
{‘world’, ‘Python’}
set()
{2}
{1, 2, 3}
{1, 3, 5}
{2}
{1, 2, 3, 5}
4
1
2
3
5

6.字典

字典可以提供基于Key检索Value的场景实现
就像查字典一样
字典的定义

a={"王力宏":88,"ttl":77,"林俊解":100}
#定义空字典
b={}
c=dict()

注意事项
键值对的Key和Value可以是任意类型(Key不可为字典)
字典内Key不允许重复，重复添加等同于覆盖原有数据
通过key进行访问
不支持索引
支持for循环，不支持while循环
以下是定义字典的示例

#定义字典
a={"王力宏":88,"ttl":77,"林俊解":100}
#定义空字典
b={}
c=dict()
print(f"{a},元素的类型是{type(a)}")
print(f"{b},元素的类型是{type(b)}")
print(f"{c},元素的类型是{type(c)}")
#定义重复key的字典
my_dict=a={"王力宏":88,"王力宏":78,"ttl":77,"林俊解":100}
print(my_dict)#重复定义的key一个被覆盖了
#从字典中基于key获取value
print(f"王力宏的分手{my_dict["王力宏"]}")
#字典的嵌套,key和value可以是任意数据类型(key不可为字典),以下定义嵌套字典
stu_score_dict={
    "王力宏":{"语文":88,"数学":90},"林俊解":{"语文":87,"数学":90}
}
print(stu_score_dict)
#从嵌套的字典获取数据
print(stu_score_dict["林俊解"]["语文"])

运行结果

字典的常用操作
字典[Key]：获取指定Key对应的Value值
字典[Key]= Value：添加或更新键值对
字典.pop(Key)：取出Key对应的Value并在字典内删除此Key的键值对
字典.clear()：清空字典
字典.keys()：获取字典的全部Key，可用于for循环遍历字典
len(字典)：计算字典内的元素数量
新增和更新元素的语法一致，如果Key不存在即新增如果Key存在即更新(Key不可重复)

7.数据容器的总结

数据容器的通用操作

使用演示

my_list = [1,2,3,4,5,6,7,8,9]
my_tuple = (1,2,3,4,5,6,7,8,9)
my_str= "hello world"
my_set = {1,2,3,4,5,6,7,8,9}
my_dict = {"a":1,"b":2,"c":3}
#len元素个数
print(len(my_list))
print(len(my_tuple))
print(len(my_str))
print(len(my_set))
print(len(my_dict))
#max取得集合的最大值
print("最大值")
print(max(my_list))
print(max(my_tuple))
print(max(my_str))
print(max(my_set))
print(max(my_dict))
#min取得集合的最小值
print("最小值")
print(min(my_list))
print(min(my_tuple))
print(min(my_str))
print(min(my_set))
print(min(my_dict))
#容器转列表
print(f"列表转列表的结果是:{list(my_list)}")
print(f"元组转列表的结果是:{list(my_tuple)}")
print(f"字符串转列表的结果是:{list(my_str)}")
print(f"集合转列表的结果是:{list(my_set)}")
print(f"字典转列表的结果是:{list(my_dict)}")#将字典的key取出到列表
#容器转元组
print(f"列表转元组的结果是:{tuple(my_list)}")
print(f"元组转元组的结果是:{tuple(my_tuple)}")
print(f"字符串元组的结果是:{tuple(my_str)}")
print(f"集合转元组的结果是:{tuple(my_set)}")
print(f"字典转元组的结果是:{tuple(my_dict)}")#将字典的key取出到列表
#容器转字符串
print(f"列表转字符串的结果是:{str(my_list)}")
print(f"元组转字符串的结果是:{str(my_tuple)}")
print(f"字符串转字符串的结果是:{str(my_str)}")
print(f"集合转字符串的结果是:{str(my_set)}")
print(f"字典转字符串的结果是:{str(my_dict)}")#将字典的全部内容取出
#容器转集合
print(f"列表转集合的结果是:{set(my_list)}")
print(f"元组转集合的结果是:{set(my_tuple)}")
print(f"字符串转集合的结果是:{set(my_str)}")
print(f"集合转集合的结果是:{set(my_set)}")
print(f"字典转集合的结果是:{set(my_dict)}")#将字典的全key取出
#容器排序的功能
my_list = [1,2,3,4,5,6,2,6,9]
my_tuple = (1,2,3,4,7,1,2,7,8,9)
my_str= "hello world"
my_set = {1,2,3,4,1,2,3,8,9}
my_dict = {"a":3,"b":1,"c":3}
print(f"对列表排序{sorted(my_list)}")
print(f"对元组排序{sorted(my_tuple)}")
print(f"对字符串排序{sorted(my_str)}")
print(f"对集合排序{sorted(my_set)}")
print(f"对字典排序{sorted(my_dict)}")

结果如下

注意，不是所有的数据都能转为字典

8.字符串比较大小

#字符串比较大小,从左往右一位一位比较,遇到一位大(ASCLL)的的就大
print(f"{'a'>'b'}")

运行结果如下

9.函数的进阶

1.函数的多返回值

return 变量1,变量2…
并且用多个变量接收返回值

def test_return():
    return 1,2
x,y=test_return()
print(f"多返回值返回的x:{x}")
print(f"多返回值返回的y:{y}")

运行结果如下

2.函数的多种传参方式

1.掌握位置参数
根据参数位置来传递参数
2.掌握关键字参数
通过“键=值”形式传递参数，可以不限参数顺序可以和位置参数混用，位置参数需在前
3.掌握缺省参数
不传递参数值时会使用默认的参数值
默认值的参数必须定义在最后
4.掌握不定长参数
·位置不定长传递以*号标记一个形式参数，以元组的形式接受参数形式参数一般命名为args
·关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs
使用示例

def user_info(name,age,gender):
    print(name)
    print(age)
    print(gender)
#位置参数
user_info("John",30,"男")
#关键字参数
user_info(name="sss",age=22,gender="女")
user_info(age=14,gender="男",name="张")#可以不按照定义的顺序使用
user_info("张",age=22,gender="男")
#缺省参数
def user_info(name,age,gender='男'):#设置默认值必须在最后
    print(name)
    print(age)
    print(gender)
user_info("张",80)#不给gender传递参数，使用默认的，默认在最后
#不定长参数
#位置不定长
def user_info(*args):#设置默认值必须在最后
    print(args)
user_info("w",20,"男")
#关键字不定长
def user_info(**kwargs):#设置默认值必须在最后
    print(kwargs,type(kwargs))
user_info(name="w",age=20,gender="男")

运行结果如下:

3.匿名函数

1.将函数作为参数传递
函数本身是可以作为参数，传入另一个函数中进行使
用的。
将函数传入的作用在于:传入计算逻辑，而非传入数
据。

def test_func(add):
    print(add(1,2))
def compute(a,b):
    return a+b
#可以理解为，传入的为计算逻辑
test_func(compute)

运行结果如下

2.lambda匿名函数
1.匿名函数使用lambda关键字进行定义
2.定义语法:
lambda 传入参数:函数体(一行代码)
3.注意事项
匿名函数用于临时构建一个函数，只用一次的场景
匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数
使用演示

def test_func(add):
    print(add(1,2))
def compute(a,b):
    return a+b
#lambda 传入参数:函数体（一行代码）
test_func(lambda x,y:x+y)

运行结果

10.文件相关的操作

1.什么是编码?
编码就是一种规则集合，记录了内密和二进制间进行相互转换的逻辑。编码有许多中，我们最常用的是UTF-8编码
2.为什么需要使用编码?
计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。

1.文件的读取操作

1.操作文件需要通过open函数打开文件得到文件对象
2.文件对象有如下读取方法
read()
readline()
readlines()
for line in 文件对象
3.文件读取完成后，要使用文件对象.close()方法关闭文件对象，否则文件会被一直占用
应用举例

#open以read模式，utf-8读取文件
file_open=open("E:\\test\\test.txt",'r',encoding='utf-8')
#read读取文件
print(file_open.read(3),end='')#读取3个字符,如果不加参数,则读取指针后的全部文件
print(file_open.readline())#读取指针所在的行
lines=file_open.readlines(2)#读取文件的所有的行,并且封装在列表中,加参数可以指定读取多少行
print(f"数据的类型是{type(lines)}")
print(lines)

file_open.close()

#with open语法操作文件,会自动关闭文件
with open("E:\\test\\test2.txt",'r',encoding='utf-8') as f:
    for line in f:
        print(line)

运行结果如下

2.文件的写入操作

1.写入文件使用open函数的’模式进行写入
2.写入的方法有:
wirte()，写入内容
flush()，刷新内容到硬盘中
3.注意事项:
w模式，文件不存在，会创建新文件w模式，文件存在，会清空原有内容
close()方法，带有flush()方法的功能
使用实例

#open以read模式，utf-8读取文件
file_open=open("E:\\test\\test3.txt",'w',encoding='utf-8')

#write写入
file_open.write("Hello World")
file_open.flush()
file_open.write("\ntest")
file_open.close()

结果

4.文件的追加

1.追加写入文件使用open函数的a模式进行写入
2.追加写入的方法有(和w模式一致):
wirte()，写入内容
flush(),刷新内容到硬盘中
3.注意事项:
会创建新文件a模式，文件不存在，
a模式，文件存在，会在原有内容后面继续写入
可以使用”\n”来写出换行符

#open以read模式，utf-8读取文件
file_open=open("E:\\test\\test3.txt",'a',encoding='utf-8')

#write写入
file_open.write("\n追加的数据")
file_open.flush()
file_open.write("\ntest")
file_open.close()

运行的结果

11.异常，模块与包

1.异常

1.什么是异常:
异常就是程序运行的过程中出现了错误
2.bug是什么意思
bug就是指异常的意思，因为历史因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误
3.为什么要捕获异常?
在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法运行。
4.捕获异常的语法?
try :
可能要发生异常的语句
except[异常 as 别名:]
出现异常的准备手段
[else:]
未出现异常时应做的事情
[finally:]
不管出不出现异常都会做的事情
5.如何捕获所有异常?
异常的种类多种多样，如果想要不管什么类型的异常都能捕获到，那么使用:
这两个会捕获所有的异常
except:
except Exception:

#演示捕获异常
#基本捕获异常
try:
    b=open("E:\test\t1.txt","r",encoding="utf-8")
    print()
except:
    print("文件有问题,将open改为w模式打开")
#捕获指定异常
try:
    #1/0
    print(name)
except NameError as e:
    print("出现了变量未定义的异常 ")
    print(e)

#捕获多个异常
try:
    1/0
except (NameError,ZeroDivisionError) as e:
    print("出现了变量未定义的异常或者除以0的异常 ")
    print(e)
#捕获所有异常
try:
    1/0
except Exception as e:
    print(e)


#异常else：表示没有异常执行的代码
try:
    1/1
except Exception as e:
    print(e)
else:
    print("没有异常")
#finally：无论如何都要执行
try:
    f=open("D:\123.txt","r",encoding="UTF-8")
except Exception as e:
    print("文件有问题")
    f = open("D:\123.txt", "w", encoding="UTF-8")
else:
    print("没有异常")
finally:
    print("finally无论如何都要执行")
    f.close()

运行结果如下

2.异常的传递性

异常的传递
异常是具有传递性的
当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02，当func02也没有捕获处理这个异常的时候main函数会捕获这个异常，这就是异常的传递性。演示代码如下

#异常的传递性
def func01():
    print("这是func01开始")
    num=1/0
    print("这是func01结束")
def func02():
    print("这是func02开始")
    func01()
    print("这是func02结束")


func02()

运行结果如下
我们可以发现，会一层一层的寻找异常，直到定位到1/0，因此如果软件出现问题，我们可以直接找最后的代码查看异常

11.python的模块

1.模块的导入

什么是模块
模块能定义函数，类和变量模块里也能包含可执行的代码
Python 模块(Module)Python 文件，是一个
以py 结尾.
模块的作用:python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能
大白话:模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用(导入模块去使用)
模块的导入方式
模块在使用前需要先导入 导入的语法如下:[from 模块名] import [模块 | 类 | 变量 | 函数 |*] [as 别名]
常用的组合形式如:
import 块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import块名 as 别名
from 模块名 import 功能名 as 别名
使用示例

#导入时间模块
#使用import导入time模块使用slepp模块
#import [模块名]
import time
print("你好")
time.sleep(5)
print("我好")

#from [模块名] import [功能名],导入某一个具体的功能
from time import sleep
sleep(10)

#from [模块名] import *导入模块内的所有功能
from time import *
sleep(10)

#使用as起一个别名
from time import sleep as test
print("开始睡10秒")
test(10)
import time as t
t.sleep(10)

运行结果如下

2.自定义模块

制作自定义模块
Python中已经帮我们实现了很多的模块，不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现，也就是自己制作一个模块
自定义模块要符合命名规则
如下图，my_module.py文件作为自定义模块

#导入自定义的模块
import my_module
my_module.test()

就可以调用运行运行

如果有多个名字相同的模块导入，会以最后一个为准
会执行，第二个导入的

在module1.py中，我们调用了test()进行测试

发现在import my_module1.py这个代码中，会执行my_module.py的测试，如何解决呢
我们可以在my_module1.py中的测试加入如下原理是：如果我们右键运行时，会给__name__传入一个值，右键运行传入__main__,会执行测试，如果是import导入包时，name__会不等于__main,从而使其不运行

all=[“函数名”]

from my_module1 import *
test1()
test()

在模块中，写入

我们发现，在执行的过程中，会报错

这是因为，all中只有test1

3.Python的包

什么是Python包
从物理上看，包就是一个文件夹，在该文件夹下包含了一个 init.py 文件，该文件夹可用于包含多个模块文件从逻辑上看，包的本质依然是模块
包的作用
方便管理越来越多的模块
创建包的方法如下
1.右键选择python package

2.在生成的包中写入自定义的模块
使用示例

#1.创建包
#导入自定义的包中的模块，并且使用
#import my_test.my_module
#my_test.my_module.test()
#from my_test import my_module
#my_module.test()
#from my_test.my_module import test
#test()

#我们可以使用__all__控制导入的模块
from my_test import *
my_module.test()

运行结果如下

5.安装第三方包

1.右键右下角

2.点击 interpreter setting，进入到设置，我们可以看到我们已经安装的包，点击+号可以添加包

12.数据可视化Echart

1.json

什么是json
JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
JSON本质上是一个带有特定格式的字符串
主要功能:json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互.类似于:
国际通用语言-英语
中国56个民族不同地区的通用语言-普通话
使用示例

import json
#准备列表，列表内每一个元素都是字典，将其转换为JSON
data=[{"name":"王大崔","age":20},{"name":"Tom","age":30}]
json_str=json.dumps(data,ensure_ascii=False)#不使用Ascii转换数据，而是将其直接输出出去
print(type(json_str))
print(json_str)
#准备字典，将字典转换为JSON
data={"name":"TOM","age":20}
json_str1=json.dumps(data,ensure_ascii=False)

#将JSON字符串转换为Python数据类型
tuplea=json.loads(json_str)
print(type(tuplea))#成功解析回列表

tupleb=json.loads(json_str1)
print(type(tupleb))#解析回字典

运行结果

2.pyechart开源可视化框架

安装pyecharts
在pycharm中点击安装即可
使用的示例
#导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
#创建一个折现图对象
line=Line()
#给折线图添加x轴的数据
line.add_xaxis([“中国”,“美国”,“英国”])
#给折线图添加y轴数据
line.add_yaxis(““GPD”,[30,20,10])
#设置全局配置项set_global_opts来设置
line.set_global_opts(
title_opts=TitleOpts(title=“GDP展示”,pos_left=“center”,pos_bottom=“1%”),
legend_opts=LegendOpts(is_show=True),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(is_show=True)
)

#通过render方法，将代码生成为html图像
line.render()
效果如下

3.数据的处理

例子：美国疫情统计折线图
有如下的美国疫情数据
经过观察，不是标准的json数据，因此将其读入后需要进行一定的处理

示例如下

"""
#导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
#创建一个折现图对象
line=Line()
#给折线图添加x轴的数据
line.add_xaxis(["中国","美国","英国"])
#给折线图添加y轴数据
line.add_yaxis("“GPD",[30,20,10])
#设置全局配置项set_global_opts来设置
line.set_global_opts(
    title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"),#标题
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True),#工具箱
    visualmap_opts=VisualMapOpts(is_show=True)
)

#通过render方法，将代码生成为html图像
line.render()
"""
import json

from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts

dateGet=open("E:\\test\\美国.txt","r",encoding="UTF-8")
dateSource=dateGet.read()
print("成功取到了原始数据")
dateSource=dateSource.replace("jsonp_1629344292311_69436(","")
dateSource=dateSource[:-2]
print("成功过滤数据")
#思考要取的数据
dict_date=json.loads(dateSource)
print(type(dict_date))
list_date=dict_date["data"]
print("成功取到了美国的数据")
updateDate=list_date[0]["trend"]["updateDate"]#统计的时间

list=list_date[0]["trend"]["list"]
Diagnosed_num=list[0]["data"]#确诊的数据
print("取到了统计时间")#updateDate
print("确诊的数据")#Diagnosed_num

line=Line()
line.add_xaxis(updateDate)
line.add_yaxis("确诊人数",Diagnosed_num)
line.set_global_opts(
    title_opts=(TitleOpts(title="美国确诊人数统计",is_show="true",pos_left="center",pos_bottom="1%")),
    legend_opts=LegendOpts(is_show="true"),
    toolbox_opts=ToolboxOpts(is_show="true"),
    visualmap_opts=VisualMapOpts(is_show=True)
)
line.render()
dateGet.close()

生成的图像如下

11.对象

1.认识对象

对象类似于表格，可以对数据进行有效的组织和管理
使用示例

#设计一个类
class Student:
    name=None
    gender=None
    nationality=None
    native_place=None
    age=None

#创建一个对象
stu_1=Student()

#为对象赋值
stu_1.name="林俊解"
stu_1.gender="男"
stu_1.nationality="中国"
stu_1.native_place="山东"
stu_1.age=20
#输出类的值
print(stu_1.gender)

结果如下

2.成员方法

1.类是由哪两部分组成呢?
类的属性，称之为:成员变量
类的行为，称之为:成员方法
函数是写在类外的，定义在类内部，我们都称之为方法哦
2.类和成员方法的定义语法
class 类名称:
成员变量
def 成员方法(self，参数列表):
成员方法体
对象!= 类名称()
3.self的作用
表示类本身的意思
只有通过self才能访问到类的成员变量
self出现在形参列表中，但不占用位置，无需理会
运行示例：以下的重点是self的使用

#设计一个类
class Student:
    name=None
    age=None

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("完成了初始化")
    #self指代类本身
    def say_hi(self):
        print(f"大家好，我是{self.name},我{self.age}岁了")
    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")

s=Student("王者荣耀",20)
s.name="sssa"
s.age=33
s.say_hi()#self在调用的过程中，会自动传入，无需自己写
s.say_hi2("我看好你")

3.类和对象

1.类和对象的关系是什么?
类是程序中的设计图纸
对象是基于图纸生产的具体实体
2.什么是面向对象编程?
面向对象编程就是，使用对象进行编程即，设计类，基于类创建对象，并使用对象来完成具体的工作

4.构造方法

Python类可以使用: init()方法，称之为构造方法。
在创建类对象(构造类)的时候，会自动执行
在创建类对象(构造类)的时候，将传入参数自动传递给 init 方法使用。
使用示例:

#设计一个类
class Student:
    name=None
    age=None

    def __init__(self,name,age):#构造方法会自动运行，并且赋值
        self.name=name
        self.age=age
        print("完成了初始化")
    #self指代类本身
    def say_hi(self):
        print(f"大家好，我是{self.name},我{self.age}岁了")
    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")

s=Student("王者荣耀",20)
s.say_hi()#self在调用的过程中，会自动传入，无需自己写

运行结果如下

5.魔术方法

上文学习的_init 构造方法，是Python类内置的方法之一。这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为:魔术方法
1.__str__方法
在我们没有重写str方法的时候，调用str方法，默认输出的对象的内存地址


我们可以自己写__str__方法，返回字符串
使用示例

class Student:
    name=None
    age=None

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("完成了初始化")
    #self指代类本身
    def say_hi(self):
        print(f"大家好，我是{self.name},我{self.age}岁了")
    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")

    def __str__(self):
        return f"我是{self.name},{self.age}岁了"
s=Student("王者荣耀",20)
s.say_hi()#self在调用的过程中，会自动传入，无需自己写
print(str(s))

运行结果

2.__lt__小于符号的比较
3.__le__小于等于的比较
4.__eq__用于2个类对象进行相等比较
使用实例

#设计一个类
class Student:
    name=None
    age=None

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("完成了初始化")
    #self指代类本身
    def say_hi(self):
        print(f"大家好，我是{self.name},我{self.age}岁了")
    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")

    def __str__(self):
        return f"我是{self.name},{self.age}岁了"

    def __lt__(self, other):#<符号
        return self.age<other.age

    def __le__(self, other):
        return self.age<=other.age

    def __eq__(self, other):#判断是否相等
        return self.age==other.age

s=Student("王者荣耀",20)
s1=Student("test",21)
s.say_hi()#self在调用的过程中，会自动传入，无需自己写
print(str(s))
print(s<s1)
print(s1<=s2)
print(s==s2)

运行结果

6.私有成员

类中提供了私有成员的形式来支持。
私有成员变量
私有成员方法
定义私有成员的方式非常简单，只需要:
私有成员变量:变量名以开头(2个下划线)私有成员方法:方法名以 开头(2个下划线)即可完成私有成员的设置
私有变量，不能通过变量名.私有变量的方法调用，只能被类内部的方法调用
使用示例：

class phone:
    __is_5g_enable=None
    def __init__(self,a):
        self.__is_5g_enable=a
    def __check_5g(self):
        if self.__is_5g_enable==True:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")
phone1=phone(True)
phone1.call_by_5g()

运行结果
### 7.继承

有单继承和多继承
继承的语法
class 类名(待继承a,待继承b,)
如果，a和b中有系统的属性或方法，以a为准，即左边的优先级更高
使用示例

#单继承
class Phone:
    IMEI=None
    producer="xm"

    def call_by_4g(self):
        print("4g通话")

class Phone2022(Phone):
    face_id=True
    def call_by_5g(self):
        print("2022年新功能：5g通话")

p=Phone2022()
p.call_by_4g()
p.call_by_5g()
#发现父类以及自己的类都能用

#多继承
class NFC:
    nfc_type="第五代NFC"
    producer="hm"
    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")

class RemoteControl:
    rc_type="红外遥控"
    def control(self):
        print("红外遥控")
class XiaoMiPhion(Phone,NFC,RemoteControl):
    pass#表示是空的，什么也没有

xm=XiaoMiPhion()
xm.read_card()
xm.control()
print(xm.producer)
#对于多继承，有重名的变量，以先来的优先（左边优先）

运行结果

7.复写和使用父类成员

复写
子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写
在子类中重新定义同名的属性或方法即可
在子类中，如何调用父类成员
方式1:
调用父类成员
使用成员变量:
使用成员方法:
父类名.成员变量父类名.成员方法(self)注意，self一定要写入
方式2:
使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法()
使用实例：

class Phone:
    IMEI=None
    producer="ITCAST"
    def call(self):
        print("4g通话")

#子类重写父类的方法
class NewPhone(Phone):
    def call(self):
        super().call()
        Phone.call(self)#self一定要写
        print("全新的5g通话")

a=NewPhone()
a.call()

运行结果如下

8.类型注解

类型注解
Python在3.5版本的时候引入了类型注解，以方便静态类型检查工具，IDE等第三方工具。
类型注解:
在代码中涉及数据交互的地方，提供数据类型的注解(显式的说明)。
主要功能:
帮助第三方IDE工具(如PyCharm)对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释
支持:
变量的类型注解
函数(方法)形参列表和返回值的类型注解
变量的类型注解语法
语法1: 变量: 类型
语法2:在注释中，#type:类型

注意:元组类型设置类型详细注解，需要将每一个元素都标记出来,字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致错误
使用示例

import json
from random import random


class Phone:
    IMEI:int=None
    producer="ITCAST"
    def call(self):
        print("4g通话")



#基础数据类型注解
var1:int=10
var2:str="sss"
var3:bool=True
#基础容器类型注解
my_list:list=[1,2,3,4,5]
my_tuple:tuple=(1,2,3,4,5)
my_dict:dict={1:"one",2:"two"}


#容器类型详细注解
my_list:list[int]=[1,2,3,4,5]
my_tuple:tuple[int,str,bool]=(1,"two",True)
my_dict:dict[str,int]={"aa":10,"test":111}

#在注释中进行类型注解
var_2=json.loads('{"name":"张三"}')#type:dict

函数形参和返回值的类型注解
函数名(形参名:数据类型，)->返回值类型

class Phone:
    IMEI:int=None
    producer="ITCAST"
    #对形参和返回值进行注解
    def call ( self , data : list)-> bool:
        print(data)
        print("4g通话")
        return True

Union类型
1.什么是Union类型?
使用Union可以定义联合类型注解
2.Union的使用方式
导包:from typingimport Union
使用:Union[类型,…, 类型]
使用示例

  def test(l:list[[Union[int,str]]],d:dict[str,Union[int,str]])->Union[int,str]:
        pass

写上注释后，pycharm会提示如下的内容，提示出参数和返回值的类型

多态
1.什么是多态?
多态指的是，同一个行为，使用不同的对象获得不同的状态。如，定义函数(方法)，通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态
2.什么是抽象类(接口)
包含抽象方法的类，称之为抽象类。抽象方法是指:没有具体实现的方法(pass)称之为抽象方法
3.抽象类的作用
多用于做顶层设计(设计标准)，以便子类做具体实现。也是对子类的一种软性约束，要求子类必须复写(实现)父类的一些方法

多态

class Animal:
    def cry(self):#这是一个抽象方法
        pass

class Dog(Animal):
    def cry(self):
        print("汪汪")

class Cat(Animal):
    def cry(self):
        print("喵喵")
def nosy(animal:Animal):
    animal.cry()
d=Dog()
c=Cat()
nosy(d)
nosy(c)

9.python操作mysql

1.Python中使用什么第三方库来操作MySQL?如何安装?
使用第三方库为:pymysql安装:pipinstall pymysql
2.如何获取链接对象?
from pymysqlimport Connection 导包
Connection(主机,端口,账户,密码)即可得到链接对象
链接对象.close()关闭和MySQL数据库的连接
3.如何执行SOL查询
通过连接对象调用cursor()方法，得到游标对象
游标对象.execute()执行SQL语句
游标对象.fetchall()返回查询得到的数据，为元组
使用示例

from pymysql import Connection
conn=Connection(
    host="192.168.159.3",
    port=3306,
    user="root",
    password="hadoop",
    autocommit=True#自动提交确认
)


print(conn.get_server_info())
#执行非查询性质的SQL语句
#获取游标对象
cursor=conn.cursor()
conn.select_db("p_test")
#cursor.execute("create table student(id int primary key ,name varchar(10),class varchar(10));")
#执行查询性质的SQL语句
cursor.execute("select * from student;")
results=cursor.fetchall()
cursor.execute("insert into student values (4,'王大锤','网络过程');")
conn.commit()
print(results)
conn.close()

运行结果

1.什么是commit提交?
pymysql库在执行对数据库有修改操作的行为时，是需要通过链接对象的commit成员方法来进行确认的。
只有确认的修改，才能生效。
2.如何自动提交呢?
autacommit=True
如下图

10.闭包

1.什么是闭包
定义双层嵌套函数内层函数可以访问外层函数的变量将内存函数作为外层函数的返回，此内层函数就是闭包函数
2.闭包的好处和缺点
优点:不定义全局变量,也可以让函数持续访问和修改一个外部变量
优点:闭包函数引用的外部变量,是外层函数的内部变量。作用域封闭难以被误操作修改
缺点:额外的内存占用
3.nonlocal关键字的作用
在闭包函数(内部函数中)想要修改外部函数的变量值需要用nonlocal声明这个外部变量
使用示例

#简单的闭包
"""
def outer(out_msg):
    def inner(inner_msg):
        print(out_msg, "使用了外部的消息",inner_msg)
    return inner
fn=outer("hello")
fn("成功了")
"""
#使用nonlocal修改为部函数的值
def outer(num1):
    def inner(num2):
        nonlocal num1
        num1=num1+num2
        print(num1)
    return inner
fn=outer(20)
fn(30)
fn(10)

#闭包实现，ATM的案例
def ATM_outer(num1=0):
    def ATM_inner(num2,R=True):
        nonlocal num1
        if R:
            num1=num1+num2
        else:
            num1=num1-num2
        print(f"余额为{num1}")

    return ATM_inner

fn=ATM_outer()
fn(20)
fn(10)
fn(10,False)

运行结果如下

11.装饰器

1.什么是装饰器
装饰器就是使用创建一个闭包函数，在闭包函数内调用目标函数。
可以达到不改动目标函数的同时,增加额外的功能。
2.写法
有两种写法，一种是传统的闭包写法，另一种是语法糖写法
闭包写法

#闭包的写法
def sleep_ing():
    sleep(random.randint(1,5))

def sleep_out(hans):
    def sleep_in():
        print("开始睡眠")
        hans()
        print("睡眠结束")

    return sleep_in#注意返回不加(),如果加了(),fn调用的时候也不能加，否则会报错

fn=sleep_out(sleep_ing)
fn()

语法糖的写法
这一种写法本质上，是将待增加功能的函数传递给闭包，让闭包调用

#语法糖的写法
def sleep_out(hans):
    def sleep_in():
        print("开始睡眠")
        hans()
        print("睡眠结束")

    return sleep_in
@sleep_out
def sleep_ing():
    sleep(random.randint(1,5))

sleep_ing()

12.设计模式之单例模式

有如下代码

class test:
    pass
a=test()
b=test()
print(id(a))
print(id(b))

运行结果如下

发现，创建的两个test对象属于不同的对象
某些工具类，仅需要1个实例，即可在各处使用
这就是单例模式所要实现的效果。
如何写单例模式
创建test1.py文件
写入如下代码

在运行的文件中

import test1
a=test1
b=test1
print(id(a))
print(id(b))

运行结果如下

发现只有一个实例对象

13.设计模式之工厂模式

1.什么是工厂模式
将对象的创建由使用原生类本身创建转换到由特定的工厂方法来创建
2.好处
大批量创建对象的时候有统一的入口,易于代码维护当发生修改，仅修改工厂类的创建方法即可符合现实世界的模式，即由工厂来制作产品(对象)

class Person:
    pass

class student(Person):
    pass

class worker(Person):
    pass

class PersonFac:
    def getPerson(self,s):
        if s=='s':
            return student()
        else:
            return worker()

p=PersonFac()
a=p.getPerson('s')
print(type(a))

14.多线程编程

使用示例
注意传参的使用

import time
import threading

def sing(msg):
    while True:
        print(msg)
        time.sleep(1)

def dance(msg):
    while True:
        print(msg)
        time.sleep(1)

a=threading.Thread(target=sing,args=("我在唱,我在跳,我又蹦又唱",))
b=threading.Thread(target=dance,kwargs={"msg":"我是Rap"})
a.start()
b.start()

15.网络编程

服务器端

#服务器端
import socket
import threading
def server(data:socket,address):#data接收连接对象
    print(f"来自{address}的连接")
    while True:
        #接收信息，接收到的信息为byte数组，要用decode解码,注意,这里会阻塞
        msg=data.recv(1024).decode('utf-8')
        print(msg)
        if msg=="exit":
            data.send("你我终将会再次相遇".encode("utf-8"))
            data.close()
            break

socket_server=socket.socket()
#绑定监听端口和IP地址
socket_server.bind(("localhost",8888))
#最大连接数量
socket_server.listen(3)
while True:
    #获取连接socket和地址等信息,会阻塞，直到受到连接并且接收连接
    conn,address=socket_server.accept()
    #将信息交给一个线程，让线程处理
    t=threading.Thread(target=server,kwargs={"data":conn,"address":address})
    t.start()

socket_server.close()

客户端

import socket
socket_client=socket.socket()
socket_client.connect(("192.168.159.3",8888))
while True:
    send_masg=input("请输入发送的消息")
    socket_client.send(send_masg.encode("UTF-8"))
    if send_masg=="exit":
        msg=socket_client.recv(1024).decode("UTF-8")
        print(msg)
        break

socket_client.close()

16.正则规则

正则表达式
正则表达式,又称规则表达式(Reqular Expression),是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换那些符合某个模式(规则)的文本。
简单来说，正则表达式就是使用:字符串定义规则,并通过规则去验证字符串是否匹配。
Python正则表达式,使用re模块,并基于re模块中三个基础方法来做正则匹配分别是:match、search、findall 三个基础方法
使用示例

import re
a="python java c++ c#"
#从第一个开始匹配，如果第一个字符就不匹配，就返回None
s=re.match('python',a)
print(s)
print(s.group())
print(s.span())
a="1python java c++ c#"
#从整个字符串寻找匹配的子串
s=re.search('python',a)
print(s)
print(s.group())
print(s.span())
#找到所有匹配的串
s=re.findall('python',a)
print(s)

运行结果

说实话，没学会这