python

python介绍

python的版本：python2 和python3(主流)
语言分类
计算机只认识2进制（0和1）
语言分为编译型通过编译器最终形成可执行文件和解释性语言（实时翻译，需要解释器一边解释，一边去执行，下方代码出错，不会影响上边代码的执行）
1.编译语言：解释型（python）、编译型（java，c,c++）
环境搭建
python环境就是python解释器环境 ，执行.py文件
添加环境变量：让程序可以在任意的目录下去执行（cmd）
pycharm:是python最好用的IDE(集成开发环境)之一
pycharm：写python代码的工具
pycharm的使用
新建hello代码
在终端cmd执行代码
Python解释器 Python代码路径
二、python包管理
pip 用来管理第三方包
1.查看已经安装的python包
pip list
2.安装:pip install package_name
3.卸载：pip uninstall package_name
4更新：pip install -u package_name
5.虚拟环境相关
导出依赖包
pip freeze >requirement.txt
安装依赖包
pip install -r requirement.txt
三、python语法
1.通过缩进来区分代码块
tab键=4个空格键
2.换行，表示一行代码执行结束了
3.注释 #空格 快捷键ctrl+/ 单行注释
“”" 三个单引号，双引号 多行注释
4.输出 print(‘’) 或者print(“”)
换行不换行？ 不想输出换行->可以直接enter键 可读性好
5波浪线
红色波浪线：代码中的错误，需要解决，否则影响代码执行 Indent(缩进问题)
灰色波浪线：不影响代码的执行，代码书写规范问题，但是代码可以正常运行
可以点code-》Reformat Code格式化代码
绿色波浪线：pycharm 认为你写的单词不对

续行符号，就是不换行
str="hello"\
    'python'
print(str)

python变量和标识符
1.变量：保存数据，先定义后使用
定义语法：变量名=数据值
=就是赋值
2.变量命名规则：
1）字母，数字和下划线组成，
2）不能以数字开头，
3）不能是关键字，
4）区分大小写，
5）可读性强
3. 标识符
用来指定某个实体的符号
变量，包名称，文件名称，函数名称，类名称
命名风格 大驼峰，小驼峰，下划线连接符
建议命名风格
类名：大驼峰
变量名、函数名：下划线连接符
python常用数据类型
数字型
1.数值 int float
2.布尔
非数字型
3.字符串 “” ‘’
使用“”的就是
4.元组
tuple（1，2，3，4）
5.列表
list[1,2,3]
6.字典
dict{“name”：“小明”}
7.集合
set{1,2,3,5}
8.None
怎么判断变量的数据类型

type(str_1)//获取str_1的类型 
print(isinstance(str_1,str))//判断str_1是不是str类型 

输入 获取键盘的输入
input()
变量=input(‘给使用者的提示信息，即告诉别人输入什么内容’)
1.代码从上到下执行，当代码遇到input的时候会暂停代码的执行，等待用户的输入
2.遇到回车结束
3.使用input获取的内容都是字符串类型

数据类型转换
1.原数据是什么类型
2.要转换为什么类型
变量=要转换的类型（原数据）
数据类型转换不会更改元数据的类型，而是生成新的数据
int():将其他类型转换为int类型
float类型可以转换为int类型
整数类型的字符串才可以转换为int类型
float():将其他类型转换为float类型
int类型可以转换为float类型
数字类型的字符串都可以转换为float类型
str():将其他类型转换为str类型 加引号
交互运行python代码
进行小的代码验证，每行代码都有一个执行结果-》》》控制台
格式化输出
按照一定的格式，在字符串中使用变量，将变量的值进行格式化输出

name="小明"
age=18
sex='男'
#我的名字是XX，年龄XX岁，性别为XX.
print('我的名字是'+name+',年龄是'+str(age)+'岁，性别是'+sex+'.')
#格式化输出，字符串.format()
#可以在python任意版本使用
#字符中需要使用变量的地方使用{}占位
#在format的括号中，按照占位的顺序，将变量写上去
print('我的名字是{},年龄是{}岁，性别是{}.'.format(name,age,sex))

F-string
python3.6版本开始可以使用
在字符串前加上f’'或者F‘’
字符中需要使用变量的地方使用{}占位
将变量直接写在占位的大括号中

