《python基础知识》

python是一门解释型，面向对象、动态数据类型的高级程序设计语言
python特点：
4、变量无需申明
3、变量的数据类型可以随时改变
构造一个字节串对象

y = bytes()
y = b'asv'
print(type(y))

构建一个复数：
z = 10 +1j
print(z)
格式控制符：
z =1
print("今天是星期%d！"%z)
输出结果：今天是星期1！
小数点精度：
x = 3.1415926
print("%6.5f"%x)
输出结果：3.14159
数据类型转换：
格式：数据类型（参数）
！！注意不可以包含两种及以上的数据类型转换为一种
运算符：
//：整除
**：幂运算（？的？次方）
is（两个对象是否相同） 和 is not（两个对象是否不相同）
is 和==的区别：is判断对象，==判断值
逻辑运算符
and or not（与 或 非）
三目运算符：max = a if a>b else b(a 如果满足 a>b，a=max 否则 b=max)
选择排序：max = a if a>b else b c if else d
(a 如果满足 a>b，a=max 否则 b=max c 如果满足 c>d，c=max 否则 d=max abmax:cdmax对比 if ad>cd ad=max else cd=max)
if else格式：
# if ：条件：
# 执行语句
# else:
# 执行语句
while语句
while 判断:
语句
for in语句
for 变量 in （数组/字符串）（数组或字符串遍历）
格式：
for i in "abcde":
print(i)
补充：（range 叠带）
元组 列表 字典 集合
序列：在python中包括字符串 列表
特性：（用负数输出数组可以从后段连续读取找到超过数组或字符串长度）
如a = "abcd"
print(a[-3])
输出结果为b
切片
序列名 [开始位置：结束位置：间隔]
序列相乘：
a="asd"
print(a*5)
输出结果：asdasdasdasdasd
序列相加：
a="asd"
b="123"
print(a+b)
输出结果：asd123
序列遍历查找in：（一般情况为字符串）
a = "qweqrwqw"
print("qw" in a)
print("l" not in a)
输出结果：True True
常用内置方法：
max()取最大值
min()取最小值
str()转换为字符串
sum() 求和
len()求长
sorted()排序
reverse()反序
列表：
列表名 = [数据1,数据2,......]
list()将序列转换为列表
删除列表
del 列表名
添加数据进入列表
append将数据添加入列表中：
列表.append(对象)
extend()方法：拆分元素分别添加进入到列表中
列表.extend(对象)
insert()方法：
列表.insert(位置，对象)
(对象包括：列表、元组、数据、等等)
删除
del 列表[索引]
del 列表[起始位置：结束位置]
pop()删除
语法：列表.pop(索引)
remove(索引)删除
clear()方法清空列表
修改列表
列表名[索引]=“修改信息”
列表名[起始：结尾]=[“修改信息”]
列表名[起始：结尾：步长]=[“修改信息”]
查找：
index
列表.index(对象，开始，结束)
列表.count(对象)
元组：数据无法改变
元组名 (1，2，'334',[1,2,3],(1,2,3))
元组名（元素1，元素2......）
tuple()创建元组
如：a =tuple("张三") print(a) 输出结果如：（'张' '三'）
range：区间
元组[起始：结尾：步长]
字典：dict（无序存储的一个结构）
用键映射出值
创建字典：字典名 = {键1：值1，键2：值2，键3：值3......}
使用键：字典名 [键]
dict()创建字典
字典名 = dict(键 = 值)
字典名 = dict([(键,值),(键,值)])序列
字典名 = dict([[键,值],[键,值]])列表
字典名 = dict(((键,值),(键,值)))元组
添加一个键值update：
定义一个可被添加的字典
字典名 ={键：值}
定义一个可被添加的键值
键值名["键"] = "值"
字典名.update(添加的键值)
判断字典里的键是否有值用键 + in即可
使用字典的一些方法：
values():返回键所对应的值
keys()返回字典的键
items()返回一个字典的键值对
copy()拷贝
更新：update()
删除字典内容pop：字典名.pop()
集合:保存数据唯一性的的序列
集合名{}
集合名 = set()
add方法添加 （不能添加列表 字典 集合）
删除集合数据：remove（元素）
交集：& 数据1 & 数据2
并集：| 数据1 | 数据2
差集：- 数据1 - 数据2
对称差集：数据1 ^ 数据2 除去交集
输入input
格式： 对象名 = input("提示信息")
函数
内置 自定义
用dif 声明函数：
格式：def函数名 （参数列表）：
函数体
return 返回值
默认参数：
1、默认参数传参时请注意默认参数类型类型不同需要转换
2、默认参数必须写在无参的后面
python闭包:
一个可以被外部访问到变量的含数
python中也叫闭包函数和闭合函数
closure记录地址
使用：对象._closure_
参数：
形参 和 实参
位置参数：
1、通过位置传入类型相同数据类型和数量的参数
return：返回一个结果
None：空值 函数运行
变量作用域：（变量的使用有效范围）
匿名函数：关键字lambda
引用名 =lambda [参数列表]：函数表达式
exec()
eval()
函数式编程：
map():
map(function，Iterable)
function -- 函数
iterable -- 一个或多个序列
filter(function，Iterable):
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
函数注解：格式# def 函数名(参数：注解) -> (返回注解)：
类和对象：10.19
特性：通过类名直接调用
面向对象：（万物皆对象）
属性 方法
如何申明类：
class 类名：
属性
方法
实例化方法：
类名(参数)
调用方法：对象名.成员
构造函数：
__init__:初始化对象
def __init__(self):
print("init")
__new__:创建对象
使用方法：
def __new__(cls):
print("new")
构造方法：用构造创建对象
继承
语法：子类名（父类名）
self:默认参数，表示默认当前的类（本身）。
实例方法 和 类方法
类方法需要@classmethod
实例方法：至少传一个参数self
类方法：至少需要一个参数cls
类实例化 --对象：
类的实例方法：类中的方法一般都为实例方法
类实例至少需要包含一个self参数
类静态方法：
普通函数定义在全局命名空间
静态方法存于类命名空间
@staticmethod 装饰的静态方法
调用可使用类名和静态名
property方法：用法定义属性
在不破坏封装的情况下对类的属性进行操作
class property([fget[, fset[, fdel[, doc]]]])
property(获取属性，设置方法，删除属性，说明)
参数
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
封装：
_或什么都不写：代表公有
__：代表私有
继承
语法：子类名（父类名）
重写：
案例：
class A:
def show(self):
print("基类输出")
def show1(self):
print("基类输出2")
class B(A):
（重写）
def show(self):
print("子类输出")
def show1(self):
print("子类输出")
obj = B()
obj.show()
obj.show1()
A.show(obj)（调用基类方法）
多态：（同名函数执行不同方法）
对象指向不同的类结果不同
MetaClass(元类)
# # 原类
# class myMetaClass(type):
# def __new__(cls,obj,bases,dict1):
# dict1['name'] ='w1'
# dict1['show'] =lambda self:print("show方法")
# return super().__new__(cls,obj,bases,dict1)
# class B(object,metaclass =myMetaClass):
# pass
# obj =B()
# print(obj.name)
# obj.show()
type()函数 高级用法 动态创建类
A = type("A",(object,),dict(show = show,put = put,name = "1234567"))
type(objmane,bases,dict)

