Python教程

pycharm快捷键

• ctrl+alt+a:打开软件设置
• ctrl+d:复制当前行代码
• shift+alt+上\下：将当前行代码上移或下移
• ctrl+shift+f10:运行当前代码文件
• shift+f6:重命名文件
• ctrl+f:搜索
• alt:同时修改多行
• ctrl+shift+alt:

基础语法

字面量

• 数字(number)

  • 整数int
  • 浮点数float
  • 复数complex
  • 布尔bool

• 字符串(string)

• 列表(List)

• 元组(Tuple)

• 集合(Set)

• 字典(Dictionary)

注释

单行：#+空格

多行：“”“注释内容”“”

变量

# print(内容1,内容2,内容3,...)
money = 50
print("钱包还有:",money)
money = money - 10
print("花费10元，还剩:",money,"元")

数据类型

type()查看数据类型

print(type(666))

数据类型的转换

int(x)
float(x)
str(x)
# num = int("黑马程序员")，转不了
# 万物皆可转字符串

标识符

1 只能有英文、数字、下划线和中文，但中文不推荐使用，只能英文下划线开头
2 大小写敏感
3 不可占用关键字
# 命名规则：见名知意，下划线命名法，英文字母全小写

运算符

• 算数运算符

  • +
  • –
  • *
  • /
  • // 取整数，9//2=4,9.0//2.0=4.0
  • % 取余
  • ** 指数，10**20表示10的20次方

• 赋值运算符

  • =

• 复合赋值运算符

  • +=
  • -=
  • *=
  • /=
  • %=
  • **=
  • //+

字符串扩展

# 字符串定义方式
1. 单引号定义法：name = 'heima'
2. 双引号定义法：name = "heima"
3. 三引号定义法：name = """heima"""
# 字符串内包含双引号
name = '"heima"'
# 字符串内包含单引号
name = "'heima'"
# 使用\进行转义
name = "\"heima\""
name = '\'heima\''
说白了\'表示单引号，\"表示双引号

字符串拼接

# print("学挨踢"+"月薪过one")
name = "heima"
address = "地球"
tel = 66666
print("我是："+name+"我的地址是："+address+"我的号码："+str(tel))
# 使用+ 只能字符串之间拼接

字符串格式化

class_num = 57
avg_salary = 16187
message = "python第%s期，平均工资%s" % (class_num,avg_salary)
print(message)

• 类型占位

  • %s:将内容转换成字符串
  • %d:将内容转换成整数
  • %f:将内容转换成浮点型

格式化的精度控制

m，控制宽度，要求是数字(很少使用)，设置的宽度小于数字本身，不生效

.n，控制小数点精度，要求是数字，会进行小数的四舍五入

• %5d:表示将整数宽度控制在5位，如数字11，被设置成5d，就会变成空格空格空格11，用3个空格补足宽度

• %5.2f:宽度为5，精度为2

  • 把11.345设置成%7.2f后，结果是空格空格11.35
  • 设置成%.2f，结果为11.35

字符串格式化方式2-快速写法

# f"内容{变量}"
name = "heima"
set_up_year = 2006
stock_price = 19.99
print(f"我是{name}，成立于{set_up_year}，今天的股价是{stock_price}")

对表达式进行格式化

print("1 * 1的结果是:%d" % (1 * 1))
print(f"1 * 1的结果是:{1 * 1}")
print("字符串的类型是:%s" % type('字符串')) 

数据输入(input语句)

# input("提示信息")
print("请告诉我你是谁？")
name = input("请告诉我你是谁:")
print("你是：%s" % name)
# 不管键盘输入什么，都是str类型

布尔类型和比较运算符

bool1=True
bool2=False
print(f"boo1的内容是：{bool1},类型是：{type(bool1)}")

if语句的基本格式

age=int(input("请输入你的年纪:"))
if age>=18:
    print("我已经成年")
    print("即将步入大学生活")
print("时间过得真快")    

if-else语句

age=int(input("请输入你的年纪:"))
if age>=18:
    print("我已经成年")
    print("即将步入大学生活")
else:
    print("未成年")

if-elif-else语句

height=int(input("请输入你的身高（cm）"))
vip_level=int(input("请输入会员等级（1-5）"))
if height<=120:
    print("可以免费")
elif vip_level>=3:
    print("可以免费")
else:
    print("必须收费")
# else可以不写，效果等同于3个独立if    

随机数

import random
num = random.randint(1,10)

while循环