print(f'我的名字是{name},年龄是{age}岁，性别是{sex}.')

转义代码
\n换行
\t制表符 tab键
print默认有一个换行符，不想换行可以加上 ,end=‘’

print('hello\nworld' ,end='')
print('hello\tworld')
print('hello world')

运算符
1.算术运算符
±/%
//取整
%取余
** 幂运算，次方
优先级：（）>次方>/ // % >±

print(10//3)#取整
print(10/3)#->结果是3.3333333333335
print(2**3)##->结果是2的3次方 结果是8

2.赋值运算符
=赋值
+= 、-=、 *=、 /=、 %=

num=1#int
str='hello'
num=1
num2=num+5
print(num2)->6

3.比较运算符

•                    >、<、<=、>=、!=、==
  

• < >= <=只能是相同类型之间进行比较（数字和字符串之间不能使用）

• 结果是布尔值类型

4.逻辑运算符
and
or
not
python只能使用 and、or、not 不能用&|来表示与或非

流程控制

三大流程：顺序，分支，循环
if语句的基本结构
单独的if语句

if 判断条件：
            判断条件成立，执行的代码

if语句后面又冒号，冒号之后回车缩进，
if语句要么都执行，要么都不执行
如果和if的判断无关就不需要写缩进
if else结构

if 判断条件：
            判断条件成立，执行的代码
else:
          判断条件不成立，执行的代码

else是关键字，后面要：
存在：就需要回车和缩进
处于else中的代码是else语句的代码块
else不能单独使用，且else和if要对齐
if和逻辑运算符结合and or not

if 判断条件：
        判断条件1成立，执行的代码
elif  判断条件：
        判断条件2成立，执行的代码
  。。。。。。。。。。。。。
else :
    判断条件都不成立，执行的代码

if嵌套
在一个if中嵌套另一个if（elif else)
递进关系 只有第一个成立才会判断第二个

if 判断条件：
        判断条件1成立，执行的代码
        if 判断条件：
        判断条件2成立，执行的代码
        else：
        判断条件2不成立，执行的代码
else:
    判断条件1不成立，执行的代码


随机数生成
导入
import random
random.randint(1,3)#输出1-3的随机整数

循环

while
初始条件

1.循环的初始条件（计数器）
2.循环的终止条件：
    判断条件成立执行的代码
    判断条件成立执行的代码
    判断条件成立执行的代码
3.计数器+1
i=0
while i<5:
    print('我错了')
    i+=1

死循环 （没有计数器+1）&无限循环
看起来是一样的，都是代码一直执行，不能停止
死循环是由于写代码的人不小心造成
无限循环是写代码的人故意这么写
无线循环一般会存在一个if判断语句，当这个判断语句的条件成立，执行break语句，来终止循环
关键字break：当执行代码遇到她，会终止循环
关键字continue:当执行代码遇到她，后续的 代码不执行，但是会继续下一次的循环
break和continue只能用在循环中

for循环

for 是从容器中将数据逐个取出的过程
容器：字符串、列表、元组、字典

for 变量 in 字符串：
 重复执行的代码
 字符串存在多少个字符，代码就执行多少次
 每次循环会从字符串取出一个字符保存到前边的变量中
 for和in都是关键字
 str1='abcd'
for i in str1:
    print('hello world',i)

for指定次数的循环：
for 变量 in range(n)
    重复执行的代码

for 变量 in xxx:
  if XX:
    break#循环执行了break代码就不会再执行else中的代码
else:#不是被break终止的可以执行

容器

字符串

定义 str=‘abcd’ “abcd” “”“hello”“”
转义字符

# 定义字符串
str5="I'm 小名"
print(str5)
str6='I\'m 小明'
print(str6)
str1='hello'
str2="hello"
str3="""hello"""
str4='''hello'''
print(type(str1),type(str2),type(str3),type(str4))
# 定义字符串
str5="I'm 小名"
print(str5)
str6='I\'m 小明'
print(str6)
str7='I\\\'m 小明'
print(str7)
str8="I\\'m 小明"
print(str8)
#原始字符串r,不会转义
str9=r'I\\\'m 小明'
print(str9)

下标，索引

