• 編程語言介紹

• Python介紹
• Python安裝
• 第一個Python程式
• 變數
• 程式交互
• 格式化輸出
• 數據運算
• 數據類型
• 控制流程
• 進位與字元編碼

編程語言介紹

編程語言的定義及作用：

編程的定義：‘動詞’即寫代碼。

編程的作用：讓電腦以人類的思維執行某些事件。

編程語言的分類：

1. 機器語言
2. 彙編語言
3. 高級語言

機器語言與彙編語言屬於低級語言.

機器語言：由於電腦只能識別二進位碼，因此用二進位碼0和1描述的指令為機器指令。全部由機器指令集合構成的語言稱之為機器語言。

• 優點：執行速度快
• 缺點：直觀性差，學習困難

彙編語言：彙編語言的實質性是與機器語言相同的都是對電腦硬體進行操作。不同的是指令採用英文縮寫的形式更方便記憶和識別。

高級語言：高級語言相比彙編語言，不但將許多相關的機器指令合成為單條指令，比並且去掉了許多與操作有關與完成工作無關的繁瑣細節。例如堆棧，寄存器等。這樣就大大的簡化了程式中的機器指令，由於忽略了很多細節，so 學習起來更加方便，編程者也不需要太多的相關知識。

高級語言的分類：

• 編譯型
• 解釋型

編譯型：在程式執行前。把源程式翻譯成機器碼。因此其目標程式可以脫離其語言環境獨立運行。程式一旦修改，就必須修改源文件程式編譯。

• 優點：運行速度快，可脫離環境單獨運行
• 缺點：可移植性（跨平臺）差，修改比較繁瑣

解釋型：目標程式由解釋器翻譯成機器語言才能執行，因此執行速度慢，且不可脫離環境單獨運行，由於不需要提前翻譯成機器語言，使用修改想比編譯型的語言方便許多

• 優點：可移植性強，修改方便
• 缺點：運行速度慢，需要語言環境才能運行

Python介紹

Python介紹：

創始人：吉多 範羅蘇姆（Guido van Rossum）

1989年聖誕節期間，Guido開始寫Python語言編譯器.他的初衷是創造一種c和shell之間簡單易學，功能全面可擴展的語言

Python的發展史：

1991年:第一個Python編譯器誕生

1994年：Python1.0

2000年：Python2.0

2004年：Python2.4同時Django誕生

2006年：Python2.5

2008年：Python2.6

2008年：Python3.0

2009年：Python3.1

2010年：Python2.7（過渡版本支持到2020年）同時支持2.x和3.x的特性

2011年：Python3.2

2012年：Python3.3

2014年：Python3.4

2015年：Python3.5

Python解釋器：

• CPython:

這個解釋器是c語言開發的，所以叫cpython.在命令行下運行python就是啟動cpython解釋器

• IPython:

Ipython是基於cpython之上的一個互動式解釋器，也是就說，ipython只是在交互上有所增強，但只是代碼是和cpytho完全一樣的。

• Pypy:

pypy是另一個python解釋器，它的目標是執行速度。pypy採用JIT技術，對python代碼進行動態編譯，所以可以顯著提高python代碼執行速度.

• Jython:

Jython是運行在Java平臺上的python解釋器，可以直接把python代碼編譯成Java位元組碼執行.

• IronPython:

IronPython和Jython類似，只不過ironpython是運行在微軟.net平臺上的python解釋器，可以直接把python代碼編譯成.net位元組碼

Python安裝：

下載地址：https://www.python.org/downloads/windows/

Windows：

預設下一步

驗證是否安裝成功：win+r 輸入cmd 出現以下字元即表明安裝成功

C:\Users\67525>python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

錯誤提示：不是內部命令

解決辦法：配置path環境

電腦（此電腦）鼠表右鍵 --> 屬性 --> 高級系統設置 -->高級 （環境變數） --> 在path中添加 Python的安裝路徑

Linux or Mac：

