学习 Python ##变量

#字典
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']
1、含义：内存空间的表示式
2、命名需要遵循规则；
import keyword
print(keyword.kw_list)
3、赋值使用 =
4、变量无数据类型 ##数据类型
1、整数类型 int
2、浮点类型 float
3、布尔类型 取值 False or True
4、字符串类型 str

1、数据类型运算方法

1、+、-、*、\
 2、5%3 = 5/3*2 除数 1 余数 2
3、17/3 = 5...返回为浮点数
4、17//3 =5 返回为整数
5、2\*\*2 = 4 计算为 2 的平方
###2、数据类型运算注意事项
1、2.2 + 2.1 = 4.2 浮点数相加会有相差
2、... ##类型转换
1、str()将其他类型转换为字符串
2、int()将其他类型转换为整数
3、float()将其他数据类型转换为浮点数
###1、类型转换使用方法
1、a=1 type(a)=int str(a) type(a)=str
2、a='1' type(a)=str int(a) type(a)=int
###2、类型转换注意事项
1、a='1.1' type(a)=str int(a) 报错 不能转换浮点数的字符串为整数
2、... ##数据类型之间连接
1、print('我叫' + name + ',今年' + str(age) + '岁') ###数据类型之间连接注意事项
1、字符串与整型链接，需要将整型转换为字符串 ##注释
1、单行注释 #这是一段注释
2、多行注释 '''这是一块注释'''

函数

# def fib(n): # """Print a Fibonacci erie's up to n.""" # a, b = 0, 1 #    while a < n: # print(a, end='') # a, b = b, a + b # print() # # # fib(1000)
# def f(a, L=None):
#     if L is None:
#         L = []
#     L.append(a)
#     return L
#
#
# print(f(1))
# print(f(2))
# print(f(3))

数据结构

list.append(x)
在列表末尾添加一个元素，相当于 a[len(a):] = [x] 。
list.extend(iterable)
用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable 。
list.insert(i, x)
在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0, x) 在列表开头插入元素， a.insert(len(a), x) 等同于 a.append(x) 。
list.remove(x)
从列表中删除第一个值为 x 的元素。未找到指定元素时，触发 ValueError 异常。
list.pop([i])
删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，a.pop() 删除并返回列表的最后一个元素。（方法签名中 i 两边的方括号表示该参数是可选的，不是要求输入方括号。这种表示法常见于 Python 参考库）。
list.clear()
删除列表里的所有元素，相当于 del a[:] 。
list.index(x[, start[, end]])
返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时，触发 ValueError 异常。
可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。
list.count(x)
返回列表中元素 x 出现的次数。
list.sort(*, key=None, reverse=False)
就地排序列表中的元素（要了解自定义排序参数，详见 sorted()）。
list.reverse()
翻转列表中的元素。
list.copy()
返回列表的浅拷贝。相当于 a[:] 。

堆栈 队列 元组

实现队列最好用 collections.dequeue ###队列
from collections import dequeue
dequeue = dequeue(['aa', 'bb', 'cc'])
dequeue.append('dd')
print(dequeue)
dequeue.poppet()
print(dequeue)
dequeue.poppet()
print(dequeue)

堆栈

