# 方法一
a1 = [] # 定义空列表
a2 = [1,2,3,4] # 存4个值 索引0-3
a3 = [1,[2,3,4]] # 嵌套列表

# 方法二(不推荐)
b1 = list() # 空列表

a = ['a','b','c','d','e','a','a',1,2]

a[2] # 通过索引 'c'
a[-1] # 通过索引从右开始取值 2
a.index('b') # 查找元素(从左往右)对应的索引 1
a.count('a') # 返回元素的个数 3

a = ['a','b','c','d','e','f','aa','bb','cc']

# 取前三个
a[0:3] # 包头不包尾

# 取最后四个
a[-1:-4] # []
a[-4:] # ['f','aa','bb','cc']

# 取前三
a[:3]

# 取所有
a[:]

# 跳指定步子取值
a[::2]

a = [1,2,3,4,5]
a.append('peiqi')
print(a) # [1,2,3,4,5,'peiqi']

# 指定位置插入
a.insert(0,'a') 
print(a) # ['a',1,2,3,4,5,'peiqi']

a = [1,2,3,4,5]
a[2] = 'a'
print(a) # [1,2,'a',4,5]

a = [1,2,3,4,5,6,7,8,9,10]
a.pop() # 删除最后一个
print(a) # [1,2,3,4,5,6,7,8,9]


b = [1,2,3,4,'a',4,'b']
b.remove(4) # 删除指定元素  从左往右匹配的第一个
print(b) # [1,2,3,'a',4,'b']

c = [1,2,3,4,5,6,7,8,9]
del c[2]
print(c) # [1,2,4,5,6,7,8,9]

del c[0:3] # 切片删

del c # 删除整个数组
print(c) # 报错

a = [1,2,3,4,5,5]
for i in a:
    print(i)

n = ['a','e','b','c',34,23]
n.sort() # 报错 不支持 int和 str一起排


m = ['a','e','A','b','c','z','h']
m.sort() # ['A','a','b','c','e','h','z']
m.insert(3,'#')
m.insert(3,'*')
m.insert(1,'!')
m.sort() # ['!','#','*','A','a','b','c','e','h','z']
# 字符按ascⅡ排序

m.reverse() # 翻转


# 列表拼接
[1,2,3] + [4,5,6] ==> [1,2,3,4,5,6]

# n.extent(n2)

a = [1,2,3]
a.clear() # []

b = [1,2,3]
c = b.copy() # b 和 c是完全独立的

a = ['a','b','c']

count = 0;
for i in a:
    print(i,count)
    count += 1

方法二 enumerate 枚举

for i in enumerate(a):
    print(i) 

'''
{0:'a'}
{1:'b'}
{2:'c'}
'''

for index,value in enumerate(a):
    print(index,value)

如:
二进制       十进制     八进制     十六进制
0000 0000    0          0         0
0000 0001    1          1         1
0000 0010    2          2         2
0000 0011    3          3         3
0000 0100    4          4         4
0000 0101    5          5         5
0000 0110    6          6         6
0000 0111    7          7         7
0000 1000    8         10         8
0000 1001    9         11         9
0000 1010   10         12         a
0000 1011   11         13         b
0000 1100   12         14         c
0000 1101   13         15         d
0000 1110   14         16         e
0000 1111   15         17         f

.py文件程序首行声明编码

第一种 官方推荐的
#! -*-coding: utf-8 -*-

第二种
#!encoding:utf-8

python3里默认支持中文

print(1.399e3) # 1399.0

# 可以用来做量子力学(编程基本用不到)
print(-5+4j)

借助 decimal 模块的 getcontext 和 Decimal方法(自行百度吧！)

+
- 
*
/
%  取余
** 幂运算   2的三次方    ==> 2**3
// 整除     11//2 ==>5

== 等于
!= 不等于
<> 不等于 类似 !=  在python3里废除了
> 
<
>=
<=

=
+=
-=
*=
/=
%=
**=
//=

and 且
or  或
not 非

if 条件 :
    满足条件后执行的代码

age = 56
if age > 50:
    print('岁数太大不要')
