python基础（三）python数据类型

时间 2019-12-14

标签 python 基础数据类型栏目 Python 繁體版

原文原文链接

1、数据类型python

计算机顾名思义就是能够作数学计算的机器，所以，计算机程序理所固然地能够处理各类数值。可是，计算机能处理的远不止数值，还能够处理文本、图形、音频、视频、网页等各类各样的数据，不一样的数据，须要定义不一样的数据类型。mysql

2、整形和浮点型git

整形也就是整数类型(int)的，在python3中都是int类型，没有什么long类型的，好比说存年龄、工资、成绩等等这样的数据就能够用int类型，有正整数、负整数和0，浮点型的也就是小数类型(folat)的，带小数点的sql

age = 18
b = -50
c = 5.222

3、布尔类型数据库

什么是布尔类型，布尔类型就是真和假，只有这两种，True和Fasle，非真即假，除了True和False还有0和1，非0即真api

a = True
b = False

4、字符串和字符串操做数组

上面说了存数字，那要是想存本身的名字呢，那用int类型的就不行了，就有另外一种数据类型应运而生，就是字符串，它能够存任意类型的字符串，好比名字，一句话等等。oracle

name = 'Sriba'
msg = 'Welcome to my blog.'

字符串还有不少内置的方法，对字符串进行操做，经常使用的方法以下，下面注释带有是否的，返回的都是一个布尔值：app

name = 'my \t name is {name},age is {age}.'
print(name.capitalize())#首字母大写，不会改变字符串原值
print(name.casefold())#首字母小写
print(name.center(50,'-'))#50个-，把name放中间
print(name.startwith('m'))#是否以xx开头
print(name.endswith('u'))#是否以x结尾
print(name.expandtabs(30))#补\t的次数
print(name.find('n'))#查找字符串的索引
print(name.format(name='niuniu',age=18))#这个是格式字符串
print(name.format_map({'name':'niuniu','age':19}))#这个也是格式化字符串，后面跟的是一个字典，字典在后面也会写
print('abA123'.isalnum())#是否包含数字和字母
print('abA'.isalpha())#是不是英文字母
print(name.count('n'))#统计某个字符串出现的次数
print(name.index('n'))#返回某个元素第一次出现的下标
by_name = name.encode()#utf8编码转化为二进制
by_name.decode()#bytes转换字符串

print('122'.isdigit())#是不是数字
print('aa'.isidentifier())#是不是一个合法的变量名
print('aa'.islower())#是不是小写字母
print('AA'.isupper())#是不是大写字母
print(''.isspace())#是不是空格
print('Loadrunner Book'.istitle())#是否是一个标题，判断首字母是否大写
print('+'.join(['hehe','haha','ee']))#拼接字符串
print(name.lower())#变成小写
print(name.upper())#变成大写
print('\nmysql \n'.lstrip())#默认去掉左边的空格和换行
print('\nmysql \n'.rstrip())#默认去掉右边的空格和换行
print('\nmysql \n'.strip())#默认去掉两边边的空格和换行
p = str.maketrans('abcdefg','1234567')#前面的字符串和后面的字符串作映射
print('cc ae gg'.translate(p))#输出按照上面maketrans作映射后的字符串
print(type(name))#获取变量类型
print(num.isinstance(num,str))#判断变量类型

#下面是反解
new_p = str.maketrans('1234567','abcdefg')
print('cc ae gg'.translate(new_p))
print('mysql is db.'.replace('mysql','oracle',1))#替换字符串
print('mysql is is db'.rfind('is'))#返回最右边字符的下标
print('1+2+3+4'.split('+'))#按照xx切割字符串，返回一个list
print('1+2+3\n1+2+3+4'.splitlines())#按照换行符分割，返回一个list
print('Abcdef'.swapcase())#大小写互相转换

5、列表和列表操做ide

