字串

基本知識

轉義符

print('hello\nyou')

輸出：

hello

you

若在‘str'前加r:可以直接顯示原始字串，不進行轉義。

print(r'hello\nbaby')

輸出：

hello\nbaby

字串的常見操作

1.isalnum() 若字串至少有一個字元且所以字元都是字母或數字則true,否則false

print('shh45'.isalnum())

輸出True‘

print(')('.isalnum())

輸出False

2.isalpha() 若字串至少有一個字元且所以字元都是字母則true,否則false

3,isdigit() 若字串只包含數字則True,否則False,isnumeric()類似，但是在漢字數字，羅馬數字情況下略有不同。

4.join(seq) 以指定字串作為分隔符，將seq中所有元素（的字串表示）合併為一個新的字串。

print(' and '.join(['Lihua', 'Zhangsan','Lisi']))

輸出:

Lihua and Zhangsan and Lisi

5.len(str) 返回字串長度

6.lstrip() 去除左邊的空格，rstrip() 去除右邊的空格，strip() 去除字串所有的空格。

print('   2 7288hhduf'.lstrip())

輸出：

2 7288hhduf

7.split(str=' ',num=string.count(str)) num=string.count(str) 以str為分隔符擷取字串，如果num有指定值，則僅擷取num+1個字串

print('Lihua and Zhangsan and Lisi'.split(' and ', 1))

輸出:

['Lihua', 'Zhangsan and Lisi']

8.encode(encoding='UTF-8',error='strict') 以encoding指定的編碼格式編碼字串，如果出錯則預設報一個ValueError的異常，除非errors指定的是'ignore'或'replace'

列表

基本知識

寫在[],元素用逗號分割，可變，元素可重複，有序。

namelist = ['Alla', 'Mara', 'John']
for name in namelist:
    print(name)
 

name無所謂，也可以寫成i,x等等。輸出：

Alla

Mara

John

也可

namelist = ['Alla', 'Mara', 'John'];i=0
while i < len(namelist):
    print(namelist[i])
    i = i+1

輸出同上。

列表常用操作

訪問切片遍歷

通過索引直接訪問：

print(list1[1])

使用list[ : : ]切片：

list1 = [1,5,6,'f','g',[2,'f']]
print(list1[1:6:2])

輸出：

[5, 'f', [2, 'f']]

遍歷類似字串，for i in list1:

增刪改查

增

1.append() 在末尾增加元素。

list1 = [1,5,6,'f','g']
list1.append(['aba',4]) #將列表當做元素追加
print(list1)

輸出：

[1, 5, 6, 'f', 'g', ['aba', 4]]

注意，append是直接修改原列表。

2.extend() 擴充套件列表。

list1 = [1,5,6,'f','g']
list1.extend(['aba',4])
print(list1)

輸出:

[1, 5, 6, 'f', 'g', 'aba', 4]

3.insert() 在指定索引處插入新增元素。

list1 = [1,5,6,'f','g']
list1.insert(2, ['aba',5]) #在2索引處插入元素
print(list1)

輸出：

[1, 5, ['aba', 5], 6, 'f', 'g']

刪

1.del list [index] 刪除指定索引的元素

list1 = [1,5,6,'f','g']
del list1[2] #刪除索引2的元素
print(list1)

輸出：

[1, 5, 'f', 'g']

2.pop(index) 彈出末尾指定索引元素，若無索引則預設彈出最後一個。

list1 = [1,5,6,'f','g']
list1.pop(2)
print(list1)

輸出：

[1, 5, 'f', 'g']

3.remove() 移除指定元素(一般用在不知道索引時)

list1 = [1,5,6,'f','g']
list1.remove(5)
print(list1)

輸出：

[1, 6, 'f', 'g']

注意，若要求刪除的元素有重複，則只刪除索引最前的一個

list1 = [1,5,6,'f','g',5]
list1.remove(5)
print(list1)

輸出：

[1, 6, 'f', 'g', 5]