stack = [3, 4, 5, 6, 7]
print(stack) # [3, 4, 5, 6, 7]
stack.pop() # 7
print(stack) # 4, 5, 6]
stack.pop() # 6
stack.pop() # 5
print(stack) # [3, 4] ####列表行列转换
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]] ## print(matrix) ### 转置行列
Sprint(list(zip(\*matrix))) # [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)] ###元组
t = 'aa', 'dd', 'a1'
print(t)
u = t, ('cc', 'gg')
print(u)
##集合 # 集合 # basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} # # print(basket) # {'orange', 'banana', 'apple', 'pear'} 集合没有重复的 ##字典 # # # 字典 # tel = {'jack': 1990, 'age': 50} # # print(tel) # {'jack': 1990, 'age': 50} # # print(tel['jack']) # 1990 以关键字作为索引 # # dict() 构造函数可以直接用键值对序列创建字典 ##常见的数据异常
1、except ZeroDivisionError
2、except IndexError
3、except KeyError
4、except NameError
5、except SyntaxError
6、except ValueError ##异常使用
try:
a = int(input('请输入第一个数'))
b = int(input('请输入第二个数'))
result = a / b
except BaseException as e:
print('出错了', e)
else:
print('结果为：', result)
finally:
print('无论是否产生异常，都执行')
print('程序结束') ##编程思想
不同点 共同点
面向过程：顺序执行 解决问题
面向对象：模块执行 解决问题 ##类
#1、类的创建 class Student
pass #关键词：class 类名（首字母大写）
#2、类的内存空间
print(id(Student)) # 140420918074560
print(type(Student)) # <class 'type'>
print(Student) # <class '**main**.Student'>
#3、类创建模板
#4、类属性 #类中方法外的变量成为类属性，其被属于该类的所有对象共享
#5、类方法 #使用@classmethod 修饰符的方法,使用类名直接使用的方法
#6、静态方法 #使用 staticmethod 修饰的主法,使用类名直接访问使用的方法
#7、类的封装 在属性前面加**
#Python 没有专门的修饰符封装私有，封装私有变量和方法，提高安全性
#8、类的继承 提高代码复用性 # 类的继承 ##定义父类
class Person(object):
def **init**(self, name, age):
self.name = name
self.age = age
def info(self):
print('姓名:{0},年龄:{1}'.format(self.name, self.age)) ##定义子类
class Teenage(Person):
def **init**(self, name, age, score):
super().**init\_\_(name, age)
self.score = score ###测试
stu6 = Teenage('jack', 20, '99')
stu6.info() # 多继承 C=>A,B=>object
class A(object):
pass
class B(object):
pass
class C(A, B):
    pass
 ##方法重写：父类方法不能满足子类需求，需要重写方法
#9、类的多态 增加代码扩展性
class Animal(object):
#     def eat(self):
#         print('动物要吃东西')
#
#
# class Dog(Animal):
#     def eat(self):
#         print('狗吃肉')
#
#
# class Cat(Animal):
#     def eat(self):
#         print('猫吃鱼')
#
#
# class Person(Animal):
#     def eat(self):
#         print('人吃五谷杂粮')
#
#
# def fun(animal):
#     animal.eat()
#
#
# fun(Dog())
# fun(Cat())
# fun(Person())

类的特殊方法和属性 #类的特殊属性

class A(object):
pass
class B(object):
pass
class C(A, B):
def **init**(self, name, age):
self.name = name
self.age = age
class D(A):
pass
x = C('jack', 20)
print(x.**dict**) # 实例对象的属性字典 {'name': 'jack', 'age': 20}
print(C.**dict**) # 类对象属性和方法字典 {'**module**': '**main**', '**init**': <function C.**init** at 0x10429e050>, '**doc**': None}
print('-------------')
print(x.**class**) # 列出该实例对象所属的类对象 <class '**main**.C'>
print(C.**bases**) # 列出继承的类对象 (<class '**main**.A'>, <class '**main**.B'>)
print(C.**base**) # 列出继承的第一个类 <class '**main**.A'>
print(C.**mro**) # 列出该类继承继承层次结构
print(A.**subclasses**()) # 列出子类 [<class '__main__.C'>, <class '__main__.D'>] #类的特殊方法
#add()
class Student(object):
def **init**(self, name):
self.name = name
def **add**(self, other): #实现了两个对象的加法运算，在类中编写 Add 方法
return self.name + other.name
stu1 = Student('张三')
stu2 = Student('李斯')
s = stu1.name + stu2.name
print(s)
#len()
class Student(object):
def **init**(self, name):
self.name = name
def **len**(self):
return len(self.name)
stu1 = Student('张三')
print(len(stu1))
list1 = [1, 2, 3, 5]
print(len(list1))
#new() 创建对象 创建子对象
class Student(object):
def **new**(cls, \*args, \*\*kwan's):
print('**new**被调用执行，cls 的 id 值为：{0}'.format(id(cls)))
obj = super().**new**(cls)
print('创建对象得到 id 为：{0}'.format(id(obj)))
return obj
def __init__(self, name, age):
print('__init__被调用执行，self的id值为：{0}'.format(id(self)))
self.name = name
self.age = age
print('object这个的对象的id为:{0}'.format(id(object)))
print('Student这个的对象的id为:{0}'.format(id(Student)))
# 创建Student类的实例对象
p1 = Student('张三', 20)
print('p1这个Student类的实例对象的id为：{0}'.format(id(p1)))
#变量的赋值
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self, cpu, disk):
self.cpu = cpu
self.disk = disk
# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)  # <__main__.CPU instance at 0x101619710>
print(cpu2)  # <__main__.CPU instance at 0x101619710>
# 类的浅拷贝  拷贝后源对象与子对象指向同一个子类对象
print('---------------')
disk = Disk()  # 创建一个硬盘类对象
computer = Computer(cpu1, disk)  # 创建一个计算机类对象
import copy
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)  # <__main__.Computer object at 0x109adb4d0> <__main__.CPU object at 0x109acb790> <__main__.Disk object at 0x109adb450>
print(computer2, computer2.cpu, computer2.disk)  # <__main__.Computer object at 0x109adb650> <__main__.CPU object at 0x109acb790> <__main__.Disk object at 0x109adb450>
# 深拷贝 拷贝源对象子对象
computer3 = copy.deepcopy(computer)
print('---------------')
print(computer, computer.cpu, computer.disk)  # <__main__.Computer object at 0x109adb4d0> <__main__.CPU object at 0x109acb790> <__main__.Disk object at 0x109adb450>
print(computer3, computer3.cpu, computer3.disk)  # <__main__.Computer object at 0x109adb910> <__main__.CPU object at 0x109add090> <__main__.Disk object at 0x109add1d0>