一般自帶Python2.7 or Python2.6，需要可其他版本自行安裝。

安裝其他版本已python3.6為例：

需要先下載python3.6.的源碼包

# tar -zxvf Python-3.6.1.tgz
# cd Python-3.6.1
# ./configure
# make && make instal

檢查是否安裝成功：

# python3 -V
Python 3.6.1

第一個Pthon程式

1.新建文件Hello.py 編輯以下內容：O

1 print('Hello World!')

在cmd下輸入 Python Hello.py

2.在Python交互器下

D:\>python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print('hello world')
hello world
>>>

變數：

變數的作用：就是把程式運算的中間結果存放到記憶體里，以便後面的代碼繼續調用

變數名的定義規則：

1. 變數名是字母下劃線及數字的任意組和
2. 變數名的首位字元不可為數字
3. 以下關鍵字不可以用作變數名

定義變數名要避免的幾種方式：

1. 變數名為中文或拼音
2. 變數名過長
3. 變數名詞不達意

變數的賦值

1 number = 5
2 name = 'xuange'

變數的命名習慣

#駝峰體
AgeOfOldBoy = 56
NumberOfStudents = 80
#下劃線
age_of_oldboy = 56
number_of_studnets = 80

常量

常量：即不可變得量，在Python中並沒有特定的語法來聲明常量，只需把常量名全部使用大寫即可.

常量的定義：

PI = 3.1415826
print(PI)

用戶交互及註釋

作用：接收用戶輸入的值，預設類型為字元串

語法：

#語法
name = input('name:')

特定條件下需要接收密碼可用模塊中的getpass模塊

import getpass
passwd = getpass.getpass('passwd:')

註釋

#這是單行註釋
'''
這是多行註釋
'''

註釋原則：只需要在不容易理解的地方加入註釋即可，不需要全部都加註釋。可以使用中文或者英文，禁止使用拼音

格式化輸出

作用：按照指定格式列印內容。

占位符：

1. %s 字元串類型
2. %d 數字類型
3. %f 浮點數類型

常見的三種字元串格式方式：

 1 ##常見的幾種方法
 2 name = input('Name:')
 3 age = input('Age:')
 4 job = input('Jbo:')
 5 salary = input('Salary:')
 6 #方法一
 7 info = '''
 8 -------info %s -------
 9 Name: %s
10 Age: %s
11 Job: %s
12 Salary: %s
13 ------ the end ---------
14 ''' % (name, name, age, job, salary)
15 print(info)
16 # 方法二
17 info = '''
18 ----- info {_name}
19 Name: {_name}
20 Age: {_age}
21 Job: {_job}
22 Salay: {_salary}
23 '''.format(_name=name, _age=age, _job=job, _salary=salary)
24 print(info)
25 #方法三
26 info  = '''
27 ------info {0} ----
28 Name :{0}
29 Age:{1}
30 Job:{2}
31 Salary: {3}
32 ''' .format(name, age, job, salary)
33 print(info)
34 #一種縮寫
35 b = 'bbb'
36 print(f'aaaa{b}')

數據運算

• 算數運算符
• 比較運算符
• 賦值運算符
• 邏輯運算符
• 成員運算
• 身份運算
• 位運算

算數運算符

 1 #例子：
 2 >>> a = 10
 3 >>> b = 5
 4 >>> c = a+b
 5 >>> c
 6 15
 7 >>> c = a-b
 8 >>> c
 9 5
10 >>> c = a*b
11 >>> c
12 50
13 >>> c = a/b
14 >>> c
15 2.0
16 >>> c = a % b
17 >>> c
18 0
19 >>> c = a ** b
20 >>> c
21 100000
22 >>> c = a //b
23 >>> c
24 2

比較運算：

#例子：
>>> a = 5
>>> b = 3
>>> a == b
False
>>> a !=b
True
>>> a > b
True
>>> a < b
False
>>> a >= b
True
>>> a <= b
False
>>>

