【最新！超详细Python从入门到精通】含PyeCharts数据可视化&绘图教程

Python入门

第一章-基础

1.1字面量

1.2注释

"""
我是多行注释
本代码XXXX
"""
print("niuma")
# 我是单行注释【#开头 建议空一个格 再写注释内容】
print(666)

1.3变量

# 格式：变量名=变量值
# 定义一个变量，用来记录钱包余额
money = 50
# 通过print语句，输出变量记录的内容
print("钱包还有：",money)
money=money-10
print("买了冰淇淋花费10元，还剩余：",money,"元")

# 假设，每间隔一小时，输出一下钱包的余额
print("现在是下午1点，钱包余额剩余：",money)
print("现在是下午2点，钱包余额剩余：",money)
print("现在是下午3点，钱包余额剩余：",money)
print("现在是下午4点，钱包余额剩余：",money)

debug工具的使用

1.对着某行代码 打断点

2.下方一步步 步进

1.4数据类型

# 方式1：使用print直接输出类型信息
print(type("niuma"))
print(type(666))
print(type(11.111))
# 方式2：使用变量存储type()语句的结果
string_type=type("黑马")
int_type=type(666)
float_type=type(11.1111)

print(string_type)
print(int_type)
print(float_type)

# 方式3: 使用type()语句，查看变量中存储的数据类型信息
name="heima niuma"
name_type=type(name)
print(name_type)

1.5数据类型转换

# 数字转字符串
num_str=str(11)
print(type(num_str),num_str)

float_str=str(11.345)
print(type(float_str),float_str)
# -------------------------------------
# 字符串转数字
num=int("2222")
print(type(num),num)

num2=float("11.345")
print(type(num2),num2)

# 错误示例，想要将字符串转换成数字，必须要求字符串内的内容都是数字
# num3 =int("niuma zhongjiurong")
# print(type(num3),num3)

# 整数转浮点数
float_num=float(11)
print(type(float_num),float_num)

# 浮点数转整数[丢失精度] 转换的结果只有整数部分：11
int_num=int(11.345)
print(type(int_num),int_num)

错误示例

# 错误示例，想要将字符串转换成数字，必须要求字符串内的内容都是数字
num3 =int("niuma zhongjiurong")
print(type(num3),num3)

1.6标识符

变量的命名规范：

1.见名知意，简洁；

2.（多个单词）用下划线命名法

3.英文字母全小写

# 规则1：内容限定，只能使用中文，英文，数字，下划线
# 注意：不能以数字开头
# 错误的代码示范：name_!="张三"

# 规则2：大小写敏感
A="zhangsan1"
a="zhangsan2"

# 规则3：不可使用关键字 False True None class 等
# 错误的代码示范：def=1
Class=1

1.7运算符

