python

#导出依赖库表
pip freeze > requirements.txt
#安装依赖库
pip install -r requirements.txt

#print指定分隔符和尾符
print(name,age,gender,sep="|",end="!")

转义字符
\n #换行
\t #制表符
\r #回车
\\ #转义\
r'所有字符串原义' #保留原义

格式化输出
%s #字符串占位符 等于简写str()函数
%d #数字占位符  浮点数转换只能取整
%f #浮点数占位符 %.2f   定义小数保留位数且4舍5入
message = '我今年{}岁了，{}结婚！'.format(18,'还没') #字符串占位函数

输入
input() #默认全转字符串，数字要int()转换

打印内存地址函数
id（）

=
+
-
*
/
+=
-=
*=
/=
**
//	#整除
%	#求余
==
!=
>
<
>=
<=
is     #比较内存地址是否相同
not is
and
or
not
in
not in
二进制转换
bin()  
int()   #十进制转换
&   #与
|   #或
!   #非
^   #异或
<<  
>>  
~   #取反

条件判断
三目运算
(a+b) if a<b else (b-a)     #真算前面，假算后面
if elif else
for in
range(start,end.step)
for else
break   #立刻退出循环
continue    #跳过本次循环。进入下一轮
while


[5:0:-1]  #字符串倒序取值，【开始：结束：倒序】

字符串方法
capitalize()    #将一句话的第一个字符转成大写
title()         #每个字符串单词首字母大写
istitle()       #判断是否是title字符串。所有is开头的内置函数均为判断。返回值True/False
upper()         #大写所有
lower()         #小写所有
len()           #求长度
sum()           #求和
find()          #查找字符串。-1没找到，或找到的第一个的下标，可选beg/end
rfind()         #从右侧开始找
index()         #等同find(),区别没找到会抛出异常
rindex()
replace()       #替换字符串（old,new,max）max替换次数
encode()        #编码 默认encoding='UTF-8' gbk中文  gb2312简体中文  unicode淘汰了
decode()        #解码 
startswith()    #判断字符串是否以xxx开头
endswith()      #判断字符串是否以xxx结尾
isalpha()       #判断全字母组合
isdigit()       #判断全数字组合
join()          #以指定'分隔符'将字符串序列连接起来
lstrip()        #可选第二参数，代表次数
rstrip()
strip()
count()         #求字符串中指定参数的个数

[]              #可用if in
del list[index]          #删除要控制下标长度。while优于for
append()        #追加
extend()        #追加拆分单位，适用于追加列表
insert(下标,'元素') #有序插入
sorted()          #默认升序排列  reverse=False降序
remove('元素')    #移除第一个匹配项
pop()             #删除列表中最后一个元素,返回值为弹出元素 可指定下标删除
clear()           #清除列表
reverse()         #反转列表————改变源列表
sort() = sorted()
count()           #查询元素出现次数
enumerate()       #枚举。得到下标
                  '''
                  for index,values in enumerate(list):
                    print(index,value)

                  '''
max()
min()
()                #元组不可变列表 只有一个元素必须加,
index()           #找出元素下标

拆装包
a,b,*c = list     #元素多的情况c为列表，少的情况c为空列表

dict{}                  #
dict['key'] = 'value'   #增改
dict['key']             #查
dict.items()            #拆分成包含元组的列表 可遍历
dict.values()           #取出所有value返回列表
dict.keys()             #取出所有keys返回列表
dict.get('key')         #按key取value 找不到不报错 可设default
del dict['key']         #删
dict.pop('key')         #弹出并返回value     如没有可设默认值，并增加键值对
dict.popitem()          #删除末尾键值对
dict.clear()            #清空
dict.update()           #合并并覆盖重名键值对
dict.fromkeys()         #列表转字典，无值可设默认值

set()                   #无序不重复
set.add()               #增 增序列
set.update()            #增 不可增序列
set.remove()            #删 不存在报错
set.pop()               #在集合中删除第一个
set.clear()             #清空
set.discard()           #删 不存在不报错
in\==\!=...
#不支持+ * 
set-set                 #等于.difference()去除差集
set&set                 #等于.intersection() 求交集
set|set                 #等于.union() 并集
set^set                 #等于.symmetric_difference()对称差集

不可变内存地址 str int float tuple set
可变内存地址 dict list

def func():      #定义 可设形参
func()           #调用 传入实参
isinstance()      #对比两个对象类型是否相同
(x,*args)         #可变参数 默认转元组
(a,b=1,c=2)       #关键字参数，可以赋默认值 隔位赋值通过关键字(a,c=5)
(**kwargs)        #接收键值对可变参数 默认转字典 接收字典加** **看成拆装字典动作
return            #必须有变量接收函数结果 可以一借多返回值返回元组 也可多接多
global            #声明全局变量 声明后可在函数内修改原变量 可变类型不需要声明如：列表/字典
nonlocal          #内部函数声明外部函数变量 全局依然是global
locals()          #查看已有本地变量
globals()         #查看已有全局变量
闭包  ·外部函数有内部函数  ·外部函数return内部函数名  ·内部函数引用外部函数变量
     ·闭包因每次传参开辟新内存地址，所以可以保存状态   ·闭包多层返回需要多层接收 a=b()=c()