改

直接通過索引修改。

list1 = [1,5,6,'f','g',5]
list1[1]='五'
print(list1)

輸出:

[1, '五', 6, 'f', 'g', 5]

查

主要是看元素存不存在。直接用if element in list:或not in

查詢

1.list.index(ele,start,end) 看元素是否出現在給定的索引值之間。區間左閉右開(注意，一般來說區間是左閉右開，但randint()是左閉右閉)。若出現則返回對應元素的索引值，否則輸出ValueError: ele is not in list。

若區間內待查詢的元素有重複，則只返回最前面的元素索引。

list1 = [1,5,6,5，'f','g',5]
print(list1.index(5,1,5))

輸出：1

2.list.count(ele) 查詢整個列表內指定元素出現次數。

list1 = [1,5,6,5,'f','g',5]
print(list1.count(5))

輸出：3

排序

1.list.reverse() 將列表所以元素順序反轉。

list1 = [1,5,6,5,'f','g',5]
list1.reverse()
print(list1)

輸出：

[5, 'g', 'f', 5, 6, 5, 1]

2.list.sort() 將列表中元素升序排列，要求元素要麼均為整數或浮點數，要麼全為字串。

list1 = [1,5,6,5.3,5]
list1.sort()
print(list1)

輸出：

[1, 5, 5, 5.3, 6]

list1 = [1,5,6,5.3,5]
list1.sort(reverse=True) #降序排列
print(list1)

輸出：

[6, 5.3, 5, 5, 1]

字串的排列按編碼對應的值，但若字串長度不同則規則較複雜。

list1 = ['2','t','你是','你','ab']
list1.sort(reverse=True)
print(list1)

輸出：

['你是', '你', 't', 'ab', '2']

巢狀

列表元素可以為列表，套娃。訪問時類似二元陣列。

list1 = [['1','b','c'],['你','數','傻逼']]
print(list1[1])
print(list1[1][1])

輸出：

['你', '數', '傻逼']

數

例題作業

例1 三個辦公室分八個老師。

import random
offices = [[],[],[]]#三個辦公室
teachers = ['A','B','C','D','E','F','G','H']#八個老師
for name in teachers:
    index = random.randint(0, 2)
    offices[index].append(name)#給每個辦公室隨機分配老師
i = 1
for office in offices:
    print('辦公室{}的老師人數為{}'.format(i,len(office)))
    print('老師為：',end='')
    for name in office:
        print('{}'.format(name),end='\t')
    i += 1
    print('\n')

輸出：

辦公室1的老師人數為4

老師為：B E F H

辦公室2的老師人數為3

老師為：A D G

辦公室3的老師人數為1

老師為：C

作業：

products = [['iphone',6888],['MacPro',14800],['xiaomi6',2499],['Coffee',31],['Book',60],['Nike',699]]
index = [0,1,2,3,4,5]
print('-'*6,'商品列表','-'*6)
for i in index:
    print('{}  {}    {}'.format(i,products[i][0],products[i][1]))

goods = []
a = input('您想要買什麼：')
while a.isnumeric()==True and int(a) in index:
    goods.append(products[int(a)][0])
    a = input('您想要買什麼：')
if a =='q':
    print('你要購買的商品為：',end='')
    for i in goods:
        print(i,end='\t')
else:
    print('不存在對應編號的商品')

輸出：

------ 商品列表 ------

0 iphone 6888

1 MacPro 14800

2 xiaomi6 2499

3 Coffee 31

4 Book 60

5 Nike 699

您想要買什麼：2

您想要買什麼：3

您想要買什麼：4

您想要買什麼：q

你要購買的商品為：xiaomi6 Coffee Book

答案：

products = [['iphone',6888],['MacPro',14800],['xiaomi6',2499],['Coffee',31],['Book',60],['Nike',699]]
i = 0
print('-'*6,'商品列表','-'*6)
for item in products:
    print(str(i)+'\t'+item[0]+'\t'+str(item[1]));
    i += 1
