从零开始的python学习

---

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、语法

1、基本语法

制表符\t自动对齐
print("hello\tword")
print("hello",end='')
print("hello",end='')
不换行，输出为hellohello

字面量-被写下来的固定值
单行注释# 建议加一个空格
多行注释三个双引号即"““开头，三个双引号结尾即””"
输出 print(内容1,内容2,…,内容n)

变量

变量名称 = 变量的值，右赋予左

数据类型

int-整数
float-浮点数
string-字符串需要’’ ''表示
type(被查看类型的数据)

数据类型转换

int(x)
float(x)
str(x)
将x转换为对应类型
浮点数转整数会丢失小数部分

标识符

给变量、类、方法等命名
限制：只允许出现中、英、数字、下划线_
不推荐中文，数字不可以出现在开头
不可使用关键字
给变量命名：小写，多个单词下划线隔开

运算符

==等于
！=不等于
// 取整除，向下取整
%取余
**指数
复合赋值运算符
+= ，即c+=a为c=c+a
-=
*=
/=
%=
**=
//=
同+=

字符串

1，单引号双引号三引号都可以定义
三引号时没有变量接受，那就是注释，支持换行操作。

\转义字符，\后解除效用
例：name='\'闪避\''输出后是闪避

2，字符串拼接
直接使用在print中使用+
数值无法拼接，只能用于字符串类型

3，字符串格式化（占位）

• **%s…%()**转字符串
• **%d…%()**转整数
• **%f…%()**转浮点

class_num = 57
avg_salary = 12113
message = "平均工资，北京%s期,毕业平均工资:%s" %(class_num,avg_salary)
print(message)#平均工资，北京57期,毕业平均工资:12113

自动把数字类型转为字符串类型

4，字符串格式化精度控制
m.n m代表宽度（大于等于数字本身宽度），n是小数点精度，自动四舍五入。

num1=123
num2=1.11111
print("%5d" %num1)
print("%8.3f" %num2)#长度由空格填充

5，字符串快速格式化

f"内容{变量}"
name='船只波尔'
year=2000
price=3.5
print(f"我是{name},我的生日是{year},yuerishi:{price}")

不改变数据类型和精度控制
6，表达式格式化
表达式：一条有明确执行结果的代码语句。

print("字符串类型是:%s"  % type("字符串"))

7，字符串比大小
根据ASCII比大小
两个字符串比较，一位一位比，只要有一位大就是大，不同长就和空格比。

数据输入-input()

输入的所有类型都是字符串

2、逻辑

布尔类型字面量：True（真），False（假）注意首字母大写
储存：变量名称=布尔类型字面量
除定义可以得到布尔类型外，通过比较运算符<,>,==等计算可以得到布尔类型

num_1=10
num_2=15
print(f"10==15的结果是:{num_1 == num_2}")#Flase

if语句

if 条件:
    条件成立时,要做的事#注意前面要有四个空格，不缩进不受if控制，别忘了冒号

if else语句

if 条件:
    条件成立时,要做的事
else:
    不满足条件时，要做的事#同样四个空格缩进

if elif else 语句

if 条件1:
    条件1成立时,要做的事
elif 条件2:
    条件2成立时,要做的事
elif 条件3:
    条件3成立时,要做的事
......

else:
    所有条件不成立，要做的事

判断语句的嵌套

if 条件1:
    条件1成立时,要做的事
    if 条件2:
    满足条件时，要做的事#if也同样四个空格缩进

外层if满足条件时，才会执行内层if判断
外层if不满足，直接执行外层else

3、循环语句

while语句

while 条件:
    条件满足时,做的事情1
    条件满足时,做的事情2
    条件满足时,做的事情3
    ......
i=0
while i<100:
    print("你是？？？")
    i+=1
while 条件1:
    条件满足1时,做的事情1
    条件满足1时,做的事情2
    条件满足1时,做的事情3
    ...
    while 条件2:
        条件满足2时,做的事情1
        条件满足2时,做的事情2
        条件满足2时,做的事情3