枚举类:(不能实例化对象，枚举值不可以在外部修改，两个枚举类型不可以直接比较)
在枚举类中一般是name和value来输出名和值
实例化对象个数相对固定的类
模块的引用：import 模块名
from 模块 import
from 模块 import*
import 模块名.函数
枚举值的编号：枚举变量：如：day->枚举变量 = 1->枚举值
# from enum import Enum
# class Color(Enum):
# RED = 1
# GREEN = 2
# BLUE = 3
# print(Color['RED'].value)
# print(Color.RED.value)
# print(type(Color.RED))
# print(type(Color.RED.value))
# print(Color.RED.value - Color.BLUE.value)
# 重载
# from functools import singledispatch
# @singledispatch
# # 修饰方法
# def f0(a):
# print("a")
# @f0.register(str)
# def f1(str):
# print("str")
# @f0.register(int)
# def f1(int):
# print("int")
# f0("")
__repr__能够把对象用字符串的形式表达出来
___dir__列出对象的所有属性
dir
class A:
def __init__(self):
self.a ="123"
self.b ="qwe"
def __repr__(self):
return self.a+self.b
def show():
pass
obj = A()
print(obj)
print(obj.__dir__())
del销毁：
class A:
def __init__(self):
self.a ="123"
self.b ="qwe"
def __del__(self):
print("我没了")
obj =A()
del obj
# 迭代器
# class A:
# def __init__(self):
# self.__list1=[]
# self.__step =0
# # 返回当前容器的下一个元素
# def __next__(self):
# if self.__step <=0:
# raise StopIteration
# self.__step -=1
# return self.__list1[self.__step]
# # __iter__返回迭代器
# def __iter__(self):
# return self
# # __setitem__设置迭代器
# def __setitem__(self,index,value):
# self.__list1.insert(index,value)
# self.__step +=1
# listobj = A()
# listobj[0] =10
# listobj[1] =20
# listobj[2] =30
# for index in listobj:
# print(index)
# 运算符重载
# __new__
# __init__
# __add__
# __lt__ __gt__(小于和大于)
# __le__ __ge__(小于等于和大于等于)
#常用的重载运算符比如
class B:
def __init__(self,a,b):
self.a = a
self.b = b
def __str__(self):
return "a:",str(self.a),"b",str(self.b)
__repr__ = __str__
def __add__(self,record):
if self.b + record.b:
return self.a - record.a,self.b - record.b
obj1 = B(12,11)
obj2 = B(4,5)
print(obj1+obj2)
这个例子把add方法重载，从而把相加变成相减
repr方法：能够把对象用字符串的形式表达出来（请区分repr和__repr__）

# 特殊实例方法__call__()
class A:
def __call__(self,a,b):
print("执行了")
print(a,b)
print( int(a) ** int(b,16) )
obj =A()
obj(3,'b')
异常
关键字
try:
pass（可能产生异常的代码模块）
except expression（错误信息） as identifier（存储错误的一个容器）:
pass（处理异常的代码模块）
try 和 except的语法
try:
num1 =int(input())
num2 =int(input())
print(num1/num2)
except(ArithmeticError,ValueError):
print("错误")
else:
pass
finally:
pass
else和 finally的语法
raise抛出
raise 异常
try:
a =int(input("sr"))
b =100/a
except ValueError:
print("输入整数，谢谢。")
# 检擦是否满足格式
except ArithmeticError:
print("a！=0")
#else在执行完try和except后执行else
else:
print("执行完毕！")
# （无论是否有异常都回执行finally）
finally:
del a
del b