#迴圈最後寫
shopping_car = [0 for i in range(len(products))] #購物車
count = 0 #買了幾件東西
sum = 0 #花了多少錢
while True:
    id = input('請輸入待購買的商品編碼：')
    if id.isdigit():
        id = int(id)
        if id < 0 or id >len(products)-1:
            print('商品編碼超出範圍，請重新輸入。')
            continue
        else:
            shopping_car[id] += 1
            count += 1
    elif id.isalpha() and id == 'q':
        if count == 0:
            print('您未購買任何商品，歡迎下次光臨!')
        else:
            print('------您已購買------')
            i = 0
            for num in shopping_car:
                if num != 0:
                    print(products[i][0]+'\t'+str(products[i][1])+'\t'+str(num)+'個'+'\t'
                          +str(int(products[i][1])*num)+'元'+'\t')
                    sum += products[i][1]*num
                i += 1
            print('共計；'+str(sum)+'元')
        exit() #系統退出
    else:
        print('輸入格式有誤，請輸入數字。')

輸出：

------ 商品列表 ------

0 iphone 6888

1 MacPro 14800

2 xiaomi6 2499

3 Coffee 31

4 Book 60

5 Nike 699

請輸入待購買的商品編碼：1

請輸入待購買的商品編碼：2

請輸入待購買的商品編碼：5

請輸入待購買的商品編碼：3

請輸入待購買的商品編碼：3

請輸入待購買的商品編碼：w

輸入格式有誤，請輸入數字。

請輸入待購買的商品編碼：123

商品編碼超出範圍，請重新輸入。

請輸入待購買的商品編碼：q

------您已購買------

MacPro 14800 1個 14800元

xiaomi6 2499 1個 2499元

Coffee 31 2個 62元

Nike 699 1個 699元

共計；18060元

Process finished with exit code 0

元組

基本知識

寫在()中，元素不可修改，元素用逗號隔開，可重複，元素可以包含可變物件如列表。注意，定義只有一個元素的元組時，必須加逗號。

tup1 = ()
tup2 = (40) #不加逗號
tup3 = (40,) #加逗號
print(tup1)
print(type(tup2))
print(type(tup3))

輸出：

()

<class 'int'>

<class 'tuple'>

元組常見操作

訪問切片遍歷

類似列表，訪問用索引，切片區間左閉右開。

增刪改查

增

元組之間的連線是可行的。注意，這種操作其實是建立了一個新的元組。

tup1 = (1,'a',[1,23,5])
tup2 = (3,4,'b')
print(tup1+tup2)

輸出：

(1, 'a', [1, 23, 5], 3, 4, 'b')

刪

del tuple 直接刪除整個變數元組，清空了記憶體。

tup1 = (1,'a',[1,23,5])
del tup1 #直接刪除了整個元組
print(tup1)

輸出：

NameError: name 'tup1' is not defined

改

不支援每個元素的賦值。

tup1 = (1,'a',[1,23,5])
tup1[1]=2
print(tup1)

輸出：

TypeError: 'tuple' object does not support item assignment

但元組的可變元素例如列表的元素是可變的。

tup1 = (1,'a',[1,23,5])
tup1[2][0]=2
print(tup1)

輸出：

(1, 'a', [2, 23, 5])

查

見元組的訪問。

其他的一些操作

1.tuple.count(ele) 類似列表，得到重複元素個數

2.min(tuple),max(tuple),len(tuple) 類似列表

3.tuple() 把其他型別物件轉換為元組。

字典

基本知識

寫在{}中，字典是無序的物件集合，使用鍵-值對儲存，查詢速度極快。鍵必須使用不可變型別，同一個字典中，鍵必須唯一。

字典常用操作

訪問遍歷

1.使用鍵來訪問值，值內部也可以訪問。

dict1 = {1:2,'我':'你','a':[1,2,3]}
print(dict1['我'])
print(dict1['a'][1])

輸出：

你

2