for语句

for 临时变量 in 待处理数据集:
     循环满足条件时执行的代码
#无法定义循环条件，只能从被处理的数据集取出内容处理

for的嵌套，同while

range语句

待处理数据集：序列类型，其内容可以一个个依次取出的类型，包括：

• 字符串
• 列表
• 元组
• 等

语法

range(num)
range(5)#[0,1,2,3,4]
range(num1,num2)
range(5,10)#[5,6,7,8,9]
range(num1,num2,step)
range(5,10,2)#step即步长为2,[5,7,9]

跳过和结束循环

continue：中断本次循环，直接进入下一次，可以用于for和while

for i in range(1,100):
    print("语句1")
    continue
    print("语句2")
    #语句2不执行

break：直接结束

for i in range(1,6):
    print("语句1")
    for j in range(1,6)
        print("语句2")
        break
        print("语句3")
  print("语句4")
    #语句1,2,4各输出五次

这两个只能作用在所在的循环，无法对上层循环起作用

二、函数

定义

def 函数名(传入参数)：
    函数体
    return 返回值
    #定义
函数名(参数)#调用

传参

函数名(参数1,参数2,...参数n)

返回值

def add(a,b,c,d):
    resut1=a+b
    resut2=c+d
    return resut1,resut2
r=add(1,2,3,4)
print(r)
#(3, 7)
def add(a,b,c,d):
    resut1=a+b
    resut2=c+d
    return resut1
r=add(1,2,3,4)
print(r)
#3
def add(a,b,c,d):
    resut1=a+b
    resut2=c+d
r=add(1,2,3,4)
print(r)
#None

None在if判断中表示False是假的意思

函数的嵌套调用

在定义一个函数时又调用了另一个函数。
函数A中执行到调用函数B的语句，会将函数B全部执行，完成后，将继续执行函数A的剩余内容。

变量在函数中的作用域

• 局部变量：在函数体内，只在函数体内生效，在函数外调用不了。
• 全局变量：在函数外定义的变量。
  global-声明以下为全局变量

num = 100
def add(a,b,c,d):

    resut1=a+b
    resut2=c+d
    global num
    num=200
    print(num)
    return resut1


r=add(1,2,3,4)
print(r)
print(num)
#结果是200,3,200.在多层嵌套的情况下，从本函数开始改变

三、数据容器

1，列表(list)

#字面量
[元素1,元素2,...]
#定义变量
变量名称=[元素1,元素2,元素3,...]
#空列表
变量名称=[]
变量名称=list()
X=[[1,2,3],[4,5,6]]
#可以嵌套

1.1列表的下标（索引）

取出列表中的特定位置的数据
从左到右索引从0开始，从右到左索引从-1开始
嵌套之后视列表为元素，下标规则一样

列表[下标]#语法
列表[下标][二维下标][三维下标]...#嵌套

1.2列表常用操作

列表.index(元素)#查询该下标，多个重复返回最小的
列表.insert(下标,元素)#在该下标位置插入元素，其他往后挪一位
列表.append(元素)#将这个元素追加到列表尾部
列表.extend(其他数据容器),#将其他数据容器内容取出，加到本列表尾部
del列表[下标]，列表.pop(下标)#删除这个下标的元素
列表.remove(元素)#删除指定元素，有重复优先第一个
列表.clear()#清空列表
列表.count(元素)#统计这个元素的数量
len(列表)#统计列表元素数量
列表[下标]#查询该下标的元素
列表[下标]=值#修改该下标的元素

1.3列表的遍历

定义：依次取出容器里的元素
例:

intex=0
while intex < len(列表):
    元素=列表[intex]
    对元素进行处理
    intex+=1
#用for
for element in my_list:
    print(f"列表的元素有:{element}")

2，元组(tuple)

不可修改元素 - 只读

变量名称=(元素1,元素2,元素3,...,元素4)

如果元组只有一个数据，那这个数据后面要加逗号
支持嵌套