賦值運算

#

例子：
>>> a = 5
>>> b = 3
>>> b += a #b = b+a
>>> b
8
>>> b -= a #b= b-a
>>> b
3
>>> b *= a #b = b*a
>>> b
15
>>> b /= a #b = b/a
>>> b
3.0
>>> b %= a #b = b%a
>>> b
3.0
>>> b **= a #b = b**a
>>> b
243.0
>>> b //= a #b = b//a
>>> b
48.0
>>>

邏輯運算

例子
>>> a  = 15
>>> b = 20
>>> a == 15 and b ==20 #所有條件都滿足才會為true
True
>>> a < 20 and b >20
False
>>> a < 20 or b > 20 # 一個條件成立就為true
True
>>> not a< 20    #取反
False

成員運算

#例子：
>>> list = [1,2,3,5,6,7]
>>> 1 in list
True
>>> 4 in list
False
>>> 1 not in list
False
>>> 4 not in list
True
>>>

身份運算

#例子：
#如果id(a)等於id(b) 則返回True ,反之返回 False
>>> a = 5
>>> b = a
>>> a is  b
True
# 如果 id(a)不等於id(b)則返回True, 反之返回False
>>> a = 7
>>> a is not b
True
>>>

位運算：

暫時沒搞明白，先不寫~~~

數據類型

• 基礎數據類型
• 數據集

基礎數據類型

數字

• 整數
• 浮點數
• 複數

整數

整型： 在32位機器上取值範圍為 -2* *31 ~ 2 * *31-1 ，64位機器上取值範圍為：-2 ** 63 ~ 2 * *63-1

長整型：在Python3中沒有整型和長整型之分

浮點數

浮點數：浮點數是屬於有理數中特定子集的數字表示，在電腦中用以表示任意某個實數。

 科學計演算法：

就是把一個數字以a*10n次冪的方式表現出來。電腦一般把10的幾次冪用中的10以e或者E來表示.且a>=1,a<10

浮點數的精度問題：

由於在電腦內部整數和浮點數的記憶體存儲方式不同，整數運算永遠是精確的，而浮點數運算則會有四捨五入的誤差。

Python預設的是17位精度，也就是小數點後16位，但這個精度越往後越不准.

計算高精度的浮點數方法：

from decimal import *
getcontext()
getcontext().prec = 20
a = Decimal(1)/Decimal(3)
print(a)

也可以使用字元串格式化的方式來表示：

>>> a =('%.30f'%(1.0/3))
>>> a
'0.333333333333333314829616256247'
>>>

複數

複數是指能寫成如下形式的數a+bi，a和b為實數i是虛數。在複數a+bi中,a為複數的實部，b為複數的虛部，i為虛數的單位，當虛部等於0時，這個複數就是實數，當虛部不等0時，這個數就是虛數

#例子
>>> a = (-5+4j)
>>> a
(-5+4j)
>>> type(a)
<class 'complex'>
>>>

其中-5,4為實數，j為虛數.

字元串

字元串特性及定義：有序不可修改的字元集合，由一對單，雙，三引號包含 包含的內容即字元串

字元串作用：用於存儲文本信息

字元串的操作方法：

 1 s = 'hello world'
 2 
 3 s.capitalize()            #返迴首字母為大寫的字元串
 4 s.casefold()            
 5 s.center()                #以該字元串為中心填充該字元串        參數：長度 ，以什麼字元填充（預設空格）
 6 s.count()                #查看該字元串某個字元出現的次數    參數：查看的字元，起始，結束（預設為空）
 7 s.encode()                #以指定編碼格式編碼字元串            參數：編碼（預設UTF-8）,設置不同錯誤的處理方案。預設為 'strict',意為編碼錯誤引起一個UnicodeError. 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 註冊的任何值。
 8 s.endswith()            #檢查字元串是否以 obj 結束.        參數：該參數可以是一個元素或是字元串,起始位置，結束位置
 9 s.expandtabs()            #擴展tab建                        參數：tab鍵長度（預設：8個空格）
