數據類型
簡介:變量值是用來保存現實世界中的狀態的，那麼針對不同的狀態就應該用不同類型的數據去表示
1 變量
1.1 什麼是變量
量: 記錄現實世界中的狀態,讓計算機能夠像人一樣去識別世間萬物
變: 現實世界的狀態是會發生改變的1.2 爲什麼要有變量
程序執行的本質就是一系列狀態的變化,也就是說程序執行的狀態是會改變的1.3 如何用變量
- 比如 name = alex
- 定義變量分爲三部分:
- 1, 變量名 name, 變量名用來引用變量值的. 但凡要用變量值都要通過引用變量名來使用.
- 2, 賦值符號 =: 賦值
- 3, 變量值 alex: 我們存放的數據, 用來記錄現實世界中的某種狀態
1.4 變量名的命名規範: 變量名的名字應該能反應變量值所記錄的狀態
- 1 變量名只能是字母,數字或者下劃線的任意組合
比如: name = alex, na_me = alex - 2 變量名的第一個字符不能是數字
- 3 python關鍵字不能聲明爲變量名
1.5 變量名的兩種風格
- 1 駝峯體 name = alex
- 2 下劃線 ( 針對變量名的命名風格,推薦使用下劃線+純小寫字母)
age_of_oldboy = 831.6 常量
- 常量: 不變的量,通常以大寫的形式
引用計數
- 如果一個變量的引用計數爲0,那麼就會被python的垃圾回收機制自動回收
變量的幾種常用操作
- 1 賦值
name = egon - 2 變量的解壓
第一種實例如下:
x = 10 y = 20 y,x = 10, 20 print(x,y)輸出結果如下:
20 10第二種實例如下:
x = 10 y = 20 print(id(x),id(y)) res = 0 res = y-x y = res x = y+res print(x,y) print(id(x),id(y))輸出結果如下:
140723908125072 140723908125392
20 10
140723908125392 140723908125072is: 判斷id是否相等
type: 判斷類型
==: 判斷值是否相等
總結:
id相等,值一定相等: 值相等,但id不一定相等(存放值的內存空間相同則值一定相同,值相同但是存放值的內存空間不一定相同)
2 字符串(str)
- 2.1 一般用來表示描述性質的狀態,比如人的名字,家庭住址等等
-
2.2 定義: name = 'egon' 在單引號或者雙引號,三引號內包含的一串字符
內置操作:
-
1、按索引取值(正向取+反向取) ：只能取
msg='hello world'
print(type(msg[5]))
print(msg[-1])
msg[2]='A' #報錯
輸出結果如下:
<class 'str'>
d -
2、切片(顧頭不顧尾，步長) 步長默認爲0
msg='hello world'
print(msg[1:5],type(msg[1:5]))
print(msg[6:-1])
print(msg[6:11])
print(msg[6:])
print(msg[6::2])
print(msg[0:])
print(msg[::-1])
msg='hello world'
print(msg[-3:-6:-1])
輸出結果如下:
ello <class 'str'>
worl
world
world
wrd
hello world
dlrow olleh
row -
3 長度 len
msg='hello world'
print(len(msg))
輸出結果如下:
11 - 4 成員運算in和not in
print('SB' in 'my name is alex,alex is SB')
print('alex' in 'my name is alex,alex is SB')
print('egon' not in 'my name is alex,alex is SB') # 推薦
print(not 'egon' in 'my name is alex,alex is SB')
輸出結果如下:
True
True
True
True - 5 移除空白strip: 只能移除左右兩邊的,字符串中間的不可以移除
name=' e gon '
print(name.strip(' '))
print(name.strip())
name='Aegon'
print(name.strip(''))
輸出結果如下:
e gon
e gon
Ae*gon - 6 切分split:切分完以後會變成一個列表,可以按照索引取值
msg='egon:18:male:180:160'
l=msg.split(':')
print(l)
print(l[3])
輸出結果如下:
['egon', '18', 'male', '180', '160']
180 -
7 循環: 一個一個的取出來,直到報錯for循環捕捉異常停止
msg='hello world'
for x in msg:
print(x)
輸出結果如下:
h
e
l
l
ow o r l d - 8 其他操作
1、strip(): 默認去掉左右兩邊的空格
lstrip():默認去掉左邊的空格
rstrip():默認去掉右邊的空格
2、lower:大寫變小寫
upper: 小寫變大寫
name='EoN'
print(name.lower()) 大變小
輸出結果:
eon
name='egonN'
print(name.upper()) 小變大
輸出結果:
EGONN3、startswith:判斷這個字符串是不是以什麼開頭的
endswith:判斷這個字符串是不是以什麼結尾的
print('alex is SB'.startswith('alex'))
print('alex is SB'.endswith('B'))
輸出結果如下:
True
True4 format的三種玩法
print('my name is %s my age is %s' %('egon',18))
print('my name is {name} my age is {age}'.format(age=18,name='egon'))
可以打破位置的限制,但仍能指名道姓地爲指定的參數傳值
print('my name is {} my age is {}'.format('egon',18))
print('my name is {0} my age is {1} {1} {1} {1}'.format('egon',18))
輸出結果如下:
my name is egon my age is 18
my name is egon my age is 18
my name is egon my age is 18
my name is egon my age is 18 18 18 185 切分
split:從左邊開始切分,可以指定步長,默認爲0
rsplit:從右邊開始切分,可以指定步長.默認爲0
info='egon:18:male'
print(info.split(':'))
print(info.split(':',1))
print(info.rsplit(':',1))
輸出結果如下:
['egon', '18', 'male']
['egon', '18:male']
['egon:18', 'male']
6 join:只能將元素全爲字符串的列表拼成一個大的字符串
info='egon:18:male'
l=info.split(':')
print(l)
new_info='-'.join(l)
print(new_info)
輸出結果如下:
['egon', '18', 'male']
egon-18-male
num=[1,2,'c']
':'.join(num)
思考:爲何會報錯?7 replace:替換指定的值(第一個參數爲指定的值,第二個參數
爲自己添加的值,第三個參數是選擇替換幾個(默認是全部替換))
msg='my name is wupeiqi,wupeiqi is SB'
print(msg.replace('wupeiqi','Pig',1))
print(msg)
輸出結果如下:
my name is Pig,wupeiqi is SB
my name is wupeiqi,wupeiqi is SB8 isdigit:判斷字符串裏是不是數字
isalnum:判斷是不是爲字母或數字
isalpha:判斷是不是字母組成
islower:判斷是不是全小寫組成
isupper:判斷是不是全大寫組成
center:輸出結果時可以在左右兩邊添加符號,第一個參數是多寬,第二個參數是以什麼符號
print('111.1'.isdigit())
print('1111'.isdigit())
msg='my name is alex,alex is hahaha'
print(msg.find('alex')) #返回一個索引位置
print(msg.find('SB')) #找不到會返回-1
print(msg.index('alex'))
# print(msg.index('SB')) # 找不到index會報錯
print(msg.find('alex',0,3))
print(msg.count('alex'))
print(msg.count('alex',0,15))
print('info egon'.center(50,'-'))
輸出結果:
False
True
11
-1
11
-1
2
1
--------------------info egon---------------------
a b c強調:字符串類型只能+或者*,是不可變類型,是有序的(可以根據索引來取值)
3 整型(int)
- 3.1 作用: 表示人的年齡,各種號碼,等級
定義:
age = 18
age=int('18')
print(id(age))
print(type(age))
輸出結果如下:
140723908125328
<class 'int'>整型是不可變類型
可變指的是改變原值,即在原值基礎上進行修改 可變類型的底層原理:在id不變的情況下,值可以改變 不可變類型的底層原理:值改變,id也跟着變4 浮點型(float)
- 4.1 作用: 表示人的身高,體重,工資等等
定義:
salary=3.1
print(id(salary))
print(type(salary))
輸出結果如下:
1656907805128
<class 'float'>5 列表(list)
列表的作用: 存放多個值
5.1 列表可以按照索引取值,索引從0開始
hobbies=['read','run','basketball'] print(hobbies[2]) print(hobbies) 輸出結果如下: basketball ['read', 'run', 'basketball']5.2 內置操作
1、按索引存取值(正向存取+反向存取)：即可存也可以取
names=['alex','wxx','lxx','egon']
names[0]='ALEX'
print(names)
['ALEX', 'wxx', 'lxx', 'egon']
2、切片(顧頭不顧尾，步長)
names=['alex','wxx','lxx','egon']
print(names[0:3])
['alex', 'wxx', 'lxx']
3、長度
names=['alex','wxx','lxx','egon']
print(len(names))
4
4、成員運算in和not in
names=['alex','wxx','lxx','egon',4]
print(4 in names)
True
5、追加
names=['alex','wxx','lxx','egon']
names.append('cxx1')
names.append('cxx2')
names.append('cxx3')
print(names)
['alex', 'wxx', 'lxx', 'egon', 'cxx1', 'cxx2', 'cxx3']
6、刪除
names=['alex','wxx','lxx','egon']
del names[2]
print(names)
['alex', 'wxx', 'egon']
7、循環
names=['alex','wxx','lxx','egon']
for name in names:
print(name)
輸出結果:
alex
wxx
lxx
egon
需要掌握的操作(****)
names=['alex','wxx','lxx','egon',4,3.1]
names.insert(1,'SB') # 在0 和1 之間加一個值進去
print(names)
['alex', 'SB', 'wxx', 'lxx', 'egon', 4, 3.1]
names=['alex','wxx','lxx','egon',4,3.1]
res=names.remove('wxx') # 單純的刪掉,是按照元素的值去刪除，沒有返回值
print(res)
print(names)
None
['alex', 'lxx', 'egon', 4, 3.1]
names=['alex','wxx','lxx','egon',4,3.1]
res=names.pop(1) #拿走一個值,是按照索引去刪除,有返回值
print(names)
print(res)
['alex', 'lxx', 'egon', 4, 3.1]
wxx
names=['alex','wxx','lxx','egon',4,3.1]
print(names.pop())
print(names.pop())
pop: 默認從最後一個開始刪除
3.1
4
names=['alex','wxx','lxx','lxx','egon',4,3.1]
print(names.count('lxx')) #統計個數
print(names.index('lxx'))
2
2
names.clear() #全部清空
print(names)
[]
x=names.copy() #拷貝,把names複製給x
print(x)
['alex', 'wxx', 'lxx', 'lxx', 'egon', 4, 3.1]
names.extend([1,2,3]) # 加值
print(names)
['alex', 'wxx', 'lxx', 'lxx', 'egon', 4, 3.1, 1, 2, 3]
names.reverse() # 將結果倒過來輸出
print(names)
[3.1, 4, 'egon', 'lxx', 'lxx', 'wxx', 'alex']
names=[1,10,-3,11]
names.sort(reverse=True) #默認從大到小排列,把reverse改爲True就變成從小到大排列
print(names)
[-3, 1, 10, 11]總結:列表是有序的,可變
l=['a','b']
print(id(l))
l[0]='A'
print(id(l))
print(l)
y=[1,2]
x=[1,1,2,3]
print(x)
結果如下:
2004845552264
2004845552264
['A', 'b']
[1, 1, 2, 3]6 字典(dict)
1 作用:
用來存取放多個值，按照key：value的方式存放的值，取的時候可以通過key而非索引去取值，key對value是有描述性的功能2 定義方式:
在{}內用逗號分隔開多個元素，每一個元素都是key:value的格式，其中value可以是任意類型，key大多數情況都是字符串類型
實例如下:
user_info={
'name':'egon',
'sex':'male',
'age':18,
'company_info':{'c_name':'oldboy','c_addr':'Shanghai','members':20}}
輸出結果如下:
2781423307440
<class 'dict'>
{'name': 'egon', 'sex': 'male', 'age': 18, 'company_info': {'c_name': 'oldboy', 'c_addr': 'Shanghai', 'members': 20}}3 常用操作+內置方法
-
1、按key存取值：可存可取
d={'x':1,'y':2}
d['x']=100
print(d)
d['z']=3
print(d)輸出結果如下: {'x': 100, 'y': 2} {'x': 100, 'y': 2, 'z': 3} -
2、長度len
d={'x':1,'y':2}
print(len(d))2 -
3、成員運算in和not in
d={'x':1,'y':2}
print('x' in d)True -
4 刪除
d={'x':1,'y':2}
del d['x']{'y': 2} - 5 添加
dic1={"name":"xiong"}
dic["age"]=222 -
6 dic.keys():取出所有的鍵放在一個列表中
dic.values():取出所有的值放在列表中
dic.items(): 將字典的鍵值都取出來
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,}keys=msg_dic.keys() 結果:dict_keys(['apple', 'tesla', 'mac', 'lenovo', 'chicken']) vals=msg_dic.values() 結果:dict_values([10, 100000, 3000, 30000, 10]) print(msg_dic.items()) 結果:dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)]) for k,v in msg_dic.items(): print(k,v) 結果: apple 10 tesla 100000 mac 3000 lenovo 30000 chicken 10 -
內置方法
get:給我這個key對應的值,如果沒有返回None
d={'x':1,'y':2,'z':3}
v=d.get('xxxx')
print(v) # 結果爲 Noneupdate: 如果有,key對應的值被更改,沒有則添加進去 d={'x':1,'y':2,'z':3} d1={'a':1,'x':1111111} d.update(d1) print(d) 結果爲: {'x': 1111111, 'y': 2, 'z': 3, 'a': 1} fromkeys:造字典的方式 l=['name','age','sex'] d=dict.fromkeys(l,None) print(d) #結果爲:{'name': None, 'age': None, 'sex': None} setdefault:鍵存在，不改動，返回字典中相應的鍵的對應值 如果沒有那麼增加一個key:value,返回新的value info={'name':'egon','age':18,'sex':'male'} res=info.setdefault('name','EGON_NB') print(info) print(res) 結果爲:{'name': 'egon', 'age': 18, 'sex': 'male'} egon info.setdefault('height',1.80) print(info) 結果爲:{'name': 'egon', 'age': 18, 'sex': 'male', 'height': 1.8}
總結: 字典是無序的,是可變的(value可變)
d={'x':1,'y':2}
print(id(d))
d['x']=1111
print(id(d))
print(d)
結果:
2374943017576
2374943017576
{'x': 1111, 'y': 2}布爾bool
1 作用: 用於判斷的條件
print(10 > 2 and 3 > 14)
print(type(True))2 如何定義:True , Flase
所有的數據類型的值本身就是一種布爾值,即所有的數據類型都可以當作條件去用.
在如此多的數據類型中只需要記住：0，None，空，它們三類的布爾值爲False
print(bool(0))
print(bool(None))
print(bool(''))
print(bool([]))
print(bool({}))
輸出結果如下:
False
False
False
False
False7 集合類型(set)
- 1 用途: 關係運算.去重
-
2 定義方式:{}內用逗號分隔開多個元素，每一個元素都必須是不可變（即可hash）類型
2.1 集合內元素都必須是不可變（即可hash）類型
2.2 集合內的元素無序
2.3 集合內的元素不能重複
s={1,2,'a'} #s=set({1,2,'a'})
print(type(s)) #結果:<class 'set'> -
3 常用操作+內置的方法
1、長度len
pythoners={'王大炮','李二丫','陳獨秀','艾裏克斯','wxx','歐德博愛'}
print(len(pythoners))
結果:6
2、成員運算in和not in
print('李二丫' in pythoners) 結果:True3、|並集
pythoners={'王大炮','李二丫','陳獨秀','艾裏克斯','wxx','歐德博愛'}
linuxers={'陳獨秀','wxx','egon','張全蛋'}
print(pythoners | linuxers)
print(pythoners.union(linuxers))4、&交集 相交的值
print(pythoners & linuxers)
print(pythoners.intersection(linuxers))
print(linuxers & pythoners)
5、-差集
print(pythoners - linuxers)
print(pythoners.difference(linuxers))
print(linuxers - pythoners)
print(linuxers.difference(pythoners)) #不重合的值
6、^對稱差集
print(pythoners ^ linuxers)
print(pythoners.symmetric_difference(linuxers)) #去掉重合的，打印不重合的
print(linuxers ^ pythoners)
7、==
s1={1,2,3}
s2={1,2,3}
print(s1 == s2)
8、父集(包含關係)：>,>=
s1={1,2,3,4,5}
s2={1,2,3}
print(s1 > s2) # s1包含s2
print(s1.issuperset(s2))#s1是不是包含有s2的值
print(s2.issubset(s1))#s2是不是s1的子集
9 刪除
s1={1,2,3,4,5}
s1.pop() # 從最後一個開始刪除s1.remove(7) # 如果沒有就會報錯
s1.discard(7) # 即便要刪除的元素不存在也不會報錯10 添加
s1={1,2,3,4,5}
s1.add(6)
print(s1) 結果: {1, 2, 3, 4, 5, 6}s1.update({4,7,8,9}) #去掉重複的，把不重複的加進去 print(s1) 結果:{1, 2, 3, 4, 5, 6, 7, 8, 9}總結: 集合是可變類型,無序
s={1,2,3} print(id(s)) s.add(4) print(s) print(id(s)) 輸出結果: 1361694401928 {1, 2, 3, 4} 13616944019288 元組類型(tuple)
- 1元組是不可變的列表，能存多個值，但多個值只有取的需求，
而沒有改的需求，那麼用元組合最合理 - 2 定義方式:在()內用逗號分割開，可以存放任意類型的值
強調: 當元組內只有一個 元素時，務必記住加一個逗號
x=('egon',)
print(type(x)) -
3 常用操作+內置的方法
1、按索引取值(正向取+反向取)：只能取
names=('alex','egon','wxx')
print(names[1]) # 正向取從 0 開始
print(names[-1]) #反向取從 -1 開始egon wxx2、切片(顧頭不顧尾，步長)
names=('alex','egon','wxx','lxx','cxxx')
print(names[1:3])('egon', 'wxx')3、長度
names=('alex','egon','wxx','lxx','cxxx')
print(len(names))54、成員運算in和not in
names=('alex','egon','wxx','lxx','cxxx')
print('alex' in names)
print('alex' not in names)True False5、循環
names=('alex','egon','wxx','lxx','cxxx')
for item in names:
print(item)alex egon wxx lxx cxxx
總結: 元組是有序的,不可變
列表可變的底層原理：
指的是索引所對應的值的內存地址是可以改變的
元組不可變的底層原理：
指的是索引所對應的值的內存地址是不可以改變的
或者反過來說，只要索引對應值的內存地址沒有改變，那麼元組始終是沒有改變的
t1=(['a','b','c'],'wc','office')
print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))
t1[0][0]='AAAA'
print(t1)
print(id(t1[0]))
輸出結果如下:
1176907637384
1176911564616
1176911564672
(['AAAA', 'b', 'c'], 'wc', 'office')
1176907637384-
隊列：先進先出
l=[]
入隊
l.append('王苗魯')
l.append('王成龍')
l.append('大腦門')
出隊
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))王苗魯 王成龍 大腦門 -
堆棧：先進後出
l=[]入棧 l.append('王苗魯') l.append('王成龍') l.append('大腦門') 出棧 print(l.pop()) print(l.pop()) print(l.pop()) 大腦門 王成龍 王苗魯總結:可變類型有: 列表,集合,字典,
不可變有: 字符串,整型,元組