本文目录一览：
高一物理
这里格式不太好，问我要吧，我是高中物理老师，很多经典题呵。说一下你的邮箱吧。
匀变速直线运动单元检测
命题人：周平 时间：90分钟 年级组长签名 时间： 月 日
班级： 学生姓名： 家长签名： 得分：
一、单项选择题
1．一物体做匀减速直线运动，初速度为10m/s，加速度大小为1m/s2，则物体在停止运动前ls内的平均速度为（ ）
A．5.5 m/s B．5 m/s C．l m/s D．0.5 m/s
2. 如图所示是物体运动的v-t图象，从t=0开始，对原点的位移最大的时刻是（ ）
A．t1 B．t2
C．t3 D．t4
3．一物体做匀加速直线运动，在第1个t s内位移为x1；第2个t s内位移为x2，则物体在第1个t s末的速度是（ ）
A．（x2-x1）/t B．（x2+x1）/t C．（x2-x1）/2t D．（x2+x1）/2 t
4．一个物体自静止开始做加速度逐渐变大的加速直线运动，经过时间t，末速度为vt，则这段时间内的位移 （ ）
A．x vtt /2 B．x = vtt /2 C．x vtt /2 D．无法确定
5．P、Q、R三点在同一条直线上，一物体从P点静止开始做匀加速直线运动，经过Q 点的速度为v，到R点的速度为3v，则PQ∶QR等于 （ ）
A．l∶8 B．l∶6 C．l∶5 D．1∶3
6．汽车正在以 10m/s的速度在平直的公路上前进，在它的正前方x处有一辆自行车 以4m/s的速度做同方向的运动，汽车立即关闭油门做a = - 6m/s2的匀变速运动，若汽车恰好碰不上自行车，则x的大小为 （ ）
A．9.67m B．3.33m C．3m D．7m
7．一小球沿斜面匀加速滑下，依次经过A、B、C三点。已知AB=6m，BC=10m，小球经过AB和BC两段所用的时间均为2s，则小球经过A、B、C三点时的速度大小分别是（ ）
A．2 m/s，3 m／s，4 m/s B．2 m/s，4 m/s，6 m/s
C．3 m/s，4 m／s，5 m/s D．3 m/s，5 m/s，7 m/s
8.某同学身高1.8 m，在运动会上他参加跳高比赛，起跳后身体横着越过了1.8 m高度的横杆。据此可估算出他起跳时竖直向上的速度大约为（g=10 m/s2） （ ）
A．2 m/s B．4 m/s C．6 m/s D．8 m/s
二、多项选择题
9．在匀加速直线运动中，（ ）
A．速度的增量总是跟时间成正比
B．位移总是随时间增加而增加
C．位移总是跟时间的平方成正比
D．加速度，速度，位移的方向一致。
10.一辆车由甲地出发，沿平直公路开到乙地刚好停止，
其速度图象如图所示，那么0—t和t—3t两段时间
内，下列说法正确的是（ ）
A加速度大小之比为2: 1
B位移大小之比为1: 2
C平均速度大小之比为1: 2
D平均速度大小之比为1:1
11如图是一个初速度为V0沿直线运动物体的速度图象，经过时间t速度为Vt,则在这段时间内物体的平均速度 和加速度a的情况是 （ ）
A. B.
C.a是恒定的 D.a是随时间t变化的
12物体甲的x-t图象和物体乙的v-t图象分别如下图所示，则这两个物体的运动情
况是（ ）
A．甲在整个t=6s时间内有来回运动，它通过的总位移为零
B．甲在整个t=6s时间内运动方向一直不变，它通过的总位移大小为4 m
C．乙在整个t=6s时间内有来回运动，它通过的总位移为零
D．乙在整个t=6s时间内运动方向一直不变，它通过的总位移大小为4 m
单项选择题答案
1 2 3 4 5 6 7 8
多项选择题答案
9 10 11 12
三、填空题
13.从车站开出的火车，做匀加速运动，最初一分钟行540m，那么它在最初10s行驶 m。
14.汽车在水平公路上自A向B作匀减速直线运动停于B点，初速度为3m/s，加速度为0.4m/s2。若汽车在某1s内通过了0.4m的位移，则在这1秒前汽车已运动了 s。
15.一物体做匀变速直线运动，某时刻速度大小为4m/s，经过1s后的速度的大小为10m/s，那么在这1s内，物体的加速度的大小可能为 .
16．一质点t=0时位于坐标原点，右图为该质点做
直线运动的速度一时间图线，由图可知，
（1）在时间t= s时质点距坐标原点最远；
（2）从t=0到t=2s内质点的位移是 ；
通过的路程是 。
17．在“探究小车速度随时间变化的规律”的实验中，打点计时器使用的交流电的频率为50 Hz，记录小车运动的纸带如图所示，在纸带上选择0、1、2、3、4、5的6个计数点，相邻两计数点之间还有四个点未画出，纸带旁并排放着带有最小分度为毫米的刻度尺，零点跟“0”计数点对齐，由图可以读出三个计数点1、3、5跟0点的距离填入下列表格中.
距离 d1 d2 d3
测量值／cm
计算小车通过计数点“2”的瞬时速度为v2 =______ m/s.小车的加速度是a =______ m/s2.
四、计算题
18．一个做匀加速度直线运动的质点，在最初两个连续的4s的时间内发生的位移分别为s1=24m，s2=64m.求质点运动的初速度和加速度。
19．一物体做匀加速直线运动，初速度为0.5 m/s，第7 s内的位移比第5 s内的位移多4 m，求：
（1）物体的加速度
（2）物体在5 s内的位移
20.跳伞运动员做低空跳伞表演，他离开飞机后先做自由落体运动，当距离地面 125 m时打开降落伞，伞张开后运动员就以14.3 m/s2的加速度做匀减速运动，到达地面时速度为5 m/s，问：
（1）运动员离开飞机时距地面的高度为多少?
（2）离开飞机后，经过多少时间才能到达地面?（g=10 m/s2）
21.一些同学乘坐动力组列车外出旅游，当火车在一段平直轨道上匀加速行驶时，一同学提议说：“我们能否用身边的器材测出火车的加速度?”许多同学参与了测量工作，测量过程如下：他们一边看着窗外每隔100 m 的路标，一边用手表记录着时间，他们观测到从第一根路标运动到第二根路标的时间间隔为5 s，从第一根路标运动到第三根路标的时间间隔为9 s，请你根据他们的测量情况，求：
（1）火车的加速度大小；
（2）他们到第三根路标时的速度大小。
22.一列火车以54km/h的速度匀速行驶，为了进站先以0.5m/s2的加速度做匀减速直线运动，在车站又停了2min，接着以0.3m/s2的加速度作匀加速直线运动，直到恢复原来的速度正常行驶，求这列车通过这个车站所延误的时间。
答案
1.D 2.B 3.D 4.A 5.A 6.C 7.B 8.B
9.ABD 10.ABD 11.AD 12.BC
13.15
14.6
15.6m/s或14m/s
16．（1）1（2）0，4m
17.1.20 5.40 12.00 0.21 0.6
18.V0=1m/s a=2.5m/s2
19.a=2 m/s2 x=27.5m
20.h=305m t=9.85s
21.a=1.11 m/s2 v=27.2m/s
22.t=160s
python里面元组是什么意思？
↑↑↑点击上方蓝字，回复资料，10个G的惊喜
作者：陈tooyoung@阿里云Python训练营 博客地址：
Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。
列表的定义
列表的创建
向列表中添加元素
删除列表中的元素
获取列表中的元素
列表的常用操作符
列表的其他方法
元组
创建和访问一个元组
更新和删除一个元组
元组相关的操作符
内置方法
解压元组
列表
简单数据类型
整型
浮点型
布尔型
容器数据类型
列表
元组
字典
集合
字符串
列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为[元素1, 元素2, ..., 元素n]。
关键点是「中括号 []」和「逗号 ,」
中括号 把所有元素绑在一起
逗号 将每个元素一一分开
列表的创建 创建一个普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7]
利用range()创建列表x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2]
利用推导式创建列表x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
创建一个混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]]
创建一个空列表empty = []
print(empty, type(empty)) # []
列表不像元组，列表内容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、删除 (remove,pop) 这些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
严格来说append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj)在编号index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
删除列表中的元素
list.remove(obj)移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del var1[, var2 ……]删除单个或多个对象。
如果知道要删除的元素在列表中的位置，可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0])) # Monday
print(x[-1], type(x[-1])) # ['Thursday', 'Friday']
print(x[-2], type(x[-2])) # Wednesday
切片的通用写法是start : stop : step
"start :"
以step为 1 (默认) 从编号start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
": stop"
以step为 1 (默认) 从列表头部往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
"start : stop"
以step为 1 (默认) 从编号start往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- "start : stop : step"
以具体的step从编号start往编号stop切片。注意最后把step设为 -1，相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
" : "
复制列表中的所有元素（浅拷贝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
浅拷贝与深拷贝list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
列表的常用操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
列表的其它方法
list.count(obj)统计某个元素在列表中出现的次数
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)对原列表进行排序。
key-- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse-- 排序规则，reverse = True降序，reverse = False升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
元组
「元组」定义语法为：(元素1, 元素2, ..., 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开
创建和访问一个元组
Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python')
print(t2, type(t2))
# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)
print(type(x)) #
x = 2, 3, 4, 5
print(type(x)) #
x = []
print(type(x)) #
x = ()
print(type(x)) #
x = (1,)
print(type(x)) #
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
创建二维元组。
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)
更新和删除一个元组week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元组相关的操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
内置方法
元组大小和内容都不可更改，因此只有count和index两种方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count('python')是记录在元组t中该元素出现几次，显然是 1 次
index(10.31)是找到该元素在元组t的索引，显然是 1
解压元组
解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2
EEx_ia代表的防护等级是什么意思？
EEx p\EEx d\EEx de\EEx e\EEx nA\ CEI/IEC 各个代表的意义。\x0d\x0a国内通常所讲的防爆电机，防火电机，隔爆电机、增安电机是否都能用以上字母表示？如何可以用以上字母表示，该如何用行业字母术语表示？ EExp：正压型；\x0d\x0aEEx d：隔爆型\x0d\x0aEEx de：隔爆增安型；\x0d\x0a EEx e：增安型；\x0d\x0aEEx nA：无火花防爆型；\x0d\x0aCEI：IEC：国际电工委员会 \x0d\x0a防爆电机：电机的统称，指各种防爆标准的电机，包括各种防爆类型；\x0d\x0a 防火电机：flameproof motor，电机的统称，没有具体的一种标准，我们一般认为防火电机也可以叫防爆电机； \x0d\x0a隔爆电机：EEx d 增安电机；\x0d\x0aEEx e 隔爆电机(EEx d)和增安电机\x0d\x0a（EEx e）是最常用的2种类型防爆电机，EEx d的应用环境区域比EEx e更高。 \x0d\x0a温度等级 T3、T4、T5、T6意义。\x0d\x0a 电气设备按其最高表面温度分为T1～T6组，使得对应的T1～T6组的电气设备的最高表面温度 不能超过对应的温度组别的允许值。温度组别、设备表面温度和可燃性气体或蒸气的引燃温 度之间的关系如下所示。 电气设备最高表面温度 450 300 200 135 100 85 温度组别 T1 T2 T3 T4 T5 T6 9. \x0d\x0aGroup I、IIB、IIC；其中I和IIB，IIC代表的意义。\x0d\x0aⅠ类设备:用于矿井地下部分的设备和用于这些矿井地面设施部分的设备，能因沼气和/或易燃粉尘而发生危险。 \x0d\x0aII类设备：工厂用电设备，用于能因爆炸环境而发生危险的其他场合的设备。\x0d\x0aⅡ类设备进一步细分为：ⅡA类（丙烷）；ⅡB类（乙烯）；ⅡC类（氢气）；Ⅱ类（所有气体），其中A表示气体环境为丙烷，B表示气体环境为乙烯，C类表示气体环境为氢气。 IIB和IIC是电气设备和气体的防爆级别 IIB代表最小点燃能量为60微焦 IIC代表最小点燃能量为20微焦 \x0d\x0a10. 2G、2D、2GD代表的意义。 2G表示表面气体高防护类别，2D表示表面粉尘高防护类别，2GD表示表面气体和粉尘高防护类别。其中G、D表示爆炸环境的类型：G（气体、蒸气或薄雾）和D（粉尘）
滑冰怎么刹闸
一、直排后煞
就是双脚平行，把有煞车器的那一脚向前推出，脚尖微向上，让煞车器磨到地面就可以了，将煞车器愈用力的压向地面，就可以愈快停下来了，厉害的人还可以金鸡独立喔。 记住重心一定要放低，保持在两脚中间，不可以太前或太后。 ABT与普通煞车其实没什幺不同，只是ABT比较容易学习，只要脚往前一伸就可刹车
二、八字煞
1. 内八字煞
适用于平缓长下坡，由于需长时间煞车，若使用T煞，则脚易酸麻，故于维持等速，避免加速太快时使用，亦可用于速度较慢时煞车。两脚张开，板成内八字，两脚弯曲蹲低，身体微向前顷，抬头两眼直视前方。 由于脚内八，所以会往内滑，此时两脚用力往外撑，就可以慢慢煞车。需要多练习才能将煞车力道均匀地施于两足。
2. 外八字煞
内八字煞是将重心置于后方，外八字煞则是置于前方
3. 后八字煞
\/(行进方向↓)，身体向前倾斜，脚尖不是向内靠而是两脚的脚跟向内才对，大腿外侧的肌肉用力向下压。
三、T字煞(Tstop)
|__--，一只脚在后面拖，|代表自由足，___代表你的溜冰足，---是前进方向。
就是以自由足的轮子，取代煞车器的功用。首先单脚前溜，后脚自由足伸直垂直的放在滑行足后面，类似弓箭步，重心完全置于溜冰足上，抬头挺胸缩小腹，上身保持正直，后脚与前脚的轮子保持垂直轻轻接触地面，此时仍是前溜，但由于后脚与前进方向垂直，轮子与地面摩擦，慢慢会停下来。初学慢慢煞，从开始煞到完全煞住的距离可以长一点，大概五、六公尺，可以煞住之后再慢慢增加后脚力量，增加摩擦力，后脚施力的方向是往下往前。煞车之前，大部分的重心应该是在溜冰足上面，少部份在自由足，自由足的重心放的越多，煞力就越强，也更不容易保持平衡。后脚本来是直的，碰地后变成弯的，两只脚都弯着，所成的平面相互垂直。 煞车的过程整个身体要维持不动，从小腿以上相对于溜冰鞋而言是静止的。在路上溜遇到稍陡的下坡之时，由于稳度与煞车兼顾，所以脚需弯曲，初学者常常会不自觉的变成"蟹步"而在地上划弧，煞到最后转成后溜或转转转」，这大多是因为放太多的重量于自由足或是因为两足的夹角大于九十度，这牵涉到腿力问题，一方面溜冰足要一直维持直行，重心也要大半放在溜冰足，自由足只负责刮地面，不要最后没力就把重心摆到自由足去，这样就会转成后溜。至于会失去重心，要慢慢练，刚开始先把自由足抬起不要着地，然后练习溜冰足弓箭步，就是稍微曲膝，然后再站直，如此重复，等练稳之后，慢慢将自由足轻触地面，去抓那个摩擦的感觉，以此慢慢增加自由足的施力。
四、雪犁煞车(SNOWPLOWSTOP)
___|---，有人称后溜T字煞或powerslide，前溜T字煞时看自己的脚是呈倒T字型，雪犁煞车则是正T。 姿势以左脚煞车为例，站起身，将右足转个90度，左足往左跨一大步再将右脚膝盖弯曲这时重心很自然地是放在右脚上。
前溜时以右足单足作转三后，再将左足放在地上煞。 或是先作摩合克变成后溜之后再将左足抬起，放在右足后作煞车。
亦即前溜变成后溜，后溜时溜冰足弯曲，自由足伸直，类似后溜弓箭步，身体可以是侧的，就是身体的面与溜的方向垂直，然后自由足的脚板与行进方向垂直往地上踩，踩在离溜冰足较远处，此时溜冰者的姿势是后溜，前脚弯，维持往后溜，后脚直，脚板垂直行进方向，用轮子与地面的摩擦来煞车。煞车效果佳，但如果技术不好，可能会转一圈，有旋转与翻滚两种一圈，旋转是后脚没撑住，结果两脚的行进方向不同所造成，翻滚是后脚完全煞住，但速度太快、站的太高，或是后脚力量不够撑住身体力重量，以至于以后脚为支点，往后翻滚一圈。
有人前溜，整个人稍微跳一下，变成侧身而煞车的。 雪犁煞车其制动力较大，速度太快的时候比较不适合。 因为刹车速度太快，脚会承受较大的作用力。 所以可以先用T字煞。
五、旋转煞车
有人称二字煞或单侧煞，像冰上曲棍球一样，双脚并拢，垂直前进方向刷出去。将两只脚并拢，接下来先稍微蹲低，再把身体提起，顺势将身体转个90度注意转的瞬间是很平顺地将溜冰鞋转过来(因为身体重量已经提起)，这种感觉可以先双手握着栏杆作，将重心提起、转身、放下重心的练习。例如，以右足为轴心，身体转身，但是左足以切线方向压内刃推出，这时几乎所有的煞车力道都在左足上。
六、冰球煞车(HOCKEYSTOP)
七、煞车头
休闲直排鞋的煞车头在后方，但有人会把他拆下来。
并排花式鞋的煞车头在鞋子的前方，而其实这个煞车头的主要目的并不是用来煞车的，当然也是可以用来煞车，最主要的原因在于花式溜冰的动作中有一些动作是需要用到煞车头的，如toe-loop，flip都是点煞车头起跳的。
并排竞速鞋：在正式的比赛中并排竞速鞋是"不准"装煞车头的，主要原因不是怕选手用煞车头加速，而是为了选手的安全着想，因为在高速的时候，若有人不小心采到煞车头，很有可能摔的很壮烈。
参考资料：
nvidiagridk2电源安装
nvidiagridk2电源安装？方法如下：方法一：（IBM xCAT 安装时方法）
在GRUB中加入一个命令：
[root@ibm2-svr0pxelinux.cfg]# pwd
/tftpboot/pxelinux.cfg
[root@ibm2-svr0pxelinux.cfg]# more ibm2-255
#installrhels6-x86_64-gpun
DEFAULT xCAT
LABEL xCAT
KERNEL xcat/rhels6/x86_64/gpun/vmlinuz
APPENDinitrd=xcat/rhels6/x86_64/gpun/initrd.img xdriver=vesa nomodeset xdriver=vesanomodeset quiet repo= ksdevice=eth0
IPAPPEND 2
[root@ibm2-svr0pxelinux.cfg]#
批量配置脚本:
sed -i"s/img/img xdriver=vesa nomodeset/g" `grep img -rl /tftpboot/pxelinux.cfg
方法二：
单节点系统已经安装完成不想重新安装方法;
Create /etc/modprobe.d/disable-nouveau.conf:
blacklist nouveau
options nouveau modeset=0
Then reboot.
Install the driver as usual
方案三：
通过系统光盘安装时可以选择不安装Open Source “Nouveau” driver ;
选择第二项 Install system with basic video driver 安装；