模块

与函数封装类似，提高代码可维护性，提高代码可复用性 ###
import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2, 3), type(math.pow(2, 3))) ### # from 模块 import 函数、方法
from math import pi
from math import pow
print(pi)
print(pow(2, 6)) ###导入自定义模块 # 导入自定义模块，并使用 选中根目录，选择 mark directory as 变成更路由 # import demo2
#from demo2 import add
#print(add(2, 10)) #在导入的文件里面，有其他函数或输出语句不需要输出时，可以添加一下代码处理
#if **name** == '**main**': # 只有运行本文件才执行代码，导入其他文件时不会执行
#print(10 + 30) ###包 包+模块 可以避免模块名冲突， #注意事项 使用 import 的是，只能导入包名或者模块名 使用 from 可以带入命名和模块名
import pageage_1.moudle_a as ma
print(ma.a)

标准库的使用和介绍

 <!-- import imp
 import sys # 与 Python 解释器及其环境相关的数据
 import time # 提供与时间相关的各种函数的标准库
 import os # 提供了访问操作系统服务功能的标准库
 import calendar # 提供了与日期相关的各种函数的标准库
 import urllib.request # 提供了用于读取来自网上（服务器）的数据标准库
 import json # 提供了使用 json 序列化和反序列化对象
 import re # 用于在字符串中执行正则表达式匹配和替换
 import math # 提供了标准算术运算函数的标准库
 import decimal # 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
 import logging # 提供了灵活的记录事件、错误、警告和调试信息等日志的功能
 print(sys.getsizeof(11))
 print(sys.getsizeof(True))
 print(sys.getsizeof('44'))
 print(time.time())
 print(time.localtime(time.time()))
 print(urllib.request.urlopen('http://www.baidu.com').read()) #第三方模块的使用 #第三方模块的使用 例如日程模块 1、pip3 install schedule 2、进入 python3 3、输入 import schedule #实现定时发送邮件：办公自动化 # import schedule # import time # def job(): # print('哈哈----') # schedule.every(3).seconds.do(job) # while True: # schedule.run_pending() # time.sleep(1) -->

with 管理上下文

装饰器

重构url

# url_for() 第一个参数为目标函数名，将其路由转换为url，第二个参数为关键字 需要填入url后置,参数的多少。与目标函数所绑定的url相匹配
#book['url'] = url_for('book_detail', book_id=book['id'])

请求方法设置

# 如果只是获取服务器的数据，则一般使用get请求，如果前端需要把数据发送给服务器，则用post请求
# 在路由路径加入参数methods，限制请求方式
#@app.route('/book/detail/<string:book_id>', methods=['GET', 'POST'])

测试方法 unittest

方法名称
assertEqual() 失败除非相等
assertNotEqual()失败如果相等
assertTrue()失败除非
assertFalse()如果失败
assertRaises() 除非增加否则失败
assertAlmostEqual()失败除非几乎相等
assertNotAlmostEqual()失败如果几乎相等

重定向设置

#@app.route("/profile")
# def profile():
# 获取用户在接口输入的url
user_id = request.args.get('id')
# 参数传递的两种方式：
#   1、作为url的组成部分：/book/1
#   2、查询字符串：/book?id=1
# print(user_id)
#if user_id:
#    return "用户个人中心"
#else:
#   return redirect(url_for("index"))

加载静态文件

动态的 web 应用同样需要静态文件。CSS 和 JavaScript 文件通常来源于此。理想情况下， 你的 web 服务器已经配置好为它们服务，然而在开发过程中 Flask 能够做到。 只要在你的包中或模块旁边创建一个名为 static 的文件夹，在应用中使用 /static 即可访问。
给静态文件生成 URL ，使用特殊的 'static' 端点名:
url_for('static', filename='style.css')

