本文目錄一覽：
高一物理
這里格式不太好，問我要吧，我是高中物理老師，很多經典題呵。說一下你的郵箱吧。
勻變速直線運動單元檢測
命題人：周平 時間：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 安裝；
