6小时速成python

参考B站视频：【油管大神】python教程 6小时完全零基础入门 并且达到能开发网站

python入门(2019年的视频)

一、print函数

语法1：print()打印：作用是把其参数打印显示到屏幕上

可以是字符串，python解析器会一行一行从上到下依次执行！

可以是表达式，python解析器会运算可以运算的部分，并把运算的结果打印显示！

二、变量

值会存储到计算机的内存中，名字(标识符)可以指向对应的值！注意这里使用print就不能用引号了！

可以把打印的部分重复内容，提取出来，然后再通过运算符连接（表达式）！

三、input函数

语法2：input()输入：作用是输出提示词，然后把用户输入的值，保存起来，注意只有值，没有标识符去指向，最好赋值给变量，就可以通过变量把输入的值提出来！

当我们把输入的值，通过变量存储，通过+连接并打印，很方便，但是当我们把输入的值，进行算术运算时，会提示错误，因为所有输入的值，都会被当作字符处理！字符与数值很多运算不支持！

四、类型转换

语法：int()或float()：作用是把其它类型的值，转化为整型或浮点型，解释器会先执行类型转换，再执行表达式，

五、输出字符串特殊符号

字符串是由双引号或单引号包裹，但如果，此时我们想输出单引号或双引号时，会与编程语言的规则冲突，解释器会从开始到结束，依次找出成对引号，里面的内容才会被识别成字符串！

六、定义长字符串

单引号或双引号可以定义短字符串，但是如果我们想输出一篇文章等长信息，并且是保留格式，那么我们可以使用三引号""" 内容 """，可以跨行！

七、获取一个字符

获取字符串中某一个字符，使用索引！通过变量名，或者字符串名，后面接[]，键值为0，第一个字符索引，特殊的是：索引为正整数，从前到后依次提取出第N-1个字符，当索引为负数时，从后往前取出字符！与内存中存储的方式有关！

八、方括号语法[]：提取字符

语法：[]：作用返回字符串中，指定的值，当值大于等于0的整数，在对应字符串中，从前到后数，小于0，从后到前，当想提出一段范围的值时使用[0:4]，冒号前后各一个数，表示范围！包前不包后！[开始索引:结束索引]，当不指定结束索引，默认到最后一个字符！同理不指定开始索引，从0开始

当开始索引为正整数，结束索引为负整数，代表从开始第几个字符，到最后第几个符，返回中间范围

九、格式化的字符串

在动态生成某些东西的时候，尤其有用！——字符变量！当文本中存在字符变量时，可以通过字符串中的表达式连接字符，可以实现功能，但这样看起来非常混乱！

格式化字符串的语法：f'{变量名} 可以是字符和变量名的混用'：作用是把f’’引号内的内容当作字符串，并可以识别出变量！把需要使用变量时，用花括号{}，当是字符串时，直接写在’‘引号内！

相当于在一串字符中，开了几个洞，用{变量名}来占据一个字符串位置，当解释器运行时，会提取变量的值，填满这个洞！

十、字符串函数

通用函数，计算长度，语法：len(字符串/字符变量)：作用是计算字符串中的长度！

字符串专用函数，也称为方法，通过点运算符！

• 转大写语法：字符串.upper()：作用是转化为大写！不改变原字符串

• 转小写语法：字符串.lower()：作用是转化为小写！不改变

• 查找语法：字符串.find(字符/串/变量)：查找字符串中是否存在字符，返回第一次出现索引！不改变

• 大小写敏感，当没有查找的字符时，返回-1

• 替换字符语法：语法：字符串.replace()：传递两个字符，作用是查找第一个字符，并用第二个字符去替换！大小写敏感，查不到则不替换

检测是否存在字符的表达式，表达式语法：字符串 in 字符串：检测在第二个字符中，是否存在第一个字符，返回值为布尔值！注意：查找语法是个方法，这是个表达式，返回布尔值！

十一、数值的算术运算

除法：/ 返回浮点型 ，print(type(6/3)) 运算后返回<class 'float'>

当希望返回为整数时，语法：//

取余数：%

指数：**

赋值运算的妙用：增值，当变量为一个数值时，对变量进行算术运算，然后再赋值给变量！

缩写：+= 算术运算符=

操作符优先级：

括号与运算：()：作用提升优先级

十二、数值的内置函数

取整函数语法：round()：作用是向上取整

绝对值函数语法：abs()：作用是返回正数

十三、python数学模块

导入语法：import math

使用导入的函数，使用点运算：math.

十四、函数结构——语法执行顺序

if 布尔值:
	语句1
	语句N
else:
	语句3
	语句N

通过缩进来识别结构分支！并且if和else和elif有种对应关系！意味着，在没有缩进的情况下，会自动匹配一定的逻辑！——分支结构！

if 布尔值：
	语句
elif 布尔值:
	语句
else:
	语句

十五、逻辑运算符

and or not

十六、比较运算符

注意类型

十七、while循环

while 条件:
	语句1
	语句N

跳出循环

break，当循环体里面，执行到break时，立刻跳出循环！

并且在循环结束，也就是循环的条件为假时，还可以添加else语句，当条件为假时执行！

案例：猜数字

