chenge-first-blog

基础篇

debug、注释、输出函数、输入函数

debug

#debug中代码为蓝色时，表示即将要运行的代码

#Run to Cursor 跳到下一个断点的位置

总结：可以通过debug调试看到程序执行的顺序

注释

单行注释，以#号开头

多行注释，三引号

快捷键：Ctrl+/

输出函数print

print（*values，sep, end）其中：

1. *value 值，表示一次可以输出多个对象，输出多个对象时，需要用逗号（，）分隔
2. sep 就是用来间隔多个值，默认是空格
3. end 用来设定用什么结尾，默认是换行符’\n‘，可以换成其他字符

输入函数input

input（prompt） prompt是提示，会在控制台显示

注：用户输入的是字符串类型

变量

变量可以被反复赋值

标识符

关键字

Python中已经使用的标识符，具有特殊的功能和含义

变量命名规范

1. 见名知义
2. 下划线分隔法：

多个单词的名称，使用小写字母，单词与单词之间用下划线分开

3.大驼峰命名法:

多个单词组成的名称，每个单词的首字母大写，其余字母小写

4.小驼峰命名法:

第一个单词首字母小写，后面单词首字母大写，其余字母小写

格式化输出

占位符

生成一定格式的字符串

%

1. %s 字符串（常用）

name='sunhao'
print("名字：%s"%name)

注：占位符只会占据位置，并不会被输出

1. %d 整数（常用）

age=19
name='sunhao'
print("名字：%s，年龄：%d"%(name,age))

3.%f 浮点数（常用）

#默认六位小数，遵循四舍五入原则

2.f格式化

格式：

f“{表达式}”

运算

1.除号 ’/‘

与C语言中不同，python中结果为浮点数，’//‘这个符号才是整除

注意：整除的时候，向下取整，不管四舍五入的规则，只要后面有小数，全部忽略

2.取余 ’%‘

只取余数部分

