一、基本語法部分

1.簡單數據類型

1.1字符串類型及操作

字符串訪問：

1.索引訪問

mystr="Hello world"
#索引訪問
print(mystr[0])  #H
print(mystr[-1]) #d
print(mystr[-7]) #o
print(mystr[6])  #w

? 2.切片訪問

[頭下標：尾下標] ，這種訪問方式稱之為“切片”。

但注意這是左閉右開的區間。

在切片方式中，若頭下標缺省，表示從字符串的開始取子串；

若尾下標缺省，表示取到字符串的最后一個字符；

若頭下標和尾下標都缺省，則取整個字符串。

#切片訪問
print(mystr[0:5])
print(mystr[:10])
print(mystr[0:])
print(mystr[6:-1])
print(mystr[:])
'''
Hello
Hello worl
Hello world
worl
Hello world
'''

還可以設置取子字符串的順序，格式為【頭下標：尾下標：步長】。

當步長大于0的時候，從左往右取字符；當步長小于0的時候，從右往左取字符。

print(mystr[0:8:1])
print(mystr[-1:5:-1])
print(mystr[0:8:2])
print(mystr[-9:-1:1])
'''
Hello wo
dlrow
Hlow
llo worl
'''

字符串處理函數:

len(x)返回字符串長度

str(x)返回任意類型x對應的字符串形式

length=len("hello world")
print(length)  #11
string=str(134)
print(type(string),string) #<class 'str'> 134

字符串方法

1.字符串查詢（index,find)

建議使用find,若未找到匹配的字符串，index方法報異常

find(str,beg=0,end=len(string))
查找子串s第一次出現的位置，如果找到則返回相應的索引，否則返回-1

str1="my name is five.what's your name?"
str2="name"
print(str1.find(str2)) #5
print(str1.find(str2,5)) #28
print(str1.find(str2,35)) #-1

2.字符串大小寫轉換操作（upper、lower、swapcase、capitalize和title)

方法名稱	功能
upper	將字符串中所有元素都轉為大寫
lower	將字符串中所有元素都轉為小寫
swapcase	交換大小寫。大寫轉為小寫，小寫轉為大寫
capitalize	第一個大寫，其余小寫
title	每個單詞的第一次字符大寫，其余均為小寫

print(str2.upper()) #NAME
print(str2.lower()) #name
print(str2.title()) #Name

3.分割字符串（split,splitlines,partition)

方法名稱	功能
split(seq=",num=string.count(str))	以seq(默認空格)為分隔符截取字符串，如果num有指定值，則僅截取num+1個子字符串（只需num個seq分隔符）。分割后得到新列表
rsplit	與split類似，不過是從右邊開始分割
splitlines	按照行進行分割，得到新的列表
partition(str)	找到字符串中第一個str,并以str為界，將字符串分割為3部分，返回一個新的元組
rpartition(str)	與partition類似，只不過是反向找

#str1="my name is five.what's your name?"
print(str1.split()) #以空格為分割符
print(str1.split('i',1)) #以i為分割符
print(str1.split('b')) #以b為分割符
print(str1.partition("name")) #以name為分割符
print(str1.rpartition("name")) #以name為分割符，從右往左找
str="""my name is Alicewhat is Bob's name?"""
print(str.splitlines()) #以換行符為分割符

4.合并與替換（join,replace)

方法名稱	功能
join(seq)	以指定字符串作為分隔符，將seq中所有的元素（的字符串表示）合并為一個新的字符串
replace(old,new[,max])	把將字符串中的old替換成new,如果max指定，則替換不超過max次

5.字符串計數（count,len)

方法名稱	功能
count(sub,start=0,end=len(string))	在字符串[start,end)范圍內，計算sub字符串的個數
len	len不是string的方法，是內置函數，計算字符串中的字符個數

6.去除兩端多余字符操作（strip)

方法名稱	功能
Istrip(str)	去掉左邊的str字符（不是字符串），默認為空白字符
rstrip(str)	去掉右邊的str字符
strip(str)	去掉左右兩邊的str字符

1.2輸入和輸出函數

輸入：input()函數

作用：從控制臺獲取用戶的輸入，以字符串類型返回結果

獲得用戶輸入之前，input()函數可以包含一些提示性文字 ? ?<變量> = input(<提示性文字>)

