python基础学习-2进阶

一.编程第一步

1.1斐波纳契数列。

#coding utf-8
#author ****
a = 0
b = 1
while b < 10:           #进入while后上方初始变量无意义
    print(b)
    a, b = b, a+b       #a的定义不会影响当前a+b的值,只能影响下一次
#特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。

等同于
#coding utf-8
#author ****
a = 0
b = 1
while b < 10:
    print(b)
    n = b              
    m = a + b          ##第一次是0+1,调用外部变量,所以会出现俩次1
    a = n
    b = m

result:  
1                       
1                         
2                         
3                         
5
8

#coding utf-8
#author ****
a = 0
b = 1
while b < 10:
    print(b)
    a = b
    b = a+b
result：
1
2
4
8

1.2 猜数字

#coding utf-8
#author ****
target = random.randint(1,100)
fail = 1
success = False
while fail <= 3:
    print("*" * 20)
    user_num = int(input(f"这是{fail}次,请输入心中所想数字:"))
    if not str(user_num).isnumeric():              #判断输入内容是否为整形
        print("你输入的不是数字,请重新输入。")
        continue
    if  user_num == target:
        print("恭喜猜对了")
        success = True
        break
    elif user_num < target:
        print("猜小了")
    else:
        print("猜大了")

    fail += 1                                #不能写在if判断体系内就是结束一次加一次
if  not success:
    print(f"遗憾没有猜对,正确数字为:{target}")

1.3 while 循环

语法：
while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
--案例
#!/usr/bin/python3
 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
   #count的大小+1
else:
   print (count, " 大于5")
   #当count大于五时输出else的内容

1.4 for循环

Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：
for <variable> in <sequence>:
    <statements>
else:
    <statements>
    
--案例
for x in range(6):
  print(x)
else:
  print("Finally finished!")


--案例
#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
        #如果site得到的列表内容为"Runoob".则结束循环
    print("循环数据 " + site)
    #不匹配if条件的都会输出此内容+为输出site内容
else:
    print("没有循环数据!")
    #此内容不会输出,因为循环没有结束,但是无法结束.因为site匹配ruoob时已经结束.无法进行最后一项的循环
print("完成循环!")

2.函数

2.1 函数定义

"""
函数，就是给一段代码起一个名字，可以独立的调用、可以重复的使用这段代码
使用函数，让程序的编写、阅读、升级都更加的容易
"""
def print_hello():
    """
    这是一个函数体
    """
    print("hello world")

print_hello()

"""
可以给函数提供参数(形参)
"""
def introduce(name):
    print(f"大家好我的名字是:{name}")
introduce("****")
introduce("小王")             #此处执行函数时传入的是实参,调用函数就等于name=""

#!/bin/env python
"""
编写一个函数：
名字叫做 sum_numbers
有一个参数叫做 number
函数内，实现 1~number 之间，所有数字的加和
打印加和的结果
调用多次这个函数，传入不同的number查看结果
"""
def sum_numbers(number):
	sum_value = 0
	for i in range(1,number):
		sum_value += i
	print(f"1--{number}的加和为:{sum_value}")

sum_numbers(int(input("请输入加和的最大数:")))

2.2 函数返回值

"""
函数可以具有返回值
函数可以具有一个或者一组值，将逻辑“封装”在函数中，会让简化整个程序
"""
def add(x,y):
    x = int(x)
    y = int(y)
    return (x+y)              #执行函数体返回的内容

result = add(3,4)                #定义result为函数的执行动作
print(result)
print(add("7",3))

"""
函数可以具有一个或者一组值，将逻辑“封装”在函数中，会让简化整个程序
"""
students = {
    "xiaoming": {"id": 101, "age": 18, "gender": "boy"},
    "xiaohuang": {"id": 102, "age": 19, "gender": "girl"},
    "xiaowang": {"id": 103, "age": 17, "gender": "girl"},
}
def get_studen(name):
    if name in students:
        return students[name]
    else:
        return None
print(get_studen("xiaoming"))
print(get_studen("xiaowang"))

"""
返回多个值
"""
students = {
    "xiaoming": {"id": 101, "age": 18, "gender": "boy"},
    "xiaohuang": {"id": 102, "age": 19, "gender": "girl"},
    "xiaowang": {"id": 103, "age": 17, "gender": "girl"},
}
def get_student(name):
    if name in students:
        return students[name]["id"],students[name]["gender"]   #只返回name字典中的id_key对应value已经gender对应value
    else:
        return None,None      #多次调用字典内容,需要俩个None否则报错