#注意
print(7.0//2)#3.5
#使用算术运算符，其中若有浮点数，结果也会用浮点数表示

转义字符

# 1. \t 制表符   通常表示四个字符  也称缩进
# print(name\tage)
# 2.  \n  换行符  表示当前位置移动到下一行的开头
# print('哈哈\n嘻嘻')
# 3.  \r  回车   表示当前位置移到本行开头
# print('six\rstar')#star
# 4.  //  反斜杠符号
# print('six\\star')#six\star
# 5.
# print(r'six\\\star')#six\\\star     r原生字符串，默认取消转义

循环

while循环

while 条件：
    循环体
    改变变量

注：若不改变变量则成为死循环

相当于：

while True：#若改为False，则不会执行
    循环体

打印九九乘法表（while循环嵌套应用）

#打印九九乘法表
a=1
while a<=9:
    b=1
    while b<=a:
        print(f'{a}*{b}={a*b}',end='\t')
        b+=1
    print()
    a+=1

for循环

#基本格式
for 临时变量 in 可迭代对象：
    循环体
#range（）
#用来记录循环次数，相当于一个计数器
range(start,stop,step)#前面包含，后面不包含
#不写开始，默认从零开始

#字符串是一个可迭代对象

break和continue关键字

break

中途退出，结束循环

continue

结束当前循环，进入下一次循环

注意：

在continue之前，一定要修改计数器，否则会进入死循环

字符串

#字符串编码转换
#a='hello'
#print(a,type(a))#str,字符串是以字符为单位进行处理
#a1=a.encode("utf-8")  #编码
#print("编码后："，a1)
#print(type(a1))  #bytes,以字节为单位进行处理的
#a2=a1.decode("utf-8")  #解码
#print(a2,type(a2))

字符串常见操作

字符串拼接

’+‘：

print('10'+'10')#1010   字符串相加，等于字符串拼接

num1='20'
num2='40'
print(num1+num2)#2040
print(num1,num2,sep='')

重复输出

’*‘

print('字符串'*3)#字符串字符串字符串
#需要输出多少次，’*‘后面写多少

查找

# 查找
#1.find：检测某个子字符串是否包含在字符串中，如果在就返回这个子字符串开始未知的下标，否则返回-1
#find(子字符串，开始位置下标，结束位置下标)
#注意：开始和结束位置下标可以省略，表示在整个字符串中查找
name='sunhaou'
print(name.find('u'))#1  --第一个u的下标为1
print(name.find('sun'))#0  --检测到第一个sun，s的下标为0
print(name.find('s',2))#-1  --超出范围，不包含，返回-1
print(name.find('h',3,5))#3

#2.index():检测某个子字符串是否包含在字符串中，如果在就返回这个子字符串开始未知的下标，否则就会报错
#index(子字符串，开始位置下标，结束位置下标)
name='我命由我不由天'
print(name.index('命'))   #1
# print(name.index('命',2))  #报错

#3.count():返回某个子字符串在整个字符串中出现的次数，没有就返回0
name=('suunhao')
print(name.count('u'))  #2
print(name.count('x'))  #0

判断

#判断
#1.startswith():是否以某个子字符串开头，是的话就返回True,不是的话就返回False,如果设置开始和结束位置
#则在指定范围内检查
st=('sixstar')
print(st.startswith('six'))  #True
print(st.startswith('s',2,6))  #False

#2.endwith():是否以某个子字符串开头，是的话就返回True,不是的话就返回False,如果设置开始和结束位置
#则在指定范围内检查
st=('sixstar')
print(st.endswith('ar'))  #True
print(st.endswith('er'))  #False

#3.isupper():检测字符串中所有字母是否为大写，是的话返回True
st=('sixstar')
print(st.isupper())  #False
print('SIX'.isupper())  #True

字符串的成员运算符

作用：检查字符串中是否包含了某个子字符串（即某个字符或多个字符）

in：如果包含返回True，不包含返回False

not in：如果不包含返回True，包含返回False

字符串修改

修改元素
# 1.replace():替换
#replace（旧内容，新内容，替换次数）
#注意：替换次数可以省略，默认为全部替换
name='好好学习，天天向上'
print(name.replace('天','时'))#好好学习，时时向上
print(name.replace('天','时',1))#好好学习，时天向上

#2.split('分隔符'，分隔次数):指定分隔符来切字符串
#注：分割后，不包含分隔符
st='hello,python'
print(st.split(','))#['hello', 'python']  --以列表的形式进行返回
#如果字符串中不包含分隔内容，就不进行分割，会作为一个整体
print(st.split('a'))#['hello,python']

# 3.capitalize():第一个字符大写
st='hello'
print(st.capitalize())#Hello

# 4.lower():大写字母转为小写
st='JGYhsuw'
print(st.lower())#jgyhsuw

# 5.upper():小写字母转为大写
st='hello'
print(st.upper())#HELLO

列表

列表常见操作

#1.添加元素
append():整体添加元素

extend():分散添加，将另一个类型的元素逐一添加
注意：
    a=[1,2,3]
    a.extend(4)  #报错，extend添加的只能是可迭代对象

insert():在指定位置添加元素

#2.删除元素
del：
    用法：
    1.del 列表名
    2.del 列表名[下标]#删除对应元素

pop：
    删除指定下标的数据，python3默认删除最后一个
列表名.pop(下标)

remove：根据元素的值进行删除
    列表名.remove(列表中的元素)
注：
1.元素不在列表中会报错
2.默认删除最开始出现的指定元素

#3.排序
sort：将列表按特定顺序重新排序，默认从小到大
    列表名.sort()

reverse:倒序
    列表名.reverse()

#4.列表推导式
格式一：[表达式 for 变量 in 列表]
in 后面不仅可以放列表，还可以放range()、可迭代对象

格式二：[表达式 for 变量 in 列表 if 条件]
#将奇数放到列表中
li=[]
[li.append(i) for i in range(1,11) if i%2==1]
print(li)#[1, 3, 5, 7, 9]

元组

1.只支持查询操作，不支持增删改操作

2.count（），index（），len（）与列表的用法相同

3.可以进行切片操作

应用：

1. 函数参数和返回值
2. 格式化输出后面的（）本质就是一个元组

#格式化输出
name='sunhao'
age=19
info = (name,age)
print(type(info))
print('%s的年龄是：%d'%info)

字典

注：

1. 字典中的键具有唯一性，但是值可以重复
2. 键名重复不会报错，会被后面的值进行覆盖

字典常见操作一

#字典常见操作一
#查看元素
变量名[键名]#键名不存在会报错

变量名.get('键名','不存在时的返回值')#不存在默认返回None

#修改元素和新增元素
#变量名[键名] = 值
键名存在修改,不存在新增

#删除元素
#1.del
#删除整个字典    del 字典名

# 删除指定键值对   del 字典名['键']
#键名不存在就会报错

#2.clear()
#清空整个字典里面的东西，但保留了这个字典
#用法：字典名.clear()

#3.pop()
#删除指定键值对，键不存在就会报错
#用法：字典名.pop()

#4.popitem()
#3.7后的版本默认删除最后一个键值对

字典常见操作二

#字典常见操作二
#1.len()求长度
#用法：len(字典名)，得到键值对的个数

#2.keys():返回字典里面包含的所有键名
#用法：字典名.keys()

#3.values():返回字典里面包含的所有值

#4.item():返回字典里面包含的所有键值对
#键值对以元组形式

集合

注意：
s1={}  #定义空字典
s2=set() #定义空集合

#集合具有无序性和唯一性
#无序性：不能修改集合中的值
#唯一性：可以自动去重

集合的常见操作

#集合中的常见操作
#1.添加元素
#add()  添加的是一个整体
#由于集合的唯一性，元素在集合中已经存在就不进行任何操作
# 注意:add()一次只能添加一个元素，这一个元素也可以是元组
s1={1,2,3,4}
s1.add(5)
print(s1)  #{1, 2, 3, 4, 5}
s1.add((4,5))
print(s1)  #{1, 2, 3, 4, 5, (4, 5)}

#update  把传入的元素拆分，一个一个放进集合中
s2={1,2,3,4}
s2.update([4,5,6]) #元素必须是能够被for循环取值的可迭代对象
print(s2)#{1, 2, 3, 4, 5, 6}

#2.删除元素
#remove：选择删除的元素，集合中有就删除，没有就报错

#pop：对集合进行无序排列，删除左边第一个元素

#discard：选择要删除的元素，有就删除，没有就不进行任何操作

#交集和并集
# A & B:表示A和B的交集
# A | B:表示A和B的并集

深浅拷贝

赋值

等于完全共享资源，一个值的改变会完全被另一个值共享

浅拷贝

#浅拷贝
#会创建心得对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
import copy  #导入copy模块
li=[1,2,3,[4,5,6]]
li2=copy.copy(li)
print('li的内存地址',id(li))
print('li2的内存地址',id(li2))
#内存地址不同，说明不是同一个对象
li.append(8)
print('li',li)#li [1, 2, 3, [4, 5, 6], 8]
print('li2',li2)#li2 [1, 2, 3, [4, 5, 6]]
li[3].append(9)
print('li',li)#li [1, 2, 3, [4, 5, 6, 9], 8]
print('li2',li2)#li2 [1, 2, 3, [4, 5, 6, 9]]

print('li[3]的内存地址',id(li[3]))
print('li2[3]的内存地址',id(li2[3]))#嵌套列表的内存地址是一样的
# 优点:拷贝速度快,占用空间少,拷贝效率高

深拷贝

#深拷贝(数据完全不共享)
#外层的对象和内部的元素都拷贝了一遍
import copy
li2=copy.deepcopy(li)#深拷贝
#外层和内部的内存地址都不同

可变对象

含义：变量对应的只可以修改，但是内存地址不会发生改变

常见可变类型：

1. list #列表
2. dict #字典
3. set #集合

不可变对象

含义：变量对应的值不能被修改，如果修改就会产生一个新的值从而分配新的内存空间

1. 数值类型：int、bool、float、complex
2. 字符串：str
3. 元组：tuple

注意：深浅拷贝只针对可变对象

函数

注意：

1. 遇到return，以下的语句不执行
2. return返回多个值，是以元组的形式返回
3. 若return后为空，则返回None

函数参数

# 默认参数
# 设置默认值，没有传值会根据默认值来执行代码，传了值根据传入的值来执行代码
# 注意：
# 所有的位置参数必须出现在默认参数前，包括函数定义和调用

# 可变参数
# 传入的值的数量是可以改变的，可以传入多个，也可以不传
# 格式：def func(*args):
# 传入的数据以元组形式接收

# 关键字参数
# 格式：def fun(**kwargs)
# 传入的数据以字典形式接收
# 传值：fun(name='sunhao',age=19) # 以键等于值的方式去传值
# def fun(**kwargs):
#     print(kwargs)
# fun(name='sunhao',age=19) # {'name': 'sunhao', 'age': 19}以字典形式返回

全局变量

# 在函数中定义全局变量：
a=100
def funb():
    print(a)

def func():
    global a
    a=120
    print(a)

print('函数执行前a的值',a) # 100
funb()#100
func()#120
print('函数执行后a的值',a)#120

#注意：
global关键字可以对全局变量进行修改吗，也可以在局部作用域中声明一个全局变量

nonlocal关键字 –了解：

用来声明外层函数的局部变量，在外部函数先进行声明，内层进行nonlocal声明

注意：

1. 在嵌套函数内使用
2. 只能对上一级进行修改

def outer():
    a=5
    def inner():
        nonlocal a
        a=20
        def inner2():
            # nonlocal a
            a=30
            print('inner2:',a)
        inner2()
        print('inner:',a)
    inner()
    print('outer:',a)
outer()

匿名函数（lambda关键字的使用）

#匿名函数
#语法：
#函数名 = lambda 形参 ： 返回值（表达式）
#调用：结果 = 函数名（实参）

#普通函数
# def add(a,b):
#     return a+b
# print(add(1,3)) # 4
# 匿名函数
add = lambda a,b : a+b #不需要return，表达式本身就是返回值
print(add(1,3))#4


#lambda的参数形式
#函数名 = lambda 形参 ： 返回值（表达式）
#无参数
funa = lambda :"sunhao"
print(funa())
#一个参数
funb = lambda name:name
print(funb('sunhao'))
#默认参数
func = lambda name,age=18:(name,age)
print(func('sunhao')) # ('sunhao', 18)
print(func('sunhao',20)) # ('sunhao', 20)
fund = lambda a,b,c=12:a+b+c
print(fund(1,2)) # 15
#注意：默认参数必须写在非默认参数后面
#关键字参数
fune = lambda **kwargs : kwargs
print(fune(name='xunhao',age=19))#{'name': 'xunhao', 'age': 19}

lambda的应用

# lambda结合if判断
# a=5
# b=8
# #为真结果 if 条件 else 为假结果
# print('a比b小') if a<b else print('a大于等于b')
comp = lambda a,b : 'a比b小' if a<b else 'a大于等于b'
print(comp(4,1)) # a大于等于b

内置函数

#内置函数
#查看内置函数
# import builtins
# print(dir(builtins))
#大写字母开头一般是内置常量名，小写字母开头一般是内置函数名

#内置函数一：
#abs():返回绝对值

#sum():求和
#注意：sum(123)和sum('123')都是不被允许的
#sum函数内要放可迭代对象（字符串除外）
#运算时，只要有一个浮点数，结果就会是浮点数

#内置函数二：
# min():求最小值
# max():求最大值
# print(min(-8,5,key=abs))#5  传入了绝对值函数，则参数就会先求绝对值，再比较

#zip():将可迭代对象作为参数，将对象中对应的元素打包成一个元组
li = [1,2,3]
li2 = ['a','b','c']
print(zip(li,li2))
#第一种方式：通过for循环
for i in zip(li,li2):
    print(i)
#如果长度不一致，按照长度最短的返回
#第二种方式：转化成列表打印
print(list(zip(li,li2)))#[(1, 'a'), (2, 'b'), (3, 'c')]

#map():
#map(func,iter1):func--定义的函数，iter1--可迭代对象
li = [1,2,3]
# def func(x):
#     return x*5
func = lambda x : x*5#和上面函数相同
mp = map(func,li)
#用for循环取出
# for i in mp:
#     print(i)
#转化成列表打印
print(list(mp)) # [5, 10, 15]

#reduce():先把对象中的两个元素取出，计算出一个值，然后保存着，接下来把这个计算值跟第三个元素进行计算
from functools import reduce
#reduce(有两个参数的函数，可迭代对象)
li2 = [2,3,4,5]
add = lambda x,y : x+y
res=reduce(add,li2)
print(res) # 14

拆包

#拆包
#含义：对于函数中的多个返回数据，去掉元组，列表或者字典直接获取里面数据的过程
tua = (1,2,3,4)
#方法一
a,b,c,d = tua
print(a,b,c,d) # 1 2 3 4
#要求元组内的个数与接收变量的个数相同
#方法二
a, *b = tua
print(a,b)#1 [2, 3, 4]
#一般在函数调用时使用
def funa(a,b,*args):
    print(a,b)#1 2
    print(args,type(args))#(3, 4, 5, 6, 7) <class 'tuple'>
funa(1,2,3,4,5,6,7)

异常、模块和包

异常

常见异常种类

异常处理

捕获异常

#异常处理（捕获异常）
#语法格式1：
# try:
#     不确定是否能正常执行的代码  #一般只放一行尝试代码
# except:
#     如果检测到异常,就执行这个位置的代码
#
# try:
#     不确定是否能正常执行的代码  #一般只放一行尝试代码
# except Exception as e:   #Exception万能异常，捕获任意异常类型
#     #as 相当于取别名，e是变量名，可以自定义，as e相当于把异常信息保存到变量e中去
#     如果检测到异常,就执行这个位置的代码
#     print(e)#打印异常信息
#
# #语法格式二：
# try:
#     可能会引发异常的代码
# except:
#     出现异常的处理代码
# else:
#     没有捕获到异常执行的代码
# 例:
li=[1,2,3,4]
try:
    print(li[3])
except:
    print('超过下标范围')
else:
    print('程序正常')  #4  程序正常

#第三种格式：
try:
    print('abc')
except Exception:
    print('这一行代码有错误')
else:
    print('程序正常')
finally:
    print('无论怎样都会被执行')
#注意：可以单独使用try...finally，也可以配合except等使用

抛出异常

#抛出异常 raise
#步骤:
#1.创建一个Exception('xxx')对象，xxx--异常提示信息
#2.raise抛出这个对象(异常对象)
#需求:密码长度不足，就报异常
#分析:用户输入密码，判断输入的长度是否大于等于6，如果输入长度不足6位，就报错，即抛出自定义异常，并捕获该异常
def login():
    pwd = input('请输入您的密码:')
    if len(pwd)>= 6:
        return '密码输入成功'
    raise Exception('长度不足六位，密码输入失败')
# print(login())
try:
    print(login())
except Exception as e:
    print(e)

模块

内置模块

如：random、time、os、logging，直接导入即可使用

第三方模块（第三方库）

通过cmd窗口输入pip install 模块名下载

自定义模块

注意：命名要遵循标识符规定以及变量命名规范，且不要与内置模块产生冲突

模块导入

导入模块方式一

格式：import 模块名

模块：

导入模块：

导入模块方式二

格式：from…import…

#从模块中导入指定部分

from 模块名 import 功能1，功能2...
#调用之后直接输入功能，不需要添加模块名
#例：
from test import funa#导入函数只需要函数名，不需要加上（）
funa()

导入模块方式三

语法：
from 模块名 import *
#把模块中所有内容全部导入
注意：
不建议过多使用from...import...有时命名冲突会导致一些错误

导入模块方式四

#as取别名
#1.给模块起别名
语法：
import 模块名 as 别名
import test as ts
ts.funa()  #这是test模块 这是test模块中的funa

#2.给功能起别名
语法：
from 模块名 import 功能 as 别名
from test import funa as a,name
a()  #这是test模块中的funa
print(name)  #sunhao

内置全局变量

内置全局变量__name__
语法：
if __name__ =="__main__":
作用：
用来控制py文件在不同的应用场景执行不同的逻辑
#__name__
#1.文件在当前程序执行(自己执行自己)：__name__=="__main__"
#2.文件被当做文件被其他文件导入：__name__==模块名

#模块test.py
print('这是会显示的内容：')
def test():
    print('啊哈哈哈')
# test()
if __name__=="__main__":  #被当做模块导入时，下面的代码不会被显示出来
    print('这是不会显示的内容')

#导入模块
import test
test.test()#这是会显示的内容： 啊哈哈哈

包

包和普通文件夹的区别：

创建包时会自动生成一个__init__.py文件

主函数

#import 导入包时，首先执行__init__.py文件中的代码
#导包方式一
# import pack_01  #这里是__init__.py

#导包方式二
# from pack_01 import register
# register.reg()  #这里是__init__.py   这里是register

#__all__:本质上是一个列表，列表里面的元素就代表要导入的模块
#作用：可以控制要引入的东西
from pack_01 import *
register.reg()
login.log()
__init__.py文件
# print('这里是__init__.py')
# #不建议在init文件中写大量代码
# #主要作用：导入这个包内的其他模块
# from pack_01 import register
# # register.reg()

__all__ = ['register','login']   #相当于导入列表里面定义的模块


模块register

def reg():
    print('这是注册函数')
# reg()

模块login

def log():
    print('这里是登录函数')

闭包&装饰器

递归函数实现斐波那契数列

#递归函数简单实现斐波那契数列
def funa(n):
    if n <= 1:
        return n
    else:
        return funa(n-1)+funa(n-2)

print(funa(5))  #5

闭包函数的简单使用

#闭包
#条件：
#1.函数嵌套(函数里面再定义函数)
#2.内层函数使用外层函数的局部变量
#3.外层函数的返回值就是内层函数的函数名
def outer():
    n=10
    def inner():
        print(n)
    return inner

# print(outer())  #返回内部函数的内存地址
# 第一种写法
# outer()()  #10
#第二种写法
ot = outer()  #调用外函数
ot()   #10   调用内函数

#闭包函数的使用二
def outer(m):
    n = 10
    def inner(o):
        print('计算结果：',m+n+o)
    return inner

ot = outer()  #调用外函数
ot(20)  #50


#闭包函数使用三
def outer(m):
    print('outer函数中的值',m)
    def inner(n):
        print('inner函数中的值',n)
        return m+n
    return inner

ot = outer(10)  #调用外函数
# print(ot(20))  #30
print(ot(30))   #40

装饰器

#装饰器
#1.标准版装饰器
def send():
    print('发送消息')

def outer(fn):   #外层函数，fn是形参，传入的是被装饰的函数名
    def inner():
        print('登录...')
        #执行被装饰的函数
        fn()
    return inner

ot = outer(send)
ot ()

#2.语法糖
#格式：@装饰器名称
def outer(fn):
    def inner():
        print('登录...')
        fn()
    return inner

@outer
def send():
    print('发送消息')

send()

注意：有多个装饰器的时候，离函数最近的装饰器先装饰，由内到外的过程

面向对象

面向过程和面向对象

面向过程，就是先分析出解决问题的步骤，再把步骤拆成一个个方法是没有对象去调用的，通过一个个方法的执行解决问题

面向对象，就是将编程当成是一个事物(对象),对外界来说，事物是直接使用的，不用去管内部的情况，而编程就是设置事物能做什么事情。

类和对象

类

类的三要素：

1. 类名
2. 属性：对象的特征描述，用来说明是什么样子的
3. 方法：对象具有的功能（行为），用来说明能做什么

#定义类
#基本格式
# class 类名:   #类名必须符合标识符标准，见名知意
#     代码块
class Washer:
    height=800  #类属性：就是类说拥有的属性
# 查看类属性： 类名.属性名
print(Washer.height)  #800
# 新增雷属性： 类名.属性名 = 值
Washer.width = 450
print(Washer.width)  #450

# 创建对象（实例化对象）
# 格式： 对象名 = 类名（）
wa = Washer()
print(wa)  #<__main__.Washer object at 0x00000259461C7890>

wa2 = Washer()
print(wa2)  #<__main__.Washer object at 0x00000259461C7910>
# 地址不同，说明是不同的对象，可以实例化多个对象

实例方法和实例属性

#实例方法
# 由对象调用，至少有一个self参数，执行实例方法的时候，自动调用该方法的对象赋值给self
class Washer:
    height = 800
    def wash(self):  #self表示当前调用该方法的对象
        print('我会洗衣服')

#实例化对象
wa = Washer()
wa.wash()

wa2=Washer()
wa2.wash()
#实例方法和实例属性
# 实例属性
# 格式：self.属性名
class Person:
    name = '孙昊'
    def introduce(self):   #self是实例属性
        print('我是实例方法')
        print(f'{Person.name}的年龄:{self.age}岁')

pe = Person()
pe.age = 19
pe.introduce()
pe.sex = '男'
print(pe.sex)
# print(Person.name)
# print(Person.sex)  #报错，实例属性只能由对象名访问，不能由类名访问
'''
print(pe.name)
print(Person.name)
访问类属性，类可以访问到，实例对象也可以访问到
'''

# 实例属性和类属性的区别
# 类属性属于类，是公共的，大家都能访问到，实例属性属于对象的，是私有的
# 只能由对象名访问，不能由类名访问

构造函数

#每实例化一次就需要添加一次，效率不高，可以用到构造函数
#构造函数__init__()
# 作用：通常用来做属性初始化或者赋值操作
# 注意：在类实例化对象的时候，会被自动调用
# class Test :
#     def __init__(self):
#         print('这是__init__函数')
#
# te = Test()

class Person :
    def __init__(self,name,age,height):
        self.name= name  #实例属性
        self.age= age
        self.height= height
    def play(self):
        print(f'{self.name}在打王者荣耀')
    def introduce(self):
        print(f'{self.name}的年龄是{self.age},身高是{self.height}cm')

# pe = Person()
# pe.play()
# pe.introduce()

pe = Person('sunhao',19,180)
pe.play()
pe.introduce()

析构函数

#析构函数 __del__()
#删除对象的时候，解释器默认调用__del__()方法
class Person:
    def __init__(self):
        print('这是__init__()')
    def __del__(self):
        print('被销毁了')
p = Person()
print('这是最后一行代码')
#正常运行时，不会调用__del__()，对象结束后，系统会自动调用
# __del__()主要是表示该程序块或者函数已经全部执行结束

文件操作

文件的基本操作

#文件对象的方法
#1.open():创建一个file对象，默认是以只读模式打开
#2.read(n):n表示从文件中读取的数据的长度，没有传n值就默认一次性读取文件的所有内容
#3.write():将指定内容写入文件
#t.close():关闭文件

#属性
#文件名.name:返回要打开的文件的文件名，可以包含文件的具体路径
#文件名.mode:返回文件的访问模式
#文件名.closed:检测文件是否关闭，关闭就用True

f = open('test.txt')
print(f.name)
f.close()

读写操作

#读写操作
#1.read(n)
f = open(r'C:\Users\28311\Desktop/test.txt')  #调用桌面文件
print(f.read())
f.close()
#2.readline():一次读取一行内容，方法执行完，会把文件指针移到下一行，准备再次读取
f = open('test.txt')
print(f.readline())
print(f.readline())
print(f.readline())#一行一行读取
while True:
    text = f.readline()
    if not text :
        break
    print(text,end='')

# with open('test.txt') as f:
#     for text in f:
#         print(text, end='')  # 如果不需要额外的换行符，可以使用end=''
# # 使用with语句可以确保文件在读取完成后被正确关闭
#3.readlines():按照行的方式一次性读取全部内容
#返回的是一个列表，每一行数据就是列表中的一个元素
f = open('test.txt')
text = f.readlines()
# print(text)   #返回列表
for i in text:
    print(i,end='')
f.close()

访问模式

#文件定位操作
#tell()和seek()
#tell():显示文件内当前位置，即文件指针当前位置
#seek(offset,whence):移动文件读取指针到当前位置
#offset ：偏移量，表示要移动的字节数
#whence ：起始位置，表示移动字节的参考位置，默认是0,0代表文件开头作为参考位置，1代表当前位置作为参考位置，2代表将文件结尾当成参考位置
# seek(0,0)就会把文件指针移到文件开头
f = open('test.txt','w+')
f.write('hello python')
pos = f.tell()         #文件内容长度
print('当前文件所在位置：',pos)
f.seek(0,0)
pos1 = f.tell()
print('当前文件所在位置：',pos1)
print(f.read())  #hello python
f.close()

with open

#with open
# 作用：代码执行完，系统会自动调用f.close(),可以省略关闭步骤
with open('test01.txt','w') as f:
    f.write('emmmmm...')
print(f.closed)   #True

编码格式

#编码格式
# with open('test01.txt','w',encoding='utf-8') as f:
#     f.write('孙昊18岁！')

# with open('test01.txt',encoding='utf-8') as f:
#     print(f.read())

#案例：图片复制  'rb'
'''
1.读取图片
图片是一个二进制文件，想要写入必须要先拿到
2.写入图片
'''
#读取图片
with open(r'C:\Users\28311\Desktop\新建文件夹\图片.jpg','rb') as f:
    img = f.read()
    print(img)
#将读取到的内容写当前文件中
with open(r'D:\pythonpro\孵化基地python\图片.jpg','wb') as file:
    file.write(img)

获取目录操作

常见操作

#导入模块
import os
#1.文件重命名 os.rename(旧名字，新名字)
# os.rename('test01.txt','sunhao')
#2.os.remove()
# os.remove('sunhao')
#3.创建文件夹 os.mkdir()
# os.mkdir('sunhao')  #创建一个空的文件夹
#4.删除文件夹 os.rmdir()
# os.rmdir('sunhao')
#5.获取当前目录 os.getcwd()
# print(os.getcwd())  #D:\pythonpro\孵化基地python
#6.获取目录列表
# print(os.listdir())   #获取当前目录列表
# print(os.listdir('../'))  #获取上一级目录列表