a=input("請輸入一個數：")
b=input("請輸入一個數：")
print(a+b)
print(int(a)+int(b))
'''
請輸入一個數：12
請輸入一個數：34
1234
46
'''

輸出函數：print()函數

該函數可以同時輸出多個參數并使用分隔符分隔。

print()函數可以輸出各種類型變量的值

格式化字符串方法：

1） print()函數通過%來選擇要輸出的變量類型—最早引入一種方法 ?

格式化字符串中變化的部分使用占位符

變量以元組形式提供

變量與格式化字符串之間以%連接

格式的字符串（即%s）與被格式化的字符串（即傳入的值）必須按照位置一一對應，

缺點：當需格式化的字符串過多時，位置極容易搞混

2）str.format 內建函數 ? ? ?

該format函數是在python2.6以后引入的，是字符類型的內置方法。因為str.format的方式比%在性能和靈活性上更好一些。 ?

1.使用位置參數：按照位置一一對應

first_name='bruce'
last_name='wu'
message="Hello {} {}.".format(first_name,last_name)
print(message)#Hello bruce wu.

2.按照索引匹配對應的值

first_name='bruce'
last_name='wu'
message="Hello {1} {0}.".format(first_name,last_name)
print(message)#Hello wu bruce.

3.按照關鍵字指定對應的值

print('我來自{place},我的年齡是{age}。'.format(place='中國',age=18))
#我來自中國,我的年齡是18。

3）f-String

由python3.6版本引入的一個特性，稱之為字面量格式化字符串

以F或者f開頭，后面跟字符串，字符串中的表達式用大括號{ }包起來，

它會將變量或表達式計算后的值替換進去

first_name='bruce'
last_name='wu'
message=f"Hello {last_name} {first_name}."
print(message)#Hello wu bruce.

eval（）函數

它能夠以Python表達式的方式解析并執行字符串， 將返回結果輸出

1、計算字符串中有效的表達式，并返回結果

print('5+2')
print(eval('5+2'))
print(eval('pow(2,2)'))
x=5
print(eval('x+2'))
'''5+2
7
4
7'''

2、將字符串轉成相應的對象（如list、tuple、dict和string之間的轉換）

1.3 數：整數和浮點數

可在數中添加下劃線使大數更易讀

基本算術運算：

除（/）：任意兩個數相除時，結果總是浮點數

雙斜杠（//）：表示整數除法，取兩數的整數商

雙乘號（**）：表示乘方運算

求模運算（%） ，計算取整除法的余數

注：浮點數計算時，結果包含的小數位數可能是不確定的。

保留浮點數小數位數的幾種常見方法：

1.使用round（）函數

2.使用字符串格式化

3.使用字符串的f-string格式化

4. 使用format（）函數

5.使用decimal模塊

number=3.1415926
round_number=round(number,2)
print(round_number)
format_number='{:.2f}'.format(number)
print(format_number) #3.14
f_string_number=f'{number:.2f}'
print(f_string_number) #3.14
format_fun_number=format(number,'.2f')
print(format_fun_number) #3.14
from decimal import *
decimal_number=Decimal(number)
decimal_number1=decimal_number.quantize(Decimal('0.00'),rounding=ROUND_HALF_UP)
print(decimal_number) #3.1415926
print(decimal_number1) #3.14

round( ) 函數 ? ?

round(a, b) 函數

返回浮點數 a 小數點后 b 位的四舍五入值，當 b 省略時 a 取整。

內置的數字運算函數

函數	描述
abs(x)	絕對值
divmod(x,y)	(x//y,x%y),輸出為二元組形式
pow(x,y[,z])	(x**y)%z
round(x[,n])	四舍五入，保留n位小數
max(a,b,Z..…)	求最大值
min(a,b,Z...…)	求最小值

內置的數字類型的轉換函數

?int(x)==>把x轉換成整數，x可以是浮點數、字符串、整數、分數 ? ? ? ? ? ? ? ?

float(x)==>返回浮點數或字符串所對應的整數類型 ? ? ? ? ? ? ? ?

complex（re [,im])==>生成一個復數，re+im j，re可以是整數、浮點數、字符串，im不能是字符串。

Math庫

導入方法： import math from math import * #*表示函數名

math.fabs(x) ：返回x的絕對值

math.fsum([x,y...]):浮點數精確求和