#可以分开变量进行接收
id,gender = get_student("xiaoming")
print(id,gender)            #id则接收的是xiaoming——id_key，gender接收的是gender对应value
#可以接收为元组
info = get_student("xiaowang")
print(info,type(info))

2.3 lambda函数

"""
lambda函数：称为匿名函数，函数的定义直接使用，不用起名字；又称为一句话函数、逻辑简单到一行代码就能表达逻辑；用于一些简单的、不会重复多次调用的情景
"""
"""
定义形式：lambda 参数:操作(参数)
定义举例：sum = lambda x,y: x+y          #lambda替代函数名
相当于
def func(x,y):
  return x+y
调用举例：sum(1,2)
"""
##案例
sgrades=[("xiaoming",89),("xiaozhao",77),("xiaoxiaozhang",99)]          #列表套元组
#如何将列表内容安装分数进行排序
sgrades.sort(key=lambda x:x[1],reverse=True)        #key:比较元素 等同于def hh(x): return x[1]。
#此sort获取到的是sgrades中每个元组中的下标为1的值,也就是分数然后进行排序
#默认列表加元组的排序方式为元组的第一个元素即名字
print(sgrades)
def mfun(m):
    return m[1]
print(sorted(sgrades,key=mfun))       #效果于lambda完全一致
##m为列表中获取到的内容即每个元组,m1为元组中的分数

2.4 函数source

def add(x,y):
    return x+y

def sub(x,y):
    return x-y

def mul(x,y):
    return x*y

def div(x,y):
    return x/y
#定义函数体的文件不调用最好


#1.导入变量文件的内容不改动
import compute                        #compute为文件名.py文件
print(compute.add(3,5))
print(compute.sub(10,20))
print(compute.mul(3,5))
print(compute.div(10,2))

#2.导入变量的文件环境变量并起别名
import compute as cm
print(cm.add(3,5))
print(cm.sub(10,20))
print(cm.mul(3,5))
print(cm.div(10,2))

#3.导入变量文件用from
from compute import add,sub,mul       #from方式不需要写函数名可以直接调用
print(add(3,5))
print(sub(10,20))
print(mul(3,5))

二.面向对象

1.基本概念

1.1 类class(基本概念)

1.class(基本概念)
#类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合。
#用计算机的语言描述类，是属性和方法的集合
2.对象instance(例子)/object(对象)
--对象是类的具象，是一个实体。
--对于我们每个人这个个体，都是抽象概念人类的不同的实体。
--对象属性：它是对象状态的抽象，用数据结构来描述
--对象操作：它是对象行为的抽象，用操作名和实现该操作的方法来描述
3.三剑客
--封装
组装：将数据和操作组装到一起
隐藏数据：对外只暴露一些接口，通过接口访问对象
--继承
多复用,继承来的就不用自己写了
多继承少修改,OCP(open-closed principle--开闭原理)，使用继承来改变，来体现个性
--多态
面向对象编程最灵活的地方，动态绑定
4 哲学思想
##一切皆对象
#对象是数据和操作的封装
#对象是独立的，但是对象之间可以相互作用
#目前OOP(Object-oriented programming--面向对象编程)是最接近人类认知的编程范式

###"""面向对象的思想主要是以对象为主，将一个问题抽象出具体的对象，并且将抽象出来的对象和对象的属性和方法封装成一个类。"""
##面向过程是一种以事件为中心的编程思想，编程的时候把解决问题的步骤分析出来，并且按步骤实现。##

1.2 类的定义

1.定义
--必须使用class(类)关键字
--类名必须是用大驼峰命名(大小写集合的命名规则)例:ClassName
--类定义完成后,就产生了一个类对象，绑定到了标识符ClassName==类对象
#用法:
class ClassName:
   语句块

1.3 类对象及属性

1.类对象及类属性
#类对象，类的定义执行后会生成一个类对象
#类的属性，类定义中的变量和类中定义的方法都是类的属性
#类变量，直接定义在类中的属性；一般来讲，类变量可使用全大写来命名

1.4 类的实例化

1.类的实例化
#在类对象名称后面加上一个括号，就是调用类的实例化方法，完成实例化
#实例化就是真正的创建一个该类的对象（实例）
#每次实例化后获得的实例，都是不同的实例
#即使是使用同样的参数实例化，也得到不一样的对象
#Python类实例化后，会自动调用 __init__ 方法，这个方法的第一个形式参数必须留给self(自己)，其它参数随意

1.5 _init_方法

