python黑马自学笔记第一阶段

已于 2024-08-19 23:06:22 修改
阅读量968 收藏 24
点赞数 26
文章标签： python 笔记
于 2024-08-19 22:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mkoss10086/article/details/140867929
版权

目录

数据类型

输入

输出

运算符和注释符

比较符号

字符串的定义

字符串的拼接

字符串的格式化

输出数据的类型

数据类型转换

判断语句

获得随机数

while循环

跳出某一次循环continue

终止循环break

for循环

range语法

函数1

None

数据容器

列表（list）

查询列表元素对应的索引值

修改列表对应元素的值

在列表中插入值

在列表中追加元素

删除列表中的元素

删除列表中相同元素的第一个

清空列表内容

统计某元素在列表中的数量

列表的sort方法(未出现在列表总结）

统计列表中的元素数量

列表总结

列表的循环遍历

元组（tuple）

查询元组元素对应的索引值

统计某元素在元组中的数量

统计元组中的元素数量

元组总结

元组的遍历

字符串（str）

查询字符串元素对应的索引值

字符串的替换

字符串的分割

字符串的规整操作

统计某字符在字符串中的数量

统计字符串中的长度

字符串总结

字符串的遍历

序列

序列切片

集合（set）

集合语法：添加新元素

移除元素

随机取出一个元素

清空集合

取两个集合的差集

消除两集合的差集

合并两个集合

统计集合的数量

集合的遍历

集合总结

字典（dict）

字典的增加与修改

删除字典中的元素

清空字典中的元素

获取全部的Key

统计字典内元素的个数

字典的遍历

字典总结

数据容器总结

数据容器转化

排序方法

函数2

函数的多返回值

函数的多种传参方式

位置参数

关键字参数

缺省参数

不定长参数

函数作为参数传递

lambda匿名函数

文件

文件的编码

文件的读取操作

文件的写入

文件的追加

异常，模块和包

异常

捕获异常

捕获指定异常

捕获多个异常

捕获所有异常

如果没有异常

异常的传递性

模块

模块的导入

模块的自定义

包

导入包

第三方包

如何安装第三方包

数据可视化

json数据格式

python数据和json数据的相互转换

pyecharts模块

pyecharts模块安装

pyecharts入门

基础折线图

全局配置选项

系列配置选项

地图可视化

动态柱状图

基础柱状图

基础时间线柱状图

数据类型

数字、字符串（String）、列表（List）、元组（Tuple）、集合（Set）、字典（Dictionary），数字又包含：整数（int）、浮点数（float）、复数（complex）

布尔类型

布尔类型分为真（true），假（false）

输入

input(内容数据)注意：输入的数据会被默认为字符串，要输入为数字要使用数据类型转化

#可以在括号内填入数据的前提
a=input("请输入数据")
print(a)

输出

print（内容数据）

print("你好")

运算符和注释符

注释符号：#，"""    """

除号：/（不取整数）

除号：//（取整）

取余数：% 

指数：**

#单行注释
"""
多行注释
"""
a1=14/4#除
a2=14//4#除（取整数）
a3=14%4#取余数
a4=2**3#取指数
a5=14+4#加
a6=14-4#减
a7=2*3#乘
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)
print(a7)

比较符号

a1=1>2
a2=1<2
#一个等号是赋值，两个等号是比较
a3=1==2
#1不等于2为真true
a4=1！=2
#输出为布尔类型
print(a1)
print(a2)
print(a3)
print(a4)

字符串的定义

字符串有三种定义方式分别是：

'    '

"    "

"'    '"

字符串的拼接

#字符串的三种定义方式
a1='你好'
a2="今天天气不错"
a3='''你吃了吗？'''
print(a1+a2+a3+"吃了")

字符串的格式化

（要输出带有”“的字符串在前面”“加一个转义字符\就可以了）

字符串格式化：(%：表示占位，s：表示将变量变成字符串放入站位的地方）

#字符串的三种定义方式
a1='你好'
a2="%s今天天气不错" % a1
a3='''%s%s你吃了吗？''' % (a1,a2)
print(a1)
print(a2)
print(a3)

不仅可以用于字符串还可以用于浮点数，整数

%s（字符串），%d（整数），%f（浮点数）

m.n：表示控制数字的宽度和精度（这里的m，n在实际）

m：控制宽度，要求是数字（当宽度小于自身时不生效）

例如%5d   11，输出---11（“-”是空格）

.n：控制精度，要求是数字

例如%5.2f    11，输出11.00（注意小数点也占一个空位）

字符串的格式化2:print(f"{变量}")

#字符串的三种定义方式
a1='你好'
a2="%s今天天气不错" % a1
a3='''%s%s你吃了吗？''' % (a1,a2)
print(f"{a1}{a2}{a3}谢谢我很好")

输出数据的类型

type(数据)

a1=11
a2=11.2
a3='你好'
a4=2>3
#整数类型
print(type(a1))
#浮点数类型
print(type(a2))
#字符串类型
print(type(a3))
#布尔类型
print(type(a4))

数据类型转换

#整数类型
a1=11
#浮点数类型
a2=12.1
#字符串类型
a3="19"
#转化为浮点数类型
a1=float(a1)
#转化为字符串类型
a2=str(a2)
#转化为整数类型
a3=int(a3)
print(a1)
print(a2)
print(a3)

判断语句

if(条件1):

    内容要缩进4格

elif(条件2):

elif(条件3):

......

else:

只能满足其中一个条件，或者都不满足，如果出现条件相同，当满数这个条件时，则会输入前面条件的内容

#将输入的数据转化为整数类型
a=int(input("请输入序号"))
if(a==1):
    print(1)
elif(a==3):
    print(2)
elif(a==3):
    print(3)
elif(a==4):
    print(4)
else:
    print("没有了")

获得随机数

import random
num = random.randint(num1,num2)

得到num是从num1到num2中随机一个数

import random
#得到num是从1到10中随机一个数
num = random.randint(1,10)
print(num)


while循环

while 表达式（判断是否为假，为真（true）继续执行内容，为假（false）则跳出循环）

   循环内容

a=0
b=0
#判断a是否小于100，当a==100时跳出循环
while a<100:
    a=a+1
    #累加，计算从0加到99
    b=b+a
#跳出循环后执行以下内容
print(b)

循环嵌套（制作九九乘法表）

a=1
while a<10:
   b=1
   while b<a+1:
       #在输出后面加上end=' '语句可以不换行
       print(f"{b}*{a}={a*b}",end=' ')
       b=b+1
  #保证99乘法表的换行
   print()
   a=a+1

跳出某一次循环continue

a=0
b=0
#while循环与判断语句嵌套使用
while a<100:
    a = a + 1
    #当a==50时跳出此次循环循环
    if(a==50):
        continue
    #当a!=50所执行的代码
    else:
#累加，计算从0加到99，中间除去了50
        b=b+a
print(b)

终止循环break

a=0
b=0
#while循环与判断语句嵌套使用
while a<100:
    a=a+1
    #当a==50时终止循环
    if(a==50):
        break
    #当a!=50所执行的代码
    else:
        # 得到从0累加到49的数
        b=b+a
print(b)

for循环

for 临时变量 in 待处理的数据集：

    循环条件满足执行的代码

待处理的数据集：（序列类型，及字符串（String）、列表（List）、元组（Tuple））详细请看数据容器

for循环也可以使用break语句和continue语句

a='Hello,World'
for x in a:
    print(x)

range语法

range只能配合for，单独使用会直接显出range语法，而不会显出数据

range（num)得到从0开始到num（不包含num）的数据序列

