CSS中的quotes属性

Posted on 2019-07-14 | In CSS学习笔记 | Visitors

在CSS中，quotes属性常常被用来指定当作content属性的插入值。

q和blockquote标签在渲染的时候是没有引用符号的，所以当有需要的时候我们必须自己去指定。这里需要注意的是，我们可以把引用符号添加到任何的元素上，而不仅仅去q或者blockquote标签。

JavaScript中的var，let和const

Posted on 2019-06-30 | In JavaScript学习笔记 | Visitors

这篇文章你将会学到在JavaScript (ES6)中创建变量的两种新方式，let和const。同时，我们会看下var，let以及const的差别。

ES2015 (or ES6)中介绍了两种创建变量的方式，let和const。在我们真正深入理解var，let和const的差别之前，有一些知识需要先了解。它们是变量声明和初始化，作用域（特别是函数作用域），以及变量提升。

变量声明 vs 变量初始化

1	var declaration

上面我们创建了一个新的声明。在JavaScript中，变量在创建的时候初始化的值为undefined。也就是说当我们尝试打印declaration的时候，输出会是undefined。

1
2
3

var declaration
console.log(declaration) // undefined

相对于变量声明，变量初始化就是在创建时指定了变量的值。

var declaration
console.log(declaration) // undefined
declaration = 'This is an initialization'

上面的例子，我们给变量declaration指定了一个字符值。下面我们看下作用域。

作用域

作用域定义了你程序内部的变量和函数的可访问性。在JavaScript中，有两种作用域：全局作用域以及函数作用域。

当你在函数中创建了一个以var的变量，那么它将只能在函数内部或者它的内部函数具有可访问性。

function getDate () {
  var date = new Date()
  return date
}
getDate()
console.log(date) // ❌ Reference Error

上面的例子中，当我们试图在函数外部访问函数中创建的变量时，会出现异常。这是因为date的作用域在getDate函数内部，只有函数本身以及内部函数才具有可访问性。

function getDate () {
  var date = new Date()
  function formatDate () {
    return date.toDateString().slice(4) // ✅
  }
  return formatDate()
}
getDate()
console.log(date) // ❌ Reference Error

我们再看一个高级的例子，假如有一价格集合 prices ，我们需要有这样的一个函数方法，其函数的参数就是价格集合以及折扣 discount，此函数返回一个打折后的价格集合。

1	discountPrices([100, 200, 300], .5) // [50, 100, 150]

实现可能是如下的样子：