math.cell(x):向上取整

math.floor(x)：向下取整

math.pow(x,y):返回x的y次冪

math.sqrt(x)：返回x的平方根

1.4 Python運算符與表達式

*運算符除了表示算術乘法，還可用于列表、元組、字符串這幾個序列類型與整數的乘法，表示序列元素的重復，生成新的序列對象。

字典和集合不支持與整數的相乘，因為其中的元素是不允許重復的。

成員測試運算符in用于成員測試，即測試一個對象是否為另一個對象的元素。

同一性測試運算符is用來測試兩個對象是否是同一個，如果是則返回True，否則返回False。

如果兩個對象是同一個，二者具有相同的內存地址。

2.Python可迭代對象

2.1、List（列表）

在形式上，列表的所有元素放在一對方括號[]中，

相鄰元素之間使用逗號分隔，元素之間可以沒有任何關系。

可以使用list(可迭代對象)函數把

元組、range對象、字符串、字典、集合或其他有限長度的可迭代對象轉換為列表。

當一個變量不再使用時，可以使用del命令將其刪除，這一點適用于所有類型的變量

創建列表之后，可以使用整數作為下標來訪問其中的元素，其中0表示第1個元素，1表示第2個元素，2表示第3個元素，以此類推；列表還支持使用負整數作為下標，其中-1表示最后1個元素，-2表示倒數第2個元素，-3表示倒數第3個元素，以此類推

（1）添加元素：append()、insert()、extend()

append(val)用于向列表尾部追加一個元素，

insert(index,val)用于向列表任意指定位置插入一個元素，

extend(iterable)用于將參數可迭代對象中的所有元素追加至當前列表的尾部，對當前列表元素進行批量增加

這3個方法都屬于原地操作，不影響列表對象在內存中的起始地址。

x=[1,2,3]
x.append(4)
x.insert(0,0)
x.extend([5,6,7])
print(x) #[0, 1, 2, 3, 4, 5, 6, 7]

（2）刪除元素：pop()、remove()、clear()

pop(index): 用于刪除并返回指定位置（默認是最后一個）上的元素；

remove(value): 用于刪除列表中第一個值與指定值相等的元素；

clear(): 用于清空列表中的所有元素。

del : 刪除列表中指定位置的元素

這4個方法也屬于原地操作。

x=[1,2,3,4,5,6,7]
x.pop()#彈出最后一個元素
x.pop(0) #彈出第一個元素
x.clear()
print(x) #[]
x=[1,2,1,1,2]
x.remove(2) #刪除第一個2
del x[3]
print(x) #[1, 1, 1]

（3）統計元素：count()、index()

count()用于返回列表中指定元素出現的次數；

index()用于返回指定元素在列表中首次出現的位置，如果該元素不在列表中則拋出異常。

（4）排序和反轉：sort()、reverse()

?lst.sort() ：永久修改原列表，對其中的元素進行排序。

sorted(lst) -> lst'：返回排序后的列表的副本。? 原列表不變

reverse()：永久修改原列表，對其中的元素進行翻轉

（5）獲取列表的長度： len() 函數

? len(lst) -> num：獲取列表的元素個數。

（6）copy()方法

copy()方法返回當前列表的淺復制，返回包含原列表中所有元素的引用的新列表。

標準庫copy中的deepcopy()函數可以實現深復制，對原列表中的元素的引用進行復制，

如果元素是容器對象就遞歸對其中的元素進行復制。深復制得到的對象與原來的對象完全獨立。

把同一個列表賦值給兩個變量時，這兩個變量的引用不同，得到兩個不同的列表，

但有可能兩個列表中的元素具有相同的引用。

直接把一個變量賦值給另一個變量時，兩個變量引用同一個對象（=）

內置函數對列表的操作

max()、min()函數用于返回列表中所有元素的最大值和最小值

sum()函數用于返回列表中所有元素之和?

len()函數用于返回列表中元素個數

zip()函數用于將多個列表中元素重新組合為元組并返回包含這些元組的zip對象

enumerate()函數返回包含若干下標和值的迭代對象

map()函數把函數映射到列表上的每個元素

filter()函數根據指定函數的返回值對列表元素進行過濾

all()函數用來測試列表中是否所有元素都等價于True

any()用來測試列表中是否有等價于True的元素