10 s.find()                #堅持字元串中是否包含子字元串str    參數：檢索的字元串,起始位置,結束位置
11 s.format()                #字元串格式化                        參數：
12 s.index()                #檢測字元串是否包含子字元串str        參數：檢索的字元串。起始位置，結束位置
13 s.isalnum()                #如果字元串至少有一個字元並且所有字元都是字母或數字則返 回 True,否則返回 False
14 s.isalpha()                #如果字元串至少有一個字元並且所有字元都是字母則返回 True, 否則返回 False
15 s.isdecimal()            #如果字元串中只有十進位字元，返回True，否則返回False
16 s.isdigit()                #如果字元串只包含數字則返回 True 否則返回 False
17 s.isidentifier()        #如果字元串是有效的表示符則返回 True 否則返回False
18 s.islower()                #如果字元串中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是小寫，則返回 True，否則返回 False
19 s.isnumeric()            #如果字元串中只包含數字字元，則返回 True，否則返回 False
20 s.isprintable()            #如果該字元串可以列印返回True 否則返回False
21 s.isspace()                #如果如果字元串中只包含空格，則返回 True，否則返回 False.
22 s.istitle()                #如果字元串是標題化的則返回 True，否則返回 False
23 s.isupper()                #如果字元串中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是大寫，則返回 True，否則返回 False
24 s.join()                #以指定字元串分割符分割串            參數：要連接的元素序列
25 s.ljust()                #回一個原字元串左對齊,填充至指定長度    參數：長度,以什麼填充（預設空格）
26 s.lower()                #將字元串中所有的大寫轉為小寫
27 s.lstrip()                #截掉字元串左邊的空格或指定字元。        參數：指定截取的字元（預設空格）
28 s.maketrans()            #創建字元映射轉換表                參數：intab:要代替的字元組成的子字元串 outtab:要代替的字元組成的字元串
29 s.partition()            #在字元串中以seq為分隔符，分割字元串    參數：seq 分割方法
30 s.replace()                #將，某個字元替換為另一個字元        參數：舊的字元，新的字元，替換次數（預設全部替換）
31 s.rfind()                #類似find(),區別就是從右邊開始查找        參數：查找的字元串，起始位置，結束位置
32 s.rindex()                #類似index(),區別就是從右邊開始查找    參數：查找的字元串，起始位置，結束位置
33 s.rjust()                #與ljust()方法相似，區別就是右對齊，填充字元串。        參數：長度，以什麼填充（預設空格）
34 s.rpartition()            #在字元串中以seq為分隔符，中字元串右邊開始分割字元串        參數：seq 分割符
35 s.rsplit()                #以str為分割符截取字元串，從右邊開始截取    參數：分隔符，分割次數
36 s.rstrip()                # 截掉字元串右邊的空格或指定字元。 參數：指定截取的字元（預設空格）
37 s.split()                # 以 str 為分隔符截取字元串             參數：分割符 分割次數
38 s.splitlines()            #以按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表   參數：keepends 預設為False 為True則保留換行符
39 s.startwith()            #檢測字元串是否已str開頭            參數：檢索的字元串，可選參數-設置起始位置，可選參數設置結束位置
40 s.strip()                #去除字元串兩邊的空格                參數：移除指定的序列
41 s.swapcase()            #字元串中的字元大小寫互換            
42 s.title()                #將字元串轉換成標題格式
43 s.translate()            #以指定表轉換字元串的字元（一般與maketrans配合使用） 參數：翻譯表，要過濾的字元
44 s.upper()                #將字元串中的小寫轉換為大寫
45 s.zfill()                #返回長度為width的字元串，原字元串右對齊，前面以0填充    參數：長度
46 ###補充
47 len(s)                    #返回字元串的長度

布爾

作用：用來進行邏輯判斷

分為真或假（True False）

