一、基本语法
注释
单行注释 #
快捷键command+/
多行注释 """ """
也可以和变量名结合写多行变量值
变量
在python里，变量必须赋值
命名规则：
字母、数字、下划线，不能以数字开头
不要使用python内置关键字
命名规范：
1、见名知意
2、全小写下划线连接
检查关键字
import keyword
keyword.kwlist
二、八大数据类型
1、字符型str-----不可变、有序
引号创建字符串
str1='hello'
str2="hello"
str3='''hello''' #换行多时使用三引号，避免手动输入换行符
str4="""hello""" #字符串中既有单引号又有双引号时，使用三引号
字符串中的转义符
#\n换行符，\t制表符
file_path= r"d:\hugege\test.xlsx" # 路径前加r，字符串中所有转义符均不进行转义
字符串操作
字符串拼接 +
print('1'+'6') #打印16
字符串重复多次 *
print('1'*6) #打印6次1
索引---获取字符串中的单个字符
判断字符串的长度len()
#下标以0为左边开始值，-1为右边开始值
str1='abcdefg'
print(str1[0]) #输出a
print(str1[-1]) #输出g
print(str1[-2]) #输出f
print(str1[3]) #输出d
str1[0]='q' #字符串是不可变对象，不可通过下标修改某个位置的值
切片---获取多个字符
[起始值：终止值：步长] 包含起始值，不包含终止值 步长默认为1
str2='abcdefg'
print(str2[0:3]) #abc
print(str2[-7:-4]) #abc
print(str2[:-4]) #起始值不写，表示从头开始取；abc
#步长为正数时，从左向右取值；步长为负数时，从右向左取值
print(str2[2::-1]) #终止值不写，表示取到后面所有值abc
print(str2[:]) #取全部值
print(str2[::2]) #aceg 逢2取1
#切片的结果为一个新对象，不影响原对象
str3='aabbccddee'
str3_new=str3[0:2]
print(str3)
print(str3_new)
#倒叙排列
print(str2[::-1])
#如果切片跳出去了,获取剩下所有的,但是索引要是超出范围则报错，IndexError
获取数据类型
type( )
格式化
"my string { } other string { }" . format(变量1，变量2)
#方案一：占位符
#%s字符串 %d整数 %f浮点数
info1='我是%s,你是%s,他是%s,今年是%d年.'%('杰伦','冠希','霆锋',2023)
#补齐%ns n是任意整数，表示补齐到n位，不足n位用空格补齐，默认右对齐
str1='我是%5s，你是%3s,今年是%10d年'%('秦','滴',2023)
print(str1)#我是 秦，你是 滴,今年是 2023年
#对于数字，可以在左侧补0
str2='我是%5s，你是%3s,今年是%010d年'%('秦','滴',2023)
print(str2)#我是 秦，你是 滴,今年是0000002023年
#左对齐 %-ns
str1='我是%-5s，你是%-6s,今年是%-10d年'%('秦','滴',2023)
print(str1)#我是秦 ，你是滴 ,今年是2023 年
#%f浮点型 默认保留6位小数
float1='您输入的数字是%f'%(3.8)
print(float1)#您输入的数字是3.800000
#%f浮点型 保留2位小数
float1='您输入的数字是%.2f'%(3.8)
print(float1)#您输入的数字是3.80
#%f浮点型 补齐到10位，保留2位小数
float1='您输入的数字是%10.2f'%(3.8)
print(float1)#您输入的数字是 3.80
#%f浮点型 用0补齐到10位，保留2位小数
float1='您输入的数字是%010.2f'%(3.8)
print(float1)#您输入的数字是0000003.80
方案二：{}
str1='我是{},你是{},年龄是{}'.formart('chokqin','jack',29)
#补齐{:n} n是任意整数，不足n位补齐到n位，字符串默认左对齐，数字默认右对齐
str1='My name is {:10},Your name is {:10},age is {:10}'.format('chokqin','jack',29)
print(str1)#My name is chokqin ,Your name is jack ,age is 29
#对于数字，可以在左侧补0
str1='My name is {:10},Your name is {:10},age is {:010}'.format('chokqin','jack',29)
print(str1)#My name is chokqin ,Your name is jack ,age is 0000000029
#改变对齐方式 >右对齐 <左对齐 ^居中对齐
str1='My name is {:>10},Your name is {:^10},age is {:<10}'.format('chokqin','jack',29)
print(str1)#My name is chokqin,Your name is jack ,age is 29
#{}里没写数字时是 顺序取值法，写了数字是 下标取值法
str1='My name is {2},Your name is {0},age is {1}'.format('chokqin','jack',29)
print(str1)#My name is 29,Your name is chokqin,age is jack
#python3.6版本后，还可以
name1='guanxi'
name2='jielun'
str1=f'my name is {name1},your name is {name2}'
print(str1)#my name is guanxi,your name is jielun
数据类型的转换
转化成整数
int(str)
转化成str
str(age)
内置函数
#转化大写
my_string.upper()
#转化小写
my_string.lower()
#大小写转化
my_string.swapcase()
#find查找，必须是连续的字符,找不到返回-1,找到返回开始字符的索引值
my_string.find('要查找的内容')
#index查找，找不到，报错ValueError，找到返回开始字符的索引值
my_string.index('要查找的内容')
#首字母大写
title()
capitalize()
#替换-字符串一旦定义，除非重新赋值，不然不会发生变化
replace()
#全部替换
new_string=old_string.replace('old','new')
#替换一个
new_string=old_string.replace('old','new',1)
#统计count()
mystring.count('要统计的内容')
#字符串拼接，正规方式的+，join
print('要拼接的东西'.join[string_1,string_2,string_3]))
#字符串分割
print(my_string.split()('根据什么分割'))
#去掉左右两边指定的字符串
strip()
#如果左右两边不一样
#去除左边
lstrip()
#去除右边
rstrip()
#左右两边一样（不管顺序）
print(my_string.strip(''))
#判断一个字符串是否是一个正整数，返回true或false
isdigit()
# 将字符转为整数表示，只接受一个字符
print(ord("a"))
# 将整数表示转为字符
print(chr(65+32))
# str 和 bytes互转
a = "自君之出矣，不复理残机"
b = a.encode("gbk") # 把 str 转成 bytes
print(b)
c = b.decode("gbk") # 把 bytes 转成 str
print(c)
2、列表list[]-------可变、有序
列表可以存放任意类型的对象（可以存储不同的数据类型，也可以列表里存储一个列表）
list1=[1,'abc',[10,20],{'A','apple'}]
索引-用法同字符串
切片-用法同字符串
列表的切片，也是一个新的对象，不影响原列表的值
如果子元素当中是列表，那么继续可以通过索引获取，切片也可以list1[1] [0:2]
添加
#列表是可以被修改的
#append()添加新的元素
list2.append(60)#一次只能添加一个，添加到列表末尾，这个函数会返回None（坑）
#extend()列表的拼接，添加多个到列表最后
list1=[1,2]
list2=[3,4]
list1.extend(list2)
print(1) #[1,2,3,4]
#insert(索引位置,添加的内容),添加元素到指定位置
list2.insert(0,‘秦川’)
删除
#del 勿轻易使用，直接从内存中清除
del list1[2]
#clear() 删除所有元素
#pop() 默认删除列表末尾元素，也可删除指定索引，可以用变量去接收，弹出
list2=[1,2,3,4,5,6]
list2.pop(0)
print(list2) #[2,3,4,5,6]
mylist=[list2.pop(1)]
print(mylist) #3
#remove() 删除指定值
list3=[100,200,300,400,500,600]
list3.remove(300)
修改
#列表是可变对象，直接获取索引然后重新赋值
#mylist[索引]=新的值
list2=[10,20,30,40]
list2[0]=666
列表的函数操作
#获取索引
index()
#逆序--直接在原来的基础上修改，和切片的逆序是有区别的
reverse（）
#排序--数字排序用的比较多
sort() #默认正序排
sort(reverse=True) #倒叙排
#列表去重
set()
3、元组tuple( )---不可变、有序
索引-用法同字符串
切片-用法同字符串
注意点
- 因为是不可变类型，所以元组不支持增删改；但是可以修改元组里面列表的元素，主要看索引前面是不是一个可变的类型
tuple1(11,22,33,[1,2])
tuple1[3][0]=888
- 空元组是一个元组
- 一个元素的元组，不是一个元组，而是去掉括号以后的原始数据类型
tuple1(6,)#如果想表示一个元素的元组，记得务必在元素后面加一个逗号
获取长度
len(my_tuple)
元组解包
#分别用两个变量去接收元组的元素,相当于变量赋值;等号两边 个数要相等
family_name,name = ('xiaoming','zhangsan')
family_name,name,*other=('qinc','luw','qinl','taot')
other = ['qinl','taot' ]
4、字典dict{}-----可变、无序
基础概念
- 用{}构造字典，每个字典元素都是以键值对形式存在，每个键值对之间用 , 隔开
- 键（key）在字典中是唯一的，字符型的键需用引号 引起来，key必须为不可变类型，一般使用字符串作为key。值可以是单个值，也可以是多个值构成的列表、元组或字典
- 字典是无序的，无法通过位置索引完成对元素值的获取，只能通过键索引实现
- 字典是可变对象
- 获取长度用len()，有几个key，长度就是几
- 字典里的单双引号没有区别，自动会变为单引号
#证明字典是无序的
dict1={'A':'apple','B':'book'}
dict2={'B':'book','A':'apple'}
print(dict1==dict2)#True
#获取字典中的某个元素
dict1['A']
增加和修改
当key不存在时，就是添加元素，当key存在时，就是修改，赋值操作会覆盖掉之前的值
my_dict={'qinc':'A'}#定义字典
print(my_dict)#{'qinc': 'A'}
my_dict['chok']='B'#字典没有对应的chok键，所有新增
print(my_dict)#{'qinc': 'A', 'chok': 'B'}
my_dict['qinc']='c'#字典有对应的qinc键，所有修改
print(my_dict){'qinc': 'c', 'chok': 'B'}
#update()方法-可以添加或修改多个键值对
my_dict.update({'D':'duck','E':'earth'})
删除
#随机删除
my_dict.popitem()
#指定key删除
my_dict.pop('key')
#清空字典中的键值对
my_dict.clear()#内存地址不变
my_dict={}##内存地址改变，相当于重新定义一个字典
#del 删除字典中的键值对
del my_dict['E']
其他方法
#把每队key和value存在一个个的元组里，再由这些元组组成一个列表
my_dict.items()
#遍历字典中的键值对
for k,v in my_dict.items()
#获取所有的key
my_dict.keys()
#遍历字典中的键
for k in my_dict.keys()
#获取所有的值
my_dict.values()
#遍历字典中的值
for v in my_dict.values()
#根据键判断某个对象在不在字典中
print('A' in my_dict)
5、集合set{}----可变、无序
基础概念
- 集合不是键值对
- 重复的元素直接丢掉，目前我们使用集合最多的功能就是去重
- 去重 my_love = set ( {"qinc","luwe","tata","qinc"})
6、布尔型boolean
7、整型int
8、浮点型float
三、流程控制
如果明确循环次数，建议使用for循环；如果循环次数不确定，建议使用while循环。
1、if
if ... elif ... else
#只要进入符合条件的，其他的分支就不会执行了
#遇到冒号要缩进
if (条件表达式)：
条件语句
elif(条件表达式)：
条件语句
else：
条件语句
2、for
#语法
for song in songs：
#for循环字典时
#默认获取的是keys
for i in name: 等价于 for i in name.keys():
#获取values
for i in name.values():
#获取keys和values
for i in name.items(): #这样取出来是一组一组的元组
for i, v in name.items(): #这样就可以全部单个的取出来
#嵌套循环，9个结果
list_1 = [4,5,6]
list_2 = [2,3,4]
for v1 in list_1：
for v2 in list_2:
print(v1+v2)
#注意：千万不要在for循环中直接修改列表，如果要修改，要复制出来，可以用切片，去for循环切片。
如果遍历已知循环次数用for，如果靠条件结束用while
3、while
i=0
while( i<100 )：
print（“。。。”）
i += 1
break#退出这个循环
continue#退出这一个条件，进入下一个分支
#死循环
while True：
print(“。。。”)
四、函数
定义
def 函数名称(参数1,参数2,参数3)：
(缩进)函数体
return 返回值（可以有多个）
参数类型
位置参数
要求比较严格
形式参数和实际参数要根据位置一一赋值
默认参数
可以少传参数,默认参数也必须放在位置参数的后面
用法：函数定义时给形参赋个默认值，那么在函数调用时，这个默认参数可以不传实际参数，使用 默认参数作为实际参数
不定长参数（动态参数）
*args可变参数
args是元组
在函数定义里，可以用*args去接收多余的位置参数
可以是列表，也可以是元组
rest = （1，2，3）
print(sum_total(3,4, *rest))
**kwargs关键字参数
允许用户传入任意个数参数，传参只能是x=y的格式，返回值是字典格式
如果不是全部传关键字参数，那么关键字参数必须放在位置参数的后面
函数的作用域
函数的调用过程
1、当所有的函数没有被调用之前，函数的定义顺序没有关系
2、一旦某一个函数被调用，那么函数体里面如果调用了其他函数，那么这个其他的函数必须要在调用之前
变量的使用
函数体内定义的变量，叫做局部变量
局部变量只能在函数体里面生效
函数体外面定义的变量，叫全局变量
可以在函数体内部使用
变量的修改
局部变量
能做函数体内修改
不能在函数体外修改
全局变量
不能在函数体里面修改
如果要在函数体内修改全局变量
global 变量名
global全局变量声明，但是现阶段强烈不建议大家使用global这个关键字，会造成数据紊乱
匿名函数
#写一个函数，返回某数的平方
pingfang2=lambda n:n*n #n是形参，后面的冒号是固定写法，返回值是n*n
print('返回值为：',pingfang2(3))#9
对象的方法
方法就是定义在类中的函数
五、模块与包
概念
一个.py文件就是一个模块，一个模块里会有很多的函数，类
存放文件的目录，若里面有一个__init__.py文件，称之为package（包）
存放文件的目录，若里面没有__init__.py文件，称之为文件夹
__init__.py文件，当导入某个包时，这个文件里的内容会被执行一次
无论是包还是文件夹，都可以导入，简称导入包
导入模块的几种方式
import 模块名
#适用于当前模块在同一个目录内，或是python标准库/第三方库中的文件；使用模块名.函数名()调用
import time
time.sleep(2)
from 包 import 模块 #使用模块名.函数名()调用
from 包.模块 import 函数 #使用函数名()调用
from 模块 import 函数 #使用函数名()调用
#别名：同一个文件中出现了重名的函数，使用别名；函数名称很长，使用别名
from sumdata1 import sumdata as f1
from sumdata2 import sumdata as f2
模块命名
1、数字、下划线、字母，不能以数字开头
2、一般是使用下划线的形式命名，而不是驼峰命名
3、模块名称不能和python内置的模块名称重合
标准路径
#标准路径
import sys
print(sys.path)#sys.path为标准路径，其值为列表
for i in sys.path:
print(i)
#python在找模块时，是按照当前目录，工程目录，标准路径的顺序进行查找
#添加标准路径
选择一个目录，右键->Mark Directory as->Sources Root,将此目录添加到标准路径
sys.path.append('D:/qinc2023')#临时添加路径到标准路径
#永久添加路径到标准路径
在python目录的lib\site-packages中新建一个xxx.pth文件，将要添加的路径写入到文件中，每个目录一行
安装第三方库
#需要安装后使用的模块，称之为第三方库
#所有的第三方库，都会安装在python的lib\site-packages中
#安装，在cmd中执行
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple flask
#卸载
pip uninstall flask
#查看
pip list
六、OS模块、文件操作
OS模块
#是python内置的，直接import os
#如果不是python内置的，要使用
#放到项目下面，作为一个包或者模块
#或者放在lib，site-packages
import os.path
#处理系统路径相关的方法
os.getcwd()#获取当前文件的相对路径，每次会变
os.path.abspath(__file__)#获取当前“文件的绝对路径”（包含文件名）
os.path.dirname(os.path.abspath(__file__))#获取文件的“文件夹路径”（不包含文件名）
os.path.join(“路径”,'qinchuan.txt')#路径拼接
os.mkdir(绝对路径)#在某个目录下创建一个新目录，一次建立一级文件夹
os.rmdir(路径)#删掉一个目录
os.path.isfile(路径)#是否是一个文件
os.path.exists(路径)#路径是否真的存在
文件的读写
#打开一个文件
open(参数1，参数2，encoding=’utf-8‘) #用open打开文件，需要用close()方法关闭文件
with open() #用法与open()一致，但可以同时处理多个文件，也无需写close()方法关闭文件
#参数1：路径含文件名和后缀
#参数2：读写的模式
#mode的模式
r #不写mode时默认为r，读
w #写，当已经存在这个文件的时候，原来的文件内容会被覆盖
x #独创模式
a #追加写入
a+ #可以同时读写，若文件不存在，则新建文件，写入时为追加写入
t #文字模式，字符串模式
b,binaty #二进制，图片，视频
open(png_pic,mode='rb') #打开图片
w+ #可以同时读写，先写后读，若文件不存在，则新建文件，写入时为清空写入
#闭坑，写完要close()后再打开读，不然写完光标在最后读不到内容
#或者seek(0)将光标移动到最前面
r+ #可以同时读写，先读后写，若文件不存在，则报错；写入时为覆盖写入
#读取
filepath='D:/note1.txt'
file1=open(filepath)
print(file1.read) #读取文件内容
print(file1.readline())#读取一行内容，若要读取多行，写while循环
while True:
line = f.readline()
if not line:
break
print(line)
print(file1.readlines())#读取文件内容，返回值是列表，每一行就是一个元素，有换行符
a=f.readlines()
for i in a:
print(i)
print(file1.read.splitlines())#读取文件内容，返回值是列表，每样就是一个元素
#写入
filepath='D:/note1.txt'
file1=open(filepath,'w')
file1.write("床前明月光")
file1.close()
filepath='D:/note1.txt'
file1=open(filepath,'a')
file1.write("疑是地上霜")
file1.close()
filepath1='D:/note2.txt'
file2=open(filepath1,'w+')
file2.write("曲径通幽处，禅房花木深")
file2.seek(0) #让光标回到行首，seek(n) n表示偏移n位，英文1个字节，中文2个字节
print(file2.read())
file2.close()
filepath='D:/note88.txt'
filepath2='D:/note99.txt'
with open(filepath) as file1,open(filepath2) as file2:
print(file1.read())
print(file2.read())
读取yaml文件
import yaml
with open('config.yaml') as file1:
f = yaml.load(file1,Loader=yaml.FullLoader)
print(f)
#读取文件中的多段内容
with open('config.yaml'，encoding=’utf-8‘) as file1:
f = yaml.load_all(file1,Loader=yaml.FullLoader)
for one in f:
print(one)
yaml文件常见格式：
#列表
-10
-20
-30
#字典
name:qinc
age:29
#列表中的字典
-
name:qinc
age:29
-
A:apple
#字典中的列表
name：
-10
-20
-30
age:20
#字典中的字典
name:
name1:qinc
#多段内容，用---分隔
-10
-20
---
name:qinc
age:29
#变量
&变量名 定义变量
*变量名 使用变量
HOST:&HOST 192.168.30.78
URL:*HOST
七、异常处理+日志模块
概念
异常：程序无法按照预计结果开始走。一旦程序报错了，程序将终止运行。
try except语句
try:
执行可能出错的代码
没出错时，try执行完，一旦出现错误，立即跳转到except里
except：
出现异常以后执行的代码
#try except语句中，至少要有一个except，可以多个；也可以加一个else语句，一个finally语句
try:
int1=int(input('请输入一个数字：'))
print(1/int1)
except ZeroDivisionError:#0作为分母的异常
print('0不能作为分母')
except ValueError:#输入的是非数字的异常
print('您输入的不是数字')
except:#如果不指定异常类型，则捕获任何出现的异常
print('程序出现错误')
else:#当程序未捕获到异常时执行else中的语句
print('没有出现异常')
finally:#无论程序是否出现异常，都会执行
print('程序执行完毕')
常见的异常
NameError 未定义的变量
IndexError 下标越界
FileNotFoundError 找不到文件异常
IOError 输入输出异常，文件操作
KeyError 字典中的键不存在
TypeError 传入的对象类型与要求不符
SyntaxError 代码逻辑语法出错，不能执行
ImportError 无法引入模块的包
所有的异常都是Exception的子类，或者子类的子类，Exception的父类为BaseException
num1='a'
num2='b'
try:
print(num1*num2)
except Exception as e:
print('这里有一个bug',e)
#D:\Programs\Python\Python38\python.exe E:/输出/py/test.py
#这里有一个bug can't multiply sequence by non-int of type 'str'
#手动抛出异常
try:
raise IOError
except IOError as e:
print('这里有一个bug',e)
日志模块
日志等级，默认打印warning以上级别，可以设置level为别的级别
import logging
logging.basicConfig(level='DEBUG')
logging.debug('出现debug信息')
logging.info('出现info信息')
logging.warning('出现warning信息')
logging.error('出现error信息')
logging.critical('出现critical信息')
#将异常信息记录到日志
time.strftime('%y-%m-%d %H:%M:%S') #记录时间
traceback.formart_exc() #返回异常信息
import time
import logging
import traceback
logging.basicConfig(filename='D/log2023.log',filemode='a+')
try:
int1=int(input('请输入一个数字：'))
print(1/int1)
except ZeroDivisionError:#0作为分母的异常
logging.error(time.strftime('%y-%m-%d %H:%M:%S')+traceback.format_exc())
except ValueError:#输入的是非数字的异常
logging.error(time.strftime('%y-%m-%d %H:%M:%S')+traceback.format_exc())
except:#如果不指定异常类型，则捕获任何出现的异常
logging.error(time.strftime('%y-%m-%d %H:%M:%S')+traceback.format_exc())
八、面向对象
类名定义
类名也是标识符
字母、数字、下划线，且不能以数字开头
不能是关键字
大驼峰式命名：BigBoss 每个单词首字母大写
类定义
class BigBoss:
def fun1():
print('hello world')
类的属性
类属性、又称为 类变量---所有的实例共用一个类属性
获取类属性:类名.属性名
类属性的修改:类名.属性名=新值
实例可以使用类属性,但是类不能使用实例属性
实例属性（实例变量）---每个实例使用各自的实例属性
类成员自己独有的特征，并不是每个类成员都具备的
定义
在def __init__(self):里
self.属性名= 属性值
获取实例属性
实例对象.实例属性名
实例属性的修改
实例名称.属性名=新值
self：是在类的定义当中，表示对象自己。
self只能在init函数中使用
#写一个长方形的类
class Rectangle:
def __init__(self,length,width):# 初始化方法
self.length=length #将用户传的length转为实例自身的length
self.width=width #将用户传的width转为实例自身的width
def perimeter(self):#实例方法
return (self.lenth+self.width)*2
def area(self):#实例方法
return self.length*self.width
@classmethod #装饰器，声明下面的方法是类方法
def features(cls):
print('我是一个类方法')
@staticmethod #装饰器，声明下面的方法是静态方法
def sumdata(a,b): #静态方法
return a + b
rec1=Rectangle(8,6) #实例化
rec1.perimeter()#求周长
rec1.area()#求面积
print(rec1.__dict__)#打印实例的属性
#inspect模块，可以判断某个对象是否是方法或函数，返回值为布尔类型
import inspect
print(inspect.ismethod(rec1.perimeter))#true
print(inspect.ismethod(rec1.features))#true
print(inspect.ismethod(rec1.sumdata))#false
print(inspect.isfunction(rec1.perimeter))#false
print(inspect.isfunction(rec1.features))#false
print(inspect.isfunction(rec1.sumdata))#true
#注意：python中初始化方法与构造方法不是一个概念
实例方法（方法）
带有 self 参数的方法叫做实例方法
#只能通过对象（实例）去调用
类方法（方法）
#类和对象（实例）都可以调用 类方法
@classmethod #装饰器，声明下面的方法是类方法
def fun1(cls):
print('我是一个类方法')
静态方法（函数）
#静态方法：刚刚好放在类下面的普通函数，和类、实例，关系不大。只是为了方便管理
@staticmethod #装饰器，声明下面的方法是静态方法
def sumdata(a,b):
return a + b
#类或者实例都可以调用
继承
#完全继承
class Square(Rectangle):
pass
#部分继承,重写父类的一些方法
class Square(Rectangle):
def __init__(self,side):
self.length=side
self.width=side
#继承父类方法的同时，对父类方法进行扩展
class Square(Rectangle):
def __init__(self,side):
self.length=side
self.width=side
@classmethod #装饰器，声明下面的方法是类方法
def features(cls):
super().features()#声明继承父类的该方法
print('长和宽也相等')
#所有的类都是object类的子类
#类名.__mro__ 查询类之间的继承顺序
#类名.__dict__ 显示类的属性
#类名.__doc__ 显示类的注释
#类名.__base__ 显示父类的名称
#类名.__bases__ 显示所有父类的名称
#类名.__name__ 显示类的名称
#多重继承
class 子类名(父类名1，父类名2，父类3):
#如果所有的父类都具有同样的一个方法，继承顺序：1、现在自己里找 2、根据代码中继承的父类先后顺序查找
@property /类的静态属性、实例的静态属性
class Test1:
a=[1,2,3] #类的静态属性，具有唯一性
def __init__(self):
self.b=[4,5,6] #实例的静态属性，不具有唯一性
@property #声明下面的方法是一个属性而不是方法
def fun1(self):
return 'Hello'
tt = Test1()
print(tt.fun1()) #不加@property时，可作为方法调用
print(tt.fun1) #加@property时，fun1可作为属性调用
注：变量在类里称为属性
实例可以使用类属性、实例属性
但是类只能使用类属性，不能使用实例属性