標準庫functools中的reduce()函數以及標準庫itertools中的compress()、groupby()、dropwhile()等大量函數也可以對列表進行操作。

Python高階函數使用

1.Lambda函數：創建匿名函數，即沒有名稱的函數。它只是一個表達式，函數體簡潔。

語法：lambda arguments(參數) : expression(表達式)

func1=lambda a,b:a+b
result=func1(2,6)
print("result=",result)

2.Map函數：根據提供的函數對指定序列做映射

語法：map(function, iterable, ...) 其中，function -- 函數，iterable -- 一個或多個序列

lst=[1,2,3,4,5]
result=map(lambda x:x*2,lst)
print(result,list(result)) #<map object at 0x0000020A0B0F0EA0> [2, 4, 6, 8, 10]

3.Reduce函數：當需要對一個列表進行一些計算并返回結果時，reduce()是個非常有用的函數，如求和，求階乘之類的。

需要引入functools模塊來調用 reduce()函數：from functools import reduce

語法： ? ? ?

reduce(function, iterable[, initializer])， ? ? ? ? ?

其中參數function -- 函數，有兩個參數；iterable -- 可迭代對象；initializer -- 可選，初始參數 reduce將函數作用在一個列表上，映射函數接收了兩個參數，reduce()把結果繼續和列表的下一個元素做累加計算

4.enumerate函數

enumerate()函數用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在for循環當中

語法：enumerate(iterable, start=0)

它的兩個參數，一個是序列、迭代器或其他支持迭代對象；另一個是下標起始位置，默認情況從0開始

5.Zip函數

語法：zip（可迭代對象，.....）

zip()函數用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表

當我們使用zip()函數時，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同

print(list(zip(range(1,4)))) #[(0, 1), (1, 2), (2, 3)]
print(list(zip(['a','b','c'],[1,2]))) #[('a', 1), ('b', 2)]

6. Filter函數

filter()函數用于過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表

語法: filter(function, iterable)

其中，function -- 判斷函數；iterable -- 可迭代對象。

返回filter object 迭代器對象

7.sorted函數：可以對序列進行排序，默認是升序，使用reverse參數調整排序方向，使用key參數，可以將序列中的元素按key參數指定的方法執行。

2.2、Tuple（元組）

從形式上，元組的所有元素放在一對圓括號中，元素之間使用逗號分隔，

如果元組中只有一個元素則必須在最后增加一個逗號。

定義后元組中元素的數量和引用不允許改變。

>>> x = (1, 2, 3) ? ? ? # 直接把元組字面值賦值給一個變量

>>> type(x) ? ? ? ? ? ? # 使用type()函數查看變量類型

<class 'tuple'>

>>> x[0] ? ? ? ? ? ? ? ?# 元組支持使用下標訪問特定位置的元素

1

>>> x[-1] ? ? ? ? ? ? ? # 最后一個元素，元組也支持雙向索引

3

>>> x[1] = 4 ? ? ? ? ? ?# 元組是不可變的

TypeError: 'tuple' object does not support item assignment

>>> x = 3, ? ? ? ? ? ? ?# 真正創建元組的是逗號，圓括號只是輔助

>>> x

(3,)

很多內置函數的返回值也是包含了若干元組或者可以生成若干元組的可迭代對象，例如enumerate()、zip()等等。

print(list(enumerate(range(5))))#[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
print(list(zip(range(3),'abcdefg')))#[(0, 'a'), (1, 'b'), (2, 'c')]

元組屬于不可變（immutable）序列，一旦定義，其元素的數量和引用都是不可變的，不可以直接修改元組中元素的引用，也無法為元組增加或刪除元素。

元組沒有提供append()、extend()和insert()等方法，無法向元組中添加元素；同樣，元組也沒有remove()和pop()方法，也不支持對元組元素進行del操作，不能從元組中刪除元素。

元組也支持切片操作，但是只能通過切片來訪問元組中的元素，不允許使用切片來修改元組中元素的值，也不支持使用切片操作來為元組增加或刪除元素。

2.3、Dictionary（字典）

dictionary（字典） 是 除列表以外 Python 之中 最靈活 的數據類型

字典同樣可以用來 存儲多個數據

通常用于存儲 描述一個 物體 的相關信息

和列表的區別

列表 是 有序 的對象集合

