sys
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
sys
print
(sys.argv)
#輸出
$ python test.py helo world
[
'test.py'
,
'helo'
,
'world'
]
#把執行腳本時傳遞的參數獲取到了
|
os
|
1
2
3
4
5
6
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
os
os.system(
"df -h"
)
#調用系統命令
|
徹底結合一下
|
1
2
3
|
import
os,sys
os.system(''.join(sys.argv[
1
:]))
#把用戶的輸入的參數看成一條命令交給os.system來執行
|
本身寫個模塊
python tab補全模塊
import sys import readline import rlcompleter if sys.platform == 'darwin' and sys.version_info[0] == 2: readline.parse_and_bind("bind ^I rl_complete") else: readline.parse_and_bind("tab: complete") # linux and python3 on mac for mac
寫完保存後就可使用了
|
1
2
3
4
5
|
localhost:$ python
Python
2.7
.
10
(default,
Oct
23
2015
,
18
:
05
:
06
)
[GCC
4.2
.
1
Compatible Apple LLVM
7.0
.
0
(clang
-
700.0
.
59.5
)] on darwin
Type
"help"
,
"copyright"
,
"credits"
or
"license"
for
more information.
>>>
import
tab
|
你會發現，上面本身寫的tab.py模塊只能在當前目錄下導入，若是想在系統的何何一個地方都使用怎麼辦呢？ 此時你就要把這個tab.py放到python全局環境變量目錄裏啦，基本通常都放在一個叫 Python/2.7/site-packages 目錄下，這個目錄在不一樣的OS裏放的位置不同，用 print(sys.path) 能夠查看python環境變量列表。
9、.pyc是個什麼鬼？
1. Python是一門解釋型語言？
我初學Python時，聽到的關於Python的第一句話就是，Python是一門解釋性語言，我就這樣一直相信下去，直到發現了*.pyc文件的存在。若是是解釋型語言，那麼生成的*.pyc文件是什麼呢？c應該是compiled的縮寫纔對啊！
爲了防止其餘學習Python的人也被這句話誤解，那麼咱們就在文中來澄清下這個問題，而且把一些基礎概念給理清。
2. 解釋型語言和編譯型語言
計算機是不可以識別高級語言的，因此當咱們運行一個高級語言程序的時候，就須要一個「翻譯機」來從事把高級語言轉變成計算機能讀懂的機器語言的過程。這個過程分紅兩類，第一種是編譯，第二種是解釋。
編譯型語言在程序執行以前，先會經過編譯器對程序執行一個編譯的過程，把程序轉變成機器語言。運行時就不須要翻譯，而直接執行就能夠了。最典型的例子就是C語言。
解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，經過解釋器對程序逐行做出解釋，而後直接運行，最典型的例子是Ruby。
經過以上的例子，咱們能夠來總結一下解釋型語言和編譯型語言的優缺點，由於編譯型語言在程序運行以前就已經對程序作出了「翻譯」，因此在運行時就少掉了「翻譯」的過程，因此效率比較高。可是咱們也不能一律而論，一些解釋型語言也能夠經過解釋器的優化來在對程序作出翻譯時對整個程序作出優化，從而在效率上超過編譯型語言。
此外，隨着Java等基於虛擬機的語言的興起，咱們又不能把語言純粹地分紅解釋型和編譯型這兩種。
用Java來舉例，Java首先是經過編譯器編譯成字節碼文件，而後在運行時經過解釋器給解釋成機器文件。因此咱們說Java是一種先編譯後解釋的語言。
3. Python究竟是什麼
其實Python和Java/C#同樣，也是一門基於虛擬機的語言，咱們先來從表面上簡單地瞭解一下Python程序的運行過程吧。
當咱們在命令行中輸入python hello.py時，實際上是激活了Python的「解釋器」，告訴「解釋器」：你要開始工做了。但是在「解釋」以前，其實執行的第一項工做和Java同樣，是編譯。
熟悉Java的同窗能夠想一下咱們在命令行中如何執行一個Java的程序：
javac hello.java
java hello
只是咱們在用Eclipse之類的IDE時，將這兩部給融合成了一部而已。其實Python也同樣，當咱們執行python hello.py時，他也同樣執行了這麼一個過程，因此咱們應該這樣來描述Python，Python是一門先編譯後解釋的語言。
4. 簡述Python的運行過程
在說這個問題以前，咱們先來講兩個概念，PyCodeObject和pyc文件。
咱們在硬盤上看到的pyc天然沒必要多說，而其實PyCodeObject則是Python編譯器真正編譯成的結果。咱們先簡單知道就能夠了，繼續向下看。
當python程序運行時，編譯的結果則是保存在位於內存中的PyCodeObject中，當Python程序運行結束時，Python解釋器則將PyCodeObject寫回到pyc文件中。
當python程序第二次運行時，首先程序會在硬盤中尋找pyc文件，若是找到，則直接載入，不然就重複上面的過程。
因此咱們應該這樣來定位PyCodeObject和pyc文件，咱們說pyc文件實際上是PyCodeObject的一種持久化保存方式。
10、數據類型初識
2 是一個整數的例子。
長整數 不過是大一些的整數。
3.23和52.3E-4是浮點數的例子。E標記表示10的冪。在這裏，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是複數的例子。
int（整型）
在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807
跟C語言不一樣，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上因爲機器內存有限，咱們使用的長整數數值不可能無限大。
注意，自從Python2.2起，若是整數發生溢出，Python會自動將整數數據轉換爲長整數，因此現在在長整數數據後面不加字母L也不會致使嚴重後果了。
float（浮點型）
浮點數用來處理實數，即帶有小數的數字。相似於C語言中的double類型，佔8個字節（64位），其中52位表示底，11位表示指數，剩下的一位表示符號。
complex（複數）
複數由實數部分和虛數部分組成，通常形式爲x＋yj，其中的x是複數的實數部分，y是複數的虛數部分，這裏的x和y都是實數。
"hello world"
|
1
2
3
4
|
name
=
"alex"
print
"i am %s "
%
name
#輸出: i am alex
|
PS: 字符串是 %s;整數 %d;浮點數%f
- 移除空白
- 分割
- 長度
- 索引
- 切片
|
1
2
3
|
name_list
=
[
'alex'
,
'seven'
,
'eric'
]
或
name_list ＝
list
([
'alex'
,
'seven'
,
'eric'
])
|
基本操做：
- 索引
- 切片
- 追加
- 刪除
- 長度
- 切片
- 循環
- 包含
|
1
2
3
|
ages
=
(
11
,
22
,
33
,
44
,
55
)
或
ages
=
tuple
((
11
,
22
,
33
,
44
,
55
))
|
|
1
2
3
|
person
=
{
"name"
:
"mr.wu"
,
'age'
:
18
}
或
person
=
dict
({
"name"
:
"mr.wu"
,
'age'
:
18
})
|
經常使用操做：
- 索引
- 新增
- 刪除
- 鍵、值、鍵值對
- 循環
- 長度
11、數據運算
比較運算：
賦值運算：
邏輯運算：
成員運算：
身份運算：
位運算：
運算符優先級：
更多內容：猛擊這裏
12、流程控制
if...else 和 if....elif...elif..........else
需求1、用戶身份認證
|
1
2
3
4
5
6
7
8
9
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import
getpass
name
=
raw_input
(
"請輸入用戶名："
)
pwd
=
raw_input
(
"請輸入密碼："
)
if
name
=
=
"tianshuai"
and
pwd
=
=
"123"
:
print
"登陸成功"
else
:
print
"登陸失敗"
|
測試：
|
1
2
3
4
5
6
7
8
9
|
root@localhost#:
python guess.py
請輸入用戶名：Jason
請輸入密碼：
登陸成功
root@localhost#:python guess
.py
請輸入用戶名:Jason
請輸入密碼：
登陸失敗
root@localhost#:
|
需求1、猜數字遊戲
有3次機會，若是3次中沒有猜中給予提示，3次都沒有猜中，鼓勵！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import
random
#隨機模塊
rand_num
=
random.randrange(
10
)
for
i
in
range
(
3
):
guess_num
=
int
(
raw_input
(
"請猜想數字："
))
if
guess_num
=
=
rand_num:
print
"太棒了你猜對了"
break
elif
guess_num > rand_num:
print
"你猜想的有點大了，請嘗試小點的數字"
else
:
print
"你猜想的有點小了，請嘗試大點的數字"
else
:
print
"不要灰心，此次只是運氣很差，請下次嘗試"
print
"這個真正的數字是：%"
%
rand_num
|
輸出結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
root@localhost
# python guess1.py
請猜想數字：
8
你猜想的有點大了，請嘗試小點的數字
請猜想數字：
7
你猜想的有點大了，請嘗試小點的數字
請猜想數字：
6
你猜想的有點大了，請嘗試小點的數字
不要灰心，此次只是運氣很差
r
oot@localhsot
# python guess1.py
請猜想數字：
5
太棒了你猜對了
這個真正的數字是：
5
|
十3、for and while循環
for loop
最簡單的循環10次
|
1
2
3
4
5
6
|
#_*_coding:utf-8_*_
__author__
=
'JasonWang'
for
i
in
range
(
10
):
print
(
"loop:"
, i )
|
輸出：
|
1
2
3
4
5
6
7
8
9
10
|
loop:
0
loop:
1
loop:
2
loop:
3
loop:
4
loop:
5
loop:
6
loop:
7
loop:
8
loop:
9
|
需求一：仍是上面的程序，可是遇到小於5的循環次數就不走了，直接跳入下一次循環
|
1
2
3
4
|
for
i
in
range
(
10
):
if
i<
5
:
continue
#不往下走了,直接進入下一次循環
print
(
"loop:"
, i )
|
需求二：仍是上面的程序，可是遇到大於5的循環次數就不走了，直接退出
|
1
2
3
4
|
for
i
in
range
(
10
):
if
i>
5
:
break
#不往下走了,直接跳出整個循環
print
(
"loop:"
, i )
|
while loop
有一種循環叫死循環，一經觸發，就運行個天荒地老、海枯石爛。
無限循環代碼
|
1
2
3
4
5
|
count
=
0
while
True
:
print
(
"looping..."
,count)
count
+
=
1
|
其實除了時間，沒有什麼是永恆的，死loop仍是少寫爲好
上面的代碼循環100次就退出吧
while 循環
他的原理是：當條件爲真的時候運行，當條件爲假的時候中止！
沒有一個規定次數，不設置條件永遠循環下去。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import
time
count
=
0
while
True
:
count
+
=
1
print
"loop"
,count
time.sleep(
3
)
#這個循環3秒鐘自+1 ，後無線循環只要這個條件爲」真「，就無限循環下去
那看下下面的例子
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import
time
cout
=
0
while
cout <
3
:
cout
+
=
1
print
"runnig"
,cout
time.sleep(
3
)
#這個循環每3秒循環一次，當條件cout < 3的時候爲真（本身設置的條件），當cout 不小於3的時候爲假(false)中止。
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
import
random
rand_num
=
random.randrange(
10
)
try_cout
=
0
while
try_cout <
3
:
guess_num
=
int
(
input
(
"請輸入猜想的數字："
))
if
guess_num >
10
:
print
"輸入的數字超出範圍了"
continue
if
guess_num
=
=
rand_num:
print
"哇！太棒了你猜對了"
break
elif
guess_num < rand_num:
print
"你猜的數字有點小了，請嘗試大點的數字"
else
:
print
"你猜的數字有點大了，請嘗試小點的數字"
try_cout
+
=
1
else
:
print
"不要灰心你，此次只是運氣很差，請下次嘗試"
print
"這個真正的數字是：%d"
%
rand_num
#當執行到guess_num> 10 若是你輸入的是大於10的數字那麼將會執行continue,就會跳出檔次循環，沒有執行try_cout +=1 因此沒有計數！
|
注：continue 是跳出當前循環，break是跳出整個循環！
有個需求，我想返回個人上層怎麼作，用標識位！以下面的例子：
|
1
2
3
4
5
6
7
8
9
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
while
True
:
print
"我是第一層"
while
True
:
print
"我是第二層"
while
True
:
print
"我是第三層"
|
這就是個死循環，當執行到第三個循環的時候就無限循環，這裏有人回想，用break行不行，不行以下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
while
True
:
print
"我是第一層"
break
while
True
:
print
"我是第二層"
break
while
True
:
print
"我是第三層"
break
|
這個的輸出結果：
|
1
2
|
root@localhost#
python jason.py
我是第一層
|
就只執行了第一個循環就跳出，不咱們想要的效果，那就用到「標誌位」了，工做中也有不少地方用到他：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
count
=
0
while
True
:
print
"我是第一層"
jump_1_flag
=
False
while
True
:
print
"我是第二層"
jump_2_flag
=
False
while
True
:
count
+
=
1
print
"我是第三層"
if
count >
3
:
jump_2_flag
=
True
break
if
jump_2_flag:
print
"第三層跳到我這裏來了，我也要跳到第一層"
jump_1_flag
=
True
break
if
jump_1_flag:
print
"第二層和第三層跳到第一層了，我也要跳"
break
|