最近在试着做一个问答系统，有个需求是记录用户的各种活动（activities）作为站点动态，传统的实现方式需要写大量重复的代码，而且可能会给后期版本迭代增加难度，为了改善这种情况，可以使用简单的观察者模式。
下面是一个简单的观察者模式示例，它实现了用户在发布问题时，通知EventLog，记录下用户的操作：

<?php

class QuestionActions{
    
    /**
     * 内部属性用来存放观察者对象
     */
    protected $_observer = null;

    /**
     * 传入观察者对象
     */
    public function notifyObserver($observer){
        $this->_observer = $observer;
    }

    /**
     * 调用观察者记录事件
     */
    public function putQuestion($user,$question){
        $this->_observer->writeLog($user,$question);
    }


}

/**
 * 定义时间记录类
 */
class EventsLog{

    public function writeLog($user,$question){
        echo "- <small><b>".$user."</b> 新增了问题：<b>“ ".$question."”</b></small><br/>";
    } 

}

$action = new QuestionActions();
$action->notifyObserver(new EventsLog());
$action->putQuestion('猪八戒','猴哥，咱们什么时候开饭啊？');

$action = new QuestionActions();
$action->notifyObserver(new EventsLog());
$action->putQuestion('沙和尚','师傅去哪了？');

$action = new QuestionActions();
$action->notifyObserver(new EventsLog());
$action->putQuestion('孙悟空','妖怪哪里逃？');

效果图：

Flask 中的上下文变量：

以上都是指向真实对象的代理，若需要获得原始对象，可以调用_get_current_object()方法。

以下代码保存了name这个值，并且可以供其他视图函数使用：

from flask import g

@app.before_request
def get_name():
    g.name = request.args.get('name')

@app.route('/hello')
def hello():
    return 'Hello, ' + g.name

1. HTTP请求

查询字符串
URL https://undefined.im/hello?name=Lily 中的?name=Lily即为查询字符串(query string)

一个完整的请求：

浏览器发送请求（request）,报文（message）在浏览器和服务器之间传输，服务器根据请求返回的数据为响应报文（response message）。

常见的HTTP方法：

Flask中的请求对象request

获取请求URL中的查询字符串参数：

request.args.get('name','默认值')
print request.args 
# {'name':value}

flask routes 命令
使用flask routes 命令可以查看所有路由

视图函数同时监听GET请求和POST请求：

@app.route('/api',methods=['GET','POST'])
def api():
    ...

转换器的使用：
转换器通过使用<转换器:变量名>(<int:age>)把变量转换成为整数。

@app.route('/api/<int:age>')
def api():
    ...

any 转换器:
any转换器可以设置可选值。

@app.route('/api/<any(blog,page,media):data>')
def api(data):
    ...

# 另外一种方式
dataType = ['blog','page','media']
@app.route('/api/<any(%s):data>'%str(data)[1:-1])
def api(data):
    ...

请求钩子
Flask 默认实现的5种请求钩子

注册一个钩子的基本示例

@app.before_request
def doSomething():
    pass
# 这个函数将在每个请求处理之前触发

2.HTTP 响应

视图函数可以返回最多由三个元素组成的元组：响应主体、状态码、首部字段。其中首部字段可以为字典，或是两元素元组组成的列表。

手工指定响应状态码

@app.route('/hello')
def hello():
    ...
    return 'hello'
    # 默认状态码为200

@app.route('/hello')
def hello():
    ...
    return 'hello',201
    # 指定状态码为201

重定向的方法

@app.route('/hello')
def hello():
    ...
    return redirect('https://notekit.cn/',302)
    # 重定向

@app.route('/hi')
def hi():
    ...
    return redirect(url_for('hello'))
    # 重定向到某个视图函数

搭建时花费了半天去解决过程中遇到的各种奇怪的坑，应当要记录下来。

virtualbox版本：6.0.14
vagrant 版本：2.2.6
box: ubuntu/xenial64

新建Box并导入