# 定义三个变量，分别存放最大限度次数，当前猜测次数，正确值
count = 9
guess_num = 1
guess_lim = 3
while guess_num <= guess_lim:
    guess = int(input('请输入你猜测的数字，提示小于10，大于0： '))
    guess_num += 1
    if guess == count:
        print('猜对了，太厉害了')
        break
else:
    print('机会已用完，猜错了，下次加油吧')

案例：驾驶小车

# 为了让代码不臃肿，不要重复第二次
input_word = ''
started = False
while True:
    input_word = input('>').lower()
    if input_word == 'quit':
        break
    elif input_word == 'start':
        if started == False:
            print('小车出发了，请小心驾驶！')
            started = True
        else:
            print('小车已经开始了，不要重复启动，会损伤发动机的！清除没？')
    elif input_word == 'stop':
        if started == True:
            print('你的停车技术真好')
            started = False
        else:
            print('小车已经停了，你点刹车也没用，别白费力气了')
    elif input_word == 'help':
        print('''
start 启动小车
stop  停车
quit  退出游戏
help  帮助
        ''')
    else:
        print('请输入正确的指令，查看全部指令请输入help')

十九、for循环
使用for可以极大的简洁代码，特别是用于遍历数组、字符串、对象，又或者是循环一定次数！
语法：for 变量名 in 范围对象：作用是遍历范围内的值，并把值赋予变量，循环次数就是值的多少，也就是说，循环次数由范围对象决定，这极大解决了循环次数，一般这种是利用对象的值进行操作！
如果范围是rang()函数，相当于C或者Js等编程语言的for，输入一个值是循环次数，给两个数值，是循环次数，且利用的循环变量不同，如果是三个值，利用的循环体步长！一般用来对循环遍历进行操作！或者纯粹的就是想循环多少次！

# 变量名随意，in后接的范围是字符串时，循环的变量就是字符，当是列表对象时，就是数据
for item in ['赵','钱','孙','李']
	print(item)

二十、循环嵌套
打印坐标，利用循环变量

for x in range(4):
	for y in range(5):
		print('* ')

打印少量无规则星号，利用数值列表，列表值的个数，就是循环次数，列表中的数值，就是待打印的个数，利用字符与数值的乘法运算，来打印

arr = [6,4,7,4]
for x_count in arr:
	print('* ' * x_count)

arr = [6,4,7,4]
# 利用范围对象包含多少个值作为循环次数，仅利用循环次数
for x_count in arr:
	count = ''
	# 利用值作为循环次数，仅利用循环次数
	for num in range(x_count):
		count += '* '
	print(count)

二十一、列表[]
访问原理和字符一致，通过索引访问，从0开始，正整数代表从前到后，负整数代表从后到前，同样可以使用[:]，来确认范围，可以是正整数或负整数，包前不包后！也就意味着你一旦拥有一个列表，就拥有不多长度的列表！[:]拆分列表，并不影响原列表！
修改列表中的值，赋值！

二十二、二维列表
二维列表，把列表当作数据，存放在列表中！
二维列表访问内部列表的数据，列表名[2][1]，第一个索引访问内部第几+1个列表，第二索引是内部列表的索引值！
二维列表，配合循环嵌套有妙用！

二十三、列表方法(函数)

• 插入
  末尾插入值方法：列表.append()：作用是将append()括号内的值插入到列表末尾，改变
  任意插入值方法：列表.insert()：作用是将()括号内的值插入到列表，可以携带两个参数，第一个参数是int类型，表示插入的索引位置，第二个是值，插入后，索引后面的值，向后退！
• 移除
  移除值方法：列表.remove()：作用是将remove()括号内的值移除列表
  清空列表方法：列表.clear()：作用是将列表内的值全部移除！
  末尾值移除方法：列表.pop()：作用是将pop()列表末尾值移除
• 查询
  查询列表中值索引：列表.index()：作用是查询index()括号内的值，如果存在，返回对应索引！如果没有会报错！
  查询列表中值是否存在：值 in 列表：查询，返回True或False，更安全！
  查询列表中值的个数：列表.count()：作用是查询()括号内的值，返回出现的个数！
• 排序
  升序方法：列表.sort()：返回None，也就是不返回，直接改变原数组，从小到大排序！
  反转序列方法：列表.reverse()：直接改变原数组！如果先排序，后反转就是降序！
• 复制
  复制列表方法：列表.copy()：作用是将()括号内的列表复制一份，返回这个列表

案例：把列表中重复的数据删除

# 生活经验，挑选新鲜的水果放入购物袋！
arr = [3,6,8,9,5,6,7,8,9,3,4,5]
new_arr = []
for num in arr:
	if not(num in new_arr):
		new_arr.append(num)
print(new_arr)	

注意：not(num in new_arr)等同于num not in new_arr

二十四、元组()
和列表类似可以存储项目列表，不同的是不能修改、不能添加新项目、不能删除原有项目！也就是说元组是不可改变的！也就是或，如果想创建一组数据，但不想随意改动，就可以使用元组！
只有两个方法，元组.count()计算一个项目出现的次数，元组.index()查询第一次出现的索引

二十五、元组简化赋值
例如：

