數(shù)據(jù)類型

1.Number[整型，浮點型，復(fù)數(shù)]

2.String：字符串

3.Boolean：布爾值[True,False]

4.None:空值

5.List：列表

6.Set：集合

7.Tuple：元組

8.Dict: 字典

可變數(shù)據(jù)類型:Dict\Set\List

不可變數(shù)據(jù)類型: Boolean\Tuple\String\Number

以內(nèi)存的值是否可以修改，來判定是否可變

Boolean布爾值

使用場景: 主要用于分支和循環(huán)語句中

True:1? False:0

b1 = True

b2 = False

print(type(b1))

None空值:

None:python中一種特殊數(shù)據(jù)類型,和0區(qū)分

n = None

print(type(n))

Number數(shù)字

1.分類

1.整型

可正可負(fù)，處理任意大小的整數(shù)

2.浮點型

注意:四舍五入的誤差

3.復(fù)數(shù)

a+bj

2.數(shù)字類型轉(zhuǎn)換

int()

float()

complex(x,y)[x是實數(shù)，y是虛數(shù)]

3.功能

3.1數(shù)學(xué)功能

import math

# 求絕對值

a1 = -10

print(abs(a1))

# 獲取最大值

m = [10,8,12,-2]

print(max(m))

# 獲取最小值

print(min(m))

# 向上取整

upInt = 18.1

print(math.ceil(upInt))

# 向下取整

downInt = 18.3

print(math.floor(downInt))

# 開平方

sartInt = 100

print(math.sqrt(sartInt))

# 平方

powInt = pow(10,2)

print(powInt)

擴(kuò)展:

# 遵循銀行家舍入

# 46舍入，5看情況，如果5后不全為0，如果5后全為0，看5前邊是奇還是偶，如果是奇則進(jìn)，如果是偶則舍棄

print(round(4.51))

print(round(3.62))

3.2隨機(jī)數(shù)

import random

# 隨機(jī)抽取

l = [3,5,7,10,-2,10.5]

s = "hello"

print(random.choice(s))

# 打亂列表順序,shuffle就是沒有返回值，直接把列表更新

m_random = [1,2,3,4,5,6,7,8,9,10]

random.shuffle(m_random)

# 隨機(jī)產(chǎn)生一個0-1的數(shù)，0-1之間這么一小數(shù)

print(random.random())

# 隨機(jī)產(chǎn)生一個0-10之間的整數(shù)

1. print(random.choice(range(1,10)))

2. print(random.randint(1,10))

# random.randrange(start,end,step)

"""

start:開始值,默認(rèn)為0

end: 結(jié)束值,不包含范圍內(nèi)

step： 步長

"""

字符串

# 首字母變大寫

s = "hello world"

print(s.title())

# 截取 包起始位置的值，不包含尾部

print(s[0:5])

# 截取e,從2--最后,記住第一個位置下標(biāo)為0

print(s[1:])

#　全部輸出

print(s[:])

#? 重復(fù)輸出

print(s * 2)

#　倒敘輸出

print(s[::-1])

字符串索引規(guī)律

從左往右，步長遞增: 0

從右往左, 步長遞減: -1

# 去除空格

s = " hello.py "

print(s.lstrip()) #l去除左邊空格

print(s.rstrip()) #r去除右邊空格

print(s.strip())? #strip去除左右兩邊的空格

轉(zhuǎn)義

需要在字符中使用特殊字符時，python用反斜杠()轉(zhuǎn)義字符。如下表：

\(在行尾時)續(xù)行符\\反斜杠符號

'單引號"雙引號

\n換行\(zhòng)t水平制表符(4個空格)

續(xù)行符

myStr = 'abcde\

f'

格式化輸出

%d? %s? %f? 占位符

print("num = %d, str19 = %s, f = %.3f" % (num, str19, f))

#%? '%%'輸出一個單一的'%'

print("%-10.2f"%22.11111,'modeng') #10 為10個長度 用做左對齊

# 輸出結(jié)果: ? ?? 22.11 modeng

print("%10.2f"%22.11111,'modeng')? #10 為10個長度 用做右對齊

# 輸出結(jié)果: 22.11 ? ?? modeng

使用format進(jìn)行格式化