1.__init__ 方法
#类的实例化，实际上就是调用的 __init__(self) 方法
#这个方法可以不定义，如果没有定义会在实例化后隐式调用
#作用：对实例进行初始化
#初始化参数可以多个参数，但是第一个位置必须是self(实例本身)
#此方法不能有返回值，也就是只能 return None
#实例化调用__init__魔术方法来进行初始化-出厂配置，对生成的实例进行属性配置，__init__ 定义的是实例的属性

1.6 实例对象instance

1.实例对象instance
--类实例化后一定会获得一个类的实例，就是实例对象
--__init__方法的第一参数self就是指代某一个实例自身
--类实例化后，得到一个实例对象，调用类方法时，采用 instance.class_method() 的方式，实例对象就会绑定到方法上
--调用类方法时，类方法的self参数，就是实例自身
--__init__ 中所定义的变量，是保存在实例上的，并不是类上，所以,称为实例变量
--实例变量是每一个实例自己的变量，是自己独有的
--类变量是类的变量，是类的所有实例共享的属性和方法
#调用实例中的变量,只能通过调用self或其他实例参数,才能使用其实例中的变量
#类中的变量供所有实例使用

1.7 实例

"""
面向对象的目的，用代码模拟现实世界的事物和情景，让代码的编写、组织、理解都更加容易
"""
"""
类class：描述一类事物
相当于一个事物模板
"""
"""
对象：一个具体的类的实例
"""
#例如动物是类的名称叫做事物模板
#具体动物类中存在了猫、狗、猪等称之为类的实例
class Student:                                   #class定义一个类模板,驼峰命名类的名称
    """ 类注释，这是学生类 """

    def __init__(self, name, age):                    #初始化构造函数,self为类本身,初始化后生成类的对象
        """ 初始化方法 """
        """类定义中的变量和类中定义的方法都是类的属性"""
        # 普通实例变量，每个实例独有
        self.hh = name                        #定义俩个初始变量(类的属性)
        self.aa = age

    def introduce(self):                            #定义普通方法调用init定义的初始属性变量即name和age(类属性)
        """ 普通方法 """
        return f"大家好，我叫{self.hh}，我{self.aa}岁了"
xiaoming = Student("小明", 18)                  #()中的属性会被传入到初始化init中的变量进行赋值
#xiaoming就是一个实例化的类对象
xiaozhang = Student("小张", 17)                 #Student("小张", 17)  为class中的init本身
xiaozhao = Student("小赵", 19)
# 使用对象.属性来访问属性；使用对象.方法来调用方法
print(xiaoming.introduce())             #此处的小明为self,hh为name,后面的intoduce方法就是
#xiaoming.introduce访问的就是类的属性和类的introduce方法
#introduce(小明,18)进行的位置参数传入
print(xiaozhang.hh, xiaozhang.aa, xiaozhang.introduce())
print(xiaozhao.hh, xiaozhao.aa, xiaozhao.introduce())

2.面向对象三大特性

2.1 封装

1.封装：把客观事物封装成抽象的类，隐藏属性和方法的实现细节，仅对外公开接口
#封装可以把计算机中的数据跟操作这些数据的方法组装在一起，把他们封装在一个模块中，也就是一个类中。
例子：
class Box():
	"""盒子类实现了开关功能"""
	def open_door(self):
		return ("open")

	def close_door(self):
		return ("close")
#将开关功能函数集合到Box类中,实现类管理功能
open_cloes = Box()                        #定义类的实例化对象
print(f"打开门:{open_cloes.open_door()}")         #可以通过实例化对象直接调用封装好的Box类中的方法
print(f"关门:{open_cloes.close_door()}")

2.2 继承

1.继承：子类可以使用父类的所有功能，并且对这些功能进行扩展。继承的过程，就是从一般到特殊的过程。
#继承简单地说就是一种层次模型，这种层次模型能够被重用。层次结构的上层具有通用性，但是下层结构则具有特殊性。在继承的过程中类则可以从最顶层的部分继承一些方法和变量。类除了可以继承以外同时还能够进行修改或者添加。通过这样的方式能够有效提高工作效率
例子:
#!/bin/env python
class Father():
	#定义父类.不介入初始化构造函数,不设置传入属性
        def talk(self):
        	#定义函数方法,交给类self内置属性管理
                return "讲中文！"
        def breather(self):
                return "张嘴呼吸!"
class Children(Father):
	#继承父类属性和方法
        def new_talk(self,language):
        	#定义子类中的函数方法,并设置新参数属性language
                self.language = language
                #纳入类管理
                return f"讲{self.language}:食べましたか"
                #函数结束返回内容中调用language属性