@装饰器            #把被装饰函数作为参数传给装饰函数   ·返回值赋给被装饰函数
定义装饰函数              def decorate(func):
                            def wrapper(*args,**kwargs):
                                pass
                            func(*args,**kwargs)
                        return wrapper
                        @decorate
                        def function(x,y,z)
                            ...
#多层装饰器，离的近的先于离得远的执行
@装饰器(参数)    ------------    装饰函数扩大一层用于接参

new = lambda a,b:a+b #匿名函数 ， 需要接收返回值
result = new(3,5)    #调用需接收结果

map(func,iterable)                #将函数功能作用于可迭代对象中每个元素
reduce(func,iterable)             #将函数累加作用于每一个元素
filter(func,list)                 #过滤
sorted(iterable,key,reverse)      #排序
递归 调用自己 返回自己 设定终止条件

open(file,mode,buffering,encoding)      #r读 w写 a追加 rb,wb二进制
read()  readline() readlines()返回列表
stream.write() writelines()             #写入
复制--->  先读后写
with                                    #上下文 自动关闭流
as                                      #别名
close()                                 #关闭流
os.path.dirname(__file__)               #当前文件夹绝对路径
os.path.abspath('文件名')                #根据相对路径找绝对路径
os.path.join(path,'文件名')              #拼接文件地址
os.path.split()                         #路径转元组（路径,文件名）
os.path.splitext()                      #分割路径于库扩展名为元组
os.path.getsize()                       #返回文件大小字节
os.getcwd()                             #返回当前目录的文件夹路径
os.listdir()                            #返回目录所有文件及文件夹为列表
os.mkdir()                              #创建文件夹
os.rmdir()                              #删除文件夹-只能删空
os.removedirs()                         #删除多层目录-只能删空
os.remove()                             #删除文件
os.chdir()                              #切换目录    os.getcwd()
文件复制    写循环读原文件/目录------> 写进新目录

try:
except:
finally:                #是否存在一场都会执行
raise                   #主动抛出异常

生成器
[表达式 for 变量 in 旧列表] [表达式 for 变量 in 旧列表 if 条件] 返回新列表
[name.capitalize() for name in names if len(name>3)]
[i for i in range(1,100) if i>50 and i <75]
可以嵌套多循环多条件
[表达式 if else 表达式 for循环]
[em['s'] + 200 if em['s'] >5000 else em['s'] +500 for em in list]
{x-1 for x in list if x > 5}                    集合推导
{value:key for key,value in dict1.items()}      字典推导
l =[x*3 for x in range(90)]    推导式 返回列表
g =(x*3 for x in range(90))    生成器 返回对象
g.__next__()                   #调用一次产生一个 等价 net(g)
函数生成器 yield      net(此生成器)调用    yield暂停属性
.send()可从生成器循环间隔中插入值 从外面向生成器递值 用于携程

isinstance(obj,Iterable)       #判断可迭代对象
迭代器
iter()                         #可迭代对象---->迭代器
---------------------------------------------------

"""
属性是变量
方法是函数
class 类名():                 #类
    def 方法(self):           #定义方法
        ...
对象名 = 类名()                #创建对象
对象.方法()                    #调用方法
---------------------------------------------------
对象名.属性名 = 值              #类外添加对象属性
对象名.属性名                   #类外访问对象属性
self.属性名                    #类里获取对象属性
---------------------------------------------------
def __init__(self[,参数]):     #初始化方法，自动调用    参数通过实例化传递
def __str__(self):            #对象返回值 默认return内存地址 可增加格式化字符串输出
---------------------------------------------------
实例方法作为参数传给另外的类实例
1-1继承
多继承 class Prentice(school,Master):     多继承同名方法默认使用第一个继承类的方法
子类重新父类同名属性和方法覆盖父类
print(类.__mro__)              #查看子类的继承关系
---------------------------------------------------
子类调用父类同名属性和方法:
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        #调用父类方法后，被父类覆盖，想不被覆盖，子类自己也要初始化属性
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    #子类调用父类的同名方法和属性：把父类的同名属性和方法再封装
    def make_master_cake(self):
        Master.__init__(self)   #重新初始化父属性
        Master.make_cake(self)  #再调用父方法
super()
super(当前类名,self).函数()
super(Prentice,self).__init__()     #调用父类属性与方法
super(Prentice, self).make_cake()
super().__init__()                  #无参数默认调用父类属性和方法
super().make_cake()
super(School,self).__init__()       #填父类[school]，可调用爷爷类[Master]
super(School,self).make_cake()
-----------------------------------------------------
私有属性和方法     #不继承给子类
self.__属性
def __方法(self)
获取,修改私有属性（在类中定义函数）
    def get_money(self):
        return self.__money
    def set_money(self):
        self.__money = 500
print(xiaoqiu.get_money())
xiaoqiu.set_money()
----------------------------------------------------
多态
class Dog(object):
    def work(self):
        pass

class ArmyDog(Dog):
    def work(self):
        print('追击敌人！')

class DrugDog(Dog):
    def work(self):
        print('追查毒品...')

class Person(object):
    def work_with_dog(self,dog):
        dog.work()


ad = ArmyDog()
dd = DrugDog()

daqiu = Person()

daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)
-----------------------------------------------------------
类属性被实例共有.通过实例无法修改类属性，而是新增实例属性
类方法配合类属性 访问或修改私有类属性
class Dog(object):
    __tooth = 10

    @classmethod
    def get__tooth(cls):
        return  cls.__tooth
关键 @classmethod cls
-----------------------------------------------------------
静态方法
@staticmethod     没有self/cls 不需要传参
class Dog(object):
    @staticmethod
    def info_print():
        print('这是个狗类')
dog = Dog()
dog.info_print()
Dog.info_print()

"""