>>> a =3
>>> b  = 5
>>> a > b
False
>>> a < b
True

數據集

• 列表
• 字典
• 元組
• 集合

列表

列表的定義：有序的

列表的特性：有序可修改的數據集合

列表的創建

l1 = [1, 2, 3]
# 創建空列表
l2 = []
l3 = list()

列表的操作

C:\Users\67525>python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> l = [1,2,3,4,5,6,7,8]
>>> # 訪問列表中的值
...
>>> l[1]
2
>>> # 取索引
...
>>> l.index(5)
4
>>> # 切片
...
>>> l[1:5]
[2, 3, 4, 5]
>>> # 添加
...
>>> l.append(8)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 8]
>>> l.insert(5,'5')
>>> l
[1, 2, 3, 4, 5, '5', 6, 7, 8, 8]
>>> #修改
...
>>> l[0] = 0
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8, 8]
>>> #刪除
>>> l.pop()
8
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8]
>>> l.remove('5')
>>> l
[0, 2, 3, 4, 5, 6, 7, 8]
>>> l.pop()
8
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8]
>>> l.remove('5')
>>> l
[0, 2, 3, 4, 5, 6, 7, 8]

>>> # 迴圈
>>> for i in l:
...     print(i)
...
0
2
3
4
5
8
>>> # 排序
...
>>> l = ['a','c','B','e','F','d','m','N','@']
>>> l
['a', 'c', 'B', 'e', 'F', 'd', 'm', 'N', '@']
>>> l.sort()
>>> l
['@', 'B', 'F', 'N', 'a', 'c', 'd', 'e', 'm']
>>> # 倒序
...
>>> l.reverse()
>>> l
['m', 'e', 'd', 'c', 'a', 'N', 'F', 'B', '@']
>>>

 列表的方法詳解：

l = [1,23,3,4,5,6,7]
l2 =['a','b']
l.append('追加')        #追加一個值  參數：要追加的值
l.copy()             #淺copy
l.count(23)         #查看某個值在該列表中出現的次數  參數： 要查看的值
l.extend(l2)         #拼接列表  參數：要拼接的列表
l.index(3)          #取列表中某個值得索引        參數：要取索引的值，起始位置，結束位置
l.insert(5,'插入')    #插入一個值                參數：要插入的位置，要插入的值
l.pop()                #取列表最後一個值，並刪除    參數：可選項，某個值得索引
l.remove()          #刪除指定的值            參數：要刪除的值
l.reverswe()        #倒序                   
l.sort()            #排序                     #參數 排序方法(預設Ascii碼)可選參數 ，是否倒序預設為false
l.clear()            #清空

深淺copy

l1 = [1,2,3,4,5] l2 = l1

該方法 l2則是完全指向了l1的記憶體地址，所以修改任意列表，其他列表也會跟著受影響。

淺copy：copy一份獨立的列表（如果有子列表子列表不獨立）。

列表的記憶體地址是獨立的，列表中的值的記憶體也是獨立的. 淺copy，則會給新的列表開闢新的記憶體地址，列表中的值則會使用原列表的記憶體地址，如果修改則會像字元串一樣在對修改的值開闢一塊新的記憶體地址，因此兩個列表之間互相影響。 如果copy的列表中包含子列表（嵌套列表），由於子列表是兩個列表共用的，因此子列表並不是有單獨的記憶體地址，，所以修改子列表中的值，兩個列表都會受影響。

深copy：copy一份完全獨立的列表(包括子列表)

import copy 
l1 = [1,2,3,[4,5]] 
l2 = copy.deepcopy(l1)

字典

字典:一種key-value 的數據類型

字典的特性：key-value結構、key必須可hash且必須為不可變數據類型而且唯一、可存放多個值

可修改、無序、查找速度快

字典的常用操作：