function discountPrices (prices, discount) {
  var discounted = []
  for (var i = 0; i < prices.length; i++) {
    var discountedPrice = prices[i] * (1 - discount)
    var finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  return discounted
}

看起来很简单的例子，但是我们看一下for循环。在for循环中声明的变量是否在外部能被访问呢？结果是：可以的。

function discountPrices (prices, discount) {
  var discounted = []
  for (var i = 0; i < prices.length; i++) {
    var discountedPrice = prices[i] * (1 - discount)
    var finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

如果JavaScript是你唯一知道的语言，那么你可能对此没有任何的疑问。但是，如果你知晓其他的语言，如Java，那么你可能会有疑问，为什么会出现这样？毕竟，在for循环之后没有任何的原因需要再去访问变量i，discountedPrice以及finalPrice。那到底为啥会导致上述的问题呢？

变量提升

文章开头的时候说过：在JavaScript中，变量在创建的时候初始化的值为undefined。这就是变量提升。JavaScript解释器会在变量的创建阶段分配默认的undefined。

再看一下上一示例，变量提升是如何作用的。

function discountPrices (prices, discount) {
  var discounted = undefined
  var i = undefined
  var discountedPrice = undefined
  var finalPrice = undefined
  discounted = []
  for (var i = 0; i < prices.length; i++) {
    discountedPrice = prices[i] * (1 - discount)
    finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

需要注意的是，在函数方法的开头，所有的变量在声明时都被赋予了初始化值undefined。那也就是为什么尝试在真正声明变量之前去访问的时候，你会得到undefined的原因。

function discountPrices (prices, discount) {
  console.log(discounted) // undefined
  var discounted = []
  for (var i = 0; i < prices.length; i++) {
    var discountedPrice = prices[i] * (1 - discount)
    var finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

现在你知道如何使用var，最后我们来看下这篇文章的主旨，var，let以及const的区别到底在哪？

var VS let VS const

var VS let

首先，我们先来看下var和let的区别。var和let的主要区别是：var是函数作用域级别，而let则是块作用域级别。也就是说，let关键字创建的变量只在块或块中内嵌的块具有可访问性。请注意，这里所说的块，就是用大花括号{}包起来的代码块，例如for循环，if语句等。

我们再来看下价格折扣的示例：

function discountPrices (prices, discount) {
  var discounted = []
  for (var i = 0; i < prices.length; i++) {
    var discountedPrice = prices[i] * (1 - discount)
    var finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

之前我们使用var关键字声明的i, discountedPrice, 以及finalPrice在for循环之后是可以打印出结果的。但是现在，我们把var关键字的变量全部改为let关键字，会出现什么样的结果呢？

function discountPrices (prices, discount) {
  let discounted = []
  for (let i = 0; i < prices.length; i++) {
    let discountedPrice = prices[i] * (1 - discount)
    let finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}
discountPrices([100, 200, 300], .5) // ❌ ReferenceError: i is not defined

从上可以看出，我们得到了一个错误：ReferenceError: i is not defined。这也就是说，用let关键字声明的变量是块作用域，而不是函数作用域。所以当我们尝试访问i (或 discountedPrice 或 finalPrice) 的时候，会得到引用错误的原因。

在之前的例子中，当我们在函数内部，使用var关键字声明的变量前面尝试打印变量时会得到undefined。

function discountPrices (prices, discount) {
  console.log(discounted) // undefined
  var discounted = []
  for (var i = 0; i < prices.length; i++) {
    var discountedPrice = prices[i] * (1 - discount)
    var finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

其实，在变量声明之前会访问变量，我是不能想到任何的这种使用场景。如何这样做的话，它应当抛出一个引用错误，而不是返回undefined。实际上，这也就是关键字let的作用。当你尝试在使用let关键字声明的变量之前去访问它时，你会得到一个引用错误ReferenceError。

function discountPrices (prices, discount) {
  console.log(discounted) // ❌ ReferenceError
  let discounted = []
  for (let i = 0; i < prices.length; i++) {
    let discountedPrice = prices[i] * (1 - discount)
    let finalPrice = Math.round(discountedPrice * 100) / 100
    discounted.push(finalPrice)
  }
  console.log(i) // 3
  console.log(discountedPrice) // 150
  console.log(finalPrice) // 150
  return discounted
}

let VS const

现在你理解了var和let的区别，那const呢？其实，const基本上类似于let。只是，唯一的差别就是一旦你给const关键字声明的变量赋予了值的话，则你不能再重新赋值：

let name = 'Tyler'
const handle = 'tylermcginnis'
name = 'Tyler McGinnis' // ✅
handle = '@tylermcginnis' // ❌ TypeError: Assignment to constant variable.

上面的例子用，用let关键字修饰的变量可以被重新赋值，但是用const关键字修饰的变量却不能。

现在我们最重要的问题还没有解答，那就是你应当使用 var，let还是const？最大众的回答就是，你应当总是使用const，除非你知道变量需要被修改，则需要修改的变量应该使用let关键字。

Python中的绝对和相对导入

Posted on 2018-11-03 | In Python学习笔记 | Visitors

翻译自：Absolute vs Relative Imports in Python

如果你正在工作中的Python项目中有多个源文件存在时，你肯定会碰到要使用 import 导入的语法。

即使是拥有几个项目的高手，有时候也会对使用 import 语句感到困惑。或许你阅读此文的目的就是你想要深入了解下Python的 import 工作原理，特别是绝对导入和相对导入。

在这个系列中，你将会了解两者之间的区别，以及它们各自的有缺点。

Python range()方法使用介绍

Posted on 2018-10-20 | In Python学习笔记 | Visitors

翻译自：Python’s range() Function (Guide)

Python中的内建方法 range 在需要执行特定的多次行为时非常方便。

range()的历史

虽然，在Python 3 和Python 2中使用了同一个 range() 名称，但是它们是完全不一样的。事实上，Python 3中的 range() 方法是Python 2中的 xrange() 的重命名而已。

起先，range() 和 xrange() 都是生成数字供 for 循环迭代使用，但是前者是即时地生成所有的数字集合，而后者则是以懒惰的方式生成数字，也就是说在需要的时候只返回生成一个数字。

当即时地生成大的数字集合时会占用大的内存，所以，在Python 3的版本中使用 xrange() 来替代 range() 一点也不惊奇。你可以通过阅读这个PEP 3100来了解更多的 xrang() 和 range() 背景。

Python装饰器入门

Posted on 2018-09-15 | In Python学习笔记 | Visitors

本文翻译自[有删改]：Primer on Python Decorators

在这篇文章中，我们将介绍什么是装饰器和如何来创建以及使用它。装饰器通过使用高阶函数提供了一种简单的语法。

先来看一下定义，装饰器就是使用另一个方法并且继承这个函数的所有的功能而不要显式的修改这个函数的函数。

听起来比较疑惑不解，但是当你看了几个示例了解了装饰器是如何工作后就不会了。

Python中的操作符重载

Posted on 2018-09-01 | In Python学习笔记 | Visitors

本文翻译自[有删改]：Operator and Function Overloading in Custom Python Classes

如果你已经在Python使用过 str 的 + 和 * 操作符，你肯定注意到它相对于 int 或 float 对象的 + 和 * 操作有不同之处。

>>> # Adds the two numbers
>>> 1 + 2
3
>>> # Concatenates the two strings
>>> 'Real' + 'Python'
'RealPython'
>>> # Gives the product
>>> 3 * 2
6
>>> # Repeats the string
>>> 'Python' * 3
'PythonPythonPython'

使用Python字典中的get方法返回默认值

Posted on 2018-07-30 | In Python学习笔记 | Visitors

假如有下面的数据结构来表示用户的ID对应的用户名：

name_for_userid = {
    382: "Alice",
    950: "Bob",
    590: "Dilbert",
}

现在编写一个 greeting() 函数根据传入的用户ID返回用户名。我们首先想到的实现方式是：

1 2	def greeting(userid): return "Hi %s!" % name_for_userid[userid]

Python中的for工作原理

Posted on 2018-07-12 | In Python学习笔记 | Visitors

这篇文章主要介绍Python中的for循环工作原理。同时，也会介绍可迭代对象，迭代器和迭代协议。

基于索引迭代：失败的例子

在Python中使用像C或者Java的基于索引的循环写法：

colors = ["red", "green", "blue", "purple"]
i = 0
while i < len(colors):
    print(colors[i])
    i += 1

上面的方式仅对列表适用，对集合则会出现错误：

>>> colors = {"red", "green", "blue", "purple"}
>>> i = 0
>>> while i < len(colors):
...     print(colors[i])
...     i += 1
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: 'set' object does not support indexing

Python's Instance, Class and Static Methods

Posted on 2018-07-07 | In Python学习笔记 | Visitors

这篇文章主要介绍Python的实例方法（Instance Methods），类方法（Class Methods）以及静态方法（Static Methods）。掌握和理解三者的用法以及区别，对编写面向对象的程序很有帮助。

三种方法的简介

首先在 MyClass 中分别创建这三个方法：

class MyClass:
    def method(self):
        return 'instance method called', self
    @classmethod
    def classmethod(cls):
        return 'class method called', cls
    @staticmethod
    def staticmethod():
        return 'static method called'

Python 中的枚举类型

Posted on 2018-04-11 | In Python学习笔记 | Visitors

转载自：Python 中的枚举类型

枚举类型可以看作是一种标签或是一系列常量的集合，通常用于表示某些特定的有限集合，例如星期、月份、状态等。Python 的原生类型（Built-in types）里并没有专门的枚举类型，但是我们可以通过很多方法来实现它，例如字典、类等：

WEEKDAY = {
    'MON': 1,
    'TUS': 2,
    'WEN': 3,
    'THU': 4,
    'FRI': 5
}
class Color:
    RED   = 0
    GREEN = 1
    BLUE  = 2

上面两种方法可以看做是简单的枚举类型的实现，如果只在局部范围内用到了这样的枚举变量是没有问题的，但问题在于它们都是可变的（mutable），也就是说可以在其它地方被修改从而影响其正常使用：

1
2
3

WEEKDAY['MON'] = WEEKDAY['FRI']
print(WEEKDAY)
{'FRI': 5, 'TUS': 2, 'MON': 5, 'WEN': 3, 'THU': 4}

通过类定义的枚举甚至可以实例化，变得不伦不类：

c = Color()
print(c.RED)
Color.RED = 2
print(c.RED)

1
2

0
2