一、引
数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换.
定义变量会申请内存空间，把值放进去，
可变类型:值改变了,id不变，证明就是在改变原值，原值是可变类型
不可变类型:值改变了,id也跟着变,证明就是在产生了新的值，原值是不可变类 型
那些不可分割的整体：字符串，浮点型，整型
3.介绍方法
（一）基本使用
1.用途
2.定义方式+数据类型转换
3.常用操作和内置方法（变量值即所存数据，变量值分各种类型，是程序的基石，对数据的处理是你程序的根基，python解释器将常用的功能写好了，这就是内置方法）
（二)该类型总结
1.存一个值or多个值
2.有序or无序（有无索引）
3.可变or不可变
二、 数字类型int与float
#========int基本使用==========
#1.用途
记录整数相关的，有年纪，等级，身份证号等数字相关的
#2.定义方式
age = 18 # age = int(18) #申请内存空间，把18造好放进去
注意：名字+括号的意思就是调用某个功能
#2.1 数据类型转换
#res=int(" 18 ") #int这家生产整型的加工厂所用的原材料可以是阿拉伯数字或中间无空格的纯阿拉伯数字组成的字符串
#print(res,type(res))
#int("aadfsadf")
#int("10") + 11
#"10" + 11
补充知识点
python一种解释型、强类型（数据类型间有强列边界不能混用，不会发生隐式转换）、动态类型（数据类型只有运行到这行代码那一刻才开始识别；数据类型在编译前已确定属于静态）
#3.常用操作+内置的方法（无）
#算术运算、比较运算
#print(10 + 3.3) #整型和浮点型之间可以混用，其余都不行
#print(10 > 3.3)
#==该类型总结==
1.存一个值（age只能等与一个数）
2.不可变
#=========float基本===========
#1、用途
记录与小数相关的薪资，身高，体重等
#2、定义方式
#sal = 18.3 # sal = float(18.3)#float这家生产浮点型的加工厂所用的原材料中间无空格的小数组成的字符串
#print(type(sal))
#2.1 数据类型转换
#int("3.3")
#res=float("3.3")
#print(res,type(res))
#3、常用操作+内置的方法
#算术运算、比较运算
#print(10 + 3.3)
#print(10 > 3.3)
#==该类型总结==
#存一个值
#不可变
#x=3.1
#print(id(x))
#x=3.2
#print(id(x))
#了解（）
#复数
#x = 1-2j
#print(x.real)
#print(x.imag)
#print(type(x))
print(bin(11))
print(oct(11))
print(hex(11))
#=============str基本使用==============
#1、用途：用于记录描述性质的状态比如名字，记录的一段话
#2、定义方式：在"",‘‘,""" """,‘‘‘ ‘‘‘内包含一串字符（人类的文字符号都算字符）
#msg = "18" （存的是1和8，别当18看） # msg=str("18")
#print(type(msg))
#数据类型转换:str这家生产字符串型的加工厂所用的原材料是任意类型
#print(res,type(res))
#3、常用操作+内置的方法
#优先掌握的操作：
字符串需要掌握的操作
字符串是不可分割的整体，要拿只能拿一串，因此字符串类型只能取不能改
#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#print(msg[0]) #这只是访问值
#print(msg[-1])
#print(msg) #原值未变
#msg[0] = "H"
2、切片(顾头不顾尾，步长)
msg = "hello world"
#print(msg[0:5])
#print(msg[0:5:2]) # 0 2 4
#print(msg)
#print(msg[:]) # 完整拷贝字符串
#print(msg[-1:-4:-1])
#print(msg[-1::-1])
#print(msg[::-1]) # 将字符串倒过来
#3、长度len（包含字符的个数）
#msg = "h 你"
#print(len(msg))
#4、成员运算in和not in
#msg = "hello world"
#print("wo" in msg)
#print(not "wx" in msg)
#print("wx" not in msg)#推荐
#5、移除空白strip
#msg = " hello "
#print(msg)
#res=msg.strip()
#print(res)
#print(msg)
#msg = "hello"
#msg = "+-/?h-ello?-&^"
#print(msg.strip("^&+-/?"))
#inp_user = input("username: ").strip() #inp_user = "egon "
#inp_pwd = input("password: ").strip()
#if inp_user == "egon" and inp_pwd == "123":
#print(‘ok‘)
#else:
#print(‘no‘)
#6、切分split（针对有规律的字符串）
msg = "egon:18:male"
#res = msg.split(":")
#print(res[0])
#print(res)
#res = msg.split(":",1)
#print(res)
#info = ["egon",18,"male"]
#res1 = "%s:%s:%s" %(info[0],info[1],info[2]) #万能拼接
#res1 = ":".join(info) #本质是加到一起了
#print(res1)
#7、循环
msg = "egon:18:male"
for x in msg:
print(x) #字符串是不可分割的整体，取的是当中字符
1、strip(剥去外皮),lstrip,rstrip
msg="douniwan"
print(msg.strip(""))
print(msg.lstrip(""))
print(msg.rstrip(""))
#2、lower,uper #全小写，全大写
msg="douniwan"
print(msg.lower())
print(msg.upper())
#3、startswith,endwith
print(msg.startswith("douni"))
print(msg.endswith("wan"))
#4、format(格式)的三种玩法
#print("my name is %s and my age is %s"%("lu",18))
print("mc".format(y=49,x="lu")) #指名道姓
print("my name is {} and my age is {}".format(49,"lu"))
print("my name is my age is {0}{0}{1}{0}".format(49,"lu"))
x=11
y=22
print(f"my name is {} and my age is {}")
5.split,rsplit # split会按照从左到右的顺序对字符串进行切分，可以指定切割次数，默认按空格切
ddo=(‘23i/444/8/5‘)
print(ddo.split(‘/‘,1))
print(ddo.rsplit(‘/‘,1))
6.join 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
7.replace 用新的字符替换字符串中旧的字符
ddo=("good afternoon holmes")
ddo=ddo.replace("afternoon","morning",2)
print(ddo)
print(ddo.replace("afternoon","morning",2))
8.isdigit 判断字符串是否是纯数字组成，返回结果为True或False
num1=‘b12‘
num2=‘23‘
num3=‘四‘
num4=‘IV‘
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
print(name.isalpha()) #字符串只由字母组成
print(name.isalnum()) #字符串由字母或数字组成
print(name.islower()) #字符串由纯小写字母组成
print(name.isuper()) #字符串由纯大写字母或数字组成
#需要了解的方法
#1、find,rfind,index,rindex,count
#msg = "hello egon xxx egon yyy egon zzz"
#print(msg.find("egon",0,7)) #找起使索引
#print(msg.index("egon"))
#print(msg.rfind("egon")) #找起使索引
#print(msg.rindex("egon"))
#print(msg.find("abcde")) #找不到出-1
#print(msg.index("abcde")) #找不到报错
#print(msg.count("egon")) #统计子字符串在大字符串中出现的次数
#2、center,ljust,rjust,zfill
#print(‘egon‘.center(50,‘‘)) #左右共计50个字符，egon居中显示，其余填满
#print(‘egon‘.ljust(50,‘‘))
#print(‘egon‘.rjust(50,‘*‘))
#print(‘egon‘.zfill(50)) #左右共计50个字符，egon居右显示，其余0填满
#print(‘egon‘.rjust(50,"0"))
#3、captalize,swapcase,title
msg = "hellO woRld"
#print(msg.capitalize()) #首字母大写
#print(msg.swapcase()) #大小写互换
#print(msg.title()) #首字母大写其余小写
#4、is数字系列
num1=b‘4‘ #bytes，字节串
num2=‘4‘ # 阿拉伯数字
num3=‘四‘ #中文数字
num4=‘Ⅳ‘ #罗马数字
#1、变量值是字节串或字符串类型并且包含的阿拉伯数字，isdigit()结果才为真
#print(num1.isdigit())
#print(num2.isdigit())
#print(num3.isdigit())
#print(num4.isdigit())
#2、变量值是字符串类型并且包含的阿拉伯数字，isdecimal()结果才为真
#print(num2.isdecimal())
#print(num3.isdecimal())
#print(num4.isdecimal())
#3、变量值是字符串类型并且包含的阿拉伯数字\中文数字\罗马数字，isnumeric结果才为真
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
#5、is其他
#name=‘egon123‘
#print(name.isalnum()) #字符串由字母或数字组成
#print(name.isalpha()) #字符串只由字母组成
#print(name.islower()) #字符串内所有字母均小写
#print(name.isupper())#字符串内所有字母均大写
#name=" "
#print(name.isspace()) #字符串内均是空格组成
#name ="Hello World"
#print(name.istitle()) #字符串内所有单词均首字母大写，其余小写
#=========该类型总结=======
#存一个值
#有序(可以进行索引操作)
#不可变
#=============list基本使用==============
1.用途：按位置存放多个值
2.定义：在[ ]内,用逗号分隔开多个任意数据类型的元素
l = [11,3.3,"xx",[1111,2222]] # l = list(。。。)
#print(type(l))
list数据类型转换: 所有可以被for循环遍历的类型都可以传给list然后转换成列表
3.常用操作及内置方法
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
#list1 = [111,222,333,444,555]
#print(list1[0])
#print(list1[-1])
#print(id(list1))
#list1[0] = 666
#print(id(list1))
#list1[5] = 777 # 不可以用不存在的索引赋值
#2、切片(顾头不顾尾，步长)
#list1 = [111,222,333,444,555]
#print(list1[0:3])
#print(list1)
#l=list1[:] # 浅拷贝
#print(l)
#print(list1[::-1])
#3、长度
#list1 = [111,222,333,444,555]
#print(len(list1))
#4、成员运算in和not in
#list1 = [111,222,333,444,555]
#print(222 in list1)
#5、追加
#list1 = [111,222,333,444,555]
#list1.append(666)
#x = list1.append(777)
#print(list1)
#print(x) #没有返回值，可通过赋值变量打印看是否有结果判断
#list1.insert(2,666)
#print(list1)
#6、删除
#list1 = [111,222,333,444,555]
#(1) 单纯的删除-》没有返回值
#del list1[0]
#print(list1)
#res=list1.remove(333)
#print(list1)
#print(res) # None
#（2）取走-》有返回值
#res=list1.pop(1)
#print(list1)
#print(res)
#7、循环
#list1 = [111,222,333,444,555]
#for x in list1:
#print(x)
#========需要掌握的操作
#list1 = [111,222,333,333,333,444,555]
#print(list1.count(333))
#list1= [99,33,22,11,-3,87]
#list1.reverse()
#print(list1)
#list1 = [111,222,333,333,333,444,555]
#list1.clear()
#list1.append([666,777,888])
#for x in [666,777,888]:
#list1.append(x)
#list1.extend([666,777,888])
#print(list1)
#浅copy
#list1.copy()
#list1[:]
#list1 = [111,222,777,888,999,333,333,333,444,555]
#res=list1.index(333,0,3)
#print(res)
#list1 = [111,222,777,888,999,333,333,333,444,555]
#list1.sort(reverse=True)
#print(list1)
queue = []
queue.append(‘one‘)
queue.append(‘two‘)
queue.append(‘three‘)
print(queue)
print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))
#=========================该类型总结===========================
#存多个值
#有序
#可变
#========tuple基本使用===========（不可变的列表）
#1用途：按位置存放多个值只有读的需求没有改的需求用元祖最合适占用内存小
每申请一个数据类型都要存到内存里，列表既要维护读行为又要维护改行为而元祖只要维护读行为更精简。
#2定义方式：在( )内用逗号分隔开多个任意类型的元素；（）有包含意思
元祖中只有一个元素要加逗号
#x = (10,) # x= tuple(...)
#print(x,type(x))
#tuple数据类型转换：任意能够被for循环遍历的类型都可以交给tuple转成元组
#print(tuple("hello"))
#3、常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#t = (111,222,333,[44,555])
#print(t[0])
#t[0]=6666
#2、切片(顾头不顾尾，步长)
#t = (111,222,333,[44,555])
#print(t[0:3])
#3、长度
#t = (111,222,333,[44,555])
#print(len(t))
#4、成员运算in和not in
#t = (111,222,333,[44,555])
#print([44,555] in t)
#5、循环
#t = (111,222,333,[44,555])
#for x in t:
#print(x)
#需要掌握的操作：
#t = (111,222,333,[44,555])
#t.index()
#t.count()
#============该类型总结=============================
#存多个值
#有序
#不可变
t = (111,222,333,[44,555])
#t[0] = 666 #列表里不存值，存的是索引和内存地址的绑定关系
#t[-1]=666
print(id(t[0]),id(t[1]),id(t[2]),id(t[3]))
t[-1][0]=6666
print(id(t[0]),id(t[1]),id(t[2]),id(t[3]))
print(t)
l1 = [111,222,333]
l1[0] = 666
#====dict基本使用================
#1、用途：按key=value存放多个值
#2、定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的格式，其中value可以是任意类型
#而key必须是不可变类型，通常是str类型，而且key不能重复
#dic = {111:6666,"k1":777,(1,2,3):8888,[1,2,3]:3333} # dic = dict(...)
#print(dic)
#print(dic[(1,2,3)]) #原材料取出的元素必须有两部分，每次遍历出来要有两个值
#dict数据类型转换
#info = [(‘k1‘,111),(‘k2‘,222),(‘k3‘,3333)]
#dic=dict(info)
#print(dic)
#print(dict(x=1,y=2,z=3))
#3、常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
#dic = {"name":"egon","age":18}
#dic[‘gender‘] = "male" #字典可以根据一个不存在的key做赋值操作
#dic[‘name‘] = "xxxx"
#print(dic)
#2、长度len
#dic = {"name":"egon","age":18}
#print(len(dic))
#3、成员运算in和not in: 以key为准
#dic = {"name":"egon","age":18}
#print(‘name‘ in dic)
#4、删除
dic = {"name": "egon", "age": 18}
#单纯的删除
#del dic[‘name‘]
#print(dic)
#取走
#v=dic.pop("name") # 返回的是你删除对应的value值
#print(v)
#v = dic.popitem() #返回的是你删除对应的key value
#print(v)
#5、键keys()，值values()，键值对items()
dic = {"name": "egon", "age": 18}
#>>> dic.keys()
#[‘age‘, ‘name‘]
#>>> dic.values()
#[18, ‘egon‘]
#>>>
#>>> dic.items()
#[(‘age‘, 18), (‘name‘, ‘egon‘)]
#>>>
#6、循环
#for k in dic.keys():
#print(k)
#for k in dic:
#print(k)
#for v in dic.values():
#print(v)
#for k,v in dic.items():
#print(k,v)
#8、get()
#dic = {"name": "egon", "age": 18} #不确定key的情况下取value，如果没有这个key不会报错；主要发生在用框架的时候
#print(dic[‘namexxxx‘])
#print(dic.get("namexxxx"))
#需要掌握的操作
#dic = {"name": "egon", "age": 18}
#dic.update({‘gender‘:"male","age":19}) #update 更新
#print(dic)
#dic = {}.fromkeys(["name","age","gender"],[ ]) #快速初始化一个字典，往里面填值
#print(dic)
#dic[‘name‘].append(1111)
#print(dic)
#dic = {}.fromkeys(["name","age","gender"],None)
#dic = {"age": 18}
#if "name" not in dic:
#dic[‘name‘] = "xxx"
#v = dic.setdefault(‘name‘,"xxx")
#print(dic)
#print(v)
#=================该类型总结====================================
#存多个值
#无序
#可变 #key是不可变，本身可变
#dic = {‘k1‘:1111}
#print(id(dic))
#dic[‘k1‘]=666
基本数据类型
原文：https://blog.51cto.com/15129993/2665905