#創建字典
>>> dict={1:2,3:4,5:6,7:9,8:5}
>>> dict
{1: 2, 3: 4, 5: 6, 7: 9, 8: 5}
#添加>>> 
>>> dict['test']=1
>>> dict
{1: 2, 3: 4, 5: 6, 7: 9, 8: 5, 'test': 1}
#修改
>>> dict['test'] = 3
>>> dict
{1: 2, 3 4, 5: 6, 7: 9, 8: 5, 'test': 3}
#查找
>>> dict.get('test')
3
>>> dict['test']        #次方法如果一個key不存在就會報錯，而get方法則返回None
3
#迴圈
>>> for key in dict:
...     print(key,dict[key])
...
1 2
3 4
5 6
7 9
8 5
test 3

字典的方法詳解：

dict.clear()        #清空字典
dict.copy()            #淺copy
dict.fromkeys()        #創建一個新的字典，以指定的元素做字典的key，val為字典所有建對應的初始值                    參數：字典鍵值列表，可選參數 鍵值序列的初始值
dict.get()            #返回指定key的值，如果值不在字典中返回default值                                         參數：字典的鍵值         key不存在時返回的值
dict.keys()            #返回列表的所有key
dict.pop()            #刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。     參數：要刪除的鍵值，返回值
dict.popitem()        #隨機返回並刪除字典中的一對鍵和值(一般刪除末尾對)。如果字典已經為空，卻調用了此方法，就報出KeyError異常
dict.setdefault()    #與get()方法類似, 如果鍵不已經存在於字典中，將會添加鍵並將值設為預設值                   　　 參數：查找的鍵值，返回的值
dict.update()        #把字典參數 dict2 的 key/value(鍵/值) 對更新到字典 dict 里。                            參數：要添加的字典（dict2）
dict.values()        #返回列表裡所有的value        

元組

元組的定義：與列表類似，由於不可變的特性被稱為只讀列表

元組的特性：有序不可變，如果元組中包含其他可變元素，這些可變元素可以改變

元組的使用場景：存放資料庫連接配置信息等

元組的操作：

創建：

name=('alex','test','shadan')

其他操作

t = (1,2,3,4,2,5,6)
print(t.index(2,3,5))
print(t.count(2))

# t.index方法:取索引值  參數：要取索引的元組參數 , 從哪裡開始 , 到哪裡結束
# t.count方法：查看某個參數在該元組中的個數  參數:取值對象
#切片
t1 = t[2::2]
print(t1)

集合

集合的作用：去重，測試兩組數據之間的交集、差集、並集等關係。

集合的特點：無序且不重覆的數據集合確定性（元素必須可hash）

集合的操作：

 1 #集合的創建
 2 >>> set = {1,2,3,4,5}
 3 >>> set2 ={2,3,5,7,8}
 4 #添加
 5 >>> set.add(9)
 6 >>> set
 7 {1, 2, 3, 4, 5, 9}
 8 >>> set.update([8,5,0])
 9 >>> set
10 {0, 1, 2, 3, 4, 5, 8, 9}
11 #刪除
12 >>> set.discard(8)
13 >>> set
14 {0, 1, 2, 3, 4, 5, 9}
15 >>> set.pop()
16 0
17 >>> set
18 {1, 2, 3, 4, 5, 9}
19 >>> set = {1,4,7,2,5,8,}
20 >>> set
21 {1, 2, 4, 5, 7, 8}
22 >>> set.remove(4)
23 >>> set

集合的關係測試:

#取交集
>>> set.intersection(set2)
{2, 3, 5}
>>> set&set2
{2, 3, 5}
#取差集
>>> set.difference(set2)
{1, 4, 9}
>>> set-set2
{1, 4, 9}
#取並集
>>> set.union(set2)
{1, 2, 3, 4, 5, 7, 8, 9}
>>> set | set2
{1, 2, 3, 4, 5, 7, 8, 9}
#取對稱差集
>>> set.symmetric_difference(set2)
{1, 4, 7, 8, 9}
>>> set^set2
{1, 4, 7, 8, 9}

集合的方法詳解：