本地开发目录下（我的是X:development/env/xenial/):

vagrant init ubuntu/xenial64

会在目录下生成Vagrantfile，我做了如下配置：

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/xenial64"
  config.vm.network "private_network", ip: "192.168.33.20"
  config.vm.synced_folder "./www", "/vagrant"
  config.vm.provider "virtualbox" do |vb|
    vb.memory = "1024"
  end
end

Python配置

Linux 下大都自带了python,使用起来非常的方便，这个box自带了python3.5.2，因此直接在它的基础上安装pip和pipenv即可。

~$ python
Python 3.5.2 (default, Oct  8 2019, 13:06:37)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>  

安装pip

sudo apt-get install python-pip

安装pipenv

pip install pipenv

创建虚拟Flask开发环境

在项目目录中执行：

pipenv install

搭建Flask开发环境

安装flask

pipenv shell
pipenv install flask

测试项目

在项目目录中创建app.py文件并保存。

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '<h1>:)</h1> Hello! Flask.'

保存后执行：

pipenv run flask run --port=8080 --host=0.0.0.0 
# 如果已经在虚拟环境下（即已经使用pipenv shell激活了虚拟环境
# 执行 flask run --port=8080 --host=0.0.0.0 即可

如果没有出现报错信息，console会提示如下：

• Environment: production
  WARNING: This is a development server. Do not use it in a production deployment.

Use a production WSGI server instead.

• Debug mode: off
• Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)

你服务器的访问地址为0.0.0.0：8080，打开主机的浏览器输入http://192.168.33.20:8080 即可看到下图：

现在，你就可以专心学习Flask了。

/app.py

""" flask 模板渲染，参数传递 """

# 引入Flask类,引入模板渲染方法
from flask import Flask, render_template

# 传入
app = Flask(__name__)

# 定义入口方法
@app.route('/')
def index():
    # return 'Hello!! Flask :)'
    """ 渲染index.html 并传入参数 title """
    return render_template('index.html',title = 'Flask')

# 运行
if __name__ == '__main__':
    app.run(debug=True, port=80, host='0.0.0.0')

# 开启debug, 设置端口号,设置主机名

/templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }}</title>
</head>
<body>
     A page rendered by Flask with param 'title' = {{title}}
</body>
</html>

falsk是一款python下的轻量级Web框架，包含众多非常实用的插件，能够帮助你使用少量的代码构建功能完备的Web应用。

因为我是在Ubuntu 下做的开发，以下所有操作均在该系统下验证通过。
安装pip：

sudo apt install python-pip

安装flask框架：

pip install flask

一个简单的hello world

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello!! Flask :)'

if __name__ == '__main__':
    app.run()

运行后报错：

ModuleNotFoundError: No module named 'flask'

排查：
因为同时安装了python2和python3，在安装pip时执行的sudo apt install python-pip是在python2下安装的pip，应当执行sudo apt install python3-pip。
同样的，在安装flask扩展时应当执行pip3 install flask

我非常肯定以后不会用到python2，所以干脆就把它卸载了：

# 卸载python2.7
sudo apt-get remove python2.7

# 卸载python2.7及其依赖
sudo apt-get remove --auto-remove python2.7

#消除python2.7
sudo apt-get purge python2.7 or sudo apt-get purge --auto-remove python2.7

修复以上错误后运行代码，控制台给出了web访问地址：

类的继承

子类可以及成父类中的变量和方法

在继承前必须要导入包含父类的模块
from model import class

父类模块：phone.py

class Phone():

    def __init__(self, number, local):
        self.number = number
        self.local = local

    def calling(self):
        print('calling '+ str(self.number) +' from ' + self.local)

    def message(self):
        print('message to ' + self.number )

子类模块：mobile.py

# 引入父类模块
from phone import Phone

class Mobile(Phone): # 继承的父类名写在括号内

    def __init__(self, number, local, url):
        self.url = url
        # 调用父类的构造方法
        super(Mobile,self).__init__(number, local) 
        
    
    def browser(self):
        print('browser to ' + self.url)
        super(Mobile,self).message() #调用父类方法