print('haha')

结果：
'岁数太大不要'
'haha'

if 条件 :
    满足条件后执行的代码
else:
    不满足条件执行的代码

if 条件1 :
    print('条件1合适')
elif 条件2 :
    print('条件2合适')
elif 条件3 :
    print('条件3合适')
elif 条件4 :
    print('条件4合适')
else :
    print('都不合适')

while 条件:
    执行代码

count = 0
while count<=100:
    print(count)
    count += 1
print('loop is end')

count = 0
while count<=100:
    if count % 2 == 0:
        print("loop",count)
    count += 1

count = 0
while count<=100:
    if count == 50:
        pass # 代表过
    elif count>=60 and count<=80:
        print(count*count)
    else:
        print(count)
    count += 1

# 就是条件永远都满足，就会触发死循环

while True:
    print('xxx')

count = 0
while count < 100:
    print(count)
    if count == 5:
        break
    count += 1

count = 5的时候结束循环

但是如果把break 换成continue就会造成死循环

因为 count +=1 得不到执行 count一直等于5

count = 0
while count < 100:
    count += 1
    print(count)
    if count == 5:
        break
else:
    print('程序被break中断过')

//java
int age = 12
char x = 'a'

# python
age = 12

a = 1
b = 'aa'

type(a) # int
type(b) # str

在32位机器上，整数的位数为32，取值范围为-2**31至2**31-1
在64位机器上，整数的位数为64，取值范围为-2**63至2**63-1

跟C语言不同，python没有指定长整型的位宽，即没有限制长整型数值的大小，但实际上由于机器内存有限，我们使用的长整型也不可能无限大。

name = 'hjx'
name2 = "alex"
msg = '''My name is Alex,I am 22 years old '''

msg = "My name is Alex,I'am 22 years old"

msg = '''
一二三四五
上山打老虎
'''

name = 'alex'
age = '22'
print(name+age) # alex22

print(name*3) # alexalexalex

a = 12
b = 5
print( a > b ) # True

name = input('name')
age = input('age')
job = input('job')
city = input('city')


info = '''
----------info of %s
Name:       %s
Age :       %s
Job :       %s
City:       %s
''' % (name,age,job,city)

print(info)

程序报错

因为input方法接收的任何输入都是字符串

你应该这样,将输入的结果转换为数字

age = int(input('age'))

print('hello world')

CattleId
FarmId

cattle_id
farm_id

CATTLE_AGE = 10

name = input("请输入你的名字")
print("hello" , name)
# 也可以这样，效果一样
print("hello" + name)

# 本行是注释
print("hello")

jsonp就是
1请求方创建一个script标签src指向响应方，并传递callback =回调函数名xxx
2响应方根据callback查询参数构造一个 xxx.call(undefined,传递的内容)
3浏览器接到响应，就会执行 xxx.call(undefined,传递的内容)
4请求方得到他想要的数据

ajax
实现原理就是使用XMLHttpRequest对象通过它来发请求
let request = new XMLHttpRequest();
request.open('get','/xxx');
request.send();
request.onreadystatechange = function(){
    if(request.readyState === 4){
        if(request.status >= 200 && request.status <300){
            console.log(request.responseText);
        }else{
            console.log(request.status);
        }
    }
}

promise就是解决 回调地域问题的，比如一些操作的校验 必须逐步成功才能往下走提交
window.ajax = function({url,method,body,headers}){
    return new Promise(function(resolve,reject){
        //ES6解构赋值
        let request = new XMLHttpRequest();
        request.open(method,url);
        for(let key in headers){
            let value = headers[key];
            request.setRequestHeader(key,value);
        }
        request.send(body);
        request.onreadystatechange = function(){
            if(request.readyState === 4){
                if(request.status >= 200 && request.status <300){
                    resolve.call(undefined,request.responseText)
                }else{
                    reject.call(undefined,request.status)
                }
            }
        }
    });
}