# 算术（数学）运算符
print("1+1=",1+1)# 加
print("2-1=",1+1)# 减
print("3*3=",3*3)# 乘
print("4/2=",4/2)# 除
print("11//2=",11//2)# 取整除
print("9%2=",9%2)# 取余
print("2**3=",2**3)# 指数
# 赋值运算符
num=1+2*3
# 复合赋值运算符
# +=
num=1
num+=1 # num=num+1
print("num+=1:",num)

num-=1 # num=num-1
print("num-=1:",num)

num*=4
print("num*=4:",num)

num/=2
print("num/=2:",num)

num=3
num%=2
print("num%=2:",num)

num**=2
print("num**=2:",num)

num=9
num//=2
print("num//=2:",num)

1.8字符串的三种定义方式

# 单引号定义法
name='niuma'
print(type(name))

# 双引号定义法
name="niuma zhong"
print(type(name))


# 三引号定义法 写法与多行注释一样
name="""
niuma zhongjiur 
"""
print(type(name))
# 注意：用变量接收它，就是字符串
#      若不适用变量接收它，它就是多行注释

# 在字符串内包含双引号
name='"niuma"'
print(name)
# 在字符串内包含单引号
name="'niuma'"
print(name)
# 使用转义字符 \ 解除引号的效用
name="\"niuma\""
print(name)
name='\'niuma\''
print(name)

1.9字符串的拼接

# 字符串字面量之间的拼接
print("学IT来黑马"+"月兴过完")
# 字符串字面量和字符串变量的拼接
name="niuma"
address="jiangxi"
tel=40000008888
print("我是:"+name+",我的地址是:"+address+"，my 电话是:"+tel)# 目前数字无法进行拼接

1.10字符串格式化

name="niuma"
message="nimmmmm:%s"% name
print(message)

# 通过占位的形式，完成数字和字符串的拼接
class_num =57
avg_salary=16781
message="python niuma  ,北京%s期，毕业平均工资:%s"%(class_num,avg_salary)
print(message)

name="船只博客"
setup_year=2006
stock_price=19.99
message="%s,成立于：%d,今天股价是：%f"%(name,setup_year,stock_price)
print(message)

1.11格式化的精度控制

num1=11
num2=11.345
print("数字11宽度限制5，结果是:%5d"%num1)
print("数字11宽度限制1，结果是:%1d"%num1)
print("数字11.345宽度限制7，小数精度2，结果是：%7.2f"%num2)
print("数字11.345宽度不限制，小数精度2，结果是：%.2f"%num2)

1.12字符串格式化方式2

name="江西财大"
set_up_yaer=1923
scale=2200.999999
jianjie='江西财经大学是一所财政部、教育部、江西省人民政府共建，以经济、管理类学科为主，法、工、文、理、艺术等学科协调发展的高等财经学府'
zongli_say="你们学校是所很好的学校"
zongli_name="温家宝"
# f:format
print(f"这里是{name},成立于：{set_up_yaer}年，占地面积：{scale}")
print(f"{jianjie}")
print(f"2008年2月，国务院总理{zongli_name}说:{zongli_say}")

1.13对表达式进行格式化

print("1*1的结果是：%d"%(1*1))
print(f"1*2的结果是：{1*2}")
print("字符串在python中的类型名是:%s"%type("字符串"))

练习

name="传智播客"
stock_code="003032"
stock_price=19.99
print(f"公司：{name},股票代码：{stock_code},当前股价：{stock_price}")
stock_price_daily_growth_facter=1.2
growth_days=7
finnal_price=stock_price*stock_price_daily_growth_facter**growth_days
print("每日增长系数是：%.1f,经过%d天的增长后，股票达到了：%.2f"%(stock_price_daily_growth_facter,growth_days,finnal_price))

第二章-条件语句

2.0input输入

name=input("你是谁？")# 给出提示信息，并用name接收【免去在前面写print手动提示】
print("我知道了，你是:%s"%name)
# 输入数字类型
num=input("请告诉我你的学号：")# input默认接收  成为字符串，哪怕是数字也会自动转为字符串
# 数据类型转换
num=int(num)# 需要数字类型，得自行进行类型转换
print("学号类型是：",type(num))

练习

user_name=input("请您输入用户名")
user_type=input("请您输入您的用户级别")
# 使用%占位符的方式输出
# print("您好：%s,您是尊贵的：%s用户，欢迎您的光临。"%(user_name,user_type))

# 使用f"{变量}"的方式输出
print(f"您好：{user_name},您是尊贵的：{user_type}用户，欢迎您的光临。")

2.1布尔类型和比较运算符

# 定义变量存储布尔类型的数据
bool_1=True
bool_2=False
print(f"bool_1变量的内容是：{bool_1},类型是:{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2},类型是:{type(bool_2)}")
# 比较运算符的使用
# ==，！=，>,<, >=, <=    注意：两个等号
# 演示进行内容的相等比较
num1=10
num2=10
print(f"10==10的结果是,{num1==num2}")
num1=10
num2=15
print(f"10!=15的结果是：{num1!=num2}")

name1="ittest"
name2="niuma"
print(f"ittest==niuma的结果是:{name1==name2}")

#演示  大于小于，大于等于，小于等于的比较运算
num1=10
num2=5
print(f"10>5的结果是：{num1>num2}")
print(f"10<5的结果是：{num1<num2}")

num1=10
num2=10
print(f"10>=10的结果是：{num1>=num2}")
print(f"10<=10的结果是：{num1<=num2}")

num1=10
num2=11
print(f"10<=11的结果是：{num1<=num2}")
print(f"10>=11的结果是：{num1>=num2}")

2.2if语句的基本格式

age=20
if age>=18: # 不需要括号，需要冒号
    print("我已经成年了")# 因归属于if的代码块，语句前需要  四个空格缩进
    print("步入大学生活")# 因归属于if的代码块，语句前需要  四个空格缩进
print("niumama")# 不归属if代码块，则不需要四个空格缩进，且会自动输出（无条件）

练习

2.3案例-成年人判断讲解

#age=input("请您输入年龄")# 获取键盘输入
#age=int(age)# 数据类型转换

age=float(input("请您输入年龄"))# 简化[获取输入+数据类型转换放在一起]，注意使用float类型更佳

if age>=18:
    print("欢迎来到黑马儿童游乐园，儿童免费，成人收费。")
    print(f"您输入的年龄是：{age}")
    print("您已成年，游玩需要补票10元。")
print("祝您游玩愉快。")

2.4if-else组合判断语句

age=int(input("请输入你的年龄："))
if age>=18:
    print("您已成年，需要买票10元。")
else:
    print("您未成年，玩吧，你免费的。")
print("游玩愉快哦！")

练习

2.5案例-我要买票吗

high=float(input("请输入您的身高(cm)"))
print("欢迎来到黑马动物园。")
if high>=120:
    print("您的身高超出120cm,游玩需要购票10元。")
else:
    print("您的身高未超出120cm,可以免费游玩。")
print("祝您游玩愉快。")

2.6if-else-else组合使用的语法

if int(input("请输入你的身高(cm):"))<120:
    print("身高小于120cm，可以免费。")
elif int(input("请输入你的VIP等级(1-5):"))>3:
    print("您是尊贵的VIP用户，级别大于3，可以免费")
elif int(input("请告诉我今天几号："))==1:
    print("今天是1号免费日，可以免费")
else:# else这一套语句 可以省略不写，效果等同于3个独立的if判断
    print("不好意思，条件都不满足，需要买票10元。")

# 注意：elif 条件判断是互斥的， 从上至下

2.7案例-猜猜心里数字讲解

num=10
if int(input("请输入你猜想的数字"))==num:
    print("恭喜你，你猜对了")
elif int(input("猜错了，再猜一次："))==num:
    print("猜对了")
elif int(input("不对，再猜最后一次:"))==num:
    print("猜对了")
else :
    print("sorry，全部猜错，我想的是10")

2.8判断语句的嵌套

# if int(input("你的身高是多少"))>120:
#     print("身高超出限制，不可以免费")
#     print("但是，如果VIP级别大于3，可以免费")
#
#     if int(input("你的VIP级别是多少："))>3:
#         print("恭喜你，VIP级达标，可以免费")
#     else:
#         print("sorry 你需要买票10元")
# else:
#     print("欢迎小朋友免费游玩")
# python一键注释多行： Ctrl+/
age=14
year=1
level=1
if age>=18:
    print("你是成年人")
    if age<30:
        print("你的年龄达标了")
        if year>2:
            print("恭喜你，年龄+入职时间都达标，可以领取礼物")
        elif level>3:
            print("恭喜你，年龄+级别都达标，可以领取礼物")
        else:
            print("不好意思，尽管年龄达标，但是入职时间和级别都不达标。")


    else:
        print("不好意思，年龄大了")
else:
    print("不好意思，小朋友不可以领取。")

2.9判断语句综合案例

# 1.构建随机的数字变量
import random
num=random.randint(1,10)

guess_num=int(input("输入你要猜的数字"))


# 2.通过if判断语句进行数字的猜测
if guess_num==num:
    print("恭喜你，第一次就猜中了")
else:
    if guess_num>num:
        print("你猜大了")
    else:
        print("你猜小了")

    guess_num = int(input("输入你要猜的数字"))
    if guess_num==num:
        print("恭喜，第二次猜中！")
    else:
        if guess_num > num:
            print("你猜大了")
        else:
            print("你猜小了")

        guess_num = int(input("输入你要猜的数字"))

        if guess_num == num:
            print("恭喜，第三次猜中！")
        else:
            print("三次机会用完了，没有猜中")

第三章-循环

3.0补充

3.01输出不换行

# 输出不换行
print("hello",end='')
print("world",end='')

3.02制表符\t

# 制表符\t = tab键
print("haha\tbest")
print("hello\tworld")

3.1while循环的基础应用

i=0
while i<100:
    print(f"牛马,{i}")
    i+=1

3.2案例求1-100的和

sum=0
i=1
while i<=100:
    sum+=i
    i+=1
    print(f"1-100累加的和是:{sum}")

3.3while循环猜数字案例

# 获取范围在1-100的随机数字
import random
num=random.randint(1,100)
# 定义一个变量，记录总共猜测了多少次
count=0
# 通过一个布尔类型的变量，做循环是否继续的标记
flag=True
while flag:
    guess_num=int(input("请输入你猜的数字"))
    count+=1
    if guess_num==num:
        print("猜中了")
        # 设置为false就是终止循环的条件
        flag=False
    elif guess_num>num:
        print("猜大了")
    else:
        print("猜小了")
print(f"你总共猜测了{count}次")

3.4while循环的嵌套应用

# 外层，表白100天的控制
i=1
while i<=100:
    print(f"今天是第{i},准备表白。。。。。")
# 内层循环
    j=1
    while j<=10:
        print(f"送给小美的第{j}只玫瑰花")
        j+=1

    print("小美，我喜欢你")
    i+=1
print(f"坚持到第{i-1}天,表白成功")

3.5while循环案例-九九乘法表

# 通过while循环输出9*9乘法表
# 定义外层循环
i=1
while i<=9:

    # 定义内层循环的控制变量
    j=1
    while j<=i:
        # 不换行，通过\t对齐
        print(f"{j}*{i}={j*i}\t",end='')
        j+=1
    i+=1
    print() # print 空内容 ，就是输出一个换行

3.6for循环的基础语法

name="nuimaa  a "
for x in name:
    # 将 name里的内容，挨个取出，赋予临时变量x
    # 就可以在循环体内对x进行处理
    print(x)
# 注意：无法定义循环条件， for 变量 in 被处理的数据。
# 注意：循环内的语句，需要有空格缩进！！！

3.7for循环案例-数一数多少字母a

name="itheima is a brand of itcast"
sum=0 # 定义一个变量来统计有多少个a
for x in name:
    if x=="a":
        sum+=1
print(sum)

3.8range语句

# range 语法1 range(num)
# range(10)# 0-9
# for x in range(10):
#     print(x)

# range 语法2 range(num1,num2)
# for x in range(5,10):# 从5开始，到10结束（不含10本身）
#     print(x)

# range 语法3 range(num1,num2,step)
# for x in range(5,10,2):# 从5开始，到10结束（不包含10本身），数字之间 间隔2，
#     print(x)

# for x in range(10):
#     print("送玫瑰花")

练习

cout=0
for x in range(1,100):
    if x%2==0:
        cout+=1

print(f"1到100(不含100本身)范围内，有{cout}个偶数。")

3.9for循环临时变量作用域

i=0# 注意，你要先定义好
for i in range(5):
    print(i)
print(i)# 若未先定义好i,则 规范上不建议

3.10for循环的嵌套使用

i=1
for i in range(1,101):# 1-100
    print(f"今天是向小美表白的第{i}天，加油坚持。")
    for j in range(1,11):
        print(f"给小美送的第{j}朵玫瑰花")
    print("小美我喜欢你")
print(f"第{i}天，表白成功")

3.11for循环打印九九乘法表

# range 语法2 range(num1,num2)
# for x in range(5,10):# 从5开始，到10结束（不含10本身）
#     print(x)
for i in range(1,10):
        for j in range(1,i+1):
            print(f"{j}*{i}={j*i}\t",end='')
        print()

3.12continue和break

#
# for i in range(1,6):
#     print("语句1")
#     continue
#     print("语句2")

# continue 只在自己的循环中起作用
# for i in range(1,6):
#     print("语句1")
#     for j in range(1,6):
#         print("语句2")
#         continue
#         print("语句3")
#     print("语句4")

# 遇到break，整个循环结束
# for i in range(1,101):
#     print("语句1")
#     break
#     print("语句2")
# print("语句3")

# 在含break的循环中，break生效。不在循环，不能断别的循环
for i in range(1,6):
    print("语句1")
    for j in range(1,6):
        print("语句2")
        break
        print("语句3")

    print("语句4")

3.13循环综合案例

# 定义账户余额变量
sum=10000
# for循环对员工发工资
for i in range(1,21):
    import random                      # 随机生成1-10 要放入for循环中
    num = random.randint(1, 10)    # 注意！随机生成1-10 要放入for循环中

    if num<5:
        print(f"员工{i},绩效分{num},低于5，不发工资，下一位。")
        continue# continue跳过发放

    if sum>=1000:
        sum-=1000
        print(f"向员工{i}发放工资1000元，账户余额还剩余{sum}元")
    else:
        print("工资发完了，下个月领取吧。")
        break# break结束发放

第四章-函数

4.1函数的初体验

# name="itheima"
# length=len(name)
# print(length)
str1="hahahahah"
str2="niuniuniu"
str3="python"
count=0
for i in str1:
    count+=1
print(f"字符串{str1}的长度是：{count}")

count=0
for i in str2:
    count+=1
print(f"字符串{str2}的长度是：{count}")

count=0
for i in str3:
    count+=1
print(f"字符串{str3}的长度是：{count}")
# 可以使用函数来优化过程
def my_len(data):
    count=0
    for i in data:
        count+=1
    print(f"f字符串{data}的长度是{count}")
my_len(str1)
my_len(str2)
my_len(str3)

4.2函数的基础定义语法

# def 函数名(传入参数):
#     函数体
#     return 返回值
def say_hi():# 定义一个函数，输出相关信息
    print("Hi,I am niuma ")

# 调用函数，让定义的函数开始工作
say_hi()

4.3函数基础定义练习案例

def ShowInfo():
    print("欢迎来到黑马程序员！\n请出示您的健康码以及72小时核酸证明！")# \n表示 换行
ShowInfo()

4.4函数的传入参数

def add(x,y,z):# 参数的数量不受限制，2，3，4，5个都可以
    result=x+y+z
    print(f"{x}+{y}+{z}的结果是{result}")
add(5,6,7)

4.5函数的参数练习案例

def test(x):
    if x>=37.5:
        print(f"欢迎来到黑马程序员！请出示您的健康码和72小时核酸证明，并配合测量体温！\n体温测量中，您的体温是：{x}度，需要隔离！")
    else:
        print(f"欢迎来到黑马程序员！请出示您的健康码和72小时核酸证明，并配合测量体温！\n体温测量中，您的体温是：{x}度，体温正常请进！")
test(37.9)

4.6函数的返回值定义语法

def add(a,b):
    result=a+b
    return result
    print("我完事了")# return后，就不会执行了！
# 函数的返回值。可以通过变量去接收
r=add(5,6)
print(r)

4.7函数返回值之None类型

# 无return语句的函数返回值
def say_hi():
    print("您好呀")
result=say_hi()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")


# 主动返回None的函数
def say_hi2():
    print("您好呀")
    return None
result=say_hi2()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")


# None在if中的使用
def check_age(age):
    if age>18:
        return "success"
    else:
        return None
result=check_age(16)
if not result:
    # 进入if表示result是None值，也就是false
    print("未成年不可以进入")


# None用于声明无初始内容的变量
name=None

4.8函数的说明文档

def add(x,y):
    """
    add 函数可以接收两个参数，进行两数相加的功能
    :param x: 形参x表示相加的其中一个数字
    :param y: 形参y表示相加的另外一个数字
    :return: 返回值是两数相加的结果
    """
    result=x+y
    print(f"f两数相加的结果是：{result}")
    return result
add(5,6)

4.9函数的嵌套调用

def fuc_b():
    print("2222")
def fun_a():
    print("1111")
    fuc_b()

    print("3333")
fun_a()

4.10变量在函数中的作用域

# def test_a():
#     num=100
#     print(num)


# global关键字，在函数内声明变量为全局变量
num=200
def test_a():
    print(f"test_a:{num}")
def test_b():
    global num # 注意！！！设置内部定义的变量为全局变量
    num=500 # 原是 局部变量，但是 此时此刻变为全局变量了
    print(f"test_b:{num}")
test_a()
test_b()
print(num) # 由于上方有一行代码：global num。因此，此时局部变量变为全局变量，参照500执行

4.11函数综合案例

Money=5000000
name=input("请您输入姓名：")
# 查询余额函数
def check_money(show_header):
    if show_header:
        print("----------查询余额----------")
    print(f"{name},您好，您的当前余额为{Money}元")

# 存款函数
def input_money(inmoney):
    global Money
    Money=Money+inmoney
    print("----------存款----------")
    print(f"您已经成功存入{inmoney}元")
    check_money(False)



# 取款函数
def output_money(outmoney):
    global Money
    Money=Money-outmoney
    print("---------取款-----------")
    print(f"{name},您好，您已经成功取出{outmoney}元")
    check_money(False)

# 主菜单函数
def main():
    print("----------主菜单----------")
    print(f"{name},您好，欢迎来到黑马银行ATM，请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    return input("请输入您的选择：")


while True:
    keyword_input=main()
    if keyword_input=="1":
        check_money(True)
        continue
    elif keyword_input=="2":
        inmoney=float(input("您想存入多少钱？请输入："))
        input_money(inmoney)
        continue
    elif keyword_input=="3":
        outmoney=float(input("您想要取多少钱？请输入："))
        output_money(outmoney)
        continue
    else:
        print("程序退出")
        break

第五章-容器

5.1数据容器入门

# 语法：[元素1，元素2，...]

# 定义一个列表list
my_list=["itheima","itcast","python"]
print(my_list)
print(type(my_list))

my_list=["itheima",666666,True]# 元素类型不受限
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list=[[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

5.2列表的定义语法

5.3列表的下标索引

# 通过下标索引   取出对应位置的数据  列表[下标索引号]
my_list=["tim","lili","hohi"]
# 列表[下标索引]，从前向后，从0开始，每次+1； 从后往前，-1开始，每次减一
print(my_list[0])
print(my_list[1])
print(my_list[2])
# print(my_list[3]) #错误示范，列表索引超出范围!  注意！
# 通过下标索引取数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
# 取出嵌套列表的元素
my_list=[[1,2,3],[4,5,6]]
print(my_list[1][1])

5.4列表的常用操作方法

my_list=["itcast","itheima","python"]
# 1.1查找某元素在列表内的下标索引
index=my_list.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index=my_list.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2.修改特定下标索引的值
my_list[0]="船只教育"
print(f"列表被值修改后，结果是：{my_list}")

# 3.在指定下标位置插入新元素
my_list.insert(1,"best")
print(f"列表插入元素后，结果是：{my_list}")

# 4.在列表的尾部追加‘’‘单个’‘’新元素
# 语法：列表.append(元素)，将指定元素追加到列表的尾部
my_list.append("黑马程序员")
print(f"列表在追加元素后，结果是：{my_list}")

# 5.在列表的尾部追加‘’‘一批’‘’新元素
# 语法：列表.extend(其他数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
mylist2=[1,2,3]
my_list.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{my_list}")


# 6.删除指定下标索引的元素(2种方式)
my_list=["itcast","itheima","python"]
# 6.1方式1：del 列表[下标]    # 仅能删除
del my_list[2]
print(f"列表删除元素后的结果是：{my_list}")

# 6.2方式2: 列表.pop(下标)  # 不仅能删除，还能 取出删除的元素值
my_list=["itcast","itheima","python"]
element=my_list.pop(2)
print(f"通过pop方法，取出元素后，列表删除元素后的结果是：{my_list}，取出元素的是{element}")



# 7.删除某元素在列表中的第一个匹配项   # 仅能删除一个
# 语法：列表.remove(元素)
my_list=["itcast","itheima","itcast","itheima","python"]
my_list.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是:{my_list}")

# 8.清空列表
# 语法：列表.clear()
my_list.clear()
print(f"列表被清空了，结果是:{my_list}")

# 9.统计列表内某元素的数量
# 语法：列表.count(元素)
my_list=["itcast","itheima","itcast","itheima","python"]
count=my_list.count("itheima")
print(f"列表中itheima的数量是{count}")

# 10.统计列表中全部的元素数量
# 语法:len(列表)
my_list=["itcast","itheima","itcast","itheima","python"]
count=len(my_list)
print(f"列表的元素数量总共有：{count}个")

5.5列表的常用操作课后练习

# 1.定义一个列表，并用变量接收它
age=[21,25,21,23,22,20]

# 2.追加一个数字31，到列表的尾部
age.append(31)
print(f"列表尾部追加31的结果是:{age}")

# 3.追加一个新列表[29,33,30]，到列表的尾部
# age2=[29,33,30]
# age.extend(age2)
age.extend([29,33,30])
print(f"追加一个列表后的结果是:{age}")

# 4.取出第一个元素（21）
# 删除element1=age.pop(0)
element1=age[0]
print(f"取出第一个元素：{element1},当前列表剩下元素:{age}")

# 5.取出最后一个元素（30）
# 删除element2=age.pop(-1)
element2=age[-1]
print(f"取出最后一个元素：{element2},当前列表剩下元素：{age}")

# 6.查找元素31，在列表中的下标位置
index=age.index(31)
print(f"查找元素31的下标位置是{index}")
print(f"当前列表元素为:{age}")

5.6列表的循环遍历

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list=["船只教育","黑马程序员","Python"]
    # 定义一个变量
    index=0    # 初始值为0
    while index<len(my_list):

        element=my_list[index]
        print(f"列表的元素：{element}")
        index+=1
        # 至关重要

list_while_func()

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    mylist=[1,2,3,4,5]
    for element in mylist:
        print(f"列表的元素有：{element}")

list_for_func()

练习

# 通过while循环遍历列表，取出列表内的偶数，并存入一个新的列表对象中
mylist=[1,2,3,4,5,6,7,8,9,10]
def while_list_func():
    index=0
    list1=[]
    while index<len(mylist):
        element=mylist[index]
        if element%2==0:
            list1.append(element)
        index+=1
    print(f"通过while循环，从列表{mylist}中提取偶数，组成新的列表：{list1}")
while_list_func()

mylist=[1,2,3,4,5,6,7,8,9,10]
def for_list_func():
    list1=[]
    for element in mylist:
        if element%2==0:
            list1.append(element)
    print(f"通过for循环，从列表{mylist}中提取偶数，组成新的列表：{list1}")
for_list_func()

5.7元组的定义和操作

# 定义元组
t1=(1,"hello",True)
t2=()
t3=tuple()
print(f"t1的类型是：{type(t1)},内容是:{t1}")
print(f"t2的类型是：{type(t2)},内容是:{t2}")
print(f"t3的类型是：{type(t3)},内容是:{t3}")

# 定义单个元素的元组
t4=("hehe",)
print(f"t4的类型是：{type(t4)},内容是:{t4}")

# 元组的嵌套
t5=((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是：{t5}")

# 通过下标索引取出内容
num=t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作:index查找方法
t6=("船只教育","黑马程序员","Python")
index=t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是:{index}")

# 元组的操作：count统计方法
t7=("船只教育","黑马程序员","niuma","niuma","niuma","Python")
num=t7.count("niuma")
print(f"在元组t7中统计niuma的数量有{num}个")

# 元组的操作：len函数统计元组元素数量
t8=("船只教育","黑马程序员","niuma","niuma","niuma","Python")
num=len(t8)
print(f"t8元组中的元素有{num}个")

# 元组的遍历：while
index=0
while index<len(t8):
    print(f"元组的元素有:{t8[index]}")
    # 至关重要
    index+=1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")
# 修改元组
# t8[0]="itcast" # 错误示范,元组不可以被修改
t9=(1,2,["niuma","hahahhaha"])
print(f"t9的内容是{t9}")
t9[2][0]="黑马程序员"
t9[2][1]="船只教育"
print(f"t9的内容是{t9}")

练习

student=('周杰伦',11,['football','music'])
index=student.index(11)
print(f"查找其年龄所在下标位置：{index}")
name=student[0]
print(f"学生的姓名是{name}")
del student[2][0]
print(f"删除football后的结果是{student}")

student[2].insert(0,'coding')
print(f"添加coding在爱好list中后的结果是{student}")

5.8字符串的定义和操作

my_str="aaaerty and aaay"
# 通过下标索引
value=my_str[2]
value2=my_str[-2]
print(f"从字符串{my_str}中取下标为2的元素，值为:{value};从字符串{my_str}中取下标为-2的元素，值为:{value2}")
# my_str[2]="E"# 错误示范！只读，不可以进行修改 ，同元组

# index方法
# 查找特定下标索引值
value=my_str.index("and")
print(f"在字符串{my_str}中查找and,其起始下标是：{value}")

# replace方法
new_my_str=my_str.replace("aaa","程序")
print(f"将字符串{my_str},进行替换后得到：{new_my_str}")

# split方法
my_str="hello python itheima itcast"
my_str_list=my_str.split(" ")
print(f"将字符串：{my_str}进行split切分后得到：{my_str_list},类型是：{type(my_str_list)}")

# strip方法
my_str="  hahaha and oooo  "
new_my_str=my_str.strip()# 不传入参数，去除首尾空格
print(f"字符串：{my_str}被strip后，结果：{new_my_str}")

my_str="12hahhaha21"
new_my_str=my_str.strip("12")
print(f"字符串：{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某个字符串出现的次数
# count方法
my_str="hahaha and oooo"
count=my_str.count("ha")
print(f"字符串{my_str}中ha出现的次数是:{count}")

# 统计字符串的长度
num=len(my_str)
print(f"字符串{my_str}的长度是：{num}")

5.9字符串的课后练习

my_str="itheima itcast boxuegu"
count=my_str.count("it")
new_my_str=my_str.replace(" ","|")
my_str_list=my_str.split(" ")
print(f"字符串{my_str}中有：{count}个it字符")
print(f"字符串{my_str},被替换空格后，结果：{new_my_str}")
print(f"字符串{my_str},按照|分隔后，得到:{my_str_list}")

5.10数据容器（序列）的切片

# 对list 进行切片，从1开始，4结束，步长1
my_list=[0,1,2,3,4,5,6]
r1=my_list[1:4] # 步长默认为1 ，所以省略不写
print(f"结果1:{r1}")


# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0,1,2,3,4,5,6)
r2=my_tuple[:] # 起始和结束不写，表示从头到尾。步长为1 可以省略
print(f"结果2:{r2}")


# 对str进行切片，从头开始，到最后结束，步长2
my_str="01234567"
r3=my_str[::2]
print(f"结果3:{r3}")


# 对str进行切片，从头开始，到最后结束，步长-1
my_str="01234567"
r4=my_str[::-1] #等同于将序列反转了
print(f"结果4:{r4}")


# 对列表进行切片，从3开始，到1结束，步长-1
my_list=[0,1,2,3,4,5,6]
r5=my_list[3:1:-1]
print(f"结果5:{r5}")


# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple=(0,1,2,3,4,5,6)
r6=my_tuple[::-2]
print(f"结果6:{r6}")

5.11序列的切片课后练习

my_str="万过薪月，员序程马黑来，nohtyP学"
# z1=my_str[::-1]
# print(f"倒序字符串后的结果是:{z1}")
# z2=z1[9:14]
# print(f"取出后的结果是：{z2}")

# 方式1：倒序字符串，切片取出
r1=my_str[::-1][9:14]
print(f"方式1:{r1}")


# 方式2：切片取出，然后倒序
r2=my_str[5:10][::-1]
print(f"方式2:{r2}")


# 方式3：split分隔“，”replace替换"来"为空，倒序字符串
r3=my_str.split("，")[1].replace("来","")[::-1]
print(f"方式3:{r3}")

5.12集合的定义和操作

# 定义集合【注意！无序的，去重的/不能重复】
# 定义语法：{元素1,元素2,元素3,...,元素n}
my_set={"船只教育","黑马程序员","itheima","船只教育","黑马程序员","itheima","船只教育","黑马程序员","itheima",}
my_set_empty=set()
print(f"my_set的内容是{my_set},类型是{type(my_set)}")
print(f"my_set_empty的内容是{my_set_empty},类型是{type(my_set_empty)}")
# 因无序，所以不支持下标索引

# 添加新元素
my_set.add("Python")
my_set.add("船只教育")
print(f"my_set添加元素后的结果是:{my_set}")

# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后的结果是：{my_set}")

# 随机取出一个元素
my_set={"船只教育","黑马程序员","itheima"}
element=my_set.pop()
print(f"集合被取出元素是:{element},取出后的结果是{my_set}")

# 清空集合 claer
my_set.clear()
print(f"集合被清空了，结果是{my_set}")

# 取两个集合的差集
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后原有set1的内容{set1}")
print(f"取差集后原有set2的内容{set2}")

# 消除2个集合的差集
set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(f"消除差集后结果  集合1的结果{set1}")
print(f"消除差集后结果  集合2的结果{set2}")

# 2个集合合并为1个
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(f"两个集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")


# 统计集合元素数量 len()
set1={1,2,3,4,5,1,2,3,4,5}
num=len(set1)
print(f"集合内的元素数量有：{num}个")


# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1={1,2,3,4,5}
for element in set1:
    print(f"集合的元素有：{element}")

5.13集合的课后练习

my_list=['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
my_set_empty=set()
for element in my_list:
    my_set_empty.add(element)
print(f"有列表:{my_list}，\n存入集合后的结果：{my_set_empty}")

5.14字典的定义

# 定义字典[无下标索引] 通过key值获取Value
my_dict={"张三":99,"李四":88,"王五":77}

# 定义空字典
my_dict3={}
my_dict2=dict()
print(f"字典1：{my_dict}，类型是{type(my_dict)}")
print(f"字典2：{my_dict2}，类型是{type(my_dict2)}")
print(f"字典3：{my_dict3}，类型是{type(my_dict3)}")
# 定义重复key的字典
my_dict4={"张三":99,"张三":66,"李四":88,"王五":77}
print(f"重复字典的内容是：{my_dict4}")

# 从字典中基于key获取Value
my_dict={"张三":99,"李四":88,"王五":77}
score=my_dict["张三"]
print(f"张三的考试分数是:{score}")
score1=my_dict["李四"]
print(f"李四的考试分数是:{score1}")

# 定义嵌套字典
stu_score_dict={
    "张三":{
        "语文":77,
        "数学":66,
        "英语":33
    },"李四":{
        "语文": 88,
        "数学": 86,
        "英语": 55
    },"王五":{
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下李四的语文信息
score=stu_score_dict["李四"]["语文"]
print(f"李四的语文分数是：{score}")
# 看一下王五的英语成绩
score2=stu_score_dict["王五"]["英语"]
print(f"王五的英语分数是：{score2}")

5.15字典的常用操作

my_dict={"周杰伦":99,"凌俊杰":88,"张学友":77}
# 新增元素
my_dict["张信哲"]=66
print(f"新增元素后：{my_dict}")

# 更新元素
my_dict["周杰伦"]=33
print(f"修改元素后：{my_dict}")

# 删除元素
score=my_dict.pop("周杰伦")
print(f"删除元素后：{my_dict},周杰伦的考试分数是:{score}")

# 清空元素,clear
my_dict.clear()
print(f"字典被清空后的结果：{my_dict}")

# 获取全部的key
my_dict={"周杰伦":99,"凌俊杰":88,"张学友":77}
keys=my_dict.keys()
print(f"字典的全部keys是：{keys}")

# 遍历字典
# 方式一：通过获取全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是:{my_dict[key]}")
# 方式二：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是:{my_dict[key]}")

# 统计字典内的元素数量,len()
num=len(my_dict)
print(f"字典中元素数量有：{num}个")

5.16字典的课后练习

worker_dict={
    "王力宏":{
        "部门":"科技部",
        "工资":3000,
        "级别":1

    },
    "周杰伦":{
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊杰":{
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学友":{
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德华":{
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}
print(f"全体员工当前信息如下：\n{worker_dict}")
for key in worker_dict:
    if worker_dict[key]["级别"]==1:
        worker_dict[key]["级别"]+=1
        worker_dict[key]["工资"]+=1000

print(f"完成升值加薪操作后:\n{worker_dict}")

5.17五类数据容器的总结对比

5.18数据容器的通用操作

""""
演示数据容器的通用功能
"""
my_list=[1,2,3,4,5]
my_tuple=(1,2,3,4,5)
my_str="abcdefg"
my_set={1,2,3,4,5}
my_dict={"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max最大元素
# 补充：用 alt+shift+鼠标选中=  一次性 集中修改选中的所有内容
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")

# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{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)}")

# 类型转换：容器转元组
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)}")
# 类型转换：容器转字符串
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)}")
# 进行容器的排序
my_list=[3,1,2,5,4]
my_tuple=(3,1,2,5,4)
my_str="bdcefga"
my_set={3,1,2,5,4}
my_dict={"key3":1,"key1":2,"key2":3,"key5":4,"key4":5}
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)}")


print(f"列表对象的反向排序结果：{sorted(my_list,reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple,reverse=True)}")
print(f"字符串对象反向排序结果：{sorted(my_str,reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set,reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict,reverse=True)}")

5.19拓展-字符串大小比较的方式

"""
演示字符串大小比较
"""
# abc比较abd
print(f"abd大于abc，结果：{'abd'>'abc'}")
# a比较ab
print(f"ab大于a,结果：{'ab'>'a'}")
# a比较A
print(f"a大于A,结果：{'a'>'A'}")
# key1比较key2
print(f"key2>key1,结果：{'key2'>'key1'}")

第六章-函数进阶

6.1函数的多返回值

def test_return():
    return 1,"hello",True
x,y,z=test_return()
print(x)
print(y)
print(z)

6.2函数的多种参数使用形式

# 位置参数
def user_info(name,age,gender):
    print(f"姓名:{name},年龄是：{age},性别是{gender}")
# 位置参数-默认使用形式
user_info('小米',20,'男')

# 关键字参数[k=v形式,可以和位置参数混用，位置参数需在前]
user_info(name='小王',age=11,gender='女')
user_info(age=20,name='hash',gender='男') # 可以  不按照参数的定义顺序传参
user_info('天天',age=18,gender='男')

# 缺省参数（默认值）【注意！默认参数写最后面】
def user_info(name,age,gender='男'): # 【默认参数写最后面】
    print(f"姓名:{name},年龄是：{age},性别是{gender}")
user_info('小东',13,gender='女')

# 不定长-位置不定长    *号------元组接收
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f"args参数的类型是：{type(args)},内容是：{args}")
user_info(1,2,3,'小米','男孩')


# 不定长-关键字不定长   **号------字典接收 [key=value 形式传入]
def user_info(**kwargs):
    print(f"kwargs参数的类型是：{type(kwargs)},内容是：{kwargs}")
user_info(name='张三',age=11,gender='man')

6.3函数作为参数传递

# 定义一个函数，接收另一个函数作为传入参数
def test_func(computer):
    result=computer(1,2)# 确定computer是函数
    print(f"computer参数的类型是：{type(computer)}")
    print(f"计算结果：{result}")
# 定义一个函数，准备作为参数传入另一个函数
def computer(x,y):
    return x+y
# 调用 并传入函数
test_func(computer)

6.4lambda匿名函数

# 定义一个函数，接受其它函数输入
def test_func(computer):
    result=computer(1,2)
    print(f"结果是：{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入【lambda匿名函数 只有一行代码】
# def computer(传入参数):
test_func(lambda x,y:x+y)
test_func(lambda x,y:x+y)

第七章-文件

7.1文件编码概念

7.2文件的读取操作

"""
演示对文件的读取
"""
import time

# 打开文件
f = open("E:/jufe.txt", "r", encoding="UTF-8")
print(type(f))

# 读取文件-read()
# print(f"读取10个字节的结果：{f.read(10)}")


# print(f"read方法读取全部内容的结果是：{f.read()}")


print("---------------------------------------------------------------------------------------")
# 读取文件-readLines()
# lines=f.readlines()# 读取文件的全部行，封装到列表中
# print(f"lines对象的类型：{type(lines)}")
# print(f"lines对象的内容是：{lines}")


# 读取文件-readLine()
# line1=f.readline()
# line2=f.readline()
# line3=f.readline()
# print(f"第一行数据是：{line1}")
# print(f"第二行数据是：{line2}")
# print(f"第三行数据是：{line3}")


# for循环读取文件行[每一次，就可以读取每一行数据]
for line in f:
    print(f"每一行数据是:{line}")

# 文件的关闭
# time.sleep(500000) # 暂停执行500000秒
f.close()
time.sleep(500000)

# with open 语法操作文件[进行with open操作后，文件会自动关闭,推荐使用]
with open("E:/jufe.txt", "r", encoding="UTF-8") as f:
    for line in f:
        print(f"每一行数据是:{line}")
time.sleep(500000)

7.3文件读取的课后练习

# 打开文件，以读取模式打开
f=open("E:/word.txt","r",encoding="UTF-8")
# 方法一：读取全部内容，通过字符串count方法统计itheima单词数量
# content=f.read()
# count=content.count("itheima")
# print(f"文件里itheima的数目是：{count}")



# 方法二：读取内容，一行一行读取
count=0
for line in f:
    line=line.strip() # 去除开头和结尾的空格 以及 换行符
    words=line.split(" ")# 进行split切分，得到一个个词
    for word in words:
        if word=="itheima":
            count+=1

# 判断单词出现次数并累计
print(f"itheima出现的次数是:{count}")


# 关闭文件   注意！一定要写 关闭
f.close()

7.4文件的写出操作

"""
演示文件的写入
"""
# import time
#
# # 打开文件，不存在的文件
# f=open("E:/test.txt","w",encoding="UTF-8")
# # write写入
# f.write("hello,world") # 内容写入到内存中
#
# # flush刷新
# # f.flush()               #将内存中积攒的内容，写入到硬盘的文件中
# # time.sleep(600000)


# 打开一个存在的文件[若文件存在，他会清空已有内容，将新的内容覆盖上去]
f=open("E:/test.txt","w",encoding="UTF-8")
# write写入，flush刷新
f.write("niuma")


# close关闭
f.close()   # close方法内置了 flush功能的

7.5文件的追加写入操作

"""
演示文件的追加写入
"""
# 打开文件，不存在的文件
# f=open("E:/text.txt","a",encoding="UTF-8")
# # write写入
# f.write("niuma aaaaaaaaaa")
# # flush刷新
# f.flush()
# # close关闭
# # f.close()

# 打开一个存在的文件
f=open("E:/text.txt","a",encoding="UTF-8")
#  write写入、flush刷新
f.write("\n别学了")
# # close关闭
f.close()

7.6文件操作的综合案例

"""
演示文件操作综合案例：文件备份
"""
# 打开文件得到文件对象，准备读取
fr=open("E:/bill.txt","r",encoding="UTF-8")
# 打开文件得到文件对象，准备写入
fw=open("E:/bill.txt.bak",'w',encoding="UTF-8")
# for循环读取文件
for line in fr:
    line=line.strip()
    # 判断内容，将满足的内容写出
    if line.split(",")[4]=="测试":
        continue # continue进入下一次循环，这一次后面的内容就跳过了
    # 将内容写出去
    fw.write(line)
    # 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
    fw.write("\n")
# close 2个文件对象
fr.close()
fw.close()  # 写出文件调用close() 会自动flush()

第八章-异常

8.1了解异常

open("D:/HAHAH.txt","r",encoding="UTF-8") #演示错误/异常/bug

8.2异常的捕获

# # 基本捕获异常
# try:
#     f=open("D:/ABC.txt","r",encoding="UTF-8")
# except:
#     print("出现异常了，因为文件不存在，将open的模式改为w模式去打开")
#     f=open("E:/abc.txt","w",encoding="UTF-8")


# # 捕获指定的异常
# try:
#     print(name)
#     # 1/0
# except NameError as e:
#     print("出现了变量未定义的异常")
#     print(e)
#
#
# # 捕获多个异常
# try:
#     # 1/0
#     print(name)
# except(NameError,ZeroDivisionError) as e:
#     print("出现了变量未定义 或 除以0的异常错误")
# 未正确设置捕获异常类型，将无法捕获异常


# 捕获所有异常
try:
    f = open("E:/hahah.txt", "r", encoding="UTF-8")
except Exception as e:
    print("出现异常了")
    f = open("E:/ABC.txt", "w", encoding="UTF-8")
else:
    print("好高兴，没有异常")
finally:
    print("我是finally,有没有异常我都要执行")
    f.close()

8.3异常的传递性

"""
演示异常的传递性
"""
# 定义一个出现异常的方法
def func1():
    print("func1开始执行")
    num=1/0   # 肯定有异常
    print("func1结束执行")

# 定义一个无异常的方法，调用上面的方法
def func2():
    print("func2 开始执行")
    func1()
    print("func2 结束执行")

# 定义一个方法，调用上面的方法
def main():    # 解释：不需要到错误处（源头）进行 try-catch.在顶层也可以实现
    try:
        func2()
    except Exception as e:
        print(f"出现异常了，异常的信息是：{e}")
main()

8.4模块的概念和导入

"""
演示python的模块导入
"""
# 使用import导入time模块使用sleep功能（函数）

# import time  # 导入python内置的time模块(time.py这个代码文件)
# print("您好")
# time.sleep(5)  # 通过 . 就可以使用模块内部的全部功能(类、函数、变量)
# print("不好啊")

# 使用from导入time的sleep功能（函数）

# from time import sleep
# print("您好")
# sleep(5)
# print("不好啊")


# 使用*号导入time模块的全部功能
# from time import *   #  *表示全部的意思
# print("您好")
# sleep(5)
# print("不好啊")

# 使用as给特定功能加上别名
import time as t
# print("您好")
# t.sleep(5)
# print("不好啊")


# 使用as给特定功能加上别名
from time import sleep as sl
print("您好")
sl(5)
print("不好啊")

8.5自定义模块并导入

"""
演示自定义模块
"""
# 导入自定义模块使用
# import my_module1
# from my_module1 import test
# test(1,2)
# my_module1.test(1,2)


# 导入不同模块的同名功能
# from my_module1 import test  # 并没有使用，为黑色
# from my_module2 import test  # 使用了，变成了亮色，module2模块会覆盖掉module1模块
# test(1,2)

# __main__变量

# from my_module1 import test

# __all__变量
from my_module1 import *  #  *能导入谁，由al
test_a(1,2)
test_b(2,1) # 因未导入test_b，则 该行 代码 会报错

8.6自定义Python包

"""
演示python的包
"""
# 创建一个包

# 方式一：导入自定义的包中的模块，并使用
# import my_package.my_module1
# import my_package.my_module2
# my_package.my_module1.info_print1()
# my_package.my_module2.info_print2()

# 方式二：from语句导入
# from my_package import my_module1
# from my_package import my_module2
# my_module1.info_print1()
# my_module2.info_print2()

# 方式三：导入更深层的模块
# from my_package.my_module1 import info_print1
# from my_package.my_module2 import info_print2
# info_print1()
# info_print2()




# 通过__all__变量,控制import *
from my_package import *
my_module1.info_print1()

# 也可以直接手动导入
from my_package import my_module1,my_module2

8.7安装第三方包

8.8异常-模块-包-综合案例

第九章-数据可视化PyeCharts入门

9.1案例介绍

9.2JSON数据格式的转换

"""
演示json数据和python字典的相互转换
"""
import json
# 准备列表，列表内每一个元素都是字典，将其转换为json
data=[{"name":"张大帅","age":11},{"name":"王小丫","age":14},{"name":"李四","age":15}]
json_str=json.dumps(data,ensure_ascii=False)
print(type(json_str))
print(json_str)


# 准备字典，将字典转换为json
d={"name":"周杰伦","addr":"台北"}
json_str=json.dumps(d,ensure_ascii=False)
print(type(json_str))
print(json_str)



# 将json字符串转换为python数据类型[{k:v,k:v},{k:v,k:v}]
s='[{"name":"张大帅","age":11},{"name":"王小丫","age":14},{"name":"李四","age":15}]'
l=json.loads(s)
print(type(l))
print(l)


# 将json字符串转换为python数据类型{k:v,k:v}
s='{"name":"周杰伦","addr":"台北"}'
d=json.loads(s)
print(type(d))
print(d)

9.3PyeCharts模块介绍

画廊：Document (pyecharts.org)

介绍文档：pyecharts - A Python Echarts Plotting Library built with love.

9.4PyeCharts的入门使用

"""
演示pyecharts的基础入门
"""
# 导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts

# 创建一个折线图对象
Line=Line()
# 给折线图对象添加x轴的数据
Line.add_xaxis(["中国","美国","英国"])
# 给折线图对象添加y轴的数据
Line.add_yaxis("GDP",[30,20,10])


# 设置全局配置项 set_global_opts来设置，position
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方法，将代码生成图像
Line.render()

9.5数据准备

懒人工具JSON解析器（ab173）：懒人工具-json在线解析-在线JSON格式化工具-json校验-程序员必备 (kuquidc.com)

"""
演示可视化需求1：折线图开发
"""
import json
# 处理数据
f_us=open("E:/美国.txt","r",encoding="UTF-8")
us_data=f_us.read() # 美国的全部内容
# 去掉不合JSON规范的开头
us_data=us_data.replace("jsonp_1629344292311_69436(","")
# 去掉不合JSON规范的结尾
us_data=us_data[:-2]
# JSON转Python字典
us_dict=json.loads(us_data)

# 获取trend key
us_trend_data=us_dict['data'][0]['trend']
# print(type(trend_data))
# print(trend_data)

# 获取日期数据，用于x轴，取2020年(到315下标结束)
us_x_data=us_trend_data['updateDate'][:314]

# 获取确认数据，用于y轴，取2020年(到315下标结束)
us_y_data=us_trend_data['list'][0]['data'][:314]

# 生成图表

9.6生成折线图

"""
演示可视化需求1：折线图开发
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts

# 处理数据
f_us=open("E:/美国.txt","r",encoding="UTF-8")
us_data=f_us.read() # 美国的全部内容

f_jp=open("E:/日本.txt","r",encoding="UTF-8")
jp_data=f_jp.read() # 日本的全部内容

f_in=open("E:/印度.txt","r",encoding="UTF-8")
in_data=f_in.read() # 印度的全部内容

# 去掉不合JSON规范的开头
us_data=us_data.replace("jsonp_1629344292311_69436(","")
jp_data=jp_data.replace("jsonp_1629350871167_29498(","")
in_data=in_data.replace("jsonp_1629350745930_63180(","")

# 去掉不合JSON规范的结尾
us_data=us_data[:-2]
jp_data=jp_data[:-2]
in_data=in_data[:-2]

# JSON转Python字典
us_dict=json.loads(us_data)
jp_dict=json.loads(jp_data)
in_dict=json.loads(in_data)

# 获取trend key
us_trend_data=us_dict['data'][0]['trend']
jp_trend_data=jp_dict['data'][0]['trend']
in_trend_data=in_dict['data'][0]['trend']
# print(type(trend_data))
# print(trend_data)

# 获取日期数据，用于x轴，取2020年(到315下标结束)
us_x_data=us_trend_data['updateDate'][:314]
jp_x_data=jp_trend_data['updateDate'][:314]
in_x_data=in_trend_data['updateDate'][:314]

# 获取确认数据，用于y轴，取2020年(到315下标结束)
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()  # 构建折线图对象

# 添加x轴数据
Line.add_xaxis(us_x_data)   # 由于x轴是共用的，所以使用一个国家的数据即可

# 添加y轴数据
Line.add_yaxis("美国确诊人数",us_y_data,label_opts=LabelOpts(is_show=False))  # 添加美国的y轴数据
Line.add_yaxis("日本确诊人数",jp_y_data,label_opts=LabelOpts(is_show=False))  # 添加日本的y轴数据
Line.add_yaxis("印度确诊人数",in_y_data,label_opts=LabelOpts(is_show=False))  # 添加印度的y轴数据

# 设置全局选项
Line.set_global_opts(
    # 标题设置
    title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图",pos_left="center",pos_bottom="1%")

)


# 调用render方法，生成图表
Line.render()


# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()

第十章-数据可视化之地图构建

10.1数据可视化-地图-基础地图使用

注意！！！现在的版本，需要加：省，市

"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
# 准备地图对象
map=Map()
# 准备数据
data=[
    ("北京市",9),
    ("上海市",8),
    ("湖南省",5),
    ("台湾省",33),
    ("江西省",699),
    ("江苏省",44),
    ("湖南省",2),
    ("湖北省",55),
    ("浙江省",3)
]
# 添加数据
map.add("测试地图",data,"china")

# 设置全局选项
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min":1,"max":9,"label":"1-9","color":"#CCFFFF"},
            {"min":10,"max":99,"label":"10-99","color":"#FF6666"},
            {"min":100,"max":999,"label":"100-999","color":"#05eb3a"}
        ]
    )
)


# 绘图
map.render()

10.2全国疫情地图构建

"""
演示全国疫情可视化地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *
# 读取数据文件
f=open("E:/疫情.txt","r",encoding="UTF-8")
data=f.read()  # 全部数据
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict=json.loads(data) # 基础数据字典
# 从字典中取出省份的数据
province_data_list=data_dict["areaTree"][0]["children"]

# 组装每个省份和确诊人数为元组，并各个省的数据都封装入列表内
data_list=[]                                          # 绘图需要用的数据列表
for province_data in province_data_list:
    province_name=province_data["name"]                 # 省份名称
    province_confirm=province_data["total"]["confirm"]  # 确诊人数
    data_list.append((province_name,province_confirm))
# print(data_list)
# 创建地图对象
map=Map()
# 添加数据
map.add("各省份确诊人数",data_list,"china")
# 设置全局配置，定制分段的视觉映射
map.set_global_opts(
    title_opts=TitleOpts(title="全国疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min":1,"max":99,"lable":"1-99人","color":"#CCFFFF"},
            {"min":100,"max":999,"lable":"100-999人","color":"#FFFF99"},
            {"min":1000,"max":4999,"lable":"1-99人","color":"#FF9966"},
            {"min":5000,"max":9999,"lable":"5000-9999人","color":"#FF6666"},
            {"min":10000,"max":99999,"lable":"10000-99999人","color":"#CC3333"},
            {"min":100000,"lable":"100000+","color":"#8B1A1A"}
        ]
    )
)
# 绘图
map.render("全国疫情地图.html")

10.3河南省疫情地图绘制

"""
演示河南省疫情地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *
# 读取文件
f=open("E:/疫情.txt","r",encoding="UTF-8")
data=f.read()
# 关闭文件
f.close()
# 获取河南省数据
# json数据转换为python字典
data_dict=json.loads(data)
# 取到河南省数据
cities_data=data_dict["areaTree"][0]["children"][3]["children"]

# 准备数据为元组并放入list
data_list=[]
for city_data3 in cities_data:
    city_name=city_data3["name"]+"市"
    city_confirm=city_data3["total"]["confirm"]
    data_list.append((city_name,city_confirm))
# 手动添加济源市的数据
data_list.append(("济源市",5))

# 构建地图
map=Map()
map.add("河南疫情分布",data_list,"河南")


# 设置全局选项
map.set_global_opts(
    title_opts=TitleOpts(title="河南省疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,          # 是否显示
        is_piecewise=True,     # 是否分段
        pieces=[
            {"min":1,"max":99,"lable":"1-99人","color":"#CCFFFF"},
            {"min":100,"max":999,"lable":"100-999人","color":"#FFFF99"},
            {"min":1000,"max":4999,"lable":"1-99人","color":"#FF9966"},
            {"min":5000,"max":9999,"lable":"5000-9999人","color":"#FF6666"},
            {"min":10000,"max":99999,"lable":"10000-99999人","color":"#CC3333"},
            {"min":100000,"lable":"100000+","color":"#8B1A1A"}
        ]
    )
)

# 绘图
map.render("河南省疫情地图.html")

第十一章-绘图

11.1基础柱状图构建

"""
演示基础柱状图的开发
"""
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
# 使用Bar构建基础柱状图
bar=Bar()
# 添加x轴的数据
bar.add_xaxis(["中国","美国","英国"])
# 添加y轴的数据
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
# 反转x轴和y轴
bar.reversal_axis()
# 绘图
bar.render("基础柱状图.html")
# 设置数值标签在右侧

11.2基础时间线柱状图绘制

"""
演示带有时间线的柱状图开发
"""
from pyecharts.charts import Bar,Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType

bar1=Bar()
bar1.add_xaxis(["中国","美国","英国"])
bar1.add_yaxis("GDP",[30,30,20],label_opts=LabelOpts(position="right"))
bar1.reversal_axis()

bar2=Bar()
bar2.add_xaxis(["中国","美国","英国"])
bar2.add_yaxis("GDP",[50,50,50],label_opts=LabelOpts(position="right"))
bar2.reversal_axis()

bar3=Bar()
bar3.add_xaxis(["中国","美国","英国"])
bar3.add_yaxis("GDP",[70,60,60],label_opts=LabelOpts(position="right"))
bar3.reversal_axis()

# 构建时间线对象
timeline=Timeline({"theme":ThemeType.LIGHT})
# 在时间线内添加柱状图对象
timeline.add(bar1,"点1")
timeline.add(bar2,"点2")
timeline.add(bar3,"点3")

# 自动播放设置
timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=True
)
# 绘图是用时间线对象绘图，而不是bar对象了
timeline.render("基础时间线柱状图.html")
# 主题设置

11.3.0扩展列表的sort方法

"""
扩展列表的sort方法
在学习了将函数作为参数传递后，我们可以学习列表的sort方法来对列表进行自定义排序
"""
# 准备列表
my_list=[["a",33],["b",55],["c",11]]

# 排序，基于带名函数
# def choose_sort_key(element):
#     return element[1]
# my_list.sort(key=choose_sort_key,reverse=True)
# print(my_list)

# 排序，基于lambda匿名函数
my_list.sort(key=lambda element:element[1],reverse=True)
print(my_list)

11.3动态GDP柱状图绘制

from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType
f=open("E:/1960-2019全球GDP数据.csv","r",encoding="GB2312")
data_lines=f.readlines()
f.close()
# 删除第一条数据
data_lines.pop(0)
# 将数据转换为字典存储，格式为：
# {年份：[ [国家,gdp],[国家,gdp],......],年份：[[国家,gdp],[国家,gdp],......],......}
# {1960：[ [美国,123],[中国,321],......],1961：[[美国,123],[中国,321],......],......}
# 先定义一个字典对象
data_dict={}
for line in data_lines:
    year=int(line.split(",")[0]) # 年份
    country=line.split(",")[1]   # 国家
    gdp=float(line.split(",")[2]) # gdp数据
    # 如何判断字典里面有没有指定的key呢？
    try:
        data_dict[year].append([country,gdp])
    except KeyError:
        data_dict[year]=[]
        data_dict[year].append([country,gdp])

# 创建时间线对象
timeline=Timeline({"theme":ThemeType.LIGHT})
# 排序年份
sorted_year_list=sorted(data_dict.keys())
for year in sorted_year_list:
    data_dict[year].sort(key=lambda element:element[1],reverse=True )
    # 取出本年份前8的国家
    year_data=data_dict[year][0:8]
    x_data=[]
    y_data=[]
    for country_gdp in year_data:
        x_data.append(country_gdp[0])  # x轴添加国家
        y_data.append(country_gdp[1]/100000000)  # y轴添加gdp数据

    # 构建柱状图对象
    bar=Bar()
    x_data.reverse()
    y_data.reverse()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP(亿)",y_data,label_opts=LabelOpts(position="right"))
    # 反转x,y轴
    bar.reversal_axis()
    # 设置每一年的图表的标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球前八国家GDP数据")
    )
    timeline.add(bar,str(year))

    timeline.add_schema(
        play_interval=1000,
        is_timeline_show=True,
        is_auto_play=True,
        is_loop_play=False
    )
# 绘图
timeline.render("1960-2019全球GDP前8国家.html")