Mobile('152','636','baidu').calling() #调用继承的方法
Mobile('152','636','baidu').browser()
 

成员的可见性

为了提高封装性和安全性,需要根据实际情况对类的成员的可见性进行约束

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.score = 0
      

    def marking(self):
    
        print(self.name + '的' + self.course + '成绩为' + str(self.score))

s = Test(name='那谁')
s.score = 20 # score可以被外部调用并更改
s.marking() 
 

定义私有变量和方法

为了提高安全性,变量score需要设置为私有,禁止外部调用,设置私有变量和方法的可见性方法如下:
在名称前使用__即可声明一个私有变量或者方法。

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.__score = 0 #设置为私有
      

    def __marking(self):
        print(self.name + '的' + self.course + '成绩为' + str(self.__score))

    def showScore(self):
        print(self.__score)

s = Test(name='那谁')
print(s.__score)  #无法访问
s.showScore() 

可访问性

python通过修改变量名称实现属性和方法的私有性：

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.__score = 0
      

    def __marking(self):
        print(self.name + '的' + self.course + '成绩为' + str(self.__score))

    def showScore(self):
        print(self.__score)

s = Test(name='那谁')
s.__score = -1  # 新增了一个名为__score的变量，和s.score 不同
print(s.__dict__) 
# {'name': '那谁', 'course': '英语', '_Test__score': 0, '__score': -1} 
print(s._Test__score) # 魔术方法，强制访问私有变量 score

基本概念

类：类是现实世界或者思维世界中的实体在计算机中的反应，它将数据以及对数据的操作封装在一起。
数据成员：用来表征对象特性的属性
成员方法：用来体现对象行为并且封装在类中的函数
类变量：类的变量,抽象层级
实例变量：对象的特征，现实层级
类和对象的关系：类是对某一类象的抽象化，通过类可以产生多个对象

类的声明

类名首字母应该大写，且遵循驼峰法C
定义一个类

class CivilEngineer():
    name = ''
    project = ''

    def __init__(self,name,project):
        self.name = name
        self.project = project


    def eat(self):
        print(self.name + '负责了' + self.project )

实例化

按照不同的属性通过实例化生成不同的对象。

person = Person()
person.showInfo()

构造函数：

通过构造函数可以根据参数生成不同的对象，构造函数在类被实例化时会被自动调用，返回值只能为None

    def __init__(self,name,project):
        self.name = name
        self.project = project

方法的定义

self和php中的$this以及JS中的this关键字作用相同，用来引入内部属性/数据成员或者方法。

    def showInfo(self):
        print(self.name + '今年' + str(self.age) + '岁' )

实例方法

def eat(self):
    print(self.name + '吃东西')

在实例方法的内部访问类变量

可以借助__class__访问类变量：

class Student():
    
    sum = 0 # 类变量
    
    def total(self):
        self.__class__.sum += 1 #操作类变量
        print(self.__class__.sum)


print(Student.sum) #获取类变量
Student().total() # 实例方法操作类变量

类方法

类方法主要用来操作类变量 声明方法如下

在定义方法前增加装饰器 @classmethod,参数列表中传入cls(可更改)，类方法用来操作类变量

class Person:
    @classmethod
    def plus_sum(cls):
        pass

类方法对类变量的操作

class Person:
    sum = 0

    @classmethod
    def total(cls):
        print(cls.sum)

Person.total() # 类方法被类调用
Person().total() # 类方法被实例调用

从上面的代码中可以看出，类方法可以更加方便的引用并操作类变量，而不像实例方法那样需要借助__class

！！！ 类方法可以被类和实例调用，但不建议使用实例对象调用类方法

静态方法

静态方法通过使用@staticmethod装饰器来声明

class Person:
    sum = 0

    @classmethod
    def total(cls):
        print(cls.sum)

    @staticmethod
    def add():
        print(Person.sum) #实例方法访问类变量
        print('static method')

