python笔记

python笔记

---

数据类型查看

• 使用 type（）语句来查看数据的类型

• 方法一：使用print直接输出信息

  print(type（"黑马程序员")
  print(type("666"))
  print(type(11.345))
  

  • 方法二：使用变量存储type（）语句的结果

  string-type=type("黑马程序员")
  int-type=type(666)
  float-type=type(11.345)
  print(string-type)
  

  • 方法三：使用type（）语句，查看变量中的数据类型

  name='黑马程序员'
  name-type=type(name)
  print(name-type)
  

  • 变量没有类型，但是变量所存储的数据有类型

字符串的定义方式

• 单引号
• 双引号
• 三个双引号

字符串格式化

字符串和变量的快速拼接

name = "黑马程序员"
message ="学IT就来 %s" % name
print(message)

则输出"学IT就来黑马程序员"

---

• % 表示:占位
• s 表示:将变量放入占位的地方

格式符号	转化
%s	将内容转化为字符串
%d	将内容转化为整数
%f	将内容转化为浮点型,放入占位位置

剩下的不再赘述

---

格式化字符串的过程中的精度控制

与c语言一致,通过"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)

---

字符串格式方法2

通过语法：f"内容{变量}“的格式；来快速格式化

下面是例子：

name = "田文哲"
birthday = "0151561"
print(f"我是{name}，我生于{birthday}")

注：

• 不会理会类型
• 不会控制精度

适合对精度没有要求时的快速使用

对表达式进行字符串格式化

print(f"1*1的结果是{1*1}")
{1*1}的结果直接输出出来

其他格式化方法同样适用

股票报价小程序

name = "无忧传媒"
stock_price = 21#"当前票价"
stock_code = 12#"股票代码"
stock_price_daily_growth_factor = 1.2#股票每日增长系数
growth_days = 7#股票涨了多少天
print(f"公司{name}，股票代码{stock_code},当前票价{stock_price}")
print("每日增长系数：%f，经过%d天的增长后，股价达到了：%.2f"%(stock_price_daily_growth_factor,growth_days,stock_price*stock_price_daily_growth_factor**growth_days))

input语句

name = input("请输入你的名字")

注意：input语句输入的默认为字符串类型

可以
num = int(input("请输入整数"))
来进行解决

常见的6种数据类型

布尔类型

result = 10>5
print(result)
则输出结果为1

not

非的意思

运算符

==等于

！=不等

>

<

>=

<=

if语句

不同于c语言，python的if的多行语句不是通过{}来实现，而是通过对应相同的空格缩进来实现！！！

num = 1
if num = 1：
print(num) #注意首行缩进四个空格

if--elif--else

与c语言不同，python通过elif来实现第一个条件不满足时接下来的条件判断

height = int(input("请输入你的身高(cm)"))
vip_level= int(input("请输入你的vip等级（1-5）"))
if  height<120:
    print("身高小于120，随便玩")
elif  vip_level>3
    print("高级用户，免费游玩")
else 
    ("需要买票10元")

也可以直接

if int(input("请输入您的身高"))<120
    print("身高小于120，随便玩")

if的嵌套

if 条件1:
if嵌套条件1:
嵌套层执行语句
else：
嵌套层执行语句
else：
最外层执行语句

while循环

猜随机数字例子

mport random
num = random.randint(1,100)
while 1:
    a = int(input("请输入一个1~100的数"))
    if a==num:
        print("恭喜你猜对了")
        break
    else:
        if a>num:
            print("你猜大了")
        else:
            print("你猜小了")
        print(num)
        print("请再猜一次")
 

break同样也可以使用

同样可以通过修改变量方式来实现bool类型改变

fiag = Ture
while flag:
    if a==num:
        print("恭喜你猜对了")
        flag = False
    else:

        print(num)

综合案例：发工资

