前言:
该系列来至https://www.w3cschool.cn/linux/
1.linux 启动过程

①读入 /boot 目录下的内核文件
②运行init(配置文件 /etc/inittab)
③运行级别(启动守护进程，它们在Windows叫做"服务"（service），在Linux就叫做"守护进程"（daemon）)
④系统初始化

在init的配置文件中有这么一行： si::sysinit:/etc/rc.d/rc.sysinit，它调用执行了/etc/rc.d/rc.sysinit，而rc.sysinit是一个bash shell的脚本，它主要是完成一些系统初始化的工作，rc.sysinit是每一个运行级别都要首先运行的重要脚本。它主要完成的工作有：激活交换分区，检查磁盘，加载硬件模块以及其它一些需要优先执行任务

2.目录结构
以下目录使用频率较高
/bin：
bin是Binary的缩写, 这个目录存放着最经常使用的命令。

/boot：
这里存放的是启动Linux时使用的一些核心文件，包括一些连接文件以及镜像文件。

/dev ：
dev是Device(设备)的缩写, 该目录下存放的是Linux的外部设备，在Linux中访问设备的方式和访问文件的方式是相同的。

/etc：
这个目录用来存放所有的系统管理所需要的配置文件和子目录。

/home：
用户的主目录，在Linux中，每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。

/root：
该目录为系统管理员，也称作超级权限者的用户主目录。

/lib：
这个目录里存放着系统最基本的动态连接共享库，其作用类似于Windows里的DLL文件。几乎所有的应用程序都需要用到这些共享库。

/media linux系统会自动识别一些设备，例如U盘、光驱等等，当识别后，linux会把识别的设备挂载到这个目录下。

/mnt：
系统提供该目录是为了让用户临时挂载别的文件系统的，我们可以将光驱挂载在/mnt/上，然后进入该目录就可以查看光驱里的内容了。

/usr：
这是一个非常重要的目录，用户的很多应用程序和文件都放在这个目录下，类似与windows下的program files目录。

/usr/bin：
系统用户使用的应用程序。

/usr/sbin：
超级用户使用的比较高级的管理程序和系统守护程序。

/usr/src：内核源代码默认的放置目录。

/var：
这个目录中存放着在不断扩充着的东西，我们习惯将那些经常被修改的目录放在这个目录下。包括各种日志文件。

以下目录使用频率较少

/sbin：
s就是Super User的意思，这里存放的是系统管理员使用的系统管理程序。

/selinux：
这个目录是Redhat/CentOS所特有的目录，Selinux是一个安全机制，类似于windows的防火墙，但是这套机制比较复杂，这个目录就是存放selinux相关的文件的。

/srv：
该目录存放一些服务启动之后需要提取的数据。

/sys：
这是linux2.6内核的一个很大的变化。该目录下安装了2.6内核中新出现的一个文件系统 sysfs 。

sysfs文件系统集成了下面3种文件系统的信息：针对进程信息的proc文件系统、针对设备的devfs文件系统以及针对伪终端的devpts文件系统。
该文件系统是内核设备树的一个直观反映。

当一个内核对象被创建的时候，对应的文件和目录也在内核对象子系统中被创建。

/tmp：
这个目录是用来存放一些临时文件的。

/opt：
这是给主机额外安装软件所摆放的目录。比如你安装一个ORACLE数据库则就可以放到这个目录下。默认是空的。

/proc：
这个目录是一个虚拟的目录，它是系统内存的映射，我们可以通过直接访问这个目录来获取系统信息。
这个目录的内容不在硬盘上而是在内存里，我们也可以直接修改里面的某些文件，比如可以通过下面的命令来屏蔽主机的ping命令，使别人无法ping你的机器：

/lost+found：
这个目录一般情况下是空的，当系统非法关机后，这里就存放了一些文件。

echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all

1,定义

 def 函数名（参数列表）:
    函数体

2.传值
传递的是可变类型，值将被改变
传递的是不可变类型，值被复制了一份传入函数，原有值不变

def change(a):
    a += 1
    return a


b = 10
change(b)
print(b)  # 输出10

def change2(list):
    list.append(33)
    list.append(44)


list = [11, 22]
change2(list)
print(list)  # [11, 22, 33, 44]

3.参数

关键字参数 ，允许函数调用使用关键字参数来确定传入的参数值

def printinfo(name, age):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=50, name="runoob")
'''
名字:  runoob
年龄:  50
'''

不定长参数

#加了1个星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
# 可写函数说明
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vartuple)

# 调用printinfo 函数
printinfo(70, 60, 50)
'''
70
(60, 50)
'''

#加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vardict)
# 调用printinfo 函数
printinfo(1, a=2, b=3)
'''
输出: 
1
{'a': 2, 'b': 3}
'''

#参数中星号 * 可以单独出现，调用的时候必须传入关键字
def f(a,b,*,c):
    return a+b+c
print(f(1,2,c=10))

# global,nonlocal关键字

a, b, c = 0, 0, 0  # 这是一个全局变量


global 和 nonlocal关键字
def sum():
    # 返回2个参数的和."
    global b  # 声明变量
    a = 1
    b = 1
    c = 1

    def kk():
        nonlocal c  # 声明变量 外部变量
        c = 2

    kk()
    print(c)  # 2


sum()
print(a)  # 0
print(b)  # 1

1.迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

import sys;
list = [2, 3, 4, 'kkk']
it=iter(list);
for item in it:
    print(item)
# 或者

it=iter(list);
while True:
    try:
        print(next(it))
    except StopIteration:  #next完成的时候,会触发StopIteration异常
        sys.exit()

2.把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()

class MyNumber:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if (self.a <=2):
            x = self.a
            self.a += 1
            return x
        else:
            return StopIteration


my = MyNumber()
my_it = iter(my)
print(next(my_it))
print(next(my_it))
print(next(my_it))

'''
结果:
1
2
<class 'StopIteration'>
'''

3.生成器
使用了 yield 的函数被称为生成器（generator）
跟普通函数不同的是，生成器是一个返回迭代器的函数
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。

import sys


def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a  # 返回了a值，暂停,并保留了 a, b, counter,第二次从这里执行，有点像步进机
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成
print(f)  # 并不是数组，而是一个 generator [ˈdʒenəreɪtə(r)]对象

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

'''
<generator object fibonacci at 0x00FE4DF0>
0 test 2 
'''

if

# if
# 1 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
# 2 在Python中没有switch – case语句。
max = int(input('输入一个正数:'))   #input() 等待用户输入
a = 0
while (a < max):
    if a % 3 == 1:
        print(str(a) + '余数1')
    elif (a % 3 == 2):
        print(str(a) + '余数2')
    else:
        print(str(a) + '余数0')
    a = a + 1
else:
    print('结束了')

#for

list = [9, 1, 3, 4]
for item in list:
    print(item)

for i in range(2, 10, 2):  # range(10) range(2,10)  range(2,10,2)   range(start,end,step)
    print(i)

list(range(10))  # 创建一个列表

//当异步代码执行成功时，我们才会调用resolve(...), 当异步代码失败时就会调用reject(...)
//在本例中，我们使用setTimeout(...)来模拟异步代码，
let myFirstPromise = new Promise(function (resolve, reject) {
    setTimeout(function () {
        Math.random() > 0.5 ? resolve("成功!") : reject("失败!");
    }, 500);

});

//success的值是上面调用resolve(...)方法传入的值.
myFirstPromise.then(function (success) {
    console.log("success! " + success);
}, function (error) {
    console.log("error! " + error);
});