Python學習之Second_Week Notes

# 數據結構分類：
數值型：
int、float、complex、bool

序列對象：
字符串：str
列表：list
tuple：

鍵值對：
集合：set
字典：dict

## 分類詳解：

數值型：

1、int、float、complex、bool都是class

2、int：python3的int就是長整型，且沒有大小限制，受限于內存區域的大小

3、float：有整數部分和小數部分組成。支持十進制和科學計數法表示。只有雙精度型。

4、complex：有實數和虛數部分組成，實數和虛數部分都是浮點數，3+4.2j

5、bool：int的子類，僅有兩個實例True、False對應1和0，可以和整數直接運算
類型轉換(built-in):

int(x)：返回一個整數
float(x)：返回一個浮點數
complex(x)、complex(x,y)：返回一個復數
bool(x)：返回布爾值，False=0，True=1

## 數字的處理函數：
1、round()：四舍五入，四舍六入五取偶
model：
round(4.6) 5
round(3.5) 4
round(4.5) 4

2、floor()地板、ceil()天花板
即一個向下取，一個向上取
model：
import math
math.ceil(2.5)
>>>3
math.floor(2.5)
>>>2

3、int()：取整數部分，和//整除一樣
model：
int(2.9)
>>>2

4、min():
取出最小的值
model:
min(1,8,2,0)
>>>0

5、max()：
取出最大值
max(1,8,2,0)
>>>8

6、pow(x,y)等于x**y：
pow(x,y)：返回的是x的y次方，如果是pow(x,y[,z]),其效果就等于x**Y % z
注意：pow() 通過內置的方法直接調用，內置方法會把參數作為整型，而 math 模塊則會把參數轉換為float
pow(2,4)
>>>16

pow(2,4,3)
>>>1

pow(2,4,4)
>>>0

7、math.sqrt()：
sqrt():返回數字的平方根

math.sqrt(16)
>>>4.0

8、進制函數
1、bin():二進制

2、oct()：八進制

3、hex()：十六進制

9、math.pi ：
數學常量 pi（圓周率，一般以π來表示）
math.pi
>>>3.141592653589793

10、math.e：
自如常數
math.e
>>>2.718281828459045

## 類型判斷：
1、type(obj)，返回類型，而不是字符串
type(1)
>>>int
type(1+True)
>>>int
type(1+True+2.0)
>>>float

2、isinstance(obj,class_or_tuple)
model：
isinstance(‘a’,str)
>>>True
isinstance(6,(str,bool,int))
>>>True

# 列表list

1、一個隊列，一個排列整齊的隊伍

2、列表內的個體稱作元素，有若干個元素組成列表

3、元素可以是任意對象(數字、字符串、對象、列表等)

4、列表內元素有順序，可以使用索引

5、線性的數據結構

6、使用[]表示

7、列表是可變的

8、列表list、鏈表、queue、stack(棧)的差異

a、鏈表：鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。

b、queue：隊列是一種特殊的線性表，是一種先進先出（FIFO）的數據結構。它只允許在表的前端（front）進行刪除操作，而在表的后端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。

c、stack：棧（stack）在計算機科學中是限定僅在表尾進行插入或刪除操作的線性表。

列表list定義 初始化

list()->new empty list

list(iterable)->new list initialized from iterable’s iterms
列表不能一開始就定義大小

l1 = list()
l1 = []
l1 = [2,6,9,’ab’]
l1 = list(range(5))

列表索引訪問：

1、索引也叫下標

2、正索引：從左至右，從0開始，為列表中每一個元素編號
l1
>>>[4, 7, 2, 1, 5, 9]
l1[0]
>>>4

l1[1]
>>>7

3、負索引：從右至左，從-1開始

l1[-1]
>>>9

l1[-2]
>>>5

4、正負索引不可以超界，否則引發異常IndexError
l1[6]
IndexError: list index out of range

5、為了理解方便，可以認為列表是從左至右排列的，左邊是頭部，右邊是尾部，左邊是下界，右邊是上界

6、列表通過索引訪問
a、list[index],index就是索引，使用中括號訪問