me = Children()
#定义me对象为调用class类
language = "日语"
#定义子类中需要引入的参数
print(f"我会:{me.talk()}也会{me.breather()}还会:{me.new_talk(language)}")
#调用函数必须加().包括内置函数

2.组合继承
class P1():
	def __init__(self):
		pass

	def talk(self):
		return "this is p1"

class P2():
	def talk(self):
		return "this is p2"

class Person(P1,P2):               #P1在最前面所以实例对象在调用继承类Person时会引用P1父类的方法和属性
	pass

class Animal(P2,P1):                #P2在最前面所以实例对象在调用继承类Person时会引用P1父类的方法和属性
	pass

man = Person()
women = Animal() 
print(f"这是多组继承:{man.talk()}")            #此处回显的时父类P1的内容
print(f"这是多组继承:{women.talk()}")          #此处回显的时父类P2的内容
#这里注意一个小细节，当我继承自多个父类，多个父类都有相同的方法。那我调用的时候会调用谁的呢？
#其实，是按照继承参数的顺序来的，谁排在第一个就调用谁的方法

2.3 多态

##多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）##
案例:
class Father():
        def __init__(self):
                pass

        def talk(self):
                return "讲中文:你好python"

class Son(Father):
        def son_talk(self):              
        """起新的方法名称不更改父类继承下来的方法"""
                return "我是儿子会讲英语:hello，world"

class Daughter(Father):
        def daughter_talk(self):
                return "我是女儿会讲俄语:Всем привет"

class Sister(Father):
        def sister_talk(self):
                return "我是妹妹会讲韩语:전 세계 여러분 안녕하세요"

son=Son()
daughter=Daughter()
sister=Sister()

print(f"父类--{son.talk()},子类:{son.son_talk()}")
####son.talk继承父类本身方法,将父类内容输出###
print(f"父类--{daughter.talk()},子类:{daughter.daughter_talk()}")
print(f"父类--{sister.talk()},子类:{sister.sister_talk()}")

####一个抽象的父类,再不更改父类中的方法拥有多个子类,叫做多态####
案例2：
class Father:
    def talk(self):
        return "我会讲话，我讲的是中文"

# 继承自爸爸类
class Me(Father):
    def talk(self):
        """直接继承修改父类方法,实现多态"""
        return "我是哥哥，我讲英语：hello，world"

# 继承自爸爸类
class Son(Father):
    def talk(self):
        return "我是弟弟，我讲俄语：Всем привет"

# 继承自爸爸类
class Sister(Father):
    def talk(self):
        return "我是妹妹，我讲韩语：전 세계 여러분 안녕하세요"

me = Me()
son = Son()
sister = Sister()

print(f"{me.talk()}")
print(f"{son.talk()}")
print(f"{sister.talk()}")

四.文件写入写出操作

4.1 基础知识

背景问题：
如果不加存储，程序关闭后数据就丢失了，下次打开程序需要重新获取/输入数据

数据存储到多个解决办法
将数据存储到纯文本文件中，例如txt文件
将数据存储到Excel文件中
将数据存储到数据库例如MySQL中

本章介绍最简单直接的文本文件的存储和读取
使用方法
来自爬虫、用户输入等外部数据，直接存储到文件中并保存
每次使用时，从文件读取已保存的数据，基于这些数据做处理
每次打开程序，都能读取到之前的数据，实现固化存储的效果

4.2 读取文件内容

"""
问题：
怎样读取文件的整个内容？
怎样按行读取数据？
怎样把所有行读取到一个列表？
"""
f = open("访客列表.txt",encoding="utf-8")
#f方法名称,open打开文件,如果目标文件包含中午需要设定字符集
conent = f.read()
#新变量为打开文件
print(conent);print("")
f.close()
#最后需要关闭文件不然可能数据丢失报错等问题

4.3 with读取文件

"""
怎样用with语法读取文件
"""
with open("访客列表.txt",encoding="utf-8") as fin:
#with为with是python关键字表示接管“资源自动关闭”等事宜.as起别名
    conent = fin.read()
    #.read内置函数就是读取文件内容
    print(conent)
#with的语法更加简洁会更多的使用.with读取文件后自动做关闭处理