直接訪問不存在的鍵，會報錯KeyError。但可以用dict.get(key)，若不存在，預設返回None。

dict1 = {1:2,'我':'你','a':[1,2,3]}
print(dict1.get('aba'))
print(dict1.get('aba','No')) #修改未找到時的預設值
print(dict1.get(1))

輸出:

None

No

2

注意，無法切片。

dict1 = {1:2,'我':'你','a':[1,2,3]}
print(dict1[0:2:1])

輸出：

TypeError: unhashable type: 'slice'

2.遍歷

直接for迴圈,keys見下的查。

dict1 = {1:2,'我':'你','a':[1,2,3]}
for key in dict1.keys():
    print(key,end = ' ')

輸出：

1 我 a

增刪改查

增

新建一個鍵值對

dict1 = {1:2,'我':'你','a':[1,2,3]}
dict1['sb']='wsnb'
print(dict1)

輸出：

{1: 2, '我': '你', 'a': [1, 2, 3], 'sb': 'wsnb'}

刪

1.del dict.[key] 直接刪除整個鍵值對。

dict1 = {1:2,'我':'你','a':[1,2,3]}
del dict1['a']
print(dict1)

輸出：

{1: 2, '我': '你'}

還可以直接刪除整個字典。

dict1 = {1:2,'我':'你','a':[1,2,3]}
del dict1
print(dict1)

輸出：

NameError: name 'dict1' is not defined

2.clear 清空整個字典的鍵值對，但字典仍存在，只是變成了空字典。

dict1 = {1:2,'我':'你','a':[1,2,3]}
dict1.clear()
print(dict1)

輸出：

{}

改

類似增，直接通過索引值修改。

查

1.鍵的查詢（類似遍歷）

dict.keys() 得到字典的所有鍵，注意：輸出為列表形式，且()不能有東西。

dict1 = {1:2,'我':'你','a':[1,2,3]}
print(dict1.keys())
print(dict1.keys(0))

輸出：

dict_keys([1, '我', 'a'])

TypeError: keys() takes no arguments (1 given)

2.值的查詢

dict.values() 類似鍵。

3.項的查詢

dict.items 得到所有的鍵值對。鍵值對儲存在元組中，元組又作為元素儲存在列表中。

dict1 = {1:2,'我':'你','a':[1,2,3]}
print(dict1.items())
print(dict1.items(1))

輸出：

dict_items([(1, 2), ('我', '你'), ('a', [1, 2, 3])])

TypeError: items() takes no arguments (1 given)

項的遍歷

1.通過for的兩個引數。

dict1 = {1:2,'我':'你','a':[1,2,3]}
for key,value in dict1.items(): #可以直接查詢每一個鍵值
    print('{}:{}'.format(key,value),end = ' ')

輸出：

1:2 我:你 a:[1, 2, 3]

2.enumerate() 列舉函式可以同時查出列表或元組的所以元素及其索引。

list1 = ['a','b','c','d'] #元組也可以
print(enumerate(list1))
for i,x in enumerate(list1): 
    print(i,x,end='---')

輸出：

<enumerate object at 0x000001F4F4944D80>

0 a---1 b---2 c---3 d---

其他

1.len(dict) 獲取字典長度，即鍵值對個數。

2.max(dict) min(dict) 獲取最大，最小的Key.

3.dict() 把其他物件（巢狀列表）轉換為字典。

dict1 = dict([(1,2),('a','b')]) #元素為元組，且要求元組長度一樣
print(dict1)

輸出：

{1: 2, 'a': 'b'}

dict1 = dict([([1,2],['a','b'])]) #元素為列表，報錯
print(dict1)

輸出：

TypeError: unhashable type: 'list'

2.dict1.update(dict2) 合併字典，dict1為合併後的字典。

dict1 = {'a':1,'b':2}
dict2 = {'c':3}
dict1.update(dict2)
print(dict1)

輸出：

{'a': 1, 'b': 2, 'c': 3}