range（num1，num2）得到从num1开始到num2（不包含num2）的数据序列

range（num1，num2，step）得到从num1开始到num2（不包含num2）的数据序列，间隔为step（间隔默认为1）

for x in range(8):
    print(x,end=' ')
#换行
print()
for x in range(2,7):
    print(x, end=' ')
print()
for x in range(1,10,3):
    print(x,end=' ')

函数1

函数是组织好的，可重复使用的，用来实现特定功能的代码段

语句：def 自定义的函数名（传入参数（可以有，也可以没有））：

                函数体

                return 返回值（及调用函数后返回的数据）

函数调用

函数名（数据）数据的个数要和传入参数的个数相同

def num1(x,y):
    return x+y
def num2():
    #函数嵌套使用
    num=num1(9,9)
    print(num)
    print("你好")
def num3(x):
    print(x)
#有返回值需要变量接收
num=num1(1,2)
print(num)
num2()
num3(99)

None

无返回值的函数，还是会返回一种值就是None，None表示空的无意义的意思

数据容器

一种可以容纳多份数据的数据类型，容纳每一个数据称为一个元素（可以是任何数据类型的数据）

数据容器根据

1.是否支持重复元素

2.是否可以修改

3.是否有序，等

分为5类：列表（list），元组（tuple），字符串（str），集合（set），字典（dict）

列表（list）

列表可以一次性存储多个数据（可以容纳2**63-1个元素），且可以为不同数据类型，支持嵌套

而且列表有序的，可以有重复的元素，可以修改（增加或者删除元素等）

字面量

[元素1,元素2,元素3,元素4,......](元素即数据)

[11,"你好",11.2]

定义变量

变量名称=[元素1,元素2,元素3,元素4,......]（可以使用print(变量名称)直接输出列表）

add=[11,"你好",11.2]
print(add)

定义空列表

变量名称=[   ]

变量名称=list( )

add=[]
add=list()

可以使用索引提取出列表中对应的元素

add=[11,"你好",11.2]
print(add[0])
print(add[1])
print(add[2])

以此类推

也可以

add=[11,"你好",11.2]
print(add[-1])
print(add[-2])
print(add[-3])

以此类推

如果是嵌套的列表，例如：

add = [[1,2],[3,4]]
print(add[0][0])
print(add[0][1])
print(add[1][0])
print(add[1][1])

以此类推

列表的方法：

查询列表元素对应的索引值