#注，可以在逗号后面加个空格
i = 1
all_wage = 10000
while i < 21:
    import random
    num = random.randint(1, 10)
    if all_wage >= 1000 :
        if num < 5:
            print(f"员工{i}，绩效分{num}，不发工资，下一位")
        else:
            all_wage = all_wage - 1000
            print(f"向员工{i}发放工资1000元，账户余额还有{all_wage}元")
        i += 1
    else :
        print("工资已发完，下个月再领")
        break

for循环

基本语法格式
for 临时变量 in 待处理数据(序列)：
循环满足条件时执行的代码
注：无法定义循环条件，只能被动取出数据处理
注：有对应的空格缩进

就是将待处理数据中的值一一赋给临时变量

eg.数单词中几个a

count = 0
for x in namea
    if x =="a"#注意别落了""
        count +=1
print(f"被统计的字符串中共有{count}个a")

​

range语句

获得一个简单的数字序列
range(num)
获得从零开始，到num结束的序列，不含num本身
eg. range(5)：[0,1,2,3,4]

range(num1,num2)
从num1开始，到num2结束
eg.range(5,10):[5,6,7,8,9]
range(num1,num2,step)
从num1开始，到num2结束，步长为step

for循环临时变量作用域

临时变量在规范上无法被外部给捕捉,即在for循环中的变量无法在外部给输出

for循环嵌套

for i in range(1,101)
for j in range(10)
print("这就是for循环嵌套")

continue与break与c语言一致

函数

# 接下来是定义函数
#利用函数求字符串长度

str1 = "abcdr"
str2 = "djskfjsda"

# python自带的len()函数
print(len(str1))
print(len(str2))
# 下面是我自己定义的函数
def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(f"字符串{data}的长度是{count}")
# 接下来就可以正常使用了
my_len(str1)
my_len(str2)

# 函数的定义：  （其实与c语言类似）
# def 函数名 （传入参数）:                    传入参数可以不写，但必须写括号 eg.test01()
#     函数体（空格缩进4字符）
#     return 返回值


# 函数的调用
# 函数名（参数） 若函数中没有参数，则这个地方的参数可以不写

def check():
    print("请出示72小时核酸隐性证明")

check()

def add(x, y, z):    # x, y, z 我们称之为形参
    result = x + y + z
    print(result)

add(5, 9, 8)       # 这，即函数调用中，我们称之为实参·

None

• 相当于c语言中的void
  def 函数名 （函数参数）
  函数体
  上方没写返回值，则默认返回值就是None
  当然，也可以写成return None
• print（函数名） #输出的是返回值类型，没写则就是None
• type（函数名） #输出结果是<class'NoneType'>
• None等同于False
• if None： #就是如果是假的话
• None 可以用来赋无初始量的值
• eg. name = None
• 在之后的操作里,再给name赋值

函数的说明文档

对函数添加一个注释:

在输入三个双引号之后,会自动给你补全

def min(a, b):
    """
    :param a:形参a的说明	
    :param b:形参b的说明
    :return:返回值的说明
    """
    函数体
    return 返回值

函数的嵌套调用

def a():
    print("1")
def b():
    print("2")
    a()  # 调用a
    print("3")

变量的作用域

注意区分全域变量与局部变量
def a()
num = 1
print(num) #这是不行的

global关键字

设置内部定义的变量为全局变量
def a()
global num =10
print(num)

有多个返回值：

def test_return():
    return 1,2
    
x,y = test_return()     #利用两个变量接收即可
print(x)    #结果1
print(y)    #结果2

变量之间用逗号隔开，
支持不同类型的数据return

函数的多种传参形式

位置参数

def max(a,b)
if ...

max(c,d) #找对应相应位置即可

关键字传参

函数调用时通过“键=值”的传参形式
可以让函数更清晰，容易使用，消除了位置需求
def user_info(name,age,gender)
print....
不按位置顺序
user_info(age = 20，gender=”男“，name = ”小明“)
可以与位置参数昏庸，位置参数必须在前，且匹配参数顺序
user_info("小明"，age = 20，gander=”男“)