i=0
while i<100:
    print("小美，我喜欢你")
    i+=1   

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

import random
num=random.randint(1,100)
print(num)
while(int(input("请输入你猜的数字"))!=num):
    print("猜错了")
print(f"终于猜对了:{num}")

import random
num=random.randint(1,100)
print(num)
count=0
flag= True
while flag:
    guess=int(input("请输入你猜测的数字:"))
    count+=1
    if guess==num:
        print("猜中了")
        flag=False
    else:
        if guess>num:
            print("猜大了")
        else:
            print("猜小了")
print(f"共猜了{count}次")            

while嵌套

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}天，表白成功")    

print("hello")
print("world")
print("hello",end='')
print("world",end='')
print("hello world")
print("itheima best")
print("hello\tworld")
print("itheima\tbest")
# \t相当于tab，多行可以对齐
# \n换行

# 99乘法表
i=1
j=1
while i<=9:
    while j<=i:
        print("%d*%d=%d\t"%(j,i,i*j),end='')
        j+=1
    print("")
    i+=1
    j=1

for循环

name="itheima"
for x in name:
    print(x)

range语句

range(5):0-4

range(num1,num2):num1到num2，不包含num2

range(num1,num2,step):num1到num2，不包含num2,步长为step，range(5,10,2):[5,7,9]

i=1
j=1
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j}*{i}={i*j}\t",end='')
    print()

break和continue

continue：中断本次循环，直接进入下一次循环

break：直接结束所在循环

函数

# len()统计长度
def my_len(data):
    count = 0
    for i in data:
        count+=1
    print(f"字符串{data}的长度是:{count}")
my_len("cnm")
my_len("wcnm")    

# 函数返回值,return后的都不会执行
def add(a,b):
    result=a+b
    return result 
r=add(1,1)
print(r)

# 若函数没有使用return，则返回None
def check_age(age):
    if age>18:
        return "success"
    return None
result=check_age(5)
if not result:
    print("未成年")

函数说明文档

# 若函数没有使用return，则返回N one
def check_age(age):
    """
    
    :param age: 
    :return: 
    """
    if age>18:
        return "success"
    return None
result=check_age(5)
if not result:
    print("未成年")

函数嵌套调用：一个函数里面又调用了另一个函数

局部变量：定义在函数体内部的变量，即只在函数体内生效

全局变量：函数体内、外都能生效

在函数内部修改全局变量使用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)

数据容器

list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

列表

# 字面量
[元素1,元素2,元素3...]
# 定义变量
变量名称=[元素1,元素2,元素3...]
# 定义空列表
变量名称=[]
变量名称=list()

# 可以为不同数据类型
name=['itheima','itcast','python']
print(name)
print(type(name))
name=['itheima',666,True]
print(name)
print(type(name))
# 嵌套列表
my_list=[[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))
# 列表的下标索引,正向从0开始每次加1，反向从-1开始每次减1
name=['itheima','itcast','python']
print(name[0])
print(name[1])
print(name[2])
print(name[-3])
print(name[-2])
print(name[-1])
#嵌套列表的下标
my_list=[[1,2,3],[4,5,6]]
print(my_list[0][0])
print(my_list[0][1])
print(my_list[0][2])

列表的常用操作

# 查找某元素的下标，找不到报错ValueError
# 语法:列表.index(元素)
mylist=['itheima','itcast','python']
index=mylist.index("itheima")
print(f"itheima在列表中的下标是：{index}")
# 修改特定位置(索引)元素的值
# 语法:列表[下标]=值
mylist[0]="传智教育"
print(mylist)
# 插入元素:列表.insert(下标,元素)
mylist.insert(1,"best")
print(mylist)
# 追加单个元素:列表.append(元素)
mylist.append("wcnm")
print(mylist)
# 追加一批元素:列表.extend(其他数据容器)
my_list=[1,2,3]
my_list.extend([4,5,6])
print(my_list)
# 删除元素:语法1:del 列表[下标]
#		  语法2:列表.pop(下标),还能返回删除的元素
mylist=['itheima','itcast','python']
del mylist[0]
print(mylist)
element=mylist.pop(0)
print(f"删除{element}后:{mylist}")
# 删除某元素在列表里的第一个匹配项:列表.remove(元素)
mylist=['itheima','itheima','itheima','itcast','python']
mylist.remove("itheima")
print(mylist)
# 清空列表:列表.clear()
mylist.clear()
# 统计某元素在列表里的数量:列表.count(元素) 
mylist=['itheima','itheima','itheima','itcast','python']
count=mylist.count("itheima")
print(f"列表中itheima的数量是{count}")
# 统计列表内总共有多少元素:len(列表)