Person.total() # 类调用类方法
Person.add()  # 类调用静态方法
Person().add() # 实例调用静态方法

python中不常使用静态方法，静态方法可以访问实例变量和类变量

函数基础知识

函数的作用：将常用功能封装起来，具有明确的功能，能够隐藏细节，减少代码复杂度，具有复用性，如下代码展示了一个函数：

a = 1.12356
print(round(a,2))
# round(number, ndigits=None)) // 四舍五入
# 控制台中输入 help(func) 可以快速查看内置函数信息
# 查看python 之禅 import this

函数的定义

语法：

def funcname(parameter_list):
    pass

parameter_list 可以没有；函数中使用return 返回值；如果没有return 则默认返回 None；函数执行到return后，即停止执行。

示例：

def add(x,y):
    result = x + y
    return result

 
def print(code):  
    print(code) 
#自定义函数不能和内置函数同名,自己调用自己 报错 Traceback

如何设置函数允许最大的递归层数

在文件头部声明：

import sys
sys.setrecursionlimit(10000)

形参和实参

def add(x,y):
    result = x + y
    return result
# x,y 形参

a = add(1,2)

# 1，2 实参

返回结果

同时返回多个结果

def damage(skill1,skill2):
     return skill1,skill2

同时接收多个参数

sk1_damages,sk2_damages = damage(3,6) # 序列解包方式 接收结果 
print(sk1_damages)

序列解包相关知识

a,b,c = 1,2,3
""" 
等同于
a = 1
b = 2
c = 3
"""
d = 1,2,3
# 等同于 
d = (1,2,3)
a,b,c = d
#另外一个例子
a=b=c=1
""" 
a = 1
b = 1
c = 1
"""

函数的参数

必须参数

函数参数列表中定义的参数必须传递，传递的参数参与到函数运算,必须参数在调用时必须考虑传入顺序。

def add(x,y)
    return x + y 
#在调用add函数时必须传入x,y,且按序
add(2,1)
# 关键字参数,调用时可忽略顺序
add(x=2,y=1)

默认参数

下面定义了一个不含默认参数的函数：

def print_student_info(name, gender, age, college):
    print('我叫' + name)
    print('我今年' + str(age) + '岁')
    print('我时' + gender + '生')
    print('我在' + college + '上学')
    print('-------------------------')

print_student_info('李小萌','女',17,'市三中')

下面定义了一个含有默认参数的函数
默认参数的定义:即给定了默认值的参数，定义和调用时默认参数需要放在参数列表最后

def print_student(name, gender='男', age=18, college='红星小学'):
    print('我叫' + name)
    print('我今年' + str(age) + '岁') 
    print('我时' + gender + '生')
    print('我在' + college + '上学')
    print('-------------------------')

print_student('李亮','女',12)

# 使用关键字传参
print_student('果果', age = 19)

调用时默认参数需要放在参数列表最后

print_student('丁丁',gender='女',17,college='大三鹿中学')
#  SyntaxError: positional argument follows keyword argument

包的概念

包可以看作是包含了很多模块的文件夹，声明包的方法是在目录中创建
__init__.py文件

模块

每个py文件都可以看做是一个模块，模块中可以包含类，方法（函数），且模块和模块之间可以相互引入。

命名空间

python中的命名空间表示为包名+.+模块名：

包content下的article模块：content.article

包的引入

# import as 用法
import content.article as artice 
#导入模块，引用模块中的变量date
import content.article
print(content.article.date)

# from module import a,def 用法 
# 导入变量title
from content.article import title
# 导入getText方法
from content.article import getText

!!! 当一个包或者包中的模块被引入时，__init__.py模块中的类，方法，变量将会被自动引用，这一特性同样可以用来解决批量引入时的问题。

统配符引入

from package.module import *
指定某模块下可以使用*号导出的元素，需要在模块中做如下声明：
__all__ = ['a','b'] // 只有a,b能通过*的方式引入，a,b可以时变量，也可以是模块