缺省函数：

缺省函数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数的定义和调用）
def user_info(name,age,gender="男"):
print.....
user_info('Tom',20)
user_info('rose',18,'女') #不写就默认男

不定长参数

不定长参数也叫可变参数，用于不确定调用时的会传递多少个参数(不传参也可以)的场景
作用：当调用函数时不确定参数个数是，可以使用不定长参数

位置传递的不定长函数里接收多个变量 ，形成元组

规范书写：里面写args

def uset_info(*args):
    print(args)

# ('Tom')
uset_info('Tom')
# ('Tom', 18)
uset_info('Tom', 18)     #所有参数会被收集，并生成一个元组

关键字传递的不定长 接收多个变量，形成字典

书写规范：kwargs

def user_info(**kwargs):
    print(wargs)

user_info(name='Tom', age=18,id=110)  

函数作为参数传递

lambda匿名函数

• def定义函数，可重复调用
• lambda关键字，可定义匿名函数（无名称），只能临时使用一次

定义及用法
lambda 传入参数：仅能写一行的函数体
注：只能写一行代码，无法多行
eg.
上述图片代码就可以简化为

test_func(lambda x,y: x + y)    #结果为3

类和对象

类只是一种程序内的“设计图纸”，需要基于图纸生产实体(对象)，才能正常工作

定义

class 类名称：

对象名 = 类名称()
对象名.类内容 = .....

class Student:
    name = None
    age = None

    def say_hi(self):
        print(f"大家好，我是{self.name}")
    
    def say_hi2(self, msg):
        print(f"大家好，我是{self.name}，{msg}")

stu = Student()
stu.name = "田文哲"
stu.say_hi()
stu.say_hi2("很高兴认识大家")

class Clock:
    id = None
    price = None
    def ring(self):
        import winsound
        winsound.Beep(2000, 3000)

clock1 = Clock
clock1.id = "003023"
clock1.price = 19.99
print(f"闹铃id{clock1.id}，价格：{clock1.price}")
clock1().ring()    # 对象的声明需要括号。而类的声明括号可有可无    定义在自定义类中的方法需要一个默认的self参数。错误提示没有self 就是说明这个类的对象没有创建成功。  转自博客

构造方法

init 注意前后各两个下划线
作用：构建类对象时会自动执行，借此特性可以给成员变量赋值

class STUDENT:

    def __init__(self, name, age, tel):   
        self.name = name
        self.age = age
        self.tel = tel
        print("非诚勿扰")

stu2 = STUDENT("周杰伦", 19, 1334567842)
print(stu2.name)
print(stu2.age)
print(stu2.tel)

上述代码写也可写成

class STUDENT:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print(name)
        print(age)
        print(tel)

        print("非诚勿扰")

注：
1.构造方法时不要忘记加self关键字
2.在方法内使用成员变量需使用self

魔术方法：

上文所提到的__init__构造方法，是python类内置的方法之一
这些内置的方法，各自有各自的功能，这些内置方法我们称之为：魔术方法

init

上文提到，不赘述

str

引入：可以试试上述代码加上print(Student),输出的是Student的地址
内存地址没多大用，我们可以通过__str__方法，控制类转换为字符串的行为

calss Student
    def __str__(self):
        return f"{self.name},{self.age}
        
print(Student)

lt

比较两个类对象的大小
定义
def lt(self, other):
return self.age < other.age
print(stu2 < stu3) # 这样返回值就是Ture or False 同时，这个就是通过age进行比较
**但注意，这个只能比较><,不能比较别的

le

进行<=,>=的比较
def le(self, other):
return self.age <= other.age
print(stu4 <= stu2)
这样依然是返回ture or false

eq

进行相等的比较
def eq(self,other):
return self.age == other.age
print(stu1 == stu2)
**如果我定义这个魔术方法，同样可以进行stu1==stu2的比较，只不过这是是比较的他两个的地址，而他两个地址肯定不同，所以会返回false

