目錄

0.背景

1.基礎

2.運算符與表達式

3.控制流

4. 函數

5.模塊

6.數據結構

7. 面向對象

8.文件

9.異常

10.with語句

11.標準庫

?

0.背景

如果你熟悉java 或其他面向對象語言，快速看下面這些代碼快速入門python

?

1.基礎

            
              print("hello world")

# 這是一行注釋


#變量
age = 20
#字符串
name = 'bobe'
#字符串格式化
print("name is {0} , age is {1}".format(name,age))   #Python 從 0 開始計數，這意味著索引中的第一位是 0，第二位是 1，以此類推。
print("name is {} , age is {}".format(name,age))   # 不寫序號也行，format 方法所做的事情便是將每個參數值替換至格式所在的位置
#聯立字符串
print("name is " + name + ", age is " + str(age))

#對浮點數保留小數點后3位
print("{0:.3f}".format(1.0 / 3))

#使用符號填充文本
print("{0:_^10}".format("hello")) # 使用了下劃線填充文本，文本居中
#基于關鍵詞輸出
print("{name} wrote {book}".format(name = "aaa",book = "bbb"))  # format 的時候將 name  和 book  格式化了

#關于print 的自動換行，print 總是會以一個不可見的“新一行”字符（\n ）結尾，因此重復調用 print 將會在相互獨立的一行中分別打印。為防止打印過程中出現這一換行符，你可以通過 end 指定其應以空白結尾：
print("a",end="")
print("b",end="")
print("c")  # 這樣打印出來的結果就不換行了

# 轉義
print('what\'s')
print('你好\\ 哈哈')

#原始字符串
#如果你需要指定一些未經過特殊處理的字符串，比如轉義序列，那么你需要在字符串前增加r 或 R 來指定一個 原始（ Raw） 字符串
print(r"sssaa d\ad asadsa\dsadas'dsa'ssdsa#")



#變量
i = 1
print("i=" + str(i))  #str(1)   將 i  轉換成字符串
i = i + 2
print("i=" + str(i))

s = '''dsadasdd""sdadsad"'sdsdsd'''  #  ''' 三引號里面的字符串將原樣輸出
print(s)



print("我是一物理行代碼")#物理行
print("這是一物理行");print("這是另一物理行")  # 這是一邏輯行
#Python 鼓勵每一行使用一句獨立語句從而使得代碼更加可讀。

#顯式行連接
s = 'This is a string. \
This continues the string.'
print(s)  #如果你有一行非常長的代碼，你可以通過使用反斜杠將其拆分成多個物理行。這被稱作顯式行連接




            
          

?

2.運算符與表達式

            
              print("運算符")


a = 3
b = 5
c = 1
d = True
e = False