print("字符串{} 浮點數(shù){} 整數(shù){}".format('asd',11.1,8))

常見函數(shù)

isnumeric() [nu:'mer?k]如果字符串中只包含數(shù)字字符，則返回 True，否則返回 False

splitStr.join(Str)以指定字符串作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串

center(self,width,fillchar)以原始字符串為中心生成新字符串

ljust(width,[str])返回一個原字符串左對齊,并使用 fillchar 填充至長度 width 的新字符串，fillchar 默認(rèn)為空格。

rjust(width,[str])返回一個原字符串右對齊,并使用 fillchar 填充至長度 width 的新字符串，fillchar 默認(rèn)為空格。

lstrip()/rstrip()/strip截掉字符串左/右邊的空格或指定字符/倆側(cè)

max(str)/min(str)返回字符串 str 中最大/小的字母。

chr(x)將一個整數(shù)轉(zhuǎn)換為一個字符

ord(x)將一個字符轉(zhuǎn)換為它的整數(shù)值

myStr.replace(old,new[,max])把 將字符串中的 str1 替換成 str2,如果 max 指定，則替換不超過 max 次。

find(str,beg=0,end=len)/index(str)查找某個字符出現(xiàn)的位置? 從左側(cè)開始查找 查到返回索引值 查不到返回-1 /查到返回索引 查不到報錯

rfind(str,beg=0,end=len)/rindex(str)查找某個字符出現(xiàn)的位置? 從右側(cè)開始查找 查到返回索引值 查不到返回-1 /右查到返回索引 查不到報錯

split(str=''[,num])num=string.count(str)) 以 str 為分隔符拆分字符串為列表，如果 num 有指定值，則僅截取 num 個子字符串

swapcase()將字符串中大寫轉(zhuǎn)換為小寫，小寫轉(zhuǎn)換為大寫

upper()轉(zhuǎn)換字符串中的小寫字母為大寫

lower()轉(zhuǎn)換字符串中的寫字母為小寫

splitlines(True)以回車換行為條件分割，參數(shù)用來設(shè)置是否保留換行

案例

# 判斷一以什么結(jié)尾

# 擴(kuò)展s字符串來源可以改成鍵盤輸入

s = "hello.py"

if s[-3:] == ".py":

print("你們是最棒的")

else:

print("我們還需要加強(qiáng)練習(xí)")

列表

1.概述

引出：存儲一個數(shù)據(jù)可以采用變量

問題：需要同時存儲多個數(shù)據(jù)，該怎么做？

#需求：有5個人的年齡，求平均年齡

age1 = 10

age2 = 32

age3 = 43

age4 = 18

age5 = 90

average = (age1 + age2 + age3 + age4 + age5) / 5

解決：容器【Python提供了一種數(shù)據(jù)結(jié)構(gòu)list，可以同時存儲多個數(shù)據(jù)】

本質(zhì)：一種有序的集合

2.創(chuàng)建列表

語法：列表名 = [列表選項一，列表選項二，列表選項三.....]

說明：使用[]表示列表，列表名其實就是標(biāo)識符

? ? ? 將列表中的列表選項被稱為元素

? ? ? 列表中的元素分別被編了號，這些編號被稱為索引【下標(biāo)，角標(biāo)】，從0開始編號

3.列表中元素的訪問

3.1取值

語法：列表名[索引]

list4 = [100,200,400,300,800]

num = list4[2]

print(num)

print(list4[2])

3.2替換

語法：列表名[索引] = 新的元素值

list4[2] = 888

print(num)

print(list4[2])

4.列表操作

#1.列表組合

#直接使用加號

list1 = [43,65,76,6]

list2 = [45,77,90,11,2,4,66]

print(list1 + list2)

?

#2.列表重復(fù)

#直接使用乘號

print(list1 * 4)

?

#3.判斷指定元素是否存在于列表中

#成員運算符：in ? ?? not in

#運算的結(jié)果為布爾值

list3 = ["hello",False,189,"good"]

print(189 in list3) #True

print(180 not in list3)? #True

?

#4.列表的截取【分片，切片】

#語法：列表名[開始下標(biāo):結(jié)束下標(biāo)]，表示獲取從開始下標(biāo)到結(jié)束下標(biāo)之間的元素，結(jié)果為一個新的列表