列表的遍历

# while循环
mylist=[1,2,3,4,5,6]
i=0
while i<len(mylist):
    print(mylist[i])
    i+=1
# for循环
mylist=[1,2,3,4,5,6]
for i in mylist:
    print(i)
for i in range(0,len(mylist)):
    print(mylist[i])

元组的定义和操作

列表可以修改，元组定义完成就不能修改，元组里嵌套了list就能改

若元组只有一个元素，要在元素后面加逗号

# 定义元组字面量
(元素,元素,元素,元素,元素)
# 定义元组变量
变量名称=(元素,元素,元素)
# 定义空元组
变量名称=()
变量名称=tuple()
t1=("hello",)
# 元组嵌套
t1=((1,2,3),(4,5,6))
print(f"t1的类型是:{type(t1)},内容是:{t1}")
# 按下标取出内容
num=t1[1][2]
print(num)
# 查找特定元素第一个匹配项的下标:index()
t1=(1,2,'hello',3,4,'hello')
print(t1.index('hello'))
# 统计某元素出现的次数:count()
print(t1.count('hello'))
# 统计元素个数:len()
print(len(t1))
# 元组嵌套列表
t2=(1,2,["itheima","itcast"])
print(t2)
t2[2][0]="cnm"
t2[2][1]="wcnm"
print(t2)

字符串的定义和操作

字符串是字符的容器,不可修改

# 通过下标获取字符
name="itheima"
print(name[0])
print(name[-1])
# 查找特定字符串的下标索引值:字符串.index(字符串)
my_str="itcast and itheima"
print(my_str.index("and"))
# 字符串的替换:字符串.replace(字符串1,字符串2)
#将一个总字符串里的字符串1全换成字符串2，注意不是修改字符串，而是得到一个新字符串
new_str=my_str.replace("it","程序")
print(new_str)
# 字符串 的分割:字符串.split(分隔符字符串)
# 按照指定的分隔符字符串，将字符串分为多个字符串，并存入列表对象中，注意：字符串本身不变，而是得到一个列表对象
my_str="hello itheima itcast python"
list=my_str.split(" ")
print(list)
# 字符串的规整操作(去前后空格):字符串.strip()
my_str="   itheima and itcast   "
print(my_str.strip())
# 字符串的规整操作(去前后指定字符串):字符串.strip(字符串)
my_str="12itheima and itcast21"
print(my_str.strip("12"))
# 传入的是"12","1"和"2"都会移除，是按照单个字符

# 统计字符串中某字符串的出现次数，count
my_str="itheima and itcast"
count=my_str.count("it")
print(count)
# 统计字符串的长度，len()
print(len(my_str))

序列的切片操作

序列：内容连续、有序，可使用下标索引的一类数据容器，列表、元组、字符串都可看作序列

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

• 起始下标表示从何处开始，可留空，留空视作从头开始

• 结束下标(不包含)表示何处结束，可留空，留空视作截取到结尾

  • 步长1：一个个取元素
  • 步长2：每次跳过一个元素取
  • 步长N：每次跳过N-1个元素取
  • 步长为负数：反向取(注意，起始下标和结束下标也要反向标记)

# list切片，从1开始，4结束，步长1,步长默认为1可不写
my_list=[0,1,2,3,4,5,6]
result1=my_list[1:4]
print(result1)
# tuple切片，从头开始到最后，步长1
my_tuple=(0,1,2,3,4,5,6)
result2=my_tuple[:]
print(result2)
# str切片，从头到尾，步长2
my_str="012345678"
result3=my_str[::2]
print(result3)
# str切片，从头到尾，步长-1，等同于序列反转
my_str="012345678"
result3=my_str[::-1]
print(result3)
# 列表切片，从3到1，步长-1
my_list=[0,1,2,3,4,5,6]
result4=my_list[3:1:-1]
print(result4)
# 元组切片，从头到尾，步长-2
my_tuple=(0,1,2,3,4,5,6)
result5=my_tuple[::-2]
print(result5)

集合的定义和操作

集合无序，不支持下标访问，内容不能重复，集合不是序列，允许修改

# 定义集合字面量
{元素,元素,...}
# 定义集合变量
变量名称={元素,元素,...}
# 定义空集合
变量名称=set()