4.4 逐行读取文件`

"""
按行读取文件
"""
with open("访客列表.txt",encoding="utf-8") as hh:
    for i in hh:
        i = i[:-1]
        #遵循左开右闭合原则,去掉文件列表最后的换行符
        #i = i.rstrip()
        #restrip会去除字符右边的空格
        print(i)

4.5 将行读取到列表中

"""
怎么把所有行读取到列表
fin.readlines()可以读取到列表
"""
with open("访客列表.txt",encoding="utf-8") as fin:
    lines = fin.readlines()
    lines = [x[:-1] for x in lines]
    #使用列表推导式,将内容进行修饰.去掉内置换行符
    print(lines)

4.6 文件读取练习

"""
新建一个文件，叫做 英汉词典.txt
每行是一个中英文对照，逗号分隔
例如：
sheep,羊
tiger,老虎
duck,鸭子
fish,鱼
用python读取文件，建立一个字典
key是英语词语，value是汉语词语
编写while循环
输入quit退出循环
输入英语，返回汉语
如果不存在，说没有这个词语
"""
#!/bin/env python
dict = {}
#定义空字典,用来接收文件中的内容
with open("英汉词典.txt",encoding='utf-8') as fin:
	for i in fin:
		i = i[:-1]
		#通过列表推导式去除换行符,读取文件默认生成的都为列表
		fieds = i.strip().split(",")
		#格式化内容为fieds
		if len(fieds) == 2:
			#fieds按照,号进行分割,那么读取每行文件,那么就会是俩个参数
			en,cn = fieds
			dict[en] = cn
		else:
			continue
	print(f"字典已生成:{dict}")
	#for循环读取文成后,循环次数为文件行数.打印生成的字典
while True:
	key = input("输入你要查询的单词对应的英文:")
	if key == "exit":
		break
	elif key not in dict.keys():
		#如果要查询的key不在字典的key中则无法查询
		print(f"没有找对{key}这个key!")
	else:
		print(f"你查询的{key}的内容为:{dict[key]}")

4.7 文件写出

"""
怎样把一个大字符串写到文件里面
怎样按行写出文件？
"""
with open("数字列表.txt", "w", encoding="utf8") as fout:
    ##"w"意思是write写文件的意思
    number = 1998
    fout.write(str(number))
    #fin.write可以写入内容
    # #注意，它只能写入字符串，数字不可以需要转换

4.8 按行写入文件

"""
怎样按行写出文件内容？
"""
with open("数字列表.txt",'w',encoding="utf-8") as new_fin:
    #w操作,每次会将输出文件清空再写入,无法追加
    for number in range(1,101):
        #输出1-100的值
        new_fin.write(str(number) + "\n")
        #\n换行符,即输出每个数字换行一次
        #输出完number对应数字后换行

with open("数字列表.txt",encoding="utf-8") as read_fin:
    for i in read_fin:
        i=i[:-1]
        print(i)

4.9 文件写入练习

"""
改进婚礼礼金程序
用”w”模式，打开一个文件“婚礼礼金.txt”文件
写一个while true
请输入“姓名 礼金”，例如“小明 1000”
将数据存储到文件中，每行一个数据
输入quit退出循环

退出循环后
重新读取文件，按行读取
把礼金读取到list中
输出list的统计数据，加和、最高、最低、平均值
"""
----方法1
with open("婚礼礼金.txt","w",encoding="utf-8") as gift:
    #此操作每次都会将文件进行格式化,也就是清空后在赋值
    while True:
        print("*" * 20)
        gift1 = input("请输入姓名礼金。用空格分隔:")
        if gift1 == "exit":
            break
        else:
            fieds = gift1.split()
            if len(fieds) == 2:
                #必须输入的内容为2个元素才能写出到文件中
                name,money = fieds
                gift.write(f"{name},{money}\n")
            else:
                continue
list = []
with open("婚礼礼金.txt",encoding="utf-8") as new_gift:
        for line in new_gift:
            line = line[:-1]
            #因为上方定义输出文件时,每行结尾加换行符,进行格式化
            fileds = line.split(",")
            #split函数拆分文本内容。默认以空格分隔
            if len(fileds) != 2:
                #判断列表内容是否为2个元素组成
                continue
                #如果是则丢弃这个数据,则脏数据
            else:
                name,money = fileds
                #否则就进行拆包,根据占位获取元素值
                money = int(money)
                #格式化money的数据类型,默认为str
                list.append(money)
                #将money追加到列表中
print(f"总金额:{sum(list)}")
print(f"最高金额:{max(list)}")
print(f"最小金额:{min(list)}")
print(f"平均金额:{sum(list) // len(list)}")


----方法2
filename = "婚礼礼金.txt"
with open(f"{filename}",'w',encoding='utf-8') as gift:
 while True:
    print("*" * 20)
    info = input("输入名称和礼金:")
    if  info == "exit":
        break
    else:
        fields = info.split()
        if  len(fields) == 2:
            name,money = fields
            #拆解list内容
        else:
            continue
        money = int(money)
        gift.write(f"{name},{money}\n")
        #只有满足条件(拆解内容为名称和礼金的)才会被输出到文件中.

with open(f"{filename}",encoding="utf-8") as gift:
    list = []
    for line in gift:
        line = line[:-1]
        fields = line.split(",")
        #此时文件内容为逗号分割开
        if len(fields) == 2:
            name,money = fields
            list.append(int(money))
        else:
            continue
print(f"总金额:{sum(list)}")
print(f"最高金额:{max(list)}")
print(f"最小金额:{min(list)}")
print(f"平均金额:{sum(list) / len(list)}")

五.文件路径

5.1.文件路径

"""
问题：读写文件的时候，怎样指定文件的路径？
问题：如果文件不在当前目录下，怎么指定电脑任何一个位置的路径？
"""
file_path ="英汉词典.txt"       #此为相对路径代表文件在统计目录下
file1_path = "E:\py-资料\py学习\文件处理操作\文件处理\hhh.txt"     #此为绝对路径

import os
print(os.path.exists(file_path))
print(os.path.exists(file1_path))
#返回ture和false

访问电脑的任何 一个文件的路径
绝对路径：从D:等盘符开始写，叫做绝对路径；
相对路径：如果不是从D:盘符开始写，那么默认从当前目录找文件和子目录，叫相对路径
# 因为\n、\t在python中有特殊含义
# 所以如果反斜线\分割路径，就前面加一个r，代表raw-string，不解析反斜线
file_path = r"D:\workbench\ant-python-zero\临时代码\数据目录\访客目录\访客列表.txt"

# 也可以直接改成正斜线，就不用考虑转义问题
file_path = "D:/workbench/ant-python-zero/临时代码/数据目录/访客目录/访客列表.txt"

5.2 练习

"""
新建一个python文件，叫做判断 “文件路径是否存在.py”

当前目录下新建一个txt文件，叫做 “文件路径是否存在.txt”
用os.path.exists方法，输出这个文件是否存在

在当前目录新建一个子目录，叫做“文件路径是否存在”，在目录中新建一个文件叫“测试路径.txt”
用os.path.exists方法，自己编写这个文件的路径，判断是否存在

在pycharm中，文件路径是否存在.txt 这个文件上，右键，复制路径，复制绝对路径
用反斜线的方式得到文件路径，自己加r前缀，用os.path.exists方法，输出这个文件是否存在

随便写一个文件名字，用os.path.exists方法，输出这个文件是否存在
"""
import os

file = "文件路径是否存在.txt"
print(os.path.exists(f"{file}"))
new_file = "文件处理/hhh.txt"
print(os.path.exists(f"{new_file}"))
new_file_path = r"E:\py-资料\py学习\第一章-基础\input和while死循环\while&input练习.py"
print(os.path.exists(new_file_path))

5.3 json文件格式

背景问题：
前面的办法，是每行的方式写一个数据
有没有办法，把python的list、dict这样的数据结构，直接存到.txt文件中，实现格式化保存和读取？
#json是一个这样的库和格式：
#data可以是str、list、dict
#import json，引入这个库
#json.dumps(data)，可以把python的对象，转换成一个字符串，你可以把这个字符串写到文件
#json.loads(str)，可以把大字符串读取成python对象，例如成为python的list和dict
-----code
import  json
data = [1,2,3,4,5]
#定义列表形式的数据内容
new_date = json.dumps(data)
##json.dumps(data)，可以把python的对象，转换成一个字符串，你可以把这个字符串写到文件
#定义新的内容为json格式化后的文件
print(new_date,type(new_date))
#data数据形式转换为了str,将对象转换为了字符串
data = {
    "xiaoming":[1,2,3,4],
    "xiaowang":[1,3,5,7],
    "xiaoli":[2,4,6,8],
}
new_date = json.dumps(data)
print(new_date,type(new_date))
#data数据形式转换为了str,将对象转换为了字符串
#数据的展示不会变

data_str = """
{"xiaoming":[1,2,3,4,5],"xiaowang":[1,3,5,7],"xiaoli":[2,4,6,8]}
"""
#"""输入数据形式的内容"""".type为字符串类型
new_date = json.loads(data_str)
#将字符串转换为根据内容的数据类型
print(new_date,type(new_date))

--result
[1, 2, 3, 4, 5] <class 'str'>
{"xiaoming": [1, 2, 3, 4], "xiaowang": [1, 3, 5, 7], "xiaoli": [2, 4, 6, 8]} <class 'str'>
{'xiaoming': [1, 2, 3, 4, 5], 'xiaowang': [1, 3, 5, 7], 'xiaoli': [2, 4, 6, 8]} <class 'dict'>

5.4 json格式练习

"""
学生成绩录入与保存程序
新建代码“成绩录入json.py”
加载文件的词典文件：成绩录入json.txt
如果文件存在，加载到字典 grade_dict
如果文件不存在，新建一个成绩字典，例如grade_dict = {}
while true，输入多个成绩
每行成绩，形如“小明 80”、“小李 90”
使用str.split拆分成name和grade
存入字典中，name是Key，grade是Value
输入quit，退出循环
将grade_dict更新保存到json文件中：成绩录入json.txt
类似用f.write(json.dumps(grade_dict))即可
"""
import os
import json
import time
file = "json.txt"
grade_dict = {}
if os.path.exists(file):
    with open(f"{file}",encoding="utf-8") as f1:
        grade_dict = json.loads(f1.read())
        #将文本中的内容json格式化后输出为python的数据类型
    print("准备读取文件内容!")
else:
    print("文件不存在！！")

print("读取文件后的内容")
for key,value in grade_dict.items():
    print(f"名字:{key},分数:{value}")
    time.sleep(0.5)

while True:
    print("*" * 20)
    info = input("输入姓名和成绩:")
    if  info == "exit":
        break
    else:
        fieds = info.split()
        if  len(fieds) != 2:
            continue
        else:
            name,grade = fieds
            grade = int(grade)
            grade_dict[name] = grade

with open(f"{file}","w",encoding="utf-8") as f1:
    #数据会被更新和写入追加
     f1.write(json.dumps(grade_dict))
##json.dumps(data)，可以把python的对象，转换成一个字符串，你可以把这个字符串写到文件

5.4 异常处理Exception

"""
什么是异常？ 
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
 一般情况下，在Python无法正常处理程序时就会发生一个异常。 
异常是Python对象，表示一个错误。 
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。 
"""
"""
你会在运行代码时，遇到这种类似的报错：
Exception	常规错误的基类
ZeroDivisionError	除(或取模)零(所有数据类型)
IOError	输入/输出操作失败 
ImportError	导入模块/对象失败 
KeyError	映射中没有这个键
SyntaxError	Python语法错误
ValueError	传入无效的参数 
"""

5.5 案例

grades = []
while True:
    grade = input("输入成绩:")
    try:
        grade = int(grade)
    except Exception as e:
        print("你输入的信息有误，请检查后输入.报错信息为：",e)
        break
    grades.append(grade) #如果上方直接报错,那么程序是无法到达这一步,也就是append内容到列表中
print(grades)

---stdion
输入成绩:199
输入成绩:ee
你输入的信息有误，请检查后输入.报错信息为： invalid literal for int() with base 10: 'ee'
[199]


案例2：
try:
    with open("123123.txt",encoding='utf-8') as f:
        print(f.read())
        #打印读取的内容
except Exception as e:
    print("读取文件错误,错误信息为:",e)
   
   输出为： 
   读取文件错误,错误信息为: [Errno 2] No such file or directory: '123123.txt'

5.6 练习1

"""
升级成绩录入程序：
while true录入姓名和成绩，存入“学生成绩带异常处理.txt”文件
增加成绩不是数字的异常处理
如果输入内容抛异常，不要暂停程序；
提示用户“发生的异常是什么”
提示“当前的信息是什么，继续可以继续录入”
一个经验：如果捕获了异常，一定至少打印点日志，方便排查问题
不然会出现情况：程序不符合预期（例如输入了成绩为abc不生效也不提示），不知道哪里有问题
"""
file = "学生成绩带异常处理.txt"
with open(f"{file}","w",encoding="utf-8") as f:
    while True:
        info = input("输入姓名和成绩:")
        try:
            if  info == "exit":
                break
            name,grade = info.split()
            #如果输入的信息不够拆包,会报错
            grade = int(grade)
            #拆出来的int不是整形会报错
        #tab整体向后缩进,shift tab向左缩进
        except Exception as e:
            print("格式错误,错误信息为:", e, f"你输入的是:{info}")
            continue
            #如果是脏数据则提前结束循环。
        f.write(f"{name},{grade}\n")
       #写在while循环内，成功一次写入一次.防止数据丢失

六.开源技术库

6.1 安装技术库

1.win + r 打开cmd
2.复制python虚拟环境绝对路径
3.C:\Users\xxq\AppData\Local\Programs\Python\Python37\python.exe -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas
#安装pandas库
"""
其中：
C:\Python310\python.exe：来自你的pycharm运行代码的python.exe的路径
-m：意思是要使用后面pip这个模块，m是module的意思
pip：是python安装软件的一个命令，可以从网上下载和安装包
install：意思是安装包的意思
-i https://pypi.tuna.tsinghua.edu.cn/simple：意思是国内有一个技术库的地址，用这个安装更快（国内地址的软件和国外的一样，每5分钟同步一次）
some-package：要安装的包，例如requests
其中 -i https://pypi.tuna.tsinghua.edu.cn/simple 可以省略，用的就是国外的包
"""

6.2 爬虫requests介绍

requests是Python的一个开源类库
用代码请求网页、接口，获取返回的数据
--案例
import requests
url = "http://qqkj.gitlab.com/"
r = requests.get(url)
print(r.status_code)
print(r.text)
##首先要确保当前环境存在requests库

--练习
import requests
url = "http://qqkj.gitlab.com/"
r = requests.get(url)
print(r.status_code)
#返回状态码
info = r.text
#info为url对应内容
with open("antpython.html","w",encoding="utf-8") as file:
    file.write(str(info))
    #打开文件并写入,写入内容为info

6.3 数据分析pandas

"""
Pandas：
Pandas 是 Python 语言的一个扩展程序库，用于数据分析。
提供高性能、易于使用的数据结构和数据分析工具。
Pandas 可以对各种文件格式比如 CSV、JSON、SQL、Excel 导入/导出数据。
Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。
Pandas 广泛应用在学术、金融、统计学等各个数据分析领域。
"""
--案例
data = [
    ["s001", "小明", 89],
    ["s002", "小张", 90],
    ["s003", "小找", 66],
]
#格式为二维行列表的格式

import pandas as pd
#导入pandas模块别名为pd
df = pd.DataFrame(data,
    #DataFrame放数据
    columns=["学号", "姓名", "成绩"])
    #coulemns放列名
df.to_excel("学生成绩excel文件.xlsx")
#导出文件名和格式


--练习
import pandas as pd
datas = []
while True:
    print("*" * 20)
    info = input("输入姓名和礼金:")
    try:
        if  info == "exit" or info == "quit":
            break
        fields = info.split()
        #用fields来接收拆包内容。方便判断
        if  len(fields) == 2:
            name,money = fields
            datas.append([name,money])
            #append追加为列表嵌套列表,组成二维列表
    except Exception as e:
         print("错误信息为:",e,f"你输入的是:{info}.")
         continue
        #如果抛错则不要此处的数据
print(datas)
df = pd.DataFrame(datas,columns=["姓名","礼金"])
#df为变量名,内容为pd(pandas),dataframe源数据,columns列
df.to_excel("婚礼礼金.xlsx",index=False)
#输出为excel文件,且生成文件中不要序号列

6.4 Falak网页开发

flask
一个轻量级Web应用框架，非常适用于开发小型网站，以及开发web服务的API；
--code
from flask import  Flask
#导入falsk框架的Flask类
app = Flask("我的网页")
#创建服务器对象
@app.route("/qqkj")
#声明访问的url
def hello():
    return "这是强强科技的首页！！！"
#返回访问url的内容
app.run()
#运行服务器,浏览器就可以访问
--访问http://127.0.0.1:5000/qqkj即可.默认falsk端口为5000
        
--练习题
"""
新建一个自己的英汉翻译词典文件“英汉翻译.txt”，复制过去，包含如下内容：
sheep,羊
tiger,老虎
duck,鸭子
fish,鱼

制作一个网页返回
URL地址设置成：/english
读取文件内容：f.read()
返回给网页前端

启动服务器
打开网页，展示词典数据
"""
from flask import Flask

app = Flask("动物网站")
#app的名称
@app.route("/english")
#设置路由
def hello():
    with open("英汉翻译.txt",encoding="utf-8") as f:
        return f.read()
app.run()
#运行服务器,根据--http://127.0.0.1:5000/english访问浏览器即可

6.5 linux运行request等模块

1.[root@client Advanced]# yum -y install python3-pip
#安装pip工具,可以下载第三方模块
2.[root@client Advanced]# pip3 install requests
#下载requests爬虫模块
3.[root@client Advanced]# python3 pachong.py
#用python3执行带有request模块的文件
4.[root@client Advanced]# pip3 list
#列出安装了的第三方模块
5.[root@client ~]# pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas
#指定清华源安装pandas模块