封装

概念：将现实事物在类中描述为属性和方法，即封装
定义私有成员：

class Phone：
    __current voltage = None    # 以两个下划线开头，它就变成了一个私有的成员变量了

定义私有成员方法;

    def __keep_single_core(self): # 同样是两个下划线
        print("让cpu以单核模式运行")

使用私有成员

私有成员无法被类对象给使用，但是可以被其它的成员给使用

class Phone:

    __current_voltage = 2

    def __keep_single_core(self):
        print("CPU正在以单核模式运行")


    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，已开启单核模式以省电")


phone = Phone()
phone.call_by_5g()

可以定义不直接给用户开放的属性和行为

方法

以函数为例：
在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法
函数：

def add(x,y)
return x+y

方法：

class Student：

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

方法和函数功能一样，有传入参数，有返回值，只是使用方法不同
函数的使用： num = add(1,2)
方法的使用： student = Student()
num = student.add(1,2)

继承

先定义一个类，若使用之后要对类进行补充，可以利用继承，这个新类就包含了以前的旧类功能
定义：class 类名称(上面已经出现过的类名称)
对应相应的称呼：子类 父类
我们以上面的Phone代码为例

class Phone:

    __current_voltage = 2

    def __keep_single_core(self):
        print("CPU正在以单核模式运行")


    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，已开启单核模式以省电")


phone = Phone()
phone.call_by_5g()

# 接下来我要对Phone进行一定补充

class Phone2022(Phone)
    face_id = "100001"
    def face_id_unlock(self)
        print("2022新功能，面部解锁")
        
   
phone = Phone2022()
phone.face_id_unlock()
phone.call_by_5g()

多继承

所谓多继承，就是一个子类继承多个父类，有多个父类的功能

class  Phone；
    IMEI = None
    producer = None
    
    def call_by_5g(self):
        print("5g通话")

class NFCReader:
    nfc_type = "第五代"
    producer = "mi"
    
    def read_card(self)
        print("读卡成功")
        
class RemoteControl():
    rc_type = "红外遥控"
    
    def control(self):
        print("红外遥控开启")
        
class Myphone(Phone,NFCReader,RemoteControl)
    pass       # pass 关键字，为了不报错，不写新功能就直接pass就行
    

复写

子类继承父类的成员属性和成员方法周后，如对其不满意，那么可以复写

class Phone:
    IMEI = None	
    producer = "itcast"
    
    def call_by_5g(self):
        print("父类的5g通话")
    
class Myphone(Phone)；
    producer = "intel"            # 复写父类属性
    
    def call_by_5g(self):
        print("子类的5g通话")       # 复写父类方法
        

如果复写父类之后，我还想在重新使用父类中的方法，当然，这是在子类中写的，可通过以下方法进行调用：
方法1

• 使用成员变量：父类名.成员变量
• 使用成员方法：父类名.成员方法(self)

方法2：使用super()调用成员
使用成员变量：super().成员变量
使用成员方法: super().成员方法()

class Phone:
    IMEI = None
    producer = "itcast"

    def call_by_5g(self):
        print("父类的5g通话")


class Myphone(Phone):
    producer = "intel"  # 复写父类属性


    def call_by_5g(self):
        print("子类的5g通话")  # 复写父类方法
        print(Phone.IMEI)
        print(super().producer)
        print(self.producer)    
        super().call_by_5g()     # 这是父类中的call_cy_5g 在子类中call_by_5g中调用 注意不用写self
miphone = Myphone()
miphone.call_by_5g()

​

数据容器

通过一个变量储存多个数据，容纳的每一个数据被称之为一个元素，每一个元素，可以是任意类型，eg.字符串，数字，bool类型

list（列表）

列表定义

定义变量：变量名称 = [元素1，元素2，...]
字面量：[元素1，元素2，...]

