Python

Python是什麼

Python 是一種直譯的語言

高階程式語言

很好懂，簡單，容易上手

廣泛使用

總之據說很好用

How to download?

  • Open GOOGLE
  • Search "Python"
  • Download it!
  • 我是使用3.x版本的啦

輸入輸出

a = input()
print(a)

基礎型別

  • int
  • float
  • string
  • bool
  • ...等等

賦值

cute = "cat"
n = 1
n = n+1 #2

輸入進來的是字串！

a = input()
print(a) #輸入a，此時a是字串
a = input()
a = int(a) #將a轉成整數
b = int(input()) #輸入的時候順便轉為整數

保留字

運算子

例如

  • 加法  +
  • 減法  -
  • 乘法  *
  • 除法  /
  • 帶餘除法  //
  • 取餘數 %
  • 等於 =
  • 判斷兩者是否等於 ==
  • 次方 **

舉例來說

a = 4
b = 3
a = a+b  # 7
a = a-b  # 1
a = a*b  # 12
a = a/b  # 1.333333333
a = a//b # 1
a = a%b  # 1
a = a**b # 64

比較運算子

  • >=
  • >
  • <=
  • <
  • !=
  • ==
a = 4
b = 3
a >= 3 # True
a != b # True

字串的運算

a = "hello"
a = a+a
print(a) # hellohello
a = "world"
a = 2*a
print(a) # worldworld
"hello" == "world" # 0

Bool

  • bool 只有True或False兩種值，代表真或假
  • and、or、not
  • 相信大家都有邏輯思考能力？
1 and 1 # 1
0 and 1 # 0
0 and 0 # 0

真值表(簡陋版)

字串

就是一堆字元？

"I am string. Nice to meet you."
函式 用途
title() 全部單字首字母大寫
capitalize() 第1個單字首字母大寫
upper() 全部字母大寫
lower() 全部字母小寫
center() 依指定長度置中對齊
ljust() 依指定長度靠左對齊
rjust() 依指定長度靠右對齊
split() 單字串切為多字串，可指定次數
rsplit() 單字串切為多字串，可指定次數 (從右切割)
join() 多字串併為單字串
count() 計算小字串在大字串中個數
zfill() 依指定字元寬度補0
strip() 兩邊移除指定字元
lstrip() 左邊移除指定字元
rstrip() 右邊移除指定字元
find() 尋找指定字串
replace() 取代指定字串

example

s = "hello"
t = s.upper()
print(t) #"HELLO"

判斷式

if statement :

a = int(input())
if a < 60:
    print("不及格")
elif a < 90:
    print("不錯！")
else:
    print("Good job!")

迴圈

for 迴圈

for i in range(10):
    print(i) # 0~9
for i in range(3,10):
    print(i) # 3~9
for i in range(3,10,2):
    print(i) # 3 5 7 9
for i in range(10,-3,-4):
    print(i) # 10 6 2 -2

while

i = 1
while i < 10:
    i = i+1
print(i) # 10

想要做一些事？

  • break
  • continue
a = 0
for i in range(1,10):
    if i >= 5:
        break
    a = a+i
print(a) # 10

for i in range(1,10):
    if i == 3:
        continue
    a = a+i
print(a) # 52

串列

功能？

  • 存很多東西
  • 存很多東西
  • 隨便存很多東西

舉例

li = [ 30, 41, 52, 63 ]
li[2]          # 52
b = li[0]
print(b)       # 30
print(sum(li)) # 186
li.append(3)
print(li[4])   # 3
print(len(li)) # 5
li[0] = 10     # 修改30變成10

串列裡面可以塞幾乎任何東西，包含再塞個串列，也可以塞不同型別的東西，這聽起來很有趣

li = [ 10, True, [ "hello", 23 ], "world" ]
print(li[2][0]+li[3]) # "helloworld"

搭配迴圈

li = [ 1, 2 , 3, 4, 5 ]
a = 0
for i in li:
    a = a+i
print(a) # 15

if 2 in li:
    print("Meow")

tuple元組

舉例

a = ()             # 空tuple
a = (1, 3, 4, 2, 5)
a[0]               # 1
a[1] = 27          #錯誤

可變不可變

可以修改值稱為可變

像是串列就是可變

但是元組就是不可變

整數看起來可變，但其實是不可變

事實上 a = 4這個動作，是將a原本指向的東東丟掉後，重新指向4的喔><

變數名稱

物件

不可變：將箭頭拔掉後重新指向一個新的物件

Compare

可變：將物件改掉

第一次上課預計到這裡

函式

def

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Example

def grade(x):
    if x >= 60:
        return "及格"
    else:
        print("不及格")

#函式可以有return也可以沒有

好處？

  1. 將任務分解為幾個小任務，降低複雜度。
  2. 可重複使用。
  3. 可與其他人使用，節省開發時間。

遞迴

自己呼叫自己

像是f(n) = f(n-1)*2

這樣的遞迴函氏

費氏數列

def F(x):
    if x == 1 or x == 2:
        return 1
    else:
        return F(x-1)+F(x-2)

存活時間與可視範圍

存活時間

一旦一個物件沒有被任何名稱指向時，它就會被python的垃圾收集機制回收

名稱的話，只有它曾經存在過，那它就會一直存在到程式結束為止。

不過實務上可以使用del語句來刪掉它

a = 3
del a
print(a) #錯誤

一個名稱的可視範圍，是指所有能夠存取它的地方。

在函式外面宣告的變數稱作全域變數。

在函式內部的變數稱作區域變數。

在python內建的變數稱作內建變數。

 

可視範圍

同名的區域變數會覆蓋掉全域變數的唷