元组[下标][二维下标][三维下标]...#取元素同列表
元组.index(元素)#查找下标
元组.count(元素)#统计这个元素的数量
len(元组)#统计元组元素数量

遍历

intex=0
while intex < len(元组):
    元素=列表[intex]
    print(f"元祖的元素有：{元素}")
    intex+=1
#用for
for element in my_tuple:
    print(f"列表的元素有:{element}")

3，字符串(str)

字符串是字符的数据容器，也同样有下标
取元素、查下标同列表、元组

字符串.replace(字符串1,字符串2)#将本字符串中的字符串1换成字符串2
字符串.split(分隔符字符串)#按照指定的分隔符字符串，吧字符串划分为多个字符串，
#存入列表里
例
my_str="qwe asd ad ad adsda"
my_str_list=my_str.split(" ")
print(my_str_list)
print(type(my_str_list))
#['qwe', 'asd', 'ad', 'ad', 'adsda']
#<class 'list'>

字符串.strip()#去除前后空格
字符串.strip(字符串)#去除前后指定字符串，如果指定去除的是12，是只要是1,2都去除
字符串.count(元素)#元素出现次数
len(字符串)#字符串长度

支持循环

4，序列

连续、有序、可用下标索引的数据容器
列表、元组、字符串都可以视为序列

序列的切片

序列[起始下标:结束下标:步长]
起始下标表示何处开始，可以留空，就是从头
结束下标表示何处结束，可以留空，就是截取到结尾
步长1表示，一个个取元素
步长2表示，跳过1个取元素
步长n表示，跳过n-1个取元素
步长为负数表示，反向取（起始下标结束下标也反向标记）
不影响序列本身，而是得到一个新序列

5，集合

集合无序，没有下标索引

变量名称={元素,元素,...,元素}
#可以写重复的，但是自动去重
集合.add(元素)——将指定元素添加到集合中
集合.pop(元素)——随机取数
集合.remove(元素)——将指定元素移除
集合.clear(元素)——清空集合
集合1.difference(集合2)#差集，集合1-集合1交集合2，得到一个新集合
集合1.difference_update(集合2)#一样，但是在集合1中操作
集合1.union(集合2)#两个集合并起来后去重
len(集合)#注意会去重
for X in set
    print()
#没有索引，不支持while遍历

6，字典(dict)

字典不允许key的重复，不可以使用下标索引，key不可是字典

变量={key1:value,key2:value,key3:value,...,keyn:value}
字典名[key][二维key]...——获取value
#########
嵌套
d_dict={
    "王力宏":{
        "yuwen":77,
        "shuxue":66,
        "yingyu":33
    },"JL":{
        "yuwen":88,
        "shuxue":99,
        "yingyu":100

    }

}
print(d_dict)
#输出{'王力宏': {'yuwen': 77, 'shuxue': 66, 'yingyu': 33}, 'JL': {'yuwen': 88, 'shuxue': 99, 'yingyu': 100}}

字典的常用操作

字典[key]=value#key存在key更新value,不存在key就是新增
字典.pop(key)#可以用变量获得value,同时删除该value
字典.clear()#清空字典
字典.keys()#获取全部key
keys=字典.keys()
for X in keys
    print(key)
    print(字典名[key])
for key in 字典
    print(key)
    print(字典名[key])
#两种遍历，因为没有索引，不支持while
len(字典)#统计元素数量

7，数据容器的几个通用操作

max(数据容器)
min(数据容器)
list.(数据容器)#转指定容器为列表
str.(数据容器)#转字符串
tuple.(数据容器)#转元组
set.(数据容器)#转集合
#字典转之后丢失value
sorted(容器,[erverse=True])#给指定容器进行排序，默认从小到大，[]里的内容默认不写
#排序结果全部变成列表，字典丢失value
#写了[]里的，就变成从大到小

四、函数进阶

函数多返回值

def test_return():
    return 1,2
x,y=test_return()
print(x)
print(y)
#返回1,2

函数多种传参方式

位置参数：前面用的，注意顺序

关键字参数

更清晰，清除了参数的顺序需求