数据在容器中的位置
一般来说，从0开始
作用：可以通过下标来获取具体位置的字符 语法：str1[-1]
python支持负数下标，-1表示最后一个位置的数据
切片：可以一次性获取容器中的多个数据，多个数据中存在一定的规律
语法 容器【start: end:step】
start:开始位置的下标
end:结束位置的下标，不包含end
step:步长，相邻两个坐标的差值

my_str='abcdefg'
# print(my_str[0:3:1])#打印abc
# print(my_str[0:3])#步长是1，可以省略不写
# print(my_str[:3])#开始是0，也可以不写
print(my_str[4:7:1])#efg
print(my_str[4:7])
print(my_str[4:])#如果取到最后，end可以不写
print(my_str[0::2])#aceg
print(my_str[0:7:2])
print(my_str[::2])
print(my_str[2:6:3])#cf
#步长为-1，反转字符串，逆序输出
print(my_str[::-1])

字符串查找方法：
字符串.find(sub_str):在字符串中找是否有sub_str这样的字符
返回：False返回-1,or 返回第一次出现的下标

str1='黑马程序员'
# print(str1.find('黑马'))
# print(str1.find('白马'))
res=str1.find('黑马')
res2=str1.find('白马')
if res!=-1:
    print('黑马存在')
    print(res)
else:
    print('黑马不存在')
if res2!=-1:
    print('白马存在')
    print(res2)
else:
    print('白马不存在')

字符串替换replace()
字符串.replace(old,new,count)
将字符串中的old字符串替换成new
count一般不写，表示全部替换，可以指定替换的次数
返回替换后完整的字符串

str1='good good study'
str2=str1.replace('good','Good')
str3=str1.replace('good','Good',1)
str4=str2.replace('Good','good',1)#第二个good替换成Good
print('str1=',str1)
print('str2=',str2)
print('str3=',str3)
print('str4=',str4)

字符串的拆分split（分隔符）
字符串.split(sep)将每个字符串按照指定的字符串sep进行分隔
默认按照空格字符分割
返回：列表，列表的每个数据就是分隔后的字符串

str1='hello Python and\titcast and\n itheima'
list1=str1.split()
print(list1)#['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
list2=str1.split(' ')
print(list2)#['hello', 'Python', 'and\titcast', 'and\n', 'itheima']
list3=str1.split('and')
print(list3)

字符串的连接join
字符串.join(容器) #容器一般是列表
将字符串插入到列表相邻的两个数据之间，组成新的字符串
注意点：列表的数据必须是字符串