#注意：包頭不包尾【前閉后開區(qū)間】 ? [開始下標(biāo),結(jié)束下標(biāo))

list4 = ["hello",False,189,"good",436,54,3,45]

print(list4[2:4])

?

#獲取從指定下標(biāo)到結(jié)尾的列表，包含指定下標(biāo)

print(list4[3:])

?

#獲取從開頭到指定下標(biāo)的列表，不包含指定下標(biāo)

print(list4[:6])

5.列表內(nèi)置功能

語法：列表名.功能()

#一、添加元素

#1.append ? 在列表結(jié)尾添加元素或者新的列表【追加】

list11 = [1,2,3,4,5]

print(list11)

#追加元素

list11.append(100)

print(list11)

#追加列表【將容器和元素一起添加進(jìn)去】

list11.append([547,76,87])

print(list11)

?

#2.extend ?? 在列表的末尾一次性追加另一個列表中的元素

list12 = [1,2,3,4,5,100]

list12.extend([547,76,87]) #只將元素添加進(jìn)去

print(list12)

?

#3.insert? 在指定索引處插入一個元素，不覆蓋原來的元素，原有的元素向后順延

#注意：告訴編譯器，需要在什么位置插入什么元素

list13 = [1,2,3,4,5]

print(list13)

#插入元素

list13.insert(2,555)

print(list13)

#插入列表

list13.insert(4,[22,33])

print(list13)

?

#二、移除元素

#4.pop ? 移除列表中指定下標(biāo)的元素

list14 = [1,2,3,4,5,100]

print(list14)

#默認(rèn)移除最后一個元素

list14.pop()

print(list14)

#移除指定下標(biāo)的元素

list14.pop(3)

print(list14)

?

#5.remove? 移除元素

list15 = [11,23,354,45,5,100]

#如果元素不存在，則出現(xiàn)錯誤：ValueError: list.remove(x): x not in list

#list15.remove(3)

list15.remove(5)

print(list15)

?

#6.clear ? 清空列表

list16 = [11,23,354,45,5,100]

list16.clear()

print(list16)

?

#三、獲取

#7.index ? 從列表中查詢第一個匹配的元素的下標(biāo)

list17 = [11,23,354,45,5,100,100,23,354]

print(list17)

#在整個列表中查詢

print(list17.index(23))

#只在部分列表中查詢【包頭不包尾】

#注意：2和7表示開始下標(biāo)和結(jié)束下標(biāo),列表下標(biāo)范圍

#print(list17.index(23,2,7))

?

#獲取相關(guān)信息，語法：功能()

#8.len 獲取列表中元素的個數(shù)【獲取列表的長度】

list18 = [11,23,354,45,5,100,100,23,354]

#注意：len直接使用

print(len(list18))

?

#9.max? 獲取列表中的最大值

print(max(list18))

?

#10.min? 獲取列表中的最小值

print(min(list18))

?

#11.count? 查看元素在列表中出現(xiàn)的次數(shù)

print(list18.count(23))

?

#四、反轉(zhuǎn)

#12.reverse? 將列表實現(xiàn)倒序

list18.reverse()

print(list18)

?

#五、排序

#sort和sorted

#13.sorted

list19 = [11,23,354,45,5,100,100,23,354]

#默認(rèn)實現(xiàn)升序排序

list1 = sorted(list19)

print(list1)

#可以實現(xiàn)降序排序

list2 = sorted(list19,reverse=True)

print(list2)

?

#通過key關(guān)鍵字來實現(xiàn)排序：根據(jù)字符串的長度排序

list20 = ["zoo","manager","hello","jack","international"]

list3 = sorted(list20,key=len)

print(list3)

?

#14.sort

list19.sort()? #升序

print(list19)

list19.sort(reverse=True)? #降序

print(list19)

?

#六、拷貝【面試題】

#淺拷貝：引用拷貝

list21 = [1,2,3,4,5]

list22 = list21

print(list21)

print(list22)

list22[2] = 100

print(list21) #[1, 2, 100, 4, 5]

print(list22) #[1, 2, 100, 4, 5]

?

#拷貝內(nèi)容