coordinates = (1,2,3)
# 想要经常使用元组内的值时，常用方法是提取赋值
x = coordinates[0]
y = coordinates[1]
z = coordinates[2]
# 更简单的方法,原理一致！
x,y,z = coordinates

注意：不仅在元组中使用，也可以在列表中使用！

二十六、字典{}
存储键值对的信息，相当于自定义索引，索引本身也具有意义，相当于存放的是一对变量！一个字典中可以存放多对相关的键值对！比如一个老师的信息，有姓名性别身高年龄工作等详情！

# 键和值可以是任意不可变的值
customer = {
	'name': 'yan',
	'age': '40',
	'verified': True
	(666,777): 'niu'
}

注意：每个键必须唯一标识符！唯一键，值可以随意！
查询值，字典['name']，像数组一样使用方括号取获取值！如果不存在值，那么返回错误！
更温和一点，字典.get()，同样可以获取值，如果不存在，返回None并且还可以赋予默认值，字典.get('birthdate','1996-1-1')，如果不存在这个键值对，那么使用默认！
案例：输入一串数字，翻译成对应单词！

fan_words = {
'1': 'one',
'2': 'two',
'3': 'three',
'4': 'four',
'5': 'five',
'6': 'six',
'7': 'seven',
'8': 'eight',
'9': 'nine'
}
input_word = input('请输入你的号码：')
output_word = ''
for num in input_word:
	output_word += fan_words.get(num)+' '
print(output_word)

案例：输入一段文字，输出输入的句子，并把某个符号翻译成表情！

fan_words = {
'6': 'good job',
'7': 'GG'
}
input_word = input('>')
output_word = ''
for num in input_word:
	output_word += fan_words.get(num,num)+' '
print(output_word)

注意：英文输入，可以通过split(' ')空格来拆分单词，从而识别出表情符号，替换成对应表情！
注意：这里的get()的妙用，有则更改，无则原封返回！
注意：输入的是字符，输出的是字符，对象的键是字符，才造就了如此简洁的代码！

二十七、函数
把代码拆分成更容易维护的块，更小的功能，可以重复调用不复写，这种优秀的组织 代码块的方式叫做函数！函数：用于实现特定功能的几行代码的容器！
像自带的函数，每个函数实现一个小功能，可重复利用的块！利用这个块，更好的组织代码！
程序：数据结构 + 算法！（实现的小功能——用代码块包裹）

• 定义函数——必须先定义再使用！

def 函数名():
    函数体
    
函数名()

注意：使用关键字def定义函数，调用函数时才执行函数体的代码！函数体后空两行！

• 传递值给函数，在定义时可以添加参数叫形参，调用时可以传递参数叫实参！

def greet_user(name):
    print(f'你好，{name}！')
    print('欢迎你的到来！')
    
    
greet_user('晏先生')
greet_user('李女士')

注意：格式，当函数有形参时，需要赋予实参，不然会报错！形参是占位符，用于接受信息！名称不重要！改名不影响函数使用！实参是为函数提供实际信息，很重要！形参的位置顺序很重要，多个形参时，使用实参也必须按照同样的位置顺序赋值！

• 调用函数时

实参可以指定，greet_user(name='晏',sex='先生')，类似赋值，去指明形参和实参的对应关系！

更多时候是按位置顺序传参，当然为了代码易读，也可以指明！注意：必须统一，要么都指明要么不，（或者，前面是位置实参，最后是指明传参，且位置要与参数名对应！）

• 返回函数值

函数默认是不返回值的，当我们调用函数打印，看到返回的值是None，表示没有返回值！

当给函数添加return 语句，执行函数会返回语句结果！返回的值可以继续参与其它运算！

二十八、如何提取出函数

一段代码实现一个功能，怎么把这段代码，改造成一个函数！

不担心输入方式，传参方式有很多种，可以把用户输入的值，作为参数，可以调用函数时，输入值！不同出输出方式，只需要把传入的信息处理后结果返回，怎么输出可以调用时再设定！

def transf(input_word):
    fan_words = {
        '6': 'good job',
        '7': 'GG'
    }
    output_word = ''
    for num in input_word:
        output_word += fan_words.get(num, num) + ' '
    return output_word


word = input('>')
print(transf(word))

二十九、处理错误

age = int(input('Age:'))
print(age)

# 当输入非数字时，程序报错，ValueError:错误的值！退出码显示1，表示程序崩溃！

处理这个应值输入错误，导致程序崩溃！当出现错误时，打印合适的提醒消息！

注意：返回的错误类型！记住这个值！

三十、用try:来处理错误！

try:用于预知错误的代码块，except用于接受错误类型

try:
    提示错误的代码块
except 错误类型:
    遇见该情况的处理

注意：通过try和except，相当于告知了python编译器，当允许这段代码时，如果遇到该错误类型，执行我说明的情况！不要崩溃了！如果不出现错误，则没事！总而言之，将这个代码块出现的错误作为例外，当出现错误，则捕获到，然后执行对策，这样程序就不会崩溃了！

案例：

try:
    age = int(input('Age:'))
    print(age)
except ValueError:
    print('请输入数字，不要输入无关的值！')

三十一、注释

注释应该是帮助理解的，说明是干什么的，但也要克制，不要随便写注释，影响观感和阅读障碍！不写重复的无用的注释！

三十二、了解类的生成！