async和await用法：简单说来就是 异步代码同步执行
function xxx(x) { 
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

async function f1() {
  var x = await xxx(10);
  console.log(x); // 10
}
f1();

其实我认为js是没有继承的，它是用function模拟的，继承的原理是基于原型链的。

1.我们知道大部分编程语言应该都有Object类型,一般都称为所有类型的基类(也就是类型的顶端)
2.每种类型都有一个共有属性 prototype也就是浏览器里的双下proto 这个属性里放置了一些属性或方法。它被称为原型
3.每个类型都有自己的原型(共有属性)prototype 比如Number有 toFixed
4.此时如果你构造一个类型他就会天生有toString() valueOf()
5.这就是原型链继承，它会逐级向上查找，如果自己本身有这个方法则使用，没有则继续查找，如果顶端Object的prototype上都没有，是属性就undefined调用方法就报错

es6的继承：虽然它有关键字 class让你看起来像java的继承
但是依然是假的，不信你可以查看浏览器里打印 依然是基于prototype的
此时就有一个问题如果我想要一个 共有属性 class怎么办？
如果是prototype 可以很方便的
// ES5
Human.prototype.s = '人类'

// ES6 对不起,不支持,有一种变通的写法
class Human{
    constructor(name){
        this.name = name
    }
    //麻烦不？？？？
    //麻烦不？？？？
    //麻烦不？？？？
    get s(){
        return '人类'
    }
}

父-->子  props
子-->父  子组件emit触发事件xx  父组件 监听xx事件

如果是祖孙三代，孙子给爷爷发消息
就是两个父子关系 emit 非常麻烦所以有了vuex

v-if 是决定html结构里是否有这个元素
v-show是切换元素的display属性

有性能问题
频繁切换用v-show
如果仅初始化一次的用v-if

vue和angular都是双向绑定的
react是单项数据流

angular 从语法书写上可以明显看出MVC思想，它大而全，关键的是官方宣布半年进行一次版本迭代，需要持续跟进学习，适合于大型项目，但是学习成本高

vue 简单快速上手，小而美，渐进式的更新各个功能，对初学者友好，因为作者是中国的，而且据统计 外国用react的多，中国用vue的多。

react facebook的自己造的轮子，单项的数据流，vue也慢慢转向单项数据流，支持jsx语法。可以用class的方式定义组件。通过render渲染，学习路径陡峭

function wrapper(){
    var a = 1
    function inner(){
        a+=1
    }
    return inner
}
这就是闭包

var str = 'trustfor@sina.cn'
var reg = /^\w+@[a-z0-9]+\.[a-z]+$/i;
if(reg.test(str)){
    //合法
}else{
    //你丫写错了
}

<meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=1.0,user-scalable=no">

队列(先进先出，请参考电影票是不是先买票的先走) 映射到数组就是 push() shift()

栈：后进先出，汉诺塔上面的盘子移走才能移动下面的盘子。映射到数组就是 push() pop()

树(二叉树/满二叉树/完全二叉树)

堆(最大堆/最小堆)

如果一个div有position:absolute是相对谁定位？

逐级向上的父元素
如果有position:absolute就相对它
如果有position:relative就相对它
都没有就相对顶级元素 body

1. 一个div实现：背景图定位到左边加  padding-left
2. flex布局:最外层容器
    display:flex;
    justify-content:flex-start; 
    左面图片设置宽高，
    右边flex-grow:1
3. 两个标签都左浮
4. position定位
5. table

res = "aabbcc"
str = "\"\' aabbcc \'\""

在生命周期的destroy里移除事件

由于sass各种报错。我也不想死嗑在这种工具问题上。我用less，基于talkdata的iview就是用的less

答案是 sass通过配置是可以用的  需要装一个ruby的东西

entry 入口
output 输入路径
loads 加载器
plugs 插件

又问 用过什么！看你水平了。 当然是说你用的

可能真不会。我说把变量置空，移除事件。尽量用委托。事件里不要保存其他变量的引用。

还有呢？
又装了，这个一定是可以调的。(你可以回去看看。好吧！继续看你表演)

console.log(a)
var a = 1
答案 undefined 变量提升

console.log(a)
console.log(b)
{
var a = 1
let b = 2
}
答案 
第一行undefined
第二行报错

{
var a = 1
let b = 2
}
console.log(a)
console.log(b)
答案 
第一行 1
第二行报错

function A(A){ console.log(1)}
function A(A,B,C){ console.log(2)}

A(1)
A(1,2,3)
A()
答案 
2 同名函数会发生覆盖。 

你传递多少个参数你不使用有意义？我真不知道啥区别！别逗我行吗？
无论先后调用A函数  都会执行第二个。您居然跟我说执行第一个？厉害

又开始嘲讽啦！ 这个vue react angular变来变去都很简单。无外乎那么点东西。
(从没见过造轮子特别傲的人,但今天看见一个用别人轮子还那么傲的。vue作者都没那么狂。果然全球第一。)

function a(x,y,z){}

a(x,y,z)
a.call(undefined,x,y,z)
a.apply(undefined,[x,y,z])

沉默了一小下，问call、apply区别
区别
call第一参数是this,第二个之后才是你实际传的参数
apply第一参数是this,第二个是你实际传的参数数组

他：嘲讽开始，还有其他方式吗？
我：不清楚。我就想看你说啥！
他：回去自己查查。
我：(我估计你自己都不知道)

各浏览器表现不一致 
google是小姐姐 化了妆出门
ie是女汉子 出门在化妆

我就要加载了css在显示页面呢？

非要实现都一直你就隐藏呗。加载完了在display:block
又开始嘲讽啦 说这有5/6种呢  你自己回去查查。

我按之前的思路回答了，答的不好就不好呗！

又开始了，你回答的很范范。你可以去看看淘宝啊京东啊看他的页面结构抄他们的代码。

事件委托呗。监听document 判断target.tagName是不是button

第一种就是每次都发请求设置个cookie头

第二种
1. 登录的一瞬间后台返回 authList 存到sessionStorage里(加密一下，引个库肯定没问题)
 authList = ["if0001","if0002","if0003"] 对应路由的name属性
2. 路由守卫里判断 to.name 是否在authList里 
3. 分支处理

一、要么后天登录的时候给你生成

二、
1.在router定义的时候  自己定义个属性建议形如[if_authmenu] 公司前缀+权限名称 表示为这个路由是菜单
判断
2.生成路由菜单的时候说明已经登录了 权限数组在你这里 v-for的时候判断

第一次是option方法  意思是询问 支持不支持我下面发送的方法
第二次是实际的get/put/post/delete等请求

其实就是三次循环每次找最大值然后移除
第一次500,000 找到最大的 然后移除元素
第二次499,999 找到第二个最大的 然后移除元素
第三次499,998 找到第三个最大的 然后结束

时间复杂度 3n

str = '((()()(()(()()))((()))))'
起点为 index = 1 的左括号 找到对应的右括号索引

答案是利用堆栈知识
左括号代表进栈 x++
右括号代表出栈 x--

所以 x = 0 时 就是匹配的那个右括号对应的索引

.xx:nth-child(2n){
    线性渐变的代码。。。 我也不会
}

双重循环遍历成二维数组

axios.post(url,param).then(
    ()=>{

    }
).catch(
    ()=>{

    }
)

id      pid   cname
0100    null   北京
0101    0100   朝阳
0102    0100   海淀
0103    0100   昌平
0200    null   天津
0201    0200   和平
0202    0200   红桥
0203    0200   南开
又卡住了我。。。。

又挂了。  iview-admin里有一个那么的组件

内容如下：
print('in demo.py')

a = 'hello'

def read():
    print('haha'+a)

import demo.py

#执行aa.py你会发现打印了 in demo.py 

如果你多次导入demo模块呢？
import demo.py
import demo.py
import demo.py
import demo.py

# 依然只打印一次  in demo.py

import demo # 这句话的时候就是把demo.py的内容加载到内存里，同时demo里所有的内容只能通过demo这个命名空间来调用
demo.read() # 
demo.a

import sys
print(sys.modules.keys()) # 查看导入的模块

import time as t
t.time()

import sys,time,random,os

1. 先引入内置的
2. 扩展的如django
3. 自己实现的

之前是
import time
time.sleep()

你可以这样
from time import sleep
sleep()

from demo import read
# 此时无法访问demo.py里的 a变量 因为你单独导入了read方法
# 但是read方法里访问了 a变量 ，说明引入模块的时候会把a保存在内存里只是本模块访问不到 


# 如果你在引入的地方定义同名read方法,那么导入的read方法就被覆盖
def read():
    pass

import demo from *
# 相当于把里面的东西全部引入进来,可以不带命名空间之间使用
read()
print(a)

__all__ = ['a']
print('in demo2.py')

a = 'hello'

def read():
    print('haha'+a)

import demo2 from *
read() # 报错 

# 因为在模块内部设置了 __all__
__all__是一个列表代表 import demo2 from *的形式导出的内容

因为刚刚只设置了 __all__ = ['a'] 
因此只有 a可用

1.因为demo2.py里有一句 print('in demo2.py') 
2.所以在你导入demo2模块的时候 程序会打印 in demo2.py
3.需求就是 只在demo2.py里打印不在 被导入的文件里 打印这句话

a = 'hello'
def read():
    print('haha'+a)

print(__name__) # __main__

import demo2

# 打印 demo2

a = 'hello'
def read():
    print('haha'+a)

if __name__ == '__main__':
    print('in demo2.py')

在模块xxx内部有一个变量 __name__
当我们直接运行这个模块xxx的时候 __name__ == '__main__'
当我们在其他文件内,引入这个模块xxx的时候,这个模块中的 __name__ =='模块的名字'

import json

dic = {"k1":"v1"}

print(type(dic),dic)
# <class 'dict'> {'k1': 'v1'}

# 序列化
str_d = json.dumps(dic)
print(type(str_d),str_d) 
# <class 'str'> {"k1": "v1"}

# 反序列化
dic_d = json.loads(str_d)
print(type(dic_d),dic_d)
# <class 'dict'> {'k1': 'v1'}

import json

dic = {"k1":"v1"}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f) # 序列化后的字符串写入到文件里
f.close()