my_set={"itheima","python","java"}
empty=set()
print(f"my_set的内容是：{my_set},类型是{type(my_set)}")
# 添加新元素:集合.add(元素)
my_set={"hello","world"}
my_set.add("itheima")
print(my_set)
# 移除元素:集合.remove(元素)
my_set.remove("hello")
# 随机取出一个元素:集合.pop()
element=my_set.pop()
# 清空集合:集合.clear()
my_set.clear()
# 取出两个集合的差集:集合1.difference(集合2)，集合1有而集合2没有，得到一个新集合
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
print(set3)
# 消除两个集合的差集:集合1.difference_update(集合2),在集合1内删除和集合2相同的元素，集合1被修改，集合2不变
set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(set1)
print(set2)
# 两个集合合并:集合1.union(集合2)，得到新集合
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(set3)
# 统计集合元素数量len()
set1={1,2,3,4,5,5}
a=len(set1)
print(a)
# 集合的遍历,因为不支持下标索引，所有不能用while循环
set1={1,2,3,4,5,5}
for i in set1:
    print(i,end='')

字典的定义

# 定义字典字面量
{key:value,key:value,...}
# 定义字典变量
my_dict={key:value,key:value,...}
# 定义空字典
my_dict={}
my_dict=dict()

my_dict1={"王力宏":99,"周杰伦":88,"林俊杰":77}
print(my_dict1)
# 定义重复key的字典
my_dict1={"王力宏":99,"王力宏":88,"林俊杰":77}
print(my_dict1)
# 从字典中基于key获取value
my_dict1={"王力宏":99,"周杰伦":88,"林俊杰":77}
score=my_dict1["王力宏"]
print(score)
# 字典的嵌套，key不可为字典
stu_score_dict={
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":33
    },
    "周杰伦":{
        "语文":88,
        "数学":86,
        "英语":55
    },
    "林俊杰":{
        "语文":99,
        "数学":96,
        "英语":66
    }
}
score=stu_score_dict["周杰伦"]["语文"]
print(score)

字典的常用操作

# 新增元素:字典[key]=value
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
stu_score["张学友"]=66
print(stu_score)
# 更新元素:字典[key]=value
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
stu_score["王力宏"]=100
print(stu_score)
# 删除元素:字典.pop(key)，获得指定key的value
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
value=stu_score.pop("王力宏")
print(value)
print(stu_score)
# 清空字典:字典.clear()
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
stu_score.clear()
print(stu_score)
# 获取全部的key:字典.keys()
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
keys=stu_score.keys()
print(keys)
# 遍历字典
# 方式1:通过获取全部的key来完成遍历
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
keys=stu_score.keys()
for i in keys:
    print(stu_score[i])
# 方式2:直接对字典进行for循环
stu_score={
    "王力宏":77,
    "周杰伦":88,
    "林俊杰":99
}
for i in stu_score:
    print(stu_score[i])
# 统计字典的元素数量:len()
num=len(stu_score)

数据容器总结

• 是否支持下标索引

  • 支持:列表、元组、字符串 —序列类型
  • 不支持:集合、字典 —非序列类型

• 是否支持重复元素

  • 支持:列表、元组、字符串 —序列类型
  • 不支持:集合、字典 —非序列类型

• 是否支持修改

  • 支持:列表、集合、字典
  • 不支持:元组字符串

# 常用操作
max()
min()
转列表：list()
转元组：tuple()
转字符串：str()
转集合：set()
排序：sorted(容器),结果变成列表
     sorted(容器,reverse=True)

函数的多返回值

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

函数多种传参方式

# 位置参数
def user_info(name,age,gender):
    print(f"您的名字是：{name},年龄是{age},性别是{gender}")
user_info("tom","20","男") 

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

# 缺省参数，也叫默认参数，必须写在最后面
def user_info(name,age,gender="男"):
    print(f"您的名字是：{name},年龄是{age},性别是{gender}")
user_info("tom","20") 
user_info("rose","18","女") 

# 不定长参数，也叫可变参数
# 作用：当调用函数时不确定参数个数时，可以使用不定长参数
# 不定长参数的类型：位置传递(元组)和关键字传递(字典)
def user_info(*args):
    print(args)
user_info("Tom")
user_info("Tom",18)
# 关键字传递,参数要满足键=值，组成字典
def user_info(**kwargs):
    print(kwargs)
user_info(name="Tom",age=18,id=110)    

匿名函数

# 函数作为参数传递
def test_func(compute):
    result=compute(1,2)
    print(result)