上面说了字符串和整形，那如今要是想存一个班级的人的名字，这个班有200我的，怎么存呢，用字符串的话，那就是names = 'marry lily king .....'这样，可是这样存是能够存，那要是想取到某我的的名字怎么取呢，为了解决这个问题，又有一种新的数据类型应运而生，那就是列表，这也是咱们在之后的开发过程当中，最经常使用的数据类型之一，列表也叫数组，列表定义，使用[]便可；列表里面能够再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，这个叫三维数组，套几层就是几维，定义格式以下：

list1 = [1,2,3,4] #一个普通的数组
list2 = ['marry','lily',[50,'monkey']] #二维数组
list3 = ['name','sex',['lily',124,['aaaa','bbb']]] #三维数组

经过下标访问列表中的元素，下标从0开始计数，也就是说，好比说一个列表，有个5元素，那么它第一个元素下标就是0，第二个就是1，以此类推，字符串也有下标，和列表同样

对列表的操做，分如下几种增、删、改、查

增：

msg = '你好'
name = ['andashu','cc','niuniu']
name.append(msg)#从最后面开始插入
name.insert(1,msg) #从指定位置插入，这个1表明下标
print(name)

改：

msg = '你好'
name = ['andashu','cc','niuniu']
name[1] = 'baby' #修改指定位置的值

查：

msg = '你好'
name = ['andashu','cc','niuniu']
print(name[0])#获取第一个元素
print(name[-1])#-1表明最后一个元素

删：

msg = '你好'
name = ['andashu','cc','niuniu']
name.remove('baby')#删除指定的值
del name[0]#删除指定位置的值
name.pop()#不传入下标的话，删除最后一个值，传入下标删除指定位置的值
name.clear()#清空列表

列表操做，一些内置的方法：

msg = '你好'
name = ['andashu','cc','niuniu']
name2 = [1,2,3,4,['hehe','haha']]
print(name.index('cc'))#取索引
print(name.count('cc'))#取cc出现的次数
name.clear()#清空列表
print(name.sort())#排序，根据阿斯克码来排序
name.extend(name2)#扩展列表，也就是把name2的值加到name里面
name.reverse()#反转数组，会改变原数组的值

切片，切片也就是另外一种方式获取列表的值，它能够获取多个元素，能够理解为，从第几个元素开始，到第几个元素结束，获取他们之间的值，格式是name[1:10]，好比说要获取name的第一个元素到第五个元素，就能够用name[0:6]，切片是不包含后面那个元素的值的，记住顾头不顾尾；前面的下标若是是0的话，能够省略不写，这样写，name[:6]，切片后面还有能够写一个参数，叫作步长，也就是隔多少个元素，取一次，默承认以不写，也就是隔一个取一次，切片操做也能够对字符串使用，和列表的用法同样，实例以下：

names = ['andashu','cc','niuniu','amy','lily']
names[1:4] #取下标1至下标4之间值，包括1，不包括4
names[1:-1] #取下标1至-1的值，不包括-1
names[0:3] #取下标0至3的值，不包括3
names[:3] #取下标0至3的值，不包括3,和上面的效果同样，0能够省略不写
names[2:]#取从第二个下标开始的后面全部元素
#下面是加上步长的
nums = [1,2,3,4,5,6,7,8,9,10]
nums[::2]#这个表明取全部的元素，而后每隔2个元素取一个
>>> 1 3 5 7 9 #输出的结果
nums[1:8:3]#表明取第二个元素开始，到第八个结束，隔3个取一次
>>>[2,5] #输出结果

6、元组

元组其实和列表同样，不同的是，元组的值不能改变，一旦建立，就不能再改变了，好比说，要存数据库的链接信息，这个链接信息在程序运行中是不能被改变的，若是变了那数据库连不上了，这样的就可使用元组了，元组的定义方式是用()，小括号；元组只有两个方法，那就是count和index

mysql_coon = ('192.168.1.109','root','123456',3306,'my_db')#定义元组

7、字典