#15.copy([淺拷貝]shallow copy)

list23 = [1,2,3,4,5]

list24 = list23.copy()

print(list23)

print(list24)

list24[2] = 666

print(list23) #[1, 2, 3, 4, 5]

print(list24) #[1,2,666,4,5]

?

#16.deepcopy([彩蛋][面試分量比較重][深拷貝]deep copy)

import copy

list_remove = [1,2,3,[0,1],5,6,7,4]

deep_list_remove = copy.deepcopy(list_remove)

deep_list_remove[3][0] = 333

print(deep_list_remove)

print(list_remove)

本質(zhì)：真正獲取一個對象的復(fù)制實體，而非引用——[記住]

6.多維 列表

實質(zhì)上還是一個簡單列表，只不過列表的元素仍然是一個列表

代碼演示：

multiList = [[11,22,33],[100,100],[438,4,4,3,21]]

取值

multiList[0] ? ? ? # [1,2,3]

multiList[0][0] ?? # 1

沒錢? ? 零買1根? ? ? ? ? ? ? ? ? ? 一個變量

稍微有錢 ? 一包 ? ? ? ? ? ? 一維列表【20個變量】

條 ? ? 10包 ? ? ? ? ? ? 二維列表【10個一維列表】

6.常見函數(shù)

len()計算列表的長度

list.count()統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)

append向列表中添加一個值

list.extend()在列表末尾一次性追加另一個序列中的多個值（用新列表擴(kuò)展原來的列表）

list.index()從列表中找出某個值第一個匹配項的索引位置

list.insert(index,obj)將對象插入列表

list.pop()移除列表中的一個元素（默認(rèn)最后一個元素），并且返回該元素的值

list.remove()移除列表中某個值的第一個匹配項

list.reverse()反向列表中元素

list.sort()對原列表進(jìn)行排序

list.clear()清空列表

list.copy()復(fù)制列表

copy.deepcopy()深拷貝 拷貝對象及其子對象

copy.copy()淺拷貝 只拷貝父對象，不會拷貝對象的內(nèi)部的子對象

元組(粗略看)

1.概念

元組本質(zhì)上也是有序的集合，和列表非常相似

區(qū)別：

a.列表使用[]表示，元組使用()表示

b.列表可以修改元素值，但是，元組不可以

注意：元組一旦被初始化之后，就不能發(fā)生改變

2.創(chuàng)建元組

語法：元組名 = （元組元素1，元組元素2，元組元素3....）

#語法：元組名 = （元組元素1，元組元素2，元組元素3....）

#1.創(chuàng)建空元組

tuple1 = ()

print(tuple1)

?

#2.創(chuàng)建一個帶有元素的元組

tuple2 = (22,23,14,87)

print(tuple2)

?

#3.元組中也可以存儲不同類型的數(shù)據(jù)

tuple3 = ("hello",True,10.24,10)

print(tuple3)

?

#4.創(chuàng)建只有一個元素的元組(強(qiáng)調(diào))

num = 56

tuple4 = (56,) #只有1個元素的時候必須加一個逗號，來消除歧義

3.元組元素的訪問

語法：列表名[索引]

? ? ? 元組名[索引]

tuple1 = (22,23,14,87)

#注意：和列表相同，元素的下標(biāo)也是從0開始的

print(tuple1[1])

#print(tuple1[4])? #IndexError: tuple index out of range? 下標(biāo)越界

?

#獲取元組中的最后一個元素

print(tuple1[-1])

print(tuple1[-2])

print(tuple1[-3])

print(tuple1[-4])? #第一個元素

#print(tuple1[-5]) ? #IndexError: tuple index out of range

?

#修改元組的元素值

#tuple1[1] = 100

?

tuple2 = (22,23,14,87,[66,77])

#修改列表的元素值

tuple2[4][0] = 888

print(tuple2)

4.元組的操作

#1.元組的連接：+

tuple1 = (2,4,54,6)

tuple2 = (4,6565,87)

print(tuple1 + tuple2)

?

#2.元組元素的重復(fù):*

print(tuple1 * 3)

?

#注意：元組的連接和重復(fù)最終得到的是一個新的元組

?

#3.判斷指定元素是否在元組中：in

print(45 in tuple1)

?

