错误处理是一种处理程序运行过程中可能出现错误的机制。

Swift - 错误处理


Python 有三种序列类型：列表、元组、字符串。

- String：`'123'`
- List：`[1, 2, 3]`
- Tuple：`(1, 2, 3)`

所有序列都是有序的，可以通过索引来访问元素，索引从 0 开始。

```python
a = 'Hello'               # String
b = [1, 4, 5]             # List
c = ('GOOG', 100, 490.1)  # Tuple

# Indexed order
a[0]                      # 'H'
b[-1]                     # 5
c[1]                      # 100

# Length of sequence
len(a)                    # 5
len(b)                    # 3
len(c)                    # 3
```

序列可以复制`repeat`

```python
>>> a = 'Hello'
>>> a * 3
'HelloHelloHello'
>>> b = [1, 2, 3]
>>> b * 2
[1, 2, 3, 1, 2, 3]
>>>
```

相同类型的序列可以相加

```python
>>> a = (1, 2, 3)
>>> b = (4, 5)
>>> a + b
(1, 2, 3, 4, 5)
>>>
>>> c = [1, 5]
>>> a + c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
```

## 切割

切割的意思是把序列分成多个部分，`s[start:end]`，比如：

```python
a = [0,1,2,3,4,5,6,7,8]

a[2:5]    # [2,3,4]
a[-5:]    # [4,5,6,7,8]
a[:3]     # [0,1,2]
```

> `start` 和 `end` 可以是负数，但必须为整数，表示从右往左的索引。
> 如果 `start` 比 `end` 大，则返回空序列。
> 如果 `start` 和 `end` 相等，则返回一个元素。
> 如果 `start` 比 `end` 都为空，则返回整个序列。

## 切割后重新定义

列表的切片可以重新定义，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
a[2:4] = [10,11,12] # [0,1,10,11,12,5,6,7,8]
```

列表的切片也可以被删除，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
del a[2:4] # [0,1,5,6,7,8]
```

## 序列升序执行（reduce）

```python
s = [1, 2, 3, 4, 5]
sum(s) # 15
min(s) # 1
max(s) # 5
t = ['hello', 'world']
max(t) # 'world'
```

## 序列的迭代

```python
s = [1, 4, 9, 16]
for i in s:
  print(i)

1
4
9
16
```

### break、continue 语句

```python
for name in namelist:
    if name == 'Jake':
        break
    ...
    ...
statements

for line in lines:
    if line == '\n':    # Skip blank lines
        continue
    # More statements
    ...
```

### for and tuples

可以使用多个迭代变量进行迭代。

```python
points = [
  (1, 4),(10, 40),(23, 14),(5, 6),(7, 8)
]
for x, y in points:
    # Loops with x = 1, y = 4
    #            x = 10, y = 40
    #            x = 23, y = 14
    #            ...
```

## zip

`zip` 函数可以将多个序列合并为一个序列，比如：

```python
columns = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]
pairs = zip(columns, values)
# pairs = [('name', 'ACME'), ('shares', 100), ('price', 490.1)]
```


Python 有三种序列类型：列表、元组、字符串。

Sequences - 序列


**export**用于设置或显示环境变量。

## 使用方法

```bash
export TEST="test"
# TEST代表变量名，test代表变量值

export -n TEST
#-n参数代表一出TEST变量
```

## 参数：

- -f 　代表[变量名称]中为函数名称。
- -n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
- -p 　列出所有的 shell 赋予程序的环境变量。


export用于设置或显示环境变量。

Linux命令export


在 CSS 中，z-index 和层叠上下文（Stacking Context）是用于控制元素的层叠顺序和叠放顺序的两个关键概念。它们通常用于解决重叠元素的显示问题。

1. z-index：z-index 是一个 CSS 属性，用于控制元素在层叠顺序中的位置。它的取值可以是数字或 auto。数字越大，元素越靠近视口，也就是显示在前面。如果两个元素的 z-index 相同，它们的顺序将由它们在 HTML 中出现的顺序决定。z-index 只对已经定位（position）的元素有效。

2. 层叠上下文（Stacking Context）：层叠上下文是一种 HTML 元素的层叠环境。每个层叠上下文都有自己的层叠顺序，元素在其中的位置由层叠顺序和 z-index 值共同决定。当一个元素有层叠上下文时，它的子元素的层叠顺序和 z-index 将相对于其父元素进行计算。

层叠上下文有多种创建方式，包括：