上面说了，整形、浮点型、字符串、列表和元组，下面说个新的数据类型，字典，字典也是咱们开发过程当中最经常使用的一种数据类型；想一个问题，如今要存整个北京市的全部人的信息，每一个人有姓名、年龄、性别、家庭住址、学历等等，那要是用列表存的话，那就得定义N多个数组，而后存上每一个人的信息，这时候又有一种新的数据类型出现了，那就是字典，dict，全称是dictionary，它具备极快的查找速度；字典是一种key-value的数据类型，好比说要存每一个人的信息，那么每一个人的编号就是key，value就是每一个人的信息，这样的话，一个字典就能存全部人的信息了。字典的定义使用{}，大括号，每一个值用“，”隔开，key和value使用“：”分隔。

举个列子，若是用列表存每一个人的信息的话，须要用两个列表，一个存人名，一个存信息：

names = ['marry','amy','lily']
infos = [[18,18612512981,'北京'],[20,18612512991,'山东'],[25,18612532981,'河南']]

给一个名字，若是要查他的对应信息，那就要先从names里面找到它的位置，而后再从infos中找到它的信息，若是这个列表越长，那么它的查询速度越慢。

若是用字典实现的话，只须要一个名字和信息对应的一个表，这样就很快的根据名字找到它对应的信息，不管这个表有多大，查找速度都不会变慢。

infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos['marry'] #取marry的信息

为何dict查找速度这么快？由于dict的实现原理和查字典是同样的。假设字典包含了1万个汉字，咱们要查某一个字，一个办法是把字典从第一页日后翻，直到找到咱们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（好比部首表）查这个字对应的页码，而后直接翻到该页，找到这个字。不管找哪一个字，这种查找速度都很是快，不会随着字典大小的增长而变慢，这种就是字典的实现方式。

字典的特性：

字典是无序的，由于它没有下标，用key来当索引，因此是无序的

字典的key必须是惟一的，由于它是经过key来进行索引的，因此key不能重复，天生就去重

字典的增删改查：

增：

infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos['andy']=[22,18712512981,'河北']#增长

修改：

infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos['marry':[38,18612512981,'北京']]

删除：

infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos.pop('marry')#标准的删除方法
del infos['marry']#使用del方法删除
info.popitem() #随机删除一个值

查询：

infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos.get('maryy')#获取marry的信息，这种方式若是key不存在的话，会返回None
infos['marry']#获取marry的信息，这种方式若是key不存在的话，会报错
'marry' in infos #判断marry是否在这个字典中，返回True或者False

字典的内置方法：

dic = {'stu1':'cc','stu2':'andashu','stu3':'niuniu'}
print(dic.values())#打印全部value
print(dic.keys())#打印全部的key
print(dic.setdefault('stu1','fengluo'))#若是这个key存在的话，那就不动它，不存在的话，添加一个
dic2 = {'stu1':'sriba','stu10':'baidu'}
dic.update(dic2)#更新字典值，若是key存在的话，就更新，不存在的话就添加
print(dic.items())#字典转换成一个list

循环字典：

dic = {'stu1':'cc','stu2':'andashu','stu3':'niuniu'}
for k in dic:
print(k,dic[k])#打印key和value的值，推荐使用这种方式，速度快
for k,v in dic.items():
print(k,v)#打印key和value的值，这种方式不推荐，由于会把字典转换成列表，效率不高

8、数据运算

算数运算符

操做符	描述	例子
+	加法 - 对操做符的两侧增长值	a + b = 30
-	减法 - 减去从左侧操做数右侧操做数	a - b = -10
*	乘法 - 相乘的运算符两侧的值	a * b = 200
/	除 - 由右侧操做数除以左侧操做数	b / a = 2
%	模 - 由右侧操做数和余返回除以左侧操做数	b % a = 0
**	指数- 执行对操做指数（幂）的计算	a**b = 10 的幂 20
//	地板除 - 操做数的除法，其中结果是将小数点后的位数被除去的商	9//2 = 4 而 9.0//2.0 = 4.0

比较运算符