#4.元組元素的截取【切片】

#元組名[開始下標(biāo)，結(jié)束下標(biāo)]，注意：包含開始下標(biāo)，但是不包含結(jié)束下標(biāo)

tuple3 = (2,4,54,6,45,100,56,90)

print(tuple3[1:4])

#從指定下標(biāo)開始截取到結(jié)尾，指定下標(biāo)包含在內(nèi)

print(tuple3[3:])

#從開頭截取到指定位置，不包含指定下標(biāo)

print(tuple3[:5])

5.元組功能

#1.獲取元組的長度或者計算元組中元素的個數(shù)

#len

tuple1 = (23,4,46,5787)

len = len(tuple1)

print(len)

?

#遍歷元組

for index in range(0,len):

print(tuple1[index])

?

?

#2.獲取元組中元素的最值

#max ? min

max = max(tuple1)

print(max)

min = min(tuple1)

print(min)

?

#3.列表和元組之間的相互轉(zhuǎn)換

#列表-----》元組

list1 = [23,4,65,76]

print(list1)

new_tuple = tuple(list1)

print(new_tuple)

?

#元組-----》列表

list2 = list(tuple1)

print(list2)

?

#自己實現(xiàn)求元組中最大值

max = tuple1[0]

?

for index in range(0,len(tuple1)):

if tuple1[index] > max:

? #給max重新賦值

? max = tuple1[index]

6.二維元組

tuple1 = ((1,2,3),(22,33),(100,200,300,400))

print(tuple1[0][1])

7.tuple和list之間的區(qū)別（重點）

1.元組中的元素是無法修改的【在項目中如果使用多線程環(huán)境，更多的傾向于操作不變的數(shù)據(jù)】

v1 = (11,22,33)

v1[0] = 666

TypeError: 'tuple' object does not support item assignment

2.元組在占用空間和創(chuàng)建時間上相對而言優(yōu)于列表

import sys

l = [1,3,4,5,6,7,8,9,20]

t = (1,3,4,5,6,7,8,9,20)

print(sys.getsizeof(l),sys.getsizeof(t))

import timeit

print(timeit.timeit(stmt="[1,3,4,5,6,7,8,9,20]"),timeit.timeit(stmt="(1,3,4,5,6,7,8,9,20)"))

字典（詳細(xì)）

1.概述

思考問題：存儲多個學(xué)生的成績

一種存儲數(shù)據(jù)的數(shù)據(jù)結(jié)構(gòu)，但是字典的無序的【在內(nèi)存中元素的順序和存放的順序不一定相同】

字典采用的鍵-值【key-value】的形式存儲數(shù)據(jù)

優(yōu)點：具有極快的查找速度，根據(jù)hash函數(shù)映射到指定位置?。?！

key --散列函數(shù)--> hash值，存儲到指定地址，做到快速尋址

2.key的特點

a.字典中的key是唯一的

b.key必須是不可變的實體

? ? 例如：字符串，整數(shù)，元組都是不可變的

? ? ? ? ? ? list可變的，不能作為字典中的key

dictA = {(1,2,3):"five",(1,2,3):6}

dictB = {[1,2,3]:"five",(1,2,3):6}

error: TypeError: unhashable type: 'list'

3.字典的創(chuàng)建

語法：字典名 = {鍵1：值1,鍵2：值2,鍵3：值3......}

4.元素訪問

#存儲多個學(xué)生的成績

dict1 = {"jack":78,"hanmeimei":99,"lilei":60}

print(dict1)

?

#元素訪問

#1.獲取 語法：字典名[key]

print(dict1["hanmeimei"])

#print(dict1["tom"]) #KeyError: 'tom'

?

#2.字典名.get()

result = dict1.get("lilei")

print(result)

?

#添加:當(dāng)指定的鍵不存在的時候，則表示添加

dict1["tom"]? = 70

print(dict1)

#但是，如果鍵已經(jīng)存在，則表示修改value

dict1["jack"]? = 50

print(dict1)

?

#刪除 pop

#注意：通過鍵，直接刪除整個鍵值對

dict1.pop("jack")

print(dict1)

?

#遍歷

dict2 = {"jack":78,"hanmeimei":99,"lilei":60}

?