f = open('fff',encoding='utf-8')
res = json.load(f)
f.close()
print(res) # {'k1': 'v1'}

import json

dic = {"k1":"中国"}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f) # 序列化后的字符串写入到文件里
f.close()


f = open('fff',encoding='utf-8')
res = json.load(f)
f.close()
print(res) # {'k1': '中国'}

import json

dic = {"k1":"中国"}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False) # 序列化后的字符串写入到文件里
f.close()


f = open('fff',encoding='utf-8')
res = json.load(f)
f.close()
print(res)

# 分次写入
import json
a = [{"k1":1},{"k2":22},{"k3":33}]
f = open('file','w')
for dic in a:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
f.close()

# 分次读取
b = []
f = open('file')
for line in f:
    dic = json.loads(line.strip())
    b.append(dic)
f.close()

import pickle

dic = {"k1":"中国"}
str = pickle.dumps(dic)
print(str) # 一串二进制内容
# b'\x80\x03}q\x00X\x02\x00\x00\x00k1q\x01X\x06\x00\x00\x00\xe4\xb8\xad\xe5\x9b\xbdq\x02s.'
res = pickle.loads(str)
print(res)
# {'k1': '中国'}

import pickle
dic = {"k1":"中国"}
f = open('fff3','wb')
pickle.dump(dic,f) # 序列化后的字符串写入到文件里
f.close()


f = open('fff3','rb')
res = pickle.load(f)
f.close()
print(res)

import pickle
dic = {"k1":"中国"}
dic2 = {"k2":"中国2"}
f = open('fff3','wb')
pickle.dump(dic,f) #
pickle.dump(dic2,f) #
f.close()


f = open('fff3','rb')
res = pickle.load(f)
res2 = pickle.load(f)
f.close()
print(res)
print(res2)

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
                        即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

sys.argv           命令行参数List，第一个元素是程序本身路径(只能在命令行里执行，在ide里报错)
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)