2.dict(zip(list1,list2)) 將兩個列表轉換為字典。dict1轉換為鍵，dict轉換為值。

list1 = [1,2,3,4]
list2 = ['a','b','c','d']
dict1 = dict(zip(list1,list2))
print(dict1)

輸出：

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

若兩個列表不等長，則轉換為長度為更少列表長度的字典。

list1 = [1,2,3,4]
list2 = ['a','b','c']
dict1 = dict(zip(list1,list2))
print(dict1)
print(len(dict1))

輸出：

{1: 'a', 2: 'b', 3: 'c'}

3

集合

基本知識

寫在{}中，集合與字典類似，但集合只是鍵的集合，不儲存值。元素不能重合（可以去重），無序。就是數學上的集合概念，可以進行交集&,並集|,差集-操作。

資料種類總結

  	有序性 	可變性         

列表[] 1 1
元組() 1 0
字典{} 0 key不可變，val可變
集合{} 0 1（不重複）

4.函式

4.1概念

獨立的程式碼塊。

4.2函式的定義與呼叫

4.2.1定義函式

普通函式

#定義
def printinfo():
    print('------------------------')
    print('  人生苦短，我用python  ')
    print('------------------------')

#呼叫
printinfo()

輸出：

帶引數的函式

def average(a,b):
    c = (a + b)/2
    print(c)

print(average(1,5))

輸出：

3.0

帶返回值的函式

def average(a,b):
    return (a+b)/2

print(average(1,5))

輸出：

3.0

多個返回值

def divid(a,b):
    shang = a//b
    yushu = a%b #取餘數
    return shang,yushu

sh,yu = divid(8,3) #使用多個值來接收返回值
print(sh,yu)

輸出：

2 2

注意，range()左閉右開。

練習題

#1
def printOneLine():
    print('_'*120)

#2
import random
def printNLines(n):
    for i in range(1,int(n+1)):#答案可以使用while
        printOneLine()

printNLines(4)
#3
def sumM(a,b,c):
    x = (a+b+c)
    return x


#4
def average1(a,b,c):
    x = sumM(a,b,c)/3
    return x

4.2.2全域性變數和區域性變數

函式內部定義的變數就是區域性變數。不同的函式定義區域性變數時可以使用相同的名字。

若全域性變數與區域性變數名字一樣，則只有在呼叫函式的時候會按照區域性變數的值顯示，其他情況均是全域性變數。

a = 100 #全域性變數

def test():
    a = 300 #區域性變數
    print('函式裡的a:',a)

test()
print('函式外的a：',a)

輸出：

函式裡的a: 300

函式外的a： 100

若要在函式內修改全域性變數，需要用global var 宣告。

a = 100 #全域性變數

def test():
    global a  #宣告呼叫全域性變數
    a = 300 #區域性變數
    print('函式裡的a:',a)

test()
print('函式外的a：',a)

輸出：

函式裡的a: 300

函式外的a： 300

5.檔案操作

5.1檔案的開啟與關閉

5.1.1開啟檔案

open(檔名，訪問模式) 可以開啟一個已經存在的檔案，也可以建立一個新檔案。

f = open('隱私保護','w')#寫模式

預設在當前資料夾生成。

關閉檔案：

f = open('隱私保護','w')
f.close()

無輸出。

模式

‘w'模式

寫入檔案。

f = open('test.txt','w') #'w'寫入模式
f.write('hello,world!')#寫入字串
f.close()

'r'模式

1.read() 讀取指定的字元，開始時定位在檔案頭部，每執行一次向後移動相應的字元數。

f = open('test.txt','r') #'r'只讀模式

content = f.read(5) #讀出5個字元
print(content)

content = f.read(5) #在往後讀取五個字元
print(content)

f.close()

輸出：

hello

,worl

2.readlines() 一次性讀取全部檔案為列表，每行一個字串。

f = open('test.txt','r')

content = f.readlines() #讀出所以行，每一行作為一個元素儲存在列表中
print(content)
content = 