目的：创建一个新类型，可以通过点位符，来实现各种自定义操作(调用各种函数)！即自己生产一个类型，按照这类型生成一个对象，给这个对象添加自己类型生成的方法！

案例：创建一个车子，可以通过点位符，去使用开车的方法、停车的方法！

# 创建一个类，注意类的名称首字母大写！命名规则！大写单词首字母！
class Car:
    def move(self):
        print('下车启动了')
        
    def stop(self):
        print('下车停止了')
        
#实例化对象       
# 创建完类后，就可以创建新对象了！核心！
car1 = Car()

# 在这个变量中使用点运算，就可以出现类里的函数了，也就是方法！
car1.move()		

# 除了方法，这些对象，还可以具有属性！就像是属于某个特定对象的变量！
car1.move_range = 100
# 使用创建的对象，来调取这个实例的变量？point()是对象的模板，代表着类!
print(car1.move_range)

​ 第一步：新类型——类

1. 创建好类，注意类名采用Pascal命名，不使用下划线，采取首字母大写

2. 在类中，缩进，创建函数！函数间空一行！

​ 第二步：新对象/实例

注意：写在在类后面空两行，对象是类的一个实例，类创建了对象的蓝图或者模板！而对象是基于类的样子生成的实际实例！

1. 输入类的名字，然后像写函数一样添加()，这就创建了一个新对象！

2. 然后返回它，把它存储在一个变量中！

完成，这样创建的新对象，就可以使用刚刚创建好的新类型的方法了，这个新类型叫做—类，这个新对象叫做—实例！

三十三、类class

• 创建类

使用关键字class，然后再使用冒号，代表后面接的是代码块！比如在后面再写几个函数，def关键字，创建函数时，点击括号，自动建立形参self，默认形参，指向类！

class 类名:
    def 函数名(self):
        函数块
        
    def 函数名(self):
        函数块
        
        
函数之间空一行，类最后空两行！

• 实例化

使用类名()，类名后接一个括号——生成新的一种对象（创建对象）！新对象返回后，使用变量保存，这个变量就是实例，这个过程叫做实例化！

变量 = 类名()

从硬件上理解，就是类名()，在内存中新创建一块地方保存从类中获取到的内容，然后用一个变量名来指向！

• 实例的属性

每个实例对象都可以调用类的函数，并且实例间不一样！每个实例里，可以建立自己的变量，所以实例可以存放自己的变量和值！叫做实例属性！私有属性！

变量.变量名 = 值

三十四、构造函数——用于类的 初始化 的函数

目的：实例化中，创建的对象可以传递值，然后创建的实例，可以通过点位符直接使用这些传入的值

第一步：在类中添加新的方法，注意方法名__init__，意思是初始化

def __init__(self):

第二步：添加新的形参，并在函数体内，可以对形参的值加工，也可以不加工，通过创建对象时实参传入！也叫做初始化对象！这个函数叫构造函数！

def __init__(self,对象形参1,对象形参2):
    self.变量1 = 对象形参1(值为对象传入的实参)
    self.变量2 = 对象形参2(值为对象传入的实参)

变量 = 类名(实参1，实参2)	# 创建的新对象初始化！

注意：这里时把初始化传入的实参，不经任何加工，又返回给了实例的变量！实例通过调取变量时，就可以得到创建的对象传入的值！

关键字self，就是实例自己！指向每个实例自己！

class Car:
    def __init__(self, x, y):	#self指向创建的实例，把初始化传入的值赋值给实例的属性
        self.m = x
        self.n = y


car1 = Car(66, 77)	# 创建对象时传参，初始化对象！再实例化！
car2 = Car(11, 22)	# 又创建对象时传参，传入的参数不同，实例也就不同，两个不同实例！

#第一个实例，变量与第二个实例变量不同，打印出属性值试试！
print(car1.m)
print(car2.n)

# 给第二个实例，重新赋值属性值，再打印试试！（私有属性）
car2.m = 7777
print(car2.m)

升级版！

当把对象传入的实参进行加工！实例再调用属性值！

变化版！

还可以在直接赋值，就不用在创建对象时赋值了！创建对象时就不能赋值了！

def __init__(self):
    self.变量名1 = 值1
    self.变量名2 = 值2

等价于，也就是说，完全可以不用在创建对象时传参！

实例.变量名1 = 值1
实例.变量名2 = 值2

案例：开着车子出去

class Car:
    def __init__(self, name):
        self.carname = name

    def move(self):
        print(f'看呀，开{self.carname}出去玩了')

    def stop(self):
        print(f'一脚刹车，把{self.carname}停下了')


car1 = Car('兰博基尼')
car1.move()

三十五、继承

创建类时，如果多个类有相同代码，那么可以把重复代码，放到一个新建的公共类里面！然后在子类添加括号，括号内填父代的类名！如果子类没有代码，编辑器会发出警告，可以添加pass关键字

class Niubi:
    pass


class Maniubi(Niubi):
    pass

案例：

class Car:
    def move(self):
        print(f'看呀，开{self.name}出去玩了')

    def stop(self):
        print(f'一脚刹车，把{self.name}停下了')


class Lanbo(Car):
    def __init__(self):
        self.name = '兰博基尼'