# 列表查詢
1、index(value,[start,[stop]])
a、通過值value，從指定區間查找列表內的元素是否匹配
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]

l1.index(7,2,7)
>>>6

b、匹配第一個就立即返回索引

c、匹配不到，拋出異常ValueError
l1.index(7,2,6)
>>>ValueError: 7 is not in list

2、count(value)
返回列表中匹配value的次數
l1.count(7)
>>>4

3、時間復雜度
a、index和count方法都是O(n)
b、隨著列表數據規模的增大，而效率下降

4、len()：返回元素的個數
len(l1)
>>>10

# 列表元素修改
索引訪問修改：
1、list[index] = value
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]
l1[1]=0
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7]
2、索引不要超界

# 列表增加、插入元素
append(object)->None
1、列表尾部追加元素，返回None
l1.append(100)

l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]

lst.append(9)

lst
>>>[1, 2, 3, 2, 2, 5, 2, 9]

a = lst.append(10)
type(a)
NoneType
print(a)
返回None

2、返回None就意味著沒有新的列表產生，就地修改
3、時間復雜度是O(1)

insert(index，object)->None
1、在指定的索引index處插入元素object
2、返回None就意味著沒有新的列表產生，就地修改
3、時間復雜度是O(1)
4、索引能超上下界嗎？
超越上界，尾部追加
超越下界，頭部追加

extend(iteratable)->None
1、將可迭代對象的元素追加進來，返回None
2、就地修改

+->list
1、連接操作，將兩個列表連接起來
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
l3
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100, 10, 11, 18, 14]
2、產生新的列表，原列表不變
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
3、本質上調用的是__add__()方法

*->list
1、重復操作，將本列表元素重復n次，返回新的列表

l4 = 2*l2
l4
[10, 11, 18, 14, 10, 11, 18, 14]

# 列表刪除元素
remove(value)->None
1、從左至右查找第一個匹配value的值，移除該元素，返回None
l4.remove(11)
l4
[10, 18, 14, 10, 11, 18, 14]

2、就地修改
3、效率？

pop([index])->item
1、不指定索引index，就從列表尾部彈出一個元素
l4.pop()
>>>14

l4
[10, 18, 14, 10, 11, 18]
2、指定索引index，就從索引處彈出一個元素，索引超界拋出IndexError錯誤
3、效率？指定索引的時間復雜度？不指定索引呢？

clear()->None
清除列表所有元素，剩下一個空列表
l3.clear()
l3
>>>[]

# 列表其它操作
reversed()->None
1、將列表元素反轉，返回None
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l1.reverse()
l1
>>>[100, 7, 3, 7, 7, 9, 5, 1, 2, 0, 4]

2、就地修改

sort(key=None,reverse=False)->None
1、對列表元素進行排序，就地修改，默認升序
l1.sort()
l1
>>>[0, 1, 2, 3, 4, 5, 7, 7, 7, 9, 100]

2、reverse為True，反轉，降序
l1.sort(reverse=True)
l1
>>>[100, 9, 7, 7, 7, 5, 4, 3, 2, 1, 0]

3、key是一個函數，指定key如何排序
lst.sort=(key=functionname)

in：
[3,4]in [1,2,[3,4]]
for x in [1,2,3,4]
lst0 = list(range(4))
id(lst0)
hash(id(lst0))

lst1 = list(range(4))
id(lst1)

lst0 == lst1 取值比較,內容
True

lst0 is lst1 取id，就是內存地址比較
False

lst1 = lst2
lst2[2] =10

lst0 = [1,[2,3,4],5]
lst5 = lst0.copy()
lst0[1][1]= 20
那么lst0 == lst5為True，因為里面拷貝的為內存 地址

列表復制：
1、copy()->List
l1
>>>[100, 9, 7]
l2 = l1.copy()
l2
>>>[100, 9, 7]

l1 == l2
True

shadow copy返回一個新的列表
2、shadow copy
影子拷貝，也叫淺拷貝，遇到引用類型，只是復制了一個引用而已
3、深拷貝
copy模塊提供了deepcopy