#方式一：只獲取鍵

for key in dict2:

value = dict2[key]

print(key,value)

?

#方式二：只獲取值

#values,得到的結(jié)果是一個列表，當(dāng)做列表處理

print(dict2.values())

?

for value in dict2.values():

print(value)

?

?

#方式三：同時獲取鍵和值

#items,得到的結(jié)果是一個列表，列表中的元素是元組

print(dict2.items())? #[('jack', 78), ('hanmeimei', 99), ('lilei', 60)]

?

for key,value? in dict2.items():

print(key,value)

?

#方式四

for index,key in enumerate(dict2):

value = dict2[key]

print(index,key,value)

?

#獲取鍵值對

print(len(dict1))

5.案例

1. 統(tǒng)計每個字符在列表中出現(xiàn)次數(shù)

l = [1,2,3,4,5,6,7,8,9,2,2,2]

dict = {}

for item in l:

if item in dict:

dict[item] += 1

else:

dict[item] = 1

警惕: 避免bool&數(shù)值同時出現(xiàn)在字典的key中

?

字典的鍵可以使用布爾類型的，True 默認(rèn)代表 1，F(xiàn)alse 默認(rèn)代表 0，如果包含 0 或 1 就無法使用布爾類型：

test = {0:"1", 1:"2", True:"3", False:"4"}

print(test)

{0: '4', 1: '3'}

?

選擇題:

? ? A: {0: '4', 1: '3'}

? ? B: {True: '4', False: '3'}

? ? C: {0:"1", 1:"2", True:"3", False:"4"}

? ? D: {0:"1", 1:"2"}

?

沒有 0 或 1 的情況下：

test = {"a":"1", "b" :"2", True:"3", False:"4"}

print(test)

{'a': '1', True: '3', 'b': '2', False: '4'}

?

集合

1.概述

一個無序不重復(fù)元素的序列

1. 全集: 所有元素的集合.例如實數(shù)集,所有實數(shù)組成的集合就是全集

2. 子集subset和超集superset: 一個集合A所有的元素都在另一個集合B內(nèi),A是B的子集,B是A的超集

3. 真子集和真超集: A是B的子集,且A不等于B,A就是B的真子集,B是A的真超集

4. 并集: 多個集合合并的解構(gòu)

5. 交集: 多個集合的公共部分

6. 差集: 集合中除去和其他集合公共部分

2.集合創(chuàng)建

s = {1,2,3,4,5,6,7,8,9,10}

l = [1,2,3,4,5,6,7,8,9,10]

s = set(l)

注意： 空集合創(chuàng)建只能set(),而不是{}，為啥呢？思考一下哈~~

3.集合操作

# set可以進(jìn)行集合運算

a = set('abk')

b = set('bal')

print(a)

print(a - b) ? ? # a和b的差集

print(a | b) ? ? # a和b的并集

print(a & b) ? ? # a和b的交集

print(a ^ b) ? ? # a和b中不同時存在的元素

4.案例

a = [1, 2, 3, 43, 31, 2] ? ? ? ? 　# 新建一個列表

b = set(a) ? ? ? ? ? ? ? ? ? ? ? ? # 將列表轉(zhuǎn)為集合

print(b) ? ? ? ? ? ? ? ? ? ? ? ? ? # {1,2,3,43,31}

常見轉(zhuǎn)換函數(shù)

函數(shù)描述

int(x [,base])將x轉(zhuǎn)換為一個整數(shù)

float(x)將x轉(zhuǎn)換到一個浮點數(shù)

complex(x [,y])將 x 和 y 轉(zhuǎn)換到一個復(fù)數(shù)，實數(shù)部分為 x，虛數(shù)部分為 y。x 和 y 是數(shù)字表達(dá)式。

str(x)將對象 x 轉(zhuǎn)換為字符串

eval(str)用來計算在字符串中的有效Python表達(dá)式,并返回一個對象

tuple(s)將序列 s 轉(zhuǎn)換為一個元組

list(s)將序列 s 轉(zhuǎn)換為一個列表

set(s)轉(zhuǎn)換為可變集合

dict(d)創(chuàng)建一個字典。d 必須是一個序列 (key,value)元組。

bool轉(zhuǎn)換為bool值