f.close()

輸出：

['hello,world!\n', 'hello,world!\n', 'hello,world!hello,world!\n', '\n', '\n']

還可以分行輸出：

f = open('test.txt','r')

content = f.readlines() #讀出所以行，每一行作為一個元素儲存在列表中
print(content)
#分行輸出
i = 1
for temp in content:
    print('{}:{}'.format(i,temp))
    i+=1

f.close()

輸出：

1:hello,world!

2:hello,world!

3:hello,world!hello,world!

4:

3.readline() 只能讀一行，開始從第一行讀起，每執行一次向後移動相應的行數。

f = open('test.txt','r')

content = f.readline()
print('{}:{}'.format(1,content))#讀一行
content = f.readline()
print('{}:{}'.format(2,content))#讀第二行

f.close()

輸出：

1:hello,world!--1

2:hello,world!--2

檔案的相關操作

重新命名檔案

需要引入os 模組，再使用rename(需要修改的檔名，新的檔名)

import os
os.rename('test.txt','test1.txt') #修改為了text1.txt

刪除檔案

os模組的remove(待刪除的檔名)

import os
os.remove('test.txt')

若檔案不存在，則報錯。

FileNotFoundError: [WinError 2] 系統找不到指定的檔案。: 'test.txt'

建立刪除資料夾

1.建立資料夾

import os
os.mkdir('test')#可以修改路徑，請百度

2.刪除資料夾

import os
os.rmdir('test')

獲取當前目錄

import os
print(os.getcwd())

輸出：

G:\work\python works\project1\venv

6.異常處理

異常捕獲

直接執行以下程式碼：

print('----test----1----')

f = open('123.txt','r') #只讀模式開啟一個不存在的檔案

print('----test----2----')

輸出：

----test----1----

Traceback (most recent call last):

File "G:/work/python works/project1/venv/demo1.py", line 3, in

f = open('123.txt','r') #檔案並不存在

FileNotFoundError: [Errno 2] No such file or directory: '123.txt'

可見，第一句print運行了，然後報錯。

使用try，錯誤相同時

可以被捕獲：

try:#以下程式碼可能發生問題
    print('----test----1----')

    f = open('123.txt','r') #檔案並不存在

    print('----test----2----')

except IOError: #檔案沒找到屬於IOError(輸入輸出異常)
    pass #捕獲異常後，程式碼執行到這裡

輸出：

----test----1----

並沒有報錯。

錯誤不同時

try:
    print(num) #num不存在，是NameError
except IOError:
    print('產生異常了')

輸出：

Traceback (most recent call last):

File "G:/work/python works/project1/venv/demo1.py", line 2, in

print(num)

NameError: name 'num' is not defined

若要捕獲多個異常

try:
    print(num)
    f = open('123')
except (IOError,NameError): #同時捕獲IOError和NameError
    print('產生異常了')

輸出：

產生異常了

瞭解出現什麼異常

try:
    print(num)
    f = open('123')
except (IOError,NameError) as result: #將異常資訊以字串的形式儲存在result這一變數中
    print('產生異常了')
    print(result)

輸出：

產生異常了

name 'num' is not defined

捕獲所有異常

try:
    print(num)
    f = open('123')
except Exception as result: #Exception為所有異常
    print('產生異常了')
    print(result)

輸出：

產生異常了

name 'num' is not defined

with open

with open自帶異常處理。

巢狀

finally

finally表示不管結果，一定要執行的語句。一般用於檔案開啟時中有可能出現異常時，最後關閉檔案以保護檔案。

import time
try:
    f = open('123')

    try:
        while True:
            content = f.readLine()
            if len(content) == 0:
                break
            time.sleep(2) #休眠兩秒，以便操作。
            print(content)
    finally:  #若上面的操作導致檔案中斷或異常，便可關閉來保護檔案
        f.close()
        print('檔案關閉')

except Exception as result:
    print('發生異常')

作業

最簡：