# 隨機數
1、random模塊
random.choice([1,2,3,4,5])
random.randint(0,1)
2、randint(a,b)返回[a,b]之間的整數
3、choice(seq)從非空序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。random.choice([1,3,5,7])
4、randrange([start,]stop[,step])從指定范圍內，按指定基數遞增的集合中獲取一個隨機數，基數缺省值為1.random.randrange(1,7,2)
5、random.shuffle(list)->None就地打亂列表元素

# 時間復雜度：
index和count方法都是O(n)
效率最高的是O(1)1表示為常數
最低的是O(n**2)

pass占位語句

 

tuple：
一個有序的序列，不可變
可以重復元素
所謂無序就是定義的順序和打印的順序不一樣,但是可以遍歷
可迭代對象構建：t=tuple(range(1,7,2))
t1= (1,)

轉義：兩個同符號或者\

0920練習：
元組tuple：
1、一個有序的元素組成的集合
2、使用小括號()表示
3、不可變對象

 

定義：
t = tuple()–空元組
t=()

“`
In [22]: t=tuple(range(1,9,2))

In [23]: t
Out[23]: (1, 3, 5, 7)
“`

In [24]: t = (2,4,6,1,7,9)

In [25]: t[1]
Out[25]: 4

單個元素的元組的定義：
t = (1,)
In [30]: type(t)
Out[30]: tuple

下面的做法是錯誤的：
In [27]: t = (1)

In [28]: type(t)
Out[28]: int

乘法的使用：
In [31]: t1 = t*5

In [32]: t1
Out[32]: (1, 1, 1, 1, 1)

訪問：支持索引
In [35]: t1 = (1,2,6,8,0)

In [36]: t1[1]
Out[36]: 2

In [37]: t[-1]
Out[37]: 1

一旦定義，不可以修改，否則，就生成新的列表

tuple.index(value,[start,[stop]])

生成新的元組，可以使用：
In [44]: t = tuple(range(1,9,3))

In [45]: t
Out[45]: (1, 4, 7)
注：一定要使用tuple(range(x))，否則無法創建成功

In [47]: t.index(4,1,3)
Out[47]: 1
如果使用t.index(4,2,3),就會報議程錯誤，因為匹配不到

匹配次數：
In [48]: t.count(4)
Out[48]: 1

元組中元素的個數：
In [49]: len(t)
Out[49]: 3

# 因為元組是不可變的，所以不支持增刪改

命名元組：
form collections import namedtuple

In [50]: from collections import namedtuple

In [51]: Point = namedtuple(‘_Point’,[‘x’,’y’])

In [52]: p = Point(89,24)

In [53]: p.x
Out[53]: 89

In [54]: p.y
Out[54]: 24

In [55]: Student = namedtuple(‘Student’,’name age’)

In [56]: tom = Student(‘tom’,20)

In [57]: jerry = Student(‘jerry’,18)

In [58]: tom.name
Out[58]: ‘tom’

In [59]: tom.age
Out[59]: 20

冒泡排序：
num_list = [1,2,3,4,5,6,7,9,8]
length = len(num_list)
count_swap = 0
count = 0

for i in range(length):
flag = False
for j in range(length-i-1):
count += 1
if num_list[j] > num_list[j+1]:
tmp = num_list[j]
num_list[j] = num_list[j+1]
num_list[j+1] = tmp
flag = True
count_swap += 1
if not flag:
break
print(num_list,count_swap,count)

 

字符串：
1、一個個字符組成的有序的序列，是字符的集合
2、使用單引號、雙引號、三引號引住的字符序列
3、字符串是不可變對象

In [60]: s1 = ‘abc’

In [61]: s2 = “telephone”

In [62]: s3 = ”’My telephone number is “13938495980””’

In [67]: s1
Out[67]: ‘abc’

In [68]: s2
Out[68]: ‘telephone’

In [69]: s3
Out[69]: ‘My telephone number is “13938495980”‘

 

 

In [63]: s4 = ‘My name \n is Eric’

In [64]: s4
Out[64]: ‘My name \n is Eric’

 

In [70]: s5 = r”My name \n is Eric”