car1 = Lanbo()
car1.move()

三十六、模块——库

• 导入模块（外部文件），注意：一个模块应该包含相关的内容！函数和类！

关键字import接文件名，不用添加后缀，使用其它文件的类时，类前面也添加上文件名！

import 文件名

# 使用外部文件，外部文件相当于一个对象，使用文件名和点位符操作！
实例 = 文件名.类名()

使用外部文件中的函数或者类时，相当于创建了一个同名的对象，通过对象引用其中的函数和类！

• 导入模块的特定函数

关键字from 文件名 import 函数名

from 文件名 import 函数名

# 调用该函数时，就不用添加文件名

案例一：导入外部模块

drivecar.py

class Car:
    def move(self):
        print(f'看呀，开{self.name}出去玩了')

    def stop(self):
        print(f'一脚刹车，把{self.name}停下了')


class Lanbo(Car):
    def __init__(self):
        self.name = '兰博基尼'


class Baoma(Car):
    def __init__(self):
        self.name = '宝马'

hello.py

import drivecar

baomao = drivecar.Baoma()
baomao.stop()

案例二：导入外部模块中的函数

drivecar.py

def move(name):
    print(f'看呀，开{name}出去玩了')


def stop(name):
    print(f'一脚刹车，把{name}停下了')

hello.py

from drivecar import move
move('兰博基尼太美')

三十七、注意名字警告

当标识符出现波浪线时，注意是不是与关键字，或内置函数重名了！重构去改名！

三十八、包

一个包是一个文件夹或目录，是为了更好的组织代码！

• 创建包

新建一个文件夹，在文件夹里创建一个名为__init__.py的python文件，这样就创建好了一个包！

必须__init__.py这个文件，这个文件夹，python才会识别为一个包！！！有快捷方式创建！！

• 导入包中的模块文件

同样有两种，导入模块或导入模块中的函数！

import 包名.模块名

# 调用模块中的函数一样需要这些前缀！
包名.模块名.函数名()

仅导入模块中的函数，就不用那么麻烦了

from 包名.模块名 import 函数名,函数名,函数名,函数名	#导入多个函数用逗号隔开！

# 直接使用函数！

语法：from XX import XX，还可以从包中导入模块

from 包名 import 模块名,模块名,模块名,	#导入多个模块用逗号隔开！

# 使用函数也需要加上模块的前缀！
模块名.函数名()

三十九、python内置模块——标准库

官方文档：https://docs.python.org/3/py-modindex.html

当我们引入标准库的模块时，不用担心自己文件中没有这个文件，python解释器知道哪里有！

案例：导入随机模块

import random

for i in range(3)
	print(random.random())	# 随机生成0-1范围的浮点数
    print(random.randint(1，20)) # 随机生成1-20范围的整数
    
# 还可以在列表中，随机抽取一个项目返回
members = ['赵','钱','孙','李']
leader = random.choice(menbers)		# 把返回的值，赋值给变量
print(leader)

案例：摇塞子

返回两个数，python默认这两个数是一个元组类型！

四十、如何使用标准库中的模块

使用标准库中的pathlib模块，中的Path类

from pathlib import Path

# 相对路径/绝对路径，这里选择的是相对路径，因为简洁方便
path = Path('文件名')
print(path.rmdir())		#删除这个文件

# 批处理文件
path = Path()
print(path.glob('*.*'))		# 查询文件 文件名.文件类型

# 打印文件名
from pathlib import Path

path = Path()
for file in path.glob('*.py'):  # 搜索指定的文件类型
	print(file)

for file in path.glob('*'):  # 搜索文件夹下所有文件
	print(file)

四十一、更全面的python包

官网模块链接：https://pypi.org/

使用一个处理excel表的包，在pycharm终端中，运行pip install openpyxl就可以下载!

在终端中运行，然后下载的文件在site-packges里面！

案例：处理excel表中的价格

把文件添加到你的项目中，如何放，要么粘贴到文件，要么从磁盘中加载！

import openpyxl as xl

wb = xl.load_workbook('dealprice.xlsx')  # 加载xl文件,并返回了一个xlsx对象
sheet = wb['Sheet1']                     # 使用方括号，指定表格的名称,确保大写首字母，返回一个表格第一行？
# cell = sheet['a1']                       # 访问特定的单元格,使用坐标，返回指定单元格,也可以调用方法来访问单元格sheet.cell(1,1)
# print(cell.value)                        # 打印单元格中的值
# 接下来是打印出价格哪一列的单元格内容！
for row in range(2,sheet.max_row + 1):      # 循环多少次,range范围是包前不包后
    cell = sheet.cell(row,3)
    # print(cell.value)                       # 打印单元格中的值value
    corrected_price = cell.value * 0.9
    corrected_price_cell = sheet.cell(row,4)    # 把修正的值，添加到新的一列，也可以覆盖原来那一列
    corrected_price_cell.value = corrected_price

wb.save('dealedprice.xlsx')         # 保存到新文件下，以防程序错误，导致原文件GG

添加柱状图！

import openpyxl as xl                               # 操作xlsx，导入类
from openpyxl.chart import BarChart, Reference      # 想生成图表，导入条形图类