def user_info(name,age,gender):
    print(f"您的名字是：{name},年龄是：{age},性别是：{gender}")
user_info(name="小明",age=20,gender="男")#关键字传参
user_info("小明",age=20,gender="男")#可以和位置参数混用，但位置参数在前，且匹配顺序

缺省参数（默认参数）

默认值必须统一在最后

def user_info(name,age,gender='男'):
    print(f"您的名字是：{name},年龄是：{age},性别是：{gender}")

user_info("小明",20,"女")
user_info("小明",20)#不设置默认就是男

不定长参数

位置传递
用*标记一个参数，以元组的形式接受参数，一般命名为args

def user_info(*args):
    print(f"args的内容是：{args}")
user_info(1,2,3,4,5,6)
返回#(1, 2, 3, 4, 5, 6)，这是元组

关键字传递
用**标记一个参数，以字典的形式接受参数，一般命名为kwargs

def user_info(**kwargs):
    print(f"kwargs 的内容是：{kwargs}")
user_info(name='小王',gender='不男不女')
#{'name': '小王', 'gender': '不男不女'}，这是字典

匿名函数

函数作为参数传递

是一种计算逻辑的传入，而非数据的传递

def test_func(compute):
    result=compute(1,2)
    print(result)
def compute(x,y):
    return x+y
test_func(compute)
#计算逻辑x+y自己随便改

lambda匿名函数

def，定义有名称的函数
lambda，定义匿名函数（无名称）
有名称，可以重复使用
无名称，只能临时使用一次

lambda 传入参数：函数体(一行代码)#只能写一行
lambda x,y:x+y
def test_func(compute):
    result=compute(1,2)
    print(result)
test_func(lambda x,y:x+y)

五、python文件操作

文件的读取

f=open(name,mode,encoding)#name是指名字或路径，mode设置打开文件的模式
#有只读——r，写入——w——打开原文件删除内容从头写，不存在创建新文件。追加——a——写到原有内容之后，没有创造新文件。
#encoding：编码格式，推荐UTF-8。f是文件对象。
文件对象.read(num)#num表示读取数据长度，单位是字节。没写就是全部。
文件对象.readlines()#按行读取，返回一个列表，每一行数据为一个元素。
文件对象.readline()#一次读一行，返回不改变数据类型。
for line in f:
    print(line)
文件对象.close()#关闭文件
with open("python.txt","r",encoding="UTF-8") as f:
    各种操作
#操作后自动关闭文件
文件对象.count(元素)#统计数量

文件的写入

w模式是删了重新写
不存在就会创造新文件

f.write("hello word")#文件写入，这是还没写进去，相当于草稿
f.flush()#内容刷新，这次才是真写了
例
f=open("D:\测试.txt","w",encoding= "UTF-8")
f.write("hello word")
f.flush()

文件的追加

和写入一样，换成a模式就行了
也是不存在就创建，\n可以换行，a模式是继续写
例

f=open("D:\测试.txt","a",encoding= "UTF-8")
f.write("hello word")
f.flush()

六、python异常、模块与包

捕获异常

异常（bug）

try:
    可能发生错误的代码
except：
    处理代码的操作，修改
#目的是不让错误外抛
try:
    print(name)
except NameError as e:
    print("出现变量未定义异常")
#这个NameError是python报错下面的
#捕获指定异常
try:
    1/0
except(NameError,ZeroDivisionError) as e:
    print("出现变量未定义或除零异常")
#捕获多个异常
try:
    1/0#各种bug都行
except Exception as e:
    print("出现异常")
#捕获所有异常
可以套else
finally:
    这里的语句不管怎样都会被执行#finally有没有异常都执行
    

异常的传递

类似于函数调用

python模块

python模块是一个python文件，以.py结尾，模块能定义函数，类和变量，里面也能包含可执行的代码。可以认为就是个工具包。

 [from 模块名] import [模块|类|变量|函数|*][as 别名]#模块的导入
 import 模块1，模块2
 模块名.功能名()#这是使用模块里的函数等，功能名就是函数名等
 from time import sleep#导入并只使用sleep函数
 from time import *
 sleep()#这样就不用模块名.了
 from time import sleep as sl
 sl()#设置别名，依旧可以使用