In [71]: s5
Out[71]: ‘My name \\n is Eric’

In [72]: s6 = ‘c:\windows\nt’

In [73]: s6
Out[73]: ‘c:\\windows\nt’

 

In [74]: s6 = R”c:\windows\nt”

In [75]: s6
Out[75]: ‘c:\\windows\\nt’

 

In [76]: s8 = ‘c:\windows\\nt’

In [77]: s8
Out[77]: ‘c:\\windows\\nt’

 

In [78]: sql = “””select * from user where name=’root'”””

In [79]: sql
Out[79]: “select * from user where name=’root'”
In [80]: sql[4]
Out[80]: ‘c’

 

In [82]: for c in sql:
…: print(c)
…: print(type(c))
…:
s
<class ‘str’>
e
<class ‘str’>
……

 

可以迭代：
lst = list(sql)

星號標記課件：
“string”.join(iterable)->str
1、使可迭代的對象連接起來，使用string作為分隔符
2、可迭代對象本身元素都是字符串
3、返回一個新字符串

In [84]: lst = [‘6′,’8′,’3’]

In [85]: print(“\””.join(lst)) 分隔符是雙引號，\是轉義
6″8″3

 

In [86]: print(” “.join(lst))
6 8 3 空格作為分隔符

In [87]: print(“\n”.join(lst))
6
8
3 換行符作為分隔符

In [88]: lst = [‘1’,[‘x’,’y’],’3′]

In [89]: print(” “.join(lst))
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-89-6106afe592ed> in <module>()
—-> 1 print(” “.join(lst))

TypeError: sequence item 1: expected str instance, list found

拋出異常，typeError

 

字符串+連接：
+ ->str
1、將連個字符串連接在一起
2、返回一個新字符串

字符串分割：
1、split系：
將字符串按照分隔符分割成若干個字符串，并返回列表

2、partition系：
將字符串按照分隔符分割成2段，返回這2段和分隔符的元組

 

# split
split(sep=None,maxsplit=-1)-> list of strings
1、從左至右
2、sep指定分割字符串，缺省的情況下空白字符串作為分隔符
3、maxsplit指定分割的次數，-1表示遍歷整個字符串
In [1]: s1 = “I’m \ta super man.”

In [2]: s1.split()
Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]

 

字符串分割：

一、split系：

將字符串按照分隔符分割成若干個字符串，并返回列表

 

二、partition系：

將字符串按照分隔符分割成2段，返回這2段和分隔符的元組

 

1、split

split(sep=None,maxsplit=-1) -> list for strings

• 從左至右
• sep指定分割字符串，缺省的情況下空白作為分割符
• maxsplit指定分割的次數，-1表示遍歷整個字符串

model：

In [1]: s1 = “I’m \ta super man.”

 

In [2]: s1.split()

Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]

In [3]: s1.split(‘s’)

Out[3]: [“I’m \ta “, ‘uper man.’]

 

2、rspilt

rsplit(sep=None,maxsplit=-1) -> list of strings

• 從右向左
• sep指定分割字符串，缺省的情況下空白字符串作為分隔符
• maxsplit指定分割次數，-1表示遍歷整個字符串

 

 

3、splitlines

splitlines([keepends])->list of strings

• 按照行來切分字符串
• keepends指的是是否保留行分隔符
• 行分隔符包括\n,\r\n,\r等

 

二：partition

1、???? partition(sep)->(head,sep,tail)

• 從左至右，遇到分隔符就把字符串分割成兩部分，返回頭、分隔符、尾三部分的三元組；如果沒有找到分隔符，就返回頭、2個空元素的三元組。
• sep分割字符串，必須指定

 

• rpartition(sep)->(head,sep,tail)
• 從右至左，遇到分隔符就把字符串分割成兩部分，返回頭、分隔符、尾三部分的三元組；如果沒有找到分隔符，就返回2個空元素和尾的三元組

 

三、字符串大小寫

1、upper()：全大寫

2、lower()：全小寫

3、大小寫，做判斷時候用

4、swapcase()：交互大小寫

 

 

四、字符串排版

1、title() -> str

標題的每個單詞都大寫