wb = xl.load_workbook('dealprice.xlsx')  # 加载xl文件,并返回了一个xlsx对象
sheet = wb['Sheet1']                     # 使用方括号，指定表格的名称,确保大写首字母，返回一个表格第一行？
# cell = sheet['a1']                       # 访问特定的单元格,使用坐标，返回指定单元格,也可以调用方法来访问单元格sheet.cell(1,1)
# print(cell.value)                        # 打印单元格中的值
# 接下来是打印出价格哪一列的单元格内容！
for row in range(2,sheet.max_row + 1):      # 循环多少次
    cell = sheet.cell(row,3)
    # print(cell.value)                       # 打印单元格中的值value
    corrected_price = cell.value * 0.9
    corrected_price_cell = sheet.cell(row,4)    # 把修正的值，添加到新的一列，也可以覆盖原来那一列
    corrected_price_cell.value = corrected_price

# 实例化对象！
value = Reference(sheet,
                  min_row=2,
                  max_row=sheet.max_row,
                  min_col=4,
                  max_col=4)                             # 引用类，来选择范围
chart = BarChart()
chart.add_data(value)                   # 传递值到图表中
sheet.add_chart(chart, 'e2')            # 把获取到的表添加到指定位置

wb.save('dealedprice2.xlsx')         # 保存到新文件下，以防程序错误，导致原文件GG

编写完成代码后，记得检查你的代码，不断迭代，干净清晰！删除无用的代码！

四十二、机器学习

工作原理：训练模型或者引擎，给大量数据！输入数据越多准确率越高！

步骤：

1.导入我们准备的数据，通常是CSV文件格式

2.筛选数据，清理重复，无效数据，因为这回污染模型！产生错误结果！

3.分成两份，一份用于训练模型，一份用于测试模型，确保最终模型是能使用的！28定律！

4.创建一个模型，选择一种分析数据的算法。比如决策树、神经网络！库里都有！

5.训练模型，我们的模型会寻找数据中的模式

6.做出预测，测试模型！

7.对预测进行评估，衡量准确性

8.试着解决或者微调我们的模型参数

库与工具：
Numpy：提供一个多维数组的库
Pandas：数据分析库，提供数据帧，二维，类似表格！
MatPlotLib：数据科学，二维绘图库
Scikit-Learn：最流行的机器学习库之一！
Jupyter：木星的环境来编写代码，更易观察的编辑器！

准备工具：ANACONDA：https://www.anaconda.com/download#downloads

打开本地网页

四十三、案例：测试

1. 下载数据集

官网：https://www.kaggle.com/

用于数据科学项目，先登录，再搜索video game sales

2. 把csv文件移到当前目录下，用pandas库打开！如果喜欢的话，可以自己研究下这个库！

木星编辑器：

3. 可以非常直观的分行执行和显示代码！

import pandas as pd
df = pd.read_csv('vgsales.csv')
df.shape

df.describe()

df.values

4. 编辑模式和命令模式下的快捷键

   命令模式下，输入字母可以操作，dd去删除！点击Enter退出命令模式，进入编辑模式

木星编辑器可以只执行当前单元格内的代码，并且会保留执行的结果，如果不改变该代码，可以不重复执行，太酷了！

四十四、案例音乐推荐！

1、下载数据集：

http://bit.ly/music-csv，[随机生成的数据](https://www.dropbox.com/s/81s0t9ayh8m4sq8/music.csv?dl=0)，移动文件到编辑文件下！

2、清理数据

删除重复数据，或者零值或异常数据，这个文件不需要清理，但需要拆分！

一个数据集是输入，进行分析，称为输入集，一个数据集进行验证结果！称为输出集！

import pandas as pd
music_data = pd.read_csv('music.csv')
# 这里用清理数据，删除列，形成输入集，并不会修改原文件，而是生成新的文件
X = music_data.drop(columns=['genre'])
y = music_data['genre']

3、使用算法模型——决策树

引入算法模块from sklearn.tree import DecisionTreeClassifier，实例化，输入模型数据，输出预测

# 把引入的决策树操作符实例化
model = DecisionTreeClassifier()
model.fit(X_input, y_output)

# 预测,输入二维数组
predictions = model.predict([ [21, 1], [27, 1], [24, 0], [28, 0] ])
predictions

### 发生报错的主要原因
data是一个带有特征名称（feature names）的DataFrame，由于带有名称，模型在拟合和预测的时候只需要输入数值，因此才会报这个错误
### 解决办法
在出现predict的地方给数据加个values
y_0_predict = model.predict(standardization.values)  # 对测试集进行预测
**如果还是出现报错，那么在fit那里也给数据加一个values**

4、测量模型的精准性

刚才是把所有数据拿去做建立模型了，一般情况是拿70%-80%建立模型，20%-30%数据用来测试！然后把预测结果与原结果对比，得出准确度！如果不够精准，再微调！

引入训练测试分离模块from sklearn.model_selection import train_test_split

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 导入数据
music_data = pd.read_csv('music.csv')
# 这里用清理数据，删除列，形成输入集，并不会修改原文件，而是生成新的文件
X_input = music_data.drop(columns=['genre'])
y_output = music_data['genre']
# 使用测试训练分离函数，随机分离数据集，调整输入输出占总数据的比例，返回元组，一个西瓜切两刀
x_train, x_test, y_train, y_test = train_test_split(X_input, y_output, test_size=0.2)