字典 是 無序 的對象集合

字典用 {} 定義 字典使用 鍵值對 存儲數據，鍵值對之間使用 , 分隔

鍵 key 是索引

值 value 是數據

鍵 和 值 之間使用 : 分隔

鍵必須是唯一的

值 可以取任何數據類型，但 鍵 只能使用 字符串、數字或 元組

1.使用賦值運算符“=”將一個字典賦值給一個變量即可創建一個字典變量。

>>> aDict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}

2. 也可以使用內置類dict以不同形式創建字典。

>>> x = dict() ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? # 空字典

>>> type(x) ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?# 查看對象類型

<class 'dict'>

>>> x = {} ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? # 空字典

>>> keys = ['a', 'b', 'c', 'd']

>>> values = [1, 2, 3, 4]

>>> d = dict(zip(keys, values)) ? ? ? ? ? ? ?# 根據已有數據創建字典

>>> d = dict(name='Dong', age=39) ? ? ? ? ? ?# 以關鍵參數的形式創建字典

>>> d = dict.fromkeys([3, 5, 7], []) ? ? ? # 所有元素的“值”引用同一個空列表

>>> d

{3: [], 5: [], 7: []}

>>> d[3].append(666) ? ? ? ? ? ? ? ? ? ? ? # 所有元素的“值”都是一樣的

>>> d

{3: [666], 5: [666], 7: [666]}

>>> d[3] = 999 ? ? ? ? ? ? ? ? ? ? ? ? ? ? # 修改一個元素“值”的引用 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? # 此后和其他的“值”再也沒有關系了

>>> d

{3: 999, 5: [666], 7: [666]}

3.還可以使用字典推導式來創建字典。

>>> {num: chr(num) for num in range(97, 103)}

{97: 'a', 98: 'b', 99: 'c', 100: 'd', 101: 'e', 102: 'f'}

1. 字典中的每個元素表示一種映射關系或對應關系，根據提供的“鍵”作為下標就可以訪問對應的“值”，如果字典中不存在這個“鍵”會拋出異常。

2.可以使用選擇結構或異常處理結構來避免“鍵”不存在時代碼崩潰拋出異常。

3.字典對象提供了一個get()方法用來返回指定“鍵”對應的“值”，并且允許指定該鍵不存在時返回特定的“值”。

4.使用字典對象的items()方法可以返回字典的鍵、值對，keys()方法可以返回字典的鍵，values()方法可以返回字典的值。

當以指定“鍵”為下標為字典元素賦值時，有兩種含義：

1）若指定的“鍵”存在，表示修改該“鍵”對應的值；

2）若指定的“鍵”不存在，表示添加一個新的“鍵:值”對，也就是添加一個新元素。

使用字典對象的update()方法可以將另一個字典的“鍵:值”元素一次性全部添加到當前字典對象中，如果兩個字典中存在相同的“鍵”，則以另一個字典中的“值”為準。

如果需要刪除字典中指定的元素，可以使用del命令。

也可以使用字典對象的pop()和popitem()方法刪除元素

2.4、Set（集合）

集合（set）屬于Python無序可變容器對象，使用一對大括號作為定界符，元素之間使用逗號分隔，同一個集合內的每個元素都是唯一的，元素之間不重復。

集合中只能包含數字、字符串、元組等不可變類型（或者說可哈希）的數據，不能以任何形式包含列表、字典、集合等可變類型的數據。

1.直接將集合字面值賦值給變量即可創建一個集合對象

2.也可以使用函數set()函數將列表、元組、字符串、range對象或其他有限長度的可迭代對象轉換為集合，并自動去除重復元素；如果原可迭代對象中有不可哈希的值，無法轉換成為集合，拋出異常。

3.還可以使用集合推導式創建集合

（1）集合元素增加與刪除

使用集合對象的add()方法可以增加新元素，如果該元素已存在則忽略該操作，不會拋出異常； update()方法用于合并另外一個或多個集合中的元素到當前集合中，并自動去除重復元素；

>>> s = {1, 2, 3}

>>> s.add(3) ? ? ? ? ? ? ? ? ? ? ? ? ?# 添加元素，重復元素自動忽略

>>> s

{1, 2, 3}

>>> s.update({3,4}) ? ? ? ? ? ? ? ? ? # 更新當前字典，自動忽略重復的元素