定义空列表（两种方法：）
变量名称 = []
变量名称 = list() #这是获取一个空列表
列表可以嵌套：
my_list = [[1,2,3],[4,5,6]]
print(my_list)

从列表中取出特定位置的元素
name_list = ['tom','lily','rose']
print(name_list[0])
print(name_list[1])
print(name_list[2])
或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1，-2，-3....）
即-1为最后一个元素
print(name_list[-1]) # rose
print(name_list[-2]) # lily
print(name_list[-3]) # tom

my_list = [[1,2,3],[4,5,6]] 索取对应元素时通过两层指引即可
my_list[1] [1] #像是一个二维数组似的

列表的方法

列表内部提供了很多函数，有很多方法

• 查询功能

  查找指定元素在列表的下标，如果找不到，报错

  语法： 列表.index（元素）

my_list = ["itcast","itheima","python"]
index = mylist.index("itheima")

• 修改特定位置的值
  与c类似，语法： 列表[下标] = 值
  my_list[1] = 2
• 插入元素
  语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素,本来的这个下标位置的数，就变成下一个数了
  my_list.insert（1,"best")
• 追加元素
  语法1：列表.append（元素），将指定元素，追加到列表尾部
  语法2：列表.extend（其它数据容器），将其它数据容器的内容取出，依次追加到列表尾部 eg.
• my_list.extend(my_list2)
• 删除元素
  语法1： del my_list[2] #删除列表中第3个元素
  语法2： 列表.pop（下标） #准确说这是取出元素，可以将其给到某个元素！

mylist = [1,2,3]
element = mylist.pop(2)
print(mylist)

• 删除某个元素在列表中的第一个匹配项
  语法： 列表.remove（元素）
  list1 = [1,2,3,2,4]
  list1.remove(2)
  print(list1) #结果： [1,3,2,3]

• 清空列表
  mylist.clear()
  print(mylist) #结果[]

• 统计某个元素在列表中的数量
  list1 = [1,2,3,2,2,4]
  i = list1.count(2) 拿变量i 接收这个数值
  print(i) #结果为3

• 统计总共有多少个元素
  语法： len（列表）

列表的遍历

将容器内的元素依次取出的行为，称之为：遍历、迭代

index = 0
while index < len(列表名)：
    元素 = 列表[index]
    对元素进行处理
    index += 1

###元组 (tuple)    元组不可修改！
####定义
使用小括号，用逗号隔开各个元素，数据可以是不同的数据类型
~~~python
变量名称 = (元素，元素，....，元素)
#定义空元组
变量名称 = ()   #方式1
变量名称 = tuple()    #方式2
# 定义1个元素的元组
t2 = ('hello','hello','hello',"nihao")   
#元组的嵌套
t3 = ( (1, 2),(3, 4) )

注意：一个元素也要有逗号，否则不是元组类型

元组的方法

• 下标索引取出内容
  t5 = ( (1, 2),(3, 4) )
  num = t5[1][2]
  print(f"索引内容为{num}")
• index查找方法
  a_find = t2.index("hello")
  pirnt(a_find)
• count统计方法
  num = t3.count('hello') # 统计hello的数量
• len函数统计元素数量的总数
  num = len(t2)

元组不可改，但在元组里嵌套列表，列表中的元素仍可修改
t7 = (1,2,['itma','5552'])
print(t7[2][1])
t7[2][1] = '2342'
print(t7[2][1])

字符串 不可修改

也是一种数据容器,与元组一样，是无法修改的容器
每个字母对应一个元素，也有对应下标索引
name = 'xiba'
print(name[1])

字符串的替换

字符串.replace(字符串1，字符串2)
功能： 将字符串的全部：字符串1，替换为字符串2
注意： 不是修改字符串本身，而是得到了一个新的字符串
new_my_str = str.replace("it","hema")

字符串的分割

语法： 字符串.split(分割字符串)
功能： 按照规定的分割字符串，将字符串划分为多个字符串，并存入列表对象中
注意： 字符串本身不变，而是得到了列表对象
my_str_list = my_str.split(" ") # 以空格作为分割