# 建立模型
# 把引入的决策树操作符实例化
model = DecisionTreeClassifier()
model.fit(x_train, y_train)
# 预测,输入二维数组
predictions = model.predict(x_test)

# 分析结果
# 测试得分，把预测出来的结果与总的测试进行对比
score = accuracy_score(y_test, predictions)
score

测试结果不确定，偶尔是0.5，偶尔0.75，偶尔1，数据越多越准确，一个好模型甚至要上亿万数据！

5、持久化加载模型的方法

现实是，我们要不断的收集用户，需求的数据，然后不断更新模式，而不是一次性训练就结束，所以不断的训练模型是很重要的，然后我们把训练好的模型保存起来，下次就不需要训练了！

当模型训练到一定程度，导出模型成独立文件，运行模型，不依靠输入数据，并能保持预测精准性！

导入保存和加载模型的模块joblib，把训练好的模型保存起来！

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
import joblib

music_data = pd.read_csv('music.csv')
X_input = music_data.drop(columns=['genre'])
y_output = music_data['genre']

model = DecisionTreeClassifier()
model.fit(X_input.values, y_output.values)

joblib.dump(model, 'music-recommender.joblib')

测试这个保存的模型

import joblib

# 加载模型，并保存
model = joblib.load('music-recommender.joblib')

predictions = model.predict([ [21, 1] ])
predictions

成功完成！！

6、以可视的格式导出模型

以二叉树的形式，看懂生成的模型是如何决策的，传入预测值，整个分析过程！

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree

# 导入数据
music_data = pd.read_csv('music.csv')
X_input = music_data.drop(columns=['genre'])
y_output = music_data['genre']

# 生成模型
model = DecisionTreeClassifier()
model.fit(X_input.values, y_output.values)

# 导入模型，保存为dot文件，设置参数，决策的列，生成结果的列，用表格展示，圆角和颜色！
tree.export_graphviz(model, out_file='music-recommender.dot',
                    feature_names=['age', 'gender'],
                    class_names=sorted(y_output.unique()),
                    label='all',
                    rounded=True,
                    filled=True)

生成dot文件，用vscode打开，下载扩展Graphviz (dot) language support for Visual Studio

完成！生成5个结果，每次只判断是否满足条件！把一件复杂的判断，分解成有规律的简单决策！

四十五、搭建网页
使用django框架，可重用模块的库？
1、使用pip安装pip install django==3亲测，安装第3版本可以使用！
安装好django后，可以在使用命令，创建项目文件django-admin startproject pyshop .

2、启动web服务

在终端输入命令python manage.py runserver

3、新建应用项目

新建终端，输入命令python manage.py startapp products

4、创建products页面

1. 在products文件的views.py模块中编辑

from django.http import HttpResponse
from django.shortcuts import render


# 当客户端访问网络时，会清求这个文件函数，并把请求信息传给index
# 当客户访问/products 时，直接把URL转到index函数
def index(request):
    return HttpResponse('Hello world')

2. 在products文件中，添加是urls.py模块，用于传递链接！

from django.urls import path
from . import views

# 为了指明访问链接时，指向谁
urlpatterns = [
    path('', views.index),		# 注意index，没有()
]

3. 在pyshop初始文件下，urls.py模块中，添加关于products文件的信息，父子关系，这是主导航

from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('products/', include('products.urls'))
]

默认每新建页面都是这几个步骤，多走几遍就熟了！

注意：一旦建立新页面，主页将消失，因为主页是默认自动生成的，以后自己肯定会新建立主页！

5、给products建立子页面

原理和4一样，去views.py文件定义函数，在父代，也就是在products文件中urls.py模块，添加指向路径！

# 当客户端访问网络时，会清求这个文件函数，并把请求信息传给index
# 当客户访问/products 时，直接把URL转到index函数
def index(request):
    return HttpResponse('Hello world')


def new(request):
    return HttpResponse('New Products')

# 为了指明访问链接时，指向谁
urlpatterns = [
    path('', views.index),
    path('new', views.new),
]

6、创建产品页面

1. 创建产品信息

在models.py模块中添加属性

class Products(models.Model):
    name = models.CharField(max_length=255)
    price = models.FloatField()
    stock = models.IntegerField()
    image_url = models.CharField(max_length=2083)

2. 创建数据库

在venv文件db.aqlite3空的数据库文件，我们用这个来储存数据数据，小网站适用，大网站就要有专门的数据库管理软件！
本次下载服务器：http://www.sqlitebrowser.org/dl/

3. 用第1步骤中添加的属性，通过命令，生成数据库文件，拖拽到数据库打开

先到pyshop文件下settings.py模块中，设置一下，我们创建的数据才能被检测到！把products文件中apps.py模块中ProductsConfig路径添加到设置中！

'products.apps.ProductsConfig'

4. 运行命令，生成数据
   命令python manage.py makemigrations，进行数据生成

# Generated by Django 3.0 on 2023-05-14 12:46

from django.db import migrations, models


class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Products',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=255)),
                ('price', models.FloatField()),
                ('stock', models.IntegerField()),
                ('image_url', models.CharField(max_length=2083)),
            ],
        ),
    ]