def compute(x,y):
    return x+y
test_func(compute)

# lambda函数，只可临时使用一次
lambda 传入参数:函数体
# 传入参数表示匿名函数的形式参数，如x,y表示接受两个形参
# 函数体是函数的执行逻辑，只能写一行，无法写多行代码
def test_func(compute):
    result=compute(1,2)
    print(result)
test_func(lambda x,y:x+y)
    

文件

文件的编码

UTF-8：全球通用的编码格式

文件的读取

open(name,mode,encoding)

• name:要打开的目标文件名的字符串(可包含文件所在的具体路径)
• mode:设置打开文件的模式：只读、写入、追加等
• encoding：编码格式(推荐UTF-8)

示例代码：

f=open("python.txt","r",encoding="UTF-8")

• 三种模式

  • r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
  • w：打开一个文件只用于写入。如果该文件已存在则打开文件并从头开始编辑，原有内容会被删除。若该文件不存在，创建新文件
  • a：打开一个文件用于追加。若该文件已经存在，新内容被写入到已有内容之后。若该文件不存在，创建新文件进行写入。

# 打开文件
f=open("D:/测试.txt","r",encoding="UTF-8")
print(type(f))
# 读取文件-read()
print(f"读取10个字节的结果：{f.read(10)}")
print(f"read方法读取全部内容的结果是：{f.read()}")
# 读取文件-readlines()
lines=f.readlines() #读取文件的全部行，封装到列表中
print(f"lines对象的类型{type(lines)},lines的内容：{lines}")
# 读取文件-readline()
line1=f.readline()
# for循环读取文件行
for line in open("python.txt","r"):
    print(line)
# 关闭文件对象
f.close()
# with open语法
with open("python.txt","r") as f:
    for line in f:
        print(f"每一行数据是:{line}")

• read()方法:文件对象.read(num)

  • num表示要从文件中读取的数据的长度(单位是字节)，如果没传入num，则表示读取文件中的所有数据

• readlines()方法:可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

• readline()方法:一次读取一行内容

• with open语法:操作完成后自动close文件

文件的写入

# 打开文件
f=open("D:/python.txt","w",encoding="UTF-8")
# 文件写入
f.write("hello world")
# 内容刷新
f.flush()
f.close()  # close方法内置了flush方法

文件的追加

# 打开文件
f=open("D:/python.txt","a",encoding="UTF-8")
# 文件写入
f.write("\nhello world")
# 内容刷新
f.flush()
f.close()  # close方法内置了flush方法

异常

异常的捕获

# 基本语法，捕获全部异常
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码
    
# 快速入门
try:
    f=open('linux.txt','r',encoding="UTF-8")
except:
    print("出现异常了，改变了open模式 ")
    f=open('linux.txt','w',encoding="UTF-8")

# 捕获指定异常，只捕获NameError
try:
    print(name)
except NameError as e:
    print(e)
    print('name变量名称未定义错误')
# 捕获多个异常
try:
    print(1/0)
except (NameError,ZeroDivisionError) as e:
    print('出现变量未定义或ZeroDivisionError错误')
# 捕获全部异常
try:
    print(name)
except Exception as e: 
    print(e)
    print('出现异常')
    
# 异常else:表示如果没有出现异常要执行的代码
try:
    print(1)
except Exception as e:
    print(e)    
    print('出现异常')
else:
    print("我是else，没有出现异常")
# 异常的finally:表示是否异常都要执行的代码
try:
   f=open('linux.txt','r',encoding="UTF-8")
except Exception as e:
    print(e)    
    f=open('linux.txt','w',encoding="UTF-8")
else:
    print("我是else，没有出现异常")
finally:
    f.close()

异常的传递

def func1():
    print("func1 开始执行")
    num=1/0
    print("func1 结束执行")
def func2():
    print("func2 开始执行")
    func1()
    print("func2 结束执行")    
def main():
    try:
    	func2()
    except Exception as e:
        print(f"出现异常了，异常的信息是:{e}")
main()    

python模块

python模块(module)，是一个python文件，以.py结尾，能定义函数、类和变量，可当作工具包导入其他模块使用

模块的导入方式

[from 模块名] import [模块|类|变量|函数|*][as 别名]

常用的组合形式：

• import 模块名
• from 模块名 import 类、变量、方法等
• from 模块名 import *
• import 模块名 as 别名
• from 模块名 import 功能名 as 别名