自定义模块

自己建一个python文件

__all__变量，如果模块文件中有这个变量，import*的时候，只能导入这个列表的元素
例如
__all__ = 'hanshuA'
定义了两个函数hanshuA，hanshuB#只能用hanshuA

同名的功能，后导入的会覆盖前面的

python包

python包就是带有一个_init_.py文件和许多模块文件的文件夹
从逻辑来看依然是模块

import 包名.模块名#导入
包名.模块名.目标()#使用
同模块
from 包.模块 import 功能
功能()#导入的第二种方式
__all__同模块一样，但只能控制*

七、图案例

json

在各个编程语言中流通的数据格式，中转用

json.dumps(data)把python数据转为json数据
json.loads(data)把json转为python

百度开发的pyecharts包，画图好用

折线图

from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
Line=Line()
Line.add_xaxis(["中国","美国","英国"])
Line.add_yaxis("GDP",[30,20,10])
Line.set_global_opts(
    title_opts=TitleOpts(title="GPT展示",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()

import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts
f_us = open("D:/美国.txt","r",encoding="UTF-8")
us_data = f_us.read()
f_jp = open("D:/日本.txt","r",encoding="UTF-8")
jp_data = f_jp.read()
f_in = open("D:/印度.txt","r",encoding="UTF-8")
in_data = f_in.read()
us_data = us_data.replace("jsonp_1629344292311_69436(","")
jp_data = jp_data.replace("jsonp_1629350871167_29498(","")
in_data = in_data.replace("jsonp_1629350745930_63180(","")
us_data=us_data[:-2]
jp_data=jp_data[:-2]
in_data=in_data[:-2]
#把json转为字典对象
us_dict=json.loads(us_data)
jp_dict=json.loads(jp_data)
in_dict=json.loads(in_data)
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']
us_x_data=us_trend_data['updateDate'][:314]
jp_x_data=jp_trend_data['updateDate'][:314]
in_x_data=in_trend_data['updateDate'][:314]
us_y_data=us_trend_data['list'][0]['data'][:314]
jp_y_data=jp_trend_data['list'][0]['data'][:314]
in_y_data=in_trend_data['list'][0]['data'][:314]
line = Line()#构建折线图
line.add_xaxis(us_x_data)#x轴公用，一个国家就行,is_show不显示数字
line.add_yaxis("美国确诊人数",us_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("日本确诊人数",jp_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("印度确诊人数",in_y_data,label_opts=LabelOpts(is_show=False))
#设置全局选项
line.set_global_opts(
    #标题设置
    title_opts=TitleOpts(title="2020年美日印确诊人数对比折线图",pos_left="center",pos_bottom="1%")#pos_bottom表示在最下面
)
line.render()
#关闭文件对象
f_us.close()
f_jp.close()
f_in.close()

地图可视化

简单的地图可视化

from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
map = Map()
data=[
    ("北京市",99),
    ("上海市",199),
    ("山东省",299),
    ("台湾省",199),
    ("安徽省",299),
    ("广州省",399),
    ("湖北省",599)
]
map.add("地图",data,"china")
map.set_global_opts(
    visualmap_opts = VisualMapOpts(
        is_show=True
    )
)
map.render()

基础柱状图

from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
bar = Bar()
bar.add_xaxis(["中国","美国","英国"])
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
#把30,20,10挪到右边
bar.reversal_axis()#反转yx轴
bar.render()

基础时间线柱状图

七、面向对象

基础定义

在程序中设计表格，称为：设计类（class）
class Student:
    name=None
在程序中打印表格，我们称之为：创建对象
stu_1=Student()
stu_2=Student()
在程序中填写表格，称之为：对象赋值
stu_1.name="周杰伦"
stu_2.name="林俊杰"

例子

class Student:
    name=None
    gender=None
    nationality=None
    native_place=None
    age=None
stu_1=Student()
stu_1.name="林俊杰"
stu_1.gemder="男"
stu_1.nationality="中国"
stu_1.native_place="山东省"
stu_1.age=31
print(stu_1.name)
print(stu_1.gemder)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)

class 类的名称
    类的属性#即定义在类中的变量
    类的行为#即定义在类中的函数
创建类对象的语法:
对象 = 类名称()

定义在类中的函数，称之为方法

def 方法名(self,形参1,......,形参n):
    方法体
    #self必须写，调用的时候不必写，但在内部调用必须写
class Student:
    name=None
    def say_hi(self):
        print(f"大家好,我是{self.name}")
stu=Student()
stu.name="林俊杰"
stu.say_hi()

类是一个抽象的概念，例如闹钟的图纸，而对象就是造出的多个闹钟实体。
不同闹钟属性就是不同价格等，不同行为是不同响铃等。
例：

class Clock:
    id=None
    price=None
    def ring(self):
        import winsound
        winsound.Beep(2000,3000)
clock1=Clock()
clock1.id="003032"
clock1.price=19.99
print(f"闹钟id：{clock1.id},价格：{clock1.price}")
clock1.ring()

clock2=Clock()
clock2.id="003032"
clock2.price=19.99
print(f"闹钟id：{clock2.id},价格：{clock2.price}")
clock2.ring()

魔术方法

构造方法

使用__init__()方法,称之为构造方法
在构造类时自动执行
在构造类时，传入参数自动传递给_init_方法使用

例子

class student:
    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("student类创造了一个类对象")
stu = student("周杰伦",31,"13233454523")
print(stu.name)
print(stu.age)
print(stu.tel)

字符串方法

class student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
    return f"student类对象，name:{self.name},age:{self.age}"
stu = student("周杰伦",31)
print(stu)
print(str(stu))

比较方法

class student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __lt__(self,other):
        return self.age < other.age
stu1 = student("周杰伦",11)
stu2 = student("林俊杰",13)
print(stu1<stu2)
print(stu1>stu2)
#不需要知道other是啥
__le__可用于>=、<=的比较
__ep__可用于==符号

封装

将现实世界中的属性、行为等封装到类中，描述为成员变量和成员方法。
不公开的属性和行为，现实世界也有类似的支持。

私有成员变量：变量名以__开头
私有成员方法：方法名以__开头

例

class phone:
    __current_voltage=None
    def __keep_d(self):
        print("让CPU以单核模式运行")
phone=phone()
phone.__keep_d()
#私有的外部无法调用，但是内部可以嵌套调用

继承

单继承

class 新类名(父类名)
    类内容体
例如
class Phone
    ...
class phone2024(phone)
    ...

多继承

class 类名(父类1,父类2,...,父类n):
    [类内容体][pass]
继承之后，不想写类内容体，写个pass

同名从左向右

继承之复写

即对父类的内容体修改
就是直接改

class phone:
    IMET = None
    producer = "ITCAST"
    def call_by_5g(self):
        print("使用5g网络通话")
class MyPhone(Phone):
    producer = "ITHM"
    def call_by_5g(self):
        print("开启单核模式")
        print("使用5g网络通话")
        print("关闭单核模式")

调用父类成员
super().成员变量
super().成员方法()

类型注解

变量的类型注解

语法是变量：类型
var_1:int=10
var_2:bool=True
class student
    pass
stu:student = student()
my_list:list=[1,2,3]
my_list:list[int]=[1,2,3]
my_tuple:tuple[str,int,bool]=("isni",666,True)
my_dict:dict[str,int] = {"itheima":666}

还可以通过注释写类型注解

import random
class student:
    pass
var_1 = random.randint(1,10)#type:int

是提示性的，不决定，标注错了代码也能跑

函数和方法类型注解

def 函数方法名(形参名:类型,形参名:类型,...)->返回值类型:
    pass
def func(data:list)->list:
    data.app
    return data
func()

多态

父类做定义声明
子类实际工作
同一行为，不同状态