list1=['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
str1=" ".join(list1)
print(str1)
str2=",".join(list1)
print(str2)
str3="*".join(list1)
print(str3)

列表

使用最频繁的，在其他语言中叫数组，专门用来存储一组数据
定义方式
列表，list []
可以存放任意类型的数据
可以存放任意多个数据
列表中的数据使用，隔开

方式1：类实例化
定义空列表 变量=list()
list1=list()
定义非空列表，也称为类型转换list(可迭代类型)
可迭代类型：能够使用for循环
list1=list()
print(type(list1),list1)
list2=list('abcd')
print(type(list2),list2)
方式2：直接使用【】进行定义
list3=['a', 'b', 'c', 'd']
print(type(list3),list3)
list4=[1, 3.14, 'hello', False]
print(type(list4),list4)
list5=[]
print(list5)

切片

列表的切片得到的是新的列表
字符串的切片得到的是新的字符串

list4=[1, 3.14, 'hello', False]
print(list4[0])#获取第一个元素
print(list4[-1])#获取最后一个元素
print(list4[1:3])#切片，第一个开始，第三个结束

列表查询方法

index()方法
这个方法的作用和字符串中find()作用一样
列表没有find()方法，只有index（）方法
find()和index（）区别：
index()没有找到直接报错，find()找到直接返回下标

列表.count(数据) #统计指定数据在list中出现的次数
list4=[3.14526,55,'asdffc','asdffc','hello']
num=list4.index(55)#查下标
print(num)
num2=list4.count('asdffc')#查出现次数
print(num2)

列表增加
列表.append(数据)
返回none,所以不需要 赋值给新的变量
直接在原列表添加数据，不会生成新的列表

list2=[123,"hello"]
print(list2)
list2.append(123456)#一次只能添加一个
print(list2)

删除数据pop()
列表.pop(index) #根据下标删除列表中的数据
index下标可以不写，默认删除最后一个
返回删除的数据

list2.append(123456)
print(list2)
list2.pop(0)
print(list2)

修改数据
想修改数据直接使用下标即可
列表【下标】=新数据
反转reverse()
字符串 反转 字符串【：：-1】
列表也可以，但是这是得到新的字符串，原列表不会改动
列表.reverse() 直接修改源列表的数据

print(list2)
list2.reverse()
print(list2)
list3=list2[::-1]
print(list3)

列表排序
列表.sort()#升序，从小到大，直接在原列表中排序
列表.sort(reserved=True) #降序，从大到小，直接在原列表进行降序

list=[1,4,7,2,5,8,3,6,9]
list.sort()#升序
print(list)
list.sort(reverse=True)#降序
print(list)

列表的嵌套
指列表中的数据都是列表

str1=[[9, 8, 7, 6, 5, 4, 3, 2, 1],[1, 2, 3, 4, 5, 6, 7, 8, 9]]
print(str1[0][1])#取出第一个8
str1[0].append('张三')
print(str1)
str1.pop()
print(str1)
#取出列表中列表的第二个元素
for info in str1:#info是列表
    print(info[1])

元组tuple

元组和列表一样都可以存数据，不同之处在于元组的元素不能修改，列表中的数据可以修改
使用的是小括号，都可以存储任意类型的数据
因为元组的数据不能修改，只有查询方法，如index，count，支持下标和切片用法和列表一样，如index(),count()
元组主要用于传参和返回值

#类实例化方法
#1.1.定义空元组 不用
tuple1=tuple()
print(type(tuple1))
#1.2定义类型转换,将列表其他可迭代类型转换为元组
tuple2=tuple([1,5,2,'555'])
print(tuple2)
# 2.直接使用（）定义
# 空元组
tuple3=()
tuple4=('helko',3.25,True,1,2)
print(tuple4[2])
#定义只有一个数据的元组
tuple5=(10,)
print(tuple5)

元组的特殊使用

交换两个变量的值（面试题）

在定义元组的时候，（）可以省略不写，
组包pack，将多个数据值组成元组的过程a=1,2 #a=(1,2)
拆包/解包unpack,将容器多个数据分别给到多个数据，需要保证元素的个数和变量的个数需要保持一致 

字典dict

字典dict,使用{}
字典是由键值对组成的
key:value
一个键值对是一组数据，多个键值对直接使用，隔开
在一个字典中，字典的键是不能重复的
字典中的键主要是字符，可以是数字

# 1类实例化
dic2=dict()

dic=dict(name='xiaoming',age=18,sex='man')
print(dic)
# 2.直接使用{}
dict3={}
print(dict3)
dict4={"name":"小明","age":"18","is_man":"True"}
print(dict4)

字典的增加和修改
字典【‘键’】=值
键存在：修改
键不存在：增加

dict4={"name":"小明","age":"18","is_man":"True"}
print(dict4)
dict4['age']=20
print(dict4)
dict4['weight']=40
print(dict4)

字典删除pop()
删除键来删除键值对

dict4.pop('age')
print(dict4)

查询
根据字典的key来获取对应的value值

方法一：键不存在，会报错
字典【’键‘】
 weight2=dict4['weight']
print(weight2)
方法二：键不存在返回None
weight1=dict4.get('weight')
print(weight1)

获取数据
直接print（字典[‘键’]）
print(字典.get(‘name’)
字典遍历
字典存在键（key）,值（value）遍历分为3种情况
遍历键，
方式1：
for 变量 in 字典：
print(变量)
方式2：
for 变量 in 字典.keys():#字典.keys():可以获取字典所有的键
print(变量)

值。
for 变量 in 字典.values():
print(变量)
键和值
变量1，变量2 就是键 和值
for 变量1，变量2 in 字典.items():
print(变量1,变量2)

in操作符是python的关键字，可以用来判断容器中是否包含这个数据，如果包含返回true,不包含返回false,对字典来说判断的是是否包含这个

集合

set {} {数据}

集合中的数据不能重复，没有重复数据
应用：对列表进行去重操作，就是类型转换，可以将列表转换为集合，然后再将集合转换为列表
或者定义新列表

#方法1：
list01=[1,2,1,2,5,2]
listnew=list(set(list01))
print(listnew)


#方法2：
new_list=[]# 新建空列表，保存去重后的数据
for i in list01:
    if i in new_list:#如果存在，什么都不操作
        pass
    else:#不存在就放进列表中
        new_list.append(i)
print(new_list)

函数

print() input() type() len() range()
函数可以实现一个特定的功能
减少代码冗余，提高编程效率
必须先定义后调用
函数的定义：
def 函数名（）：
函数体
函数名需要满足命名规则
最后需要冒号
定义不会执行，要执行需要调用，
调用 ：函数名（）

函数的文档注释：

作用：对函数的作用和使用方法进行说明，比如有哪些参数，返回值是什么
书写位置：再函数定义的下方，使用三对“”来书写
查看 ：在函数名上使用ctrl+q查看
在函数名上使用快捷键Ctrl+B 跳转到函数定义的地方查看
在函数名上，按住Ctrl键，按住Ctr，点击函数名，跳转到函数定义的地方查看
定义带参数的函数
函数调用的时候会把形参传给实参，让函数更加通用
使用场景：判断函数中数值是不是固定不变的，如果是变化的，就可以使用参数传递
函数的嵌套调用
在一个函数中调用另一个函数
代码从上到下执行
函数定义不会执行函数中的代码
函数调用会进入函数中执行函数的代码
函数中的代码执行结束，会回到调用的地方继续向下执行
函数的返回值：
print()–>none
input()—>键盘输入的内容
type()---->变量的数据类型
len()—》容器的长度
使用return关键字？-》得到的数据结果想要在函数外面使用，就需要返回值
函数有返回值，在调用的时候会使用变量来接受
return：将一个数据值返回到调用的地址；函数遇到return 会结束函数的执行
return只能在函数中使用

模块的导入

模块：moudle
每个以.py结尾的python代码文件就是一个模块
模块中定义的全局变量，函数，类都是提供给外界直接使用的工具
模块就好比工具包，要想使用这个工具包的工具，就需要先导入模块
模块名就是 文件名 没有.py名
as关键字 ，可以给模块起别名
1import

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

模块名.功能名（）#功能名可以是变量，函数和类
2.from …import… ：

from  random import randint
num=randint(1,10)
print(num)

from 模块名 import 功能名 #导入指定的功能
#使用
功能名（）

__name__的使用

导入模块的时候，会执行模块中的代码
如果在导入模块的时候，模块中的部分代码不想被执行，可以使用__name__来解决
__name__是python解释器内置的变量，变量的值是自动维护的每个代码文件中都有这个变量
在模块中直接运行代码文件，name__变量的值是__main
如果是被导入运行代码文件，__name__变量的值是模块名（文件名 ）

模块的导入顺序

在导入模块的时候，会先从代码所在的目录进行导入
如果没有找到，回去python系统的目录查找导入
如果没有找到，报错
注意点：自己定义的代码文件名字不要和导入系统的模块的文件名一样

包

将多个模块放在一个目录中并集中管理，并在这个目录中创建一个__init__.py(可以什么都不写)
就是一个包

导包

包创建
包导入
方式一: import 包名 .模块名
#使用
包名.模块名.工具名
方式2：from 包名 import 模块名
#使用
模块名.工具名
方式3：from 包名.模块名 import 工具名
使用：工具名

变量的进阶

range的补充
range(n)----->[0,n)
range(start,end,step)---->(start,end)步长是step

引用

1.定义变量的时候，变量和数据都会在内存开辟空间
2.变量所对应的内存空间存储的是数据所在内存的地址（平时理解为将数据存储到变量中即可）
3.变量中保存数据的地址就称为引用
4.ptyhon中所有的数据的传递，传递的都是引用（即地址）
5.赋值运算符会改变变量的引用（只有等号可以改）
6.可以使用id函数查看变量的引用

可变类型与不可变类型

根据内存中是否允许修改，将数据类型分为可变类型与不可变类型
简单理解：不使用=能不能修改数据值
可变类型：可以修改
-列表 -字典 -集合
list.append(13)
dict[‘键’]=12

不可变类型：不允许修改
-数字类型 （int，float,bool）-元组，-字符串

tuple1=(1,2,[10,20])#元组中存的是1，2，列表的地址
tuple1[-1][-1]=0#数据改了，但是改的是列表的最后一个位置的引用

局部变量和全局变量

根据变量定义的位置将将变量分为局部变量和全局变量
局部变量：1.只能在函数内部使用
2.可以在不同函数内定义名字相同的局部变量
3.生命周期（使用范围）
在函数执行的时候被创建，在函数执行结束的时候被销毁
4.形参可认为是局部变量
5.想在函数外部使用局部变量的值，使用return 返回
全局变量：可以在任意函数内访问
特点：可以在任意函数内访问 在函数内部想修改全局变量的引用，需要修改global的值声明，如果在函数内部出现和全局变量名字相同的局部变量，在函数内部使用的是局部变量
声明周期：代码执行的时候创建，执行结束销毁

函数进阶

函数返回多个数据值
return关键字作用：
1.返回数据值
2.结束函数的运行
函数如果想要返回多个数据值，一般是组成元组，一起返回

def clac(a ,b):
    return (a+b,a-b)
print(clac(10,20))

函数传参的方式：如何将实参的值传递给形参
位置传参：按形参的顺序
关键字传参：在函数调用的时候，指定实参传递给那个形参
混合使用：1.位置参数必须写在关键字参数的前边，关键字参数必须放在位置参数的后面
2.同一个形参只能使用一个实参值

缺省参数/默认参数

给某个参数指定一个默认值，
必须保证缺省参数在参数列表末尾
在函数调用的时候，缺省参数可以不用传递实参值
如果传递实参使用的就是传递的值

多值参数（可变参数，不定长参数）

在函数定义的时候，不确定在调用的时候实参有多少个，此时可以使用多值参数
eg:print()
定义：在普通的参数前加一个*,这个参数就变为多值参数
这个参数可以接受任意多个位置参数传参的数据，类型是元组
这个形参一般写做args(arguments),即*args
参数顺序：普通，多值，缺省

def func(*args):
    print(args)


func()
func(1,2,3)

my_tuple=(1,2,3,4,5)
def sum(*args):
    num=0
    for i in my_tuple:
      num+=i
    return num


print(sum(*my_tuple))
#要把列表/元组作为参数输入，只需要在列表前加一个*，进行拆包即可 

匿名函数
使用lambda关键字定义的表达式，
语法：lambda 参数，参数：一行代码# 只能写一行代码
匿名函数没有函数名称，只能返回一个表达式
一般不直接调用，作为函数参数去使用

fun=lambda  a ,b :a+b#将匿名函数保存到变量中，所以func就指代函数
print(fun(1,2))
应用：作为函数的参数，用def太麻烦
# 定义匿名参数，参数作为一个字典，返回字典中键为age的值
lambda x:x.get('age')
lambda  x:x['age']

应用：
user_list=[
    {'name':"张三",'age':22,'title':'测试工程师'},
    {'name': "李四", 'age': 24, 'title': '开发工程师'},
    {'name': "王五", 'age': 21, 'title': '测试工程师'}

]
# user_list.sort()#只能对数字，字符串排序
# 根据字典的age排序
# 列表.sort(key)
# key这个参数需要传递一个函数，使用匿名函数
# user_list.sort()
#列表.sort(key=lambda x:x['键'])
user_list.sort(key=lambda x:x['age'])
print(user_list)

面向对象

一种编程思想，即指导如何写代码，适用于中大型项目 考虑的是谁能做这件事
面向过程：也是一种编程思想，适用于小型项目 考虑的是实现的细节

类和对象

类是对具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用，指代多个事物
class 定义
类的三要素：类名（大驼峰），属性（事物的特征）,方法（事物的行为）
对象是由类创建出来的，可以直接使用，指代一个具体的事物
使用类去创建，实例化
面向对象代码的步骤
1.设计类（3要素）

2.定义类
基本语法：
class 类名：
\t#定义类的属性和方法
def 方法名（self）：
pass
3.创建对象(实例化)
变量=类名（）#将这个变量称为对象
4.由对象调用类中的方法
语法：对象.方法名（）

class Cat:
    def eat(self):
        print("小猫爱吃鱼")
    def drink(self):
        print("小猫要喝水")
  self参数
  从参函数的语法来看，self是形参，名字可以任意的变量名
  特殊点：self是一个普通的参数，按照函数的语法，在调用的时候必须传递参数，原因呢是python解释器自动的将调用这个方法的对象作为参数传递给self #谁调用谁就是self

#创建对象
Tom=Cat()
Tom.eat()
属性：表示事物的特征，可以给对象添加或者获取对象的属性
添加： 对象.属性名=属性值（类的外部）
获取：对象.属性名（类的外部）
在方法中操作属性（self是对象）:
self.属性名=属性值
self.属性值
类的内部添加属性：
魔法方法：在python在存在这一类方法，————开头————结尾，在满足某个条件的时候自动调用
什么时候自动调用？创建对象
应用场景：初始化对象，给对象添加属性
注意事项：__init__
如果属性是会变化的，则可以把这个属性的值作为参数传递，在创建对象的时候必须传递实参
初始化：__init__

__ str__方法：
1.调用时机：使用print（）打印对象的时候自动调用，
如果没有定义，默认打印的是对象的引用地址
定义了则打印的是方法的返回值
2.应用场景：使用print(对象),打印出书对象的属性信息
3.注意事项：必须返回一个字符串

dir()函数

dir(对象变量)
可以查看对象内的所有属性及方法
不具备输出功能，需要和print()函数配合使用

对象对象的三大特征：封装，继承，多态

封装：将对象的属性和方法定义到类中
继承：多个类中存在多个相同的代码逻辑，则可以考虑将相同逻辑的代码抽取封装到父类中，再通过继承关系，直接实例化子类对象并调用父类中的方法使用即可
继承：
需要考虑类与类是否存在is…a关系
好处：避免反复编写相同逻辑的代码，提高效率
语法：class 类名（父类名):

class A：父类，基类   默认继承object类 python中最原始的类
class A():
class A(object)
   pass
class B(A): 子类，派生类 #继承，类B继承类A
  pass
  

继承有传递性
对象嗲用方法的顺序：对象.方法名（）
1.会在自己的类中查找，找到直接使用
2.没有找到 去父类中查找，找到直接使用
3.没有找到，直到object类也没有,就报错
重写：在子类中定义了和父类名字一样的方法
为什么重写（override）？父类中的代码不能满足子类对象的需要
重写方式：覆盖式重写，扩展类重写
覆盖式重写：父类的功能代码全部不要
直接在子类中定义和父类名字一样的方法接口，直接书写新的代码
扩展式重写：父类的功能还需要，只是添加新的功能
方法：1.先在子类中定义和父类名字相同的方法
2.在子类的代码中使用__super().方法名()___，来调用父类中的方法名
3.书写新的功能
多态:不同的子类方法调用相同的父类方法，产生不同的执行结果
调用代码的技巧
权限：私有和公有
在python中，定义类的时候，可以给属性和方法设置访问权限
公有：定义：直接定义的属性和方法就是公有的
特点：只要有对象就可以访问
私有权限：只能在类内部中定义（clas关键字的缩进中）
只要在属性名或者方法名前边加上两个下划线就变为私有的
特点：私有只能在当前类的内部使用，不能在类的外部和子类直接使用
应用场景：一般来说，定义的属性和方法都是公有的
某个属性不想再外部直接使用，定义为私有

对象分类

类对象就是类就是使用class定义的类，在代码执行的时候，解释器会自动创建
作用：使用类对象创建实例对象，存储一些类的特征值（类属性）
实例对象
创建对象也称为实例化，所以由类对象创建的对象也称为实例对象，简称实例
一般来说，没有特殊强调，我们所说的类就是指实例对象
实例对象可以称为保存实例的特征值（实例属性）
就是使用类名()创建的对象

属性的划分

使用实例对象.属性 访问 属性的时候 ，会先在实例属性中查找，如果找不到，去类属性中查找，找到就使用，找不到就报错
实例属性
是每个实例对象具有的特征（属性），每个实例对象的特征
定义：一般都是在__init__方法中，使用self.属性名=属性值
特征：每个实例对象都会保存自己的实例属性，即内存中存在多份
访问和修改：实例对象.属性=属性值(可以认为是通过self来修改的) 实例对象.属性
类属性
是类对象具有的特征，是整个类的特征
定义 在类的内部中，方法的外部定义的变量
特征：只有类对象保存一份，即在内存中只有一个
访问和修改：#即通过类名
类对象.属性=属性值
类对象.属性
方法：
实例方法
定义时机：如果方法中需要使用实例属性，则这个方法必须 定义为实例方法
定义

class 类名：
     def 方法名（self）:
        pass

参数一般写作self,表示的是实例对象
调用：实例对象.方法名（）
类方法
定义时机：如果方法中不需要使用实例属性，但需要使用类属性，则这个方法可以定义为类方法
定义：

需要在方法名上方书写@classmethod
class 类名：
     @classmethod
     def 方法名（cls）:
        pass

参数一般写作cls,表示类对象，即类名，同样不需要手动传递，python会自动传递
调用：1.类名.方法名（）
2.实例对象.方法名（）
静态方法
定义时机：方法中既不需要使用类属性也不需要实例属性 可以将这个方法定义为静态属性
定义

需要使用装饰器@staticmethod
class 类名：
     @staticmethod
     def 方法名（cls）:
        pass

静态方法对参数没有要求
调用：1.类名.方法名（）
2.实例对象.方法名（）

文件

文件操作，使用代码来读写文件
文件是可以存储在长期存储设备（硬盘，U盘）上的一段数据
文件在电脑的存储的形式都是二进制0和1
文件分类：根据能否使用文本软件打开，分为文本文件（txt,py,md,json）和二进制文件,音视频mp3,mp4
文件操作的步骤：打开文件、读写文件、关闭文件
打开文件：open(file,mode=‘r’,encoding=None)
file:表示要操作的文件的名字，可以用相对路径和绝对路径
mode:打开文件的文件
-r 只读 文件不存在会报错
-w 只写 文件存在会覆盖源文件
-a 追加打开 在文件末尾写入新的
-encoding :编码格式，指二进制数据和汉字转换的规则的
utf-8(常用)：将一个汉字转换为3个字节的二进制
gbk：将一个汉字转换为2个字节的二进制
返回值：文件对象，后续对文件的操作都需要这个文件
关闭文件close()
文件对象.close()#如果是写文件，会自动保存，即即将内存中的数据同步到硬盘中
读取文件read()
文件对象.read()
返回值：返回读取到的文件内容，类型是字符串
写文件 write()
文件对象.write()
#参数是写入文件的内容，类型：字符串
返回值写入文件的字符数，字符串的长度，一般不关注

#打开文件
f=open('a.txt','w',encoding='utf-8')
#写文件
# f.write("hello python")
f.write("good good study")
#关闭文件
f.close()

文件打开的另一种写法（推荐）

with open(file,mode,encoding)as 变量： #变量就是文件对象 
不用手动关闭，出了with的缩进之后，文件就会自动关闭
with open("a.txt",mode='r',encoding='utf-8') as f:
   buf= f.read()
   print(buf)

按行读取文件readline()
文件对象.readline() #一次读取一行
read()和redaline（）如果读到末尾，返回的都是空字符串

with open('a.txt','r',encoding='utf-8') as f:
    buf=f.readline()
    print(buf)#aaaaa
    buf1=f.readline()
    print(buf1)###bbbbb

with open('a.txt','r',encoding='utf-8') as f:
    while True:
        buf=f.readline()
        if buf==" ":
            break
        else:
            print(buf,end='')

with open('a.txt','r',encoding='utf-8') as f:
    while True:
        buf=f.readline()
        if buf:#推荐
            print(buf,end='')
        else:
            break

打开文件的方式：r,w,a:文本文件的二进制进行编码转换
rb,wb二进制方式打开，文本文件和二进制文件都可以打开，但是二进制文件只能二进制方式打开，同时不能传递encoding 参数

json文件本质也是文本文件 可以直接使用read和write操作
比较特殊，比较像Python的字典和列表
使用