本文主要是介绍Python学习(打基础版),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
以前只是大致的了解,现在比较完整的整理一下笔记,以后工作可能会用到。
学习地址如下所示: |
黑马程序员python教程,8天python从入门到精通,学python看这套就够了_哔哩哔哩_bilibili |
第一章 环境配置
1 初识Python
人生苦短,我用Python。由于Python的含义是蟒蛇,所以Python的Logo使用两个蟒蛇表示。
山东省已经将Python加入小学六年级的信息技术的课程之中。
2 编程语言
编程语言是与计算机进行交流的一种语言,可以将其视为一种编译器,写代码->翻译。
自然语言是比较麻烦的,因此使用编程语言是最简便的方式,使用固定的代码去表示固定的东西。关爱人工智障,人人有责。
3 Python环境安装
一.下载安装包(windows系统)
1.下载:以3.10.4版本为例,官方地址:Welcome to Python.org
2.进行安装
等待一分钟
3.验证是否安装成功
当看到相应的版本就可以得知,相应的python是安装好的。
4 "你好,世界"
win+r,输入cmd
出现的问题:
1.如果输入python并不能够出现版本号,则在进行安装的时候没有选中使用相应的环境变量的过程,需要在网上重新找一下教程,非常简单的。
卸载python的软件,我建议使用geek uninstaller这一款软件,可以卸载相应的注册表,下载地址如下:Geek Uninstaller官方下载_Geek Uninstaller官网下载_Geek Uninstaller电脑版下载
2.出现invaild character的时候,说明括号使用的并不是英文的,需要重新输入字符就可以了。
5 Python解释器
1.Python解释器就是将相应的Python代码解释为二进制,之后进行提交执行的过程。
上面的应用程序.exe文件就是相应的解释器。
2.Python解释器的使用
(1)首先将文档的扩展名展示出来
(2)声明一个.txt结尾的文件
(3)将.txt文件改成.pt文件
(4)出现错误
把刚才文档之中的汉字改为英文就可以了。
6 Python
一.开发环境
1.程序的下载,第三方开发工具PyCharm:JetBrains: Essential tools for software developers and teams
2.程序的安装
安装位置:
点击运行 - 同意 - 不发送
3.程序的环境
4.程序的创建
5.执行
二.配置
1.主题
2.字体大小
字体大小方式2
3.中文版界面
4.翻译 选中单词,右键翻译
5.快捷键
shift + alt + 上/下:移动当前句
shift + alt + f10 :运行当前代码
第二章 基础语法
(本章节和C、C++、Java差不多,不做过多解释,只写重点)
-
字面量(固定的值)
-
注释
单行注释:#+注释内容,#与注释内容间有空格---规范
多行注释:""" 注释内容 """
- 变量
程序运行的过程中,用来记录数据的。
# 定义一个变量,用来记录
money = 50# 买了一个奶黄包,还剩多少钱
money = money - 10print("还有多少钱:", money, "元")
-
数据类型
type()直接输出相关的数据类型
name = "心若不欺,必然扬眉吐气!"
string_name = type(name)
print(string_name)
-
数据类型转换
int(x) float(x) str(x),字符串
# 将数字转换为相应的字符串类型
num_str = str(11)
print(type(num_str), num_str)
-
标识符
不建议使用中文,不能够使用数字进行开头,大小写敏感,不可以使用关键字
-
运算符
/:取除法
//:取整除
**:取指数
print("11/2", 11/2)
print("11//2", 11//2)
print("3**2", 3**2)
-
字符串的三种定义
单引号,双引号,三引号定义法
# 单引号定义法
name = '老刘打羽毛球'
print(name)# 双引号定义法
name = "老姚找对象去了"
print(name)# 三引号定义法
name = """
老田这个胖子,
晚上打王者荣耀输了,
坑坑捶墙
"""
print(name)
打印相应的单引号与双引号的方法有两种
# 在字符串内 包含单引号
name = "'老田去了杭州的海康威视'"
# 在字符串内 包含双引号
name = '"老姚去了北京"'
# 转义字符的使用
name = "\"老刘去地下工作了\""
-
字符串的拼接与格式化
1.拼接过程直接使用“+”就是可以的,字符串只能和字符串进行拼接。
2.占位拼接,%:占位,s:将变量变为字符串的地方,d:整数,f:浮点型
class_id = 1701
name_id = 201705090102
message = "我在测控卓越%s班,学号是%s" % (class_id, name_id)
print(message)
3.精度控制:m.n:m是宽度,n为小数
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)
4.精度控制:快速写法语法:f"内容{变量}"的格式进行快速格式化,不限数据类型,不做精度控制
shazi = 2
print(f"老姚是{shazi}傻子")
-
表达式的格式化
概念比较简单,直接使用
# 定义需要的变量
name = "老姚"
daletou_price = 20
daletou_paper = 2
# 输出
print(f"{name}买了{daletou_paper}张大乐透,花了{(daletou_price*daletou_paper)}元" )
-
数据输入
input():你是我是谁,我是没头脑!
print("请告诉我你是谁?")
name = input()
print("我知道了,你是:%s" % name)
第三章 判断语句
(本章节和C、C++、Java差不多,不做过多解释,只写重点)
-
布尔类型和比较运算符
这个地方时比较好理解的,不做过多记录
# 定义的方法
zhen = True
jia = False
print(f"zhen的变量内容是:{zhen},类型是{type(zhen)}")
print(f"jia的变量内容是:{jia},类型是{type(jia)}")# 比较运算法
print(f"1000>=50? {1000>=50}")
-
if语句的基本格式
if 要判断的条件:
条件成立时,要做的事情
age = 18
if age >= 18:print("可以考驾照")print("可以写入党申请书")
have_passid = "是"
input_pass = input()
PD = have_passid == input_passprint(f"""
欢迎来到天津大学,有校园卡可以进入,没有校园卡需要申请。
请输入是否有校园卡:{PD}""")
if PD:print("欢迎来到七里台男子职业技术学院")
-
if_else组合判断语句
使用方式见下面的代码
age = int(input("请输入你的年龄:"))
if age >= 18:print("可以去考驾照了")
else:print("年龄不够,不能考取驾照,去打王者荣耀吧")
-
if_elif_else组合使用
1.多条件判断方式
age = int(input("请输入你的年龄:"))
if age >= 60:print("可以养老")
elif age >= 23:print("可以找女朋友")
elif age >= 18:print("可以考驾照")
elif age >= 14:print("可以打王者")
else:print("你还小,只能看看天线宝宝")
2.练习题-----自己想的题目
A与B两个人说晚饭要吃啥,A猜想B的心理想的什么,只有三次机会。猜错重新猜,猜对则输出。
dinner_B = "地三鲜"
if str(input("请猜:"))=="地三鲜":print("真默契,上来就猜对了")
elif str(input("不对,接着猜:")) == "地三鲜":print("对了")
elif str(input("还不对,接着猜:")) == "地三鲜":print("终于猜对了")
else:print("我想的是地三鲜,没默契,不跟你吃饭了,哈哈哈哈哈")
-
判断语句的综合嵌套
1.嵌套的关系是通过缩进进行区别的
2.嵌套判断代码
age = input("请输入您的您的年龄:")
if int(age) >= 18:print("老紫成年人")if int(age) <= 30:print("青年人")else:print("不是青年人")
else:print("还是个孩子")
3.例题
案例需求:
定义一个数字(1~10,随机产生),通过3次判断来猜出来数字
案例要求:
1. 数字随机产生,范围1-10
2. 有3次机会猜测数字,通过3层嵌套判断实现
3. 每次猜不中,会提示大了或小了
# 1.构建一个随机的数字
import random
num = random.randint(1,10)# 2.输入猜测的数字
guess_num = int(input("请进行第一次猜测数字:"))# 3.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:if (guess_num > num):print("猜的数字太大了")else:print("猜的数字太小了")
第四章 循环语句
(本章节和C、C++、Java差不多,不做过多解释,只写重点)
-
while循环
1.格式
2.简单的使用
i = 0
while i < 100:print("小美,双面龟喜欢你!")i += 1
3.输出1-100的数量和
i = 1
sum = 0
while i <= 100:sum = sum + ii += 1if i == 101:print(sum)
4.猜数字的案例:
设置一个范围1-100的随机整数变量,通过while循环,配合input语句,判断输入的数字是否等于随机数
- 无限次机会,直到猜中为止
- 每一次猜不中,会提示大了或小了
- 猜完数字后,提示猜了几次
- 无限次机会,终止条件不适合用数字累加来判断
- 可以考虑布尔类型本身(True or False)
- 需要提示几次猜中,就需要提供数字累加功能
# 1.引入随机数字1-100之间的数
import random
num = random.randint(1,100)# 2.定义一个数字,记录猜的次数
count = 0# 3.进行标志位定义
flag = True# 4.进行循环
while flag:guess_num = int(input("请输入猜的数字:"))count += 1if guess_num == num:print(f"猜对了,猜的次数为{count}")flag = False # 退出循环else:if guess_num > num:print("猜的数字太大了")else:print("猜的数字太小了")
剩余的几个例题是同样的道理,就不写了
-
for循环
1.示例格式
# 定义字符串name
name = "zhuzhuxia"# for循环处理字符串
for x in name:print(x)
2.判断字符串之中存在多少个字母a
# 定义字符串name
name = "itheima is a brand of itcast"# 定义一个变量,看里面有多少个字母a
count = 0# for循环处理字符串
for x in name:if x == "a":count += 1print(f"一共有{count}个字母a")
3.for的嵌套循环
-
range语句->序列
1.语法
①range(num):range(5)->[0,1,2,3,4]
②range(num1,num2):range(5,10)->[5,6,7,8,9]
③range(num1,num2,step):range(5,10,2)->[5,7,9]
-
continue和break使用
1.continue:结束本次循环,break:结束循环
第五章 函数
(本章节和C、C++、Java差不多,不做过多解释,只写重点)
-
函数
1.定义:已组织好,可重复使用,针对特定功能
① 参数如不需要,可以省略(后续章节讲解)
② 返回值如不需要,可以省略(后续章节讲解)
③ 函数必须先定义后使用
2.举例说明
# 定义一个函数,输出相关的信息
def say_hi():print("学Python,就去哔哩哔哩白嫖黑马程序员")# 调用
say_hi()
-
函数传入参数
比较简单,直接写代码,不做过多记录
# 定义一个函数,输出相关的信息
def add(x,y):result = x + yprint(f"{x} + {y} = {result}")# 使用函数
add(1,5)
-
函数返回参数
1.定义语法
注意:函数体只要是遇到return,后面的代码是不会进行执行的。
2.函数返回值None
其含义就是在函数之中,无论是否写了return,都是存在返回值的
# 无返回值函数
def return_result():print("返回")result = return_result()# 使用函数
print(f"无返回值函数返回的值:{result}")
print(f"无返回值函数返回的类型:{type(result)}")
注意:None可以视为False,在使用if进行判断时
-
函数说明文档
-
函数嵌套使用
在一个函数之中调用了另一个函数的使用。
-
变量在函数中的作用域
局部变量:出了函数体不能够使用的变量
全局变量:函数体内外都能够正常使用的变量 函数内直接global关键字的使用
第六章 数据容器
-
容器
一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素 每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
数据容器根据特点的不同,如: 是否支持重复元素、是否可以修改、是否有序
-
列表(list)
1.定义方式
注意:列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
2.代码演示
# 定义一个列表
my_list = ["考虫",299,True]# 打印输出
print(f"元素为:{my_list} 类型为:{type(my_list)}")
3.下标索引
两种方式:
方式一:正向遍历
方式二:反向遍历
注意针对于嵌套的而言,可以使用双重索引进行使用,和别的语言是一样的使用方式
4.列表的特定方法
(a)方法的概念
在函数之中,如果要是将函数定义为相应的class类的成员,那么函数就是会称之为方法。使用方法如下所示:
class Student:def add(self,x,y):return x + ystudent = Student()
print(f"1+5={student.add(1,5)}")
(b)查询功能:查找某个元素的下标,在进行查询的时候,需要注意查找最后一个元素的方式为下标[-1]
I.功能:查找指定元素在列表的下标,如果找不到,报错ValueError
语法:列表.index(元素) ->index就是列表对象(变量)内置的方法(函数)
# 定义一个列表
my_list = ["考虫",299,True]# 打印输出
print(f"考虫的索引为:{my_list.index('考虫')} ")
注意:上述代码中的index之中的考虫需要''索引好,跟视频之中不一样
II.如果查询不到,会报出错误
# 定义一个列表
my_list = ["考虫",299,True]# 打印输出
print(f"考虫的索引为:{my_list.index('小猪佩奇身上纹')} ")
(c)
(c)修改list之中的值
# 定义一个列表
my_list = ["考虫",299,True]# 进行修改的操作
my_list[0]="新东方"# 打印输出
print(f"考虫的索引为:{my_list} ")
(d)在list之中插入值 insert(下标,元素),在
# 定义一个列表
my_list = ["考虫",299,True]# 进行插入的操作 第一个元素的含义是在第一个元素前面进行插入
my_list.insert(0,"考研英语")# 打印输出
print(f"考虫的索引为:{my_list} ")
(e)追加元素,将元素插入到末尾的位置 append(元素)
# 定义一个列表
my_list = ["考虫",299,True]# 进行插入的操作 第一个元素的含义是在第一个元素前面进行插入
my_list.append("去哔哩哔哩,白嫖黑马程序员")# 打印输出
print(f"考虫的索引为:{my_list} ")
(f)追加一批元素 extend([元素])
# 定义一个列表
my_list = ["考虫",299,True]# 进行插入的操作 第一个元素的含义是在第一个元素前面进行插入
my_list.extend(["新东方",199,False])# 打印输出
print(f"考虫的索引为:{my_list} ")
(g)元素的删除 del 指定元素
# 定义一个列表
my_list = ["考虫",299,True]# 删除元素
del my_list[2]# 打印输出
print(f"考虫的索引为:{my_list} ")
(h)元素的删除,并且可以得到删除的那个元素值 pop(下标)
# 定义一个列表
my_list = ["考虫",299,True]# 删除元素
pop_element = my_list.pop(0)# 打印输出
print(f"删除之后:{my_list},删除的元素为:{pop_element} ")
(i)元素的删除,制指定的某个元素进行删除 move(元素)
# 定义一个列表
my_list = ["考虫",299,True]# 删除元素
my_list.remove(299)# 打印输出
print(f"删除之后:{my_list} ")
(j)列表的清空 clear()
# 定义一个列表
my_list = ["考虫",299,True]# 清空元素
my_list.clear()# 打印输出
print(f"清空之后:{my_list} ")
(k)统计某一元素的数量 count(元素)
# 定义一个列表
my_list = ["考虫",299,True,"孙悟空","猪八戒","沙僧","孙悟空"]# 元素个数
count = my_list.count("孙悟空")# 打印输出
print(f"元素个数:{count} ")
(l)统计列表织鬃所有的元素的个数
# 定义一个列表
my_list = ["考虫",299,True,"孙悟空","猪八戒","沙僧","孙悟空"]# 元素个数
count = len(my_list)# 打印输出
print(f"元素个数:{count} ")
5.列表的循环遍历
(a)使用while循环遍历
def list_while_func():"""使用while循环遍历列表:return: None"""my_list = ["考虫",299,True,"孙悟空","猪八戒","沙僧","孙悟空"]index = 0while index < len(my_list):element = my_list[index]print(f"列表的元素为:{element}")index += 1list_while_func()
(b)使用for循环遍历
def list_for_func():"""使用while循环遍历列表:return: None"""my_list = ["考虫",299,True,"孙悟空","猪八戒","沙僧","孙悟空"]for element in my_list:print(f"列表的元素为:{element}")list_for_func()
-
元组(tuple)
1.元素的定义
元组和列表是一样的,都是可以封装多个、不同类型的元素在内。但是最大的不同点再远:元组一旦定义完成,就不可修改。
2.定义语法
注意:I 元组要是定义单个元素的时候,后面必须要加一个逗号
t1 = ("二傻子")# 定义单个元组
t2 = ("二傻子",)
print(f"t1的类型为{type(t1)},t2的类型为{type(t2)}")
II 同list可以进行嵌套,可以使用取索引取出内容,可以使用index方式查找,count统计,len函数查询长度。
-
字符串(str)
方法之中使用下标的方式取值和index方式取值以及len()、count()前面已经得知,不做过多记录。
1.替换 replace(被替换的元素,替换成为的元素)
str = ("Hello, it is my honor to paticipate in this interview! My name is Yang and I come from CangZhou")# replace方法
new_str = str.replace("CangZhou","Tianjin")print(f"{new_str}")
2.分割方法 split(元素)
str = ("Hello, it is my honor to paticipate in this interview! My name is Yang and I come from CangZhou")# split方法
new_str = str.split(" ")print(f"{new_str}")
3.去除操作 strip()
a.字符串.strip():直接去除原始字符串前后的空格
b.字符串.strip(字符串):去除字符串
str = ("123 Hello, it is my honor to paticipate in this interview! My name is Yang and I come from CangZhou 321")# strip方法
new_str = str.strip("132")print(f"{new_str}")
注意:使用的过程中,strip("字符串"),字符串是单个的字符串,只要单个一致便可以去除。
4.序列
I.定义:序列是指内容连续、有序,可以使用下标进行索引的一类数据容器。
II.语法
# 对list进行切片,从1开始,4结束,步长为1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4] # 步长默认为1,可以省略不写
print(f"结果1:{result1}")# 对tuple进行切片,从头开始,最后结束,步长为1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾,步长为1可以省略
print(f"结果2:{result2}")# 对str进行切片,从头开始,到最后结束,步长为2
my_str = "0123456"
result3 = my_str[::2]
print(f"结果3:{result3}")# 对str进行切片,从头开始,最后结束,步长为-1
my_str = "0123456"
result4 = my_str[::-1] # 等同于将字符串进行翻转
print(f"结果4:{result4}")# 对列表进行切片,从3开始,到1结束,步长为-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1] # 步长默认为1,可以省略不写
print(f"结果5:{result5}")# 对元组进行切片,从头开始,到尾结束,步长为-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2] # 起始和结束不写表示从头到尾,步长为1可以省略
print(f"结果6:{result6}")
-
集合(set)
1.集合的定义
a.为什么要学习set?
b.集合的特点:内部无序,并且是元素不重复
c.定义过程
# 集合的定义
my_set = {"孙悟空","猪八戒","林黛玉","贾宝玉","林黛玉","贾宝玉"}
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)}")
2.集合的操作
a.修改 add(元素)
b.移除 remove(元素)
c.随机取出一个元素 pop()
d.清空集合 clear()
e.取出2个集合的差集 .differernce(集合)
# 取2个集合的差集
my_set1 = {"孙悟空","猪八戒","林黛玉","贾宝玉","林黛玉","贾宝玉"}
my_set2 = {"孙悟空","林黛玉","贾宝玉"}
set3 = my_set1.difference(my_set2)
print(f"两个集合的差集为:{set3}")
f.消除差集,集合1.difference_update(集合2):在集合1内删除掉共有的元素
# 消除差集
my_set1 = {"孙悟空","猪八戒","林黛玉","贾宝玉","林黛玉","贾宝玉"}
my_set2 = {"孙悟空","林黛玉","贾宝玉"}
set3 = my_set1.difference_update(my_set2)
print(f"消除差集为:{set3}")
g.2个集合进行合并 集合1.union(集合2)
# 合并集合
my_set1 = {"孙悟空","猪八戒","林黛玉","贾宝玉","林黛玉","贾宝玉"}
my_set2 = {"孙悟空","林黛玉","贾宝玉","老姚"}
set3 = my_set1.union(my_set2)
print(f"合并集合为:{set3}")
h.统计集合元素的数量 len(集合)
i.集合的遍历 由于不支持下标索引,因此进行索引的时候,只能够使用for
-
字典(dict)
1.字典的定义
2.特点
字典之中的Key是不可以重复的,若重复只保留后面的Key。
不可以使用下标索引。
使用Key进行索引。
3.字典的嵌套
字典的Key和Value都是可以为任意的数据类型,Key是不可以为字典的。
4.字典的常用操作
由于本处是进行Key与Value同时操作,因此,这个地方的代码与前方是不一样的,进行全部记录
"""
演示字典的常用操作
"""
my_dict = {"老姚":82,"老田":80,"老刘":90}# 新增元素
my_dict["老马"] = 85
print(f"字典经过新增元素之后,结果为:{my_dict}")# 更新元素
my_dict["老马"] = 0 # 老马作弊了,成绩直接变为0# 删除元素
Liu = my_dict.pop("老刘")
print(f"字典中被移除了一个元素,结果是:{my_dict},移除的分数为:{Liu}")# 清空元素,clear()# 获取全部的Key
keys = my_dict.keys()
print(f"字典之中全部的keys是:{keys}")# 遍历字典
for key in keys:print(f"字典之中的Key是:{key}")print(f"字典之中的Value是:{my_dict[key]}")# 统计字典内的元素数量
num = len(my_dict)
print(f"字典之中的元素有{num}个")
-
容器的拓展
1.数据容器的特点对比
2.字符串比较
字符串进行比较的过程是进行按位比较的
第七章 函数进阶
-
函数的多返回值
1.表示形式
2.函数参数的种类
a.位置参数:调用函数时根据函数定义的参数位置来传递参数
b.关键字参数:函数调用时通过“键=值”形式传递参数
作用: 可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求
c.缺省参数:缺省参数也叫默认参数,用于定义函数,为参数提供默认值,调用函数时可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)
作用: 当调用函数时没有传递参数, 就会使用默认是用缺省参数对应的值
d.不定长参数:不定长参数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
作用: 当调用函数时不确定参数个数时, 可以使用不定长参数
I.位置传递
注意:
①传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是位置传递
②位置的不定长传递以*号标记一个形式参数,以元组的形式接受参数,参数的一般命名为args
II.关键字传递
注意:
①参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典
②关键字不定长传递以**编辑一个形式参数,以字典的形式接受参数,形式参数一般命名为kwargs
-
匿名函数
1.函数作为参数传递
函数作为参数进行使用的过程是比较简单的,是对于计算逻辑进行相应的传递,不做过多记录
2.lambda匿名函数
a.普通函数与lambda函数之间的区别
①函数的定义中 def关键字,可以定义带有名称的函数
②lambda关键字,可以定义匿名函数(无名称)
③有名称的函数,可以基于名称重复使用。
④无名称的匿名函数,只可临时使用一次
b.lambda函数的定义语法
lambda 是关键字,表示定义匿名函数
传入参数表示匿名函数的形式参数,如:x, y 表示接收2个形式参数
函数体,就是函数的执行逻辑->注意:只能写一行,无法写多行代码
c.具体使用对比
第八章 文件操作
-
文件编码
编码技术即:翻译的规则,记录了如何将内容翻译成二进制,以及如何将二进制翻译回可识别内容
编码就是一种规则集合,记录了内容和二进制间进行相互转换的逻辑。 编码有许多中,我们最常用的是UTF-8编码
-
文件读取 r
1.打开文件open()
name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)
mode:设置打开文件的模式(访问模式):只读、写入、追加等
encoding:编码格式(推荐使用UTF-8)
# open()打开文件
f = open("D:/要长脑子.txt", "r", encoding="gbk")
2.读取方法
a.read(字节数)
# open()打开文件
f = open("D:/要长脑子.txt", "r", encoding="gbk") # 读取文件read()
print(f"读取10个字节:{f.read(7)}") # 读取7个字节
print(f"读取后面的:{f.read()}") # 读取从上个位置开始之后全部的内容
b.readLines()
# open()打开文件
f = open("D:/要长脑子.txt", "r", encoding="GBK")# 读取文件readLines()
lines = f.readlines()
print(f"按照行进行读取:{lines}")
print(f"按照行进行读取的类型为:{type(lines)}")
c.readline()
# open()打开文件
f = open("D:/要长脑子.txt", "r", encoding="GBK")# 读取文件readLine()
line = f.readline()
print(f"按照行进行读取:{line}")
print(f"按照行进行读取的类型为:{type(line)}")
d.for循环读取文件行
# open()打开文件
f = open("D:/要长脑子.txt", "r", encoding="GBK")# 读取文件for
for line in f:print(f"按照行进行读取:{line}")
e.文件的关闭,直接调用
I.直接调用文件.close()
II.使用with 函数,使用结束后,自动关闭
import time# 读取文件for
with open("D:/要长脑子.txt", "r", encoding="GBK") as f:for line in f:print(f"按照行进行读取:{line}")time.sleep(121212)
-
文件的写出 w
直接调用write,内容并未真正写入文件,而是会积攒在程序的内存中,称之为缓冲区
当调用flush的时候,内容会真正写入文件
这样做是避免频繁的操作硬盘,导致效率下降(攒一堆,一次性写磁盘)
注意:
①文件如果不存在,使用”w”模式,会创建新文件
②文件如果存在,使用”w”模式,会将原有内容清空
③close()内置了flush()功能
-
文件的追加 a
如果要是加入相应的换行,直接使用一个\n
第九章 异常模块与包
-
异常
1.异常的定义
a.异常(Bug):当检测到一个错误时,Python解释器就无法继续执行了,反而出现了一些错误的提示
b.为什么异常叫做Bug?
1945年9月9日,下午三点,马克二型计算机无法正常工作了,技术人员试了很多办法,最后定位到第70号继电器出错。负责人哈珀观察这个出错的继电器,发现一只飞蛾躺在中间,已经被继电器打死。她小心地用摄子将蛾子夹出来,用透明胶布帖到“事件记录本”中,并注明“第一个发现虫子的实例。”自此之后,引发软件失效的缺陷,便被称为Bug。
早起的马克二号计算机
c.异常的示例
2.异常的捕获
a.当我们的程序遇到了BUG, 那么接下来有两种情况:
① 整个程序因为一个BUG停止运行
② 对BUG进行提醒, 整个程序继续运行(异常的捕获)
b.语法
c.示例
d.捕获指定异常
e.捕获多个异常
f.捕获所有异常
g.异常else
h.异常finally:有没有异常都要执行
3.异常的传递
利用异常具有传递性的特点, 当我们想要保证程序不会因为异常崩溃的时候, 就可以在main函数中设置异常捕获, 由于无论在整个程序哪里发生异常, 最终都 会传递到main函数中, 这样就可以确保所有的异常都会被捕获
在最顶级的地方进行调用
-
模块
1.模块的定义
模块(Module),是一个 Python 文件,以 .py 结尾. 模块能定义函数,类和变量,模块里也能包含可执行的代码
2.模块的作用
Python中有很多各种不同的模块, 每一个模块都可以帮助我 们快速的实现一些功能, 比如实现和时间相关的功能就可以使用time模块 我们可以认为一个模块就是一个工具包, 每一个工具包中都有各种不同的 工具供我们使用进而实现各种不同的功能
3.模块的导入
4.基本语法
a.import模块名
b.from 模块名 import 功能名
c.from 模块名 import *
d.as定义别名
5.自定义模块
a.自定义模块
注意事项:当导入多个模块的时候,且模块内有同名功能. 当调用这个同名功能的时候,调用到的是后面导入的模块的功能
b.无论是当前文件,还是其他已经导入了该模块的文件,在运行的时候都会自动执行`test`函数的调用
c.部分导入方式
如果一个模块文件中有`__all__`变量,当使用`from xxx import *`导入时,只能导入这个列表中的元素
-
Python包
1.自定义包
a.定义
①从物理上看,包就是一个文件夹,在该文件夹下包含了一个 __init__.py 文件,该文件夹可用于包含多个模块文件
②从逻辑上看,包的本质依然是模块
b.作用:当我们的模块文件越来越多时,包可以帮助我们管理这些模块, 包的作用就是包含多个模块,但包的本质依然是模块
c.创建的过程
d.导入包的方式
方式一:
方式二:必须在`__init__.py`文件中添加`__all__ = []`,控制允许导入的模块列表
2.第三方包
a.演示安装第三方包 numpy
windows+R - 输入cmd - pip install numpy
如果国内的网站太慢的话,可以使用下面的命令链接国内的网站进行包的安装:
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
b.测试安装情况
c.软件之中进行安装
安装中
第十章 数据可视化-折线图
-
JSON格式说明
1.JSON格式的说明:
①JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
②JSON本质上是一个带有特定格式的字符串
主要功能:进行各个语言间的数据流通的数据格式,负责不同编程语言中的数据传递和交互。
2.JSON格式数据转换
3.Python数据和Json数据的相互转化
上面的过程是比较容易理解的,不作过多解释。
"""
演示将JSON格式的数据与Python格式的数据进行相互的转换
"""# 引入相应的JSON库函数
import json# 准备数据 列表形式
data = [{"name":"小土豆","age":"18"}, {"name":"大地瓜","age":22}, {"name":"铁憨憨","age":90},{"name":"大聪明","age":88}]
json_str = json.dumps(data,ensure_ascii=False) # ensure_ascii=False保证输出的为文字
print(type(json_str))
print(json_str)# 准备数据 字典类型
data = {"name":"小土豆","age":"18"}
json_str = json.dumps(data,ensure_ascii=False) # ensure_ascii=False保证输出的为文字
print(type(json_str))
print(json_str)
# 将JSON格式的数据转换为Python格式数据
s = '[{"name":"小土豆","age":"18"}, {"name":"大地瓜","age":22}, {"name":"铁憨憨","age":90},{"name":"大聪明","age":88}]'
l = json.loads(s)
print(type(l))
print(l)# 将JSON格式的数据转换为Python格式数据
s = '{"name":"小土豆","age":"18"}'
l = json.loads(s)
print(type(l))
print(l)
-
pyecharts模块
1.简介
Echarts 是个由百度开源的数据可视化,凭借着良好的交互性,精巧的图表设计,得到了众多开发者的认可. 而 Python 是门富有表达力的语言,很适合用于数据处理. 当数据分析遇上数据可视化时pyecharts 诞生了.
2.官方网站
网站一:pyecharts - A Python Echarts Plotting Library built with love.Descriptionhttps://pyecharts.org/#/
网站二:DocumentDescriptionhttps://gallery.pyecharts.org/#/README
3.安装
安装过程爆出错误
解决办法
由于使用终端安装总是存在问题,所以我使用软件进行安装
-
生成折线图
1.基础折线图
# 导包,导入Line功能构建折线图对象
from pyecharts.charts import Line# 得到折线图对象
line = Line()# 添加x轴数据
line.add_xaxis(["中国","美国","英国"])# 添加y轴数据
line.add_yaxis("GDP",["30","20","10"])# 生成折线图表
line.render()
将html文件使用谷歌浏览器打开
2.全局配置
set_global_opts方法
# 导包,导入Line功能构建折线图对象
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"])# 设置全局全局配置
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()
3.案例使用
"""
演示可视化需求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()
第十一章 数据可视化-地图
"""
演示全国疫情可视化地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *# 读取数据文件
f = open("D:/疫情.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))# 创建地图对象
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~9999人", "color": "#FFFF99"},{"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},{"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},{"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},{"min": 100000, "lable": "100000+", "color": "#990033"},])
)
# 绘图
map.render("全国疫情地图.html")
第十二章 数据可视化-动态柱状图
1.基础柱状图
Timeline()-时间线
"""
基础柱状图
"""
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")
2.基础时间线柱状图
"""
带有时间线的柱状图
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeTypebar1 = 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")
3.动态柱状图的绘制
列表的sort方法
列表.sort(key=选择排序依据的函数, reverse=True|False) 参数key,是要求传入一个函数,表示将列表的每一个元素都传入函数中,返回排序的依据
参数reverse,是否反转排序结果,True表示降序,False表示升序
"""
GDP动态柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType# 读取数据
f = open("D:/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])# print(data_dict[1960])# 创建时间线对象
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}年全球前8GDP数据"))timeline.add(bar, str(year))# for循环每一年的数据,基于每一年的数据,创建每一年的bar对象
# 在for中,将每一年的bar对象添加到时间线中# 设置时间线自动播放
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")
第十三章 面向对象
(本章学习的时候,可以思考之前学过的C++和Java语言,很相似)
-
对象
# 设计一个类(类比生活中,设计一张登记表)
class Student:name = None # 记录姓名gender = None # 记录性别nationality = None # 记录国籍native_place = None# 记录地区age = None # 记录年龄# 创建对象(类比打印登记表)
stu_1 = Student()# 对象赋值(类比填表)
stu_1.name = "老马"
stu_1.gender = "貌似是男生" # 哈哈哈
stu_1.nationality = "中国"
stu_1.native_place = "青海"
stu_1.age = 25# 获取对象之中的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)
-
类的成员方法
1.类的定义
2.成员变量和成员方法
成员方法访问成员变量需要使用self进行调用。
注意事项:
-
类和对象
-
构造方法
1.定义
__init__()方法,称之为构造方法。
特性:
①在创建类对象(构造类)的时候,会自动执行。
②在创建类对象(构造类)的时候,将传入参数自动传递给__init__方法使用。
2.使用案例
注意:
①构造方法名称:__init__ __init__ __init__ , 千万不要忘记init前后都有2个下划线
②构造方法也是成员方法,不要忘记在参数列表中提供:self
-
魔术方法
__str__方法:改变为输出转变字符串的行为
class Person:def __init__(self,name,age):self.name = nameself.age = age# __str__魔术方法def __str__(self):return f"{self.name}是一个{self.age}的老男人"person_1 = Person("老刘",27)print(person_1)
print(str(person_1))
__lt__ 小于符号比较方法:
class Person:def __init__(self,name,age):self.name = nameself.age = age# __lt__魔术方法def __lt__(self, other):return self.age < other.ageperson_1 = Person("老刘",27)
person_2 = Person("老姚",26)print(person_1 < person_2)
__le__ 小于等于比较符号方法:
class Person:def __init__(self,name,age):self.name = nameself.age = age# __le__魔术方法def __le__(self, other):return self.age <= other.ageperson_1 = Person("老刘",27)
person_2 = Person("老姚",26)print(person_1 <= person_2)
__eq__比较运算符实现方法:
class Person:def __init__(self,name,age):self.name = nameself.age = age# __eq__魔术方法def __eq__(self, other):return self.age == other.ageperson_1 = Person("老刘",27)
person_2 = Person("老姚",26)print(person_1 == person_2)
-
封装
1.定义
封装表示的是,将现实世界事物的属性、行为,封装到类中,描述为 成员变量 成员方法,从而完成程序对现实世界事物的描述
2.私有成员
a.私有成员变量:变量名以__开头(2个下划线)
私有成员方法:方法名以__开头(2个下划线)
b.使用方式
-
继承
1.格式
单继承
多继承
2.单继承
3.多继承
注意:pass的关键字是用来补全语法的
4.多继承的注意事项
多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级(先继承的保留,后继承的被覆盖)
5.复写
在子类中重新定义同名的属性或方法即可
6.调用父类同名成员
一旦复写父类成员,那么类对象调用成员的时候,就会调用复写后的新成员
方式1: 调用父类成员
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
方式2: 使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法()
-
类型注解
1.变量的类型注解
a.基础语法
变量: 类型
注意:
①元组类型设置类型详细注解,需要将每一个元素都标记出来
②字典类型设置类型详细注解,需要2个类型,第一个是key第二个是value
b.类型注解语法
# type: 类型
类型注解只是一个备注,不会影响程序的执行。
2.函数和方法注解
a.形参注解
b.返回值注解
3.Union联合类型的注解
Union[类型, ......, 类型]
-
多态
1.定义
多种状态,即完成某个行为时,使用不同的对象会得到不同的状态
2.抽象类
抽象类:含有抽象方法的类称之为抽象类
抽象方法:方法体是空实现的(pass)称之为抽象方法
这篇关于Python学习(打基础版)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!