表达式

C语言中关于表达式的定义：表达式(Expression)是运算符(operator)和操作数(operand)所构成的序列。

1+1
a = [1,2,3]
a > b
1 + 2 * 3 # 有顺序
c = int('1') + 2 # 可调用函数

以上全部都是表达式。

优先级

a = 1
b = 2
c = 3
a + b * c # 7
a or b and c # 1  先计算 b and c, 返回3，再计算 a or 3,返回1

Python 优先级排序（查资料）

同优先级运算从左到右计算，否则按照优先级从高到低运算，如果需要刻意改变优先级，可使用()包含。
没有赋值运算符 = ，左结合，存在赋值运算符，右结合。

优先级：算数运算符 > 比较运算符 > 逻辑运算符。
not > and > or。

not 1 or 2 + 2 == 2 # 先计算2+2，然后计算4==4，再计算 not 1,得到结果False or False 返回False 

条件控制

python中的条件控制可以通过使用 if else，if elif else来实现，语法：

# if else 语法
if condition:
    pass
else:
    code

# if elif else 语法
if condition:
    code1
elif condition2:
    code2
else
    code3

!!! python中并没有switch语法，不过我们可以借助if elif 来实现同样的功能。
相关文档：https://docs.python.org/3/faq/design.html

循环控制

python中的循环控制可以使用while和for来实现，while循环尝试用在递归操作中，而for循环则常常用来遍历序列，集合，字典等。

while循环语法

CONDITION = True
while CONDITION:
    pass
# 以上是一个无限循环/死循环
count = 0
while count <= 11:
    count += 1
    print(count,end="|")
# 输出 0|1|2|3|4|5|6|7|8|9|10|

for 循环语法
下面的代码分别实现了循环输出一个列表和嵌套列表。

#列表循环
a = ['a','b','c','d']
for x in a:
    print(x)

# 列表和元组嵌套的场景
l = [['a','b','c','d'],(1,2,3)] 
for b in l:
    for c in b:
        print(c,end=' ')

# for else 用法
l = [['a','b','c','d'],(1,2,3)] 
for b in l:
    for c in b:
        print(c,end=' ')
else:
    print('遍历完成')

跳出语句 break continue

break 和 continue 仅能跳出当前循环，使用时应当注意。

# break

l =  ['a','b','c','d'] 
# 遇到 'c' 跳出
for c in l:
    if c == 'c':
        break
    print(c)
#  输出 ['a','b'] 

l =  ['a','b','c','d'] 
# continue 跳过c 输出
for c in l:
    if c == 'c':
        continue
    print(c,end='|')
#  输出  ['a','b','d'] 

可以借助range方法和for实现重复执行10次
range函数的用法：
range(start,end,step)

for x in range(0,10,2):
    print(x,end="|")
print('\r')
#  输出 0|2|4|6|8|

输出等差数列

for x in range(20,0,-2):
    print(x,end="|")
print('\r')
#  输出 18|16|14|12|10|...

打印指定间隔元素

l = [1,2,3,4,5,6,7,8,9,10]
for x in range(0,10,2):
    print(l[x],end="|")
print('\r')
# 输出 1|3|5|7|9|
 
# 改进

l = [1,2,3,4,5,6,7,8,9,10]
for x in range(0,len(l),2):
    print(l[x],end="|")
print('\r')
# 输出 1|3|5|7|9|

列表的切片可以通过如下方式实现：

l = [1,2,3,4,5,6,7,8,9,10]
s = l[0:len(l):2]
print(s)
# 输出 [1, 3, 5, 7, 9]

变量赋值操作（赋值符号 = ）

# 未使用变量
[1,2,3,4]*3+[1,2,3]+[1,2,3,4]
# [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 4]
# 变量
a = [1,2,3,4] # 赋值
b = [1,2,3]  
a*3+b+a # 运算