2、capitalize()-> str

首個單詞大寫

3、center(width[,fillchar]) -> str

width 打印寬度

fillchar 填充的字符

4、zfill(width)->str

width 打印寬度，局右，左邊用0填充

5、ljust(width[,fillchar])-str：左對齊

6、rjust(width[,fillchar])->str：右對齊

 

 

五、字符串修改

1、replace(old,new[,count])->str

字符串中找到匹配替換為新子串，返回新字符串

count表示替換幾次，不指定就是全部替換

 

2、strip([chars])->str

從字符串兩端去除指定的字符集chars中的所有字符

如果chars沒有指定，去除兩端的空白字符

lstrip([chars])->str：從左開始

rstrip([chars])-str：從右開始

 

六、字符串查找

1、find(sub[,start[,end]])->int

在指定的區間[start,end)，從左至右，查找子串sub。找到返回索引，沒有找到返回-1

2、rfind(sub[,start[,end]])

在指定的區間[start,end),從右至左，查找子串sub。找到返回索引，沒有找到返回-1

 

3、index(sub[,start[,end]])->int

在指定的區間[start,end],從左至右，查找字符串sub。找到返回索引，沒有找到拋出異常ValueError

4、rindex(sub[,start[,end]]) ->int

在指定的區間[start,end]，從左至右，查找子串sub。找到返回索引，沒有找到拋出異常ValueError。

 

七、時間復雜度

index和count方法都是O(n)

隨著列表數據規模的增大，而效率下降

1、len(string)

返回字符串的長度，即字符的個數

2、count(sub[,start[,end]])->int

在指定的區間[start,end],從左至右，統計子串sub出現的次數。

 

八、字符串判斷

1、endswith(suffix[,start[,end]])->bool

在指定的區間[start,end]，字符串是否是suffix結尾

2、startwith(prefix[,start[,end]])->bool

在指定的區間[start,edn]，字符串是否是prefix開頭

3、is系列

isalnum()->bool：是否是字母和數字組成

isalpha()：是否是字母

isdecimal()：是否只包含十進制數字

isdigit()：是否全部是數字

isidentifier()：是不是字母和下劃線開頭，其他都是字母、數字、下劃線

islower()：是否都是小寫

isupper()：是否全部為大寫

isspace()：是否只包含空白字符

 

 

九、字符串格式化

字符串的格式化是一種拼接字符串輸出樣式的手段，更靈活方便

join拼接只能使用分隔符，切被拼接的是可迭代

+拼接字符串還方便，但非字符串需要先轉換為字符串才可以

 

format：

格式語法：

format函數格式字符串語法—Python鼓勵使用

1、”{}{xxx}”.format(*args,**kwargs)–>str

2、args是位置參數，是一個元組

3、kwargs是關鍵字參數，是一個字典

4、花括號表示占位符

5、{}表示按照順序匹配位置參數，{n}表示取位置參數索引為n的值

6、{xxx}表示關鍵字參數中搜索名稱一致的

7、{{}}表示打印花括號

 

a、位置參數：

“{}:{}”.format(‘192.168.1.100’,8888)，這就是按照位置參數順序用位置參數替換前面的格式字符串的占位符

 

b、關鍵字參數或命名參數

“{server}{1}:{0}”.format(8888,’192.168.0.200’,server=’Web Server Info:’位置參數按照序號匹配，關鍵字參數按照名詞匹配

 

c、訪問元素

“{0[0]}.{0[1]}”.format((‘Eric’,’com’))

d、對象屬性訪問

from collections import namedtuple

Point = namedtuple(‘Point’,’x y’)

p = Point(4,5)

“{{{0.x},{0.y}}}”.format(p)

對齊：

‘{0}*{1}={2:<2}’.format(3,2,2*3) ‘{0}*{1}={2:<02}’.format(3,2,2*3) ‘{0}*{1}={2:>02}’.format(3,2,2*3) ‘{:^30}’.format(‘centered’)

‘{:*^30}’.format(‘centered’)

 

進制：

“int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)

“int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}”.format(42)

octets = [192, 168, 0, 1] ‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)