会话：cookies基础上改造

除了请求对象，还有第二个称为 session 对象允许你在不同请求间存储特定用户的信息。 这是在 cookies 的基础上实现的，   并且在 cookies 中使用加密的签名。这意味着用户可以查看 cookie 的内容， 但是不能修改它，除非它知道签名的密钥。

常用库介绍

Flask 常用库详情
flask-script
为Flask提供强大的命令行操作，与Django shell类似。
flask-login
Flask user session 管理，提供诸如login_user, logout_user, login_required, current_user等功能，也是其他很多Flask库的基础。
flask-admin
为Flask应用提供操作简单且易于扩展的数据库管理界面，与Django自带的数据库管理app类似。
Flask-WTF
Flask与WTForms的集成，提供强大的Form安全和校验机制，与Django内置的Form功能类似。
flask-principal
Flask强大的权限管理机制，灵活性强，提供了一个权限管理的基础框架，是很多Flask权限相关扩展的基础。
flask-restful
一个强大的Flask RESTful框架，简单好用。
flask-api
相当于Django REST Framework的Flask版，是另一个强大的Flask RESTful框架。
Flask-Mail
Flask-Mail 为Flask应用添加了SMTP 邮件发送功能
Flask-User
Flask-User集成了用户管理相关功能，并允许对功能做定制性修改，其相关功能包括Register, Confirm email, Login, Change username, Change password, Forgot password等。
Flask-User 基于Flask-SQLAlchemy，NoSQL数据库无法使用。
flask-security
Flask-Security让开发者能够很快的为应用添加常用的安全机制，其整合了Flask-Login, Flask-Mail, Flask-Principal, Flask-Script等应用。其安全机制包括：
Session based authentication
Role management
Password encryption
Basic HTTP authentication
Token based authentication
Token based account activation (optional)
Token based password recovery / resetting (optional)
User registration (optional)
Login tracking (optional)
JSON/Ajax Support
flask-babel
Flask国际化和本地化扩展，基于Babel
flask-locale
为Flask应用添加语言包，与flask-babel类似。

flask_蓝图

###蓝图：Blueprint 是一种组织一组相关视图及其他代码的方式。与把视图及其他 代码直接注册到应用的方式不同，蓝图方式是把它们注册到蓝图，然后在工厂函数中 把蓝图注册到应用。
###理解：在vue中，蓝图相当于路由管理，把所有组件放置在路由，并通过一些方法，让其他组件可以快速访问，其中路由守卫的功能在蓝图中实现，进入或者离开

tran库常见问题处理

    常见问题和处理
故障：flask.cli.NoAppException: Could not import "manage".
原因：Flask需要在网站的根目录下运行，在其它路径地方运行会出现，遇到这个提示要检查是否在正确位置，不对的要进入网站目录
cd /web/www/py_xxx
故障：Address already in use
原因：已经有相同的程序运行着，端口不能重复使用，需要运行下面的命令清除
ps -e | grep flask | grep -v grep | awk '{ print $1 }' | xargs sudo kill
故障：ImportError: No module named 'flask-mail' 或者 ModuleNotFoundError: No module named 'loguru'
原因：模块没有按照引起，需要重新运行命令安装（其它模块缺少也是如此安装，注意：xcore xuser xadmin xweb是公司开发组件，看上面的安装提示）：
sudo pip3 install flask-mail
故障：ssl.SSLError: [SSL] PEM lib
原因：网站证书错误或者或者下载有问题，运行下面的命令修复
wget -T 10 -t 3 -O /web/tools/dev.com.pem http://soft.oa.com/dev.com.pem
wget -T 10 -t 3 -O /web/tools/dev.com.key http://soft.oa.com/dev.com.key
故障：ImportError: cannot import name 'bytes_type'
原因：组件版本问题
sudo pip3 install oauthlib==2.1.0 requests-oauthlib==1.1.0
故障：mongoengine.connection.ConnectionFailure: You have not defined a default connection
原因：mongoengine版本问题，运行如下命令更换下版本即可
pip3 install mongoengine==0.19.0
故障：访问 https://dev.com 时候，浏览器提示证书错误
原因：没有安装好浏览器证书，运行命令修复，安装完成以后需要重启电脑，更多的问题解决方案看：https测试环境
wget -T 10 -t 3 -O /tmp/telking.pem http://soft.oa.com/telking.pem
sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/telking.pem