print(my_str_list,type(my_str_list))

my_str_list1 = my_str.replace(" ", "|") #把空格换成|
my_str_list2 = my_str_list1.split("|") #用|作为分割
print(my_str_list2) # 打印

字符串的规整操作(去句子首尾空格)

1.字符串.strip()
print(my_str.strip())
2.my_str = "21you and me12"
print(my_str.strip("12")) # 结果： “you and me”
==注意：传入的是“12”，其实就是：“1”和“2”都会被移除

统计字符串的长度 len()

num = len(my_str)

统计字符串中某字符串出现的次数

字符串.count("想要统计的字符串")

序列 可直接在其他操作上用

序列是指：内容连续，有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列

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

语法： 序列[起始下标:结束下标:步长] 注：步长为负数表示，则起始下标和结束下标也要反过来，大的在前，小的在后
序列[:] # 都不写，表示从头到尾，步长为1可省略

# 以下是打印黑马程序员的操作
str3 = "万过薪月，员序程马黑来，nohtyp学"
# 倒叙字符串，切片取出
result1 = str3[::-1][9:14]
print(result1)
# 切片去除，然后倒叙
result2 = str3[5:10][::-1]
print(result2)

集合 元素不重复，且无序，不是序列

my_set = {"tan","tan","tan","tan","tan","djak"}
打印结果：
{"djak","tan"} # 本身会去重

添加新元素/移除元素

my_set.add("输入新添加的元素")
my_set.remove("输入要删除的元素")

随机取出元素

element = my_set.pop()
取出这个元素后，原集合就没有这个元素了

求集合的差集

语法： 集合1.difference(集合2)
功能：取出集合1有而集合2没有的元素
结果：得到一个新集合，集合1与集合2不变

消除2个集合的差集

语法：集合1.difference_update(集合2)
功能：在集合1中，删除和集合2相同的元素。
结果：集合1被修改，集合2不变

2个集合合并

语法：集合1.unior(集合2)
功能：将集合1与集合2合并组成新集合，原集合不变
set3 = set1.unior(集合2)

统计集合中元素个数 len()

见上

集合的遍历