Python变量名对大小写敏感，给变量起名一定要有意义,增强可读性，例如 skill,goodsId...
变量名可以使用数字，字母，下划线组成，首字母不能是数字。

_config ='config info"
user_info = 'user'

也不能用系统保留字作为变量名.
python 中的变量无需申明变量类型

float a = 10.0 
a = 10.0

注意以下现象：

a = 1
b = a
a = 3
print(b)
# 1 b没有随着a改变

a = [1,2,3]
b = a
a[0] = 6
print(b)
# [6,2,3] b 随着a变化

值类型和引用类型

值类型不可变，引用类型可变
int str tuple是值类型 list set dict是引用类型

a = "hello"
id(a) = 6522010 # 内容地址
a = a　＋ "world" 
id(a) = 6522966 # 内存地址 
print(a) # hello world

列表修改

b  = [1,2,3] # 定义列表
b.append(4)
print(b) # [1,2,3,4] 可动态改变

元组不可追加，不可修改

(1,2,3) # 元组
a[2] = 1 # 报错 ！！！

运算符

1.算数

！！！ Python 中没有自增++ 和自减 --运算符

2.赋值

3.比较

以下代码需要重点理解：

'abc' < 'abd' # ASII码逐个比较 a < a? b < b ? c < d? 序列特性
[1,2,3] < [1,2,4] # True
(1,2,3) > (1,2,4) # False
(1,2,3) < (2,1,3) # True  得到结果即返回
# 集合，字典同样是适用

4.逻辑

int float
0 为 False , 非0均为True
str
'' 为False, '0'为True
list
[] 为 False

5.成员运算符

成员运算符支持所有序列，包括字符串，元组，列表，集合，字典

a = 'key'
a in {'key':1} # True  成员运算符在字典中仅适用于key 查询
a in {'1':'key'} # False 
'a' in 'action'  # True

5.身份运算符

a = 1
b = 1.0
a == b # True 关系运算符对值比较
a is b /# False 身份运算,比较内存地址
{2,1,3} == {1,2,3} # 集合 True 无序列表元素顺序不影响值
(1,2,3) == (2,1,3) # 元组 False 元组属于有序，会

关系运算符对值比较，身份运算比较内存地址；
变量类型判断

a = 1
isinstance(a,(int,float,str))

对象的三个特征： id、值、类型

5.位运算符

按位与理解
把数字转成2进制后每一位进行比较，如果相同则返回1，不同则返回0

 # 　2: 0b10
 # 　3: 0b11
2 & 3
# 0b10
# 0b11
# 0b10 
# output:2　  0b10
2 | 3
# 0b10
# 0b11
# 0b11 
# output: 3    0b11

nubmber 数字类型（整数(int)，浮点数/小数(float)

>>> type(1)
<class 'int'>
>>>type(2/2)
<class 'float'>
>>>type(2//2) 
<class 'int'>

2进制，8进制，16进制

• 十进制：10
• 二进制: 0b10 (2)
• 八进制：0O10 (8)
• 十六进制： 0x1F(16)

进制转换：

• 转换成二进制

     bin(10)

• 转换成八进制

     oct(10)

• 转换成十六进制

     hex(10)
  

bool 布尔类型：表示真和假的状态

True # 真 （非0非空）
False #  假 （0或none）
# Python中的True和False首字母必须大写

complex 复数

    36j # 表示复数

str 字符串

单引号，双引号，三引号表示字符串

'python'
"python"

三引号用来换行

'''
hello
hello
'''

"""
hello
hello """

转义字符 \
用来表示无法看见的字符，或者与语言本身冲突的字符

\n # 换行
\t # tab
\r # 回车

换行符 \

"hello\
world"

输出路径的方法

print(r'C:\windows\system32\bin')
# r用来申明原始字符串,大小写不敏感
print('C:\\windows\\system32\\bin')

字符串操作：

字符串运算

"hello"+"world" # 输出 hello world
"hello" * 3  # 输出 hello hello hello
"hello"[0] # 输入h 正序
"hello"[-1] # 输出 o 倒序
"hello world"[0:5] # 切片 输出 hello  
"hello world"[0:-1] # 切片 输出 hello worl
"hello python java #c javascript php"[6:] # 切片 输出 python java #c javascript php
"hello python java #c javascript php"[-3:] # 切片 输出 php

组/序列

表示组的方式有很多种：列表
列表list,元素可加入多种类型，可嵌套：

[1,2,3,4,5,6,'呵呵',True,['a','c']]

访问列表元素：

['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面']
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][0] # 烤包子
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][0:2] # ['烤包子','大盘鸡'] 切片操作
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][-1:] # ['过油肉拌面']