- 根元素（HTML）和 window 对象是层叠上下文的根元素。
- position 值为 absolute 或 relative 且 z-index 值不为 auto 的元素。
- position 值为 fixed 或 sticky 的元素。
- 具有 opacity 值小于 1 的元素。
- 具有 transform、filter、perspective、clip-path、mask、mix-blend-mode 等属性的元素。
- 具有 isolation 属性设置为 isolate 的元素。
- 具有 will-change 属性的元素（例如 will-change: transform）。

当元素发生重叠时，可以通过改变层叠顺序和 z-index 值来控制它们的显示顺序。但是，应该注意避免滥用 z-index 和层叠上下文，因为它们可能会导致布局问题和难以维护的代码。建议尽可能使用更简单和可预测的布局方法，如 Flexbox 和 Grid，来避免这些问题。

以下是一个示例，说明如何使用 z-index 和层叠上下文来控制元素的层叠顺序：

HTML 代码：

```html
<div class="parent">
  <div class="child child1"></div>
  <div class="child child2"></div>
</div>
```

CSS 代码：

```css
.parent {
  position: relative;
}

.child {
  position: absolute;
  width: 100px;
  height: 100px;
}

.child1 {
  background-color: red;
  z-index: 1;
}

.child2 {
  background-color: blue;
  z-index: 2;
}
```

在这个例子中，父元素 .parent 有定位属性 position: relative;，使它成为一个层叠上下文。子元素 .child 都有绝对定位属性 position: absolute;，并设置了相同的宽度和高度。.child1 的 z-index 值为 1，.child2 的 z-index 值为 2，因此 .child2 会显示在 .child1 的前面，即蓝色盒子会显示在红色盒子上面。

通过使用 z-index 和层叠上下文，可以方便地控制元素的层叠顺序，以达到所需的布局效果。


css - Z-index & Stacking Context


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

![Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/OrJAie.jpg)

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

![Page Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Bk8qhy.jpg)

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

在 Swift 中，我们可以使用扩展来完成以下任务：

- 添加计算属性、存储属性、方法、下标和构造器等功能
- 定义协议的默认实现
- 整合协议的实现
- 分解类型实现

使用扩展可以使代码更加模块化，易于维护和扩展。以下是一个示例：

```swift
// 当前版本的 Swift 中，所有基本类型都是结构体

// 添加一个名为 squared 的计算属性来计算整数的平方，返回一个新的整数
extension Int {
    var squared: Int {
        return self * self
    }
    // 添加一个 mutating 方法来计算自身平方
    mutating func square() {
        self = self.squared
    }
}
// 对于给定的整数，可以使用点语法来访问 squared 属性和 square() 方法
let x = 5
print(x.squared) // 输出 "25"

var y = 7
y.square()
print(y) // 输出 "49"
```

在上面的示例中，我们向 Swift 中的 Int 类型添加了一个扩展。扩展中包含一个计算属性 squared 和一个 mutating 方法 square，用于计算整数的平方。可以通过使用点语法访问 squared 和调用 square() 方法在 Int 类型的所有实例中使用这些功能。

需要注意的是，扩展不能添加存储属性或添加必须由结构体或类定义的初始化器。此外，扩展也不能覆盖现有的方法或属性。除此之外，使用扩展的过程与定义原始类型的方法相同，因此扩展的函数和方法可以在同一文件中定义，并像原始代码一样被编译和执行。

总之，使用扩展的代码可以增强 Swift 中类型的灵活性和可读性，从而使代码更加模块化和高效，减少命名冲突和重复代码的出现。


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

Swift - 扩展


在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型。Swift 中支持的高级运算符包括：

- 位运算符：按位操作二进制数据，包括按位取反、按位与、按位或、按位异或等。
- 移位运算符：用来对二进制数据进行左移或右移操作。
- 溢出运算符：对于数值类型，当其存储的值超出其所能容纳的范围时，就会发生溢出。Swift 中提供了溢出加法运算符（&+）、溢出减法运算符（&-）和溢出乘法运算符（&\*）来处理这种情况。
- 比较运算符：用于比较两个值的大小关系，包括等于、不等于、大于、小于、大于等于和小于等于等。
- 逻辑运算符：用于组合和操作布尔值，包括逻辑非、逻辑与和逻辑或。
- 匹配模式运算符：用于判断一个值是否匹配某个模式，包括元组模式、可选模式、类型转换模式等。

Swift 还提供了一些自定义高级运算符的功能。开发者可以通过运算符函数来定义新的运算符，并对其进行重载。这使得 Swift 具有更高的可读性和可维护性，并能够实现更简洁和灵活的代码实现。


在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型