运算符	描述	实例
==	检查两个操做数的值是否相等，若是是则条件变为真	(a == b) 为false
!=	检查两个操做数的值是否相等，若是值不相等，则条件变为真	a != b) 为 true.
>	检查左操做数的值是否大于右操做数的值，若是是，则条件成立	(a > b) 不为 true.
<	检查左操做数的值是否小于右操做数的值，若是是，则条件成立	(a < b) 为 true.
>=	检查左操做数的值是否大于或等于右操做数的值，若是是，则条件成立	(a >= b) 不为 true.
<=	检查左操做数的值是否小于或等于右操做数的值，若是是，则条件成立	(a <= b) 为 true.

Python赋值运算符

运算符	描述	示例
=	简单的赋值运算符，赋值从右侧操做数左侧操做数	c = a + b将指定的值 a + b 到 c
+=	加法AND赋值操做符，它增长了右操做数左操做数和结果赋给左操做数	c += a 至关于 c = c + a
-=	减AND赋值操做符，它减去右边的操做数从左边操做数，并将结果赋给左操做数	c -= a 至关于 c = c - a
*=	乘法AND赋值操做符，它乘以右边的操做数与左操做数，并将结果赋给左操做数	c = a 至关于 c = c a
/=	除法AND赋值操做符，它把左操做数与正确的操做数，并将结果赋给左操做数	c /= a 至关于c = c / a
%=	模量AND赋值操做符，它须要使用两个操做数的模量和分配结果左操做数	c %= a 至关于 c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操做符和赋值给左操做数	c = a 至关于 c = c a
//=	地板除，并分配一个值，执行地板除对操做和赋值给左操做数	c //= a 至关于 c = c // a

逻辑运算符

运算符	描述	示例
and	所谓逻辑与运算符。若是两个操做数都是真的，那么则条件成立。	(a and b) 为 true.
or	所谓逻辑OR运算符。若是有两个操做数都是非零而后再条件变为真。	(a or b) 为 true.
not	所谓逻辑非运算符。用于反转操做数的逻辑状态。若是一个条件为真，则逻辑非运算符将返回false。	not(a and b) 为 false.

身份运算符

运算符	描述	示例
is	is判断两个标识符是否引用自一个对象	x is y,若是id(x)等于id(y) ，返回True
is not	is not判断两个标识符是否引用不一样的对象	x is not y,若是id(x)不等于id(y)，返回True

9、模块初识

模块是导入别人已经写好的python文件，里面已经有一些写好的功能，能够直接拿来使用，使用import 关键字导入须要的模块，导入模块时，默认会在当前目录下去寻找该文件，若是当前目录下没有的话，回去python的环境变量中找，若是找不到就报错，下面有一些简单的python标准模块，os和sys模块：

import sys,os #导入sys模块和os模块
arg = sys.argv #获取传入的参数，第一个参数是文件名，返回的是一个list
sys.path #python的环境变量，返回的也是一个list
os模块是和操做系统相关的命令
os.system('ls')#执行操做系统命令，返回的是一个执行结果，成功或者失败，成功返回0
os.popen('ls') #这个也是执行操做系统的命令，和system区别就是，这个命令返回的是执行结果，也就是返回了什么东西，而不是返回的执行成功或者失败，读取内容需用read方法
os.popen('ls').read()
os.mkdir('test')#建立文件夹
os.path.sep#路径分隔符，根据不一样的操做系统，分割符会变化

10、三元运算符

三元运算符就是在赋值变量的时候，能够直接给它加上判断，而后赋值

    res = 值1 if 条件 else 值2
    a = 5
    b = 4
    c = a if a>b else b #若是a大于b的话，c=a，不然c = b ，若是不用三元运算符的话，就得下面这么写
    if a>b:
        c = a
    else:
        c = b

固然三元运算符也能够用在列表和字典中，这么写的话，就比较简单了，不过若是搞不明白三元运算符的话，仍是不用为好

    nums = [1,2,3,4,5,6,7,8,9,10]
    odd_num = [num for num in nums if num%2!=0]#循环nums，若是nums里面的值，不能被2整除的话，就写到odd_num这个list中，也就是算奇数，等于下面这么写
    odd_num = []
    for num in nums:
        if num % 2 !=0:
            odd_num.append(num)