列表.index(元素）= 索引值

例如：

add=[11,"你好",11.2]
num1=add.index(11)
num2=add.index(("你好"))
num3=add.index(11.2)
print(num1)
print(num2)
print(num3)

修改列表对应元素的值

列表[索引]=所要修改的值例如：

add=[11,"你好",11.2]
add[0]=12
print(add[0])
print(add[1])
print(add[2])

在列表中插入值

列表.insert(索引，元素)

例如：

add=[11,"你好",11.2]
add.insert(1,"我不好")
print(add[0])
print(add[1])
print(add[2])
print(add[3])
print(add)

在列表中追加元素

方式1：列表.append(元素）

例如：

add=[11,"你好",11.2]
add.append("我很好")
print(add[0])
print(add[1])
print(add[2])
print(add[3])
print(add)

                        

方式2：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表尾部

例如：

add=[11,"你好",11.2]
add.extend([1,2,3])
print(add[0])
print(add[1])
print(add[2])
print(add[3])
print(add)

删除列表中的元素

方法1：del 列表[索引]（注意空格）

例如：

add=[11,"你好",11.2]
del add[1]
print(add[0])
print(add[1])
print(add)

当将该位置的数据删除时，会有后面的数据填充进来

方法2：列表.pop(索引)

add=[11,"你好",11.2]
num=add.pop(1)
print(add[0])
print(add[1])
print(add)
print(num)

此方法还能将删除的数据输出出来，但是此方法最好不要用两次

删除列表中相同元素的第一个

列表.remove(元素)

例如：

add=[11,"你好",11.2,"你好"]
add.remove("你好")
print(add)

如果需要remove和pop同时出现最好是pop在remove前面

清空列表内容

列表.clear()

add=[11,"你好",11.2,"你好"]
add.clear()
print(add)

统计某元素在列表中的数量

列表.count(元素)

add=[11,"你好",11.2,"你好"]
num1 = add.count("你好")
num2 = add.count(3)
num3 = add.count(11)
print(num1)
print(num2)
print(num3)
print(add)

列表的sort方法(未出现在列表总结）

用于数据可视化，建议学习柱状图时学习此方法

列表.sort(key=选择排序依据的函数(reverse=True|False)
参数key，是要求传入一个函数（把函数当作参数传入）

表示将列表的每一个元素都传入函数中，返回排序的依据（及把列表中的元素传入函数，由函数决定拿到的哪一部分，作为排序的依据，返回出结果）
参数reverse，是否反转排序结果，True表示降序，False表示升序

#列表中内嵌列表不适用sorted方法要用sort方法
num=[["a1",35],["b2",67],["c3",23]]
#列表中每一个列表元素放入函数，返回列表元素的中的第二个元素
def mimi(mo):
    return mo[1]
#reverse=True表示降序
num.sort(key=mimi,reverse=True)
#也可以lambda匿名形式，结果一样
#num.sort(key=lambda mo: mo[1],reverse=True)
#排序完成
print(num)

统计列表中的元素数量

len(列表)

add=[11,"你好",11.2,"你好"]
num = len(add)
print(num)
print(add)

列表总结
1列表.append(元素)向列表中追加一个元素
2列表.extend(容器)将数据容器的内容依次取出，追加到列表尾部
3列表.insert(下标，元素)在指定下标处，插入指定的元素
4del 列表[下标]删除列表指定元素下标
5列表.pop(下标)删除列表指定元素下标
6列表.remove(元素)从前向后，删除此元素第一个匹配项
7列表.clear()清空列表
8列表.count(元素)统计此元素在列表中出现的次数
9列表.index(元素)查找指定元素在列表的下标（找不到报错ValueError）
10len(列表)统计容器内有多少元素
列表的循环遍历

while

i=0
add=[1,2,"你好",1.1,2.2,"我很好"]
while i<len(add):
    num=add[i]
    i+=1
    print(num)

for

add=[1,2,"你好",1.1,2.2,"我很好"]
for x in add:
    print(x)

上下两种方法都是可以的，都会得出同样的结果

add=[1,2,"你好",1.1,2.2,"我很好"]
for x in range(0,len(add)):
   # range(0,5)=[0,1,2,3,4](在for循环中使用)
    num = add[x]
    print(num)

元组（tuple）

元组可以一次性存储多个数据（），且可以为不同数据类型，也可以嵌套，

而且列表有序的，可以有重复的元素

但是元组一旦定义完成，就不可以修改

字面量

(11,"你好",11.2)

定义元组变量

add=(11,"你好",11.2)
print(add)

定义元组空变量

add=()
add=tuple()

如果你要定义一个元组，但是元组里面只有一个元素那就要在这一个元素后面添加一个逗号,如果不添加的话，就不是元组类型

add=("Hello",)

利用索引取出对应元素与列表（list）相同

add=(11,"你好",11.2)
num1 = add[1]
bdd=((1,2,3),(11,"你好",11.2))
num2 = bdd[1][2]
print(num1)
print(num2)

元组的方法：

查询元组元素对应的索引值

元组.index(元素)=索引值

add=(11,"你好",11.2)
num = add.index("你好")
print(num)

统计某元素在元组中的数量

元组.count(元素)

add=(11,"你好",11.2,11,11.2,"我很好")
num1 = add.count("你好")
num2 = add.count(11)
print(num1)
print(num2)

统计元组中的元素数量

len(元组)

add=(11,"你好",11.2,11,11.2,"我很好")
num = len(add)
print(num)

元组的定义完的内容不可以修改，但是元组内嵌套一个列表（list），列表里的内容可以修改

add=(11,"你好",11.2,[11,"你好",11.2])
print(add)
add[3][0]=12
add[3][1]="我很好"
add[3].append(19)
print(add)

元组总结
1index()查找某个数据，如果数据存在返回对应的下标，否则报错
2count()统计某个数据在当前元组出现的个数
3len(元组)统计元组内的元素个数
元组的遍历

while

add=(11,"你好",11.2,11,11.2,"我很好")
num=0
while num<len(add):
    print(add[num])
    num=num+1

for

add=(11,"你好",11.2,11,11.2,"我很好")
for x in add:
    print(x)

字符串（str）

一个字符串可以存放任意数量的字符，字符串也是一个不可修改的数据容器，可以有重复字符

如果硬要修改那只能得到一个新字符串

利用索引取出对应元素

num="Today is really nice"
print(num[0])
print(num[-4])
print(num[-5])#第-5个字符是个空格

字符串方法：

查询字符串元素对应的索引值

字符串.index(元素)=索引值

num="Today is really nice"
max=num.index(" ")
min=num.index(" r")
#这里我把空格加一个r设为一个字符串
print(max)
print(min)

字符串的替换

字符串.replace(字符串1，字符串2）（将字符串1全部转换为字符串2，不是修改字符串本身，而是得到一个新的字符串）

num="Today is really nice"
max=num.replace("really nice","not good")
print(max)
print(num)

字符串的分割

字符串.split(分割符字符串)（按照指定的分割符字符串，将字符串分为多个字符串，并存入列表对象中，字符串本身不变，而是得到一个列表对象）

num="Today is really nice"
max=num.split(" ")#分割字符是一个空格
min=num.split("a")#分割字符是a
print(num)
print(max)
print(min)

字符串的规整操作

字符串.strip() （去除字符串最首尾空格，跟空格的多少没关系）

字符串.strip(字符串1) （去除字符串前后指定的字符串1，如果没有则无效）

num="  Today is really nice "
max1=num.strip()
max2=max1.strip("a")
max3 =max1.strip("T")#去除首尾字符串中的"T"
max4=max1.strip("Te")#去除首尾字符串中的"T"和"e"，只有去除其中一个才能有机会去除另外一个
max5=max1.strip("Teo")#去除首尾字符串中的"T"，"e"，"o"
print(max1)
print(max2)
print(max3)
print(max4)
print(max5)

（理解能力有限）

统计某字符在字符串中的数量

字符串.count(某字符)

num="  Today is really nice "
max=num.count("a")
print(max)

统计字符串中的长度

len(字符串)

num="Today is really nice"
max=len(num)
print(max)

字符串总结
1字符串[下标]根据下标索引取出特定位置字符
2字符串.index(字符串)查找给定字符的第一个匹配项的下标
3字符串.replace(字符串1,字符串2)

将字符串内的全部字符串1，替换为字符串2（不会修改原字符串，而是得到一个新的）

4字符串.split(字符串)按照给定的字符串，对字符串进行分隔（不会修改原字符串，而是得到一个新的列表）
5

字符串.strip()

字符串.strip(字符串)

移除首尾的空格和换行符或指定字符串
6字符串.count(字符串)统计字符串内某字符串出现的次数
7len(字符串)统计字符串的字符个数
字符串的遍历

（字符串的遍历和元组，列表差不多就不写了）

序列

内容连续，有序，可以使用下标索引的数据容器（列表，元组，字符串均可视为序列）

序列切片

从一个序列中，取出一个子序列，但不会影响母序列

序列[起始索引:结束索引:步长]

起始索引：表示从哪里开始，可以留空，留空视作从头开始

结束索引（不含其本身）：表示从哪里结束，可以留空，留空视作截取到结尾

步长：步长为1表示一个个取

          步长为2表示跳过一个元素取

          步长为m表示跳过m-1个元素取

          步长为负数表示反向取（注意起始索引和结束索引也要反向）

num1=[0,1,2,3,4,5,6,7,8,9]
num2=num1[2:7]#步长为1省略不写
num3=num1[1:7:2]
num4=num1[:]#从头到尾，步长为1
num5=num1[::2]#从头到尾，步长为2
num6=num1[::-1]#从头到尾步长为-1
num7=num1[7:1:-2]#从7到1，步长为-2
print(num1)
print(num2)
print(num3)
print(num4)
print(num5)
print(num6)
print(num7)

集合（set）

集合可以一次性存储多个数据，且可以为不同数据类型，支持嵌套

集合是无序的（不支持下标索引），不支持重复的元素（有重复元素会在输出是去掉），可以修改（增加或者删除元素等）

字面量

{11,"你好",11.2}

定义集合变量

num={11,"你好",11.2}
print(num)

定义集合空变量

num=set()
集合语法：
添加新元素

集合.add(元素)

num={11,"你好",11.2}
print(num)
num.add("我很好")
print(num)

移除元素

集合.remove(元素)

num={11,"你好",11.2}
print(num)
num.remove("你好")
print(num)

随机取出一个元素

集合.pop()

num={11,"你好",11.2}
print(num)
max=num.pop()
print(num)
print(max)

清空集合

集合.clear

num={11,"你好",11.2}
print(num)
num.clear()
print(num)

取两个集合的差集

集合1.difference(集合2)（集合1有集合2没有的，集合1和集合2本身没有改变）

num1={11,"你好",11.2}
num2={11.3,"我很好",11.2}
max=num1.difference(num2)
min=num2.difference(num1)
print(max)
print(min)

消除两集合的差集

集合1.difference_update(集合2)（集合1改变了，集合2没有改变）

num1={11,"你好",11.2}
num2={11.3,"我很好",11.2}
num1.difference_update(num2)#集合1改变了，集合2没有改变
print(num1)
num2.difference_update(num1)#因为集合2中没有和集合1相同的元素了，所以集合2不变
print(num2)

合并两个集合

集合1.unior(集合2)（原两个集合不变）

num1={11,"你好",11.2}
num2={11.3,"我很好",11.2}
num3=num1.union(num2)
print(num1)
print(num2)
print(num3)#重复的去掉

统计集合的数量

len(集合)

num1={11,"你好",11.2,11.2}
num2=len(num1)
print(num1)#集合去重
print(num2)

集合的遍历

集合的遍历因为不能使用索引所以不能使用while，但关于for的可以使用且和列表元组差不多

集合总结
1集合.add(元素)集合内添加一个元素
2集合.remove(元素)移除集合内指定元素
3集合.pop()从集合中随机取出一个元素
4集合.clear()将集合清空
5集合1.difference(集合2)得到一个新集合，内含两个集合的差集，原有的两个集合内容不变
6集合1.difference_update（集合2）在集合1中，删除和集合2中相同的元素，集合1修改，集合2不变
7集合1.union(集合2)得到一个新集合，内含两个集合的全部元素，原有的两个集合不变
8len(集合)得到一个整数，记录了集合总元素个数（重复的不记录）

字典（dict）

字典可以一次性存储多个数据，且可以为不同数据类型，支持嵌套，可以修改（增加或者删除元素等），不支持下标索引，支持for循环，不支持while循环，每一份数据都是Key value值对，用于基于Key检索value的场景（Key不予许重复，重复添加则代表覆盖了原有的数据）

字面量（类比于现实中的字典，key相当于你查的汉字，value相当于你要查的那个字的含义）

{key:value,key:value,key:value}

定义字典的变量

num={key:value,key:value,key:value}

定义空字典

mun={}
num=dict()

可嵌套使用

num={"小王":{"语文":60,"英语":59,"数学":70},"小李":{"语文":70,"英语":55,"数学":60}}
print(num)
print(num["小李"])
print(num["小王"]["英语"])

字典的方法：

字典的增加与修改
num={"小王":80,"小李":88}
print(num)
num["小美"]=86#如果不存在就是新增
print(num)
num["小李"]=78#如果存在就是覆盖
print(num)

删除字典中的元素

字典.pop(Key)

num={"小王":80,"小李":88,"小美":90}
max=num.pop("小王")
print(max)
print(num)

清空字典中的元素

字典.clear()

num={"小王":80,"小李":88,"小美":90}
num.clear()
print(num)

获取全部的Key

字典.keys()

num={"小王":80,"小李":88,"小美":90}
max=num.keys()
print(max)
print(num)

统计字典内元素的个数

len(字典)

num={"小王":80,"小李":88,"小美":90}
max=len(num)
print(num)
print(max)

字典的遍历

for

num={"小王":80,"小李":88,"小美":90}
for x in num:
    print(x)
    print(num[x])

字典总结
1字典[Key]获取指定Key对应的Value值
2字典[Key]=Value添加或更新键值对
3字典.pop(Key)取出Key对应的Value并在字典内删除此Key的键值对
4字典.clear()清空字典
5字典.keys()获取字典的全部Key，可用于for循环的遍历字典
6len(字典)计算字典内的元素数量

数据容器总结

列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意

Key：Value

Key：除字典外的任意类型

Value：任意类型

下标索引支持支持支持不支持不支持
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改，可重复的一批数据记录场景不可修改，可重复的一批数据记录场景一串字符串的记录场景不可重复的数据记录场景Key检索value的数据记录场景
数据容器转化

max()

min()（最大最小元素）

list（容器）（转化为列表）

num1=[1,2,3,4,5]
num2=(1,2,3,4,5,)
num3="abcdefg"
num4={1,2,3,4,5}
num5={"Key1":1,"Key2":2,"Key3":3,"Key4":4,"Key5":5}
print(list(num1))
print(list(num2))
print(list(num3))
print(list(num4))
print(list(num5))

str（容器）（转化为字符串）

num1=[1,2,3,4,5]
num2=(1,2,3,4,5,)
num3="abcdefg"
num4={1,2,3,4,5}
num5={"Key1":1,"Key2":2,"Key3":3,"Key4":4,"Key5":5}
print(str(num1))
print(str(num2))
print(str(num3))
print(str(num4))
print(str(num5))

tuple（容器）（转化为元组）

num1=[1,2,3,4,5]
num2=(1,2,3,4,5,)
num3="abcdefg"
num4={1,2,3,4,5}
num5={"Key1":1,"Key2":2,"Key3":3,"Key4":4,"Key5":5}
print(tuple(num1))
print(tuple(num2))
print(tuple(num3))
print(tuple(num4))
print(tuple(num5))

set（容器）（转化为集合）

num1=[1,2,3,4,5]
num2=(1,2,3,4,5,)
num3="abcdefg"
num4={1,2,3,4,5}
num5={"Key1":1,"Key2":2,"Key3":3,"Key4":4,"Key5":5}
print(set(num1))
print(set(num2))
print(set(num3))
print(set(num4))
print(set(num5))

排序方法

sorted(容器,[reverse=True])

num1=[6,7,3,9,3,1]
num2=(6,7,3,9,3,1)
num3="vvavtebedf"
num4={6,7,3,9,3,1}
num5={"Key3":3,"Key5":5,"Key1":1,"Key4":4,"Key2":2}
#结果对象都变成列表了
print(sorted(num1))
print(sorted(num2))
print(sorted(num3))
print(sorted(num4))
print(sorted(num5))
print(sorted(num1,reverse=True))#反过来了

函数2

函数的多返回值

def num():
    return 1,2.2,"你好"
x,y,z=num()
print(x)
print(y)
print(z)

函数的多种传参方式

位置参数

调用函数时，根据函数定义的参数位置来传递参数（传递的参数和函数定义的参数的顺序及个数必须一致）

def num(x,y,z):
    print(f"我叫{x}，我今年{y}岁，我喜欢{z}")
num("小明",20,"打篮球")

关键字参数

函数调用时，通过“键=值”的形式传递参数（函数调用时，如果有位置参数，位置参数必须在关键字参数前面，但关键字函数不存在位置关系）

def num(x,y,z):
    print(f"我叫{x}，我今年{y}岁，我喜欢{z}")
num(x="小明",y=20,z="打篮球")
num(z="画画",x="小红",y=21)
num("小兰",z="游泳",y=24)

缺省参数

也叫默认参数，用于定义函数，为参数提供默认值，调用函数时不可传该默认参数的值（所有位置参数，必须在默认参数之前）函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认参数值

def num(x,y,z="男"):#在缺省参数中默认参数必须设在最后面
    print(f"我叫{x}，我今年{y}岁，性别{z}")
num(x="小明",y=20)
num(z="女",x="小红",y=21)
num("小兰",z="女",y=24)

不定长参数

也叫可变参数，用于不确定调用的时候会传多少个参数（不传也可以）的场景

不定长参数也可以再分为两个：位置参数和关键字参数

位置参数

def 函数（*参数）

def num(*max):
    print(max)
num("你好",11)
num(11.2)
#传进去的所有参数会被max变量收集，他会根据传进参数的位置合并为一个元组（tuple），max是元组类型

关键字参数

def 函数（**参数）

def num(**max):
    print(max)
num(name="你好",age=11)
num(age=11.2)
#参数是“键=值”形式的形式的情况下，所有的“键=值”都会被max接受，同时会根据“键=值”形成字典

函数作为参数传递
def num(max):
    auo=max(3,4)
    print(type(max))
    print(auo)
def max(x,y):
    return x+y
num(max)

lambda匿名函数

def有名称函数

lambda定义匿名函数适用于只能使用一次的场景

lambda 传入参数：函数体（一行代码）

lambda表示匿名函数，传入参数表示匿名函数的形式参数，函数体只能写一行代码

def num(max):
    auo=max(3,4)
    print(type(max))
    print(auo)
num(lambda x,y:x+y)

文件

文件的编码

编码技术：及翻译规则，记录了如何将内容翻译成二进制（编码有许多，要使用正确的编码，才能对文件进行正确的读写操作）

可以通过Windows系统自带的记事本看到（例如：UTF-8（通用），GBK，Big5等）

文件的读取操作

利用open()函数打开存在，或直接创建一个文件

open(name,mode,encoding)

name:是要打开目标文件名的字符串（可以包含目标文件所在的具体路径）

mode:设置打开文件的模式（访问模式），只读，写入，追加等

  有三种模式

   r：只读

   w：写入，从头开始（原文会被删除，如果没有则创建文件）

   a：追加（在原文最后追加，如果没有则创建）

encoding:编码格式（推荐UTF-8）

f=open("D:/测试.txt","r",encoding="UTF-8")#"D:/测试.txt"是在我的D盘有一个测试txt文件
"r"是只读 "UTF-8"是编码
print(type(f))
print(f)

read（）方法

文件对象.read(num)

num表示从文件中读取数据的长度（单位：字节）（字符串形式），如果没有传入则，表示读取全部

f=open("D:/测试.txt","r",encoding="UTF-8")
mimi=f.read(10)
#"Hello,Wor
nasi=f.read()
#ld"
# "你好"
# 11
# 11.2
#在读取文件过程中，每一次读取开始是从前一次的末尾开始（第一次是从头开始）
print(nasi)
print(mimi)
f.close()#关闭文件

readlines（）方法

按照行的方式把整个文件的内容进行一次性读取，并且返回的是一个列表，其中每一行数据是一个元素

f=open("D:/测试.txt","r",encoding="UTF-8")
nasi=f.readlines()
print(nasi)#文件内容
f.close()#关闭文件

readline（)方法

一次读取一行内容（字符串形式）

f=open("D:/测试.txt","r",encoding="UTF-8")
nasi=f.readline()#读取第一行内容
mimi=f.readline()#读取第二行内容
san=f.readline()#读取第三行内容
print(nasi)
print(mimi)
print(san)
f.close()#关闭文件

用for循环读取文件

f=open("D:/测试.txt","r",encoding="UTF-8")
for lian in f:
    print(lian)
f.close()#关闭文件

文件关闭

文件如果打开后不关闭则会一直被python占用，会导致文件无法删除改名等等

文件.close()（打开文件后关闭）前面例子有出现

with open 语法

可以通过with open的语句对文件进行操作。可以在操作完成后自动关闭close文件，避免忘记close方法

with open("D:/测试.txt","r",encoding="UTF-8") as f:
    for lian in f:
        print(lian)

汇总：

操作功能
文件对象=open(file,mode,encoding)打开文件获得文件对象
文件对象.read(num)读取指定长度字节，不指定num读取文件全部
文件对象.readline()读取一行
文件对象.readlines()读取全部行，得到列表
for line in 文件对象for循环文件行，一次循环得到一行数据
文件对象.close()关闭文件对象
with open() as f通过with open语法打开文件，可以自动关闭

文件的写入

文件对象.write(要写入的内容)

直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区

当调用flush时内容才会真正写入文件（如果你不调用flush，调用close文件关闭也是可以的）

这是为了避免频繁操作硬盘，导致效率下降（及攒一堆，一次性写出去）

f=open("D:/测试.txt","r",encoding="UTF-8")
mimi1=f.read()
# HelloWorld
# 你好
# 11
# 11.2
#原有的文件内容读取
#---------------------
d=open("D:/测试.txt","w",encoding="UTF-8")#如果文件不存在“w“模式会帮我们创建一个
d.write("今天真好")#写出内容
d.flush()#将写出的内容刷新到硬盘中取，但原有的内容被删除
d.flush()
#----------------------
s=open("D:/测试.txt","r",encoding="UTF-8")
mimi2=s.read()
#今天真好
#改完后的内容再次读取
print(mimi1)
print(mimi2)
s.close()#关闭文件

额外增加一小点：

time.sleep(10000)将程序睡眠10000秒

文件的追加

和文件的写入几乎一模一样就是”w“模式变成”a“模式

f=open("D:/测试.txt","r",encoding="UTF-8")
mimi1=f.read()
# HelloWorld
# 你好
# 11
# 11.2
#原有的文件内容读取
#---------------------
d=open("D:/测试.txt","a",encoding="UTF-8")
d.write("今天真好")#追加内容
d.write("\n每天都好")#追加内容
d.flush()#将追加的内容刷新到硬盘中取，在原有的内容后面添加
d.flush()
#----------------------
s=open("D:/测试.txt","r",encoding="UTF-8")
mimi2=s.read()
#改完后的内容读取
print(mimi1)
print(mimi2)
s.close()#关闭文件

异常，模块和包

异常

了解异常

当检测到一个错误时，Python解释器就无法继续执行，反而出现一些错误的提示，这就是所谓的“异常”，也就是常说的“BUG”

捕获异常

当我们的程序遇到了BUG一般会有两种情况：

1.整个程序因为一个BUG停止运行

2.对BUG进行提醒，整个程序继续进行

当我们遇到情况2的时候就要使用捕获异常（捕获异常的作用在于，提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段）

try：

可能发生错误的代码

except：

如果出现异常，所执行的代码

整个代码就是如果try中的代码报错，就会执行except中的代码

try:
    f=open("D:/mimi.txt","r",encoding="UTF-8")
#在D盘中我没有创建mimi.txt文件
except:
    print("出现异常，文件不存在，将r模式换成w模式打开")
    f=open("D:/mimi.txt","w",encoding="UTF-8")

捕获指定异常

try：

发生错误的代码

except 异常类型 as 变量(及异常对象):

发生错误后执行代码

若发生的异常和定义的异常类型不一致则无法被捕获，一般try下面只放一行尝试执行的代码

try:
    print(num)
except NameError as a:
    print("出现变量未定义的异常")
    print(a)#异常信息

try:
    1/0
except NameError as a:#异常与所给的异常类型不相同，无法捕获
    print("出现变量未定义的异常")
    print(a)

由上面图片可以看出“1/0”的异常类型（ZeroDivisionError）

捕获多个异常

try：

发生错误的代码

except （异常类型1，异常类型2........）as 变量(及异常对象) :

发生错误后执行代码

try:
    #1/0
    print(num)
except (NameError,ZeroDivisionError) as a:#多个异常类型
    print("出现变量未定义的异常或者出现除以0的异常")

捕获所有异常

try：

可能发生错误的代码

except Exception as a：#捕获所用异常和except差不多（except也是捕获所有异常）

如果出现异常，所执行的代码

如果没有异常

try：（必要）

可能发生错误的代码

except：（必要）

如果出现异常，所执行的代码

else：#当然可写可不写（可选）

如果没有异常所执行的代码

finally：#当然可写可不写（可选）

表示无论出不出现异常也要运行的代码，例如文件的关闭操作close（）语法

try:
    print(1)
except Exception as a:
    print("出现异常")
else:
    print("没有异常")
finally:
    print("无论有没有异常，我都要运行")

try:
    print(1/0)
except Exception as a:
    print("出现异常")
else:
    print("没有异常")
finally:
    print("无论有没有异常，我都要运行")

异常的传递性
def a1():
    print("a1开始")
    print(1/0)#异常开始
    print("a1结束")
def a2():
    print("a2开始")
    a1()#传递到函数a2
    print("a2结束")
def a3():
    a2()#传递到a3
a3()#异常出现

def a1():
    print("a1开始")
    print(1/0)#异常开始
    print("a1结束")
def a2():
    print("a2开始")
    a1()#传递到函数a2
    print("a2结束")
def a3():
    try:#在a3中捕获异常
        a2()#传递到a3
    except Exception as a:
        print(a)
a3()

模块
模块的导入

模块导入一般写在开头

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

模块就是类比于工具包，我们平常在一个python文件里写代码就是制作工具，当我们需要用到这个工具时，可以不用重新做而是直接拿（及导入模块)

导入模块方式：

[from 模块名] import[模块|类|变量|函数|   *   (代表模块内的全部内容)][as 别名]（[]中是可选的意思）

常用组合形式：

import 模块名

from 模块名 import 类、变量、方法等

from 模块名 import *

import 模块名 as 别名（别名就是自己给具体的模块或者功能改的名）

from 模块名 import 功能名 as 别名

基本语法：

import 模块名

import 模块名1,模块名2

模块名.功能()  功能就是模块内的功能，通过“  .  ”来确定层级关系，并使用其中的功能

import time#导入python中的内置模块time
#import time as t#将模块time改成t（别名效果）
print("你好")
time.sleep(5)#使用time模块中的程序睡眠功能sleep(单位：秒)睡眠5秒
#t.sleep(5)（别名效果）
print("我很好")
#可以自己尝试一下

from 模块名 import 功能名

功能名()

from time import sleep#导入python中的内置模块time并使块中用time模的程序睡眠功能sleep
#或者from time import * 这里的*表示全部及模块time中的所有功能
print("你好")
sleep(5)#睡眠5秒
#sleep(5) 在众多功能中拿出一个sleep功能使用
print("我很好")

模块的自定义

就是自己创建一个python文件（设文件名为num），然后在里面写变量函数，这就是模块自定义

当你创建了两个模块，两个模块中的一个方法命名相同，当你调用这两个模块中的相同方法时，后面一个方法会将前面的方法覆盖

from num1 import a#x+y方法
from num2 import a#x-y方法（将上一个覆盖了）
mi=a(1,1)
#但若是mi=num1.a(1,1)则输出2
print(mi)

在自定义模块中，我们需要测试自己的方法是否创建成功，则会使用测试代码，但调用时，需要删除测试代码，如果不删，则可能对结果产生影响，有时候我们不想删测试代码，又想保证调用正确则要通过“__main__"变量执行

def a(x,y):
    return x+y
if __name__ == '__main__':#"__name__"是一个内置变量，如果在本文件中运行则会被标记成“__main__”
   i= a(2,3)#这样就不会防止测试代码调用到别的文件当中去
   print(i)#4,5行为测试代码
#既方便了测试又方便了调用

本文件输出结果

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素

__all__=["方法1"，"方法2"]

方法1，方法2，方法3（方法3不会被导入）

除非from xxx import 方法3

补充模块

补充python中的模块winsound，可以控制电脑发出声音

class Mou：
    def num(self):
#导入模块
        import winsound
使用功能2000频率，3000时常
        winsound.Beep(2000,3000)
mou=Mou()
mou.num()
包

包就是一个文件夹，里面包含python模块，通过包在逻辑上将这一批包归为一类，方便使用

python包里面有__init__.py文件如果没有就不是python包

导入包

导入包里面的模块和导入模块差不多，就多了一个包名

from mi1.no1 import a1#mi1是包名no1是模块名
from mi1.no2 import a2
m=a1(1,2)#x+y方法
n=a2(4,3)#x-y方法
print(m)
print(n)

包也有__all__变量

from mi1 import *

表示mi1里所有的模块

当有__all__变量时只能用__all__变量里的模块，但使用__all__变量只能在__init__.py文件里

第三方包

及非python官方的包，这些包虽然不是python官方的但很实用，极大了丰富了python编程生态提高了开发效率，由于不是python官方开发的，所以没有内置他们

科学计算中常用的         numpy包
数据分析中常用的         pandas包
大数据计算中常用的     pyspark、apache-flink包
图形可视化常用的         matplotlib、pyecharts
人工智能常用的             tensorflow

如何安装第三方包

在命令提示符里：

输入：pip install 包名称（慢）

或者：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称（快）

数据可视化

json数据格式

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

在线JSON压缩转义工具-json转义压缩-json数据转义-懒人工具|www.ab173.com

在线JSON压缩转义工具-json转义压缩-json数据转义-懒人工具|www.ab173.com这个懒人网站可以直接转化json数据，及将json数据变成我们可以看得懂得数据

python数据和json数据的相互转换

python将字典，列表（列表内嵌字典）通过json转化为字符串

语法：import json

num=json.dumps(num)

将python数据转化为json数据

import json
num1={"name":"小王","age":18}
num2=[{"name":"小红","age":20},{"name":"小蓝","age":30},{"name":"小明","age":28}]
num1=json.dumps(num1,ensure_ascii=False)#当传入参数有汉字时需要添加ensure_ascii=False
num2=json.dumps(num2)
print(type(num1))#被转化为字符串
print(type(num2))
print(num1)
print(num2)

num=json.loads(num)

将json数据转化为python数据

import json
num1={"name":"小王","age":18}
num2='[{"name":"小红","age":20},{"name":"小蓝","age":30},{"name":"小明","age":28}]'#字符串
num1=json.dumps(num1,ensure_ascii=False)
num2=json.loads(num2)#字符串转化为列表
print(type(num1))
print(type(num2))
print(num1)
print(num2)#转化为列表形式

pyecharts模块

Python培训_北京Python培训班_好口碑Python培训机构-黑马程序员 (itheima.com)(黑马python网站)

开发可视化图表使用的技术栈是：pyecharts包

pyecharts - A Python Echarts Plotting Library built with love.（pyecharts网站，右上角切换语言）

Document（pyecharts的画廊，右上角切换语言，参考用途）

pyecharts模块安装

命令提示符

pip install pyecharts（慢）

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyecharts（快）

pyecharts入门
基础折线图
#利用导包pyecharts的charts模块的Line功能
from pyecharts.charts import Line
#通过Line得到一个空的坐标系，及折线图对象lian
lian=Line()
#设置空坐标系的x轴上的数据，列表数据
lian.add_xaxis(["小王","小李","小肖"])
#设置空坐标系的x轴上的数据，y轴命名，列表数据
lian.add_yaxis("岁数",[18,19,17])
#通过render()方法将代码生成图表
lian.render()
#但运行后不会直接生成图标会出现一个文件
# 点击进入文件，可以看到一个网页代码，
# 右上角有可以选择浏览器进入即可看到图表

全局配置选项

主要针对这些图像通用设置项配置

在pyecharts - A Python Echarts Plotting Library built with love.可以找到具体的全局配置的选项

通过set_global_opts方法配置

语法：图像对象.set_global_opts(相关全局设置项)

from pyecharts.charts import Line
#所有项在模块options里,通过逗号导入多个功能
#TitleOpts标题控制选项
#LegendOpts图例控制选项
#ToolboxOpts工具箱控制选项
#VisualMapOpts视觉映射控制选项
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
lian=Line()
lian.add_xaxis(["小王","小李","小肖"])
lian.add_yaxis("岁数",[18,19,17])
#设置全局配置项，通过set_global_opts（）设置,项通过逗号隔开
#将鼠标放置在set_global_opts()上，可以看到
lian.set_global_opts(
    #标题title,
    #标题左右位置(left 左)center居中
    #标题上下位置(bottom 底部)距离底部1%的距离
    title_opts=TitleOpts(title="年龄展示",pos_left="center",pos_bottom="1%"),
    #图例(默认存在) is_show表示是否展示
    legend_opts=LegendOpts(is_show=True),
    #工具箱
    toolbox_opts=ToolboxOpts(is_show=True),
    #视觉映射
    visualmap_opts=VisualMapOpts(is_show=True)
)
#通过render()方法将代码生成图表
lian.render()
#如果不懂请联系基础折线图中的代码图解读

系列配置选项

主要针对具体的轴数据配置

详细系列配置到pyecharts - A Python Echarts Plotting Library built with love.查看

例如：

from pyecharts.options import LabelOpts
#设置空坐标系的x轴上的数据，x轴命名，列表数据
lian.add_xaxis(["小王","小李","小肖"])
#设置空坐标系的x轴上的数据，y轴命名，列表数据
#不显示折线上得数字了
lian.add_yaxis("岁数",[18,19,17],label_opts=LabelOpts(is_show=False))

承接全局配置选项里的代码，改动以上内容，得出结果如下：

地图可视化
#利用导包pyecharts的charts模块的Map功能
from pyecharts.charts import Map
#所有项在模块options里，VisualMapOpts视觉映射控制选项
from pyecharts.options import VisualMapOpts
#创建对象
map=Map()
#准备数据,列表内嵌套元组
#对应的省份和数据，注意省份名称要全称
dtat=[
    ("北京市",10),
    ("云南省",180),
    ("山东省",270),
    ("广东省",2999),
    ("湖南省",8888),
    ("湖北省",49999),
    ("台湾省",999666)
]
#地图名称，数据，地图类型
#（默认中国地图，但我们这里还是写了China），如果要使用省份地图，写对应的省份就行了
#例如："湖南"，"河南"
map.add("测试地图",dtat,"china")
#设置全局配置项
map.set_global_opts(
    #视觉映射
    visualmap_opts=VisualMapOpts(
        #显示
        is_show=True,
        #开启手动校准范围
        is_piecewise=True,
        #定义范围，列表里面嵌套元组，使用最小，最大值,label(标签),color(颜色)
        pieces=[
            {"min": 1, "max": 9, "label": "1-9人", "color":"#CCFFFF"},
            {"min": 10, "max": 99, "label": "10-99人", "color":"#FFFF99"},
            {"min": 100, "max": 999, "label": "100-999人", "color":"#FF9966"},
            {"min": 1000, "max": 9999, "label": "1000-9999人", "color":"#FF6666"},
            {"min": 10000,  "label": "10000人以上", "color":"#CC3333"}
                                 ]))
#通过render()方法将代码生成地图，在（）内为文件的命名，可写可不写
map.render()

如何写出颜色对应的值

通过在线JSON压缩转义工具-json转义压缩-json数据转义-懒人工具|www.ab173.com，前端，rgb颜色对照表，可以看到对应颜色的值

动态柱状图
基础柱状图

和基础折线图差不多，和折线图不同的是柱状图可以反转x轴和y轴

#利用导包pyecharts的charts模块的Bar功能
from pyecharts.charts import Bar

from pyecharts.options import LabelOpts
#创建对象
bar=Bar()
#系列配置项
#设置坐标系的x轴上的数据，列表数据
bar.add_xaxis(["小王","小李","小肖"])
#设置坐标系的x轴上的数据，y轴命名，列表数据
bar.add_yaxis("岁数",[18,19,17],
              #将柱状图的数据从柱子的上侧改成右侧
              label_opts=LabelOpts(
                  #position（位置）改成right（右侧）
                  position="right"
              ))
#反转x轴和y轴
bar.reversal_axis()
#通过render()方法将代码生成图表
bar.render()

基础时间线柱状图
#利用导包pyecharts的charts模块的Bar功能创建柱状图
#Timeline用来构建时间线对象
from pyecharts.charts import Bar,Timeline
from pyecharts.options import LabelOpts
#导入主题类型ThemeType
from  pyecharts.globals import ThemeType

#创建对象1
bar1=Bar()
bar1.add_xaxis(["湖南","江西","湖北"])
bar1.add_yaxis("人数",[78,89,56],
              label_opts=LabelOpts(position="right"))
#反转x轴和y轴
bar1.reversal_axis()
#创建对象2
bar2=Bar()
bar2.add_xaxis(["湖南","江西","湖北"])
bar2.add_yaxis("人数",[115,99,140],
              label_opts=LabelOpts(position="right"))
#反转x轴和y轴
bar2.reversal_axis()
#创建对象3
bar3=Bar()
bar3.add_xaxis(["湖南","江西","湖北"])
bar3.add_yaxis("人数",[160,170,130],
              label_opts=LabelOpts(position="right"))
#反转x轴和y轴
bar3.reversal_axis()

#创建时间线对象对象,并设置时间线主题，内嵌字典“theme”（主题）LIGHT为主题颜色
timeline=Timeline({"theme":ThemeType.LIGHT})
#在时间线内添加柱状图对象
timeline.add(bar1,"第一个")
timeline.add(bar2,"第二个")
timeline.add(bar3,"第三个")
#设置自动播放
timeline.add_schema(
#自动播放的时间间隔，单位毫秒
play_interval=1000,
#是否在自动播放的时候，显示时间线
is_timeline_show=True,
# 是否自动播放
is_auto_play=True,
#是否循环自动播放
is_loop_play=True
)
#有时间线对象用时间线对象绘图,用bar绘图的话只能出来一个
timeline.render()

主题颜色总结

编号颜色
ThemeType.WHITE红蓝默认颜色等bar=Bar()
ThemeType.LIGHT蓝黄粉高亮颜色
ThemeType.DARK红蓝黑色背景
ThemeType.CHALK红蓝 绿黑色背景
ThemeType.ESSOS红黄暖色系
ThemeType.INFOGRAPHIC红蓝黄偏亮
ThemeType.MACARONS紫绿
ThemeType.PURPLE_PASSION粉紫灰色背景
ThemeType.ROMA红黑灰偏暗
ThemeType.ROMANTIC红粉蓝淡黄色背景

远处山峰
关注
黑马程序员Python学习笔记，代码使用Pycharm编写。_黑马编程python笔记
2401_84141337的博客
05-02 957
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。元组不可修改内容（可以修改内部list的内部元素)元组的下标：从前向后，下标从0开始从后向前，下标从-1开始#方式一变量名称 = （）#方式二变量名称 = tuple（）# 定义单个元素的元组，后面必须加一个逗号，不然它的类型不是tuple而是其他# 元组的嵌套t1 = ((1,'多',True),(2,'la',False))print(t1)# 下表索引取出内容内容连续、有序，可使用下标索引的一类数据容器。
上海黑马python培训
weixin_63757190的博客
12-07 649
过去的2017年这一年，Python 开发者在全球快速增长，国内小伙伴学习 Python 的热情一路高涨。同时，Python 成为大量开发者推荐的入门编程语言和第二编程语言。2017年12月，Python 在 TIOBE 全球编程语言年度排行榜上升至第四，目前看来，第四的份额将轻松保持。此外，作为人工智能的主要编程语言，在人工智能风口可能到来的 2018 年以及未来的几年，Python势必继续高歌。 为助力小伙伴们学习 Python，今天小编要跟小伙伴们分享的是 2017 年度最受读者欢迎的 Python
【Python教程】第一部分 --黑马笔记
ksksr的博客
07-07 1212
第一部分python笔记
python视频教程黑马-python视频教程免费：求黑马程序员python教程？
weixin_37988176的博客
11-01 1568
python后端开发需要学什么?第一阶段：Python语言基础主习Python最基识，如Python3、数据类型、字符串、函数、类件操作等。阶段课程结束后，学员需要完成Pygame实战飞机大战、2048等项目。第二阶段：Python语言高级主要学习Python库、正则表达式、进程线程、爬虫、遍历以及MySQL数据库。第三阶段：Python　web开发主要学习HTML、CSS、JavaScript、...
python黑马
weixin_41130372的博客
12-04 451
注释 PEP （Python Enhancement Proposals）文档 第八篇 针对Python的代码格式 PyCharm的调试工具 F8 step over 可以单步执行代码，会把函数调用看作是一行代码直接执行 F7 step into 可以单步执行代码，如果是函数，会进入函数内部 在函数中给文档增加注释 """ 注释""" 光标移到函数 ctrl+Q快速查看 函数体相对比较独立...
【黑马-python】---学习笔记(2）---Python基础
plain_rookie的博客
04-19 1601
Python基础 1 Python简介 1.1 python起源 1991年第一个Python解释器诞生，用C语言实现，并能够调用C语言的库文件； 开源 1.1.1 解释器（科普） 计算机不能直接理解任何除机器语言以外的语言，所以必须要把程序员所写的程序语言翻译成机器语言，计算机才能执行程序，将其他语言翻译成其他机器语言的工具，被称为编译器； 编译器翻译的方式有两种，一个是编译，另一个是解释，两种方式之间的区别在于翻译时间点的不同，当编译器以解释方式运行的时候，也称之为解释器； 解
B站黑马程序员Python教程学习笔记.zip
02-21
Python是一种高级、通用的编程语言，以其简洁、易读的语法而闻名，被广泛应用于网络爬虫、数据分析、机器学习、人工智能等多个领域。在B站黑马程序员的Python教程中，你将深入理解Python的基础概念，包括： 1. **...
黑马python机器学习入门笔记
08-21
《黑马Python机器学习入门笔记》是一份针对初学者编写的指南，旨在帮助读者掌握Python语言在机器学习领域的基本应用。这份笔记将带你踏入这个充满无限可能的领域，通过Python这门易学且强大的编程语言，开启你的数据...
2022黑马Python学习笔记
热门推荐
xuansoyo的博客
10-08 1万+
学习B站2022黑马程序的Python课程的学习笔记，第一次创作，如有问题，请评论区或私信告知我，感谢大家的观看！
黑马程序员Python学习笔记，代码使用Pycharm编写。_黑马编程python笔记(1)
最新发布
2401_84141332的博客
05-02 760
单引号定义法：ｎａｍｅ＝＇ｈｅｌｌｏ！双引号定义法：ｎａｍｅ＝＂ｈｅｌｌｏ！三引号定义法：ｎａｍｅ＝＂＇ｈｅｌｌｏ！＇＂三引号定义法，和多行注释的写法一样，同样支持换行操作。使用变量接收它，它就是字符串不使用变量接收它，就可以作为多行注释使用。问题：如果想要定义的字符串本身　，是包含：单引号／双引号怎么写？单引号定义法，可以内含双引号双引号定义法，可以内含单引号可以使用转义字符（＼）来讲引号解除效用，变成普通字符串。
黑马最新python教学视频，包含课件，软件。
11-22
黑马最新python教学视频，包含课件，学习过程中的安装软件，资源大小为19G,带项目实战，百度王牌下载地址，亲测可用。
2017黑马python
09-12
2017黑马就业班视频,密码点击压缩包,右边有,...
如何自学Python？一文讲清楚
i54996的博客
10-09 212
今天就给大家分享一下，工作之余，应该如何学习Python？ 明确目标 对于零基础的学员而言，要明确你学习Python仅仅是为了满足好奇心？还是有工作需要，比如办公自动化的需要，转行的需要。不同的目标，所选用的学习内容和相应的学习方法也就会有所不同。 比如，仅仅是好奇，其实就不需要系统学习Python的知识了，简单做个了解，能够根据老师的操作，做出一些能满足好奇心的小案例即可。但如果是工作的需要，那就需要踏踏实实打牢基础了。最后，如果你的时间不是很紧张，并且又想快速的提高，最重要的是不怕吃苦，建议你可以价
Python 模块和包
lllong33的博客
12-03 282
01. 模块 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块 模块别名 应该符合 大驼峰命名法 不推荐import *，容易出现重名 Python 中每一个模块都有一个内置属性 __file__ 可以 查看模块 的 完整路径 在导入文件时，文件中 所有没有任何缩进的代码 都会被执行一遍！ __name__ 是 Python 的一个内置属性，记录着一个 字符串，如果是被其他文件...
黑马程序员Python从入门到精通代码汇总
Mickey的博客
04-23 3800
本帖子是本人于2023年暑假期间在B站观看《黑马程序员python教程，8天python从入门到精通》通过基于web的Jupyternotebook实时编译交互环境整理的Python学习笔记，大家可以根据黑马原视频对照学习。
黑马程序员python入门学习笔记（一）
weixin_47067992的博客
10-15 2776
python入门学习笔记
黑马程序员Python学习笔记，代码使用Pycharm编写。
qq_49288362的博客
09-14 3235
黑马程序员Python学习笔记，全阶段学习，新手、基础、进阶。代码使用pycharm编写。 很详细！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值