# import模块名
import 模块名
import 模块名1,模块名2
模块名.功能名()
# 案例
import time
print("开始")
time.sleep(1)
print("结束")
# from 模块名 import 功能名
from time import sleep
print("开始")
sleep(1)
print("结束")
# from 模块名 import *
from time import *
print("开始")
sleep(1)
print("结束")
# 模块定义别名：import 模块名 as 别名
import time as tt
tt.sleep(2)
print("hello")
# 功能定义别名：from 模块名 import 功能 as 别名
from time import sleep as sl
sl(2)
print("hello")

自定义模块

不同模块功能重名

# 模块1代码
def my_test(a,b):
    print(a+b)
# 模块2代码
def my_test(a,b):
    print(a-b)
# 导入模块和调用功能代码
from my_mdule1 import my_test
from my_mdule2 import my_test
# 实际执行的是模块2中的test
my_test(1,1)

不想在导入模块时执行,既满足了测试功能，又满足了在外部导入时不会运行测试代码

# 模块1代码
def test(a,b):
    print(a+b)    
if __name__ == '__main__':
    test(1,2)

# 若一个模块文件中有'__all__'变量，当使用'from xxx import *'导入时，只能导入这个列表中的元素
# my_module1.py
__all__ = ['test_A']

def test_A():
    print("testA")
def test_B():
    print("testB") 
# test_my_module.py,里面只能用test_A函数
from my_module1 import *
test_A()

自定义python包

从物理上看，包就是一个文件夹，包含很多模块和一个__init__.py文件

import package.module

from package import module

from package.module import function1

在__init__.py中添加__all__=["xxx"]控制允许导入的模块列表

导入from 包名 import *，使用模块名.目标

安装第三方包

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

安装第三方包，cmd中

pip install 包名称

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

pycharm安装第三方包

Pycharm右下角–>解释器设置–>+号–>pandas–>选项-i https://pypi.tuna.tsinghua.edu.cn/simple

案例-数据可视化-折线图

json数据格式

• json是一种轻量级的数据交互格式
• json本质上是一个带有特定格式的字符串,就是字符串
• 负责不同编程语言中数据传递和交互
• json是一个单独的字典或者是内部元素都是字典的列表

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

import json
data=[{"name":"老王","age":16},{"name":"张三","age":20}]
# 把python数据转化成json数据
data=json.dumps(data,ensure_ascii=False)
print(data)
print(type(data))
# 把json数据转化成python数据
data=json.loads(data)
print(data)

pyecharts模块介绍及入门

官方网站pyecharts.org画廊网站gallery.pyecharts.org

• 基础折线图

  # 导包，导入Line功能构建折线图对象
  from pyecharts.charts import Line
  from pyecharts.options import TitleOpts,legend_opts,ToolboxOpts,VisualMapOpts
  # 得到折线图对象
  line=Line()
  # 添加x轴数据
  line.add_xaxis(["中国","美国","英国"])
  # 添加y轴数据
  line.add_yaxis("GDP",[30,20,10])
  # 设置全局配置项如下
  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),
  )
  # 生成图表
  line.render()
  

数据处理

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

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

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

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

# 去掉不合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']

# 获取日期数据，用于x轴，取2020年（到314下标结束）
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年（到314下标结束）
us_y_data = us_trend_data['list'][0]['data'][:314]
jp_y_data = jp_trend_data['list'][0]['data'][:314]
in_y_data = in_trend_data['list'][0]['data'][:314]

# 生成图表
line = Line()       # 构建折线图对象
# 添加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()

案例-数据可视化-地图

基础地图使用

from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts

# 准备地图对象
map = Map()
# 准备数据
data = [
    ("北京市", 99),
    ("上海市", 199),
    ("湖南省", 299),
    ("台湾省", 199),
    ("安徽省", 299),
    ("广州市", 399),
    ("湖北省", 599)
]
# 添加数据
map.add("地图", data, "china")
# 设置全局变量
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min": 1, "max": 9, "label": "1-9人", "color": "#CCFFFF"},
            {"min": 10, "max": 99, "label": "10-99人", "color": "#FFFF99"},
            {"min": 100, "max": 499, "label": "99-499人", "color": "#FF9966"},
            {"min": 500, "max": 999, "label": "499-999人", "color": "#FF6666"},
            {"min": 1000, "max": 9999, "label": "1000-9999人", "color": "#CC3333"},
            {"min": 10000, "label": "10000以上", "color": "#990033"}
        ]
    )
)

# 绘图
map.render()