5. 再运行这个文件，生成产品表

命令：python manage.py migrate，生成的是在venv目录下的db.sqlite3数据表！

7、创建折扣数据

与6同理，在在models.py模块中添加属性，运行命令行生成表

8、登录页面

1. 创建第一个用户，超级管理员！

在终端运行命令行：python manage.py createsuperuser

运行web服务，然后打开网页，登录后台http://127.0.0.1:8000/admin/

9、后台页面添加管理产品

products目录下，admin.py模块中设置！

from django.contrib import admin
from .models import Products

admin.site.register(Products)

10、添加产品的列

products目录下，admin.py模块中设置！

from django.contrib import admin
from .models import Products


class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price', 'stock')


admin.site.register(Products, ProductAdmin)

十一、展示产品

打开views.py文件定义函数

修改返回的信息，返回一个网页！

from django.http import HttpResponse
from django.shortcuts import render
from .models import Products


# 当客户端访问网络时，会清求这个文件函数，并把请求信息传给index
# 当客户访问/products 时，直接把URL转到index函数
def index(request):
    products = Products.objects.all()
    return render(request, 'index.html', {'products':products})

在products目录下，新建目录templates，再新建一个index.html的网页文件

<h1>这是老子的水果摊</h1>
<ul>
    {% for product in products %}
        <li>{{ product.name }} (￥{{ product.price }})</li>
    {% endfor %}
</ul>

十二、利用框架生成漂亮网页

选用https://getbootstrap.com/docs/5.3/getting-started/introduction/
在目录templates下，新建网页页面base.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>水果超市</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-KK94CHFLLe+nY2dmCWGMq91rCGa5gtU4mk92HdvYe+M/SXH301p5ILy+dN9+nJOZ" crossorigin="anonymous">
  </head>
  <body>
    {% block content %}
    {% endblock %}

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/js/bootstrap.bundle.min.js" integrity="sha384-ENjdO4Dr2bkBIFxQpeoTz1HIcje39Wm4jDKdf19U8gI4ddQ3GYNS7NTKfAdVQSZe" crossorigin="anonymous"></script>
  </body>
</html>

更改index内容，引入base.html为模板，替换其中内容

{% extends 'base.html' %}

{% block content %}
    <h1>这是老子的水果摊</h1>
    <ul>
        {% for product in products %}
            <li>{{ product.name }} (￥{{ product.price }})</li>
        {% endfor %}
    </ul>
{% endblock %}

十三、产品页展示图片
添加样式：https://getbootstrap.com/docs/5.3/components/card/

把模板的内容替换成自己表格的数据！

十四、最后修饰

添加样式：https://getbootstrap.com/docs/5.3/components/navbar/

base.html单独一个文件出来！

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>水果超市</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-KK94CHFLLe+nY2dmCWGMq91rCGa5gtU4mk92HdvYe+M/SXH301p5ILy+dN9+nJOZ" crossorigin="anonymous">
  </head>
  <body>
      <nav class="navbar navbar-expand-lg bg-body-tertiary">
      <div class="container-fluid">
        <a class="navbar-brand" href="#">PyShop</a>
        <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
          <span class="navbar-toggler-icon"></span>
        </button>
        <div class="collapse navbar-collapse" id="navbarSupportedContent">
          <ul class="navbar-nav me-auto mb-2 mb-lg-0">
            <li class="nav-item">
              <a class="nav-link active" aria-current="page" href="#">Home</a>
            </li>
            <li class="nav-item">
              <a class="nav-link" href="#">Link</a>
            </li>
            <li class="nav-item dropdown">
              <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">
                Dropdown
              </a>
              <ul class="dropdown-menu">
                <li><a class="dropdown-item" href="#">Action</a></li>
                <li><a class="dropdown-item" href="#">Another action</a></li>
                <li><hr class="dropdown-divider"></li>
                <li><a class="dropdown-item" href="#">Something else here</a></li>
              </ul>
            </li>
            <li class="nav-item">
              <a class="nav-link disabled">Disabled</a>
            </li>
          </ul>
          <form class="d-flex" role="search">
            <input class="form-control me-2" type="search" placeholder="Search" aria-label="Search">
            <button class="btn btn-outline-success" type="submit">Search</button>
          </form>
        </div>
      </div>
    </nav>
    <div class="container">
        {% block content %}
        {% endblock %}
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/js/bootstrap.bundle.min.js" integrity="sha384-ENjdO4Dr2bkBIFxQpeoTz1HIcje39Wm4jDKdf19U8gI4ddQ3GYNS7NTKfAdVQSZe" crossorigin="anonymous"></script>
  </body>
</html>

index.html

{% extends 'base.html' %}

{% block content %}

    <div class="row">
        {% for product in products %}
        <div class="col">
            <div class="card" style="width: 18rem;">
              <img src="{{ product.image_url }}" class="card-img-top" alt="...">
              <div class="card-body">
                <h5 class="card-title">{{ product.name }}</h5>
                <p class="card-text">￥{{ product.price }}</p>
                <a href="#" class="btn btn-primary">Add to Cart</a>
              </div>
            </div>
        </div>
        {% endfor %}
    </div>
{% endblock %}

完结撒花！！！