print("加："+str(a + b))
print("減："+str(a - b))
print("乘：" + str(a * b))
print("除："+str(a / b))
print("乘方："+str(a ** b))#意為 a的b次方
print("整除："+str(a // c))
print("取模："+str(b % a))#返回除法運算后的余數
print("左移：" + str(a << c ))#左移， 每個數字在內存中以二進制數表示，即 0 和1
print("右移：" + str(a >> c))#右移
print("按位與 ："+ str(a & c))#
print("按位或 ："+ str(a | c))#
print("按位異或 ："+ str(a ^ c))
print("按位取反："+ str(~a))

print("小于："+ str(a < b))
print("大于："+ str(a > b))
print("大于等于："+ str(a >= b))
print("小于等于："+ str(a <= b))
print("是否等于："+ str(a == b))
print("不等于："+ str(a != b))
print("not非："+ str(not d))
print("and和："+ str(d and e))
print("or或："+ str(d or e))




print("表達式")
i = 5
print("i = " + str(i))
i = i + 5
i += 3
print("i = " + str(i))



            
          

?

3.控制流

            
              print('控制流')

print("if")
num = 16
#輸入數字
#inputNum = int(input("請輸入任意數字:"))
inputNum = 5
print("你輸入了：" + str(inputNum))
if num == inputNum:   # 這里需要一個冒號
    print("num == inputNum")
elif num < inputNum:
    print('num < imputNum')
else:
    print('num > inputNum')

print("比較結束")

#Python 中不存在 switch 語句



#while循環
#while 語句同樣可以擁有 else 子句作為可選選項

a= 10
b = True
while b:
    a = a -1
    print("a = :" + str(a))
    if a <= 0:
        b = False
else:
    print(str(b))
print("循環結束")



#for循環
for c in range(1,5):
    print("c:" + str(c))
else:
    print("for 循環結束")

#下面是多行注釋的寫法
'''   
range 將會返回一個數字序列，從第一個數字
開始，至第二個數字結束。舉個例子， range(1,5) 將輸出序列 [1, 2, 3, 4] 。在默認情況
下， range 將會以 1 逐步遞增。如果我們向 range 提供第三個數字，則這個數字將成為逐
步遞增的加數。同樣舉個例子來說明， range(1,5,2) 將會輸出 [1, 3] 。要記住這一序列擴
展直到第二個數字，也就是說，它不會包括第二個數字在內
'''


#break 語句 ，用于終止循環體
d = 1
while d < 10:
    print("d:" + str(d))
    d = d + 1
    if d > 5:
        break
print("循環結束了d:" + str(d))


#continue 語句， 用于跳過當次循環，開始下次循環
e = 2
while e < 5:

    e+=1
    if e == 3 :
        continue
    print("e= " + str(e))
print("循環結束了：" + str(e))
            
          

?

4. 函數

            
              print("函數")

"""
函數可以通過關鍵字 def 來定義。這一關鍵字后跟一個函數的標識符名稱，再跟一對圓括
號，其中可以包括一些變量的名稱，再以冒號結尾，結束這一行。隨后而來的語句塊是函數
的一部分。
"""


def sayHello():
    # 這里屬于函數體內容
    print("sayHello函數被調用了")


# 函數結束


# 調用3次函數
sayHello()
sayHello()
sayHello()

print("帶參數的函數")


def comple(a, b):
    if a > b:
        print("a > b")
    elif a == b:
        print("a == b")
    else:
        print("a < b")


# 函數要定義在調用前面， 否則會報錯
comple(3, 5)

print("局部變量")

x = 50


def fun1(a):
    print("函數內 x is:" + str(a))
    x = 3;
    print("changed x is : " + str(x))


fun1(x)
print("函數外：" + str(x))

print("global 語句")
y = 30


def fun2():
    global y
    print("y is:" + str(y))
    y = 15
    print("changed y :" + str(y))


fun2()
print(" out y :" + str(y))

"""
global 語句用以聲明 x 是一個全局變量——因此，當我們在函數中為 x 進行賦值時，這
一改動將影響到我們在主代碼塊中使用的 x 的值。
可以在同一句 global 語句中指定不止一個的全局變量，例如 global x, y, z
"""

print("默認參數值")


def fun3(a, b=5):
    print(str(a * b))


fun3(2)  # 調用函數，參數不給值時，會使用定義函數時的默認值
fun3(2, 3)

"""
只有那些位于參數列表末尾的參數才能被賦予默認參數值，意即在函數的參數列表中擁
有默認參數值的參數不能位于沒有默認參數值的參數之前。
這是因為值是按參數所處的位置依次分配的。舉例來說， def func(a, b=5) 是有效的，
但 def func(a=5, b) 是無效的
"""

print("關鍵字參數")
"""
如果你有一些具有許多參數的函數，而你又希望只對其中的一些進行指定，那么你可以通過
命名它們來給這些參數賦值——這就是關鍵字參數（ Keyword Arguments） ——我們使用命
名（ 關鍵字） 而非位置（ 一直以來我們所使用的方式） 來指定函數中的參數。
這樣做有兩大優點——其一，我們不再需要考慮參數的順序，函數的使用將更加容易。其
二，我們可以只對那些我們希望賦予的參數以賦值，只要其它的參數都具有默認參數值。
"""


def fun4(a, b=3, c=5):
    print("a = ", a, " b:=", b, '  c:=', c)


fun4(1, 2, 3)
fun4(1, 3)
fun4(1, c=10)
fun4(a=1, b=1, c=1)

"""
print("可變參數")
def fun5(a=5, *num, **list):
    print('a', a)

    for z in num:
        print("z", z)

    for c, d in list:
        print(c, d)


fun5(3)
fun5(10, 1, 2, 4, Jack=1123, John=2231, Inge=1560)
"""



print("return 語句")


# return 語句用于從函數中返回，也就是中斷函數。我們也可以選擇在中斷函數時從函數中返回一個值。
def testReturn(x, y):
    if x > y:
        return x
    elif x == y:
        return "相等"
    else:
        return None

print(testReturn(3,5))
print(testReturn(3,3))
print(testReturn(5,3))

"""
要注意到如果 return 語句沒有搭配任何一個值則代表著 返回 None 。 None 在 Python 中一
個特殊的類型，代表著虛無。舉個例子， 它用于指示一個變量沒有值，如果有值則它的值便
是 None（ 虛無） 。
每一個函數都在其末尾隱含了一句 return None ，除非你寫了你自己的 return 語句。
"""


print("DocStrings文檔字符串（ Documentation Strings） ")
def doc(x,y):
    """打印兩參數最大的數
    :param x:  x
    :param y:  y
    :return:  較大的數
    """
    if x > y:
        print(x)
    else:
        print(y)
doc(3,5)
print(doc.__doc__)
#python 中，所有的東西都是對象，所以函數也是對象， 調用函數的 __doc__ 方法， 會打印函數內部寫的DocStrings文檔字符串

            
          

?

5.模塊

test

            
              
if __name__ == '__main__':
    print("a當前程序運行在自己的模塊中")
else:
    print("a當前模塊被加載在另一個模塊中運行")



def sayhello():
    print("hahha ,我 是 子  模塊 ")
            
          

?

            
              import sys
print("模塊")

for i in sys.argv:
    print(i)
print(sys.path)




#每一個 Python 模塊都定義了它的 __name__ 屬性。如果它與 __main__ 屬性相同則代表這一模塊是由用戶獨立運行的
if __name__ == '__main__':
    print("當前程序運行在自己的模塊中")
else:
    print("當前模塊被加載在另一個模塊中運行")



#導入測試模塊
import  hello_05_test
hello_05_test.sayhello()



#dir 函數
l = dir()
print(l)

dir1 = dir(hello_05_test)
print(dir1)


a= 3
print(a)
del  a  # 刪除對a的定義
# print("a："+ str(a))   #NameError: name 'a' is not defined


c = 3
print(dir(c))


            
          

?

?

6.數據結構

            
              print('數據結構')

# 列表（可變的）
mList = ['a', 'b', 'c']
print(mList)
for i in mList:
    print(i)

mList.append('d')  # 追加
print(mList)
for i in mList:
    print(i)

mList.append('z')
mList.append('f')

mList.sort()  # 排序
print(mList)

s = mList[0]
print(s)
del mList[0]  # 移除
print(mList)

# 元組
print("元組（不可變）元組內的數值永遠不會變")
names = ("bob", 'cat', 'care')
print(names)
print("獲取長度")
print(len(names))

temp = ('a', 'b', names, 3)
print(temp)

# 字典(類似java中的map)
print("字典")
desc = {"a": "aaa", "b": "bbb", "c": "ccc"}
print(desc)
# 刪除一對鍵值
del desc["a"]
print(desc)

for k, v in desc.items():
    print(k, v)
# 增加一元素
desc["e"] = "eee"
print(desc)

if "e" in desc:
    print(desc["e"])




# 序列
print("序列")
shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'
# 索引或“下標（ Subscription） ”操作符 #
print('Item 0 is', shoplist[0])
print('Item 1 is', shoplist[1])
print('Item 2 is', shoplist[2])
print('Item 3 is', shoplist[3])
print('Item -1 is', shoplist[-1])
print('Item -2 is', shoplist[-2])
print('Character 0 is', name[0])
# Slicing on a list #
print('Item 1 to 3 is', shoplist[1:3])
print('Item 2 to end is', shoplist[2:])
print('Item 1 to -1 is', shoplist[1:-1])
print('Item start to end is', shoplist[:])
# 從某一字符串中切片 #
print('characters 1 to 3 is', name[1:3])
print('characters 2 to end is', name[2:])
print('characters 1 to -1 is', name[1:-1])
print('characters start to end is', name[:])



#集合
print("集合")
shoplist2 = ['apple', 'mango', 'carrot', 'banana']
print(shoplist2)
mshl = shoplist2
print(mshl)
del mshl[0]
print(shoplist2)
print(mshl)



            
          

?

7. 面向對象

            
              print("面向對象")




class Person:


    desc = "我是一個人" #類字段

    #初始化函數。類似java 的構造函數
    def __init__(self,name):
        self.name = name #成員字段



    #成員方法
    def say(self):
        print("my name is :",self.name)


    #類方法， 靜態方法
    @classmethod
    def printDesc(cls):
        print(cls.desc)






p = Person("小明")
p.say()
Person.printDesc()





            
          

繼承

            
              #定義學校工作者類
class SchoolMember:
    #初始化函數
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print(self):
        print("name :{0}  age:{1} ".format(self.name, self.age))


#定義學生類
class Student(SchoolMember):#繼承寫法
    def __init__(self, name, age, score):
        #需要主動調用父類的初始化方法， python不會主動調用
        SchoolMember.__init__(self, name, age)
        self.score = score

    def printScore(self):
        print("student score:",self.score)



class Teacher(SchoolMember):
    def __init__(self,name,age,salary):
        SchoolMember.__init__(self,name,age)
        self.salary = salary


    def print(self):
        print("teacher name{0} , age{1} , salary{2}".format(self.name,self.age,self.salary))




s = SchoolMember("小明", 13)
s.print()


student = Student("",18,90)
student.printScore()


t = Teacher("老王",39,5000)
t.print()

            
          

8.文件

            
              #定義學校工作者類
class SchoolMember:
    #初始化函數
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print(self):
        print("name :{0}  age:{1} ".format(self.name, self.age))


#定義學生類
class Student(SchoolMember):#繼承寫法
    def __init__(self, name, age, score):
        #需要主動調用父類的初始化方法， python不會主動調用
        SchoolMember.__init__(self, name, age)
        self.score = score

    def printScore(self):
        print("student score:",self.score)



class Teacher(SchoolMember):
    def __init__(self,name,age,salary):
        SchoolMember.__init__(self,name,age)
        self.salary = salary


    def print(self):
        print("teacher name{0} , age{1} , salary{2}".format(self.name,self.age,self.salary))




s = SchoolMember("小明", 13)
s.print()


student = Student("",18,90)
student.printScore()


t = Teacher("老王",39,5000)
t.print()

            
          

?

9.異常

            
              print("異常")

# 異常捕獲
try:
    i = 4 / 0
except ZeroDivisionError as  e:
    print("error", e.args)

try:
    i = 4 / 0
except ZeroDivisionError:  # 也可以不寫具體原因當參數
    print("error")

print("拋出異常")


def say():
    print("下面會開始拋出異常")
    raise Exception("我是被拋出的異常")  # 此處用raise 關鍵字拋出異常


try:
    say()
except Exception as e:
    print(e.args)

print("自定義異常")


class MyError(Exception):
    def __init__(self, error):
        self.error = error


print("下面拋出一自定義異常")
try:
    raise MyError("這是一個自定義拋出的異常")
except MyError as e:
    print(e.error)
    pass




import sys
import time

f = None
try:
    f = open("poem.txt")
    # 我們常用的文件閱讀風格
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line, end='')
        sys.stdout.flush()
        print("Press ctrl+c now")
        # 為了確保它能運行一段時間
        time.sleep(2)
except IOError:
    print("Could not find file poem.txt")
except KeyboardInterrupt:
    print("!! You cancelled the reading from the file.")
finally:
    if f:
        f.close()
    print("(Cleaning up: Closed the file)")

            
          

?

?

10.with語句

            
              """
在 try 塊中獲取資源，然后在 finally 塊中釋放資源是一種常見的模式。因此，還有一個
with 語句使得這一過程可以以一種干凈的姿態得以完成

"""

with open("test.txt") as f:
    for line in f:
        print(line)




"""
程序輸出的內容應與上一個案例所呈現的相同。本例的不同之處在于我們使用的是 open 函
數與 with 語句——我們將關閉文件的操作交由 with open 來自動完成。
在幕后發生的事情是有一項 with 語句所使用的協議（ Protocol） 。它會獲取由 open 語句
返回的對象，在本案例中就是“thefile”。
它總會在代碼塊開始之前調用 thefile.__enter__ 函數，并且總會在代碼塊執行完畢之后調
用 thefile.__exit__ 。
因此，我們在 finally 代碼塊中編寫的代碼應該格外留心 __exit__ 方法的自動操作。這能
夠幫助我們避免重復顯式使用 try..finally 語句。
"""
            
          

?

11.標準庫

            
              import sys

print(sys.version_info)

import os
import platform
import logging

if platform.platform().startswith("Windows"):
    logging_file = os.path.join(os.getenv('HOMEDRIVE'),
                                os.getenv('HOMEPATH'),
                                'test.log')
else:
    logging_file = os.path.join(os.getenv('HOME'),
                                'test.log')

print("Logging to", logging_file)
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s : %(levelname)s : %(message)s',
    filename=logging_file,
    filemode='w',
)
logging.debug("aaa")
logging.info("bbb")
logging.warning("ccc")

            
          

?