因其无下标索引，所以不能用while循环，但可以用for循环
for element in set1
print(f"集合里的元素有{element}”)
、

字典 不支持下标索引，不能用while循环

作用原理：利用key来找到value

key	value
田文哲	100分
你	32分
他	23分

定义：

my_dict = {key:value,key:value,......,key:value}
my_dict = {"田文哲":100，"你":23}

空字典：

• my_dict = {}
• my_dict = dict{}

使用：

score = my_dict{"田文哲"}
print("田文哲得分是{score}")

字典的嵌套

注意：key 不能为字典
stu_score_dict = {
"田文哲":{"语文"：100,"数学101"}，"ni":{"语文":0,"数学":0}
}
获取数据print(stu_score_dict["田文哲"]["语文"])

字典的常用操作

• 新增/修改元素
  语法： 字典[key] = value, 当key值不存在时，就等于新添加了元素，有对应key值，则就是修改了value
• 删除元素
  字典名.pop(key)，结果：获取指定key的value，同时更是字典被修改，指定key的而数据被删除，用一个新变量接收这个数据
• 清空字典
  字典名.clear()
• 获取全部的key
  keys = my_dict.keys()
  print(keys)
• 字典的遍历
  -- 法1
  print(f"字典的key是：{key}")
  print(f"字典的value是：{my_dict[key]}" )
  -- 法2
  for key in my_dict:
  print(f"字典的key是：{key}")
  print(f"字典的value是：{my_dict[key]}" )
• 统计元素数量
  num = len(my_dict)

数据容器的普遍操作：

• len(容器) 统计元素个数
• max(容器) 统计容器的最大元素
• min(容器) 统计容器的最小元素

除了上述共性之外，还有：

• list(容器) 将给定容器转换为列表
• str() 将给定容器转换为字符串
• tuple(容器) 将给定容器转换为元组
• set(容器) 将给定容器转换为集合
  字典转元组的结果是：只保留key，抛弃value
  转字符串就保留value了

还有
sorted(容器) 从小到大排序，并放入列表当中
sorted(容器，reverse = True) 从大到小排序，并放入列表当中

字符串比大小
"dasfsdaf" <"fdsafsdaf" #返回值是 Ture 或者 False
利用ascii码表比较

文件的读取

f = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
f1 = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
f2 = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
print(type(f))    # 输出结果文件类型是：对文本文件进行IO操作功能的一个类
# 读取文件  利用变量名所存的文件，加上  .read(这输入你想读取的字节)    下面是例子
print(f"读取全部字节的结果：{f.read()}")
# 值得注意的是：下一个read函数，接着上一个read函数的末尾开始的  你看：下面就已经是没有内容了
print(f"读取全部字节的结果：{f.read()}")
lines = f1.readlines()  # 读取文件的全部行，封装到列表中
print(f"d读取全部行的结果：{lines}")   # 注意输出，他每一行算是一个元素， 还有换行符'\n'
# 接下里是readline方法 使用一次，仅去一行函数
line1 = f2.readline()
print(line1)
# 下面是for循环读取文档
# for line2 in f:
#    print(line2)
# 每一个line临时变量，就记录了文件的一行数据

# 关闭文件操作： .close()
f.close()

# with open语法
with open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8") as f3:
    f3.readlines()
# 执行完该语句块自动关闭文件

os模块

爬虫里面用的多

首先理解相对路径和绝对路径
绝对路径：参考的是我们的磁盘
相对路径:参考的是当前的文件 ：
类如与main.py处于同一个文件夹下，则直接
open("文件名.txt")即可，若在同一根目录下，则直接
"./所在文件夹/文件名.txt"即可

• os.walk(path)

作用 ：传入任意一个path路径，深层次遍历指定路径下的所有子文件夹；

返回的是一个由路径、文件夹列表、文件列表组成的元组。代码中写的方式属于元组拆包；

元组拆包：就是将一个元组中的每个值，赋值给不同的变量；

import os

dir1 = os.path.dirname(__file__)   #  # 就是获得这个main.py的绝对路径

if not os.path.exist('这不是新建目')   # 判断文件是否存在·
    os.mkdir("这不是新建目")  # 创建目录




# os.mkdir("这不是新建目")   # 创建文件夹
# os.rmdir("这不是新建目录")   # 删除文件夹，如果文件夹里有东西则是删不掉的

path = os.path.abspath("输入路径")  # 这是获取一个文件的地址


os.remove(path)    # 输入路径，就能删除相应文件了  
a = os.getcwd()      这个也是获取当前文件的绝对路径
print(a)
path = "D:/RM战队任务"
print(os.listdir(path))  # 浏览一个文件夹
paths = "D:/Genshin Impact"
#
#for path, dirs, files in os.walk(paths):
    # print(dirs)
  #  print(files)
 #   print("\n")
#
x = os.path.join(path, paths)
print(x)

拆分与拼接

拆分:

• path2 = os.path.split("D:\笔记\python用文档.txt") 传入个文件地址，拆成了一个元组，可以利用下标索引，path[0]为
  D:\笔记\，path[1] = python用文档.txt
• path3 = os.path.splitext("D:\笔记\python用文档.txt")
  这样就是 path[0] = D:\笔记\python用文档,path[1] = .txt
  拼接：
  os.path.join(path[0], path[1])

注1：python不支持i++这种需要写成i+=1

注2：print("这是不换行的标志"，end=''),python同样支持\t换列对齐（同时不换行）

注3：print("D:/test.txt") r符号

我想打印D：/text.txt,但是有换列字符/t，为了让他不进行换列操作，我们可以使用print(r"D:/test.txt"),r这个特殊符号