列表追加：

['1']+['b'] # ['1','b']

元组tuple,可参考列表
当元组中只有唯一一个元素时，元组将转换成该元素的类型

(1) # int
("string") # str

申明单个元素的元组

(1,) # tuple
("string",) # tuple

空元组

() # tuple

* 字符串，列表，元组均可看作是序列 *

延申：

逻辑运算

3 in [1,2,4,5] # False
3 not in [1,2,4,5] # True

常用计算

len('python') # 6 
max([1,3,7]) # 7
min([1,3,7]) # 1
max('python') # y 按照ASII码值排序
min('python') # h 字符串用空格会输出空格
ord('w') # 119

集合 set

区别于序列，集合时无序的一组元素组成的对象,集合会自动剔除重复的元素

集合的表示：

{1,2,3,4}
{1,2,3,4}[0] # 报错！！！
{1,1,3,4,6,6} # {1,3,4,6}

集合的操作：

len{1,2,3} # 3 获取长度
3 in {1,2,3} # True 判断集合中是否存在某元素
{1,2,3,4,5} - {3,4} # {1,2,5} 求集合的差集
{1,2,3,4,5} & {3,4} # {3,4} 求集合的交集
{1,2,3,4,5} | {3,4,7} # {1,2,3,4,5,7} 求集合的并集
set() //定义空集合

字典 dict

由很多键值对组成的集合, 字典中的键不能重复，键值必须时不可变的类型，字典可以嵌套

{key1:vaule1,key2:value2}
{'title':'内容标题','tag':{'mind':'心理学','development':'编程开发'},'content':'这是内容'}
joh = {'name':'Joh','age':29}
joh['name] # Joh

需求及使用场景

想要实现侧边栏中的某个元素滚动到顶端后固定，滚动到初始位置后取消固定的效果。

代码实现

需要用到jquery,具体实现思路见如下代码。

<script src="https://code.jquery.com/jquery-1.10.2.min.js"></script>
<script type="application/javascript">

    $(function () {
        // 选择器，选择需要设置的元素
        var elm = $('#tag-widget'); 

        // 获取元素到浏览器窗体顶部的偏移量
        var startPos = $(elm).offset().top; 
        // 增加鼠标滚动触发的方法
        $.event.add(window, "scroll", function () {
            // 获取元素当前到浏览器窗口顶部的偏移量
            var p = $(window).scrollTop();
            // 判断如果当前偏移量>初始偏移量
            if ((p) > startPos) {  //to Top
               // 设置position属性为fixed
                $(elm).css('position', 'fixed');
                $(elm).css('top', '0px');
                $(elm).css('width', $('#secondary').width()); 
                $(elm).css('background', '#fff');   
       
     
            } else { //复原
                $(elm).css('position', '');
         

            }

        });
    });
</script>

2.7 注释

注释的好处很多，比如方便理解、查找或方便项目组里的其他开发人员了解你的代码，而且也方便以后你对自己的代码进行修改。

// 定义函数 showInfo
var a = function showInfo(){
    document.write('Hello,OrAndNot!');
}
/* project： Orandnot
*  author: 或且非
*  data: 2019-12-06
*/

上面的代码中，使用 // 进行了单行注释，/* 和 */ 包围的部分可以标记多行注释，这和PHP中很像。