def meow():
    a = 2
    print(a)
a = 3
meow #輸出2

如果想要在函數中使用全域變數的話，則可以使用global語句唷><'

a = 3
def meow():
    global a
    a = 2
meow
print(a) #輸出2

我用的是誰？

當使用某個變數的時候，會優先在區域中找是否有那個變數，找不到的話就往上層找，若全域變數也找不到的話，就會到內建變數中找。

a = 3
def meow():
    print(a)
meow # 在meow中找不到a，往全域變數找

新的、還是修改了？

有些動作會建立新物件，有些動作則會原地修改，多注意唷><

a = b = c = [0]
b = b+[1] #右邊產生了新物件
c += [2]
# a [0,2]
# b [0,1]
# c [0,2]

python有分所謂的淺複製和深複製

淺複製：兩個名稱指向同個物件

深複製：指向不同物件

import copy
a = [0]
b = copy.copy(a)
c = copy.deepcopy(a)
b[0] = 1
c[0] = 2
# a [1]
# b [1]
# c [2]
這邊好像有錯
不要管這頁簡報

串列生成式

大家還記得之前在教迴圈的時候的那個咚咚嗎？

for i in range(0,10):
    print("meow")

運算式 for 名稱 in 可迭代者 

運算式 for 名稱 in 可迭代者 if 運算式

a = []
for i in range(0,4):
    a.append(i)
b = [5*x for x in a]
c = [5*x for x in a if x%2 == 0]
# b [0,5,10,15]
# c [0,10]

這好像很方便可以嘗試用用看

它也有一堆噁心的操作，像是包一堆串列生成式之類的，有興趣的話可以玩玩看

模組

簡單來說就是import

import math
print(math.pi) # 3.1415926535.... 
print(math.factorial(6)) # 720
#
import math as m #import math，並將其縮寫為m
print(m.e) # 2.8....
#
from math import pi as meow # 從math裡面import pi進來
print(meow) # 3.1415926
# 
from math import * #將math裡所有咚咚import進來
print(pi) #3.1415926

字典

dict

有key對到value

從鍵映射到值，鍵要不可變

d = {}
d = {'name': 'cat', 'love': 'meow', 'size': 20}
print(d['name']) # 'cat'
d['size'] = 18
print(d['size']) # 18
d = ['name': 'AY', 'age': 17,  'club': 'infor']
'club' in d # True
del d[age]
print(d[age]) #錯誤
d['love'] = 'Ayase'
d.get('love') # 'Ayase'
for k in d.keys():
    print(k)
for v in d.values():
    print(v)
for k,v in d.items():
    print(k,v)        // 不保證順序

舉例來說

集合

set

x = {1,2,3,1} 
x # {1,2,3} 每個元素只會出現一次
x = set(range(1,3))
x # {1,2}
x = {[1,2],3} #錯誤
#set裡面只能塞不能修改的物件
#list可修改，int不可修改
print(x[0]) #錯誤，set不具順序性，沒有index
x = {1,2}
x.add(3)
x # {1,2,3}
x.remove(1)
x # {2,3}
x.remove(1) # 錯誤，1不存在
x.discard(1) # OK，discard可以無視不存在的
x.discard(2) 
x # {3}

和數學上一樣的操作

x = {1,2,3}
y = {2,3,4}
x&y # {2,3}
x|y # {1,2,3,4}
x-y # {1}
x^y # {1,4}
li1 = [1,1,1]
li2 = [1]
x = set(li1)
y = set(li2)
x == y # True

物件導向程式設計

概論

把所有東西包成物件，然後物件裡面可能會有方法(method)，也就是某種類似函式的東西，然後用物件做任何事情的說><

舉例來說

銀行帳戶是一個物件

裡面有個int紀錄還有多少錢

或許有個list紀錄所有的交易

還有著存款、提款、查詢之類的方法

三大概念

封裝：將所需要的資料包在物件裡面，僅提供公開介面加以存取

線上遊戲中，所有武器都有攻擊力之類的設定，所以武器繼承自攻擊力的物件、爆擊率的物件......等等

多型：讓同一個方法或運算子因為型別不同而做不同的事情

銀行提供ATM而不直接提供鈔票來交易

繼承：讓物件有上下關係，子物件可以使用父物件的程式碼

a+b

在int是加法

在str是連接

封裝

class account():
    def __init__(self):
        self.b = 0
    def dep(self,amou):
        self.b += amou
    def wit(self,amou):
        self.b -= amou
    def get(self):
        return self.b
ac = account()
print(ac.b) # 0
ac.dep(100)
ac.wit(10)
print(ac.get()) # 90

繼承

class A():
    def __init__(self,a):
        self.a = a
    def meow(self):
        return self.a*(self.a+1)
class B(A):
    def __init__(self,a,b):
        # self.__init__(a) 錯誤
        # A.__init__(self,a) 可以
        # super(B,self).__init__(a) 可以
        super().__init__(a)
        self.b = b
    def cute(self):
        return self.b*self.meow()
AY = B() #錯誤
AY = B(2,1187)
print(AY.cute()) # 7122

多型

class Animal():
    def shout(self): print('Animal shout')
class Dog(Animal):
    def shout(self): print('Dog shout')
class Cat(Animal):
    def shout(self): print('Cat shout')
d = Dog()
e = Cat()
d.shout() # 'Dog shout'
e.shout() # 'Cat shout'
子類別和父類別method名字相同稱為覆寫
不同類別的實體有著相同的method名字則稱為多型

然後python基礎語法課程就結束囉的說~~!

期待再會喔的說

(不)

Made with Slides.com