>>> s

{1, 2, 3, 4}

pop()方法用于隨機刪除并返回集合中的一個元素，如果集合為空則拋出異常；

remove(value)方法用于刪除集合中的元素，如果指定元素不存在則拋出異常；

discard(value)用于從集合中刪除一個特定元素，如果元素不在集合中則忽略該操作；

clear()方法清空集合刪除所有元素。

可以使用集合快速提取序列中單一元素，即提取出序列中所有不重復元素

2.5、列表推導式

列表推導式使用非常簡潔的方式來快速生成滿足特定需求的列表，對原可迭代對象中的元素進行計算或過濾，代碼具有非常強的可讀性。

列表推導式語法形式為： [expression for expr1 in sequence1 if condition1 ? ? ? ? ? ?

???????????????????????????????????????????????????????????for expr2 in sequence2 if condition2 ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?for expr3 in sequence3 if condition3 ? ? ? ? ? ?

???????????????????????????????????????????????????????????... ? ? ? ? ? ?

??????????????????????????????????????????????????????????for exprN in sequenceN if conditionN]

列表推導式在邏輯上等價于一個循環語句，只是形式上更加簡潔，但代碼執行效率并不比循環結構高。

>>> aList = [x*x for x in range(10)]

相當于

>>> aList = []

>>> for x in range(10): ? ?

????????aList.append(x*x)

2.6、列表切片

切片用來訪問有序序列中的部分元素。在形式上，切片使用2個冒號分隔的3個數字來完成。 [start:end:step]

第一個數字start表示切片開始位置，默認為0；

第二個數字end表示切片截止（但不包含）位置（默認為列表長度）；

第三個數字step表示切片的步長（默認為1）。

當start為0時可以省略，當step為1時可以省略，省略步長時還可以同時省略最后一個冒號；step為正整數時省略end表示一直切到最后一個元素，step為負整數時省略end表示一直切到第一個元素。

step為負整數時表示反向切片，這時start應該在end的右側才行，否則返回結果為空。

（1）使用切片獲取列表部分元素 ? ? ? ? ?

使用切片可以返回列表中部分元素組成的新列表，其中包含原列表中部分元素的引用。與使用索引作為下標訪問列表元素的方法不同，切片操作不會因為下標越界而拋出異常，而是簡單地截斷或者返回一個空列表，代碼具有更強的健壯性。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::] ? ? ? ? ? ? ?# 返回包含原列表中所有元素的新列表

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::-1] ? ? ? ? ? ?# 返回包含原列表中所有元素的逆序列表

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

>>> aList[::2] ? ? ? ? ? ? # 從下標0開始，隔一個取一個，獲取偶數位置的元素

[3, 5, 7, 11, 15]

>>> aList[1::2] ? ? ? ? ? ?# 從下標1開始，隔一個取一個，獲取奇數位置的元素

[4, 6, 9, 13, 17]

>>> aList[3:6] ? ? ? ? ? ? # 返回下標[3,6)之間的元素

[6, 7, 9]

>>> aList[0:100] ? ? ? ? ? ? # 切片結束位置大于列表長度時，從列表尾部截斷

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[100] ? ? ? ? ? ? ? # 拋出異常，不允許越界訪問

IndexError: list index out of range

>>> aList[100:] ? ? ? ? ? ? ?# 切片開始位置大于列表長度時，返回空列表

[]

>>> aList[-15:3] ? ? ? ? ? ? # 起始位置小于左邊界，在開始處截斷

[3, 4, 5]

>>> len(aList)

10

>>> aList[3:-10:-1] ? ? ? ? ?# 位置3在位置-10的右側，-1表示反向切片

[6, 5, 4]

>>> aList[3:-5] ? ? ? ? ? ? ?# 位置3在位置-5的左側，正向切片

[6, 7]

（2）使用切片為列表增加元素 可以使用切片操作在列表任意位置插入新元素，不影響列表對象的內存地址，屬于原地操作。切片在等號左側時用來標記位置，并沒有真的切出來。

>>> aList = [3, 5, 7]

>>> aList[len(aList):]

[]

>>> aList[len(aList):] = [9] ? ? ? # 在列表尾部增加元素

>>> aList[:0] = [1, 2] ? ? ? ? ? ? # 在列表頭部插入多個元素

