数据类型
简介:变量值是用来保存现实世界中的状态的，那么针对不同的状态就应该用不同类型的数据去表示
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()) 大脑门 王成龙 王苗鲁总结:可变类型有: 列表,集合,字典,
不可变有: 字符串,整型,元组