#
# class Dog(object):
#     @staticmethod
#     def info_print():
#         print('这是个狗类')
# dog = Dog()
# dog.info_print()
# Dog.info_print()








# class Dog(object):
#     __tooth = 100
#
#     @classmethod
#     def get__tooth(cls):
#         return  cls.__tooth
#
# dog = Dog()
#
# print(dog.get__tooth())
#
#
#
# class Dog(object):
#     tooth = 10
#
# wangcai = Dog()
# xiaohei = Dog()
#
# Dog.tooth = 22
#
# wangcai.tooth = 11
# print(Dog.tooth)
# print(wangcai.tooth)
# print(xiaohei.tooth)



# class Master(object):
#     def __init__(self):
#         self.kongfu = '[古法兼并果子配方]'
#
#     def make_cake(self):
#         print(f'运用{self.kongfu}制作煎饼果子')
#
# class School(Master):
#     def __init__(self):
#         self.kongfu = '[黑马煎饼果子配方]'
#     def make_cake(self):
#         print(f'运用{self.kongfu}制作煎饼果子')
#
#         # super(School,self).__init__()
#         # super(School,self).make_cake()
#         # super().__init__()
#         # super().make_cake()
# class Prentice(School):
#     def __init__(self):
#         self.kongfu = '[独创煎饼果子配方]'
#         self.__money = 200000
#
#     def get_money(self):
#         return self.__money
#
#     def set_money(self):
#         self.__money = 500
#
#
#     def make_cake(self):
#         #调用父类方法后，被父类覆盖，想不被覆盖，子类自己也要初始化属性
#         self.__init__()
#         print(f'运用{self.kongfu}制作煎饼果子')
#
#     #子类调用父类的同名方法和属性：把父类的同名属性和方法再封装
#     def make_master_cake(self):
#         Master.__init__(self)   #重新初始化父属性
#         Master.make_cake(self)  #再调用父方法
#
#     def make_school_cake(self):
#         School.__init__(self)
#         School.make_cake(self)
#
#     def make_old_cake(self):
#         # School.__init__(self)
#         # School.make_cake(self)
#         # Master.__init__(self)
#         # Master.make_cake(self)
#
#         # super(Prentice,self).__init__()
#         # super(Prentice, self).make_cake()
#
#         super(School,self).__init__()
#         super(School,self).make_cake()
#
# class Tusun(Prentice):
#     pass
#
#
# daqiu = Prentice()
# print(daqiu.kongfu)
# # daqiu.make_cake()
# print(Prentice.__mro__)
#
# # daqiu.make_master_cake()
# # daqiu.make_school_cake()
# # daqiu.make_cake()
#
# xiaoqiu = Tusun()
# #
# # xiaoqiu.make_cake()
# # xiaoqiu.make_master_cake()
# # xiaoqiu.make_school_cake()
# xiaoqiu.make_old_cake()
#
# print(xiaoqiu.get_money())
#
# xiaoqiu.set_money()
#
# print(xiaoqiu.get_money())

# class A(object):
#     def __init__(self):
#         self.num = 1
#
#     def info_print(self):
#         print(self.num)
#
#
# class B(A):
#     pass
#
#
# result = B()
# result.info_print()




# class Furniture():
#     def __init__(self, name, area):
#         self.name = name
#         self.area = area
#
#
# class Home():
#     def __init__(self, address, area):
#         self.address = address
#         self.area = area
#         self.free_area = area
#         self.furniture = []
#
#     def __str__(self):
#         return f'房子位置在{self.address},房屋面积是{self.area},剩余面积{self.free_area},家具有{self.furniture}'
#
#     def add_furniture(self, item):
#         if item.area <= self.free_area:
#             self.furniture.append(item.name)
#             self.free_area -= item.area
#         else:
#             print('家具太大，装不下了')
#
# bed = Furniture('双人床', 6)
# sofa = Furniture('沙发', 10)
# ball = Furniture('篮球场',2000)
# jia1 = Home('北京', 1000, )
# print(jia1)
#
# jia1.add_furniture(bed)
# print(jia1)
#
# jia1.add_furniture(ball)
# print(jia1)