>>> aList[3:3] = [4] ? ? ? ? ? ? ? # 在列表中間位置插入元素

>>> aList

[1, 2, 3, 4, 5, 7, 9]

（3）使用切片替換和修改列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = [1, 2, 3] ? ? ? ? ? # 替換列表元素，等號兩邊的列表長度相等

>>> aList

[1, 2, 3, 9]

>>> aList[3:] = [4, 5, 6] ? ? ? ? ? # step=1時等號兩邊的列表長度可以不相等

>>> aList

[1, 2, 3, 4, 5, 6]

>>> aList[::2] = [0] * 3 ? ? ? ? ? ?# 隔一個修改一個，切片步長不為1 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

?????????????????????????????????????????????# 此時等號兩邊的元素數量必須相等

>>> aList [0, 2, 0, 4, 0, 6]

>>> aList[::2] = ['a', 'b', 'c'] ? ?# 隔一個修改一個，等號兩側長度相等

>>> aList

['a', 2, 'b', 4, 'c', 6]

（4）使用切片刪除列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = [] ? ? ? ? ? ? ? ? ?# 刪除列表中前3個元素，切片步長必須為1

>>> aList

[9]

也可以結合使用del命令與切片結合來刪除列表中的部分元素，此時切片可以不連續，不要求step必須為1。

>>> aList = [3, 5, 7, 9, 11]

>>> del aList[:3] ? ? ? ? ? ? ? ? ? # 切片元素連續

>>> aList

[9, 11]

3.Python函數

3.1 函數定義

在Python中函數定義語法如下：

def ?function_name(arg1,arg2[,...])： ?

????????statement ?

????????[return value]

函數參數和返回值不是必須的，如果沒有return語句，則Python函數默認返回值為None 。

3.2 函數參數

實參和形參

def greet_user(username):"""顯示簡單問候語"""print(f"Hello,{username.title()}!")
greet_user('jesse')

形參（parameter）：username，即函數完成工作所需的信息。

實參（argument） ：'jesse' ，即在調用函數時傳遞的信息。

單向傳遞：在函數內部直接修改形參的引用不會影響實參

雙向傳遞：可以通過下標或可變對象自身提供的原地修改方法在函數內部修改實參的值

也就是說，如果傳遞給函數的實參是可變對象，并且在函數內部使用下標或可變對象自身的方法增加、刪除元素或修改元素時，實參也得到相應的修改

位置實參：基于實參的順序進行關聯

關鍵字實參：基于名稱將值進行關聯，函數不會混淆，不需要考慮參數順序

在編寫函數時，可以給每個形參指定默認值，稱為可選參數，必須定義在非可選參數的后面

形參---可變長度參數

可變長度參數主要有兩種形式：定義函數時在形參名稱前面加1個或2個星號。

*parameter用來接收多個位置參數并將其放在一個元組中，元組長度取決于實際接收的位置參數個數；

**parameter用來接收多個關鍵參數并存放到一個字典中，字典中元素個數取決于實際接收的關鍵參數個數。

?函數形參數分類

形式參數：def ?function(arg1,arg2,…)

關鍵字參數：def ?function(arg=value,…)

元組參數：def ?function(*arg)

字典參數：def ?function(**arg)

參數使用規則： 關鍵字參數必須在形式參數之后；

????????????????????????在單個函數定義中，只能使用一個tuple參數（*arg）和一個字典參數（**arg）； ?

????????????????????????tuple 參數必須在連接形式參數和關鍵字參數之后；

????????????????????????字典參數必須在所有其它參數最后定義。

函數返回值

總結：函數返回元組值，或者空元組，或者None。

4.類與對象定義

聲明類

（1）構造函數——綁定數據

class Coordinate(object):def __init__(self,x,y):self.x=xself.y=yself.name=None

所有的實例變量都應在構造函數內賦值（初始化），除了self參數不需要賦值。 前兩句綁定傳入的數據。由于沒有傳入與name有關的數據，將name賦值為None。

（2）創建實例

class Coordinate(object):def __init__(self,x,y):self.x=yself.y=xself.name=None
data1=Coordinate(1,2)
print(data1.x,data1.y) #2 1

（3）直接訪問和修改內部數據

print(data1.x,data1.y) #2 1
data1.x=10
print(data1.x,data1.y) #10 1